arch/x86/pci/common.c

   1 /*
   2  *      Low-Level PCI Support for PC
   3  *
   4  *      (c) 1999--2000 Martin Mares <mj@ucw.cz>
   5  */
   6
   7 #include <linux/sched.h>
   8 #include <linux/pci.h>
   9 #include <linux/ioport.h>
  10 #include <linux/init.h>
  11 #include <linux/dmi.h>
  12
  13 #include <asm/acpi.h>
  14 #include <asm/segment.h>
  15 #include <asm/io.h>
  16 #include <asm/smp.h>
  17
  18 #include "pci.h"
  19
  20 unsigned int pci_probe = PCI_PROBE_BIOS | PCI_PROBE_CONF1 | PCI_PROBE_CONF2 |
  21                                 PCI_PROBE_MMCONF;
  22
  23 static int pci_bf_sort;
  24 int pci_routeirq;
  25 int pcibios_last_bus = -1;
  26 unsigned long pirq_table_addr;
  27 struct pci_bus *pci_root_bus;
  28 struct pci_raw_ops *raw_pci_ops;
  29 struct pci_raw_ops *raw_pci_ext_ops;
  30
  31 int raw_pci_read(unsigned int domain, unsigned int bus, unsigned int devfn,
  32                                                 int reg, int len, u32 *val)
  33 {
  34         if (reg < 256 && raw_pci_ops)
  35                 return raw_pci_ops->read(domain, bus, devfn, reg, len, val);
  36         if (raw_pci_ext_ops)
  37                 return raw_pci_ext_ops->read(domain, bus, devfn, reg, len, val);
  38         return -EINVAL;
  39 }
  40
  41 int raw_pci_write(unsigned int domain, unsigned int bus, unsigned int devfn,
  42                                                 int reg, int len, u32 val)
  43 {
  44         if (reg < 256 && raw_pci_ops)
  45                 return raw_pci_ops->write(domain, bus, devfn, reg, len, val);
  46         if (raw_pci_ext_ops)
  47                 return raw_pci_ext_ops->write(domain, bus, devfn, reg, len, val);
  48         return -EINVAL;
  49 }
  50
  51 static int pci_read(struct pci_bus *bus, unsigned int devfn, int where, int size, u32 *value)
  52 {
  53         return raw_pci_read(pci_domain_nr(bus), bus->number,
  54                                  devfn, where, size, value);
  55 }
  56
  57 static int pci_write(struct pci_bus *bus, unsigned int devfn, int where, int size, u32 value)
  58 {
  59         return raw_pci_write(pci_domain_nr(bus), bus->number,
  60                                   devfn, where, size, value);
  61 }
  62
  63 struct pci_ops pci_root_ops = {
  64         .read = pci_read,
  65         .write = pci_write,
  66 };
  67
  68 /*
  69  * legacy, numa, and acpi all want to call pcibios_scan_root
  70  * from their initcalls. This flag prevents that.
  71  */
  72 int pcibios_scanned;
  73
  74 /*
  75  * This interrupt-safe spinlock protects all accesses to PCI
  76  * configuration space.
  77  */
  78 DEFINE_SPINLOCK(pci_config_lock);
  79
  80 /*
  81  * Several buggy motherboards address only 16 devices and mirror
  82  * them to next 16 IDs. We try to detect this `feature' on all
  83  * primary buses (those containing host bridges as they are
  84  * expected to be unique) and remove the ghost devices.
  85  */
  86
  87 static void __devinit pcibios_fixup_ghosts(struct pci_bus *b)
  88 {
  89         struct list_head *ln, *mn;
  90         struct pci_dev *d, *e;
  91         int mirror = PCI_DEVFN(16,0);
  92         int seen_host_bridge = 0;
  93         int i;
  94
  95         DBG("PCI: Scanning for ghost devices on bus %d\n", b->number);
  96         list_for_each(ln, &b->devices) {
  97                 d = pci_dev_b(ln);
  98                 if ((d->class >> 8) == PCI_CLASS_BRIDGE_HOST)
  99                         seen_host_bridge++;
 100                 for (mn=ln->next; mn != &b->devices; mn=mn->next) {
 101                         e = pci_dev_b(mn);
 102                         if (e->devfn != d->devfn + mirror ||
 103                             e->vendor != d->vendor ||
 104                             e->device != d->device ||
 105                             e->class != d->class)
 106                                 continue;
 107                         for(i=0; i<PCI_NUM_RESOURCES; i++)
 108                                 if (e->resource[i].start != d->resource[i].start ||
 109                                     e->resource[i].end != d->resource[i].end ||
 110                                     e->resource[i].flags != d->resource[i].flags)
 111                                         continue;
 112                         break;
 113                 }
 114                 if (mn == &b->devices)
 115                         return;
 116         }
 117         if (!seen_host_bridge)
 118                 return;
 119         printk(KERN_WARNING "PCI: Ignoring ghost devices on bus %02x\n", b->number);
 120
 121         ln = &b->devices;
 122         while (ln->next != &b->devices) {
 123                 d = pci_dev_b(ln->next);
 124                 if (d->devfn >= mirror) {
 125                         list_del(&d->global_list);
 126                         list_del(&d->bus_list);
 127                         kfree(d);
 128                 } else
 129                         ln = ln->next;
 130         }
 131 }
 132
 133 static void __devinit pcibios_fixup_device_resources(struct pci_dev *dev)
 134 {
 135         struct resource *rom_r = &dev->resource[PCI_ROM_RESOURCE];
 136
 137         if (rom_r->parent)
 138                 return;
 139         if (rom_r->start)
 140                 /* we deal with BIOS assigned ROM later */
 141                 return;
 142         if (!(pci_probe & PCI_ASSIGN_ROMS))
 143                 rom_r->start = rom_r->end = rom_r->flags = 0;
 144 }
 145
 146 /*
 147  *  Called after each bus is probed, but before its children
 148  *  are examined.
 149  */
 150
 151 void __devinit  pcibios_fixup_bus(struct pci_bus *b)
 152 {
 153         struct pci_dev *dev;
 154
 155         pcibios_fixup_ghosts(b);
 156         pci_read_bridge_bases(b);
 157         list_for_each_entry(dev, &b->devices, bus_list)
 158                 pcibios_fixup_device_resources(dev);
 159 }
 160
 161 /*
 162  * Only use DMI information to set this if nothing was passed
 163  * on the kernel command line (which was parsed earlier).
 164  */
 165
 166 static int __devinit set_bf_sort(const struct dmi_system_id *d)
 167 {
 168         if (pci_bf_sort == pci_bf_sort_default) {
 169                 pci_bf_sort = pci_dmi_bf;
 170                 printk(KERN_INFO "PCI: %s detected, enabling pci=bfsort.\n", d->ident);
 171         }
 172         return 0;
 173 }
 174
 175 /*
 176  * Enable renumbering of PCI bus# ranges to reach all PCI busses (Cardbus)
 177  */
 178 #ifdef __i386__
 179 static int __devinit assign_all_busses(const struct dmi_system_id *d)
 180 {
 181         pci_probe |= PCI_ASSIGN_ALL_BUSSES;
 182         printk(KERN_INFO "%s detected: enabling PCI bus# renumbering"
 183                         " (pci=assign-busses)\n", d->ident);
 184         return 0;
 185 }
 186 #endif
 187
 188 static struct dmi_system_id __devinitdata pciprobe_dmi_table[] = {
 189 #ifdef __i386__
 190 /*
 191  * Laptops which need pci=assign-busses to see Cardbus cards
 192  */
 193         {
 194                 .callback = assign_all_busses,
 195                 .ident = "Samsung X20 Laptop",
 196                 .matches = {
 197                         DMI_MATCH(DMI_SYS_VENDOR, "Samsung Electronics"),
 198                         DMI_MATCH(DMI_PRODUCT_NAME, "SX20S"),
 199                 },
 200         },
 201 #endif          /* __i386__ */
 202         {
 203                 .callback = set_bf_sort,
 204                 .ident = "Dell PowerEdge 1950",
 205                 .matches = {
 206                         DMI_MATCH(DMI_SYS_VENDOR, "Dell"),
 207                         DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge 1950"),
 208                 },
 209         },
 210         {
 211                 .callback = set_bf_sort,
 212                 .ident = "Dell PowerEdge 1955",
 213                 .matches = {
 214                         DMI_MATCH(DMI_SYS_VENDOR, "Dell"),
 215                         DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge 1955"),
 216                 },
 217         },
 218         {
 219                 .callback = set_bf_sort,
 220                 .ident = "Dell PowerEdge 2900",
 221                 .matches = {
 222                         DMI_MATCH(DMI_SYS_VENDOR, "Dell"),
 223                         DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge 2900"),
 224                 },
 225         },
 226         {
 227                 .callback = set_bf_sort,
 228                 .ident = "Dell PowerEdge 2950",
 229                 .matches = {
 230                         DMI_MATCH(DMI_SYS_VENDOR, "Dell"),
 231                         DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge 2950"),
 232                 },
 233         },
 234         {
 235                 .callback = set_bf_sort,
 236                 .ident = "Dell PowerEdge R900",
 237                 .matches = {
 238                         DMI_MATCH(DMI_SYS_VENDOR, "Dell"),
 239                         DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge R900"),
 240                 },
 241         },
 242         {
 243                 .callback = set_bf_sort,
 244                 .ident = "HP ProLiant BL20p G3",
 245                 .matches = {
 246                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
 247                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL20p G3"),
 248                 },
 249         },
 250         {
 251                 .callback = set_bf_sort,
 252                 .ident = "HP ProLiant BL20p G4",
 253                 .matches = {
 254                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
 255                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL20p G4"),
 256                 },
 257         },
 258         {
 259                 .callback = set_bf_sort,
 260                 .ident = "HP ProLiant BL30p G1",
 261                 .matches = {
 262                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
 263                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL30p G1"),
 264                 },
 265         },
 266         {
 267                 .callback = set_bf_sort,
 268                 .ident = "HP ProLiant BL25p G1",
 269                 .matches = {
 270                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
 271                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL25p G1"),
 272                 },
 273         },
 274         {
 275                 .callback = set_bf_sort,
 276                 .ident = "HP ProLiant BL35p G1",
 277                 .matches = {
 278                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
 279                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL35p G1"),
 280                 },
 281         },
 282         {
 283                 .callback = set_bf_sort,
 284                 .ident = "HP ProLiant BL45p G1",
 285                 .matches = {
 286                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
 287                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL45p G1"),
 288                 },
 289         },
 290         {
 291                 .callback = set_bf_sort,
 292                 .ident = "HP ProLiant BL45p G2",
 293                 .matches = {
 294                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
 295                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL45p G2"),
 296                 },
 297         },
 298         {
 299                 .callback = set_bf_sort,
 300                 .ident = "HP ProLiant BL460c G1",
 301                 .matches = {
 302                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
 303                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL460c G1"),
 304                 },
 305         },
 306         {
 307                 .callback = set_bf_sort,
 308                 .ident = "HP ProLiant BL465c G1",
 309                 .matches = {
 310                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
 311                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL465c G1"),
 312                 },
 313         },
 314         {
 315                 .callback = set_bf_sort,
 316                 .ident = "HP ProLiant BL480c G1",
 317                 .matches = {
 318                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
 319                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL480c G1"),
 320                 },
 321         },
 322         {
 323                 .callback = set_bf_sort,
 324                 .ident = "HP ProLiant BL685c G1",
 325                 .matches = {
 326                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
 327                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant BL685c G1"),
 328                 },
 329         },
 330         {
 331                 .callback = set_bf_sort,
 332                 .ident = "HP ProLiant DL385 G2",
 333                 .matches = {
 334                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
 335                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant DL385 G2"),
 336                 },
 337         },
 338         {
 339                 .callback = set_bf_sort,
 340                 .ident = "HP ProLiant DL585 G2",
 341                 .matches = {
 342                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
 343                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant DL585 G2"),
 344                 },
 345         },
 346 #ifdef __i386__
 347         {
 348                 .callback = assign_all_busses,
 349                 .ident = "Compaq EVO N800c",
 350                 .matches = {
 351                         DMI_MATCH(DMI_SYS_VENDOR, "Compaq"),
 352                         DMI_MATCH(DMI_PRODUCT_NAME, "EVO N800c"),
 353                 },
 354         },
 355 #endif
 356         {
 357                 .callback = set_bf_sort,
 358                 .ident = "HP ProLiant DL385 G2",
 359                 .matches = {
 360                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
 361                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant DL385 G2"),
 362                 },
 363         },
 364         {
 365                 .callback = set_bf_sort,
 366                 .ident = "HP ProLiant DL585 G2",
 367                 .matches = {
 368                         DMI_MATCH(DMI_SYS_VENDOR, "HP"),
 369                         DMI_MATCH(DMI_PRODUCT_NAME, "ProLiant DL585 G2"),
 370                 },
 371         },
 372         {}
 373 };
 374
 375 struct pci_bus * __devinit pcibios_scan_root(int busnum)
 376 {
 377         struct pci_bus *bus = NULL;
 378         struct pci_sysdata *sd;
 379
 380         dmi_check_system(pciprobe_dmi_table);
 381
 382         while ((bus = pci_find_next_bus(bus)) != NULL) {
 383                 if (bus->number == busnum) {
 384                         /* Already scanned */
 385                         return bus;
 386                 }
 387         }
 388
 389         /* Allocate per-root-bus (not per bus) arch-specific data.
 390          * TODO: leak; this memory is never freed.
 391          * It's arguable whether it's worth the trouble to care.
 392          */
 393         sd = kzalloc(sizeof(*sd), GFP_KERNEL);
 394         if (!sd) {
 395                 printk(KERN_ERR "PCI: OOM, not probing PCI bus %02x\n", busnum);
 396                 return NULL;
 397         }
 398
 399         printk(KERN_DEBUG "PCI: Probing PCI hardware (bus %02x)\n", busnum);
 400
 401         return pci_scan_bus_parented(NULL, busnum, &pci_root_ops, sd);
 402 }
 403
 404 extern u8 pci_cache_line_size;
 405
 406 static int __init pcibios_init(void)
 407 {
 408         struct cpuinfo_x86 *c = &boot_cpu_data;
 409
 410         if (!raw_pci_ops) {
 411                 printk(KERN_WARNING "PCI: System does not support PCI\n");
 412                 return 0;
 413         }
 414
 415         /*
 416          * Assume PCI cacheline size of 32 bytes for all x86s except K7/K8
 417          * and P4. It's also good for 386/486s (which actually have 16)
 418          * as quite a few PCI devices do not support smaller values.
 419          */
 420         pci_cache_line_size = 32 >> 2;
 421         if (c->x86 >= 6 && c->x86_vendor == X86_VENDOR_AMD)
 422                 pci_cache_line_size = 64 >> 2;  /* K7 & K8 */
 423         else if (c->x86 > 6 && c->x86_vendor == X86_VENDOR_INTEL)
 424                 pci_cache_line_size = 128 >> 2; /* P4 */
 425
 426         pcibios_resource_survey();
 427
 428         if (pci_bf_sort >= pci_force_bf)
 429                 pci_sort_breadthfirst();
 430         return 0;
 431 }
 432
 433 subsys_initcall(pcibios_init);
 434
 435 char * __devinit  pcibios_setup(char *str)
 436 {
 437         if (!strcmp(str, "off")) {
 438                 pci_probe = 0;
 439                 return NULL;
 440         } else if (!strcmp(str, "bfsort")) {
 441                 pci_bf_sort = pci_force_bf;
 442                 return NULL;
 443         } else if (!strcmp(str, "nobfsort")) {
 444                 pci_bf_sort = pci_force_nobf;
 445                 return NULL;
 446         }
 447 #ifdef CONFIG_PCI_BIOS
 448         else if (!strcmp(str, "bios")) {
 449                 pci_probe = PCI_PROBE_BIOS;
 450                 return NULL;
 451         } else if (!strcmp(str, "nobios")) {
 452                 pci_probe &= ~PCI_PROBE_BIOS;
 453                 return NULL;
 454         } else if (!strcmp(str, "biosirq")) {
 455                 pci_probe |= PCI_BIOS_IRQ_SCAN;
 456                 return NULL;
 457         } else if (!strncmp(str, "pirqaddr=", 9)) {
 458                 pirq_table_addr = simple_strtoul(str+9, NULL, 0);
 459                 return NULL;
 460         }
 461 #endif
 462 #ifdef CONFIG_PCI_DIRECT
 463         else if (!strcmp(str, "conf1")) {
 464                 pci_probe = PCI_PROBE_CONF1 | PCI_NO_CHECKS;
 465                 return NULL;
 466         }
 467         else if (!strcmp(str, "conf2")) {
 468                 pci_probe = PCI_PROBE_CONF2 | PCI_NO_CHECKS;
 469                 return NULL;
 470         }
 471 #endif
 472 #ifdef CONFIG_PCI_MMCONFIG
 473         else if (!strcmp(str, "nommconf")) {
 474                 pci_probe &= ~PCI_PROBE_MMCONF;
 475                 return NULL;
 476         }
 477 #endif
 478         else if (!strcmp(str, "noacpi")) {
 479                 acpi_noirq_set();
 480                 return NULL;
 481         }
 482         else if (!strcmp(str, "noearly")) {
 483                 pci_probe |= PCI_PROBE_NOEARLY;
 484                 return NULL;
 485         }
 486 #ifndef CONFIG_X86_VISWS
 487         else if (!strcmp(str, "usepirqmask")) {
 488                 pci_probe |= PCI_USE_PIRQ_MASK;
 489                 return NULL;
 490         } else if (!strncmp(str, "irqmask=", 8)) {
 491                 pcibios_irq_mask = simple_strtol(str+8, NULL, 0);
 492                 return NULL;
 493         } else if (!strncmp(str, "lastbus=", 8)) {
 494                 pcibios_last_bus = simple_strtol(str+8, NULL, 0);
 495                 return NULL;
 496         }
 497 #endif
 498         else if (!strcmp(str, "rom")) {
 499                 pci_probe |= PCI_ASSIGN_ROMS;
 500                 return NULL;
 501         } else if (!strcmp(str, "assign-busses")) {
 502                 pci_probe |= PCI_ASSIGN_ALL_BUSSES;
 503                 return NULL;
 504         } else if (!strcmp(str, "use_crs")) {
 505                 pci_probe |= PCI_USE__CRS;
 506                 return NULL;
 507         } else if (!strcmp(str, "routeirq")) {
 508                 pci_routeirq = 1;
 509                 return NULL;
 510         }
 511         return str;
 512 }
 513
 514 unsigned int pcibios_assign_all_busses(void)
 515 {
 516         return (pci_probe & PCI_ASSIGN_ALL_BUSSES) ? 1 : 0;
 517 }
 518
 519 int pcibios_enable_device(struct pci_dev *dev, int mask)
 520 {
 521         int err;
 522
 523         if ((err = pcibios_enable_resources(dev, mask)) < 0)
 524                 return err;
 525
 526         if (!dev->msi_enabled)
 527                 return pcibios_enable_irq(dev);
 528         return 0;
 529 }
 530
 531 void pcibios_disable_device (struct pci_dev *dev)
 532 {
 533         if (!dev->msi_enabled && pcibios_disable_irq)
 534                 pcibios_disable_irq(dev);
 535 }
 536
 537 struct pci_bus *__devinit pci_scan_bus_with_sysdata(int busno)
 538 {
 539         struct pci_bus *bus = NULL;
 540         struct pci_sysdata *sd;
 541
 542         /*
 543          * Allocate per-root-bus (not per bus) arch-specific data.
 544          * TODO: leak; this memory is never freed.
 545          * It's arguable whether it's worth the trouble to care.
 546          */
 547         sd = kzalloc(sizeof(*sd), GFP_KERNEL);
 548         if (!sd) {
 549                 printk(KERN_ERR "PCI: OOM, skipping PCI bus %02x\n", busno);
 550                 return NULL;
 551         }
 552         sd->node = -1;
 553         bus = pci_scan_bus(busno, &pci_root_ops, sd);
 554         if (!bus)
 555                 kfree(sd);
 556
 557         return bus;
 558 }