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