kernel: Use NULL for DRIVER_MODULE()'s evh & arg (which are pointers).
[dragonfly.git] / sys / bus / pci / i386 / pci_pir.c
CommitLineData
4d28e78f
SZ
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.
83c1faaa
SW
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 $
4d28e78f
SZ
30 */
31
4d28e78f
SZ
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 */
55struct 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
64struct pci_link_lookup {
65 struct pci_link **pci_link_ptr;
66 int bus;
67 int device;
68 int pin;
69};
70
71struct pci_dev_lookup {
72 uint8_t link;
73 int bus;
74 int device;
75 int pin;
76};
77
78typedef void pir_entry_handler(struct PIR_entry *entry,
79 struct PIR_intpin* intpin, void *arg);
80
81static void pci_print_irqmask(u_int16_t irqs);
82static int pci_pir_biosroute(int bus, int device, int func, int pin,
83 int irq);
84static int pci_pir_choose_irq(struct pci_link *pci_link, int irqmask);
85static void pci_pir_create_links(struct PIR_entry *entry,
86 struct PIR_intpin *intpin, void *arg);
87static void pci_pir_dump_links(void);
88static struct pci_link *pci_pir_find_link(uint8_t link_id);
89static void pci_pir_find_link_handler(struct PIR_entry *entry,
90 struct PIR_intpin *intpin, void *arg);
91static void pci_pir_initial_irqs(struct PIR_entry *entry,
92 struct PIR_intpin *intpin, void *arg);
93static void pci_pir_parse(void);
94static uint8_t pci_pir_search_irq(int bus, int device, int pin);
95static int pci_pir_valid_irq(struct pci_link *pci_link, int irq);
96static void pci_pir_walk_table(pir_entry_handler *handler, void *arg);
97
98static MALLOC_DEFINE(M_PIR, "$PIR", "$PIR structures");
99
100static struct PIR_table *pci_route_table;
101static device_t pir_device;
102static int pci_route_count, pir_bios_irqs, pir_parsed;
103static TAILQ_HEAD(, pci_link) pci_links;
104static int pir_interrupt_weight[NUM_ISA_INTERRUPTS];
105
106/* sysctl vars */
107SYSCTL_DECL(_hw_pci);
108
109/* XXX this likely should live in a header file */
4d28e78f
SZ
110/* IRQs 3, 4, 5, 6, 7, 9, 10, 11, 12, 14, 15 */
111#define PCI_IRQ_OVERRIDE_MASK 0xdef8
4d28e78f
SZ
112
113static uint32_t pci_irq_override_mask = PCI_IRQ_OVERRIDE_MASK;
114TUNABLE_INT("hw.pci.irq_override_mask", &pci_irq_override_mask);
115SYSCTL_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 */
127void
128pci_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];
e71fdd32
SZ
154 if (ck != 0) {
155 kprintf("$PIR: checksum failed!\n");
4d28e78f 156 return;
e71fdd32 157 }
4d28e78f
SZ
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 */
169static struct pci_link *
170pci_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 */
184static void
185pci_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 */
200static int
201pci_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 */
214static void
215pci_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
230static void
231pci_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 */
263static uint8_t
264pci_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 */
306static void
307pci_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 */
377static void
378pci_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 */
470static int
471pci_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 */
485int
486pci_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"));
05065648 552 BUS_CONFIG_INTR(pir_device, pir_device, pci_link->pl_irq,
4d28e78f
SZ
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 */
565static int
566pci_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
593static void
594pci_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 */
616static void
617pci_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 */
637int
638pci_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
653static int
654pir_probe(device_t dev)
655{
656 char buf[64];
09e7d9f3 657
4d28e78f
SZ
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
664static int
665pir_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
674static void
675pir_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
688static int
689pir_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
726static 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
735static driver_t pir_driver = {
736 "pir",
737 pir_methods,
738 1,
739};
740
741static devclass_t pir_devclass;
742
aa2b9d05 743DRIVER_MODULE(pir, legacy, pir_driver, pir_devclass, NULL, NULL);