arch/i386/pci/fixup.c

   1 /*
   2  * Exceptions for specific devices. Usually work-arounds for fatal design flaws.
   3  */
   4
   5 #include <linux/pci.h>
   6 #include <linux/init.h>
   7 #include "pci.h"
   8
   9
  10 static void __devinit pci_fixup_i450nx(struct pci_dev *d)
  11 {
  12         /*
  13          * i450NX -- Find and scan all secondary buses on all PXB's.
  14          */
  15         int pxb, reg;
  16         u8 busno, suba, subb;
  17
  18         printk(KERN_WARNING "PCI: Searching for i450NX host bridges on %s\n", pci_name(d));
  19         reg = 0xd0;
  20         for(pxb=0; pxb<2; pxb++) {
  21                 pci_read_config_byte(d, reg++, &busno);
  22                 pci_read_config_byte(d, reg++, &suba);
  23                 pci_read_config_byte(d, reg++, &subb);
  24                 DBG("i450NX PXB %d: %02x/%02x/%02x\n", pxb, busno, suba, subb);
  25                 if (busno)
  26                         pci_scan_bus(busno, &pci_root_ops, NULL);       /* Bus A */
  27                 if (suba < subb)
  28                         pci_scan_bus(suba+1, &pci_root_ops, NULL);      /* Bus B */
  29         }
  30         pcibios_last_bus = -1;
  31 }
  32
  33 static void __devinit pci_fixup_i450gx(struct pci_dev *d)
  34 {
  35         /*
  36          * i450GX and i450KX -- Find and scan all secondary buses.
  37          * (called separately for each PCI bridge found)
  38          */
  39         u8 busno;
  40         pci_read_config_byte(d, 0x4a, &busno);
  41         printk(KERN_INFO "PCI: i440KX/GX host bridge %s: secondary bus %02x\n", pci_name(d), busno);
  42         pci_scan_bus(busno, &pci_root_ops, NULL);
  43         pcibios_last_bus = -1;
  44 }
  45
  46 static void __devinit  pci_fixup_umc_ide(struct pci_dev *d)
  47 {
  48         /*
  49          * UM8886BF IDE controller sets region type bits incorrectly,
  50          * therefore they look like memory despite of them being I/O.
  51          */
  52         int i;
  53
  54         printk(KERN_WARNING "PCI: Fixing base address flags for device %s\n", pci_name(d));
  55         for(i=0; i<4; i++)
  56                 d->resource[i].flags |= PCI_BASE_ADDRESS_SPACE_IO;
  57 }
  58
  59 static void __devinit  pci_fixup_ncr53c810(struct pci_dev *d)
  60 {
  61         /*
  62          * NCR 53C810 returns class code 0 (at least on some systems).
  63          * Fix class to be PCI_CLASS_STORAGE_SCSI
  64          */
  65         if (!d->class) {
  66                 printk(KERN_WARNING "PCI: fixing NCR 53C810 class code for %s\n", pci_name(d));
  67                 d->class = PCI_CLASS_STORAGE_SCSI << 8;
  68         }
  69 }
  70
  71 static void __devinit pci_fixup_ide_bases(struct pci_dev *d)
  72 {
  73         int i;
  74
  75         /*
  76          * PCI IDE controllers use non-standard I/O port decoding, respect it.
  77          */
  78         if ((d->class >> 8) != PCI_CLASS_STORAGE_IDE)
  79                 return;
  80         DBG("PCI: IDE base address fixup for %s\n", pci_name(d));
  81         for(i=0; i<4; i++) {
  82                 struct resource *r = &d->resource[i];
  83                 if ((r->start & ~0x80) == 0x374) {
  84                         r->start |= 2;
  85                         r->end = r->start;
  86                 }
  87         }
  88 }
  89
  90 static void __devinit  pci_fixup_ide_trash(struct pci_dev *d)
  91 {
  92         int i;
  93
  94         /*
  95          * Runs the fixup only for the first IDE controller
  96          * (Shai Fultheim - shai@ftcon.com)
  97          */
  98         static int called = 0;
  99         if (called)
 100                 return;
 101         called = 1;
 102
 103         /*
 104          * There exist PCI IDE controllers which have utter garbage
 105          * in first four base registers. Ignore that.
 106          */
 107         DBG("PCI: IDE base address trash cleared for %s\n", pci_name(d));
 108         for(i=0; i<4; i++)
 109                 d->resource[i].start = d->resource[i].end = d->resource[i].flags = 0;
 110 }
 111
 112 static void __devinit  pci_fixup_latency(struct pci_dev *d)
 113 {
 114         /*
 115          *  SiS 5597 and 5598 chipsets require latency timer set to
 116          *  at most 32 to avoid lockups.
 117          */
 118         DBG("PCI: Setting max latency to 32\n");
 119         pcibios_max_latency = 32;
 120 }
 121
 122 static void __devinit pci_fixup_piix4_acpi(struct pci_dev *d)
 123 {
 124         /*
 125          * PIIX4 ACPI device: hardwired IRQ9
 126          */
 127         d->irq = 9;
 128 }
 129
 130 /*
 131  * Addresses issues with problems in the memory write queue timer in
 132  * certain VIA Northbridges.  This bugfix is per VIA's specifications,
 133  * except for the KL133/KM133: clearing bit 5 on those Northbridges seems
 134  * to trigger a bug in its integrated ProSavage video card, which
 135  * causes screen corruption.  We only clear bits 6 and 7 for that chipset,
 136  * until VIA can provide us with definitive information on why screen
 137  * corruption occurs, and what exactly those bits do.
 138  *
 139  * VIA 8363,8622,8361 Northbridges:
 140  *  - bits  5, 6, 7 at offset 0x55 need to be turned off
 141  * VIA 8367 (KT266x) Northbridges:
 142  *  - bits  5, 6, 7 at offset 0x95 need to be turned off
 143  * VIA 8363 rev 0x81/0x84 (KL133/KM133) Northbridges:
 144  *  - bits     6, 7 at offset 0x55 need to be turned off
 145  */
 146
 147 #define VIA_8363_KL133_REVISION_ID 0x81
 148 #define VIA_8363_KM133_REVISION_ID 0x84
 149
 150 static void __devinit pci_fixup_via_northbridge_bug(struct pci_dev *d)
 151 {
 152         u8 v;
 153         u8 revision;
 154         int where = 0x55;
 155         int mask = 0x1f; /* clear bits 5, 6, 7 by default */
 156
 157         pci_read_config_byte(d, PCI_REVISION_ID, &revision);
 158
 159         if (d->device == PCI_DEVICE_ID_VIA_8367_0) {
 160                 /* fix pci bus latency issues resulted by NB bios error
 161                    it appears on bug free^Wreduced kt266x's bios forces
 162                    NB latency to zero */
 163                 pci_write_config_byte(d, PCI_LATENCY_TIMER, 0);
 164
 165                 where = 0x95; /* the memory write queue timer register is
 166                                 different for the KT266x's: 0x95 not 0x55 */
 167         } else if (d->device == PCI_DEVICE_ID_VIA_8363_0 &&
 168                         (revision == VIA_8363_KL133_REVISION_ID ||
 169                         revision == VIA_8363_KM133_REVISION_ID)) {
 170                         mask = 0x3f; /* clear only bits 6 and 7; clearing bit 5
 171                                         causes screen corruption on the KL133/KM133 */
 172         }
 173
 174         pci_read_config_byte(d, where, &v);
 175         if (v & ~mask) {
 176                 printk(KERN_WARNING "Disabling VIA memory write queue (PCI ID %04x, rev %02x): [%02x] %02x & %02x -> %02x\n", \
 177                         d->device, revision, where, v, mask, v & mask);
 178                 v &= mask;
 179                 pci_write_config_byte(d, where, v);
 180         }
 181 }
 182
 183 /*
 184  * For some reasons Intel decided that certain parts of their
 185  * 815, 845 and some other chipsets must look like PCI-to-PCI bridges
 186  * while they are obviously not. The 82801 family (AA, AB, BAM/CAM,
 187  * BA/CA/DB and E) PCI bridges are actually HUB-to-PCI ones, according
 188  * to Intel terminology. These devices do forward all addresses from
 189  * system to PCI bus no matter what are their window settings, so they are
 190  * "transparent" (or subtractive decoding) from programmers point of view.
 191  */
 192 static void __devinit pci_fixup_transparent_bridge(struct pci_dev *dev)
 193 {
 194         if ((dev->class >> 8) == PCI_CLASS_BRIDGE_PCI &&
 195             (dev->device & 0xff00) == 0x2400)
 196                 dev->transparent = 1;
 197 }
 198
 199 /*
 200  * Fixup for C1 Halt Disconnect problem on nForce2 systems.
 201  *
 202  * From information provided by "Allen Martin" <AMartin@nvidia.com>:
 203  *
 204  * A hang is caused when the CPU generates a very fast CONNECT/HALT cycle
 205  * sequence.  Workaround is to set the SYSTEM_IDLE_TIMEOUT to 80 ns.
 206  * This allows the state-machine and timer to return to a proper state within
 207  * 80 ns of the CONNECT and probe appearing together.  Since the CPU will not
 208  * issue another HALT within 80 ns of the initial HALT, the failure condition
 209  * is avoided.
 210  */
 211 static void __init pci_fixup_nforce2(struct pci_dev *dev)
 212 {
 213         u32 val, fixed_val;
 214         u8 rev;
 215
 216         pci_read_config_byte(dev, PCI_REVISION_ID, &rev);
 217
 218         /*
 219          * Chip  Old value   New value
 220          * C17   0x1F0FFF01  0x1F01FF01
 221          * C18D  0x9F0FFF01  0x9F01FF01
 222          *
 223          * Northbridge chip version may be determined by
 224          * reading the PCI revision ID (0xC1 or greater is C18D).
 225          */
 226         fixed_val = rev < 0xC1 ? 0x1F01FF01 : 0x9F01FF01;
 227
 228         pci_read_config_dword(dev, 0x6c, &val);
 229
 230         /*
 231          * Apply fixup only if C1 Halt Disconnect is enabled
 232          * (bit28) because it is not supported on some boards.
 233          */
 234         if ((val & (1 << 28)) && val != fixed_val) {
 235                 printk(KERN_WARNING "PCI: nForce2 C1 Halt Disconnect fixup\n");
 236                 pci_write_config_dword(dev, 0x6c, fixed_val);
 237         }
 238 }
 239
 240 struct pci_fixup pcibios_fixups[] = {
 241         {
 242                 .pass           = PCI_FIXUP_HEADER,
 243                 .vendor         = PCI_VENDOR_ID_INTEL,
 244                 .device         = PCI_DEVICE_ID_INTEL_82451NX,
 245                 .hook           = pci_fixup_i450nx
 246         },
 247         {
 248                 .pass           = PCI_FIXUP_HEADER,
 249                 .vendor         = PCI_VENDOR_ID_INTEL,
 250                 .device         = PCI_DEVICE_ID_INTEL_82454GX,
 251                 .hook           = pci_fixup_i450gx
 252         },
 253         {
 254                 .pass           = PCI_FIXUP_HEADER,
 255                 .vendor         = PCI_VENDOR_ID_UMC,
 256                 .device         = PCI_DEVICE_ID_UMC_UM8886BF,
 257                 .hook           = pci_fixup_umc_ide
 258         },
 259         {
 260                 .pass           = PCI_FIXUP_HEADER,
 261                 .vendor         = PCI_VENDOR_ID_SI,
 262                 .device         = PCI_DEVICE_ID_SI_5513,
 263                 .hook           = pci_fixup_ide_trash
 264         },
 265         {
 266                 .pass           = PCI_FIXUP_HEADER,
 267                 .vendor         = PCI_ANY_ID,
 268                 .device         = PCI_ANY_ID,
 269                 .hook           = pci_fixup_ide_bases
 270         },
 271         {
 272                 .pass           = PCI_FIXUP_HEADER,
 273                 .vendor         = PCI_VENDOR_ID_SI,
 274                 .device         = PCI_DEVICE_ID_SI_5597,
 275                 .hook           = pci_fixup_latency
 276         },
 277         {
 278                 .pass           = PCI_FIXUP_HEADER,
 279                 .vendor         = PCI_VENDOR_ID_SI,
 280                 .device         = PCI_DEVICE_ID_SI_5598,
 281                 .hook           = pci_fixup_latency
 282         },
 283         {
 284                 .pass           = PCI_FIXUP_HEADER,
 285                 .vendor         = PCI_VENDOR_ID_INTEL,
 286                 .device         = PCI_DEVICE_ID_INTEL_82371AB_3,
 287                 .hook           = pci_fixup_piix4_acpi
 288         },
 289         {
 290                 .pass           = PCI_FIXUP_HEADER,
 291                 .vendor         = PCI_VENDOR_ID_INTEL,
 292                 .device         = PCI_DEVICE_ID_INTEL_82801CA_10,
 293                 .hook           = pci_fixup_ide_trash
 294         },
 295         {
 296                 .pass           = PCI_FIXUP_HEADER,
 297                 .vendor         = PCI_VENDOR_ID_INTEL,
 298                 .device         = PCI_DEVICE_ID_INTEL_82801CA_11,
 299                 .hook           = pci_fixup_ide_trash
 300         },
 301         {
 302                 .pass           = PCI_FIXUP_HEADER,
 303                 .vendor         = PCI_VENDOR_ID_INTEL,
 304                 .device         = PCI_DEVICE_ID_INTEL_82801DB_9,
 305                 .hook           = pci_fixup_ide_trash
 306         },
 307         {
 308                 .pass           = PCI_FIXUP_HEADER,
 309                 .vendor         = PCI_VENDOR_ID_VIA,
 310                 .device         = PCI_DEVICE_ID_VIA_8363_0,
 311                 .hook           = pci_fixup_via_northbridge_bug
 312         },
 313         {
 314                 .pass           = PCI_FIXUP_HEADER,
 315                 .vendor         = PCI_VENDOR_ID_VIA,
 316                 .device         = PCI_DEVICE_ID_VIA_8622,
 317                 .hook           = pci_fixup_via_northbridge_bug
 318         },
 319         {
 320                 .pass           = PCI_FIXUP_HEADER,
 321                 .vendor         = PCI_VENDOR_ID_VIA,
 322                 .device         = PCI_DEVICE_ID_VIA_8361,
 323                 .hook           = pci_fixup_via_northbridge_bug
 324         },
 325         {
 326                 .pass           = PCI_FIXUP_HEADER,
 327                 .vendor         = PCI_VENDOR_ID_VIA,
 328                 .device         = PCI_DEVICE_ID_VIA_8367_0,
 329                 .hook           = pci_fixup_via_northbridge_bug
 330         },
 331         {
 332                 .pass           = PCI_FIXUP_HEADER,
 333                 .vendor         = PCI_VENDOR_ID_NCR,
 334                 .device         = PCI_DEVICE_ID_NCR_53C810,
 335                 .hook           = pci_fixup_ncr53c810
 336         },
 337         {
 338                 .pass           = PCI_FIXUP_HEADER,
 339                 .vendor         = PCI_VENDOR_ID_INTEL,
 340                 .device         = PCI_ANY_ID,
 341                 .hook           = pci_fixup_transparent_bridge
 342         },
 343         {
 344                 .pass           = PCI_FIXUP_HEADER,
 345                 .vendor         = PCI_VENDOR_ID_NVIDIA,
 346                 .device         = PCI_DEVICE_ID_NVIDIA_NFORCE2,
 347                 .hook           = pci_fixup_nforce2
 348         },
 349         { .pass = 0 }
 350 };