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