blob: f2cb942f828197ae61b36c2314cc8b2fcee75446 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Low-Level PCI Support for PC -- Routing of Interrupts
3 *
4 * (c) 1999--2000 Martin Mares <mj@ucw.cz>
5 */
6
Linus Torvalds1da177e2005-04-16 15:20:36 -07007#include <linux/types.h>
8#include <linux/kernel.h>
9#include <linux/pci.h>
10#include <linux/init.h>
11#include <linux/slab.h>
12#include <linux/interrupt.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070013#include <linux/dmi.h>
14#include <asm/io.h>
15#include <asm/smp.h>
16#include <asm/io_apic.h>
Nick Pigginb33fa1f2005-10-01 02:34:42 +100017#include <linux/irq.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include <linux/acpi.h>
19
20#include "pci.h"
21
22#define PIRQ_SIGNATURE (('$' << 0) + ('P' << 8) + ('I' << 16) + ('R' << 24))
23#define PIRQ_VERSION 0x0100
24
25static int broken_hp_bios_irq9;
26static int acer_tm360_irqrouting;
27
28static struct irq_routing_table *pirq_table;
29
30static int pirq_enable_irq(struct pci_dev *dev);
31
32/*
33 * Never use: 0, 1, 2 (timer, keyboard, and cascade)
34 * Avoid using: 13, 14 and 15 (FP error and IDE).
35 * Penalize: 3, 4, 6, 7, 12 (known ISA uses: serial, floppy, parallel and mouse)
36 */
37unsigned int pcibios_irq_mask = 0xfff8;
38
39static int pirq_penalty[16] = {
40 1000000, 1000000, 1000000, 1000, 1000, 0, 1000, 1000,
41 0, 0, 0, 0, 1000, 100000, 100000, 100000
42};
43
44struct irq_router {
45 char *name;
46 u16 vendor, device;
47 int (*get)(struct pci_dev *router, struct pci_dev *dev, int pirq);
48 int (*set)(struct pci_dev *router, struct pci_dev *dev, int pirq, 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) = NULL;
David Shaohua Li87bec662005-07-27 23:02:00 -040057void (*pcibios_disable_irq)(struct pci_dev *dev) = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -070058
59/*
jayalk@intworks.biz120bb422005-03-21 20:20:42 -080060 * Check passed address for the PCI IRQ Routing Table signature
61 * and perform checksum verification.
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) {
Daniel Marjamäki81745512005-12-01 18:01:28 +010080 DBG(KERN_DEBUG "PCI: Interrupt Routing Table found at 0x%p\n", rt);
jayalk@intworks.biz120bb422005-03-21 20:20:42 -080081 return rt;
82 }
83 return NULL;
84}
85
86
87
88/*
Linus Torvalds1da177e2005-04-16 15:20:36 -070089 * Search 0xf0000 -- 0xfffff for the PCI IRQ Routing Table.
90 */
91
92static struct irq_routing_table * __init pirq_find_routing_table(void)
93{
94 u8 *addr;
95 struct irq_routing_table *rt;
Linus Torvalds1da177e2005-04-16 15:20:36 -070096
jayalk@intworks.biz120bb422005-03-21 20:20:42 -080097 if (pirq_table_addr) {
98 rt = pirq_check_routing_table((u8 *) __va(pirq_table_addr));
99 if (rt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100 return rt;
jayalk@intworks.biz120bb422005-03-21 20:20:42 -0800101 printk(KERN_WARNING "PCI: PIRQ table NOT found at pirqaddr\n");
102 }
103 for(addr = (u8 *) __va(0xf0000); addr < (u8 *) __va(0x100000); addr += 16) {
104 rt = pirq_check_routing_table(addr);
105 if (rt)
106 return rt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107 }
108 return NULL;
109}
110
111/*
112 * If we have a IRQ routing table, use it to search for peer host
113 * bridges. It's a gross hack, but since there are no other known
114 * ways how to get a list of buses, we have to go this way.
115 */
116
117static void __init pirq_peer_trick(void)
118{
119 struct irq_routing_table *rt = pirq_table;
120 u8 busmap[256];
121 int i;
122 struct irq_info *e;
123
124 memset(busmap, 0, sizeof(busmap));
125 for(i=0; i < (rt->size - sizeof(struct irq_routing_table)) / sizeof(struct irq_info); i++) {
126 e = &rt->slots[i];
127#ifdef DEBUG
128 {
129 int j;
Daniel Marjamäki81745512005-12-01 18:01:28 +0100130 DBG(KERN_DEBUG "%02x:%02x slot=%02x", e->bus, e->devfn/8, e->slot);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131 for(j=0; j<4; j++)
132 DBG(" %d:%02x/%04x", j, e->irq[j].link, e->irq[j].bitmap);
133 DBG("\n");
134 }
135#endif
136 busmap[e->bus] = 1;
137 }
138 for(i = 1; i < 256; i++) {
139 if (!busmap[i] || pci_find_bus(0, i))
140 continue;
141 if (pci_scan_bus(i, &pci_root_ops, NULL))
142 printk(KERN_INFO "PCI: Discovered primary peer bus %02x [IRQ]\n", i);
143 }
144 pcibios_last_bus = -1;
145}
146
147/*
148 * Code for querying and setting of IRQ routes on various interrupt routers.
149 */
150
151void eisa_set_level_irq(unsigned int irq)
152{
153 unsigned char mask = 1 << (irq & 7);
154 unsigned int port = 0x4d0 + (irq >> 3);
155 unsigned char val;
156 static u16 eisa_irq_mask;
157
158 if (irq >= 16 || (1 << irq) & eisa_irq_mask)
159 return;
160
161 eisa_irq_mask |= (1 << irq);
Daniel Marjamäki81745512005-12-01 18:01:28 +0100162 printk(KERN_DEBUG "PCI: setting IRQ %u as level-triggered\n", irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163 val = inb(port);
164 if (!(val & mask)) {
Daniel Marjamäki81745512005-12-01 18:01:28 +0100165 DBG(KERN_DEBUG " -> edge");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166 outb(val | mask, port);
167 }
168}
169
170/*
171 * Common IRQ routing practice: nybbles in config space,
172 * offset by some magic constant.
173 */
174static unsigned int read_config_nybble(struct pci_dev *router, unsigned offset, unsigned nr)
175{
176 u8 x;
177 unsigned reg = offset + (nr >> 1);
178
179 pci_read_config_byte(router, reg, &x);
180 return (nr & 1) ? (x >> 4) : (x & 0xf);
181}
182
183static void write_config_nybble(struct pci_dev *router, unsigned offset, unsigned nr, unsigned int val)
184{
185 u8 x;
186 unsigned reg = offset + (nr >> 1);
187
188 pci_read_config_byte(router, reg, &x);
189 x = (nr & 1) ? ((x & 0x0f) | (val << 4)) : ((x & 0xf0) | val);
190 pci_write_config_byte(router, reg, x);
191}
192
193/*
194 * ALI pirq entries are damn ugly, and completely undocumented.
195 * This has been figured out from pirq tables, and it's not a pretty
196 * picture.
197 */
198static int pirq_ali_get(struct pci_dev *router, struct pci_dev *dev, int pirq)
199{
Andreas Mohra0de1f02006-06-23 02:04:28 -0700200 static const unsigned char irqmap[16] = { 0, 9, 3, 10, 4, 5, 7, 6, 1, 11, 0, 12, 0, 14, 0, 15 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201
202 return irqmap[read_config_nybble(router, 0x48, pirq-1)];
203}
204
205static int pirq_ali_set(struct pci_dev *router, struct pci_dev *dev, int pirq, int irq)
206{
Andreas Mohra0de1f02006-06-23 02:04:28 -0700207 static const unsigned char irqmap[16] = { 0, 8, 0, 2, 4, 5, 7, 6, 0, 1, 3, 9, 11, 0, 13, 15 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208 unsigned int val = irqmap[irq];
209
210 if (val) {
211 write_config_nybble(router, 0x48, pirq-1, val);
212 return 1;
213 }
214 return 0;
215}
216
217/*
218 * The Intel PIIX4 pirq rules are fairly simple: "pirq" is
219 * just a pointer to the config space.
220 */
221static int pirq_piix_get(struct pci_dev *router, struct pci_dev *dev, int pirq)
222{
223 u8 x;
224
225 pci_read_config_byte(router, pirq, &x);
226 return (x < 16) ? x : 0;
227}
228
229static int pirq_piix_set(struct pci_dev *router, struct pci_dev *dev, int pirq, int irq)
230{
231 pci_write_config_byte(router, pirq, irq);
232 return 1;
233}
234
235/*
236 * The VIA pirq rules are nibble-based, like ALI,
237 * but without the ugly irq number munging.
238 * However, PIRQD is in the upper instead of lower 4 bits.
239 */
240static int pirq_via_get(struct pci_dev *router, struct pci_dev *dev, int pirq)
241{
242 return read_config_nybble(router, 0x55, pirq == 4 ? 5 : pirq);
243}
244
245static int pirq_via_set(struct pci_dev *router, struct pci_dev *dev, int pirq, int irq)
246{
247 write_config_nybble(router, 0x55, pirq == 4 ? 5 : pirq, irq);
248 return 1;
249}
250
251/*
Aleksey Gorelov80bb82a2005-06-23 00:08:29 -0700252 * The VIA pirq rules are nibble-based, like ALI,
253 * but without the ugly irq number munging.
254 * However, for 82C586, nibble map is different .
255 */
256static int pirq_via586_get(struct pci_dev *router, struct pci_dev *dev, int pirq)
257{
Daniel Ritzf3ac8432006-11-14 02:03:25 -0800258 static const unsigned int pirqmap[5] = { 3, 2, 5, 1, 1 };
Aleksey Gorelov80bb82a2005-06-23 00:08:29 -0700259 return read_config_nybble(router, 0x55, pirqmap[pirq-1]);
260}
261
262static int pirq_via586_set(struct pci_dev *router, struct pci_dev *dev, int pirq, int irq)
263{
Daniel Ritzf3ac8432006-11-14 02:03:25 -0800264 static const unsigned int pirqmap[5] = { 3, 2, 5, 1, 1 };
Aleksey Gorelov80bb82a2005-06-23 00:08:29 -0700265 write_config_nybble(router, 0x55, pirqmap[pirq-1], irq);
266 return 1;
267}
268
269/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270 * ITE 8330G pirq rules are nibble-based
271 * FIXME: pirqmap may be { 1, 0, 3, 2 },
272 * 2+3 are both mapped to irq 9 on my system
273 */
274static int pirq_ite_get(struct pci_dev *router, struct pci_dev *dev, int pirq)
275{
Andreas Mohra0de1f02006-06-23 02:04:28 -0700276 static const unsigned char pirqmap[4] = { 1, 0, 2, 3 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277 return read_config_nybble(router,0x43, pirqmap[pirq-1]);
278}
279
280static int pirq_ite_set(struct pci_dev *router, struct pci_dev *dev, int pirq, int irq)
281{
Andreas Mohra0de1f02006-06-23 02:04:28 -0700282 static const unsigned char pirqmap[4] = { 1, 0, 2, 3 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283 write_config_nybble(router, 0x43, pirqmap[pirq-1], irq);
284 return 1;
285}
286
287/*
288 * OPTI: high four bits are nibble pointer..
289 * I wonder what the low bits do?
290 */
291static int pirq_opti_get(struct pci_dev *router, struct pci_dev *dev, int pirq)
292{
293 return read_config_nybble(router, 0xb8, pirq >> 4);
294}
295
296static int pirq_opti_set(struct pci_dev *router, struct pci_dev *dev, int pirq, int irq)
297{
298 write_config_nybble(router, 0xb8, pirq >> 4, irq);
299 return 1;
300}
301
302/*
303 * Cyrix: nibble offset 0x5C
304 * 0x5C bits 7:4 is INTB bits 3:0 is INTA
305 * 0x5D bits 7:4 is INTD bits 3:0 is INTC
306 */
307static int pirq_cyrix_get(struct pci_dev *router, struct pci_dev *dev, int pirq)
308{
309 return read_config_nybble(router, 0x5C, (pirq-1)^1);
310}
311
312static int pirq_cyrix_set(struct pci_dev *router, struct pci_dev *dev, int pirq, int irq)
313{
314 write_config_nybble(router, 0x5C, (pirq-1)^1, irq);
315 return 1;
316}
317
318/*
319 * PIRQ routing for SiS 85C503 router used in several SiS chipsets.
320 * We have to deal with the following issues here:
321 * - vendors have different ideas about the meaning of link values
322 * - some onboard devices (integrated in the chipset) have special
323 * links and are thus routed differently (i.e. not via PCI INTA-INTD)
324 * - different revision of the router have a different layout for
325 * the routing registers, particularly for the onchip devices
326 *
327 * For all routing registers the common thing is we have one byte
328 * per routeable link which is defined as:
329 * bit 7 IRQ mapping enabled (0) or disabled (1)
330 * bits [6:4] reserved (sometimes used for onchip devices)
331 * bits [3:0] IRQ to map to
332 * allowed: 3-7, 9-12, 14-15
333 * reserved: 0, 1, 2, 8, 13
334 *
335 * The config-space registers located at 0x41/0x42/0x43/0x44 are
336 * always used to route the normal PCI INT A/B/C/D respectively.
337 * Apparently there are systems implementing PCI routing table using
338 * link values 0x01-0x04 and others using 0x41-0x44 for PCI INTA..D.
339 * We try our best to handle both link mappings.
340 *
341 * Currently (2003-05-21) it appears most SiS chipsets follow the
342 * definition of routing registers from the SiS-5595 southbridge.
343 * According to the SiS 5595 datasheets the revision id's of the
344 * router (ISA-bridge) should be 0x01 or 0xb0.
345 *
346 * Furthermore we've also seen lspci dumps with revision 0x00 and 0xb1.
347 * Looks like these are used in a number of SiS 5xx/6xx/7xx chipsets.
348 * They seem to work with the current routing code. However there is
349 * some concern because of the two USB-OHCI HCs (original SiS 5595
350 * had only one). YMMV.
351 *
352 * Onchip routing for router rev-id 0x01/0xb0 and probably 0x00/0xb1:
353 *
354 * 0x61: IDEIRQ:
355 * bits [6:5] must be written 01
356 * bit 4 channel-select primary (0), secondary (1)
357 *
358 * 0x62: USBIRQ:
359 * bit 6 OHCI function disabled (0), enabled (1)
360 *
361 * 0x6a: ACPI/SCI IRQ: bits 4-6 reserved
362 *
363 * 0x7e: Data Acq. Module IRQ - bits 4-6 reserved
364 *
365 * We support USBIRQ (in addition to INTA-INTD) and keep the
366 * IDE, ACPI and DAQ routing untouched as set by the BIOS.
367 *
368 * Currently the only reported exception is the new SiS 65x chipset
369 * which includes the SiS 69x southbridge. Here we have the 85C503
370 * router revision 0x04 and there are changes in the register layout
371 * mostly related to the different USB HCs with USB 2.0 support.
372 *
373 * Onchip routing for router rev-id 0x04 (try-and-error observation)
374 *
375 * 0x60/0x61/0x62/0x63: 1xEHCI and 3xOHCI (companion) USB-HCs
376 * bit 6-4 are probably unused, not like 5595
377 */
378
379#define PIRQ_SIS_IRQ_MASK 0x0f
380#define PIRQ_SIS_IRQ_DISABLE 0x80
381#define PIRQ_SIS_USB_ENABLE 0x40
382
383static int pirq_sis_get(struct pci_dev *router, struct pci_dev *dev, int pirq)
384{
385 u8 x;
386 int reg;
387
388 reg = pirq;
389 if (reg >= 0x01 && reg <= 0x04)
390 reg += 0x40;
391 pci_read_config_byte(router, reg, &x);
392 return (x & PIRQ_SIS_IRQ_DISABLE) ? 0 : (x & PIRQ_SIS_IRQ_MASK);
393}
394
395static int pirq_sis_set(struct pci_dev *router, struct pci_dev *dev, int pirq, int irq)
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 x &= ~(PIRQ_SIS_IRQ_MASK | PIRQ_SIS_IRQ_DISABLE);
405 x |= irq ? irq: PIRQ_SIS_IRQ_DISABLE;
406 pci_write_config_byte(router, reg, x);
407 return 1;
408}
409
410
411/*
412 * VLSI: nibble offset 0x74 - educated guess due to routing table and
413 * config space of VLSI 82C534 PCI-bridge/router (1004:0102)
414 * Tested on HP OmniBook 800 covering PIRQ 1, 2, 4, 8 for onboard
415 * devices, PIRQ 3 for non-pci(!) soundchip and (untested) PIRQ 6
416 * for the busbridge to the docking station.
417 */
418
419static int pirq_vlsi_get(struct pci_dev *router, struct pci_dev *dev, int pirq)
420{
421 if (pirq > 8) {
422 printk(KERN_INFO "VLSI router pirq escape (%d)\n", pirq);
423 return 0;
424 }
425 return read_config_nybble(router, 0x74, pirq-1);
426}
427
428static int pirq_vlsi_set(struct pci_dev *router, struct pci_dev *dev, int pirq, int irq)
429{
430 if (pirq > 8) {
431 printk(KERN_INFO "VLSI router pirq escape (%d)\n", pirq);
432 return 0;
433 }
434 write_config_nybble(router, 0x74, pirq-1, irq);
435 return 1;
436}
437
438/*
439 * ServerWorks: PCI interrupts mapped to system IRQ lines through Index
440 * and Redirect I/O registers (0x0c00 and 0x0c01). The Index register
441 * format is (PCIIRQ## | 0x10), e.g.: PCIIRQ10=0x1a. The Redirect
442 * register is a straight binary coding of desired PIC IRQ (low nibble).
443 *
444 * The 'link' value in the PIRQ table is already in the correct format
445 * for the Index register. There are some special index values:
446 * 0x00 for ACPI (SCI), 0x01 for USB, 0x02 for IDE0, 0x04 for IDE1,
447 * and 0x03 for SMBus.
448 */
449static int pirq_serverworks_get(struct pci_dev *router, struct pci_dev *dev, int pirq)
450{
451 outb_p(pirq, 0xc00);
452 return inb(0xc01) & 0xf;
453}
454
455static int pirq_serverworks_set(struct pci_dev *router, struct pci_dev *dev, int pirq, int irq)
456{
457 outb_p(pirq, 0xc00);
458 outb_p(irq, 0xc01);
459 return 1;
460}
461
462/* Support for AMD756 PCI IRQ Routing
463 * Jhon H. Caicedo <jhcaiced@osso.org.co>
464 * Jun/21/2001 0.2.0 Release, fixed to use "nybble" functions... (jhcaiced)
465 * Jun/19/2001 Alpha Release 0.1.0 (jhcaiced)
466 * The AMD756 pirq rules are nibble-based
467 * offset 0x56 0-3 PIRQA 4-7 PIRQB
468 * offset 0x57 0-3 PIRQC 4-7 PIRQD
469 */
470static int pirq_amd756_get(struct pci_dev *router, struct pci_dev *dev, int pirq)
471{
472 u8 irq;
473 irq = 0;
474 if (pirq <= 4)
475 {
476 irq = read_config_nybble(router, 0x56, pirq - 1);
477 }
478 printk(KERN_INFO "AMD756: dev %04x:%04x, router pirq : %d get irq : %2d\n",
479 dev->vendor, dev->device, pirq, irq);
480 return irq;
481}
482
483static int pirq_amd756_set(struct pci_dev *router, struct pci_dev *dev, int pirq, int irq)
484{
485 printk(KERN_INFO "AMD756: dev %04x:%04x, router pirq : %d SET irq : %2d\n",
486 dev->vendor, dev->device, pirq, irq);
487 if (pirq <= 4)
488 {
489 write_config_nybble(router, 0x56, pirq - 1, irq);
490 }
491 return 1;
492}
493
494#ifdef CONFIG_PCI_BIOS
495
496static int pirq_bios_set(struct pci_dev *router, struct pci_dev *dev, int pirq, int irq)
497{
498 struct pci_dev *bridge;
499 int pin = pci_get_interrupt_pin(dev, &bridge);
500 return pcibios_set_irq_routing(bridge, pin, irq);
501}
502
503#endif
504
505static __init int intel_router_probe(struct irq_router *r, struct pci_dev *router, u16 device)
506{
Andreas Mohra0de1f02006-06-23 02:04:28 -0700507 static struct pci_device_id __initdata pirq_440gx[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82443GX_0) },
509 { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82443GX_2) },
510 { },
511 };
512
513 /* 440GX has a proprietary PIRQ router -- don't use it */
514 if (pci_dev_present(pirq_440gx))
515 return 0;
516
517 switch(device)
518 {
519 case PCI_DEVICE_ID_INTEL_82371FB_0:
520 case PCI_DEVICE_ID_INTEL_82371SB_0:
521 case PCI_DEVICE_ID_INTEL_82371AB_0:
522 case PCI_DEVICE_ID_INTEL_82371MX:
523 case PCI_DEVICE_ID_INTEL_82443MX_0:
524 case PCI_DEVICE_ID_INTEL_82801AA_0:
525 case PCI_DEVICE_ID_INTEL_82801AB_0:
526 case PCI_DEVICE_ID_INTEL_82801BA_0:
527 case PCI_DEVICE_ID_INTEL_82801BA_10:
528 case PCI_DEVICE_ID_INTEL_82801CA_0:
529 case PCI_DEVICE_ID_INTEL_82801CA_12:
530 case PCI_DEVICE_ID_INTEL_82801DB_0:
531 case PCI_DEVICE_ID_INTEL_82801E_0:
532 case PCI_DEVICE_ID_INTEL_82801EB_0:
533 case PCI_DEVICE_ID_INTEL_ESB_1:
534 case PCI_DEVICE_ID_INTEL_ICH6_0:
535 case PCI_DEVICE_ID_INTEL_ICH6_1:
536 case PCI_DEVICE_ID_INTEL_ICH7_0:
537 case PCI_DEVICE_ID_INTEL_ICH7_1:
Jason Gaston4d24a432005-05-01 08:58:50 -0700538 case PCI_DEVICE_ID_INTEL_ICH7_30:
539 case PCI_DEVICE_ID_INTEL_ICH7_31:
Jason Gastone285f802005-04-16 15:24:41 -0700540 case PCI_DEVICE_ID_INTEL_ESB2_0:
Jason Gastonb6ebb262006-01-09 10:53:45 -0800541 case PCI_DEVICE_ID_INTEL_ICH8_0:
542 case PCI_DEVICE_ID_INTEL_ICH8_1:
543 case PCI_DEVICE_ID_INTEL_ICH8_2:
544 case PCI_DEVICE_ID_INTEL_ICH8_3:
545 case PCI_DEVICE_ID_INTEL_ICH8_4:
Jason Gaston3b59d522006-11-22 15:15:08 -0800546 case PCI_DEVICE_ID_INTEL_ICH9_0:
547 case PCI_DEVICE_ID_INTEL_ICH9_1:
548 case PCI_DEVICE_ID_INTEL_ICH9_2:
549 case PCI_DEVICE_ID_INTEL_ICH9_3:
550 case PCI_DEVICE_ID_INTEL_ICH9_4:
551 case PCI_DEVICE_ID_INTEL_ICH9_5:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552 r->name = "PIIX/ICH";
553 r->get = pirq_piix_get;
554 r->set = pirq_piix_set;
555 return 1;
556 }
557 return 0;
558}
559
aleksey_gorelov@phoenix.com750deaa2005-10-30 14:59:36 -0800560static __init int via_router_probe(struct irq_router *r,
561 struct pci_dev *router, u16 device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562{
563 /* FIXME: We should move some of the quirk fixup stuff here */
Giancarlo Formicucciaac122592005-07-28 01:07:33 -0700564
aleksey_gorelov@phoenix.com750deaa2005-10-30 14:59:36 -0800565 /*
566 * work arounds for some buggy BIOSes
567 */
568 if (device == PCI_DEVICE_ID_VIA_82C586_0) {
569 switch(router->device) {
570 case PCI_DEVICE_ID_VIA_82C686:
571 /*
572 * Asus k7m bios wrongly reports 82C686A
573 * as 586-compatible
574 */
575 device = PCI_DEVICE_ID_VIA_82C686;
576 break;
577 case PCI_DEVICE_ID_VIA_8235:
578 /**
579 * Asus a7v-x bios wrongly reports 8235
580 * as 586-compatible
581 */
582 device = PCI_DEVICE_ID_VIA_8235;
583 break;
584 }
Giancarlo Formicucciaac122592005-07-28 01:07:33 -0700585 }
586
aleksey_gorelov@phoenix.com750deaa2005-10-30 14:59:36 -0800587 switch(device) {
588 case PCI_DEVICE_ID_VIA_82C586_0:
589 r->name = "VIA";
590 r->get = pirq_via586_get;
591 r->set = pirq_via586_set;
592 return 1;
593 case PCI_DEVICE_ID_VIA_82C596:
594 case PCI_DEVICE_ID_VIA_82C686:
595 case PCI_DEVICE_ID_VIA_8231:
Grzegorz Janoszka40d8b892006-03-21 11:57:19 +0100596 case PCI_DEVICE_ID_VIA_8233A:
aleksey_gorelov@phoenix.com750deaa2005-10-30 14:59:36 -0800597 case PCI_DEVICE_ID_VIA_8235:
Grzegorz Janoszka40d8b892006-03-21 11:57:19 +0100598 case PCI_DEVICE_ID_VIA_8237:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599 /* FIXME: add new ones for 8233/5 */
aleksey_gorelov@phoenix.com750deaa2005-10-30 14:59:36 -0800600 r->name = "VIA";
601 r->get = pirq_via_get;
602 r->set = pirq_via_set;
603 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604 }
605 return 0;
606}
607
608static __init int vlsi_router_probe(struct irq_router *r, struct pci_dev *router, u16 device)
609{
610 switch(device)
611 {
612 case PCI_DEVICE_ID_VLSI_82C534:
613 r->name = "VLSI 82C534";
614 r->get = pirq_vlsi_get;
615 r->set = pirq_vlsi_set;
616 return 1;
617 }
618 return 0;
619}
620
621
622static __init int serverworks_router_probe(struct irq_router *r, struct pci_dev *router, u16 device)
623{
624 switch(device)
625 {
626 case PCI_DEVICE_ID_SERVERWORKS_OSB4:
627 case PCI_DEVICE_ID_SERVERWORKS_CSB5:
628 r->name = "ServerWorks";
629 r->get = pirq_serverworks_get;
630 r->set = pirq_serverworks_set;
631 return 1;
632 }
633 return 0;
634}
635
636static __init int sis_router_probe(struct irq_router *r, struct pci_dev *router, u16 device)
637{
638 if (device != PCI_DEVICE_ID_SI_503)
639 return 0;
640
641 r->name = "SIS";
642 r->get = pirq_sis_get;
643 r->set = pirq_sis_set;
644 return 1;
645}
646
647static __init int cyrix_router_probe(struct irq_router *r, struct pci_dev *router, u16 device)
648{
649 switch(device)
650 {
651 case PCI_DEVICE_ID_CYRIX_5520:
652 r->name = "NatSemi";
653 r->get = pirq_cyrix_get;
654 r->set = pirq_cyrix_set;
655 return 1;
656 }
657 return 0;
658}
659
660static __init int opti_router_probe(struct irq_router *r, struct pci_dev *router, u16 device)
661{
662 switch(device)
663 {
664 case PCI_DEVICE_ID_OPTI_82C700:
665 r->name = "OPTI";
666 r->get = pirq_opti_get;
667 r->set = pirq_opti_set;
668 return 1;
669 }
670 return 0;
671}
672
673static __init int ite_router_probe(struct irq_router *r, struct pci_dev *router, u16 device)
674{
675 switch(device)
676 {
677 case PCI_DEVICE_ID_ITE_IT8330G_0:
678 r->name = "ITE";
679 r->get = pirq_ite_get;
680 r->set = pirq_ite_set;
681 return 1;
682 }
683 return 0;
684}
685
686static __init int ali_router_probe(struct irq_router *r, struct pci_dev *router, u16 device)
687{
688 switch(device)
689 {
690 case PCI_DEVICE_ID_AL_M1533:
691 case PCI_DEVICE_ID_AL_M1563:
Daniel Marjamäki81745512005-12-01 18:01:28 +0100692 printk(KERN_DEBUG "PCI: Using ALI IRQ Router\n");
693 r->name = "ALI";
694 r->get = pirq_ali_get;
695 r->set = pirq_ali_set;
696 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697 }
698 return 0;
699}
700
701static __init int amd_router_probe(struct irq_router *r, struct pci_dev *router, u16 device)
702{
703 switch(device)
704 {
705 case PCI_DEVICE_ID_AMD_VIPER_740B:
706 r->name = "AMD756";
707 break;
708 case PCI_DEVICE_ID_AMD_VIPER_7413:
709 r->name = "AMD766";
710 break;
711 case PCI_DEVICE_ID_AMD_VIPER_7443:
712 r->name = "AMD768";
713 break;
714 default:
715 return 0;
716 }
717 r->get = pirq_amd756_get;
718 r->set = pirq_amd756_set;
719 return 1;
720}
721
722static __initdata struct irq_router_handler pirq_routers[] = {
723 { PCI_VENDOR_ID_INTEL, intel_router_probe },
724 { PCI_VENDOR_ID_AL, ali_router_probe },
725 { PCI_VENDOR_ID_ITE, ite_router_probe },
726 { PCI_VENDOR_ID_VIA, via_router_probe },
727 { PCI_VENDOR_ID_OPTI, opti_router_probe },
728 { PCI_VENDOR_ID_SI, sis_router_probe },
729 { PCI_VENDOR_ID_CYRIX, cyrix_router_probe },
730 { PCI_VENDOR_ID_VLSI, vlsi_router_probe },
731 { PCI_VENDOR_ID_SERVERWORKS, serverworks_router_probe },
732 { PCI_VENDOR_ID_AMD, amd_router_probe },
733 /* Someone with docs needs to add the ATI Radeon IGP */
734 { 0, NULL }
735};
736static struct irq_router pirq_router;
737static struct pci_dev *pirq_router_dev;
738
739
740/*
741 * FIXME: should we have an option to say "generic for
742 * chipset" ?
743 */
744
745static void __init pirq_find_router(struct irq_router *r)
746{
747 struct irq_routing_table *rt = pirq_table;
748 struct irq_router_handler *h;
749
750#ifdef CONFIG_PCI_BIOS
751 if (!rt->signature) {
752 printk(KERN_INFO "PCI: Using BIOS for IRQ routing\n");
753 r->set = pirq_bios_set;
754 r->name = "BIOS";
755 return;
756 }
757#endif
758
759 /* Default unless a driver reloads it */
760 r->name = "default";
761 r->get = NULL;
762 r->set = NULL;
763
Daniel Marjamäki81745512005-12-01 18:01:28 +0100764 DBG(KERN_DEBUG "PCI: Attempting to find IRQ router for %04x:%04x\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765 rt->rtr_vendor, rt->rtr_device);
766
Alan Cox7cd8b682006-12-07 02:14:03 +0100767 pirq_router_dev = pci_get_bus_and_slot(rt->rtr_bus, rt->rtr_devfn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768 if (!pirq_router_dev) {
Daniel Marjamäki81745512005-12-01 18:01:28 +0100769 DBG(KERN_DEBUG "PCI: Interrupt router not found at "
770 "%02x:%02x\n", rt->rtr_bus, rt->rtr_devfn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771 return;
772 }
773
774 for( h = pirq_routers; h->vendor; h++) {
775 /* First look for a router match */
776 if (rt->rtr_vendor == h->vendor && h->probe(r, pirq_router_dev, rt->rtr_device))
777 break;
778 /* Fall back to a device match */
779 if (pirq_router_dev->vendor == h->vendor && h->probe(r, pirq_router_dev, pirq_router_dev->device))
780 break;
781 }
782 printk(KERN_INFO "PCI: Using IRQ router %s [%04x/%04x] at %s\n",
783 pirq_router.name,
784 pirq_router_dev->vendor,
785 pirq_router_dev->device,
786 pci_name(pirq_router_dev));
Alan Cox7cd8b682006-12-07 02:14:03 +0100787
788 /* The device remains referenced for the kernel lifetime */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789}
790
791static struct irq_info *pirq_get_info(struct pci_dev *dev)
792{
793 struct irq_routing_table *rt = pirq_table;
794 int entries = (rt->size - sizeof(struct irq_routing_table)) / sizeof(struct irq_info);
795 struct irq_info *info;
796
797 for (info = rt->slots; entries--; info++)
798 if (info->bus == dev->bus->number && PCI_SLOT(info->devfn) == PCI_SLOT(dev->devfn))
799 return info;
800 return NULL;
801}
802
803static int pcibios_lookup_irq(struct pci_dev *dev, int assign)
804{
805 u8 pin;
806 struct irq_info *info;
807 int i, pirq, newirq;
808 int irq = 0;
809 u32 mask;
810 struct irq_router *r = &pirq_router;
811 struct pci_dev *dev2 = NULL;
812 char *msg = NULL;
813
814 /* Find IRQ pin */
815 pci_read_config_byte(dev, PCI_INTERRUPT_PIN, &pin);
816 if (!pin) {
Daniel Marjamäki81745512005-12-01 18:01:28 +0100817 DBG(KERN_DEBUG " -> no interrupt pin\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700818 return 0;
819 }
820 pin = pin - 1;
821
822 /* Find IRQ routing entry */
823
824 if (!pirq_table)
825 return 0;
826
Daniel Marjamäki81745512005-12-01 18:01:28 +0100827 DBG(KERN_DEBUG "IRQ for %s[%c]", pci_name(dev), 'A' + pin);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828 info = pirq_get_info(dev);
829 if (!info) {
Daniel Marjamäki81745512005-12-01 18:01:28 +0100830 DBG(" -> not found in routing table\n" KERN_DEBUG);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831 return 0;
832 }
833 pirq = info->irq[pin].link;
834 mask = info->irq[pin].bitmap;
835 if (!pirq) {
Daniel Marjamäki81745512005-12-01 18:01:28 +0100836 DBG(" -> not routed\n" KERN_DEBUG);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837 return 0;
838 }
839 DBG(" -> PIRQ %02x, mask %04x, excl %04x", pirq, mask, pirq_table->exclusive_irqs);
840 mask &= pcibios_irq_mask;
841
842 /* Work around broken HP Pavilion Notebooks which assign USB to
843 IRQ 9 even though it is actually wired to IRQ 11 */
844
845 if (broken_hp_bios_irq9 && pirq == 0x59 && dev->irq == 9) {
846 dev->irq = 11;
847 pci_write_config_byte(dev, PCI_INTERRUPT_LINE, 11);
848 r->set(pirq_router_dev, dev, pirq, 11);
849 }
850
851 /* same for Acer Travelmate 360, but with CB and irq 11 -> 10 */
852 if (acer_tm360_irqrouting && dev->irq == 11 && dev->vendor == PCI_VENDOR_ID_O2) {
853 pirq = 0x68;
854 mask = 0x400;
855 dev->irq = r->get(pirq_router_dev, dev, pirq);
856 pci_write_config_byte(dev, PCI_INTERRUPT_LINE, dev->irq);
857 }
858
859 /*
860 * Find the best IRQ to assign: use the one
861 * reported by the device if possible.
862 */
863 newirq = dev->irq;
Linus Torvalds7ed409182006-01-06 08:43:16 -0800864 if (newirq && !((1 << newirq) & mask)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865 if ( pci_probe & PCI_USE_PIRQ_MASK) newirq = 0;
Daniel Marjamäki81745512005-12-01 18:01:28 +0100866 else printk("\n" KERN_WARNING
867 "PCI: IRQ %i for device %s doesn't match PIRQ mask "
868 "- try pci=usepirqmask\n" KERN_DEBUG, newirq,
869 pci_name(dev));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870 }
871 if (!newirq && assign) {
872 for (i = 0; i < 16; i++) {
873 if (!(mask & (1 << i)))
874 continue;
Thomas Gleixner4879d772006-07-01 19:29:16 -0700875 if (pirq_penalty[i] < pirq_penalty[newirq] && can_request_irq(i, IRQF_SHARED))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700876 newirq = i;
877 }
878 }
879 DBG(" -> newirq=%d", newirq);
880
881 /* Check if it is hardcoded */
882 if ((pirq & 0xf0) == 0xf0) {
883 irq = pirq & 0xf;
884 DBG(" -> hardcoded IRQ %d\n", irq);
885 msg = "Hardcoded";
886 } else if ( r->get && (irq = r->get(pirq_router_dev, dev, pirq)) && \
887 ((!(pci_probe & PCI_USE_PIRQ_MASK)) || ((1 << irq) & mask)) ) {
888 DBG(" -> got IRQ %d\n", irq);
889 msg = "Found";
Linus Torvaldsafa024c2006-06-23 02:04:21 -0700890 eisa_set_level_irq(irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700891 } else if (newirq && r->set && (dev->class >> 8) != PCI_CLASS_DISPLAY_VGA) {
892 DBG(" -> assigning IRQ %d", newirq);
893 if (r->set(pirq_router_dev, dev, pirq, newirq)) {
894 eisa_set_level_irq(newirq);
895 DBG(" ... OK\n");
896 msg = "Assigned";
897 irq = newirq;
898 }
899 }
900
901 if (!irq) {
902 DBG(" ... failed\n");
903 if (newirq && mask == (1 << newirq)) {
904 msg = "Guessed";
905 irq = newirq;
906 } else
907 return 0;
908 }
909 printk(KERN_INFO "PCI: %s IRQ %d for device %s\n", msg, irq, pci_name(dev));
910
911 /* Update IRQ for all devices with the same pirq value */
912 while ((dev2 = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, dev2)) != NULL) {
913 pci_read_config_byte(dev2, PCI_INTERRUPT_PIN, &pin);
914 if (!pin)
915 continue;
916 pin--;
917 info = pirq_get_info(dev2);
918 if (!info)
919 continue;
920 if (info->irq[pin].link == pirq) {
921 /* We refuse to override the dev->irq information. Give a warning! */
922 if ( dev2->irq && dev2->irq != irq && \
923 (!(pci_probe & PCI_USE_PIRQ_MASK) || \
924 ((1 << dev2->irq) & mask)) ) {
925#ifndef CONFIG_PCI_MSI
926 printk(KERN_INFO "IRQ routing conflict for %s, have irq %d, want irq %d\n",
927 pci_name(dev2), dev2->irq, irq);
928#endif
929 continue;
930 }
931 dev2->irq = irq;
932 pirq_penalty[irq]++;
933 if (dev != dev2)
934 printk(KERN_INFO "PCI: Sharing IRQ %d with %s\n", irq, pci_name(dev2));
935 }
936 }
937 return 1;
938}
939
940static void __init pcibios_fixup_irqs(void)
941{
942 struct pci_dev *dev = NULL;
943 u8 pin;
944
Daniel Marjamäki81745512005-12-01 18:01:28 +0100945 DBG(KERN_DEBUG "PCI: IRQ fixup\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700946 while ((dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, dev)) != NULL) {
947 /*
948 * If the BIOS has set an out of range IRQ number, just ignore it.
949 * Also keep track of which IRQ's are already in use.
950 */
951 if (dev->irq >= 16) {
Daniel Marjamäki81745512005-12-01 18:01:28 +0100952 DBG(KERN_DEBUG "%s: ignoring bogus IRQ %d\n", pci_name(dev), dev->irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700953 dev->irq = 0;
954 }
955 /* If the IRQ is already assigned to a PCI device, ignore its ISA use penalty */
956 if (pirq_penalty[dev->irq] >= 100 && pirq_penalty[dev->irq] < 100000)
957 pirq_penalty[dev->irq] = 0;
958 pirq_penalty[dev->irq]++;
959 }
960
961 dev = NULL;
962 while ((dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, dev)) != NULL) {
963 pci_read_config_byte(dev, PCI_INTERRUPT_PIN, &pin);
964#ifdef CONFIG_X86_IO_APIC
965 /*
966 * Recalculate IRQ numbers if we use the I/O APIC.
967 */
968 if (io_apic_assign_pci_irqs)
969 {
970 int irq;
971
972 if (pin) {
973 pin--; /* interrupt pins are numbered starting from 1 */
974 irq = IO_APIC_get_PCI_irq_vector(dev->bus->number, PCI_SLOT(dev->devfn), pin);
975 /*
976 * Busses behind bridges are typically not listed in the MP-table.
977 * In this case we have to look up the IRQ based on the parent bus,
978 * parent slot, and pin number. The SMP code detects such bridged
979 * busses itself so we should get into this branch reliably.
980 */
981 if (irq < 0 && dev->bus->parent) { /* go back to the bridge */
982 struct pci_dev * bridge = dev->bus->self;
983
984 pin = (pin + PCI_SLOT(dev->devfn)) % 4;
985 irq = IO_APIC_get_PCI_irq_vector(bridge->bus->number,
986 PCI_SLOT(bridge->devfn), pin);
987 if (irq >= 0)
988 printk(KERN_WARNING "PCI: using PPB %s[%c] to get irq %d\n",
989 pci_name(bridge), 'A' + pin, irq);
990 }
991 if (irq >= 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700992 printk(KERN_INFO "PCI->APIC IRQ transform: %s[%c] -> IRQ %d\n",
993 pci_name(dev), 'A' + pin, irq);
994 dev->irq = irq;
995 }
996 }
997 }
998#endif
999 /*
1000 * Still no IRQ? Try to lookup one...
1001 */
1002 if (pin && !dev->irq)
1003 pcibios_lookup_irq(dev, 0);
1004 }
1005}
1006
1007/*
1008 * Work around broken HP Pavilion Notebooks which assign USB to
1009 * IRQ 9 even though it is actually wired to IRQ 11
1010 */
1011static int __init fix_broken_hp_bios_irq9(struct dmi_system_id *d)
1012{
1013 if (!broken_hp_bios_irq9) {
1014 broken_hp_bios_irq9 = 1;
1015 printk(KERN_INFO "%s detected - fixing broken IRQ routing\n", d->ident);
1016 }
1017 return 0;
1018}
1019
1020/*
1021 * Work around broken Acer TravelMate 360 Notebooks which assign
1022 * Cardbus to IRQ 11 even though it is actually wired to IRQ 10
1023 */
1024static int __init fix_acer_tm360_irqrouting(struct dmi_system_id *d)
1025{
1026 if (!acer_tm360_irqrouting) {
1027 acer_tm360_irqrouting = 1;
1028 printk(KERN_INFO "%s detected - fixing broken IRQ routing\n", d->ident);
1029 }
1030 return 0;
1031}
1032
1033static struct dmi_system_id __initdata pciirq_dmi_table[] = {
1034 {
1035 .callback = fix_broken_hp_bios_irq9,
1036 .ident = "HP Pavilion N5400 Series Laptop",
1037 .matches = {
1038 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1039 DMI_MATCH(DMI_BIOS_VERSION, "GE.M1.03"),
1040 DMI_MATCH(DMI_PRODUCT_VERSION, "HP Pavilion Notebook Model GE"),
1041 DMI_MATCH(DMI_BOARD_VERSION, "OmniBook N32N-736"),
1042 },
1043 },
1044 {
1045 .callback = fix_acer_tm360_irqrouting,
1046 .ident = "Acer TravelMate 36x Laptop",
1047 .matches = {
1048 DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
1049 DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 360"),
1050 },
1051 },
1052 { }
1053};
1054
1055static int __init pcibios_irq_init(void)
1056{
Daniel Marjamäki81745512005-12-01 18:01:28 +01001057 DBG(KERN_DEBUG "PCI: IRQ init\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001058
1059 if (pcibios_enable_irq || raw_pci_ops == NULL)
1060 return 0;
1061
1062 dmi_check_system(pciirq_dmi_table);
1063
1064 pirq_table = pirq_find_routing_table();
1065
1066#ifdef CONFIG_PCI_BIOS
1067 if (!pirq_table && (pci_probe & PCI_BIOS_IRQ_SCAN))
1068 pirq_table = pcibios_get_irq_routing_table();
1069#endif
1070 if (pirq_table) {
1071 pirq_peer_trick();
1072 pirq_find_router(&pirq_router);
1073 if (pirq_table->exclusive_irqs) {
1074 int i;
1075 for (i=0; i<16; i++)
1076 if (!(pirq_table->exclusive_irqs & (1 << i)))
1077 pirq_penalty[i] += 100;
1078 }
1079 /* If we're using the I/O APIC, avoid using the PCI IRQ routing table */
1080 if (io_apic_assign_pci_irqs)
1081 pirq_table = NULL;
1082 }
1083
1084 pcibios_enable_irq = pirq_enable_irq;
1085
1086 pcibios_fixup_irqs();
1087 return 0;
1088}
1089
1090subsys_initcall(pcibios_irq_init);
1091
1092
David Shaohua Lic9c3e452005-04-01 00:07:31 -05001093static void pirq_penalize_isa_irq(int irq, int active)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001094{
1095 /*
1096 * If any ISAPnP device reports an IRQ in its list of possible
1097 * IRQ's, we try to avoid assigning it to PCI devices.
1098 */
David Shaohua Lic9c3e452005-04-01 00:07:31 -05001099 if (irq < 16) {
1100 if (active)
1101 pirq_penalty[irq] += 1000;
1102 else
1103 pirq_penalty[irq] += 100;
1104 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001105}
1106
David Shaohua Lic9c3e452005-04-01 00:07:31 -05001107void pcibios_penalize_isa_irq(int irq, int active)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001108{
Len Brown6153df7b2005-08-25 12:27:09 -04001109#ifdef CONFIG_ACPI
Linus Torvalds1da177e2005-04-16 15:20:36 -07001110 if (!acpi_noirq)
David Shaohua Lic9c3e452005-04-01 00:07:31 -05001111 acpi_penalize_isa_irq(irq, active);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001112 else
1113#endif
David Shaohua Lic9c3e452005-04-01 00:07:31 -05001114 pirq_penalize_isa_irq(irq, active);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001115}
1116
1117static int pirq_enable_irq(struct pci_dev *dev)
1118{
1119 u8 pin;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001120 struct pci_dev *temp_dev;
1121
1122 pci_read_config_byte(dev, PCI_INTERRUPT_PIN, &pin);
1123 if (pin && !pcibios_lookup_irq(dev, 1) && !dev->irq) {
1124 char *msg = "";
1125
1126 pin--; /* interrupt pins are numbered starting from 1 */
1127
1128 if (io_apic_assign_pci_irqs) {
1129 int irq;
1130
1131 irq = IO_APIC_get_PCI_irq_vector(dev->bus->number, PCI_SLOT(dev->devfn), pin);
1132 /*
1133 * Busses behind bridges are typically not listed in the MP-table.
1134 * In this case we have to look up the IRQ based on the parent bus,
1135 * parent slot, and pin number. The SMP code detects such bridged
1136 * busses itself so we should get into this branch reliably.
1137 */
1138 temp_dev = dev;
1139 while (irq < 0 && dev->bus->parent) { /* go back to the bridge */
1140 struct pci_dev * bridge = dev->bus->self;
1141
1142 pin = (pin + PCI_SLOT(dev->devfn)) % 4;
1143 irq = IO_APIC_get_PCI_irq_vector(bridge->bus->number,
1144 PCI_SLOT(bridge->devfn), pin);
1145 if (irq >= 0)
1146 printk(KERN_WARNING "PCI: using PPB %s[%c] to get irq %d\n",
1147 pci_name(bridge), 'A' + pin, irq);
1148 dev = bridge;
1149 }
1150 dev = temp_dev;
1151 if (irq >= 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001152 printk(KERN_INFO "PCI->APIC IRQ transform: %s[%c] -> IRQ %d\n",
1153 pci_name(dev), 'A' + pin, irq);
1154 dev->irq = irq;
1155 return 0;
1156 } else
1157 msg = " Probably buggy MP table.";
1158 } else if (pci_probe & PCI_BIOS_IRQ_SCAN)
1159 msg = "";
1160 else
1161 msg = " Please try using pci=biosirq.";
1162
1163 /* With IDE legacy devices the IRQ lookup failure is not a problem.. */
1164 if (dev->class >> 8 == PCI_CLASS_STORAGE_IDE && !(dev->class & 0x5))
1165 return 0;
1166
1167 printk(KERN_WARNING "PCI: No IRQ known for interrupt pin %c of device %s.%s\n",
1168 'A' + pin, pci_name(dev), msg);
1169 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001170 return 0;
1171}