home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / lxapi32.zip / Linux / PCI / quirks.c < prev    next >
C/C++ Source or Header  |  2002-04-26  |  18KB  |  535 lines
  1. /*
  2.  * $Id: quirks.c,v 1.2 2002/04/26 23:09:32 smilcke Exp $
  3.  *
  4.  *  This file contains work-arounds for many known PCI hardware
  5.  *  bugs.  Devices present only on certain architectures (host
  6.  *  bridges et cetera) should be handled in arch-specific code.
  7.  *
  8.  *  Copyright (c) 1999 Martin Mares <mj@ucw.cz>
  9.  *
  10.  *  The bridge optimization stuff has been removed. If you really
  11.  *  have a silly BIOS which is unable to set your host bridge right,
  12.  *  use the PowerTweak utility (see http://powertweak.sourceforge.net).
  13.  */
  14.  
  15. #include <linux/config.h>
  16. #include <linux/types.h>
  17. #include <linux/kernel.h>
  18. #include <linux/pci.h>
  19. #include <linux/init.h>
  20. #include <linux/delay.h>
  21.  
  22. #undef DEBUG
  23.  
  24. /* Deal with broken BIOS'es that neglect to enable passive release,
  25.    which can cause problems in combination with the 82441FX/PPro MTRRs */
  26. static void __init quirk_passive_release(struct pci_dev *dev)
  27. {
  28.     struct pci_dev *d = NULL;
  29.     unsigned char dlc;
  30.  
  31.     /* We have to make sure a particular bit is set in the PIIX3
  32.        ISA bridge, so we have to go out and find it. */
  33.     while ((d = pci_find_device(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82371SB_0, d))) {
  34.         pci_read_config_byte(d, 0x82, &dlc);
  35.         if (!(dlc & 1<<1)) {
  36.             printk(KERN_ERR "PCI: PIIX3: Enabling Passive Release on %s\n", d->slot_name);
  37.             dlc |= 1<<1;
  38.             pci_write_config_byte(d, 0x82, dlc);
  39.         }
  40.     }
  41. }
  42.  
  43. /*  The VIA VP2/VP3/MVP3 seem to have some 'features'. There may be a workaround
  44.     but VIA don't answer queries. If you happen to have good contacts at VIA
  45.     ask them for me please -- Alan 
  46.     
  47.     This appears to be BIOS not version dependent. So presumably there is a 
  48.     chipset level fix */
  49.     
  50.  
  51. int isa_dma_bridge_buggy;        /* Exported */
  52.     
  53. static void __init quirk_isa_dma_hangs(struct pci_dev *dev)
  54. {
  55.     if (!isa_dma_bridge_buggy) {
  56.         isa_dma_bridge_buggy=1;
  57.         printk(KERN_INFO "Activating ISA DMA hang workarounds.\n");
  58.     }
  59. }
  60.  
  61. int pci_pci_problems;
  62.  
  63. /*
  64.  *    Chipsets where PCI->PCI transfers vanish or hang
  65.  */
  66.  
  67. static void __init quirk_nopcipci(struct pci_dev *dev)
  68. {
  69.     if((pci_pci_problems&PCIPCI_FAIL)==0)
  70.     {
  71.         printk(KERN_INFO "Disabling direct PCI/PCI transfers.\n");
  72.         pci_pci_problems|=PCIPCI_FAIL;
  73.     }
  74. }
  75.  
  76. /*
  77.  *    Triton requires workarounds to be used by the drivers
  78.  */
  79.  
  80. static void __init quirk_triton(struct pci_dev *dev)
  81. {
  82.     if((pci_pci_problems&PCIPCI_TRITON)==0)
  83.     {
  84.         printk(KERN_INFO "Limiting direct PCI/PCI transfers.\n");
  85.         pci_pci_problems|=PCIPCI_TRITON;
  86.     }
  87. }
  88.  
  89. /*
  90.  *    VIA Apollo KT133 needs PCI latency patch
  91.  *    Made according to a windows driver based patch by George E. Breese
  92.  *    see PCI Latency Adjust on http://www.viahardware.com/download/viatweak.shtm
  93.  *      Also see http://home.tiscalinet.de/au-ja/review-kt133a-1-en.html for
  94.  *      the info on which Mr Breese based his work.
  95.  *
  96.  *    Updated based on further information from the site and also on
  97.  *    information provided by VIA 
  98.  */
  99. static void __init quirk_vialatency(struct pci_dev *dev)
  100. {
  101.     struct pci_dev *p;
  102.     u8 rev;
  103.     u8 busarb;
  104.     /* Ok we have a potential problem chipset here. Now see if we have
  105.        a buggy southbridge */
  106.        
  107.     p=pci_find_device(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C686, NULL);
  108.     if(p!=NULL)
  109.     {
  110.         pci_read_config_byte(p, PCI_CLASS_REVISION, &rev);
  111.         /* 0x40 - 0x4f == 686B, 0x10 - 0x2f == 686A; thanks Dan Hollis */
  112.         /* Check for buggy part revisions */
  113.         if (rev < 0x40 || rev > 0x42) 
  114.             return;
  115.     }
  116.     else
  117.     {
  118.         p = pci_find_device(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8231, NULL);
  119.         if(p==NULL)    /* No problem parts */
  120.             return;
  121.         pci_read_config_byte(p, PCI_CLASS_REVISION, &rev);
  122.         /* Check for buggy part revisions */
  123.         if (rev < 0x10 || rev > 0x12) 
  124.             return;
  125.     }
  126.     
  127.     /*
  128.      *    Ok we have the problem. Now set the PCI master grant to 
  129.      *    occur every master grant. The apparent bug is that under high
  130.      *    PCI load (quite common in Linux of course) you can get data
  131.      *    loss when the CPU is held off the bus for 3 bus master requests
  132.      *    This happens to include the IDE controllers....
  133.      *
  134.      *    VIA only apply this fix when an SB Live! is present but under
  135.      *    both Linux and Windows this isnt enough, and we have seen
  136.      *    corruption without SB Live! but with things like 3 UDMA IDE
  137.      *    controllers. So we ignore that bit of the VIA recommendation..
  138.      */
  139.  
  140.     pci_read_config_byte(dev, 0x76, &busarb);
  141.     /* Set bit 4 and bi 5 of byte 76 to 0x01 
  142.        "Master priority rotation on every PCI master grant */
  143.     busarb &= ~(1<<5);
  144.     busarb |= (1<<4);
  145.     pci_write_config_byte(dev, 0x76, busarb);
  146.     printk(KERN_INFO "Applying VIA southbridge workaround.\n");
  147. }
  148.  
  149. /*
  150.  *    VIA Apollo VP3 needs ETBF on BT848/878
  151.  */
  152.  
  153. static void __init quirk_viaetbf(struct pci_dev *dev)
  154. {
  155.     if((pci_pci_problems&PCIPCI_VIAETBF)==0)
  156.     {
  157.         printk(KERN_INFO "Limiting direct PCI/PCI transfers.\n");
  158.         pci_pci_problems|=PCIPCI_VIAETBF;
  159.     }
  160. }
  161. static void __init quirk_vsfx(struct pci_dev *dev)
  162. {
  163.     if((pci_pci_problems&PCIPCI_VSFX)==0)
  164.     {
  165.         printk(KERN_INFO "Limiting direct PCI/PCI transfers.\n");
  166.         pci_pci_problems|=PCIPCI_VSFX;
  167.     }
  168. }
  169.  
  170.  
  171. /*
  172.  *    Natoma has some interesting boundary conditions with Zoran stuff
  173.  *    at least
  174.  */
  175.  
  176. static void __init quirk_natoma(struct pci_dev *dev)
  177. {
  178.     if((pci_pci_problems&PCIPCI_NATOMA)==0)
  179.     {
  180.         printk(KERN_INFO "Limiting direct PCI/PCI transfers.\n");
  181.         pci_pci_problems|=PCIPCI_NATOMA;
  182.     }
  183. }
  184.  
  185. /*
  186.  *  S3 868 and 968 chips report region size equal to 32M, but they decode 64M.
  187.  *  If it's needed, re-allocate the region.
  188.  */
  189.  
  190. static void __init quirk_s3_64M(struct pci_dev *dev)
  191. {
  192.     struct resource *r = &dev->resource[0];
  193.  
  194.     if ((r->start & 0x3ffffff) || r->end != r->start + 0x3ffffff) {
  195.         r->start = 0;
  196.         r->end = 0x3ffffff;
  197.     }
  198. }
  199.  
  200. static void __init quirk_io_region(struct pci_dev *dev, unsigned region, unsigned size, int nr)
  201. {
  202.     region &= ~(size-1);
  203.     if (region) {
  204.         struct resource *res = dev->resource + nr;
  205.  
  206.         res->name = dev->name;
  207.         res->start = region;
  208.         res->end = region + size - 1;
  209.         res->flags = IORESOURCE_IO;
  210.         pci_claim_resource(dev, nr);
  211.     }
  212. }    
  213.  
  214. /*
  215.  * Let's make the southbridge information explicit instead
  216.  * of having to worry about people probing the ACPI areas,
  217.  * for example.. (Yes, it happens, and if you read the wrong
  218.  * ACPI register it will put the machine to sleep with no
  219.  * way of waking it up again. Bummer).
  220.  *
  221.  * ALI M7101: Two IO regions pointed to by words at
  222.  *    0xE0 (64 bytes of ACPI registers)
  223.  *    0xE2 (32 bytes of SMB registers)
  224.  */
  225. static void __init quirk_ali7101_acpi(struct pci_dev *dev)
  226. {
  227.     u16 region;
  228.  
  229.     pci_read_config_word(dev, 0xE0, ®ion);
  230.     quirk_io_region(dev, region, 64, PCI_BRIDGE_RESOURCES);
  231.     pci_read_config_word(dev, 0xE2, ®ion);
  232.     quirk_io_region(dev, region, 32, PCI_BRIDGE_RESOURCES+1);
  233. }
  234.  
  235. /*
  236.  * PIIX4 ACPI: Two IO regions pointed to by longwords at
  237.  *    0x40 (64 bytes of ACPI registers)
  238.  *    0x90 (32 bytes of SMB registers)
  239.  */
  240. static void __init quirk_piix4_acpi(struct pci_dev *dev)
  241. {
  242.     u32 region;
  243.  
  244.     pci_read_config_dword(dev, 0x40, ®ion);
  245.     quirk_io_region(dev, region, 64, PCI_BRIDGE_RESOURCES);
  246.     pci_read_config_dword(dev, 0x90, ®ion);
  247.     quirk_io_region(dev, region, 32, PCI_BRIDGE_RESOURCES+1);
  248. }
  249.  
  250. /*
  251.  * VIA ACPI: One IO region pointed to by longword at
  252.  *    0x48 or 0x20 (256 bytes of ACPI registers)
  253.  */
  254. static void __init quirk_vt82c586_acpi(struct pci_dev *dev)
  255. {
  256.     u8 rev;
  257.     u32 region;
  258.  
  259.     pci_read_config_byte(dev, PCI_CLASS_REVISION, &rev);
  260.     if (rev & 0x10) {
  261.         pci_read_config_dword(dev, 0x48, ®ion);
  262.         region &= PCI_BASE_ADDRESS_IO_MASK;
  263.         quirk_io_region(dev, region, 256, PCI_BRIDGE_RESOURCES);
  264.     }
  265. }
  266.  
  267. /*
  268.  * VIA VT82C686 ACPI: Three IO region pointed to by (long)words at
  269.  *    0x48 (256 bytes of ACPI registers)
  270.  *    0x70 (128 bytes of hardware monitoring register)
  271.  *    0x90 (16 bytes of SMB registers)
  272.  */
  273. static void __init quirk_vt82c686_acpi(struct pci_dev *dev)
  274. {
  275.     u16 hm;
  276.     u32 smb;
  277.  
  278.     quirk_vt82c586_acpi(dev);
  279.  
  280.     pci_read_config_word(dev, 0x70, &hm);
  281.     hm &= PCI_BASE_ADDRESS_IO_MASK;
  282.     quirk_io_region(dev, hm, 128, PCI_BRIDGE_RESOURCES + 1);
  283.  
  284.     pci_read_config_dword(dev, 0x90, &smb);
  285.     smb &= PCI_BASE_ADDRESS_IO_MASK;
  286.     quirk_io_region(dev, smb, 16, PCI_BRIDGE_RESOURCES + 2);
  287. }
  288.  
  289.  
  290. #ifdef CONFIG_X86_IO_APIC 
  291. extern int nr_ioapics;
  292.  
  293. /*
  294.  * VIA 686A/B: If an IO-APIC is active, we need to route all on-chip
  295.  * devices to the external APIC.
  296.  *
  297.  * TODO: When we have device-specific interrupt routers,
  298.  * this code will go away from quirks.
  299.  */
  300. static void __init quirk_via_ioapic(struct pci_dev *dev)
  301. {
  302.     u8 tmp;
  303.     
  304.     if (nr_ioapics < 1)
  305.         tmp = 0;    /* nothing routed to external APIC */
  306.     else
  307.         tmp = 0x1f; /* all known bits (4-0) routed to external APIC */
  308.         
  309.     printk(KERN_INFO "PCI: %sbling Via external APIC routing\n",
  310.            tmp == 0 ? "Disa" : "Ena");
  311.  
  312.     /* Offset 0x58: External APIC IRQ output control */
  313.     pci_write_config_byte (dev, 0x58, tmp);
  314. }
  315.  
  316. #endif /* CONFIG_X86_IO_APIC */
  317.  
  318.  
  319. /*
  320.  * Via 686A/B:  The PCI_INTERRUPT_LINE register for the on-chip
  321.  * devices, USB0/1, AC97, MC97, and ACPI, has an unusual feature:
  322.  * when written, it makes an internal connection to the PIC.
  323.  * For these devices, this register is defined to be 4 bits wide.
  324.  * Normally this is fine.  However for IO-APIC motherboards, or
  325.  * non-x86 architectures (yes Via exists on PPC among other places),
  326.  * we must mask the PCI_INTERRUPT_LINE value versus 0xf to get
  327.  * interrupts delivered properly.
  328.  *
  329.  * TODO: When we have device-specific interrupt routers,
  330.  * quirk_via_irqpic will go away from quirks.
  331.  */
  332.  
  333. /*
  334.  * FIXME: it is questionable that quirk_via_acpi
  335.  * is needed.  It shows up as an ISA bridge, and does not
  336.  * support the PCI_INTERRUPT_LINE register at all.  Therefore
  337.  * it seems like setting the pci_dev's 'irq' to the
  338.  * value of the ACPI SCI interrupt is only done for convenience.
  339.  *    -jgarzik
  340.  */
  341. static void __init quirk_via_acpi(struct pci_dev *d)
  342. {
  343.     /*
  344.      * VIA ACPI device: SCI IRQ line in PCI config byte 0x42
  345.      */
  346.     u8 irq;
  347.     pci_read_config_byte(d, 0x42, &irq);
  348.     irq &= 0xf;
  349.     if (irq && (irq != 2))
  350.         d->irq = irq;
  351. }
  352.  
  353. static void __init quirk_via_irqpic(struct pci_dev *dev)
  354. {
  355.     u8 irq, new_irq = dev->irq & 0xf;
  356.  
  357.     pci_read_config_byte(dev, PCI_INTERRUPT_LINE, &irq);
  358.  
  359.     if (new_irq != irq) {
  360.         printk(KERN_INFO "PCI: Via IRQ fixup for %s, from %d to %d\n",
  361.                dev->slot_name, irq, new_irq);
  362.  
  363.         udelay(15);
  364.         pci_write_config_byte(dev, PCI_INTERRUPT_LINE, new_irq);
  365.     }
  366. }
  367.  
  368.  
  369. /*
  370.  * PIIX3 USB: We have to disable USB interrupts that are
  371.  * hardwired to PIRQD# and may be shared with an
  372.  * external device.
  373.  *
  374.  * Legacy Support Register (LEGSUP):
  375.  *     bit13:  USB PIRQ Enable (USBPIRQDEN),
  376.  *     bit4:   Trap/SMI On IRQ Enable (USBSMIEN).
  377.  *
  378.  * We mask out all r/wc bits, too.
  379.  */
  380. static void __init quirk_piix3_usb(struct pci_dev *dev)
  381. {
  382.     u16 legsup;
  383.  
  384.     pci_read_config_word(dev, 0xc0, &legsup);
  385.     legsup &= 0x50ef;
  386.     pci_write_config_word(dev, 0xc0, legsup);
  387. }
  388.  
  389. /*
  390.  * VIA VT82C598 has its device ID settable and many BIOSes
  391.  * set it to the ID of VT82C597 for backward compatibility.
  392.  * We need to switch it off to be able to recognize the real
  393.  * type of the chip.
  394.  */
  395. static void __init quirk_vt82c598_id(struct pci_dev *dev)
  396. {
  397.     pci_write_config_byte(dev, 0xfc, 0);
  398.     pci_read_config_word(dev, PCI_DEVICE_ID, &dev->device);
  399. }
  400.  
  401. /*
  402.  * CardBus controllers have a legacy base address that enables them
  403.  * to respond as i82365 pcmcia controllers.  We don't want them to
  404.  * do this even if the Linux CardBus driver is not loaded, because
  405.  * the Linux i82365 driver does not (and should not) handle CardBus.
  406.  */
  407. static void __init quirk_cardbus_legacy(struct pci_dev *dev)
  408. {
  409.     if ((PCI_CLASS_BRIDGE_CARDBUS << 8) ^ dev->class)
  410.         return;
  411.     pci_write_config_dword(dev, PCI_CB_LEGACY_MODE_BASE, 0);
  412. }
  413.  
  414. /*
  415.  * The AMD io apic can hang the box when an apic irq is masked.
  416.  * We check all revs >= B0 (yet not in the pre production!) as the bug
  417.  * is currently marked NoFix
  418.  *
  419.  * We have multiple reports of hangs with this chipset that went away with
  420.  * noapic specified. For the moment we assume its the errata. We may be wrong
  421.  * of course. However the advice is demonstrably good even if so..
  422.  */
  423.  
  424. static void __init quirk_amd_ioapic(struct pci_dev *dev)
  425. {
  426.     u8 rev;
  427.  
  428.     pci_read_config_byte(dev, PCI_REVISION_ID, &rev);
  429.     if(rev >= 0x02)
  430.     {
  431.         printk(KERN_WARNING "I/O APIC: AMD Errata #22 may be present. In the event of instability try\n");
  432.         printk(KERN_WARNING "        : booting with the \"noapic\" option.\n");
  433.     }
  434. }
  435.  
  436. /*
  437.  * Following the PCI ordering rules is optional on the AMD762. I'm not
  438.  * sure what the designers were smoking but let's not inhale...
  439.  *
  440.  * To be fair to AMD, it follows the spec by default, its BIOS people
  441.  * who turn it off!
  442.  */
  443.  
  444. static void __init quirk_amd_ordering(struct pci_dev *dev)
  445. {
  446.     u32 pcic;
  447.     
  448.     pci_read_config_dword(dev, 0x42, &pcic);
  449.     if((pcic&2)==0)
  450.     {
  451.         pcic |= 2;
  452.         printk(KERN_WARNING "BIOS disabled PCI ordering compliance, so we enabled it again.\n");
  453.         pci_write_config_dword(dev, 0x42, pcic);        
  454.     }
  455. }
  456.  
  457. /*
  458.  *  The main table of quirks.
  459.  */
  460.  
  461. static struct pci_fixup pci_fixups[] __initdata = {
  462.     { PCI_FIXUP_FINAL,    PCI_VENDOR_ID_INTEL,    PCI_DEVICE_ID_INTEL_82441,    quirk_passive_release },
  463.     { PCI_FIXUP_FINAL,    PCI_VENDOR_ID_INTEL,    PCI_DEVICE_ID_INTEL_82441,    quirk_passive_release },
  464.     /*
  465.      * Its not totally clear which chipsets are the problematic ones
  466.      * We know 82C586 and 82C596 variants are affected.
  467.      */
  468.     { PCI_FIXUP_FINAL,    PCI_VENDOR_ID_VIA,    PCI_DEVICE_ID_VIA_82C586_0,    quirk_isa_dma_hangs },
  469.     { PCI_FIXUP_FINAL,    PCI_VENDOR_ID_VIA,    PCI_DEVICE_ID_VIA_82C596,    quirk_isa_dma_hangs },
  470.     { PCI_FIXUP_FINAL,      PCI_VENDOR_ID_INTEL,    PCI_DEVICE_ID_INTEL_82371SB_0,  quirk_isa_dma_hangs },
  471.     { PCI_FIXUP_HEADER,    PCI_VENDOR_ID_S3,    PCI_DEVICE_ID_S3_868,        quirk_s3_64M },
  472.     { PCI_FIXUP_HEADER,    PCI_VENDOR_ID_S3,    PCI_DEVICE_ID_S3_968,        quirk_s3_64M },
  473.     { PCI_FIXUP_FINAL,    PCI_VENDOR_ID_INTEL,     PCI_DEVICE_ID_INTEL_82437,     quirk_triton }, 
  474.     { PCI_FIXUP_FINAL,    PCI_VENDOR_ID_INTEL,     PCI_DEVICE_ID_INTEL_82437VX,     quirk_triton }, 
  475.     { PCI_FIXUP_FINAL,    PCI_VENDOR_ID_INTEL,     PCI_DEVICE_ID_INTEL_82439,     quirk_triton }, 
  476.     { PCI_FIXUP_FINAL,    PCI_VENDOR_ID_INTEL,     PCI_DEVICE_ID_INTEL_82439TX,     quirk_triton }, 
  477.     { PCI_FIXUP_FINAL,    PCI_VENDOR_ID_INTEL,     PCI_DEVICE_ID_INTEL_82441,     quirk_natoma }, 
  478.     { PCI_FIXUP_FINAL,    PCI_VENDOR_ID_INTEL,     PCI_DEVICE_ID_INTEL_82443LX_0,     quirk_natoma }, 
  479.     { PCI_FIXUP_FINAL,    PCI_VENDOR_ID_INTEL,     PCI_DEVICE_ID_INTEL_82443LX_1,     quirk_natoma }, 
  480.     { PCI_FIXUP_FINAL,    PCI_VENDOR_ID_INTEL,     PCI_DEVICE_ID_INTEL_82443BX_0,     quirk_natoma }, 
  481.     { PCI_FIXUP_FINAL,    PCI_VENDOR_ID_INTEL,     PCI_DEVICE_ID_INTEL_82443BX_1,     quirk_natoma }, 
  482.     { PCI_FIXUP_FINAL,    PCI_VENDOR_ID_INTEL,     PCI_DEVICE_ID_INTEL_82443BX_2,     quirk_natoma },
  483.     { PCI_FIXUP_FINAL,    PCI_VENDOR_ID_SI,    PCI_DEVICE_ID_SI_5597,        quirk_nopcipci },
  484.     { PCI_FIXUP_FINAL,    PCI_VENDOR_ID_SI,    PCI_DEVICE_ID_SI_496,        quirk_nopcipci },
  485.     { PCI_FIXUP_FINAL,    PCI_VENDOR_ID_VIA,    PCI_DEVICE_ID_VIA_8363_0,    quirk_vialatency },
  486.     { PCI_FIXUP_FINAL,    PCI_VENDOR_ID_VIA,    PCI_DEVICE_ID_VIA_8371_1,    quirk_vialatency },
  487.     { PCI_FIXUP_FINAL,    PCI_VENDOR_ID_VIA,    0x3112    /* Not out yet ? */,    quirk_vialatency },
  488.     { PCI_FIXUP_FINAL,    PCI_VENDOR_ID_VIA,    PCI_DEVICE_ID_VIA_82C576,    quirk_vsfx },
  489.     { PCI_FIXUP_FINAL,    PCI_VENDOR_ID_VIA,    PCI_DEVICE_ID_VIA_82C597_0,    quirk_viaetbf },
  490.     { PCI_FIXUP_HEADER,    PCI_VENDOR_ID_VIA,    PCI_DEVICE_ID_VIA_82C597_0,    quirk_vt82c598_id },
  491.     { PCI_FIXUP_HEADER,    PCI_VENDOR_ID_VIA,    PCI_DEVICE_ID_VIA_82C586_3,    quirk_vt82c586_acpi },
  492.     { PCI_FIXUP_HEADER,    PCI_VENDOR_ID_VIA,    PCI_DEVICE_ID_VIA_82C686_4,    quirk_vt82c686_acpi },
  493.     { PCI_FIXUP_HEADER,    PCI_VENDOR_ID_INTEL,    PCI_DEVICE_ID_INTEL_82371AB_3,    quirk_piix4_acpi },
  494.     { PCI_FIXUP_HEADER,    PCI_VENDOR_ID_AL,    PCI_DEVICE_ID_AL_M7101,        quirk_ali7101_acpi },
  495.      { PCI_FIXUP_HEADER,    PCI_VENDOR_ID_INTEL,    PCI_DEVICE_ID_INTEL_82371SB_2,    quirk_piix3_usb },
  496.     { PCI_FIXUP_HEADER,    PCI_VENDOR_ID_INTEL,    PCI_DEVICE_ID_INTEL_82371AB_2,    quirk_piix3_usb },
  497.     { PCI_FIXUP_FINAL,    PCI_ANY_ID,        PCI_ANY_ID,            quirk_cardbus_legacy },
  498.  
  499. #ifdef CONFIG_X86_IO_APIC 
  500.     { PCI_FIXUP_FINAL,    PCI_VENDOR_ID_VIA,    PCI_DEVICE_ID_VIA_82C686,    quirk_via_ioapic },
  501. #endif
  502.     { PCI_FIXUP_HEADER,    PCI_VENDOR_ID_VIA,    PCI_DEVICE_ID_VIA_82C586_3,    quirk_via_acpi },
  503.     { PCI_FIXUP_HEADER,    PCI_VENDOR_ID_VIA,    PCI_DEVICE_ID_VIA_82C686_4,    quirk_via_acpi },
  504.     { PCI_FIXUP_FINAL,    PCI_VENDOR_ID_VIA,    PCI_DEVICE_ID_VIA_82C586_2,    quirk_via_irqpic },
  505.     { PCI_FIXUP_FINAL,    PCI_VENDOR_ID_VIA,    PCI_DEVICE_ID_VIA_82C686_5,    quirk_via_irqpic },
  506.     { PCI_FIXUP_FINAL,    PCI_VENDOR_ID_VIA,    PCI_DEVICE_ID_VIA_82C686_6,    quirk_via_irqpic },
  507.  
  508.     { PCI_FIXUP_FINAL,     PCI_VENDOR_ID_AMD,    PCI_DEVICE_ID_AMD_VIPER_7410,    quirk_amd_ioapic },
  509.     { PCI_FIXUP_FINAL,    PCI_VENDOR_ID_AMD,    PCI_DEVICE_ID_AMD_FE_GATE_700C, quirk_amd_ordering },
  510.  
  511.     { 0 }
  512. };
  513.  
  514.  
  515. static void pci_do_fixups(struct pci_dev *dev, int pass, struct pci_fixup *f)
  516. {
  517.     while (f->pass) {
  518.         if (f->pass == pass &&
  519.              (f->vendor == dev->vendor || f->vendor == (u16) PCI_ANY_ID) &&
  520.              (f->device == dev->device || f->device == (u16) PCI_ANY_ID)) {
  521. #ifdef DEBUG
  522.             printk(KERN_INFO "PCI: Calling quirk %p for %s\n", f->hook, dev->slot_name);
  523. #endif
  524.             f->hook(dev);
  525.         }
  526.         f++;
  527.     }
  528. }
  529.  
  530. void pci_fixup_device(int pass, struct pci_dev *dev)
  531. {
  532.     pci_do_fixups(dev, pass, pcibios_fixups);
  533.     pci_do_fixups(dev, pass, pci_fixups);
  534. }
  535.