xref: /src/sys/arch/cobalt/cobalt/interrupt.c

/*	$NetBSD: interrupt.c,v 1.11 2020/11/21 15:26:53 thorpej Exp $	*/

/*-
 * Copyright (c) 2006 Izumi Tsutsui.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/*-
 * Copyright (c) 2001 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Jason R. Thorpe.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

/*
 * Copyright (c) 2000 Soren S. Jorvang.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions, and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: interrupt.c,v 1.11 2020/11/21 15:26:53 thorpej Exp $");

#define __INTR_PRIVATE

#include <sys/param.h>
#include <sys/kmem.h>
#include <sys/cpu.h>
#include <sys/intr.h>

#include <mips/mips3_clock.h>
#include <sys/bus.h>

#include <dev/ic/i8259reg.h>
#include <dev/isa/isareg.h>

#include <cobalt/dev/gtreg.h>

#define ICU_LEVEL	4
#define IRQ_SLAVE	2

#define IO_ELCR		0x4d0
#define IO_ELCRSIZE	2
#define ELCR0		0
#define ELCR1		1

#define ICU1_READ(reg)		\
    bus_space_read_1(icu_bst, icu1_bsh, (reg))
#define ICU1_WRITE(reg, val)	\
    bus_space_write_1(icu_bst, icu1_bsh, (reg), (val))
#define ICU2_READ(reg)		\
    bus_space_read_1(icu_bst, icu2_bsh, (reg))
#define ICU2_WRITE(reg, val)	\
    bus_space_write_1(icu_bst, icu2_bsh, (reg), (val))
#define ELCR_READ(reg)		\
    bus_space_read_1(icu_bst, elcr_bsh, (reg))
#define ELCR_WRITE(reg, val)	\
    bus_space_write_1(icu_bst, elcr_bsh, (reg), (val))

static u_int icu_imask, icu_elcr;
static bus_space_tag_t icu_bst;
static bus_space_handle_t icu1_bsh, icu2_bsh, elcr_bsh;

struct icu_intrhead {
	LIST_HEAD(, cobalt_intrhand) intr_q;
	int intr_type;
	struct evcnt intr_evcnt;
	char intr_evname[32];
};
static struct icu_intrhead icu_intrtab[NICU_INT];

struct cpu_intrhead {
	struct cobalt_intrhand intr_ih;
	struct evcnt intr_evcnt;
	char intr_evname[32];
};
static struct cpu_intrhead cpu_intrtab[NCPU_INT];

static int	icu_intr(void *);
static void	icu_set(void);

static const struct ipl_sr_map cobalt_ipl_sr_map = {
    .sr_bits = {
	[IPL_NONE] =		MIPS_INT_MASK_0,
	[IPL_SOFTCLOCK] =	MIPS_SOFT_INT_MASK_0 | MIPS_INT_MASK_0,
	[IPL_SOFTBIO] =		MIPS_SOFT_INT_MASK_0 | MIPS_INT_MASK_0,
	[IPL_SOFTNET] =		MIPS_SOFT_INT_MASK | MIPS_INT_MASK_0,
	[IPL_SOFTSERIAL] =	MIPS_SOFT_INT_MASK | MIPS_INT_MASK_0,
	[IPL_VM] =		MIPS_INT_MASK ^ MIPS_INT_MASK_5,
	[IPL_SCHED] =		MIPS_INT_MASK,
	[IPL_DDB] =		MIPS_INT_MASK,
	[IPL_HIGH] =		MIPS_INT_MASK,
    },
};

void
intr_init(void)
{
	int i;

	ipl_sr_map = cobalt_ipl_sr_map;
	/*
	 * Initialize CPU interrupts.
	 */
	for (i = 0; i < NCPU_INT; i++) {
		snprintf(cpu_intrtab[i].intr_evname,
		    sizeof(cpu_intrtab[i].intr_evname), "int %d", i);
		evcnt_attach_dynamic(&cpu_intrtab[i].intr_evcnt,
		    EVCNT_TYPE_INTR, NULL, "mips", cpu_intrtab[i].intr_evname);
	}

	extern struct mips_bus_space cobalt_bs;

	/*
	 * Initialize ICU interrupts.
	 */
	icu_bst = &cobalt_bs;
	bus_space_map(icu_bst, PCIB_BASE + IO_ICU1, IO_ICUSIZE, 0, &icu1_bsh);
	bus_space_map(icu_bst, PCIB_BASE + IO_ICU2, IO_ICUSIZE, 0, &icu2_bsh);
	bus_space_map(icu_bst, PCIB_BASE + IO_ELCR, IO_ELCRSIZE, 0, &elcr_bsh);

	/* All interrupts default to "masked off". */
	icu_imask = 0xffff;

	/* All interrupts default to edge-triggered. */
	icu_elcr = 0;

	/* Initialize master PIC */

	/* reset; program device, four bytes */
	ICU1_WRITE(PIC_ICW1, ICW1_SELECT | ICW1_IC4);
	/* starting at this vector index */
	ICU1_WRITE(PIC_ICW2, 0);			/* XXX */
	/* slave on line 2 */
	ICU1_WRITE(PIC_ICW3, ICW3_CASCADE(IRQ_SLAVE));
	/* special fully nested mode, 8086 mode */
	ICU1_WRITE(PIC_ICW4, ICW4_SFNM | ICW4_8086);
	/* mask all interrupts */
	ICU1_WRITE(PIC_OCW1, icu_imask & 0xff);
	/* special mask mode */
	ICU1_WRITE(PIC_OCW3, OCW3_SELECT | OCW3_SSMM | OCW3_SMM);
	/* read IRR by default */
	ICU1_WRITE(PIC_OCW3, OCW3_SELECT | OCW3_RR);

	/* Initialize slave PIC */

	/* reset; program device, four bytes */
	ICU2_WRITE(PIC_ICW1, ICW1_SELECT | ICW1_IC4);
	/* starting at this vector index */
	ICU2_WRITE(PIC_ICW2, 8);			/* XXX */
	/* slave connected to line 2 of master */
	ICU2_WRITE(PIC_ICW3, ICW3_SIC(IRQ_SLAVE));
	/* special fully nested mode, 8086 mode */
	ICU2_WRITE(PIC_ICW4, ICW4_SFNM | ICW4_8086);
	/* mask all interrupts */
	ICU1_WRITE(PIC_OCW1, (icu_imask >> 8) & 0xff);
	/* special mask mode */
	ICU2_WRITE(PIC_OCW3, OCW3_SELECT | OCW3_SSMM | OCW3_SMM);
	/* read IRR by default */
	ICU2_WRITE(PIC_OCW3, OCW3_SELECT | OCW3_RR);

	/* default to edge-triggered */
	ELCR_WRITE(ELCR0, icu_elcr & 0xff);
	ELCR_WRITE(ELCR1, (icu_elcr >> 8) & 0xff);

	wbflush();

	/* Initialize our interrupt table. */
	for (i = 0; i < NICU_INT; i++) {
		LIST_INIT(&icu_intrtab[i].intr_q);
		snprintf(icu_intrtab[i].intr_evname,
		    sizeof(icu_intrtab[i].intr_evname), "irq %d", i);
		evcnt_attach_dynamic(&icu_intrtab[i].intr_evcnt,
		    EVCNT_TYPE_INTR, &cpu_intrtab[ICU_LEVEL].intr_evcnt,
		    "icu", icu_intrtab[i].intr_evname);
		icu_intrtab[i].intr_type = IST_NONE;
	}

	cpu_intr_establish(ICU_LEVEL, IPL_NONE, icu_intr, NULL);
}

void *
icu_intr_establish(int irq, int type, int ipl, int (*func)(void *), void *arg)
{
	struct cobalt_intrhand *ih;
	int s;

	if (irq >= NICU_INT || irq == IRQ_SLAVE || type == IST_NONE)
		panic("%s: bad irq or type", __func__);

	switch (icu_intrtab[irq].intr_type) {
	case IST_NONE:
		icu_intrtab[irq].intr_type = type;
		break;

	case IST_EDGE:
	case IST_LEVEL:
		if (type == icu_intrtab[irq].intr_type)
			break;
		/* FALLTHROUGH */
	case IST_PULSE:
		/*
		 * We can't share interrupts in this case.
		 */
		return NULL;
	}

	ih = kmem_alloc(sizeof(*ih), KM_SLEEP);
	ih->ih_func = func;
	ih->ih_arg = arg;
	ih->ih_irq = irq;
	ih->ih_cookie_type = COBALT_COOKIE_TYPE_ICU;

	s = splhigh();

	/* Insert the handler into the table. */
	LIST_INSERT_HEAD(&icu_intrtab[irq].intr_q, ih, ih_q);

	/* Enable it, set trigger mode. */
	icu_imask &= ~(1U << irq);
	if (icu_intrtab[irq].intr_type == IST_LEVEL)
		icu_elcr |= (1U << irq);
	else
		icu_elcr &= ~(1U << irq);

	icu_set();

	splx(s);

	return ih;
}

void
icu_intr_disestablish(void *cookie)
{
	struct cobalt_intrhand *ih = cookie;
	int s;

	if (ih->ih_cookie_type == COBALT_COOKIE_TYPE_ICU) {
		s = splhigh();

		LIST_REMOVE(ih, ih_q);

		if (LIST_FIRST(&icu_intrtab[ih->ih_irq].intr_q) == NULL) {
			icu_imask |= (1U << ih->ih_irq);
			icu_set();
		}
		splx(s);
		kmem_free(ih, sizeof(*ih));
	}
}

void
icu_set(void)
{

	if ((icu_imask & 0xff00) != 0xff00)
		icu_imask &= ~(1U << IRQ_SLAVE);
	else
		icu_imask |= (1U << IRQ_SLAVE);

	ICU1_WRITE(PIC_OCW1, icu_imask);
	ICU2_WRITE(PIC_OCW1, icu_imask >> 8);

	ELCR_WRITE(ELCR0, icu_elcr);
	ELCR_WRITE(ELCR1, icu_elcr >> 8);
}

int
icu_intr(void *arg)
{
	struct cobalt_intrhand *ih;
	int irq, handled;

	handled = 0;

	for (;;) {
		/* check requested irq */
		ICU1_WRITE(PIC_OCW3, OCW3_SELECT | OCW3_POLL);
		irq = ICU1_READ(PIC_OCW3);
		if ((irq & OCW3_POLL_PENDING) == 0)
			return handled;

		irq = OCW3_POLL_IRQ(irq);
		if (irq == IRQ_SLAVE) {
			ICU2_WRITE(PIC_OCW3, OCW3_SELECT | OCW3_POLL);
			irq = OCW3_POLL_IRQ(ICU2_READ(PIC_OCW3)) + 8;
		}

		icu_intrtab[irq].intr_evcnt.ev_count++;
		LIST_FOREACH(ih, &icu_intrtab[irq].intr_q, ih_q) {
			if (__predict_false(ih->ih_func == NULL))
				printf("%s: spurious interrupt (irq = %d)\n",
				    __func__, irq);
			else if (__predict_true((*ih->ih_func)(ih->ih_arg))) {
				handled = 1;
			}
		}

		/* issue EOI to ack */
		if (irq >= 8) {
			ICU2_WRITE(PIC_OCW2,
			    OCW2_SELECT | OCW2_SL | OCW2_EOI |
			    OCW2_ILS(irq - 8));
			irq = IRQ_SLAVE;
		}
		ICU1_WRITE(PIC_OCW2,
		    OCW2_SELECT | OCW2_SL | OCW2_EOI | OCW2_ILS(irq));
	}
}

void *
cpu_intr_establish(int level, int ipl, int (*func)(void *), void *arg)
{
	struct cobalt_intrhand *ih;

	if (level < 0 || level >= NCPU_INT)
		panic("invalid interrupt level");

	ih = &cpu_intrtab[level].intr_ih;

	if (ih->ih_func != NULL)
		panic("cannot share CPU interrupts");

	ih->ih_cookie_type = COBALT_COOKIE_TYPE_CPU;
	ih->ih_func = func;
	ih->ih_arg = arg;
	ih->ih_irq = NICU_INT + level;

	return ih;
}

void
cpu_intr_disestablish(void *cookie)
{
	struct cobalt_intrhand *ih = cookie;

	if (ih->ih_cookie_type == COBALT_COOKIE_TYPE_CPU) {
		ih->ih_func = NULL;
		ih->ih_arg = NULL;
		ih->ih_cookie_type = 0;
	}
}

static void inline
intr_handle(struct cpu_intrhead *intr)
{
	struct cobalt_intrhand * const ih = &intr->intr_ih;
	if (__predict_true(ih->ih_func != NULL)
	    && __predict_true((*ih->ih_func)(ih->ih_arg))) {
		intr->intr_evcnt.ev_count++;
	}
}

void
cpu_intr(int ppl, vaddr_t pc, uint32_t status)
{
	uint32_t pending;
	int ipl;

	curcpu()->ci_data.cpu_nintr++;

	while (ppl < (ipl = splintr(&pending))) {
		splx(ipl);
		if (pending & MIPS_INT_MASK_5) {
			struct clockframe cf;
			/* call the common MIPS3 clock interrupt handler */
			cf.pc = pc;
			cf.sr = status;
			cf.intr = (curcpu()->ci_idepth > 1);
			mips3_clockintr(&cf);
		}

		if (__predict_false(pending & MIPS_INT_MASK_0)) {
			/* GT64x11 timer0 */
			volatile uint32_t *irq_src =
			    (uint32_t *)MIPS_PHYS_TO_KSEG1(GT_BASE + GT_INTR_CAUSE);

			if (__predict_true((*irq_src & T0EXP) != 0)) {
				/* GT64x11 timer is no longer used for hardclock(9) */
				*irq_src = 0;
			}
		}

		if (pending & MIPS_INT_MASK_3) {
			/* 16650 serial */
			intr_handle(&cpu_intrtab[3]);
		}

		if (pending & MIPS_INT_MASK_1) {
			/* tulip primary */
			intr_handle(&cpu_intrtab[1]);
		}

		if (pending & MIPS_INT_MASK_2) {
			/* tulip secondary */
			intr_handle(&cpu_intrtab[2]);
		}

		if (pending & MIPS_INT_MASK_4) {
			/* ICU interrupts */
			intr_handle(&cpu_intrtab[4]);
		}
		(void)splhigh();
	}
}