The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/i386/pci/pci_pir.c

Version: -  FREEBSD  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-2  -  FREEBSD-11-1  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-4  -  FREEBSD-10-3  -  FREEBSD-10-2  -  FREEBSD-10-1  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-3  -  FREEBSD-9-2  -  FREEBSD-9-1  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-4  -  FREEBSD-8-3  -  FREEBSD-8-2  -  FREEBSD-8-1  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-4  -  FREEBSD-7-3  -  FREEBSD-7-2  -  FREEBSD-7-1  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-4  -  FREEBSD-6-3  -  FREEBSD-6-2  -  FREEBSD-6-1  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-5  -  FREEBSD-5-4  -  FREEBSD-5-3  -  FREEBSD-5-2  -  FREEBSD-5-1  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

    1 /*-
    2  * Copyright (c) 1997, Stefan Esser <se@freebsd.org>
    3  * Copyright (c) 2000, Michael Smith <msmith@freebsd.org>
    4  * Copyright (c) 2000, BSDi
    5  * All rights reserved.
    6  * Copyright (c) 2004, John Baldwin <jhb@FreeBSD.org>
    7  *
    8  * Redistribution and use in source and binary forms, with or without
    9  * modification, are permitted provided that the following conditions
   10  * are met:
   11  * 1. Redistributions of source code must retain the above copyright
   12  *    notice unmodified, this list of conditions, and the following
   13  *    disclaimer.
   14  * 2. Redistributions in binary form must reproduce the above copyright
   15  *    notice, this list of conditions and the following disclaimer in the
   16  *    documentation and/or other materials provided with the distribution.
   17  *
   18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   19  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   20  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
   21  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
   22  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
   23  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   24  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   25  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
   27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   28  */
   29 
   30 #include <sys/cdefs.h>
   31 __FBSDID("$FreeBSD: stable/11/sys/i386/pci/pci_pir.c 367457 2020-11-07 18:10:59Z dim $");
   32 
   33 #include <sys/param.h>
   34 #include <sys/systm.h>
   35 #include <sys/bus.h>
   36 #include <sys/kernel.h>
   37 #include <sys/malloc.h>
   38 #include <sys/module.h>
   39 #include <sys/sysctl.h>
   40 #include <vm/vm.h>
   41 #include <vm/pmap.h>
   42 #include <vm/vm_param.h>
   43 #include <machine/md_var.h>
   44 #include <dev/pci/pcivar.h>
   45 #include <dev/pci/pcireg.h>
   46 #include <machine/pci_cfgreg.h>
   47 #include <machine/segments.h>
   48 #include <machine/pc/bios.h>
   49 
   50 #define NUM_ISA_INTERRUPTS      16
   51 
   52 /*
   53  * A link device.  Loosely based on the ACPI PCI link device.  This doesn't
   54  * try to support priorities for different ISA interrupts.
   55  */
   56 struct pci_link {
   57         TAILQ_ENTRY(pci_link) pl_links;
   58         uint8_t         pl_id;
   59         uint8_t         pl_irq;
   60         uint16_t        pl_irqmask;
   61         int             pl_references;
   62         int             pl_routed;
   63 };
   64 
   65 struct pci_link_lookup {
   66         struct pci_link **pci_link_ptr;
   67         int             bus;
   68         int             device;
   69         int             pin;
   70 };
   71 
   72 struct pci_dev_lookup {
   73         uint8_t         link;
   74         int             bus;
   75         int             device;
   76         int             pin;
   77 };
   78 
   79 typedef void pir_entry_handler(struct PIR_entry *entry,
   80     struct PIR_intpin* intpin, void *arg);
   81 
   82 static void     pci_print_irqmask(u_int16_t irqs);
   83 static int      pci_pir_biosroute(int bus, int device, int func, int pin,
   84                     int irq);
   85 static int      pci_pir_choose_irq(struct pci_link *pci_link, int irqmask);
   86 static void     pci_pir_create_links(struct PIR_entry *entry,
   87                     struct PIR_intpin *intpin, void *arg);
   88 static void     pci_pir_dump_links(void);
   89 static struct pci_link *pci_pir_find_link(uint8_t link_id);
   90 static void     pci_pir_find_link_handler(struct PIR_entry *entry,
   91                     struct PIR_intpin *intpin, void *arg);
   92 static void     pci_pir_initial_irqs(struct PIR_entry *entry,
   93                     struct PIR_intpin *intpin, void *arg);
   94 static void     pci_pir_parse(void);
   95 static uint8_t  pci_pir_search_irq(int bus, int device, int pin);
   96 static int      pci_pir_valid_irq(struct pci_link *pci_link, int irq);
   97 static void     pci_pir_walk_table(pir_entry_handler *handler, void *arg);
   98 
   99 static MALLOC_DEFINE(M_PIR, "$PIR", "$PIR structures");
  100 
  101 static struct PIR_table *pci_route_table;
  102 static device_t pir_device;
  103 static int pci_route_count, pir_bios_irqs, pir_parsed;
  104 static TAILQ_HEAD(, pci_link) pci_links;
  105 static int pir_interrupt_weight[NUM_ISA_INTERRUPTS];
  106 
  107 /* sysctl vars */
  108 SYSCTL_DECL(_hw_pci);
  109 
  110 /* XXX this likely should live in a header file */
  111 #ifdef PC98
  112 /* IRQs 3, 5, 7, 9, 10, 11, 12, 13 */
  113 #define PCI_IRQ_OVERRIDE_MASK 0x3e68
  114 #else
  115 /* IRQs 3, 4, 5, 6, 7, 9, 10, 11, 12, 14, 15 */
  116 #define PCI_IRQ_OVERRIDE_MASK 0xdef8
  117 #endif
  118 
  119 static uint32_t pci_irq_override_mask = PCI_IRQ_OVERRIDE_MASK;
  120 SYSCTL_INT(_hw_pci, OID_AUTO, irq_override_mask, CTLFLAG_RDTUN,
  121     &pci_irq_override_mask, PCI_IRQ_OVERRIDE_MASK,
  122     "Mask of allowed irqs to try to route when it has no good clue about\n"
  123     "which irqs it should use.");
  124 
  125 /*
  126  * Look for the interrupt routing table.
  127  *
  128  * We use PCI BIOS's PIR table if it's available. $PIR is the standard way
  129  * to do this.  Sadly, some machines are not standards conforming and have
  130  * _PIR instead.  We shrug and cope by looking for both.
  131  */
  132 void
  133 pci_pir_open(void)
  134 {
  135         struct PIR_table *pt;
  136         uint32_t sigaddr;
  137         int i;
  138         uint8_t ck, *cv;
  139 
  140         /* Don't try if we've already found a table. */
  141         if (pci_route_table != NULL)
  142                 return;
  143 
  144         /* Look for $PIR and then _PIR. */
  145         sigaddr = bios_sigsearch(0, "$PIR", 4, 16, 0);
  146         if (sigaddr == 0)
  147                 sigaddr = bios_sigsearch(0, "_PIR", 4, 16, 0);
  148         if (sigaddr == 0)
  149                 return;
  150 
  151         /* If we found something, check the checksum and length. */
  152         /* XXX - Use pmap_mapdev()? */
  153         pt = (struct PIR_table *)(uintptr_t)BIOS_PADDRTOVADDR(sigaddr);
  154         if (pt->pt_header.ph_length <= sizeof(struct PIR_header))
  155                 return;
  156         for (cv = (u_int8_t *)pt, ck = 0, i = 0;
  157              i < (pt->pt_header.ph_length); i++)
  158                 ck += cv[i];
  159         if (ck != 0)
  160                 return;
  161 
  162         /* Ok, we've got a valid table. */
  163         pci_route_table = pt;
  164         pci_route_count = (pt->pt_header.ph_length -
  165             sizeof(struct PIR_header)) / 
  166             sizeof(struct PIR_entry);
  167 }
  168 
  169 /*
  170  * Find the pci_link structure for a given link ID.
  171  */
  172 static struct pci_link *
  173 pci_pir_find_link(uint8_t link_id)
  174 {
  175         struct pci_link *pci_link;
  176 
  177         TAILQ_FOREACH(pci_link, &pci_links, pl_links) {
  178                 if (pci_link->pl_id == link_id)
  179                         return (pci_link);
  180         }
  181         return (NULL);
  182 }
  183 
  184 /*
  185  * Find the link device associated with a PCI device in the table.
  186  */
  187 static void
  188 pci_pir_find_link_handler(struct PIR_entry *entry, struct PIR_intpin *intpin,
  189     void *arg)
  190 {
  191         struct pci_link_lookup *lookup;
  192 
  193         lookup = (struct pci_link_lookup *)arg;
  194         if (entry->pe_bus == lookup->bus &&
  195             entry->pe_device == lookup->device &&
  196             intpin - entry->pe_intpin == lookup->pin)
  197                 *lookup->pci_link_ptr = pci_pir_find_link(intpin->link);
  198 }
  199 
  200 /*
  201  * Check to see if a possible IRQ setting is valid.
  202  */
  203 static int
  204 pci_pir_valid_irq(struct pci_link *pci_link, int irq)
  205 {
  206 
  207         if (!PCI_INTERRUPT_VALID(irq))
  208                 return (0);
  209         return (pci_link->pl_irqmask & (1 << irq));
  210 }
  211 
  212 /*
  213  * Walk the $PIR executing the worker function for each valid intpin entry
  214  * in the table.  The handler is passed a pointer to both the entry and
  215  * the intpin in the entry.
  216  */
  217 static void
  218 pci_pir_walk_table(pir_entry_handler *handler, void *arg)
  219 {
  220         struct PIR_entry *entry;
  221         struct PIR_intpin *intpin;
  222         int i, pin;
  223 
  224         entry = &pci_route_table->pt_entry[0];
  225         for (i = 0; i < pci_route_count; i++, entry++) {
  226                 intpin = &entry->pe_intpin[0];
  227                 for (pin = 0; pin < 4; pin++, intpin++)
  228                         if (intpin->link != 0)
  229                                 handler(entry, intpin, arg);
  230         }
  231 }
  232 
  233 static void
  234 pci_pir_create_links(struct PIR_entry *entry, struct PIR_intpin *intpin,
  235     void *arg)
  236 {
  237         struct pci_link *pci_link;
  238 
  239         pci_link = pci_pir_find_link(intpin->link);
  240         if (pci_link != NULL) {
  241                 pci_link->pl_references++;
  242                 if (intpin->irqs != pci_link->pl_irqmask) {
  243                         if (bootverbose)
  244                                 printf(
  245         "$PIR: Entry %d.%d.INT%c has different mask for link %#x, merging\n",
  246                                     entry->pe_bus, entry->pe_device,
  247                                     (intpin - entry->pe_intpin) + 'A',
  248                                     pci_link->pl_id);
  249                         pci_link->pl_irqmask &= intpin->irqs;
  250                 }
  251         } else {
  252                 pci_link = malloc(sizeof(struct pci_link), M_PIR, M_WAITOK);
  253                 pci_link->pl_id = intpin->link;
  254                 pci_link->pl_irqmask = intpin->irqs;
  255                 pci_link->pl_irq = PCI_INVALID_IRQ;
  256                 pci_link->pl_references = 1;
  257                 pci_link->pl_routed = 0;
  258                 TAILQ_INSERT_TAIL(&pci_links, pci_link, pl_links);
  259         }
  260 }
  261 
  262 /*
  263  * Look to see if any of the functions on the PCI device at bus/device
  264  * have an interrupt routed to intpin 'pin' by the BIOS.
  265  */
  266 static uint8_t
  267 pci_pir_search_irq(int bus, int device, int pin)
  268 {
  269         uint32_t value;
  270         uint8_t func, maxfunc;
  271 
  272         /* See if we have a valid device at function 0. */
  273         value = pci_cfgregread(bus, device, 0, PCIR_VENDOR, 2);
  274         if (value == PCIV_INVALID)
  275                 return (PCI_INVALID_IRQ);
  276         value = pci_cfgregread(bus, device, 0, PCIR_HDRTYPE, 1);
  277         if ((value & PCIM_HDRTYPE) > PCI_MAXHDRTYPE)
  278                 return (PCI_INVALID_IRQ);
  279         if (value & PCIM_MFDEV)
  280                 maxfunc = PCI_FUNCMAX;
  281         else
  282                 maxfunc = 0;
  283 
  284         /* Scan all possible functions at this device. */
  285         for (func = 0; func <= maxfunc; func++) {
  286                 value = pci_cfgregread(bus, device, func, PCIR_VENDOR, 2);
  287                 if (value == PCIV_INVALID)
  288                         continue;
  289                 value = pci_cfgregread(bus, device, func, PCIR_INTPIN, 1);
  290 
  291                 /*
  292                  * See if it uses the pin in question.  Note that the passed
  293                  * in pin uses 0 for A, .. 3 for D whereas the intpin
  294                  * register uses 0 for no interrupt, 1 for A, .. 4 for D.
  295                  */
  296                 if (value != pin + 1)
  297                         continue;
  298                 value = pci_cfgregread(bus, device, func, PCIR_INTLINE, 1);
  299                 if (bootverbose)
  300                         printf(
  301                 "$PIR: Found matching pin for %d.%d.INT%c at func %d: %d\n",
  302                             bus, device, pin + 'A', func, value);
  303                 if (value != PCI_INVALID_IRQ)
  304                         return (value);
  305         }
  306         return (PCI_INVALID_IRQ);
  307 }
  308 
  309 /*
  310  * Try to initialize IRQ based on this device's IRQ.
  311  */
  312 static void
  313 pci_pir_initial_irqs(struct PIR_entry *entry, struct PIR_intpin *intpin,
  314     void *arg)
  315 {
  316         struct pci_link *pci_link;
  317         uint8_t irq, pin;
  318 
  319         pin = intpin - entry->pe_intpin;
  320         pci_link = pci_pir_find_link(intpin->link);
  321         irq = pci_pir_search_irq(entry->pe_bus, entry->pe_device, pin);
  322         if (irq == PCI_INVALID_IRQ || irq == pci_link->pl_irq)
  323                 return;
  324 
  325         /* Don't trust any BIOS IRQs greater than 15. */
  326         if (irq >= NUM_ISA_INTERRUPTS) {
  327                 printf(
  328         "$PIR: Ignoring invalid BIOS IRQ %d from %d.%d.INT%c for link %#x\n",
  329                     irq, entry->pe_bus, entry->pe_device, pin + 'A',
  330                     pci_link->pl_id);
  331                 return;
  332         }
  333 
  334         /*
  335          * If we don't have an IRQ for this link yet, then we trust the
  336          * BIOS, even if it seems invalid from the $PIR entries.
  337          */
  338         if (pci_link->pl_irq == PCI_INVALID_IRQ) {
  339                 if (!pci_pir_valid_irq(pci_link, irq))
  340                         printf(
  341         "$PIR: Using invalid BIOS IRQ %d from %d.%d.INT%c for link %#x\n",
  342                             irq, entry->pe_bus, entry->pe_device, pin + 'A',
  343                             pci_link->pl_id);
  344                 pci_link->pl_irq = irq;
  345                 pci_link->pl_routed = 1;
  346                 return;
  347         }
  348 
  349         /*
  350          * We have an IRQ and it doesn't match the current IRQ for this
  351          * link.  If the new IRQ is invalid, then warn about it and ignore
  352          * it.  If the old IRQ is invalid and the new IRQ is valid, then
  353          * prefer the new IRQ instead.  If both IRQs are valid, then just
  354          * use the first one.  Note that if we ever get into this situation
  355          * we are having to guess which setting the BIOS actually routed.
  356          * Perhaps we should just give up instead.
  357          */
  358         if (!pci_pir_valid_irq(pci_link, irq)) {
  359                 printf(
  360                 "$PIR: BIOS IRQ %d for %d.%d.INT%c is not valid for link %#x\n",
  361                     irq, entry->pe_bus, entry->pe_device, pin + 'A',
  362                     pci_link->pl_id);
  363         } else if (!pci_pir_valid_irq(pci_link, pci_link->pl_irq)) {
  364                 printf(
  365 "$PIR: Preferring valid BIOS IRQ %d from %d.%d.INT%c for link %#x to IRQ %d\n", 
  366                     irq, entry->pe_bus, entry->pe_device, pin + 'A',
  367                     pci_link->pl_id, pci_link->pl_irq);
  368                 pci_link->pl_irq = irq;
  369                 pci_link->pl_routed = 1;
  370         } else
  371                 printf(
  372         "$PIR: BIOS IRQ %d for %d.%d.INT%c does not match link %#x irq %d\n",
  373                     irq, entry->pe_bus, entry->pe_device, pin + 'A',
  374                     pci_link->pl_id, pci_link->pl_irq);
  375 }
  376 
  377 /*
  378  * Parse $PIR to enumerate link devices and attempt to determine their
  379  * initial state.  This could perhaps be cleaner if we had drivers for the
  380  * various interrupt routers as they could read the initial IRQ for each
  381  * link.
  382  */
  383 static void
  384 pci_pir_parse(void)
  385 {
  386         char tunable_buffer[64];
  387         struct pci_link *pci_link;
  388         int i, irq;
  389 
  390         /* Only parse once. */
  391         if (pir_parsed)
  392                 return;
  393         pir_parsed = 1;
  394 
  395         /* Enumerate link devices. */
  396         TAILQ_INIT(&pci_links);
  397         pci_pir_walk_table(pci_pir_create_links, NULL);
  398         if (bootverbose) {
  399                 printf("$PIR: Links after initial probe:\n");
  400                 pci_pir_dump_links();
  401         }
  402 
  403         /*
  404          * Check to see if the BIOS has already routed any of the links by
  405          * checking each device connected to each link to see if it has a
  406          * valid IRQ.
  407          */
  408         pci_pir_walk_table(pci_pir_initial_irqs, NULL);
  409         if (bootverbose) {
  410                 printf("$PIR: Links after initial IRQ discovery:\n");
  411                 pci_pir_dump_links();
  412         }
  413 
  414         /*
  415          * Allow the user to override the IRQ for a given link device.  We
  416          * allow invalid IRQs to be specified but warn about them.  An IRQ
  417          * of 255 or 0 clears any preset IRQ.
  418          */
  419         i = 0;
  420         TAILQ_FOREACH(pci_link, &pci_links, pl_links) {
  421                 snprintf(tunable_buffer, sizeof(tunable_buffer),
  422                     "hw.pci.link.%#x.irq", pci_link->pl_id);
  423                 if (getenv_int(tunable_buffer, &irq) == 0)
  424                         continue;
  425                 if (irq == 0)
  426                         irq = PCI_INVALID_IRQ;
  427                 if (irq != PCI_INVALID_IRQ &&
  428                     !pci_pir_valid_irq(pci_link, irq) && bootverbose)
  429                         printf(
  430                 "$PIR: Warning, IRQ %d for link %#x is not listed as valid\n",
  431                             irq, pci_link->pl_id);
  432                 pci_link->pl_routed = 0;
  433                 pci_link->pl_irq = irq;
  434                 i = 1;
  435         }
  436         if (bootverbose && i) {
  437                 printf("$PIR: Links after tunable overrides:\n");
  438                 pci_pir_dump_links();
  439         }
  440 
  441         /*
  442          * Build initial interrupt weights as well as bitmap of "known-good"
  443          * IRQs that the BIOS has already used for PCI link devices.
  444          */
  445         TAILQ_FOREACH(pci_link, &pci_links, pl_links) {
  446                 if (!PCI_INTERRUPT_VALID(pci_link->pl_irq))
  447                         continue;
  448                 pir_bios_irqs |= 1 << pci_link->pl_irq;
  449                 pir_interrupt_weight[pci_link->pl_irq] +=
  450                     pci_link->pl_references;
  451         }
  452         if (bootverbose) {
  453                 printf("$PIR: IRQs used by BIOS: ");
  454                 pci_print_irqmask(pir_bios_irqs);
  455                 printf("\n");
  456                 printf("$PIR: Interrupt Weights:\n[ ");
  457                 for (i = 0; i < NUM_ISA_INTERRUPTS; i++)
  458                         printf(" %3d", i);
  459                 printf(" ]\n[ ");
  460                 for (i = 0; i < NUM_ISA_INTERRUPTS; i++)
  461                         printf(" %3d", pir_interrupt_weight[i]);
  462                 printf(" ]\n");
  463         }
  464 }
  465 
  466 /*
  467  * Use the PCI BIOS to route an interrupt for a given device.
  468  *
  469  * Input:
  470  * AX = PCIBIOS_ROUTE_INTERRUPT
  471  * BH = bus
  472  * BL = device [7:3] / function [2:0]
  473  * CH = IRQ
  474  * CL = Interrupt Pin (0x0A = A, ... 0x0D = D)
  475  */
  476 static int
  477 pci_pir_biosroute(int bus, int device, int func, int pin, int irq)
  478 {
  479         struct bios_regs args;
  480 
  481         args.eax = PCIBIOS_ROUTE_INTERRUPT;
  482         args.ebx = (bus << 8) | (device << 3) | func;
  483         args.ecx = (irq << 8) | (0xa + pin);
  484         return (bios32(&args, PCIbios.ventry, GSEL(GCODE_SEL, SEL_KPL)));
  485 }
  486 
  487 
  488 /*
  489  * Route a PCI interrupt using a link device from the $PIR.
  490  */
  491 int
  492 pci_pir_route_interrupt(int bus, int device, int func, int pin)
  493 {
  494         struct pci_link_lookup lookup;
  495         struct pci_link *pci_link;
  496         int error, irq;
  497 
  498         if (pci_route_table == NULL)
  499                 return (PCI_INVALID_IRQ);
  500 
  501         /* Lookup link device for this PCI device/pin. */
  502         pci_link = NULL;
  503         lookup.bus = bus;
  504         lookup.device = device;
  505         lookup.pin = pin - 1;
  506         lookup.pci_link_ptr = &pci_link;
  507         pci_pir_walk_table(pci_pir_find_link_handler, &lookup);
  508         if (pci_link == NULL) {
  509                 printf("$PIR: No matching entry for %d.%d.INT%c\n", bus,
  510                     device, pin - 1 + 'A');
  511                 return (PCI_INVALID_IRQ);
  512         }
  513 
  514         /*
  515          * Pick a new interrupt if we don't have one already.  We look
  516          * for an interrupt from several different sets.  First, if
  517          * this link only has one valid IRQ, use that.  Second, we
  518          * check the set of PCI only interrupts from the $PIR.  Third,
  519          * we check the set of known-good interrupts that the BIOS has
  520          * already used.  Lastly, we check the "all possible valid
  521          * IRQs" set.
  522          */
  523         if (!PCI_INTERRUPT_VALID(pci_link->pl_irq)) {
  524                 if (pci_link->pl_irqmask != 0 && powerof2(pci_link->pl_irqmask))
  525                         irq = ffs(pci_link->pl_irqmask) - 1;
  526                 else
  527                         irq = pci_pir_choose_irq(pci_link,
  528                             pci_route_table->pt_header.ph_pci_irqs);
  529                 if (!PCI_INTERRUPT_VALID(irq))
  530                         irq = pci_pir_choose_irq(pci_link, pir_bios_irqs);
  531                 if (!PCI_INTERRUPT_VALID(irq))
  532                         irq = pci_pir_choose_irq(pci_link,
  533                             pci_irq_override_mask);
  534                 if (!PCI_INTERRUPT_VALID(irq)) {
  535                         if (bootverbose)
  536                                 printf(
  537                         "$PIR: Failed to route interrupt for %d:%d INT%c\n",
  538                                     bus, device, pin - 1 + 'A');
  539                         return (PCI_INVALID_IRQ);
  540                 }
  541                 pci_link->pl_irq = irq;
  542         }
  543 
  544         /* Ask the BIOS to route this IRQ if we haven't done so already. */
  545         if (!pci_link->pl_routed) {
  546                 error = pci_pir_biosroute(bus, device, func, pin - 1,
  547                     pci_link->pl_irq);
  548 
  549                 /* Ignore errors when routing a unique interrupt. */
  550                 if (error && !powerof2(pci_link->pl_irqmask)) {
  551                         printf("$PIR: ROUTE_INTERRUPT failed.\n");
  552                         return (PCI_INVALID_IRQ);
  553                 }
  554                 pci_link->pl_routed = 1;
  555 
  556                 /* Ensure the interrupt is set to level/low trigger. */
  557                 KASSERT(pir_device != NULL, ("missing pir device"));
  558                 BUS_CONFIG_INTR(pir_device, pci_link->pl_irq,
  559                     INTR_TRIGGER_LEVEL, INTR_POLARITY_LOW);
  560         }
  561         if (bootverbose)
  562                 printf("$PIR: %d:%d INT%c routed to irq %d\n", bus, device,
  563                     pin - 1 + 'A', pci_link->pl_irq);
  564         return (pci_link->pl_irq);
  565 }
  566 
  567 /*
  568  * Try to pick an interrupt for the specified link from the interrupts
  569  * set in the mask.
  570  */
  571 static int
  572 pci_pir_choose_irq(struct pci_link *pci_link, int irqmask)
  573 {
  574         int i, irq, realmask;
  575 
  576         /* XXX: Need to have a #define of known bad IRQs to also mask out? */
  577         realmask = pci_link->pl_irqmask & irqmask;
  578         if (realmask == 0)
  579                 return (PCI_INVALID_IRQ);
  580 
  581         /* Find IRQ with lowest weight. */
  582         irq = PCI_INVALID_IRQ;
  583         for (i = 0; i < NUM_ISA_INTERRUPTS; i++) {
  584                 if (!(realmask & 1 << i))
  585                         continue;
  586                 if (irq == PCI_INVALID_IRQ ||
  587                     pir_interrupt_weight[i] < pir_interrupt_weight[irq])
  588                         irq = i;
  589         }
  590         if (bootverbose && PCI_INTERRUPT_VALID(irq)) {
  591                 printf("$PIR: Found IRQ %d for link %#x from ", irq,
  592                     pci_link->pl_id);
  593                 pci_print_irqmask(realmask);
  594                 printf("\n");
  595         }
  596         return (irq);
  597 }
  598 
  599 static void
  600 pci_print_irqmask(u_int16_t irqs)
  601 {
  602         int i, first;
  603 
  604         if (irqs == 0) {
  605                 printf("none");
  606                 return;
  607         }
  608         first = 1;
  609         for (i = 0; i < 16; i++, irqs >>= 1)
  610                 if (irqs & 1) {
  611                         if (!first)
  612                                 printf(" ");
  613                         else
  614                                 first = 0;
  615                         printf("%d", i);
  616                 }
  617 }
  618 
  619 /*
  620  * Display link devices.
  621  */
  622 static void
  623 pci_pir_dump_links(void)
  624 {
  625         struct pci_link *pci_link;
  626 
  627         printf("Link  IRQ  Rtd  Ref  IRQs\n");
  628         TAILQ_FOREACH(pci_link, &pci_links, pl_links) {
  629                 printf("%#4x  %3d   %c   %3d  ", pci_link->pl_id,
  630                     pci_link->pl_irq, pci_link->pl_routed ? 'Y' : 'N',
  631                     pci_link->pl_references);
  632                 pci_print_irqmask(pci_link->pl_irqmask);
  633                 printf("\n");
  634         }
  635 }
  636 
  637 /*
  638  * See if any interrupts for a given PCI bus are routed in the PIR.  Don't
  639  * even bother looking if the BIOS doesn't support routing anyways.  If we
  640  * are probing a PCI-PCI bridge, then require_parse will be true and we should
  641  * only succeed if a host-PCI bridge has already attached and parsed the PIR.
  642  */
  643 int
  644 pci_pir_probe(int bus, int require_parse)
  645 {
  646         int i;
  647 
  648         if (pci_route_table == NULL || (require_parse && !pir_parsed))
  649                 return (0);
  650         for (i = 0; i < pci_route_count; i++)
  651                 if (pci_route_table->pt_entry[i].pe_bus == bus)
  652                         return (1);
  653         return (0);
  654 }
  655 
  656 /*
  657  * The driver for the new-bus pseudo device pir0 for the $PIR table.
  658  */
  659 
  660 static int
  661 pir_probe(device_t dev)
  662 {
  663         char buf[64];
  664 
  665         snprintf(buf, sizeof(buf), "PCI Interrupt Routing Table: %d Entries",
  666             pci_route_count);
  667         device_set_desc_copy(dev, buf);
  668         return (0);
  669 }
  670 
  671 static int
  672 pir_attach(device_t dev)
  673 {
  674 
  675         pci_pir_parse();
  676         KASSERT(pir_device == NULL, ("Multiple pir devices"));
  677         pir_device = dev;
  678         return (0);
  679 }
  680 
  681 static void
  682 pir_resume_find_device(struct PIR_entry *entry, struct PIR_intpin *intpin,
  683     void *arg)
  684 {
  685         struct pci_dev_lookup *pd;
  686 
  687         pd = (struct pci_dev_lookup *)arg;
  688         if (intpin->link != pd->link || pd->bus != -1)
  689                 return;
  690         pd->bus = entry->pe_bus;
  691         pd->device = entry->pe_device;
  692         pd->pin = intpin - entry->pe_intpin;
  693 }
  694 
  695 static int
  696 pir_resume(device_t dev)
  697 {
  698         struct pci_dev_lookup pd;
  699         struct pci_link *pci_link;
  700         int error;
  701 
  702         /* Ask the BIOS to re-route each link that was already routed. */
  703         TAILQ_FOREACH(pci_link, &pci_links, pl_links) {
  704                 if (!PCI_INTERRUPT_VALID(pci_link->pl_irq)) {
  705                         KASSERT(!pci_link->pl_routed,
  706                             ("link %#x is routed but has invalid PCI IRQ",
  707                             pci_link->pl_id));
  708                         continue;
  709                 }
  710                 if (pci_link->pl_routed) {
  711                         pd.bus = -1;
  712                         pd.link = pci_link->pl_id;
  713                         pci_pir_walk_table(pir_resume_find_device, &pd);
  714                         KASSERT(pd.bus != -1,
  715                 ("did not find matching entry for link %#x in the $PIR table",
  716                             pci_link->pl_id));
  717                         if (bootverbose)
  718                                 device_printf(dev,
  719                             "Using %d.%d.INT%c to route link %#x to IRQ %d\n",
  720                                     pd.bus, pd.device, pd.pin + 'A',
  721                                     pci_link->pl_id, pci_link->pl_irq);
  722                         error = pci_pir_biosroute(pd.bus, pd.device, 0, pd.pin,
  723                             pci_link->pl_irq);
  724                         if (error)
  725                                 device_printf(dev,
  726                             "ROUTE_INTERRUPT on resume for link %#x failed.\n",
  727                                     pci_link->pl_id);
  728                 }
  729         }
  730         return (0);
  731 }
  732 
  733 static device_method_t pir_methods[] = {
  734         /* Device interface */
  735         DEVMETHOD(device_probe,         pir_probe),
  736         DEVMETHOD(device_attach,        pir_attach),
  737         DEVMETHOD(device_resume,        pir_resume),
  738 
  739         { 0, 0 }
  740 };
  741 
  742 static driver_t pir_driver = {
  743         "pir",
  744         pir_methods,
  745         1,
  746 };
  747 
  748 static devclass_t pir_devclass;
  749 
  750 DRIVER_MODULE(pir, legacy, pir_driver, pir_devclass, 0, 0);

Cache object: 184d6a8a49a455e6569f4001d17eaae5


[ 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.