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