mips_pic.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    1 /*-
    2  * Copyright (c) 2015 Alexander Kabaev
    3  * Copyright (c) 2006 Oleksandr Tymoshenko
    4  * Copyright (c) 2002-2004 Juli Mallett <jmallett@FreeBSD.org>
    5  * Copyright (c) 2017 The FreeBSD Foundation
    6  * All rights reserved.
    7  *
    8  * Portions of this software were developed by Landon Fuller
    9  * under sponsorship from the FreeBSD Foundation.
   10  *
   11  * Redistribution and use in source and binary forms, with or without
   12  * modification, are permitted provided that the following conditions
   13  * are met:
   14  * 1. Redistributions of source code must retain the above copyright
   15  *    notice, this list of conditions, and the following disclaimer,
   16  *    without modification, immediately at the beginning of the file.
   17  * 2. The name of the author may not be used to endorse or promote products
   18  *    derived from this software without specific prior written permission.
   19  *
   20  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
   21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   23  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
   24  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   30  * SUCH DAMAGE.
   31  *
   32  */
   33 
   34 #include <sys/cdefs.h>
   35 __FBSDID("$FreeBSD$");
   36 
   37 #include "opt_platform.h"
   38 #include "opt_hwpmc_hooks.h"
   39 
   40 #include <sys/param.h>
   41 #include <sys/systm.h>
   42 #include <sys/bus.h>
   43 #include <sys/kernel.h>
   44 #include <sys/ktr.h>
   45 #include <sys/module.h>
   46 #include <sys/malloc.h>
   47 #include <sys/rman.h>
   48 #include <sys/pcpu.h>
   49 #include <sys/proc.h>
   50 #include <sys/cpuset.h>
   51 #include <sys/limits.h>
   52 #include <sys/lock.h>
   53 #include <sys/mutex.h>
   54 #include <sys/smp.h>
   55 #include <sys/sched.h>
   56 #include <sys/pmc.h>
   57 #include <sys/pmckern.h>
   58 
   59 #include <machine/bus.h>
   60 #include <machine/hwfunc.h>
   61 #include <machine/intr.h>
   62 #include <machine/smp.h>
   63 
   64 #ifdef FDT
   65 #include <dev/fdt/fdt_common.h>
   66 #include <dev/ofw/openfirm.h>
   67 #include <dev/ofw/ofw_bus.h>
   68 #include <dev/ofw/ofw_bus_subr.h>
   69 #endif
   70 
   71 #include "pic_if.h"
   72 
   73 struct mips_pic_softc;
   74 
   75 static int                       mips_pic_intr(void *);
   76 static struct mips_pic_intr     *mips_pic_find_intr(struct resource *r);
   77 static int                       mips_pic_map_fixed_intr(u_int irq,
   78                                      struct mips_pic_intr **mapping);
   79 static void                      cpu_establish_intr(struct mips_pic_softc *sc,
   80                                      const char *name, driver_filter_t *filt,
   81                                      void (*handler)(void*), void *arg, int irq,
   82                                      int flags, void **cookiep);
   83 
   84 #define INTR_MAP_DATA_MIPS      INTR_MAP_DATA_PLAT_1
   85 
   86 struct intr_map_data_mips_pic {
   87         struct intr_map_data    hdr;
   88         u_int                   irq;
   89 };
   90 
   91 /**
   92  * MIPS interrupt state; available prior to MIPS PIC device attachment.
   93  */
   94 static struct mips_pic_intr {
   95         u_int                    mips_irq;      /**< MIPS IRQ# 0-7 */
   96         u_int                    intr_irq;      /**< INTRNG IRQ#, or INTR_IRQ_INVALID if unmapped */
   97         u_int                    consumers;     /**< INTRNG activation refcount */
   98         struct resource         *res;           /**< resource shared by all interrupt handlers registered via
   99                                                      cpu_establish_hardintr() or cpu_establish_softintr(); NULL
  100                                                      if no interrupt handlers are yet registered. */
  101 } mips_pic_intrs[] = {
  102         { 0, INTR_IRQ_INVALID, 0, NULL },
  103         { 1, INTR_IRQ_INVALID, 0, NULL },
  104         { 2, INTR_IRQ_INVALID, 0, NULL },
  105         { 3, INTR_IRQ_INVALID, 0, NULL },
  106         { 4, INTR_IRQ_INVALID, 0, NULL },
  107         { 5, INTR_IRQ_INVALID, 0, NULL },
  108         { 6, INTR_IRQ_INVALID, 0, NULL },
  109         { 7, INTR_IRQ_INVALID, 0, NULL },
  110 };
  111 
  112 struct mtx mips_pic_mtx;
  113 MTX_SYSINIT(mips_pic_mtx, &mips_pic_mtx, "mips intr controller mutex", MTX_DEF);
  114 
  115 struct mips_pic_irqsrc {
  116         struct intr_irqsrc      isrc;
  117         u_int                   irq;
  118 };
  119 
  120 struct mips_pic_softc {
  121         device_t                        pic_dev;
  122         struct mips_pic_irqsrc          pic_irqs[NREAL_IRQS];
  123         uint32_t                        nirqs;
  124 };
  125 
  126 static struct mips_pic_softc *pic_sc;
  127 
  128 #define PIC_INTR_ISRC(sc, irq)          (&(sc)->pic_irqs[(irq)].isrc)
  129 
  130 #ifdef FDT
  131 static struct ofw_compat_data compat_data[] = {
  132         {"mti,cpu-interrupt-controller",        true},
  133         {NULL,                                  false}
  134 };
  135 #endif
  136 
  137 #ifndef FDT
  138 static void
  139 mips_pic_identify(driver_t *drv, device_t parent)
  140 {
  141 
  142         BUS_ADD_CHILD(parent, 0, "cpupic", 0);
  143 }
  144 #endif
  145 
  146 static int
  147 mips_pic_probe(device_t dev)
  148 {
  149 
  150 #ifdef FDT
  151         if (!ofw_bus_status_okay(dev))
  152                 return (ENXIO);
  153 
  154         if (!ofw_bus_search_compatible(dev, compat_data)->ocd_data)
  155                 return (ENXIO);
  156 #endif
  157         device_set_desc(dev, "MIPS32 Interrupt Controller");
  158         return (BUS_PROBE_DEFAULT);
  159 }
  160 
  161 static inline void
  162 pic_irq_unmask(struct mips_pic_softc *sc, u_int irq)
  163 {
  164 
  165         mips_wr_status(mips_rd_status() | ((1 << irq) << 8));
  166 }
  167 
  168 static inline void
  169 pic_irq_mask(struct mips_pic_softc *sc, u_int irq)
  170 {
  171 
  172         mips_wr_status(mips_rd_status() & ~((1 << irq) << 8));
  173 }
  174 
  175 static inline intptr_t
  176 pic_xref(device_t dev)
  177 {
  178 #ifdef FDT
  179         return (OF_xref_from_node(ofw_bus_get_node(dev)));
  180 #else
  181         return (MIPS_PIC_XREF);
  182 #endif
  183 }
  184 
  185 static int
  186 mips_pic_register_isrcs(struct mips_pic_softc *sc)
  187 {
  188         int error;
  189         uint32_t irq, i, tmpirq;
  190         struct intr_irqsrc *isrc;
  191         char *name;
  192 
  193         for (irq = 0; irq < sc->nirqs; irq++) {
  194                 sc->pic_irqs[irq].irq = irq;
  195 
  196                 isrc = PIC_INTR_ISRC(sc, irq);
  197                 if (irq < NSOFT_IRQS) {
  198                         name = "sint";
  199                         tmpirq = irq;
  200                 } else {
  201                         name = "int";
  202                         tmpirq = irq - NSOFT_IRQS;
  203                 }
  204                 error = intr_isrc_register(isrc, sc->pic_dev, 0, "%s%u",
  205                     name, tmpirq);
  206                 if (error != 0) {
  207                         for (i = 0; i < irq; i++) {
  208                                 intr_isrc_deregister(PIC_INTR_ISRC(sc, i));
  209                         }
  210                         device_printf(sc->pic_dev, "%s failed", __func__);
  211                         return (error);
  212                 }
  213         }
  214 
  215         return (0);
  216 }
  217 
  218 static int
  219 mips_pic_attach(device_t dev)
  220 {
  221         struct          mips_pic_softc *sc;
  222         intptr_t        xref = pic_xref(dev);
  223 
  224         if (pic_sc)
  225                 return (ENXIO);
  226 
  227         sc = device_get_softc(dev);
  228 
  229         sc->pic_dev = dev;
  230         pic_sc = sc;
  231 
  232         /* Set the number of interrupts */
  233         sc->nirqs = nitems(sc->pic_irqs);
  234 
  235         /* Register the interrupts */
  236         if (mips_pic_register_isrcs(sc) != 0) {
  237                 device_printf(dev, "could not register PIC ISRCs\n");
  238                 goto cleanup;
  239         }
  240 
  241         /*
  242          * Now, when everything is initialized, it's right time to
  243          * register interrupt controller to interrupt framefork.
  244          */
  245         if (intr_pic_register(dev, xref) == NULL) {
  246                 device_printf(dev, "could not register PIC\n");
  247                 goto cleanup;
  248         }
  249 
  250         /* Claim our root controller role */
  251         if (intr_pic_claim_root(dev, xref, mips_pic_intr, sc, 0) != 0) {
  252                 device_printf(dev, "could not set PIC as a root\n");
  253                 intr_pic_deregister(dev, xref);
  254                 goto cleanup;
  255         }
  256 
  257         return (0);
  258 
  259 cleanup:
  260         return(ENXIO);
  261 }
  262 
  263 int
  264 mips_pic_intr(void *arg)
  265 {
  266         struct mips_pic_softc *sc = arg;
  267         register_t cause, status;
  268         int i, intr;
  269 
  270         cause = mips_rd_cause();
  271         status = mips_rd_status();
  272         intr = (cause & MIPS_INT_MASK) >> 8;
  273         /*
  274          * Do not handle masked interrupts. They were masked by
  275          * pre_ithread function (mips_mask_XXX_intr) and will be
  276          * unmasked once ithread is through with handler
  277          */
  278         intr &= (status & MIPS_INT_MASK) >> 8;
  279         while ((i = fls(intr)) != 0) {
  280                 i--; /* Get a 0-offset interrupt. */
  281                 intr &= ~(1 << i);
  282 
  283                 if (intr_isrc_dispatch(PIC_INTR_ISRC(sc, i),
  284                     curthread->td_intr_frame) != 0) {
  285                         device_printf(sc->pic_dev,
  286                             "Stray interrupt %u detected\n", i);
  287                         pic_irq_mask(sc, i);
  288                         continue;
  289                 }
  290         }
  291 
  292         KASSERT(i == 0, ("all interrupts handled"));
  293 
  294 #ifdef HWPMC_HOOKS
  295         if (pmc_hook && (PCPU_GET(curthread)->td_pflags & TDP_CALLCHAIN)) {
  296                 struct trapframe *tf = PCPU_GET(curthread)->td_intr_frame;
  297 
  298                 pmc_hook(PCPU_GET(curthread), PMC_FN_USER_CALLCHAIN, tf);
  299         }
  300 #endif
  301         return (FILTER_HANDLED);
  302 }
  303 
  304 static void
  305 mips_pic_disable_intr(device_t dev, struct intr_irqsrc *isrc)
  306 {
  307         u_int irq;
  308 
  309         irq = ((struct mips_pic_irqsrc *)isrc)->irq;
  310         pic_irq_mask(device_get_softc(dev), irq);
  311 }
  312 
  313 static void
  314 mips_pic_enable_intr(device_t dev, struct intr_irqsrc *isrc)
  315 {
  316         u_int irq;
  317 
  318         irq = ((struct mips_pic_irqsrc *)isrc)->irq;
  319         pic_irq_unmask(device_get_softc(dev), irq);
  320 }
  321 
  322 static int
  323 mips_pic_map_intr(device_t dev, struct intr_map_data *data,
  324     struct intr_irqsrc **isrcp)
  325 {
  326         struct mips_pic_softc *sc;
  327         int res;
  328 
  329         sc = device_get_softc(dev);
  330         res = 0;
  331 #ifdef FDT
  332         if (data->type == INTR_MAP_DATA_FDT) {
  333                 struct intr_map_data_fdt *daf;
  334 
  335                 daf = (struct intr_map_data_fdt *)data;
  336 
  337                 if (daf->ncells != 1 || daf->cells[0] >= sc->nirqs)
  338                         return (EINVAL);
  339 
  340                 *isrcp = PIC_INTR_ISRC(sc, daf->cells[0]);
  341         } else
  342 #endif
  343         if (data->type == INTR_MAP_DATA_MIPS) {
  344                 struct intr_map_data_mips_pic *mpd;
  345 
  346                 mpd = (struct intr_map_data_mips_pic *)data;
  347 
  348                 if (mpd->irq < 0 || mpd->irq >= sc->nirqs)
  349                         return (EINVAL);
  350 
  351                 *isrcp = PIC_INTR_ISRC(sc, mpd->irq);
  352         } else {
  353                 res = ENOTSUP;
  354         }
  355 
  356         return (res);
  357 }
  358 
  359 static void
  360 mips_pic_pre_ithread(device_t dev, struct intr_irqsrc *isrc)
  361 {
  362 
  363         mips_pic_disable_intr(dev, isrc);
  364 }
  365 
  366 static void
  367 mips_pic_post_ithread(device_t dev, struct intr_irqsrc *isrc)
  368 {
  369 
  370         mips_pic_enable_intr(dev, isrc);
  371 }
  372 
  373 static void
  374 mips_pic_post_filter(device_t dev, struct intr_irqsrc *isrc)
  375 {
  376 }
  377 
  378 static device_method_t mips_pic_methods[] = {
  379         /* Device interface */
  380 #ifndef FDT
  381         DEVMETHOD(device_identify,      mips_pic_identify),
  382 #endif
  383         DEVMETHOD(device_probe,         mips_pic_probe),
  384         DEVMETHOD(device_attach,        mips_pic_attach),
  385 
  386         /* Interrupt controller interface */
  387         DEVMETHOD(pic_disable_intr,     mips_pic_disable_intr),
  388         DEVMETHOD(pic_enable_intr,      mips_pic_enable_intr),
  389         DEVMETHOD(pic_map_intr,         mips_pic_map_intr),
  390         DEVMETHOD(pic_pre_ithread,      mips_pic_pre_ithread),
  391         DEVMETHOD(pic_post_ithread,     mips_pic_post_ithread),
  392         DEVMETHOD(pic_post_filter,      mips_pic_post_filter),
  393 
  394         { 0, 0 }
  395 };
  396 
  397 static driver_t mips_pic_driver = {
  398         "cpupic",
  399         mips_pic_methods,
  400         sizeof(struct mips_pic_softc),
  401 };
  402 
  403 static devclass_t mips_pic_devclass;
  404 
  405 #ifdef FDT
  406 EARLY_DRIVER_MODULE(cpupic, ofwbus, mips_pic_driver, mips_pic_devclass, 0, 0,
  407     BUS_PASS_INTERRUPT);
  408 #else
  409 EARLY_DRIVER_MODULE(cpupic, nexus, mips_pic_driver, mips_pic_devclass, 0, 0,
  410     BUS_PASS_INTERRUPT);
  411 #endif
  412 
  413 /**
  414  * Return the MIPS interrupt map entry for @p r, or NULL if no such entry has
  415  * been created.
  416  */
  417 static struct mips_pic_intr *
  418 mips_pic_find_intr(struct resource *r)
  419 {
  420         struct mips_pic_intr    *intr;
  421         rman_res_t               irq;
  422 
  423         irq = rman_get_start(r);
  424         if (irq != rman_get_end(r) || rman_get_size(r) != 1)
  425                 return (NULL);
  426 
  427         mtx_lock(&mips_pic_mtx);
  428         for (size_t i = 0; i < nitems(mips_pic_intrs); i++) {
  429                 intr = &mips_pic_intrs[i];
  430 
  431                 if (intr->intr_irq != irq)
  432                         continue;
  433 
  434                 mtx_unlock(&mips_pic_mtx);
  435                 return (intr);
  436         }
  437         mtx_unlock(&mips_pic_mtx);
  438 
  439         /* Not found */
  440         return (NULL);
  441 }
  442 
  443 /**
  444  * Allocate a fixed IRQ mapping for the given MIPS @p irq, or return the
  445  * existing mapping if @p irq was previously mapped.
  446  * 
  447  * @param       irq     The MIPS IRQ to be mapped.
  448  * @param[out]  mapping On success, will be populated with the interrupt
  449  *                      mapping.
  450  *
  451  * @retval 0            success
  452  * @retval EINVAL       if @p irq is not a valid MIPS IRQ#.
  453  * @retval non-zero     If allocating the MIPS IRQ mapping otherwise fails, a
  454  *                      regular unix error code will be returned.
  455  */
  456 static int
  457 mips_pic_map_fixed_intr(u_int irq, struct mips_pic_intr **mapping)
  458 {
  459         struct mips_pic_intr            *intr;
  460         struct intr_map_data_mips_pic   *data;
  461         device_t                         pic_dev;
  462         uintptr_t                        xref;
  463 
  464         if (irq < 0 || irq >= nitems(mips_pic_intrs))
  465                 return (EINVAL);
  466 
  467         mtx_lock(&mips_pic_mtx);
  468 
  469         /* Fetch corresponding interrupt entry */
  470         intr = &mips_pic_intrs[irq];
  471         KASSERT(intr->mips_irq == irq,
  472                 ("intr %u found at index %u", intr->mips_irq, irq));
  473 
  474         /* Already mapped? */
  475         if (intr->intr_irq != INTR_IRQ_INVALID) {
  476                 mtx_unlock(&mips_pic_mtx);
  477                 *mapping = intr;
  478                 return (0);
  479         }
  480 
  481         /* Map the interrupt */
  482         data = (struct intr_map_data_mips_pic *)intr_alloc_map_data(
  483                 INTR_MAP_DATA_MIPS, sizeof(*data), M_WAITOK | M_ZERO);
  484         data->irq = intr->mips_irq;
  485 
  486 #ifdef FDT
  487         /* PIC must be attached on FDT devices */
  488         KASSERT(pic_sc != NULL, ("%s: no pic", __func__));
  489 
  490         pic_dev = pic_sc->pic_dev;
  491         xref = pic_xref(pic_dev);
  492 #else /* !FDT */
  493         /* PIC has a fixed xref, and may not have been attached yet */
  494         pic_dev = NULL;
  495         if (pic_sc != NULL)
  496                 pic_dev = pic_sc->pic_dev;
  497 
  498         xref = MIPS_PIC_XREF;
  499 #endif /* FDT */
  500 
  501         KASSERT(intr->intr_irq == INTR_IRQ_INVALID, ("duplicate map"));
  502         intr->intr_irq = intr_map_irq(pic_dev, xref, &data->hdr);
  503         *mapping = intr;
  504 
  505         mtx_unlock(&mips_pic_mtx);
  506         return (0);
  507 }
  508 
  509 /**
  510  * 
  511  * Produce fixed IRQ mappings for all MIPS IRQs.
  512  *
  513  * Non-FDT/OFW MIPS targets do not provide an equivalent to OFW_BUS_MAP_INTR();
  514  * it is instead necessary to reserve INTRNG IRQ# 0-7 for use by MIPS device
  515  * drivers that assume INTRNG IRQs 0-7 are directly mapped to MIPS IRQs 0-7.
  516  * 
  517  * XXX: There is no support in INTRNG for reserving a fixed IRQ range. However,
  518  * we should be called prior to any other interrupt mapping requests, and work
  519  * around this by iteratively allocating the required 0-7 MIP IRQ# range.
  520  *
  521  * @retval 0            success
  522  * @retval non-zero     If allocating the MIPS IRQ mappings otherwise fails, a
  523  *                      regular unix error code will be returned.
  524  */
  525 int
  526 mips_pic_map_fixed_intrs(void)
  527 {
  528         int error;
  529 
  530         for (u_int i = 0; i < nitems(mips_pic_intrs); i++) {
  531                 struct mips_pic_intr *intr;
  532 
  533                 if ((error = mips_pic_map_fixed_intr(i, &intr)))
  534                         return (error);
  535 
  536                 /* INTRNG IRQs 0-7 must be directly mapped to MIPS IRQs 0-7 */
  537                 if (intr->intr_irq != intr->mips_irq) {
  538                         panic("invalid IRQ mapping: %u->%u", intr->intr_irq,
  539                             intr->mips_irq);
  540                 }
  541         }
  542 
  543         return (0);
  544 }
  545 
  546 /**
  547  * If @p r references a MIPS interrupt mapped by the MIPS32 interrupt
  548  * controller, handle interrupt activation internally.
  549  *
  550  * Otherwise, delegate directly to intr_activate_irq().
  551  */
  552 int
  553 mips_pic_activate_intr(device_t child, struct resource *r)
  554 {
  555         struct mips_pic_intr    *intr;
  556         int                      error;
  557 
  558         /* Is this one of our shared MIPS interrupts? */
  559         if ((intr = mips_pic_find_intr(r)) == NULL) {
  560                 /* Delegate to standard INTRNG activation */
  561                 return (intr_activate_irq(child, r));
  562         }
  563 
  564         /* Bump consumer count and request activation if required */
  565         mtx_lock(&mips_pic_mtx);
  566         if (intr->consumers == UINT_MAX) {
  567                 mtx_unlock(&mips_pic_mtx);
  568                 return (ENOMEM);
  569         }
  570 
  571         if (intr->consumers == 0) {
  572                 if ((error = intr_activate_irq(child, r))) {
  573                         mtx_unlock(&mips_pic_mtx);
  574                         return (error);
  575                 }
  576         }
  577 
  578         intr->consumers++;
  579         mtx_unlock(&mips_pic_mtx);
  580 
  581         return (0);
  582 }
  583 
  584 /**
  585  * If @p r references a MIPS interrupt mapped by the MIPS32 interrupt
  586  * controller, handle interrupt deactivation internally.
  587  * 
  588  * Otherwise, delegate directly to intr_deactivate_irq().
  589  */
  590 int
  591 mips_pic_deactivate_intr(device_t child, struct resource *r)
  592 {
  593         struct mips_pic_intr    *intr;
  594         int                      error;
  595 
  596         /* Is this one of our shared MIPS interrupts? */
  597         if ((intr = mips_pic_find_intr(r)) == NULL) {
  598                 /* Delegate to standard INTRNG deactivation */
  599                 return (intr_deactivate_irq(child, r));
  600         }
  601 
  602         /* Decrement consumer count and request deactivation if required */
  603         mtx_lock(&mips_pic_mtx);
  604         KASSERT(intr->consumers > 0, ("refcount overrelease"));
  605 
  606         if (intr->consumers == 1) {
  607                 if ((error = intr_deactivate_irq(child, r))) {
  608                         mtx_unlock(&mips_pic_mtx);
  609                         return (error);
  610                 }
  611         }
  612         intr->consumers--;
  613         
  614         mtx_unlock(&mips_pic_mtx);
  615         return (0);
  616 }
  617 
  618 void
  619 cpu_init_interrupts(void)
  620 {
  621 }
  622 
  623 /**
  624  * Provide backwards-compatible support for registering a MIPS interrupt handler
  625  * directly, without allocating a bus resource. 
  626  */
  627 static void
  628 cpu_establish_intr(struct mips_pic_softc *sc, const char *name,
  629     driver_filter_t *filt, void (*handler)(void*), void *arg, int irq,
  630     int flags, void **cookiep)
  631 {
  632         struct mips_pic_intr    *intr;
  633         struct resource         *res;
  634         int                      rid;
  635         int                      error;
  636 
  637         rid = -1;
  638 
  639         /* Fetch (or create) a fixed mapping */
  640         if ((error = mips_pic_map_fixed_intr(irq, &intr)))
  641                 panic("Unable to map IRQ %d: %d", irq, error);
  642 
  643         /* Fetch the backing resource, if any */
  644         mtx_lock(&mips_pic_mtx);
  645         res = intr->res;
  646         mtx_unlock(&mips_pic_mtx);
  647 
  648         /* Allocate our IRQ resource */
  649         if (res == NULL) {
  650                 /* Optimistically perform resource allocation */
  651                 rid = intr->intr_irq;
  652                 res = bus_alloc_resource(sc->pic_dev, SYS_RES_IRQ, &rid,
  653                     intr->intr_irq, intr->intr_irq, 1, RF_SHAREABLE|RF_ACTIVE);
  654 
  655                 if (res != NULL) {
  656                         /* Try to update intr->res */
  657                         mtx_lock(&mips_pic_mtx);
  658                         if (intr->res == NULL) {
  659                                 intr->res = res;
  660                         }
  661                         mtx_unlock(&mips_pic_mtx);
  662 
  663                         /* If intr->res was updated concurrently, free our local
  664                          * resource allocation */
  665                         if (intr->res != res) {
  666                                 bus_release_resource(sc->pic_dev, SYS_RES_IRQ,
  667                                     rid, res);
  668                         }
  669                 } else {
  670                         /* Maybe someone else allocated it? */
  671                         mtx_lock(&mips_pic_mtx);
  672                         res = intr->res;
  673                         mtx_unlock(&mips_pic_mtx);
  674                 }
  675         
  676                 if (res == NULL) {
  677                         panic("Unable to allocate IRQ %d->%u resource", irq,
  678                             intr->intr_irq);
  679                 }
  680         }
  681 
  682         error = bus_setup_intr(sc->pic_dev, res, flags, filt, handler, arg,
  683             cookiep);
  684         if (error)
  685                 panic("Unable to add IRQ %d handler: %d", irq, error);
  686 }
  687 
  688 void
  689 cpu_establish_hardintr(const char *name, driver_filter_t *filt,
  690     void (*handler)(void*), void *arg, int irq, int flags, void **cookiep)
  691 {
  692         KASSERT(pic_sc != NULL, ("%s: no pic", __func__));
  693 
  694         if (irq < 0 || irq >= NHARD_IRQS)
  695                 panic("%s called for unknown hard intr %d", __func__, irq);
  696 
  697         cpu_establish_intr(pic_sc, name, filt, handler, arg, irq+NSOFT_IRQS,
  698             flags, cookiep);
  699 }
  700 
  701 void
  702 cpu_establish_softintr(const char *name, driver_filter_t *filt,
  703     void (*handler)(void*), void *arg, int irq, int flags,
  704     void **cookiep)
  705 {
  706         KASSERT(pic_sc != NULL, ("%s: no pic", __func__));
  707 
  708         if (irq < 0 || irq >= NSOFT_IRQS)
  709                 panic("%s called for unknown soft intr %d", __func__, irq);
  710 
  711         cpu_establish_intr(pic_sc, name, filt, handler, arg, irq, flags,
  712             cookiep);
  713 }
  714
Cache object: 1ee4326349e627e3cdd80138b2d20d0b
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/mips/mips/mips_pic.c

FreeBSD/Linux Kernel Cross Reference
sys/mips/mips/mips_pic.c
