1
2
3
4
5
6
7#include <linux/types.h>
8#include <linux/kernel.h>
9#include <linux/pci.h>
10#include <linux/init.h>
11#include <linux/interrupt.h>
12#include <linux/dmi.h>
13#include <linux/io.h>
14#include <linux/smp.h>
15#include <asm/io_apic.h>
16#include <linux/irq.h>
17#include <linux/acpi.h>
18#include <asm/pci_x86.h>
19
20#define PIRQ_SIGNATURE (('$' << 0) + ('P' << 8) + ('I' << 16) + ('R' << 24))
21#define PIRQ_VERSION 0x0100
22
23static int broken_hp_bios_irq9;
24static int acer_tm360_irqrouting;
25
26static struct irq_routing_table *pirq_table;
27
28static int pirq_enable_irq(struct pci_dev *dev);
29static void pirq_disable_irq(struct pci_dev *dev);
30
31
32
33
34
35
36unsigned int pcibios_irq_mask = 0xfff8;
37
38static int pirq_penalty[16] = {
39 1000000, 1000000, 1000000, 1000, 1000, 0, 1000, 1000,
40 0, 0, 0, 0, 1000, 100000, 100000, 100000
41};
42
43struct irq_router {
44 char *name;
45 u16 vendor, device;
46 int (*get)(struct pci_dev *router, struct pci_dev *dev, int pirq);
47 int (*set)(struct pci_dev *router, struct pci_dev *dev, int pirq,
48 int new);
49};
50
51struct irq_router_handler {
52 u16 vendor;
53 int (*probe)(struct irq_router *r, struct pci_dev *router, u16 device);
54};
55
56int (*pcibios_enable_irq)(struct pci_dev *dev) = pirq_enable_irq;
57void (*pcibios_disable_irq)(struct pci_dev *dev) = pirq_disable_irq;
58
59
60
61
62
63
64static inline struct irq_routing_table *pirq_check_routing_table(u8 *addr)
65{
66 struct irq_routing_table *rt;
67 int i;
68 u8 sum;
69
70 rt = (struct irq_routing_table *) addr;
71 if (rt->signature != PIRQ_SIGNATURE ||
72 rt->version != PIRQ_VERSION ||
73 rt->size % 16 ||
74 rt->size < sizeof(struct irq_routing_table))
75 return NULL;
76 sum = 0;
77 for (i = 0; i < rt->size; i++)
78 sum += addr[i];
79 if (!sum) {
80 DBG(KERN_DEBUG "PCI: Interrupt Routing Table found at 0x%p\n",
81 rt);
82 return rt;
83 }
84 return NULL;
85}
86
87
88
89
90
91
92
93static struct irq_routing_table * __init pirq_find_routing_table(void)
94{
95 u8 *addr;
96 struct irq_routing_table *rt;
97
98 if (pirq_table_addr) {
99 rt = pirq_check_routing_table((u8 *) __va(pirq_table_addr));
100 if (rt)
101 return rt;
102 printk(KERN_WARNING "PCI: PIRQ table NOT found at pirqaddr\n");
103 }
104 for (addr = (u8 *) __va(0xf0000); addr < (u8 *) __va(0x100000); addr += 16) {
105 rt = pirq_check_routing_table(addr);
106 if (rt)
107 return rt;
108 }
109 return NULL;
110}
111
112
113
114
115
116
117
118static void __init pirq_peer_trick(void)
119{
120 struct irq_routing_table *rt = pirq_table;
121 u8 busmap[256];
122 int i;
123 struct irq_info *e;
124
125 memset(busmap, 0, sizeof(busmap));
126 for (i = 0; i < (rt->size - sizeof(struct irq_routing_table)) / sizeof(struct irq_info); i++) {
127 e = &rt->slots[i];
128#ifdef DEBUG
129 {
130 int j;
131 DBG(KERN_DEBUG "%02x:%02x slot=%02x", e->bus, e->devfn/8, e->slot);
132 for (j = 0; j < 4; j++)
133 DBG(" %d:%02x/%04x", j, e->irq[j].link, e->irq[j].bitmap);
134 DBG("\n");
135 }
136#endif
137 busmap[e->bus] = 1;
138 }
139 for (i = 1; i < 256; i++) {
140 if (!busmap[i] || pci_find_bus(0, i))
141 continue;
142 pcibios_scan_root(i);
143 }
144 pcibios_last_bus = -1;
145}
146
147
148
149
150
151
152void elcr_set_level_irq(unsigned int irq)
153{
154 unsigned char mask = 1 << (irq & 7);
155 unsigned int port = 0x4d0 + (irq >> 3);
156 unsigned char val;
157 static u16 elcr_irq_mask;
158
159 if (irq >= 16 || (1 << irq) & elcr_irq_mask)
160 return;
161
162 elcr_irq_mask |= (1 << irq);
163 printk(KERN_DEBUG "PCI: setting IRQ %u as level-triggered\n", irq);
164 val = inb(port);
165 if (!(val & mask)) {
166 DBG(KERN_DEBUG " -> edge");
167 outb(val | mask, port);
168 }
169}
170
171
172
173
174
175static unsigned int read_config_nybble(struct pci_dev *router, unsigned offset, unsigned nr)
176{
177 u8 x;
178 unsigned reg = offset + (nr >> 1);
179
180 pci_read_config_byte(router, reg, &x);
181 return (nr & 1) ? (x >> 4) : (x & 0xf);
182}
183
184static void write_config_nybble(struct pci_dev *router, unsigned offset,
185 unsigned nr, unsigned int val)
186{
187 u8 x;
188 unsigned reg = offset + (nr >> 1);
189
190 pci_read_config_byte(router, reg, &x);
191 x = (nr & 1) ? ((x & 0x0f) | (val << 4)) : ((x & 0xf0) | val);
192 pci_write_config_byte(router, reg, x);
193}
194
195
196
197
198
199
200static int pirq_ali_get(struct pci_dev *router, struct pci_dev *dev, int pirq)
201{
202 static const unsigned char irqmap[16] = { 0, 9, 3, 10, 4, 5, 7, 6, 1, 11, 0, 12, 0, 14, 0, 15 };
203
204 WARN_ON_ONCE(pirq > 16);
205 return irqmap[read_config_nybble(router, 0x48, pirq-1)];
206}
207
208static int pirq_ali_set(struct pci_dev *router, struct pci_dev *dev, int pirq, int irq)
209{
210 static const unsigned char irqmap[16] = { 0, 8, 0, 2, 4, 5, 7, 6, 0, 1, 3, 9, 11, 0, 13, 15 };
211 unsigned int val = irqmap[irq];
212
213 WARN_ON_ONCE(pirq > 16);
214 if (val) {
215 write_config_nybble(router, 0x48, pirq-1, val);
216 return 1;
217 }
218 return 0;
219}
220
221
222
223
224
225static int pirq_piix_get(struct pci_dev *router, struct pci_dev *dev, int pirq)
226{
227 u8 x;
228
229 pci_read_config_byte(router, pirq, &x);
230 return (x < 16) ? x : 0;
231}
232
233static int pirq_piix_set(struct pci_dev *router, struct pci_dev *dev, int pirq, int irq)
234{
235 pci_write_config_byte(router, pirq, irq);
236 return 1;
237}
238
239
240
241
242
243
244static int pirq_via_get(struct pci_dev *router, struct pci_dev *dev, int pirq)
245{
246 return read_config_nybble(router, 0x55, pirq == 4 ? 5 : pirq);
247}
248
249static int pirq_via_set(struct pci_dev *router, struct pci_dev *dev, int pirq, int irq)
250{
251 write_config_nybble(router, 0x55, pirq == 4 ? 5 : pirq, irq);
252 return 1;
253}
254
255
256
257
258
259
260static int pirq_via586_get(struct pci_dev *router, struct pci_dev *dev, int pirq)
261{
262 static const unsigned int pirqmap[5] = { 3, 2, 5, 1, 1 };
263
264 WARN_ON_ONCE(pirq > 5);
265 return read_config_nybble(router, 0x55, pirqmap[pirq-1]);
266}
267
268static int pirq_via586_set(struct pci_dev *router, struct pci_dev *dev, int pirq, int irq)
269{
270 static const unsigned int pirqmap[5] = { 3, 2, 5, 1, 1 };
271
272 WARN_ON_ONCE(pirq > 5);
273 write_config_nybble(router, 0x55, pirqmap[pirq-1], irq);
274 return 1;
275}
276
277
278
279
280
281
282static int pirq_ite_get(struct pci_dev *router, struct pci_dev *dev, int pirq)
283{
284 static const unsigned char pirqmap[4] = { 1, 0, 2, 3 };
285
286 WARN_ON_ONCE(pirq > 4);
287 return read_config_nybble(router, 0x43, pirqmap[pirq-1]);
288}
289
290static int pirq_ite_set(struct pci_dev *router, struct pci_dev *dev, int pirq, int irq)
291{
292 static const unsigned char pirqmap[4] = { 1, 0, 2, 3 };
293
294 WARN_ON_ONCE(pirq > 4);
295 write_config_nybble(router, 0x43, pirqmap[pirq-1], irq);
296 return 1;
297}
298
299
300
301
302
303static int pirq_opti_get(struct pci_dev *router, struct pci_dev *dev, int pirq)
304{
305 return read_config_nybble(router, 0xb8, pirq >> 4);
306}
307
308static int pirq_opti_set(struct pci_dev *router, struct pci_dev *dev, int pirq, int irq)
309{
310 write_config_nybble(router, 0xb8, pirq >> 4, irq);
311 return 1;
312}
313
314
315
316
317
318
319static int pirq_cyrix_get(struct pci_dev *router, struct pci_dev *dev, int pirq)
320{
321 return read_config_nybble(router, 0x5C, (pirq-1)^1);
322}
323
324static int pirq_cyrix_set(struct pci_dev *router, struct pci_dev *dev, int pirq, int irq)
325{
326 write_config_nybble(router, 0x5C, (pirq-1)^1, irq);
327 return 1;
328}
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391#define PIRQ_SIS_IRQ_MASK 0x0f
392#define PIRQ_SIS_IRQ_DISABLE 0x80
393#define PIRQ_SIS_USB_ENABLE 0x40
394
395static int pirq_sis_get(struct pci_dev *router, struct pci_dev *dev, int pirq)
396{
397 u8 x;
398 int reg;
399
400 reg = pirq;
401 if (reg >= 0x01 && reg <= 0x04)
402 reg += 0x40;
403 pci_read_config_byte(router, reg, &x);
404 return (x & PIRQ_SIS_IRQ_DISABLE) ? 0 : (x & PIRQ_SIS_IRQ_MASK);
405}
406
407static int pirq_sis_set(struct pci_dev *router, struct pci_dev *dev, int pirq, int irq)
408{
409 u8 x;
410 int reg;
411
412 reg = pirq;
413 if (reg >= 0x01 && reg <= 0x04)
414 reg += 0x40;
415 pci_read_config_byte(router, reg, &x);
416 x &= ~(PIRQ_SIS_IRQ_MASK | PIRQ_SIS_IRQ_DISABLE);
417 x |= irq ? irq: PIRQ_SIS_IRQ_DISABLE;
418 pci_write_config_byte(router, reg, x);
419 return 1;
420}
421
422
423
424
425
426
427
428
429
430
431static int pirq_vlsi_get(struct pci_dev *router, struct pci_dev *dev, int pirq)
432{
433 WARN_ON_ONCE(pirq >= 9);
434 if (pirq > 8) {
435 dev_info(&dev->dev, "VLSI router PIRQ escape (%d)\n", pirq);
436 return 0;
437 }
438 return read_config_nybble(router, 0x74, pirq-1);
439}
440
441static int pirq_vlsi_set(struct pci_dev *router, struct pci_dev *dev, int pirq, int irq)
442{
443 WARN_ON_ONCE(pirq >= 9);
444 if (pirq > 8) {
445 dev_info(&dev->dev, "VLSI router PIRQ escape (%d)\n", pirq);
446 return 0;
447 }
448 write_config_nybble(router, 0x74, pirq-1, irq);
449 return 1;
450}
451
452
453
454
455
456
457
458
459
460
461
462
463static int pirq_serverworks_get(struct pci_dev *router, struct pci_dev *dev, int pirq)
464{
465 outb(pirq, 0xc00);
466 return inb(0xc01) & 0xf;
467}
468
469static int pirq_serverworks_set(struct pci_dev *router, struct pci_dev *dev,
470 int pirq, int irq)
471{
472 outb(pirq, 0xc00);
473 outb(irq, 0xc01);
474 return 1;
475}
476
477
478
479
480
481
482
483
484
485static int pirq_amd756_get(struct pci_dev *router, struct pci_dev *dev, int pirq)
486{
487 u8 irq;
488 irq = 0;
489 if (pirq <= 4)
490 irq = read_config_nybble(router, 0x56, pirq - 1);
491 dev_info(&dev->dev,
492 "AMD756: dev [%04x:%04x], router PIRQ %d get IRQ %d\n",
493 dev->vendor, dev->device, pirq, irq);
494 return irq;
495}
496
497static int pirq_amd756_set(struct pci_dev *router, struct pci_dev *dev, int pirq, int irq)
498{
499 dev_info(&dev->dev,
500 "AMD756: dev [%04x:%04x], router PIRQ %d set IRQ %d\n",
501 dev->vendor, dev->device, pirq, irq);
502 if (pirq <= 4)
503 write_config_nybble(router, 0x56, pirq - 1, irq);
504 return 1;
505}
506
507
508
509
510static int pirq_pico_get(struct pci_dev *router, struct pci_dev *dev, int pirq)
511{
512 outb(0x10 + ((pirq - 1) >> 1), 0x24);
513 return ((pirq - 1) & 1) ? (inb(0x26) >> 4) : (inb(0x26) & 0xf);
514}
515
516static int pirq_pico_set(struct pci_dev *router, struct pci_dev *dev, int pirq,
517 int irq)
518{
519 unsigned int x;
520 outb(0x10 + ((pirq - 1) >> 1), 0x24);
521 x = inb(0x26);
522 x = ((pirq - 1) & 1) ? ((x & 0x0f) | (irq << 4)) : ((x & 0xf0) | (irq));
523 outb(x, 0x26);
524 return 1;
525}
526
527#ifdef CONFIG_PCI_BIOS
528
529static int pirq_bios_set(struct pci_dev *router, struct pci_dev *dev, int pirq, int irq)
530{
531 struct pci_dev *bridge;
532 int pin = pci_get_interrupt_pin(dev, &bridge);
533 return pcibios_set_irq_routing(bridge, pin - 1, irq);
534}
535
536#endif
537
538static __init int intel_router_probe(struct irq_router *r, struct pci_dev *router, u16 device)
539{
540 static struct pci_device_id __initdata pirq_440gx[] = {
541 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82443GX_0) },
542 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82443GX_2) },
543 { },
544 };
545
546
547 if (pci_dev_present(pirq_440gx))
548 return 0;
549
550 switch (device) {
551 case PCI_DEVICE_ID_INTEL_82371FB_0:
552 case PCI_DEVICE_ID_INTEL_82371SB_0:
553 case PCI_DEVICE_ID_INTEL_82371AB_0:
554 case PCI_DEVICE_ID_INTEL_82371MX:
555 case PCI_DEVICE_ID_INTEL_82443MX_0:
556 case PCI_DEVICE_ID_INTEL_82801AA_0:
557 case PCI_DEVICE_ID_INTEL_82801AB_0:
558 case PCI_DEVICE_ID_INTEL_82801BA_0:
559 case PCI_DEVICE_ID_INTEL_82801BA_10:
560 case PCI_DEVICE_ID_INTEL_82801CA_0:
561 case PCI_DEVICE_ID_INTEL_82801CA_12:
562 case PCI_DEVICE_ID_INTEL_82801DB_0:
563 case PCI_DEVICE_ID_INTEL_82801E_0:
564 case PCI_DEVICE_ID_INTEL_82801EB_0:
565 case PCI_DEVICE_ID_INTEL_ESB_1:
566 case PCI_DEVICE_ID_INTEL_ICH6_0:
567 case PCI_DEVICE_ID_INTEL_ICH6_1:
568 case PCI_DEVICE_ID_INTEL_ICH7_0:
569 case PCI_DEVICE_ID_INTEL_ICH7_1:
570 case PCI_DEVICE_ID_INTEL_ICH7_30:
571 case PCI_DEVICE_ID_INTEL_ICH7_31:
572 case PCI_DEVICE_ID_INTEL_TGP_LPC:
573 case PCI_DEVICE_ID_INTEL_ESB2_0:
574 case PCI_DEVICE_ID_INTEL_ICH8_0:
575 case PCI_DEVICE_ID_INTEL_ICH8_1:
576 case PCI_DEVICE_ID_INTEL_ICH8_2:
577 case PCI_DEVICE_ID_INTEL_ICH8_3:
578 case PCI_DEVICE_ID_INTEL_ICH8_4:
579 case PCI_DEVICE_ID_INTEL_ICH9_0:
580 case PCI_DEVICE_ID_INTEL_ICH9_1:
581 case PCI_DEVICE_ID_INTEL_ICH9_2:
582 case PCI_DEVICE_ID_INTEL_ICH9_3:
583 case PCI_DEVICE_ID_INTEL_ICH9_4:
584 case PCI_DEVICE_ID_INTEL_ICH9_5:
585 case PCI_DEVICE_ID_INTEL_EP80579_0:
586 case PCI_DEVICE_ID_INTEL_ICH10_0:
587 case PCI_DEVICE_ID_INTEL_ICH10_1:
588 case PCI_DEVICE_ID_INTEL_ICH10_2:
589 case PCI_DEVICE_ID_INTEL_ICH10_3:
590 case PCI_DEVICE_ID_INTEL_PATSBURG_LPC_0:
591 case PCI_DEVICE_ID_INTEL_PATSBURG_LPC_1:
592 r->name = "PIIX/ICH";
593 r->get = pirq_piix_get;
594 r->set = pirq_piix_set;
595 return 1;
596 }
597
598 if ((device >= PCI_DEVICE_ID_INTEL_5_3400_SERIES_LPC_MIN &&
599 device <= PCI_DEVICE_ID_INTEL_5_3400_SERIES_LPC_MAX)
600 || (device >= PCI_DEVICE_ID_INTEL_COUGARPOINT_LPC_MIN &&
601 device <= PCI_DEVICE_ID_INTEL_COUGARPOINT_LPC_MAX)
602 || (device >= PCI_DEVICE_ID_INTEL_DH89XXCC_LPC_MIN &&
603 device <= PCI_DEVICE_ID_INTEL_DH89XXCC_LPC_MAX)
604 || (device >= PCI_DEVICE_ID_INTEL_PANTHERPOINT_LPC_MIN &&
605 device <= PCI_DEVICE_ID_INTEL_PANTHERPOINT_LPC_MAX)) {
606 r->name = "PIIX/ICH";
607 r->get = pirq_piix_get;
608 r->set = pirq_piix_set;
609 return 1;
610 }
611
612 return 0;
613}
614
615static __init int via_router_probe(struct irq_router *r,
616 struct pci_dev *router, u16 device)
617{
618
619
620
621
622
623 if (device == PCI_DEVICE_ID_VIA_82C586_0) {
624 switch (router->device) {
625 case PCI_DEVICE_ID_VIA_82C686:
626
627
628
629
630 device = PCI_DEVICE_ID_VIA_82C686;
631 break;
632 case PCI_DEVICE_ID_VIA_8235:
633
634
635
636
637 device = PCI_DEVICE_ID_VIA_8235;
638 break;
639 case PCI_DEVICE_ID_VIA_8237:
640
641
642
643
644 device = PCI_DEVICE_ID_VIA_8237;
645 break;
646 }
647 }
648
649 switch (device) {
650 case PCI_DEVICE_ID_VIA_82C586_0:
651 r->name = "VIA";
652 r->get = pirq_via586_get;
653 r->set = pirq_via586_set;
654 return 1;
655 case PCI_DEVICE_ID_VIA_82C596:
656 case PCI_DEVICE_ID_VIA_82C686:
657 case PCI_DEVICE_ID_VIA_8231:
658 case PCI_DEVICE_ID_VIA_8233A:
659 case PCI_DEVICE_ID_VIA_8235:
660 case PCI_DEVICE_ID_VIA_8237:
661
662 r->name = "VIA";
663 r->get = pirq_via_get;
664 r->set = pirq_via_set;
665 return 1;
666 }
667 return 0;
668}
669
670static __init int vlsi_router_probe(struct irq_router *r, struct pci_dev *router, u16 device)
671{
672 switch (device) {
673 case PCI_DEVICE_ID_VLSI_82C534:
674 r->name = "VLSI 82C534";
675 r->get = pirq_vlsi_get;
676 r->set = pirq_vlsi_set;
677 return 1;
678 }
679 return 0;
680}
681
682
683static __init int serverworks_router_probe(struct irq_router *r,
684 struct pci_dev *router, u16 device)
685{
686 switch (device) {
687 case PCI_DEVICE_ID_SERVERWORKS_OSB4:
688 case PCI_DEVICE_ID_SERVERWORKS_CSB5:
689 r->name = "ServerWorks";
690 r->get = pirq_serverworks_get;
691 r->set = pirq_serverworks_set;
692 return 1;
693 }
694 return 0;
695}
696
697static __init int sis_router_probe(struct irq_router *r, struct pci_dev *router, u16 device)
698{
699 if (device != PCI_DEVICE_ID_SI_503)
700 return 0;
701
702 r->name = "SIS";
703 r->get = pirq_sis_get;
704 r->set = pirq_sis_set;
705 return 1;
706}
707
708static __init int cyrix_router_probe(struct irq_router *r, struct pci_dev *router, u16 device)
709{
710 switch (device) {
711 case PCI_DEVICE_ID_CYRIX_5520:
712 r->name = "NatSemi";
713 r->get = pirq_cyrix_get;
714 r->set = pirq_cyrix_set;
715 return 1;
716 }
717 return 0;
718}
719
720static __init int opti_router_probe(struct irq_router *r, struct pci_dev *router, u16 device)
721{
722 switch (device) {
723 case PCI_DEVICE_ID_OPTI_82C700:
724 r->name = "OPTI";
725 r->get = pirq_opti_get;
726 r->set = pirq_opti_set;
727 return 1;
728 }
729 return 0;
730}
731
732static __init int ite_router_probe(struct irq_router *r, struct pci_dev *router, u16 device)
733{
734 switch (device) {
735 case PCI_DEVICE_ID_ITE_IT8330G_0:
736 r->name = "ITE";
737 r->get = pirq_ite_get;
738 r->set = pirq_ite_set;
739 return 1;
740 }
741 return 0;
742}
743
744static __init int ali_router_probe(struct irq_router *r, struct pci_dev *router, u16 device)
745{
746 switch (device) {
747 case PCI_DEVICE_ID_AL_M1533:
748 case PCI_DEVICE_ID_AL_M1563:
749 r->name = "ALI";
750 r->get = pirq_ali_get;
751 r->set = pirq_ali_set;
752 return 1;
753 }
754 return 0;
755}
756
757static __init int amd_router_probe(struct irq_router *r, struct pci_dev *router, u16 device)
758{
759 switch (device) {
760 case PCI_DEVICE_ID_AMD_VIPER_740B:
761 r->name = "AMD756";
762 break;
763 case PCI_DEVICE_ID_AMD_VIPER_7413:
764 r->name = "AMD766";
765 break;
766 case PCI_DEVICE_ID_AMD_VIPER_7443:
767 r->name = "AMD768";
768 break;
769 default:
770 return 0;
771 }
772 r->get = pirq_amd756_get;
773 r->set = pirq_amd756_set;
774 return 1;
775}
776
777static __init int pico_router_probe(struct irq_router *r, struct pci_dev *router, u16 device)
778{
779 switch (device) {
780 case PCI_DEVICE_ID_PICOPOWER_PT86C523:
781 r->name = "PicoPower PT86C523";
782 r->get = pirq_pico_get;
783 r->set = pirq_pico_set;
784 return 1;
785
786 case PCI_DEVICE_ID_PICOPOWER_PT86C523BBP:
787 r->name = "PicoPower PT86C523 rev. BB+";
788 r->get = pirq_pico_get;
789 r->set = pirq_pico_set;
790 return 1;
791 }
792 return 0;
793}
794
795static __initdata struct irq_router_handler pirq_routers[] = {
796 { PCI_VENDOR_ID_INTEL, intel_router_probe },
797 { PCI_VENDOR_ID_AL, ali_router_probe },
798 { PCI_VENDOR_ID_ITE, ite_router_probe },
799 { PCI_VENDOR_ID_VIA, via_router_probe },
800 { PCI_VENDOR_ID_OPTI, opti_router_probe },
801 { PCI_VENDOR_ID_SI, sis_router_probe },
802 { PCI_VENDOR_ID_CYRIX, cyrix_router_probe },
803 { PCI_VENDOR_ID_VLSI, vlsi_router_probe },
804 { PCI_VENDOR_ID_SERVERWORKS, serverworks_router_probe },
805 { PCI_VENDOR_ID_AMD, amd_router_probe },
806 { PCI_VENDOR_ID_PICOPOWER, pico_router_probe },
807
808 { 0, NULL }
809};
810static struct irq_router pirq_router;
811static struct pci_dev *pirq_router_dev;
812
813
814
815
816
817
818
819static void __init pirq_find_router(struct irq_router *r)
820{
821 struct irq_routing_table *rt = pirq_table;
822 struct irq_router_handler *h;
823
824#ifdef CONFIG_PCI_BIOS
825 if (!rt->signature) {
826 printk(KERN_INFO "PCI: Using BIOS for IRQ routing\n");
827 r->set = pirq_bios_set;
828 r->name = "BIOS";
829 return;
830 }
831#endif
832
833
834 r->name = "default";
835 r->get = NULL;
836 r->set = NULL;
837
838 DBG(KERN_DEBUG "PCI: Attempting to find IRQ router for [%04x:%04x]\n",
839 rt->rtr_vendor, rt->rtr_device);
840
841 pirq_router_dev = pci_get_bus_and_slot(rt->rtr_bus, rt->rtr_devfn);
842 if (!pirq_router_dev) {
843 DBG(KERN_DEBUG "PCI: Interrupt router not found at "
844 "%02x:%02x\n", rt->rtr_bus, rt->rtr_devfn);
845 return;
846 }
847
848 for (h = pirq_routers; h->vendor; h++) {
849
850 if (rt->rtr_vendor == h->vendor &&
851 h->probe(r, pirq_router_dev, rt->rtr_device))
852 break;
853
854 if (pirq_router_dev->vendor == h->vendor &&
855 h->probe(r, pirq_router_dev, pirq_router_dev->device))
856 break;
857 }
858 dev_info(&pirq_router_dev->dev, "%s IRQ router [%04x:%04x]\n",
859 pirq_router.name,
860 pirq_router_dev->vendor, pirq_router_dev->device);
861
862
863}
864
865static struct irq_info *pirq_get_info(struct pci_dev *dev)
866{
867 struct irq_routing_table *rt = pirq_table;
868 int entries = (rt->size - sizeof(struct irq_routing_table)) /
869 sizeof(struct irq_info);
870 struct irq_info *info;
871
872 for (info = rt->slots; entries--; info++)
873 if (info->bus == dev->bus->number &&
874 PCI_SLOT(info->devfn) == PCI_SLOT(dev->devfn))
875 return info;
876 return NULL;
877}
878
879static int pcibios_lookup_irq(struct pci_dev *dev, int assign)
880{
881 u8 pin;
882 struct irq_info *info;
883 int i, pirq, newirq;
884 int irq = 0;
885 u32 mask;
886 struct irq_router *r = &pirq_router;
887 struct pci_dev *dev2 = NULL;
888 char *msg = NULL;
889
890
891 pci_read_config_byte(dev, PCI_INTERRUPT_PIN, &pin);
892 if (!pin) {
893 dev_dbg(&dev->dev, "no interrupt pin\n");
894 return 0;
895 }
896
897 if (io_apic_assign_pci_irqs)
898 return 0;
899
900
901
902 if (!pirq_table)
903 return 0;
904
905 info = pirq_get_info(dev);
906 if (!info) {
907 dev_dbg(&dev->dev, "PCI INT %c not found in routing table\n",
908 'A' + pin - 1);
909 return 0;
910 }
911 pirq = info->irq[pin - 1].link;
912 mask = info->irq[pin - 1].bitmap;
913 if (!pirq) {
914 dev_dbg(&dev->dev, "PCI INT %c not routed\n", 'A' + pin - 1);
915 return 0;
916 }
917 dev_dbg(&dev->dev, "PCI INT %c -> PIRQ %02x, mask %04x, excl %04x",
918 'A' + pin - 1, pirq, mask, pirq_table->exclusive_irqs);
919 mask &= pcibios_irq_mask;
920
921
922
923
924 if (broken_hp_bios_irq9 && pirq == 0x59 && dev->irq == 9) {
925 dev->irq = 11;
926 pci_write_config_byte(dev, PCI_INTERRUPT_LINE, 11);
927 r->set(pirq_router_dev, dev, pirq, 11);
928 }
929
930
931 if (acer_tm360_irqrouting && dev->irq == 11 &&
932 dev->vendor == PCI_VENDOR_ID_O2) {
933 pirq = 0x68;
934 mask = 0x400;
935 dev->irq = r->get(pirq_router_dev, dev, pirq);
936 pci_write_config_byte(dev, PCI_INTERRUPT_LINE, dev->irq);
937 }
938
939
940
941
942
943 newirq = dev->irq;
944 if (newirq && !((1 << newirq) & mask)) {
945 if (pci_probe & PCI_USE_PIRQ_MASK)
946 newirq = 0;
947 else
948 dev_warn(&dev->dev, "IRQ %d doesn't match PIRQ mask "
949 "%#x; try pci=usepirqmask\n", newirq, mask);
950 }
951 if (!newirq && assign) {
952 for (i = 0; i < 16; i++) {
953 if (!(mask & (1 << i)))
954 continue;
955 if (pirq_penalty[i] < pirq_penalty[newirq] &&
956 can_request_irq(i, IRQF_SHARED))
957 newirq = i;
958 }
959 }
960 dev_dbg(&dev->dev, "PCI INT %c -> newirq %d", 'A' + pin - 1, newirq);
961
962
963 if ((pirq & 0xf0) == 0xf0) {
964 irq = pirq & 0xf;
965 msg = "hardcoded";
966 } else if (r->get && (irq = r->get(pirq_router_dev, dev, pirq)) && \
967 ((!(pci_probe & PCI_USE_PIRQ_MASK)) || ((1 << irq) & mask))) {
968 msg = "found";
969 elcr_set_level_irq(irq);
970 } else if (newirq && r->set &&
971 (dev->class >> 8) != PCI_CLASS_DISPLAY_VGA) {
972 if (r->set(pirq_router_dev, dev, pirq, newirq)) {
973 elcr_set_level_irq(newirq);
974 msg = "assigned";
975 irq = newirq;
976 }
977 }
978
979 if (!irq) {
980 if (newirq && mask == (1 << newirq)) {
981 msg = "guessed";
982 irq = newirq;
983 } else {
984 dev_dbg(&dev->dev, "can't route interrupt\n");
985 return 0;
986 }
987 }
988 dev_info(&dev->dev, "%s PCI INT %c -> IRQ %d\n", msg, 'A' + pin - 1, irq);
989
990
991 for_each_pci_dev(dev2) {
992 pci_read_config_byte(dev2, PCI_INTERRUPT_PIN, &pin);
993 if (!pin)
994 continue;
995
996 info = pirq_get_info(dev2);
997 if (!info)
998 continue;
999 if (info->irq[pin - 1].link == pirq) {
1000
1001
1002
1003
1004 if (dev2->irq && dev2->irq != irq && \
1005 (!(pci_probe & PCI_USE_PIRQ_MASK) || \
1006 ((1 << dev2->irq) & mask))) {
1007#ifndef CONFIG_PCI_MSI
1008 dev_info(&dev2->dev, "IRQ routing conflict: "
1009 "have IRQ %d, want IRQ %d\n",
1010 dev2->irq, irq);
1011#endif
1012 continue;
1013 }
1014 dev2->irq = irq;
1015 pirq_penalty[irq]++;
1016 if (dev != dev2)
1017 dev_info(&dev->dev, "sharing IRQ %d with %s\n",
1018 irq, pci_name(dev2));
1019 }
1020 }
1021 return 1;
1022}
1023
1024void __init pcibios_fixup_irqs(void)
1025{
1026 struct pci_dev *dev = NULL;
1027 u8 pin;
1028
1029 DBG(KERN_DEBUG "PCI: IRQ fixup\n");
1030 for_each_pci_dev(dev) {
1031
1032
1033
1034
1035
1036 if (dev->irq >= 16) {
1037 dev_dbg(&dev->dev, "ignoring bogus IRQ %d\n", dev->irq);
1038 dev->irq = 0;
1039 }
1040
1041
1042
1043
1044 if (pirq_penalty[dev->irq] >= 100 &&
1045 pirq_penalty[dev->irq] < 100000)
1046 pirq_penalty[dev->irq] = 0;
1047 pirq_penalty[dev->irq]++;
1048 }
1049
1050 if (io_apic_assign_pci_irqs)
1051 return;
1052
1053 dev = NULL;
1054 for_each_pci_dev(dev) {
1055 pci_read_config_byte(dev, PCI_INTERRUPT_PIN, &pin);
1056 if (!pin)
1057 continue;
1058
1059
1060
1061
1062 if (!dev->irq)
1063 pcibios_lookup_irq(dev, 0);
1064 }
1065}
1066
1067
1068
1069
1070
1071static int __init fix_broken_hp_bios_irq9(const struct dmi_system_id *d)
1072{
1073 if (!broken_hp_bios_irq9) {
1074 broken_hp_bios_irq9 = 1;
1075 printk(KERN_INFO "%s detected - fixing broken IRQ routing\n",
1076 d->ident);
1077 }
1078 return 0;
1079}
1080
1081
1082
1083
1084
1085static int __init fix_acer_tm360_irqrouting(const struct dmi_system_id *d)
1086{
1087 if (!acer_tm360_irqrouting) {
1088 acer_tm360_irqrouting = 1;
1089 printk(KERN_INFO "%s detected - fixing broken IRQ routing\n",
1090 d->ident);
1091 }
1092 return 0;
1093}
1094
1095static struct dmi_system_id __initdata pciirq_dmi_table[] = {
1096 {
1097 .callback = fix_broken_hp_bios_irq9,
1098 .ident = "HP Pavilion N5400 Series Laptop",
1099 .matches = {
1100 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1101 DMI_MATCH(DMI_BIOS_VERSION, "GE.M1.03"),
1102 DMI_MATCH(DMI_PRODUCT_VERSION,
1103 "HP Pavilion Notebook Model GE"),
1104 DMI_MATCH(DMI_BOARD_VERSION, "OmniBook N32N-736"),
1105 },
1106 },
1107 {
1108 .callback = fix_acer_tm360_irqrouting,
1109 .ident = "Acer TravelMate 36x Laptop",
1110 .matches = {
1111 DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
1112 DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 360"),
1113 },
1114 },
1115 { }
1116};
1117
1118void __init pcibios_irq_init(void)
1119{
1120 DBG(KERN_DEBUG "PCI: IRQ init\n");
1121
1122 if (raw_pci_ops == NULL)
1123 return;
1124
1125 dmi_check_system(pciirq_dmi_table);
1126
1127 pirq_table = pirq_find_routing_table();
1128
1129#ifdef CONFIG_PCI_BIOS
1130 if (!pirq_table && (pci_probe & PCI_BIOS_IRQ_SCAN))
1131 pirq_table = pcibios_get_irq_routing_table();
1132#endif
1133 if (pirq_table) {
1134 pirq_peer_trick();
1135 pirq_find_router(&pirq_router);
1136 if (pirq_table->exclusive_irqs) {
1137 int i;
1138 for (i = 0; i < 16; i++)
1139 if (!(pirq_table->exclusive_irqs & (1 << i)))
1140 pirq_penalty[i] += 100;
1141 }
1142
1143
1144
1145
1146 if (io_apic_assign_pci_irqs)
1147 pirq_table = NULL;
1148 }
1149
1150 x86_init.pci.fixup_irqs();
1151
1152 if (io_apic_assign_pci_irqs && pci_routeirq) {
1153 struct pci_dev *dev = NULL;
1154
1155
1156
1157
1158
1159 printk(KERN_INFO "PCI: Routing PCI interrupts for all devices because \"pci=routeirq\" specified\n");
1160 for_each_pci_dev(dev)
1161 pirq_enable_irq(dev);
1162 }
1163}
1164
1165static void pirq_penalize_isa_irq(int irq, int active)
1166{
1167
1168
1169
1170
1171 if (irq < 16) {
1172 if (active)
1173 pirq_penalty[irq] += 1000;
1174 else
1175 pirq_penalty[irq] += 100;
1176 }
1177}
1178
1179void pcibios_penalize_isa_irq(int irq, int active)
1180{
1181#ifdef CONFIG_ACPI
1182 if (!acpi_noirq)
1183 acpi_penalize_isa_irq(irq, active);
1184 else
1185#endif
1186 pirq_penalize_isa_irq(irq, active);
1187}
1188
1189static int pirq_enable_irq(struct pci_dev *dev)
1190{
1191 u8 pin = 0;
1192
1193 pci_read_config_byte(dev, PCI_INTERRUPT_PIN, &pin);
1194 if (pin && !pcibios_lookup_irq(dev, 1)) {
1195 char *msg = "";
1196
1197 if (!io_apic_assign_pci_irqs && dev->irq)
1198 return 0;
1199
1200 if (io_apic_assign_pci_irqs) {
1201#ifdef CONFIG_X86_IO_APIC
1202 struct pci_dev *temp_dev;
1203 int irq;
1204
1205 if (dev->irq_managed && dev->irq > 0)
1206 return 0;
1207
1208 irq = IO_APIC_get_PCI_irq_vector(dev->bus->number,
1209 PCI_SLOT(dev->devfn), pin - 1);
1210
1211
1212
1213
1214
1215
1216 temp_dev = dev;
1217 while (irq < 0 && dev->bus->parent) {
1218 struct pci_dev *bridge = dev->bus->self;
1219
1220 pin = pci_swizzle_interrupt_pin(dev, pin);
1221 irq = IO_APIC_get_PCI_irq_vector(bridge->bus->number,
1222 PCI_SLOT(bridge->devfn),
1223 pin - 1);
1224 if (irq >= 0)
1225 dev_warn(&dev->dev, "using bridge %s "
1226 "INT %c to get IRQ %d\n",
1227 pci_name(bridge), 'A' + pin - 1,
1228 irq);
1229 dev = bridge;
1230 }
1231 dev = temp_dev;
1232 if (irq >= 0) {
1233 dev->irq_managed = 1;
1234 dev->irq = irq;
1235 dev_info(&dev->dev, "PCI->APIC IRQ transform: "
1236 "INT %c -> IRQ %d\n", 'A' + pin - 1, irq);
1237 return 0;
1238 } else
1239 msg = "; probably buggy MP table";
1240#endif
1241 } else if (pci_probe & PCI_BIOS_IRQ_SCAN)
1242 msg = "";
1243 else
1244 msg = "; please try using pci=biosirq";
1245
1246
1247
1248
1249
1250 if (dev->class >> 8 == PCI_CLASS_STORAGE_IDE &&
1251 !(dev->class & 0x5))
1252 return 0;
1253
1254 dev_warn(&dev->dev, "can't find IRQ for PCI INT %c%s\n",
1255 'A' + pin - 1, msg);
1256 }
1257 return 0;
1258}
1259
1260bool mp_should_keep_irq(struct device *dev)
1261{
1262 if (dev->power.is_prepared)
1263 return true;
1264#ifdef CONFIG_PM
1265 if (dev->power.runtime_status == RPM_SUSPENDING)
1266 return true;
1267#endif
1268
1269 return false;
1270}
1271
1272static void pirq_disable_irq(struct pci_dev *dev)
1273{
1274 if (io_apic_assign_pci_irqs && !mp_should_keep_irq(&dev->dev) &&
1275 dev->irq_managed && dev->irq) {
1276 mp_unmap_irq(dev->irq);
1277 dev->irq = 0;
1278 dev->irq_managed = 0;
1279 }
1280}
1281