开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
pci-irq.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：22k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

pci-irq.c：源码内容
  1. /*
  2.  * Low-Level PCI Support for PC -- Routing of Interrupts
  3.  *
  4.  * (c) 1999--2000 Martin Mares <mj@ucw.cz>
  5.  */
  7. #include <linux/config.h>
  8. #include <linux/types.h>
  9. #include <linux/kernel.h>
  10. #include <linux/pci.h>
  11. #include <linux/init.h>
  12. #include <linux/slab.h>
  13. #include <linux/interrupt.h>
  14. #include <linux/irq.h>
  16. #include <asm/io.h>
  17. #include <asm/smp.h>
  18. #include <asm/io_apic.h>
  20. #include "pci-i386.h"
  22. #define PIRQ_SIGNATURE (('$' << 0) + ('P' << 8) + ('I' << 16) + ('R' << 24))
  23. #define PIRQ_VERSION 0x0100
  25. int broken_hp_bios_irq9;
  27. static struct irq_routing_table *pirq_table;
  29. /*
  30.  * Never use: 0, 1, 2 (timer, keyboard, and cascade)
  31.  * Avoid using: 13, 14 and 15 (FP error and IDE).
  32.  * Penalize: 3, 4, 6, 7, 12 (known ISA uses: serial, floppy, parallel and mouse)
  33.  */
  34. unsigned int pcibios_irq_mask = 0xfff8;
  36. static int pirq_penalty[16] = {
  37. 1000000, 1000000, 1000000, 1000, 1000, 0, 1000, 1000,
  38. 0, 0, 0, 0, 1000, 100000, 100000, 100000
  39. };
  41. struct irq_router {
  42. char *name;
  43. u16 vendor, device;
  44. int (*get)(struct pci_dev *router, struct pci_dev *dev, int pirq);
  45. int (*set)(struct pci_dev *router, struct pci_dev *dev, int pirq, int new);
  46. };
  48. /*
  49.  *  Search 0xf0000 -- 0xfffff for the PCI IRQ Routing Table.
  50.  */
  52. static struct irq_routing_table * __init pirq_find_routing_table(void)
  53. {
  54. u8 *addr;
  55. struct irq_routing_table *rt;
  56. int i;
  57. u8 sum;
  59. for(addr = (u8 *) __va(0xf0000); addr < (u8 *) __va(0x100000); addr += 16) {
  60. rt = (struct irq_routing_table *) addr;
  61. if (rt->signature != PIRQ_SIGNATURE ||
  62.     rt->version != PIRQ_VERSION ||
  63.     rt->size % 16 ||
  64.     rt->size < sizeof(struct irq_routing_table))
  65. continue;
  66. sum = 0;
  67. for(i=0; i<rt->size; i++)
  68. sum += addr[i];
  69. if (!sum) {
  70. DBG("PCI: Interrupt Routing Table found at 0x%pn", rt);
  71. return rt;
  72. }
  73. }
  74. return NULL;
  75. }
  77. /*
  78.  *  If we have a IRQ routing table, use it to search for peer host
  79.  *  bridges.  It's a gross hack, but since there are no other known
  80.  *  ways how to get a list of buses, we have to go this way.
  81.  */
  83. static void __init pirq_peer_trick(void)
  84. {
  85. struct irq_routing_table *rt = pirq_table;
  86. u8 busmap[256];
  87. int i;
  88. struct irq_info *e;
  90. memset(busmap, 0, sizeof(busmap));
  91. for(i=0; i < (rt->size - sizeof(struct irq_routing_table)) / sizeof(struct irq_info); i++) {
  92. e = &rt->slots[i];
  93. #ifdef DEBUG
  94. {
  95. int j;
  96. DBG("%02x:%02x slot=%02x", e->bus, e->devfn/8, e->slot);
  97. for(j=0; j<4; j++)
  98. DBG(" %d:%02x/%04x", j, e->irq[j].link, e->irq[j].bitmap);
  99. DBG("n");
  100. }
  101. #endif
  102. busmap[e->bus] = 1;
  103. }
  104. for(i=1; i<256; i++)
  105. /*
  106.  *  It might be a secondary bus, but in this case its parent is already
  107.  *  known (ascending bus order) and therefore pci_scan_bus returns immediately.
  108.  */
  109. if (busmap[i] && pci_scan_bus(i, pci_root_bus->ops, NULL))
  110. printk(KERN_INFO "PCI: Discovered primary peer bus %02x [IRQ]n", i);
  111. pcibios_last_bus = -1;
  112. }
  114. /*
  115.  *  Code for querying and setting of IRQ routes on various interrupt routers.
  116.  */
  118. static void eisa_set_level_irq(unsigned int irq)
  119. {
  120. unsigned char mask = 1 << (irq & 7);
  121. unsigned int port = 0x4d0 + (irq >> 3);
  122. unsigned char val = inb(port);
  124. if (!(val & mask)) {
  125. DBG(" -> edge");
  126. outb(val | mask, port);
  127. }
  128. }
  130. /*
  131.  * Common IRQ routing practice: nybbles in config space,
  132.  * offset by some magic constant.
  133.  */
  134. static unsigned int read_config_nybble(struct pci_dev *router, unsigned offset, unsigned nr)
  135. {
  136. u8 x;
  137. unsigned reg = offset + (nr >> 1);
  139. pci_read_config_byte(router, reg, &x);
  140. return (nr & 1) ? (x >> 4) : (x & 0xf);
  141. }
  143. static void write_config_nybble(struct pci_dev *router, unsigned offset, unsigned nr, unsigned int val)
  144. {
  145. u8 x;
  146. unsigned reg = offset + (nr >> 1);
  148. pci_read_config_byte(router, reg, &x);
  149. x = (nr & 1) ? ((x & 0x0f) | (val << 4)) : ((x & 0xf0) | val);
  150. pci_write_config_byte(router, reg, x);
  151. }
  153. /*
  154.  * ALI pirq entries are damn ugly, and completely undocumented.
  155.  * This has been figured out from pirq tables, and it's not a pretty
  156.  * picture.
  157.  */
  158. static int pirq_ali_get(struct pci_dev *router, struct pci_dev *dev, int pirq)
  159. {
  160. static unsigned char irqmap[16] = { 0, 9, 3, 10, 4, 5, 7, 6, 1, 11, 0, 12, 0, 14, 0, 15 };
  162. return irqmap[read_config_nybble(router, 0x48, pirq-1)];
  163. }
  165. static int pirq_ali_set(struct pci_dev *router, struct pci_dev *dev, int pirq, int irq)
  166. {
  167. static unsigned char irqmap[16] = { 0, 8, 0, 2, 4, 5, 7, 6, 0, 1, 3, 9, 11, 0, 13, 15 };
  168. unsigned int val = irqmap[irq];
  170. if (val) {
  171. write_config_nybble(router, 0x48, pirq-1, val);
  172. return 1;
  173. }
  174. return 0;
  175. }
  177. /*
  178.  * The Intel PIIX4 pirq rules are fairly simple: "pirq" is
  179.  * just a pointer to the config space.
  180.  */
  181. static int pirq_piix_get(struct pci_dev *router, struct pci_dev *dev, int pirq)
  182. {
  183. u8 x;
  185. pci_read_config_byte(router, pirq, &x);
  186. return (x < 16) ? x : 0;
  187. }
  189. static int pirq_piix_set(struct pci_dev *router, struct pci_dev *dev, int pirq, int irq)
  190. {
  191. pci_write_config_byte(router, pirq, irq);
  192. return 1;
  193. }
  195. /*
  196.  * The VIA pirq rules are nibble-based, like ALI,
  197.  * but without the ugly irq number munging.
  198.  */
  199. static int pirq_via_get(struct pci_dev *router, struct pci_dev *dev, int pirq)
  200. {
  201. return read_config_nybble(router, 0x55, pirq);
  202. }
  204. static int pirq_via_set(struct pci_dev *router, struct pci_dev *dev, int pirq, int irq)
  205. {
  206. write_config_nybble(router, 0x55, pirq, irq);
  207. return 1;
  208. }
  210. /*
  211.  * ITE 8330G pirq rules are nibble-based
  212.  * FIXME: pirqmap may be { 1, 0, 3, 2 },
  213.  *    2+3 are both mapped to irq 9 on my system
  214.  */
  215. static int pirq_ite_get(struct pci_dev *router, struct pci_dev *dev, int pirq)
  216. {
  217. static unsigned char pirqmap[4] = { 1, 0, 2, 3 };
  218. return read_config_nybble(router,0x43, pirqmap[pirq-1]);
  219. }
  221. static int pirq_ite_set(struct pci_dev *router, struct pci_dev *dev, int pirq, int irq)
  222. {
  223. static unsigned char pirqmap[4] = { 1, 0, 2, 3 };
  224. write_config_nybble(router, 0x43, pirqmap[pirq-1], irq);
  225. return 1;
  226. }
  228. /*
  229.  * OPTI: high four bits are nibble pointer..
  230.  * I wonder what the low bits do?
  231.  */
  232. static int pirq_opti_get(struct pci_dev *router, struct pci_dev *dev, int pirq)
  233. {
  234. return read_config_nybble(router, 0xb8, pirq >> 4);
  235. }
  237. static int pirq_opti_set(struct pci_dev *router, struct pci_dev *dev, int pirq, int irq)
  238. {
  239. write_config_nybble(router, 0xb8, pirq >> 4, irq);
  240. return 1;
  241. }
  243. /*
  244.  * Cyrix: nibble offset 0x5C
  245.  */
  246. static int pirq_cyrix_get(struct pci_dev *router, struct pci_dev *dev, int pirq)
  247. {
  248. return read_config_nybble(router, 0x5C, (pirq-1)^1);
  249. }
  251. static int pirq_cyrix_set(struct pci_dev *router, struct pci_dev *dev, int pirq, int irq)
  252. {
  253. write_config_nybble(router, 0x5C, (pirq-1)^1, irq);
  254. return 1;
  255. }
  257. /*
  258.  * PIRQ routing for SiS 85C503 router used in several SiS chipsets
  259.  * According to the SiS 5595 datasheet (preliminary V1.0, 12/24/1997)
  260.  * the related registers work as follows:
  261.  *
  262.  * general: one byte per re-routable IRQ,
  263.  *  bit 7      IRQ mapping enabled (0) or disabled (1)
  264.  *  bits [6:4] reserved
  265.  *  bits [3:0] IRQ to map to
  266.  *      allowed: 3-7, 9-12, 14-15
  267.  *      reserved: 0, 1, 2, 8, 13
  268.  *
  269.  * individual registers in device config space:
  270.  *
  271.  * 0x41/0x42/0x43/0x44: PCI INT A/B/C/D - bits as in general case
  272.  *
  273.  * 0x61: IDEIRQ: bits as in general case - but:
  274.  * bits [6:5] must be written 01
  275.  * bit 4 channel-select primary (0), secondary (1)
  276.  *
  277.  * 0x62: USBIRQ: bits as in general case - but:
  278.  * bit 4 OHCI function disabled (0), enabled (1)
  279.  *
  280.  * 0x6a: ACPI/SCI IRQ - bits as in general case
  281.  *
  282.  * 0x7e: Data Acq. Module IRQ - bits as in general case
  283.  *
  284.  * Apparently there are systems implementing PCI routing table using both
  285.  * link values 0x01-0x04 and 0x41-0x44 for PCI INTA..D, but register offsets
  286.  * like 0x62 as link values for USBIRQ e.g. So there is no simple
  287.  * "register = offset + pirq" relation.
  288.  * Currently we support PCI INTA..D and USBIRQ and try our best to handle
  289.  * both link mappings.
  290.  * IDE/ACPI/DAQ mapping is currently unsupported (left untouched as set by BIOS).
  291.  */
  293. static int pirq_sis_get(struct pci_dev *router, struct pci_dev *dev, int pirq)
  294. {
  295. u8 x;
  296. int reg = pirq;
  298. switch(pirq) {
  299. case 0x01:
  300. case 0x02:
  301. case 0x03:
  302. case 0x04:
  303. reg += 0x40;
  304. case 0x41:
  305. case 0x42:
  306. case 0x43:
  307. case 0x44:
  308. case 0x62:
  309. pci_read_config_byte(router, reg, &x);
  310. if (reg != 0x62)
  311. break;
  312. if (!(x & 0x40))
  313. return 0;
  314. break;
  315. case 0x61:
  316. case 0x6a:
  317. case 0x7e:
  318. printk(KERN_INFO "SiS pirq: advanced IDE/ACPI/DAQ mapping not yet implementedn");
  319. return 0;
  320. default:
  321. printk(KERN_INFO "SiS router pirq escape (%d)n", pirq);
  322. return 0;
  323. }
  324. return (x & 0x80) ? 0 : (x & 0x0f);
  325. }
  327. static int pirq_sis_set(struct pci_dev *router, struct pci_dev *dev, int pirq, int irq)
  328. {
  329. u8 x;
  330. int reg = pirq;
  332. switch(pirq) {
  333. case 0x01:
  334. case 0x02:
  335. case 0x03:
  336. case 0x04:
  337. reg += 0x40;
  338. case 0x41:
  339. case 0x42:
  340. case 0x43:
  341. case 0x44:
  342. case 0x62:
  343. x = (irq&0x0f) ? (irq&0x0f) : 0x80;
  344. if (reg != 0x62)
  345. break;
  346. /* always mark OHCI enabled, as nothing else knows about this */
  347. x |= 0x40;
  348. break;
  349. case 0x61:
  350. case 0x6a:
  351. case 0x7e:
  352. printk(KERN_INFO "advanced SiS pirq mapping not yet implementedn");
  353. return 0;
  354. default:
  355. printk(KERN_INFO "SiS router pirq escape (%d)n", pirq);
  356. return 0;
  357. }
  358. pci_write_config_byte(router, reg, x);
  360. return 1;
  361. }
  363. /*
  364.  * VLSI: nibble offset 0x74 - educated guess due to routing table and
  365.  *       config space of VLSI 82C534 PCI-bridge/router (1004:0102)
  366.  *       Tested on HP OmniBook 800 covering PIRQ 1, 2, 4, 8 for onboard
  367.  *       devices, PIRQ 3 for non-pci(!) soundchip and (untested) PIRQ 6
  368.  *       for the busbridge to the docking station.
  369.  */
  371. static int pirq_vlsi_get(struct pci_dev *router, struct pci_dev *dev, int pirq)
  372. {
  373. if (pirq > 8) {
  374. printk(KERN_INFO "VLSI router pirq escape (%d)n", pirq);
  375. return 0;
  376. }
  377. return read_config_nybble(router, 0x74, pirq-1);
  378. }
  380. static int pirq_vlsi_set(struct pci_dev *router, struct pci_dev *dev, int pirq, int irq)
  381. {
  382. if (pirq > 8) {
  383. printk(KERN_INFO "VLSI router pirq escape (%d)n", pirq);
  384. return 0;
  385. }
  386. write_config_nybble(router, 0x74, pirq-1, irq);
  387. return 1;
  388. }
  390. /*
  391.  * ServerWorks: PCI interrupts mapped to system IRQ lines through Index
  392.  * and Redirect I/O registers (0x0c00 and 0x0c01).  The Index register
  393.  * format is (PCIIRQ## | 0x10), e.g.: PCIIRQ10=0x1a.  The Redirect
  394.  * register is a straight binary coding of desired PIC IRQ (low nibble).
  395.  *
  396.  * The 'link' value in the PIRQ table is already in the correct format
  397.  * for the Index register.  There are some special index values:
  398.  * 0x00 for ACPI (SCI), 0x01 for USB, 0x02 for IDE0, 0x04 for IDE1,
  399.  * and 0x03 for SMBus.
  400.  */
  401. static int pirq_serverworks_get(struct pci_dev *router, struct pci_dev *dev, int pirq)
  402. {
  403. outb_p(pirq, 0xc00);
  404. return inb(0xc01) & 0xf;
  405. }
  407. static int pirq_serverworks_set(struct pci_dev *router, struct pci_dev *dev, int pirq, int irq)
  408. {
  409. outb_p(pirq, 0xc00);
  410. outb_p(irq, 0xc01);
  411. return 1;
  412. }
  414. /* Support for AMD756 PCI IRQ Routing
  415.  * Jhon H. Caicedo <jhcaiced@osso.org.co>
  416.  * Jun/21/2001 0.2.0 Release, fixed to use "nybble" functions... (jhcaiced)
  417.  * Jun/19/2001 Alpha Release 0.1.0 (jhcaiced)
  418.  * The AMD756 pirq rules are nibble-based
  419.  * offset 0x56 0-3 PIRQA  4-7  PIRQB
  420.  * offset 0x57 0-3 PIRQC  4-7  PIRQD
  421.  */
  422. static int pirq_amd756_get(struct pci_dev *router, struct pci_dev *dev, int pirq)
  423. {
  424. u8 irq;
  425. irq = 0;
  426. if (pirq <= 4)
  427. {
  428. irq = read_config_nybble(router, 0x56, pirq - 1);
  429. }
  430. printk(KERN_INFO "AMD756: dev %04x:%04x, router pirq : %d get irq : %2dn",
  431. dev->vendor, dev->device, pirq, irq);
  432. return irq;
  433. }
  435. static int pirq_amd756_set(struct pci_dev *router, struct pci_dev *dev, int pirq, int irq)
  436. {
  437. printk(KERN_INFO "AMD756: dev %04x:%04x, router pirq : %d SET irq : %2dn", 
  438. dev->vendor, dev->device, pirq, irq);
  439. if (pirq <= 4)
  440. {
  441. write_config_nybble(router, 0x56, pirq - 1, irq);
  442. }
  443. return 1;
  444. }
  446. #ifdef CONFIG_PCI_BIOS
  448. static int pirq_bios_set(struct pci_dev *router, struct pci_dev *dev, int pirq, int irq)
  449. {
  450. struct pci_dev *bridge;
  451. int pin = pci_get_interrupt_pin(dev, &bridge);
  452. return pcibios_set_irq_routing(bridge, pin, irq);
  453. }
  455. static struct irq_router pirq_bios_router =
  456. { "BIOS", 0, 0, NULL, pirq_bios_set };
  458. #endif
  460. static struct irq_router pirq_routers[] = {
  461. { "PIIX", PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82371FB_0, pirq_piix_get, pirq_piix_set },
  462. { "PIIX", PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82371SB_0, pirq_piix_get, pirq_piix_set },
  463. { "PIIX", PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82371AB_0, pirq_piix_get, pirq_piix_set },
  464. { "PIIX", PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82371MX,   pirq_piix_get, pirq_piix_set },
  465. { "PIIX", PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82443MX_0, pirq_piix_get, pirq_piix_set },
  466. { "PIIX", PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801AA_0, pirq_piix_get, pirq_piix_set },
  467. { "PIIX", PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801AB_0, pirq_piix_get, pirq_piix_set },
  468. { "PIIX", PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801BA_0, pirq_piix_get, pirq_piix_set },
  469. { "PIIX", PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801BA_10, pirq_piix_get, pirq_piix_set },
  470. { "PIIX", PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801CA_0, pirq_piix_get, pirq_piix_set },
  471. { "PIIX", PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801CA_12, pirq_piix_get, pirq_piix_set },
  472. { "PIIX", PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801DB_0, pirq_piix_get, pirq_piix_set },
  473. { "PIIX", PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801E_0, pirq_piix_get, pirq_piix_set },
  475. { "ALI", PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M1533, pirq_ali_get, pirq_ali_set },
  477. { "ITE", PCI_VENDOR_ID_ITE, PCI_DEVICE_ID_ITE_IT8330G_0, pirq_ite_get, pirq_ite_set },
  479. { "VIA", PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C586_0, pirq_via_get, pirq_via_set },
  480. { "VIA", PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C596, pirq_via_get, pirq_via_set },
  481. { "VIA", PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C686, pirq_via_get, pirq_via_set },
  483. { "OPTI", PCI_VENDOR_ID_OPTI, PCI_DEVICE_ID_OPTI_82C700, pirq_opti_get, pirq_opti_set },
  485. { "NatSemi", PCI_VENDOR_ID_CYRIX, PCI_DEVICE_ID_CYRIX_5520, pirq_cyrix_get, pirq_cyrix_set },
  486. { "SIS", PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_503, pirq_sis_get, pirq_sis_set },
  487. { "VLSI 82C534", PCI_VENDOR_ID_VLSI, PCI_DEVICE_ID_VLSI_82C534, pirq_vlsi_get, pirq_vlsi_set },
  488. { "ServerWorks", PCI_VENDOR_ID_SERVERWORKS, PCI_DEVICE_ID_SERVERWORKS_OSB4,
  489.   pirq_serverworks_get, pirq_serverworks_set },
  490. { "ServerWorks", PCI_VENDOR_ID_SERVERWORKS, PCI_DEVICE_ID_SERVERWORKS_CSB5,
  491.   pirq_serverworks_get, pirq_serverworks_set },
  492. { "AMD756 VIPER", PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_VIPER_740B,
  493. pirq_amd756_get, pirq_amd756_set },
  494. { "AMD766", PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_VIPER_7413,
  495. pirq_amd756_get, pirq_amd756_set },
  496. { "AMD768", PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_VIPER_7443,
  497. pirq_amd756_get, pirq_amd756_set },
  499. { "default", 0, 0, NULL, NULL }
  500. };
  502. static struct irq_router *pirq_router;
  503. static struct pci_dev *pirq_router_dev;
  505. static void __init pirq_find_router(void)
  506. {
  507. struct irq_routing_table *rt = pirq_table;
  508. struct irq_router *r;
  510. #ifdef CONFIG_PCI_BIOS
  511. if (!rt->signature) {
  512. printk(KERN_INFO "PCI: Using BIOS for IRQ routingn");
  513. pirq_router = &pirq_bios_router;
  514. return;
  515. }
  516. #endif
  518. DBG("PCI: Attempting to find IRQ router for %04x:%04xn",
  519.     rt->rtr_vendor, rt->rtr_device);
  521. /* fall back to default router if nothing else found */
  522. pirq_router = &pirq_routers[ARRAY_SIZE(pirq_routers) - 1];
  524. pirq_router_dev = pci_find_slot(rt->rtr_bus, rt->rtr_devfn);
  525. if (!pirq_router_dev) {
  526. DBG("PCI: Interrupt router not found at %02x:%02xn", rt->rtr_bus, rt->rtr_devfn);
  527. return;
  528. }
  530. for(r=pirq_routers; r->vendor; r++) {
  531. /* Exact match against router table entry? Use it! */
  532. if (r->vendor == rt->rtr_vendor && r->device == rt->rtr_device) {
  533. pirq_router = r;
  534. break;
  535. }
  536. /* Match against router device entry? Use it as a fallback */
  537. if (r->vendor == pirq_router_dev->vendor && r->device == pirq_router_dev->device) {
  538. pirq_router = r;
  539. }
  540. }
  541. printk(KERN_INFO "PCI: Using IRQ router %s [%04x/%04x] at %sn",
  542. pirq_router->name,
  543. pirq_router_dev->vendor,
  544. pirq_router_dev->device,
  545. pirq_router_dev->slot_name);
  546. }
  548. static struct irq_info *pirq_get_info(struct pci_dev *dev)
  549. {
  550. struct irq_routing_table *rt = pirq_table;
  551. int entries = (rt->size - sizeof(struct irq_routing_table)) / sizeof(struct irq_info);
  552. struct irq_info *info;
  554. for (info = rt->slots; entries--; info++)
  555. if (info->bus == dev->bus->number && PCI_SLOT(info->devfn) == PCI_SLOT(dev->devfn))
  556. return info;
  557. return NULL;
  558. }
  560. static void pcibios_test_irq_handler(int irq, void *dev_id, struct pt_regs *regs)
  561. {
  562. }
  564. static int pcibios_lookup_irq(struct pci_dev *dev, int assign)
  565. {
  566. u8 pin;
  567. struct irq_info *info;
  568. int i, pirq, newirq;
  569. int irq = 0;
  570. u32 mask;
  571. struct irq_router *r = pirq_router;
  572. struct pci_dev *dev2;
  573. char *msg = NULL;
  575. if (!pirq_table)
  576. return 0;
  578. /* Find IRQ routing entry */
  579. pci_read_config_byte(dev, PCI_INTERRUPT_PIN, &pin);
  580. if (!pin) {
  581. DBG(" -> no interrupt pinn");
  582. return 0;
  583. }
  584. pin = pin - 1;
  586. DBG("IRQ for %s:%d", dev->slot_name, pin);
  587. info = pirq_get_info(dev);
  588. if (!info) {
  589. DBG(" -> not found in routing tablen");
  590. return 0;
  591. }
  592. pirq = info->irq[pin].link;
  593. mask = info->irq[pin].bitmap;
  594. if (!pirq) {
  595. DBG(" -> not routedn");
  596. return 0;
  597. }
  598. DBG(" -> PIRQ %02x, mask %04x, excl %04x", pirq, mask, pirq_table->exclusive_irqs);
  599. mask &= pcibios_irq_mask;
  601. /* Work around broken HP Pavilion Notebooks which assign USB to
  602.    IRQ 9 even though it is actually wired to IRQ 11 */
  604. if (broken_hp_bios_irq9 && pirq == 0x59 && dev->irq == 9) {
  605. dev->irq = 11;
  606. pci_write_config_byte(dev, PCI_INTERRUPT_LINE, 11);
  607. r->set(pirq_router_dev, dev, pirq, 11);
  608. }
  610. /*
  611.  * Find the best IRQ to assign: use the one
  612.  * reported by the device if possible.
  613.  */
  614. newirq = dev->irq;
  615. if (!newirq && assign) {
  616. for (i = 0; i < 16; i++) {
  617. if (!(mask & (1 << i)))
  618. continue;
  619. if (pirq_penalty[i] < pirq_penalty[newirq] &&
  620.     !request_irq(i, pcibios_test_irq_handler, SA_SHIRQ, "pci-test", dev)) {
  621. free_irq(i, dev);
  622. newirq = i;
  623. }
  624. }
  625. }
  626. DBG(" -> newirq=%d", newirq);
  628. /* Check if it is hardcoded */
  629. if ((pirq & 0xf0) == 0xf0) {
  630. irq = pirq & 0xf;
  631. DBG(" -> hardcoded IRQ %dn", irq);
  632. msg = "Hardcoded";
  633. } else if (r->get && (irq = r->get(pirq_router_dev, dev, pirq))) {
  634. DBG(" -> got IRQ %dn", irq);
  635. msg = "Found";
  636. } else if (newirq && r->set && (dev->class >> 8) != PCI_CLASS_DISPLAY_VGA) {
  637. DBG(" -> assigning IRQ %d", newirq);
  638. if (r->set(pirq_router_dev, dev, pirq, newirq)) {
  639. eisa_set_level_irq(newirq);
  640. DBG(" ... OKn");
  641. msg = "Assigned";
  642. irq = newirq;
  643. }
  644. }
  646. if (!irq) {
  647. DBG(" ... failedn");
  648. if (newirq && mask == (1 << newirq)) {
  649. msg = "Guessed";
  650. irq = newirq;
  651. } else
  652. return 0;
  653. }
  654. printk(KERN_INFO "PCI: %s IRQ %d for device %sn", msg, irq, dev->slot_name);
  656. /* Update IRQ for all devices with the same pirq value */
  657. pci_for_each_dev(dev2) {
  658. pci_read_config_byte(dev2, PCI_INTERRUPT_PIN, &pin);
  659. if (!pin)
  660. continue;
  661. pin--;
  662. info = pirq_get_info(dev2);
  663. if (!info)
  664. continue;
  665. if (info->irq[pin].link == pirq) {
  666. /* We refuse to override the dev->irq information. Give a warning! */
  667.      if (dev2->irq && dev2->irq != irq) {
  668.      printk(KERN_INFO "IRQ routing conflict for %s, have irq %d, want irq %dn",
  669.        dev2->slot_name, dev2->irq, irq);
  670.      continue;
  671.      }
  672. dev2->irq = irq;
  673. pirq_penalty[irq]++;
  674. if (dev != dev2)
  675. printk(KERN_INFO "PCI: Sharing IRQ %d with %sn", irq, dev2->slot_name);
  676. }
  677. }
  678. return 1;
  679. }
  681. void __init pcibios_irq_init(void)
  682. {
  683. DBG("PCI: IRQ initn");
  684. pirq_table = pirq_find_routing_table();
  685. #ifdef CONFIG_PCI_BIOS
  686. if (!pirq_table && (pci_probe & PCI_BIOS_IRQ_SCAN))
  687. pirq_table = pcibios_get_irq_routing_table();
  688. #endif
  689. if (pirq_table) {
  690. pirq_peer_trick();
  691. pirq_find_router();
  692. if (pirq_table->exclusive_irqs) {
  693. int i;
  694. for (i=0; i<16; i++)
  695. if (!(pirq_table->exclusive_irqs & (1 << i)))
  696. pirq_penalty[i] += 100;
  697. }
  698. /* If we're using the I/O APIC, avoid using the PCI IRQ routing table */
  699. if (io_apic_assign_pci_irqs)
  700. pirq_table = NULL;
  701. }
  702. }
  704. void __init pcibios_fixup_irqs(void)
  705. {
  706. struct pci_dev *dev;
  707. u8 pin;
  709. DBG("PCI: IRQ fixupn");
  710. pci_for_each_dev(dev) {
  711. /*
  712.  * If the BIOS has set an out of range IRQ number, just ignore it.
  713.  * Also keep track of which IRQ's are already in use.
  714.  */
  715. if (dev->irq >= 16) {
  716. DBG("%s: ignoring bogus IRQ %dn", dev->slot_name, dev->irq);
  717. dev->irq = 0;
  718. }
  719. /* If the IRQ is already assigned to a PCI device, ignore its ISA use penalty */
  720. if (pirq_penalty[dev->irq] >= 100 && pirq_penalty[dev->irq] < 100000)
  721. pirq_penalty[dev->irq] = 0;
  722. pirq_penalty[dev->irq]++;
  723. }
  725. pci_for_each_dev(dev) {
  726. pci_read_config_byte(dev, PCI_INTERRUPT_PIN, &pin);
  727. #ifdef CONFIG_X86_IO_APIC
  728. /*
  729.  * Recalculate IRQ numbers if we use the I/O APIC.
  730.  */
  731. if (io_apic_assign_pci_irqs)
  732. {
  733. int irq;
  735. if (pin) {
  736. pin--; /* interrupt pins are numbered starting from 1 */
  737. irq = IO_APIC_get_PCI_irq_vector(dev->bus->number, PCI_SLOT(dev->devfn), pin);
  738. /*
  739.  * Busses behind bridges are typically not listed in the MP-table.
  740.  * In this case we have to look up the IRQ based on the parent bus,
  741.  * parent slot, and pin number. The SMP code detects such bridged
  742.  * busses itself so we should get into this branch reliably.
  743.  */
  744. if (irq < 0 && dev->bus->parent) { /* go back to the bridge */
  745. struct pci_dev * bridge = dev->bus->self;
  747. pin = (pin + PCI_SLOT(dev->devfn)) % 4;
  748. irq = IO_APIC_get_PCI_irq_vector(bridge->bus->number, 
  749. PCI_SLOT(bridge->devfn), pin);
  750. if (irq >= 0)
  751. printk(KERN_WARNING "PCI: using PPB(B%d,I%d,P%d) to get irq %dn", 
  752. bridge->bus->number, PCI_SLOT(bridge->devfn), pin, irq);
  753. }
  754. if (irq >= 0) {
  755. printk(KERN_INFO "PCI->APIC IRQ transform: (B%d,I%d,P%d) -> %dn",
  756. dev->bus->number, PCI_SLOT(dev->devfn), pin, irq);
  757. dev->irq = irq;
  758. }
  759. }
  760. }
  761. #endif
  762. /*
  763.  * Still no IRQ? Try to lookup one...
  764.  */
  765. if (pin && !dev->irq)
  766. pcibios_lookup_irq(dev, 0);
  767. }
  768. }
  770. void pcibios_penalize_isa_irq(int irq)
  771. {
  772. /*
  773.  *  If any ISAPnP device reports an IRQ in its list of possible
  774.  *  IRQ's, we try to avoid assigning it to PCI devices.
  775.  */
  776. pirq_penalty[irq] += 100;
  777. }
  779. void pcibios_enable_irq(struct pci_dev *dev)
  780. {
  781. u8 pin;
  782. pci_read_config_byte(dev, PCI_INTERRUPT_PIN, &pin);
  783. if (pin && !pcibios_lookup_irq(dev, 1) && !dev->irq) {
  784. char *msg;
  785. if (io_apic_assign_pci_irqs)
  786. msg = " Probably buggy MP table.";
  787. else if (pci_probe & PCI_BIOS_IRQ_SCAN)
  788. msg = "";
  789. else
  790. msg = " Please try using pci=biosirq.";
  791. printk(KERN_WARNING "PCI: No IRQ known for interrupt pin %c of device %s.%sn",
  792.        'A' + pin - 1, dev->slot_name, msg);
  793. }
  794. }