freebsd-dev/sys/mips/nlm/intr_machdep.c
Jayachandran C. 72e64728c9 Whitespace fixes for files in sys/mips/nlm
Clean up whitespace issues under sys/mips/nlm (except dev). No
functional change in this commit.
2015-02-28 00:17:29 +00:00

341 lines
8.0 KiB
C

/*-
* Copyright 2003-2011 Netlogic Microsystems (Netlogic). 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 Netlogic Microsystems ``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 NETLOGIC 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.
*
* NETLOGIC_BSD */
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/bus.h>
#include <sys/interrupt.h>
#include <sys/kernel.h>
#include <sys/module.h>
#include <dev/ofw/ofw_bus.h>
#include <dev/ofw/ofw_bus_subr.h>
#include <machine/cpu.h>
#include <machine/cpufunc.h>
#include <machine/cpuinfo.h>
#include <machine/cpuregs.h>
#include <machine/frame.h>
#include <machine/intr_machdep.h>
#include <machine/md_var.h>
#include <machine/trap.h>
#include <machine/hwfunc.h>
#include <mips/nlm/hal/haldefs.h>
#include <mips/nlm/hal/iomap.h>
#include <mips/nlm/hal/mips-extns.h>
#include <mips/nlm/interrupt.h>
#include <mips/nlm/hal/pic.h>
#include <mips/nlm/xlp.h>
struct xlp_intrsrc {
void (*bus_ack)(int, void *); /* Additional ack */
void *bus_ack_arg; /* arg for additional ack */
struct intr_event *ie; /* event corresponding to intr */
int irq;
int irt;
};
static struct xlp_intrsrc xlp_interrupts[XLR_MAX_INTR];
static mips_intrcnt_t mips_intr_counters[XLR_MAX_INTR];
static int intrcnt_index;
int
xlp_irq_to_irt(int irq)
{
uint32_t offset;
switch (irq) {
case PIC_UART_0_IRQ:
case PIC_UART_1_IRQ:
offset = XLP_IO_UART_OFFSET(0, irq - PIC_UART_0_IRQ);
return (xlp_socdev_irt(offset));
case PIC_PCIE_0_IRQ:
case PIC_PCIE_1_IRQ:
case PIC_PCIE_2_IRQ:
case PIC_PCIE_3_IRQ:
offset = XLP_IO_PCIE_OFFSET(0, irq - PIC_PCIE_0_IRQ);
return (xlp_socdev_irt(offset));
case PIC_USB_0_IRQ:
case PIC_USB_1_IRQ:
case PIC_USB_2_IRQ:
case PIC_USB_3_IRQ:
case PIC_USB_4_IRQ:
offset = XLP_IO_USB_OFFSET(0, irq - PIC_USB_0_IRQ);
return (xlp_socdev_irt(offset));
case PIC_I2C_0_IRQ:
case PIC_I2C_1_IRQ:
offset = XLP_IO_I2C0_OFFSET(0);
return (xlp_socdev_irt(offset) + irq - PIC_I2C_0_IRQ);
default:
printf("ERROR: %s: unknown irq %d\n", __func__, irq);
return (-1);
}
}
void
xlp_enable_irq(int irq)
{
uint64_t eimr;
eimr = nlm_read_c0_eimr();
nlm_write_c0_eimr(eimr | (1ULL << irq));
}
void
cpu_establish_softintr(const char *name, driver_filter_t * filt,
void (*handler) (void *), void *arg, int irq, int flags,
void **cookiep)
{
panic("Soft interrupts unsupported!\n");
}
static void
xlp_post_filter(void *source)
{
struct xlp_intrsrc *src = source;
if (src->bus_ack)
src->bus_ack(src->irq, src->bus_ack_arg);
nlm_pic_ack(xlp_pic_base, src->irt);
}
static void
xlp_pre_ithread(void *source)
{
struct xlp_intrsrc *src = source;
if (src->bus_ack)
src->bus_ack(src->irq, src->bus_ack_arg);
}
static void
xlp_post_ithread(void *source)
{
struct xlp_intrsrc *src = source;
nlm_pic_ack(xlp_pic_base, src->irt);
}
void
xlp_set_bus_ack(int irq, void (*ack)(int, void *), void *arg)
{
struct xlp_intrsrc *src;
KASSERT(irq > 0 && irq <= XLR_MAX_INTR,
("%s called for bad hard intr %d", __func__, irq));
/* no locking needed - this will called early in boot */
src = &xlp_interrupts[irq];
KASSERT(src->ie != NULL,
("%s called after IRQ enable for %d.", __func__, irq));
src->bus_ack_arg = arg;
src->bus_ack = ack;
}
void
cpu_establish_hardintr(const char *name, driver_filter_t * filt,
void (*handler) (void *), void *arg, int irq, int flags,
void **cookiep)
{
struct intr_event *ie; /* descriptor for the IRQ */
struct xlp_intrsrc *src = NULL;
int errcode;
KASSERT(irq > 0 && irq <= XLR_MAX_INTR ,
("%s called for bad hard intr %d", __func__, irq));
/*
* Locking - not needed now, because we do this only on
* startup from CPU0
*/
src = &xlp_interrupts[irq];
ie = src->ie;
if (ie == NULL) {
/*
* PIC based interrupts need ack in PIC, and some SoC
* components need additional acks (e.g. PCI)
*/
if (XLP_IRQ_IS_PICINTR(irq))
errcode = intr_event_create(&ie, src, 0, irq,
xlp_pre_ithread, xlp_post_ithread, xlp_post_filter,
NULL, "hard intr%d:", irq);
else {
if (filt == NULL)
panic("Unsupported non filter percpu intr %d", irq);
errcode = intr_event_create(&ie, src, 0, irq,
NULL, NULL, NULL, NULL, "hard intr%d:", irq);
}
if (errcode) {
printf("Could not create event for intr %d\n", irq);
return;
}
src->irq = irq;
src->ie = ie;
}
if (XLP_IRQ_IS_PICINTR(irq)) {
/* Set all irqs to CPU 0 for now */
src->irt = xlp_irq_to_irt(irq);
nlm_pic_write_irt_direct(xlp_pic_base, src->irt, 1, 0,
PIC_LOCAL_SCHEDULING, irq, 0);
}
intr_event_add_handler(ie, name, filt, handler, arg,
intr_priority(flags), flags, cookiep);
xlp_enable_irq(irq);
}
void
cpu_intr(struct trapframe *tf)
{
struct intr_event *ie;
uint64_t eirr, eimr;
int i;
critical_enter();
/* find a list of enabled interrupts */
eirr = nlm_read_c0_eirr();
eimr = nlm_read_c0_eimr();
eirr &= eimr;
if (eirr == 0) {
critical_exit();
return;
}
/*
* No need to clear the EIRR here as the handler writes to
* compare which ACKs the interrupt.
*/
if (eirr & (1 << IRQ_TIMER)) {
intr_event_handle(xlp_interrupts[IRQ_TIMER].ie, tf);
critical_exit();
return;
}
/* FIXME sched pin >? LOCK>? */
for (i = sizeof(eirr) * 8 - 1; i >= 0; i--) {
if ((eirr & (1ULL << i)) == 0)
continue;
ie = xlp_interrupts[i].ie;
/* Don't account special IRQs */
switch (i) {
case IRQ_IPI:
case IRQ_MSGRING:
break;
default:
mips_intrcnt_inc(mips_intr_counters[i]);
}
/* Ack the IRQ on the CPU */
nlm_write_c0_eirr(1ULL << i);
if (intr_event_handle(ie, tf) != 0) {
printf("stray interrupt %d\n", i);
}
}
critical_exit();
}
void
mips_intrcnt_setname(mips_intrcnt_t counter, const char *name)
{
int idx = counter - intrcnt;
KASSERT(counter != NULL, ("mips_intrcnt_setname: NULL counter"));
snprintf(intrnames + (MAXCOMLEN + 1) * idx,
MAXCOMLEN + 1, "%-*s", MAXCOMLEN, name);
}
mips_intrcnt_t
mips_intrcnt_create(const char* name)
{
mips_intrcnt_t counter = &intrcnt[intrcnt_index++];
mips_intrcnt_setname(counter, name);
return counter;
}
void
cpu_init_interrupts()
{
int i;
char name[MAXCOMLEN + 1];
/*
* Initialize all available vectors so spare IRQ
* would show up in systat output
*/
for (i = 0; i < XLR_MAX_INTR; i++) {
snprintf(name, MAXCOMLEN + 1, "int%d:", i);
mips_intr_counters[i] = mips_intrcnt_create(name);
}
}
static int xlp_pic_probe(device_t);
static int xlp_pic_attach(device_t);
static int
xlp_pic_probe(device_t dev)
{
if (!ofw_bus_is_compatible(dev, "netlogic,xlp-pic"))
return (ENXIO);
device_set_desc(dev, "XLP PIC");
return (0);
}
static int
xlp_pic_attach(device_t dev)
{
return (0);
}
static device_method_t xlp_pic_methods[] = {
DEVMETHOD(device_probe, xlp_pic_probe),
DEVMETHOD(device_attach, xlp_pic_attach),
DEVMETHOD_END
};
static driver_t xlp_pic_driver = {
"xlp_pic",
xlp_pic_methods,
1, /* no softc */
};
static devclass_t xlp_pic_devclass;
DRIVER_MODULE(xlp_pic, simplebus, xlp_pic_driver, xlp_pic_devclass, 0, 0);