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