drivers/pci/probe.c

   1 /*
   2  * probe.c - PCI detection and setup code
   3  */
   4
   5 #include <linux/kernel.h>
   6 #include <linux/delay.h>
   7 #include <linux/init.h>
   8 #include <linux/pci.h>
   9 #include <linux/slab.h>
  10 #include <linux/module.h>
  11 #include <linux/cpumask.h>
  12 #include "pci.h"
  13
  14 #define CARDBUS_LATENCY_TIMER   176     /* secondary latency timer */
  15 #define CARDBUS_RESERVE_BUSNR   3
  16 #define PCI_CFG_SPACE_SIZE      256
  17 #define PCI_CFG_SPACE_EXP_SIZE  4096
  18
  19 /* Ugh.  Need to stop exporting this to modules. */
  20 LIST_HEAD(pci_root_buses);
  21 EXPORT_SYMBOL(pci_root_buses);
  22
  23
  24 static int find_anything(struct device *dev, void *data)
  25 {
  26         return 1;
  27 }
  28
  29 /*
  30  * Some device drivers need know if pci is initiated.
  31  * Basically, we think pci is not initiated when there
  32  * is no device to be found on the pci_bus_type.
  33  */
  34 int no_pci_devices(void)
  35 {
  36         struct device *dev;
  37         int no_devices;
  38
  39         dev = bus_find_device(&pci_bus_type, NULL, NULL, find_anything);
  40         no_devices = (dev == NULL);
  41         put_device(dev);
  42         return no_devices;
  43 }
  44 EXPORT_SYMBOL(no_pci_devices);
  45
  46 #ifdef HAVE_PCI_LEGACY
  47 /**
  48  * pci_create_legacy_files - create legacy I/O port and memory files
  49  * @b: bus to create files under
  50  *
  51  * Some platforms allow access to legacy I/O port and ISA memory space on
  52  * a per-bus basis.  This routine creates the files and ties them into
  53  * their associated read, write and mmap files from pci-sysfs.c
  54  */
  55 static void pci_create_legacy_files(struct pci_bus *b)
  56 {
  57         b->legacy_io = kzalloc(sizeof(struct bin_attribute) * 2,
  58                                GFP_ATOMIC);
  59         if (b->legacy_io) {
  60                 b->legacy_io->attr.name = "legacy_io";
  61                 b->legacy_io->size = 0xffff;
  62                 b->legacy_io->attr.mode = S_IRUSR | S_IWUSR;
  63                 b->legacy_io->read = pci_read_legacy_io;
  64                 b->legacy_io->write = pci_write_legacy_io;
  65                 device_create_bin_file(&b->dev, b->legacy_io);
  66
  67                 /* Allocated above after the legacy_io struct */
  68                 b->legacy_mem = b->legacy_io + 1;
  69                 b->legacy_mem->attr.name = "legacy_mem";
  70                 b->legacy_mem->size = 1024*1024;
  71                 b->legacy_mem->attr.mode = S_IRUSR | S_IWUSR;
  72                 b->legacy_mem->mmap = pci_mmap_legacy_mem;
  73                 device_create_bin_file(&b->dev, b->legacy_mem);
  74         }
  75 }
  76
  77 void pci_remove_legacy_files(struct pci_bus *b)
  78 {
  79         if (b->legacy_io) {
  80                 device_remove_bin_file(&b->dev, b->legacy_io);
  81                 device_remove_bin_file(&b->dev, b->legacy_mem);
  82                 kfree(b->legacy_io); /* both are allocated here */
  83         }
  84 }
  85 #else /* !HAVE_PCI_LEGACY */
  86 static inline void pci_create_legacy_files(struct pci_bus *bus) { return; }
  87 void pci_remove_legacy_files(struct pci_bus *bus) { return; }
  88 #endif /* HAVE_PCI_LEGACY */
  89
  90 /*
  91  * PCI Bus Class Devices
  92  */
  93 static ssize_t pci_bus_show_cpuaffinity(struct device *dev,
  94                                         struct device_attribute *attr,
  95                                         char *buf)
  96 {
  97         int ret;
  98         cpumask_t cpumask;
  99
 100         cpumask = pcibus_to_cpumask(to_pci_bus(dev));
 101         ret = cpumask_scnprintf(buf, PAGE_SIZE, cpumask);
 102         if (ret < PAGE_SIZE)
 103                 buf[ret++] = '\n';
 104         return ret;
 105 }
 106 DEVICE_ATTR(cpuaffinity, S_IRUGO, pci_bus_show_cpuaffinity, NULL);
 107
 108 /*
 109  * PCI Bus Class
 110  */
 111 static void release_pcibus_dev(struct device *dev)
 112 {
 113         struct pci_bus *pci_bus = to_pci_bus(dev);
 114
 115         if (pci_bus->bridge)
 116                 put_device(pci_bus->bridge);
 117         kfree(pci_bus);
 118 }
 119
 120 static struct class pcibus_class = {
 121         .name           = "pci_bus",
 122         .dev_release    = &release_pcibus_dev,
 123 };
 124
 125 static int __init pcibus_class_init(void)
 126 {
 127         return class_register(&pcibus_class);
 128 }
 129 postcore_initcall(pcibus_class_init);
 130
 131 /*
 132  * Translate the low bits of the PCI base
 133  * to the resource type
 134  */
 135 static inline unsigned int pci_calc_resource_flags(unsigned int flags)
 136 {
 137         if (flags & PCI_BASE_ADDRESS_SPACE_IO)
 138                 return IORESOURCE_IO;
 139
 140         if (flags & PCI_BASE_ADDRESS_MEM_PREFETCH)
 141                 return IORESOURCE_MEM | IORESOURCE_PREFETCH;
 142
 143         return IORESOURCE_MEM;
 144 }
 145
 146 /*
 147  * Find the extent of a PCI decode..
 148  */
 149 static u32 pci_size(u32 base, u32 maxbase, u32 mask)
 150 {
 151         u32 size = mask & maxbase;      /* Find the significant bits */
 152         if (!size)
 153                 return 0;
 154
 155         /* Get the lowest of them to find the decode size, and
 156            from that the extent.  */
 157         size = (size & ~(size-1)) - 1;
 158
 159         /* base == maxbase can be valid only if the BAR has
 160            already been programmed with all 1s.  */
 161         if (base == maxbase && ((base | size) & mask) != mask)
 162                 return 0;
 163
 164         return size;
 165 }
 166
 167 static u64 pci_size64(u64 base, u64 maxbase, u64 mask)
 168 {
 169         u64 size = mask & maxbase;      /* Find the significant bits */
 170         if (!size)
 171                 return 0;
 172
 173         /* Get the lowest of them to find the decode size, and
 174            from that the extent.  */
 175         size = (size & ~(size-1)) - 1;
 176
 177         /* base == maxbase can be valid only if the BAR has
 178            already been programmed with all 1s.  */
 179         if (base == maxbase && ((base | size) & mask) != mask)
 180                 return 0;
 181
 182         return size;
 183 }
 184
 185 static inline int is_64bit_memory(u32 mask)
 186 {
 187         if ((mask & (PCI_BASE_ADDRESS_SPACE|PCI_BASE_ADDRESS_MEM_TYPE_MASK)) ==
 188             (PCI_BASE_ADDRESS_SPACE_MEMORY|PCI_BASE_ADDRESS_MEM_TYPE_64))
 189                 return 1;
 190         return 0;
 191 }
 192
 193 static void pci_read_bases(struct pci_dev *dev, unsigned int howmany, int rom)
 194 {
 195         unsigned int pos, reg, next;
 196         u32 l, sz;
 197         struct resource *res;
 198
 199         for(pos=0; pos<howmany; pos = next) {
 200                 u64 l64;
 201                 u64 sz64;
 202                 u32 raw_sz;
 203
 204                 next = pos+1;
 205                 res = &dev->resource[pos];
 206                 res->name = pci_name(dev);
 207                 reg = PCI_BASE_ADDRESS_0 + (pos << 2);
 208                 pci_read_config_dword(dev, reg, &l);
 209                 pci_write_config_dword(dev, reg, ~0);
 210                 pci_read_config_dword(dev, reg, &sz);
 211                 pci_write_config_dword(dev, reg, l);
 212                 if (!sz || sz == 0xffffffff)
 213                         continue;
 214                 if (l == 0xffffffff)
 215                         l = 0;
 216                 raw_sz = sz;
 217                 if ((l & PCI_BASE_ADDRESS_SPACE) ==
 218                                 PCI_BASE_ADDRESS_SPACE_MEMORY) {
 219                         sz = pci_size(l, sz, (u32)PCI_BASE_ADDRESS_MEM_MASK);
 220                         /*
 221                          * For 64bit prefetchable memory sz could be 0, if the
 222                          * real size is bigger than 4G, so we need to check
 223                          * szhi for that.
 224                          */
 225                         if (!is_64bit_memory(l) && !sz)
 226                                 continue;
 227                         res->start = l & PCI_BASE_ADDRESS_MEM_MASK;
 228                         res->flags |= l & ~PCI_BASE_ADDRESS_MEM_MASK;
 229                 } else {
 230                         sz = pci_size(l, sz, PCI_BASE_ADDRESS_IO_MASK & 0xffff);
 231                         if (!sz)
 232                                 continue;
 233                         res->start = l & PCI_BASE_ADDRESS_IO_MASK;
 234                         res->flags |= l & ~PCI_BASE_ADDRESS_IO_MASK;
 235                 }
 236                 res->end = res->start + (unsigned long) sz;
 237                 res->flags |= pci_calc_resource_flags(l);
 238                 if (is_64bit_memory(l)) {
 239                         u32 szhi, lhi;
 240
 241                         pci_read_config_dword(dev, reg+4, &lhi);
 242                         pci_write_config_dword(dev, reg+4, ~0);
 243                         pci_read_config_dword(dev, reg+4, &szhi);
 244                         pci_write_config_dword(dev, reg+4, lhi);
 245                         sz64 = ((u64)szhi << 32) | raw_sz;
 246                         l64 = ((u64)lhi << 32) | l;
 247                         sz64 = pci_size64(l64, sz64, PCI_BASE_ADDRESS_MEM_MASK);
 248                         next++;
 249 #if BITS_PER_LONG == 64
 250                         if (!sz64) {
 251                                 res->start = 0;
 252                                 res->end = 0;
 253                                 res->flags = 0;
 254                                 continue;
 255                         }
 256                         res->start = l64 & PCI_BASE_ADDRESS_MEM_MASK;
 257                         res->end = res->start + sz64;
 258 #else
 259                         if (sz64 > 0x100000000ULL) {
 260                                 printk(KERN_ERR "PCI: Unable to handle 64-bit "
 261                                         "BAR for device %s\n", pci_name(dev));
 262                                 res->start = 0;
 263                                 res->flags = 0;
 264                         } else if (lhi) {
 265                                 /* 64-bit wide address, treat as disabled */
 266                                 pci_write_config_dword(dev, reg,
 267                                         l & ~(u32)PCI_BASE_ADDRESS_MEM_MASK);
 268                                 pci_write_config_dword(dev, reg+4, 0);
 269                                 res->start = 0;
 270                                 res->end = sz;
 271                         }
 272 #endif
 273                 }
 274         }
 275         if (rom) {
 276                 dev->rom_base_reg = rom;
 277                 res = &dev->resource[PCI_ROM_RESOURCE];
 278                 res->name = pci_name(dev);
 279                 pci_read_config_dword(dev, rom, &l);
 280                 pci_write_config_dword(dev, rom, ~PCI_ROM_ADDRESS_ENABLE);
 281                 pci_read_config_dword(dev, rom, &sz);
 282                 pci_write_config_dword(dev, rom, l);
 283                 if (l == 0xffffffff)
 284                         l = 0;
 285                 if (sz && sz != 0xffffffff) {
 286                         sz = pci_size(l, sz, (u32)PCI_ROM_ADDRESS_MASK);
 287                         if (sz) {
 288                                 res->flags = (l & IORESOURCE_ROM_ENABLE) |
 289                                   IORESOURCE_MEM | IORESOURCE_PREFETCH |
 290                                   IORESOURCE_READONLY | IORESOURCE_CACHEABLE;
 291                                 res->start = l & PCI_ROM_ADDRESS_MASK;
 292                                 res->end = res->start + (unsigned long) sz;
 293                         }
 294                 }
 295         }
 296 }
 297
 298 void __devinit pci_read_bridge_bases(struct pci_bus *child)
 299 {
 300         struct pci_dev *dev = child->self;
 301         u8 io_base_lo, io_limit_lo;
 302         u16 mem_base_lo, mem_limit_lo;
 303         unsigned long base, limit;
 304         struct resource *res;
 305         int i;
 306
 307         if (!dev)               /* It's a host bus, nothing to read */
 308                 return;
 309
 310         if (dev->transparent) {
 311                 printk(KERN_INFO "PCI: Transparent bridge - %s\n", pci_name(dev));
 312                 for(i = 3; i < PCI_BUS_NUM_RESOURCES; i++)
 313                         child->resource[i] = child->parent->resource[i - 3];
 314         }
 315
 316         for(i=0; i<3; i++)
 317                 child->resource[i] = &dev->resource[PCI_BRIDGE_RESOURCES+i];
 318
 319         res = child->resource[0];
 320         pci_read_config_byte(dev, PCI_IO_BASE, &io_base_lo);
 321         pci_read_config_byte(dev, PCI_IO_LIMIT, &io_limit_lo);
 322         base = (io_base_lo & PCI_IO_RANGE_MASK) << 8;
 323         limit = (io_limit_lo & PCI_IO_RANGE_MASK) << 8;
 324
 325         if ((io_base_lo & PCI_IO_RANGE_TYPE_MASK) == PCI_IO_RANGE_TYPE_32) {
 326                 u16 io_base_hi, io_limit_hi;
 327                 pci_read_config_word(dev, PCI_IO_BASE_UPPER16, &io_base_hi);
 328                 pci_read_config_word(dev, PCI_IO_LIMIT_UPPER16, &io_limit_hi);
 329                 base |= (io_base_hi << 16);
 330                 limit |= (io_limit_hi << 16);
 331         }
 332
 333         if (base <= limit) {
 334                 res->flags = (io_base_lo & PCI_IO_RANGE_TYPE_MASK) | IORESOURCE_IO;
 335                 if (!res->start)
 336                         res->start = base;
 337                 if (!res->end)
 338                         res->end = limit + 0xfff;
 339         }
 340
 341         res = child->resource[1];
 342         pci_read_config_word(dev, PCI_MEMORY_BASE, &mem_base_lo);
 343         pci_read_config_word(dev, PCI_MEMORY_LIMIT, &mem_limit_lo);
 344         base = (mem_base_lo & PCI_MEMORY_RANGE_MASK) << 16;
 345         limit = (mem_limit_lo & PCI_MEMORY_RANGE_MASK) << 16;
 346         if (base <= limit) {
 347                 res->flags = (mem_base_lo & PCI_MEMORY_RANGE_TYPE_MASK) | IORESOURCE_MEM;
 348                 res->start = base;
 349                 res->end = limit + 0xfffff;
 350         }
 351
 352         res = child->resource[2];
 353         pci_read_config_word(dev, PCI_PREF_MEMORY_BASE, &mem_base_lo);
 354         pci_read_config_word(dev, PCI_PREF_MEMORY_LIMIT, &mem_limit_lo);
 355         base = (mem_base_lo & PCI_PREF_RANGE_MASK) << 16;
 356         limit = (mem_limit_lo & PCI_PREF_RANGE_MASK) << 16;
 357
 358         if ((mem_base_lo & PCI_PREF_RANGE_TYPE_MASK) == PCI_PREF_RANGE_TYPE_64) {
 359                 u32 mem_base_hi, mem_limit_hi;
 360                 pci_read_config_dword(dev, PCI_PREF_BASE_UPPER32, &mem_base_hi);
 361                 pci_read_config_dword(dev, PCI_PREF_LIMIT_UPPER32, &mem_limit_hi);
 362
 363                 /*
 364                  * Some bridges set the base > limit by default, and some
 365                  * (broken) BIOSes do not initialize them.  If we find
 366                  * this, just assume they are not being used.
 367                  */
 368                 if (mem_base_hi <= mem_limit_hi) {
 369 #if BITS_PER_LONG == 64
 370                         base |= ((long) mem_base_hi) << 32;
 371                         limit |= ((long) mem_limit_hi) << 32;
 372 #else
 373                         if (mem_base_hi || mem_limit_hi) {
 374                                 printk(KERN_ERR "PCI: Unable to handle 64-bit address space for bridge %s\n", pci_name(dev));
 375                                 return;
 376                         }
 377 #endif
 378                 }
 379         }
 380         if (base <= limit) {
 381                 res->flags = (mem_base_lo & PCI_MEMORY_RANGE_TYPE_MASK) | IORESOURCE_MEM | IORESOURCE_PREFETCH;
 382                 res->start = base;
 383                 res->end = limit + 0xfffff;
 384         }
 385 }
 386
 387 static struct pci_bus * pci_alloc_bus(void)
 388 {
 389         struct pci_bus *b;
 390
 391         b = kzalloc(sizeof(*b), GFP_KERNEL);
 392         if (b) {
 393                 INIT_LIST_HEAD(&b->node);
 394                 INIT_LIST_HEAD(&b->children);
 395                 INIT_LIST_HEAD(&b->devices);
 396         }
 397         return b;
 398 }
 399
 400 static struct pci_bus * __devinit
 401 pci_alloc_child_bus(struct pci_bus *parent, struct pci_dev *bridge, int busnr)
 402 {
 403         struct pci_bus *child;
 404         int i;
 405
 406         /*
 407          * Allocate a new bus, and inherit stuff from the parent..
 408          */
 409         child = pci_alloc_bus();
 410         if (!child)
 411                 return NULL;
 412
 413         child->self = bridge;
 414         child->parent = parent;
 415         child->ops = parent->ops;
 416         child->sysdata = parent->sysdata;
 417         child->bus_flags = parent->bus_flags;
 418         child->bridge = get_device(&bridge->dev);
 419
 420         /* initialize some portions of the bus device, but don't register it
 421          * now as the parent is not properly set up yet.  This device will get
 422          * registered later in pci_bus_add_devices()
 423          */
 424         child->dev.class = &pcibus_class;
 425         sprintf(child->dev.bus_id, "%04x:%02x", pci_domain_nr(child), busnr);
 426
 427         /*
 428          * Set up the primary, secondary and subordinate
 429          * bus numbers.
 430          */
 431         child->number = child->secondary = busnr;
 432         child->primary = parent->secondary;
 433         child->subordinate = 0xff;
 434
 435         /* Set up default resource pointers and names.. */
 436         for (i = 0; i < 4; i++) {
 437                 child->resource[i] = &bridge->resource[PCI_BRIDGE_RESOURCES+i];
 438                 child->resource[i]->name = child->name;
 439         }
 440         bridge->subordinate = child;
 441
 442         return child;
 443 }
 444
 445 struct pci_bus *__ref pci_add_new_bus(struct pci_bus *parent, struct pci_dev *dev, int busnr)
 446 {
 447         struct pci_bus *child;
 448
 449         child = pci_alloc_child_bus(parent, dev, busnr);
 450         if (child) {
 451                 down_write(&pci_bus_sem);
 452                 list_add_tail(&child->node, &parent->children);
 453                 up_write(&pci_bus_sem);
 454         }
 455         return child;
 456 }
 457
 458 static void pci_fixup_parent_subordinate_busnr(struct pci_bus *child, int max)
 459 {
 460         struct pci_bus *parent = child->parent;
 461
 462         /* Attempts to fix that up are really dangerous unless
 463            we're going to re-assign all bus numbers. */
 464         if (!pcibios_assign_all_busses())
 465                 return;
 466
 467         while (parent->parent && parent->subordinate < max) {
 468                 parent->subordinate = max;
 469                 pci_write_config_byte(parent->self, PCI_SUBORDINATE_BUS, max);
 470                 parent = parent->parent;
 471         }
 472 }
 473
 474 /*
 475  * If it's a bridge, configure it and scan the bus behind it.
 476  * For CardBus bridges, we don't scan behind as the devices will
 477  * be handled by the bridge driver itself.
 478  *
 479  * We need to process bridges in two passes -- first we scan those
 480  * already configured by the BIOS and after we are done with all of
 481  * them, we proceed to assigning numbers to the remaining buses in
 482  * order to avoid overlaps between old and new bus numbers.
 483  */
 484 int __devinit pci_scan_bridge(struct pci_bus *bus, struct pci_dev *dev, int max, int pass)
 485 {
 486         struct pci_bus *child;
 487         int is_cardbus = (dev->hdr_type == PCI_HEADER_TYPE_CARDBUS);
 488         u32 buses, i, j = 0;
 489         u16 bctl;
 490
 491         pci_read_config_dword(dev, PCI_PRIMARY_BUS, &buses);
 492
 493         pr_debug("PCI: Scanning behind PCI bridge %s, config %06x, pass %d\n",
 494                  pci_name(dev), buses & 0xffffff, pass);
 495
 496         /* Disable MasterAbortMode during probing to avoid reporting
 497            of bus errors (in some architectures) */
 498         pci_read_config_word(dev, PCI_BRIDGE_CONTROL, &bctl);
 499         pci_write_config_word(dev, PCI_BRIDGE_CONTROL,
 500                               bctl & ~PCI_BRIDGE_CTL_MASTER_ABORT);
 501
 502         if ((buses & 0xffff00) && !pcibios_assign_all_busses() && !is_cardbus) {
 503                 unsigned int cmax, busnr;
 504                 /*
 505                  * Bus already configured by firmware, process it in the first
 506                  * pass and just note the configuration.
 507                  */
 508                 if (pass)
 509                         goto out;
 510                 busnr = (buses >> 8) & 0xFF;
 511
 512                 /*
 513                  * If we already got to this bus through a different bridge,
 514                  * ignore it.  This can happen with the i450NX chipset.
 515                  */
 516                 if (pci_find_bus(pci_domain_nr(bus), busnr)) {
 517                         printk(KERN_INFO "PCI: Bus %04x:%02x already known\n",
 518                                         pci_domain_nr(bus), busnr);
 519                         goto out;
 520                 }
 521
 522                 child = pci_add_new_bus(bus, dev, busnr);
 523                 if (!child)
 524                         goto out;
 525                 child->primary = buses & 0xFF;
 526                 child->subordinate = (buses >> 16) & 0xFF;
 527                 child->bridge_ctl = bctl;
 528
 529                 cmax = pci_scan_child_bus(child);
 530                 if (cmax > max)
 531                         max = cmax;
 532                 if (child->subordinate > max)
 533                         max = child->subordinate;
 534         } else {
 535                 /*
 536                  * We need to assign a number to this bus which we always
 537                  * do in the second pass.
 538                  */
 539                 if (!pass) {
 540                         if (pcibios_assign_all_busses())
 541                                 /* Temporarily disable forwarding of the
 542                                    configuration cycles on all bridges in
 543                                    this bus segment to avoid possible
 544                                    conflicts in the second pass between two
 545                                    bridges programmed with overlapping
 546                                    bus ranges. */
 547                                 pci_write_config_dword(dev, PCI_PRIMARY_BUS,
 548                                                        buses & ~0xffffff);
 549                         goto out;
 550                 }
 551
 552                 /* Clear errors */
 553                 pci_write_config_word(dev, PCI_STATUS, 0xffff);
 554
 555                 /* Prevent assigning a bus number that already exists.
 556                  * This can happen when a bridge is hot-plugged */
 557                 if (pci_find_bus(pci_domain_nr(bus), max+1))
 558                         goto out;
 559                 child = pci_add_new_bus(bus, dev, ++max);
 560                 buses = (buses & 0xff000000)
 561                       | ((unsigned int)(child->primary)     <<  0)
 562                       | ((unsigned int)(child->secondary)   <<  8)
 563                       | ((unsigned int)(child->subordinate) << 16);
 564
 565                 /*
 566                  * yenta.c forces a secondary latency timer of 176.
 567                  * Copy that behaviour here.
 568                  */
 569                 if (is_cardbus) {
 570                         buses &= ~0xff000000;
 571                         buses |= CARDBUS_LATENCY_TIMER << 24;
 572                 }
 573
 574                 /*
 575                  * We need to blast all three values with a single write.
 576                  */
 577                 pci_write_config_dword(dev, PCI_PRIMARY_BUS, buses);
 578
 579                 if (!is_cardbus) {
 580                         child->bridge_ctl = bctl;
 581                         /*
 582                          * Adjust subordinate busnr in parent buses.
 583                          * We do this before scanning for children because
 584                          * some devices may not be detected if the bios
 585                          * was lazy.
 586                          */
 587                         pci_fixup_parent_subordinate_busnr(child, max);
 588                         /* Now we can scan all subordinate buses... */
 589                         max = pci_scan_child_bus(child);
 590                         /*
 591                          * now fix it up again since we have found
 592                          * the real value of max.
 593                          */
 594                         pci_fixup_parent_subordinate_busnr(child, max);
 595                 } else {
 596                         /*
 597                          * For CardBus bridges, we leave 4 bus numbers
 598                          * as cards with a PCI-to-PCI bridge can be
 599                          * inserted later.
 600                          */
 601                         for (i=0; i<CARDBUS_RESERVE_BUSNR; i++) {
 602                                 struct pci_bus *parent = bus;
 603                                 if (pci_find_bus(pci_domain_nr(bus),
 604                                                         max+i+1))
 605                                         break;
 606                                 while (parent->parent) {
 607                                         if ((!pcibios_assign_all_busses()) &&
 608                                             (parent->subordinate > max) &&
 609                                             (parent->subordinate <= max+i)) {
 610                                                 j = 1;
 611                                         }
 612                                         parent = parent->parent;
 613                                 }
 614                                 if (j) {
 615                                         /*
 616                                          * Often, there are two cardbus bridges
 617                                          * -- try to leave one valid bus number
 618                                          * for each one.
 619                                          */
 620                                         i /= 2;
 621                                         break;
 622                                 }
 623                         }
 624                         max += i;
 625                         pci_fixup_parent_subordinate_busnr(child, max);
 626                 }
 627                 /*
 628                  * Set the subordinate bus number to its real value.
 629                  */
 630                 child->subordinate = max;
 631                 pci_write_config_byte(dev, PCI_SUBORDINATE_BUS, max);
 632         }
 633
 634         sprintf(child->name, (is_cardbus ? "PCI CardBus #%02x" : "PCI Bus #%02x"), child->number);
 635
 636         /* Has only triggered on CardBus, fixup is in yenta_socket */
 637         while (bus->parent) {
 638                 if ((child->subordinate > bus->subordinate) ||
 639                     (child->number > bus->subordinate) ||
 640                     (child->number < bus->number) ||
 641                     (child->subordinate < bus->number)) {
 642                         pr_debug("PCI: Bus #%02x (-#%02x) is %s "
 643                                 "hidden behind%s bridge #%02x (-#%02x)\n",
 644                                 child->number, child->subordinate,
 645                                 (bus->number > child->subordinate &&
 646                                  bus->subordinate < child->number) ?
 647                                         "wholly" : "partially",
 648                                 bus->self->transparent ? " transparent" : "",
 649                                 bus->number, bus->subordinate);
 650                 }
 651                 bus = bus->parent;
 652         }
 653
 654 out:
 655         pci_write_config_word(dev, PCI_BRIDGE_CONTROL, bctl);
 656
 657         return max;
 658 }
 659
 660 /*
 661  * Read interrupt line and base address registers.
 662  * The architecture-dependent code can tweak these, of course.
 663  */
 664 static void pci_read_irq(struct pci_dev *dev)
 665 {
 666         unsigned char irq;
 667
 668         pci_read_config_byte(dev, PCI_INTERRUPT_PIN, &irq);
 669         dev->pin = irq;
 670         if (irq)
 671                 pci_read_config_byte(dev, PCI_INTERRUPT_LINE, &irq);
 672         dev->irq = irq;
 673 }
 674
 675 #define LEGACY_IO_RESOURCE      (IORESOURCE_IO | IORESOURCE_PCI_FIXED)
 676
 677 /**
 678  * pci_setup_device - fill in class and map information of a device
 679  * @dev: the device structure to fill
 680  *
 681  * Initialize the device structure with information about the device's
 682  * vendor,class,memory and IO-space addresses,IRQ lines etc.
 683  * Called at initialisation of the PCI subsystem and by CardBus services.
 684  * Returns 0 on success and -1 if unknown type of device (not normal, bridge
 685  * or CardBus).
 686  */
 687 static int pci_setup_device(struct pci_dev * dev)
 688 {
 689         u32 class;
 690
 691         sprintf(pci_name(dev), "%04x:%02x:%02x.%d", pci_domain_nr(dev->bus),
 692                 dev->bus->number, PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn));
 693
 694         pci_read_config_dword(dev, PCI_CLASS_REVISION, &class);
 695         dev->revision = class & 0xff;
 696         class >>= 8;                                /* upper 3 bytes */
 697         dev->class = class;
 698         class >>= 8;
 699
 700         pr_debug("PCI: Found %s [%04x/%04x] %06x %02x\n", pci_name(dev),
 701                  dev->vendor, dev->device, class, dev->hdr_type);
 702
 703         /* "Unknown power state" */
 704         dev->current_state = PCI_UNKNOWN;
 705
 706         /* Early fixups, before probing the BARs */
 707         pci_fixup_device(pci_fixup_early, dev);
 708         class = dev->class >> 8;
 709
 710         switch (dev->hdr_type) {                    /* header type */
 711         case PCI_HEADER_TYPE_NORMAL:                /* standard header */
 712                 if (class == PCI_CLASS_BRIDGE_PCI)
 713                         goto bad;
 714                 pci_read_irq(dev);
 715                 pci_read_bases(dev, 6, PCI_ROM_ADDRESS);
 716                 pci_read_config_word(dev, PCI_SUBSYSTEM_VENDOR_ID, &dev->subsystem_vendor);
 717                 pci_read_config_word(dev, PCI_SUBSYSTEM_ID, &dev->subsystem_device);
 718
 719                 /*
 720                  *      Do the ugly legacy mode stuff here rather than broken chip
 721                  *      quirk code. Legacy mode ATA controllers have fixed
 722                  *      addresses. These are not always echoed in BAR0-3, and
 723                  *      BAR0-3 in a few cases contain junk!
 724                  */
 725                 if (class == PCI_CLASS_STORAGE_IDE) {
 726                         u8 progif;
 727                         pci_read_config_byte(dev, PCI_CLASS_PROG, &progif);
 728                         if ((progif & 1) == 0) {
 729                                 dev->resource[0].start = 0x1F0;
 730                                 dev->resource[0].end = 0x1F7;
 731                                 dev->resource[0].flags = LEGACY_IO_RESOURCE;
 732                                 dev->resource[1].start = 0x3F6;
 733                                 dev->resource[1].end = 0x3F6;
 734                                 dev->resource[1].flags = LEGACY_IO_RESOURCE;
 735                         }
 736                         if ((progif & 4) == 0) {
 737                                 dev->resource[2].start = 0x170;
 738                                 dev->resource[2].end = 0x177;
 739                                 dev->resource[2].flags = LEGACY_IO_RESOURCE;
 740                                 dev->resource[3].start = 0x376;
 741                                 dev->resource[3].end = 0x376;
 742                                 dev->resource[3].flags = LEGACY_IO_RESOURCE;
 743                         }
 744                 }
 745                 break;
 746
 747         case PCI_HEADER_TYPE_BRIDGE:                /* bridge header */
 748                 if (class != PCI_CLASS_BRIDGE_PCI)
 749                         goto bad;
 750                 /* The PCI-to-PCI bridge spec requires that subtractive
 751                    decoding (i.e. transparent) bridge must have programming
 752                    interface code of 0x01. */
 753                 pci_read_irq(dev);
 754                 dev->transparent = ((dev->class & 0xff) == 1);
 755                 pci_read_bases(dev, 2, PCI_ROM_ADDRESS1);
 756                 break;
 757
 758         case PCI_HEADER_TYPE_CARDBUS:               /* CardBus bridge header */
 759                 if (class != PCI_CLASS_BRIDGE_CARDBUS)
 760                         goto bad;
 761                 pci_read_irq(dev);
 762                 pci_read_bases(dev, 1, 0);
 763                 pci_read_config_word(dev, PCI_CB_SUBSYSTEM_VENDOR_ID, &dev->subsystem_vendor);
 764                 pci_read_config_word(dev, PCI_CB_SUBSYSTEM_ID, &dev->subsystem_device);
 765                 break;
 766
 767         default:                                    /* unknown header */
 768                 printk(KERN_ERR "PCI: device %s has unknown header type %02x, ignoring.\n",
 769                         pci_name(dev), dev->hdr_type);
 770                 return -1;
 771
 772         bad:
 773                 printk(KERN_ERR "PCI: %s: class %x doesn't match header type %02x. Ignoring class.\n",
 774                        pci_name(dev), class, dev->hdr_type);
 775                 dev->class = PCI_CLASS_NOT_DEFINED;
 776         }
 777
 778         /* We found a fine healthy device, go go go... */
 779         return 0;
 780 }
 781
 782 /**
 783  * pci_release_dev - free a pci device structure when all users of it are finished.
 784  * @dev: device that's been disconnected
 785  *
 786  * Will be called only by the device core when all users of this pci device are
 787  * done.
 788  */
 789 static void pci_release_dev(struct device *dev)
 790 {
 791         struct pci_dev *pci_dev;
 792
 793         pci_dev = to_pci_dev(dev);
 794         kfree(pci_dev);
 795 }
 796
 797 static void set_pcie_port_type(struct pci_dev *pdev)
 798 {
 799         int pos;
 800         u16 reg16;
 801
 802         pos = pci_find_capability(pdev, PCI_CAP_ID_EXP);
 803         if (!pos)
 804                 return;
 805         pdev->is_pcie = 1;
 806         pci_read_config_word(pdev, pos + PCI_EXP_FLAGS, &reg16);
 807         pdev->pcie_type = (reg16 & PCI_EXP_FLAGS_TYPE) >> 4;
 808 }
 809
 810 /**
 811  * pci_cfg_space_size - get the configuration space size of the PCI device.
 812  * @dev: PCI device
 813  *
 814  * Regular PCI devices have 256 bytes, but PCI-X 2 and PCI Express devices
 815  * have 4096 bytes.  Even if the device is capable, that doesn't mean we can
 816  * access it.  Maybe we don't have a way to generate extended config space
 817  * accesses, or the device is behind a reverse Express bridge.  So we try
 818  * reading the dword at 0x100 which must either be 0 or a valid extended
 819  * capability header.
 820  */
 821 int pci_cfg_space_size(struct pci_dev *dev)
 822 {
 823         int pos;
 824         u32 status;
 825
 826         pos = pci_find_capability(dev, PCI_CAP_ID_EXP);
 827         if (!pos) {
 828                 pos = pci_find_capability(dev, PCI_CAP_ID_PCIX);
 829                 if (!pos)
 830                         goto fail;
 831
 832                 pci_read_config_dword(dev, pos + PCI_X_STATUS, &status);
 833                 if (!(status & (PCI_X_STATUS_266MHZ | PCI_X_STATUS_533MHZ)))
 834                         goto fail;
 835         }
 836
 837         if (pci_read_config_dword(dev, 256, &status) != PCIBIOS_SUCCESSFUL)
 838                 goto fail;
 839         if (status == 0xffffffff)
 840                 goto fail;
 841
 842         return PCI_CFG_SPACE_EXP_SIZE;
 843
 844  fail:
 845         return PCI_CFG_SPACE_SIZE;
 846 }
 847
 848 static void pci_release_bus_bridge_dev(struct device *dev)
 849 {
 850         kfree(dev);
 851 }
 852
 853 struct pci_dev *alloc_pci_dev(void)
 854 {
 855         struct pci_dev *dev;
 856
 857         dev = kzalloc(sizeof(struct pci_dev), GFP_KERNEL);
 858         if (!dev)
 859                 return NULL;
 860
 861         INIT_LIST_HEAD(&dev->bus_list);
 862
 863         pci_msi_init_pci_dev(dev);
 864
 865         return dev;
 866 }
 867 EXPORT_SYMBOL(alloc_pci_dev);
 868
 869 /*
 870  * Read the config data for a PCI device, sanity-check it
 871  * and fill in the dev structure...
 872  */
 873 static struct pci_dev * __devinit
 874 pci_scan_device(struct pci_bus *bus, int devfn)
 875 {
 876         struct pci_dev *dev;
 877         u32 l;
 878         u8 hdr_type;
 879         int delay = 1;
 880
 881         if (pci_bus_read_config_dword(bus, devfn, PCI_VENDOR_ID, &l))
 882                 return NULL;
 883
 884         /* some broken boards return 0 or ~0 if a slot is empty: */
 885         if (l == 0xffffffff || l == 0x00000000 ||
 886             l == 0x0000ffff || l == 0xffff0000)
 887                 return NULL;
 888
 889         /* Configuration request Retry Status */
 890         while (l == 0xffff0001) {
 891                 msleep(delay);
 892                 delay *= 2;
 893                 if (pci_bus_read_config_dword(bus, devfn, PCI_VENDOR_ID, &l))
 894                         return NULL;
 895                 /* Card hasn't responded in 60 seconds?  Must be stuck. */
 896                 if (delay > 60 * 1000) {
 897                         printk(KERN_WARNING "Device %04x:%02x:%02x.%d not "
 898                                         "responding\n", pci_domain_nr(bus),
 899                                         bus->number, PCI_SLOT(devfn),
 900                                         PCI_FUNC(devfn));
 901                         return NULL;
 902                 }
 903         }
 904
 905         if (pci_bus_read_config_byte(bus, devfn, PCI_HEADER_TYPE, &hdr_type))
 906                 return NULL;
 907
 908         dev = alloc_pci_dev();
 909         if (!dev)
 910                 return NULL;
 911
 912         dev->bus = bus;
 913         dev->sysdata = bus->sysdata;
 914         dev->dev.parent = bus->bridge;
 915         dev->dev.bus = &pci_bus_type;
 916         dev->devfn = devfn;
 917         dev->hdr_type = hdr_type & 0x7f;
 918         dev->multifunction = !!(hdr_type & 0x80);
 919         dev->vendor = l & 0xffff;
 920         dev->device = (l >> 16) & 0xffff;
 921         dev->cfg_size = pci_cfg_space_size(dev);
 922         dev->error_state = pci_channel_io_normal;
 923         set_pcie_port_type(dev);
 924
 925         /* Assume 32-bit PCI; let 64-bit PCI cards (which are far rarer)
 926            set this higher, assuming the system even supports it.  */
 927         dev->dma_mask = 0xffffffff;
 928         if (pci_setup_device(dev) < 0) {
 929                 kfree(dev);
 930                 return NULL;
 931         }
 932
 933         return dev;
 934 }
 935
 936 void pci_device_add(struct pci_dev *dev, struct pci_bus *bus)
 937 {
 938         device_initialize(&dev->dev);
 939         dev->dev.release = pci_release_dev;
 940         pci_dev_get(dev);
 941
 942         set_dev_node(&dev->dev, pcibus_to_node(bus));
 943         dev->dev.dma_mask = &dev->dma_mask;
 944         dev->dev.dma_parms = &dev->dma_parms;
 945         dev->dev.coherent_dma_mask = 0xffffffffull;
 946
 947         pci_set_dma_max_seg_size(dev, 65536);
 948         pci_set_dma_seg_boundary(dev, 0xffffffff);
 949
 950         /* Fix up broken headers */
 951         pci_fixup_device(pci_fixup_header, dev);
 952
 953         /*
 954          * Add the device to our list of discovered devices
 955          * and the bus list for fixup functions, etc.
 956          */
 957         down_write(&pci_bus_sem);
 958         list_add_tail(&dev->bus_list, &bus->devices);
 959         up_write(&pci_bus_sem);
 960 }
 961
 962 struct pci_dev *__ref pci_scan_single_device(struct pci_bus *bus, int devfn)
 963 {
 964         struct pci_dev *dev;
 965
 966         dev = pci_scan_device(bus, devfn);
 967         if (!dev)
 968                 return NULL;
 969
 970         pci_device_add(dev, bus);
 971
 972         return dev;
 973 }
 974 EXPORT_SYMBOL(pci_scan_single_device);
 975
 976 /**
 977  * pci_scan_slot - scan a PCI slot on a bus for devices.
 978  * @bus: PCI bus to scan
 979  * @devfn: slot number to scan (must have zero function.)
 980  *
 981  * Scan a PCI slot on the specified PCI bus for devices, adding
 982  * discovered devices to the @bus->devices list.  New devices
 983  * will not have is_added set.
 984  */
 985 int pci_scan_slot(struct pci_bus *bus, int devfn)
 986 {
 987         int func, nr = 0;
 988         int scan_all_fns;
 989
 990         scan_all_fns = pcibios_scan_all_fns(bus, devfn);
 991
 992         for (func = 0; func < 8; func++, devfn++) {
 993                 struct pci_dev *dev;
 994
 995                 dev = pci_scan_single_device(bus, devfn);
 996                 if (dev) {
 997                         nr++;
 998
 999                         /*
1000                          * If this is a single function device,
1001                          * don't scan past the first function.
1002                          */
1003                         if (!dev->multifunction) {
1004                                 if (func > 0) {
1005                                         dev->multifunction = 1;
1006                                 } else {
1007                                         break;
1008                                 }
1009                         }
1010                 } else {
1011                         if (func == 0 && !scan_all_fns)
1012                                 break;
1013                 }
1014         }
1015         return nr;
1016 }
1017
1018 unsigned int __devinit pci_scan_child_bus(struct pci_bus *bus)
1019 {
1020         unsigned int devfn, pass, max = bus->secondary;
1021         struct pci_dev *dev;
1022
1023         pr_debug("PCI: Scanning bus %04x:%02x\n", pci_domain_nr(bus), bus->number);
1024
1025         /* Go find them, Rover! */
1026         for (devfn = 0; devfn < 0x100; devfn += 8)
1027                 pci_scan_slot(bus, devfn);
1028
1029         /*
1030          * After performing arch-dependent fixup of the bus, look behind
1031          * all PCI-to-PCI bridges on this bus.
1032          */
1033         pr_debug("PCI: Fixups for bus %04x:%02x\n", pci_domain_nr(bus), bus->number);
1034         pcibios_fixup_bus(bus);
1035         for (pass=0; pass < 2; pass++)
1036                 list_for_each_entry(dev, &bus->devices, bus_list) {
1037                         if (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE ||
1038                             dev->hdr_type == PCI_HEADER_TYPE_CARDBUS)
1039                                 max = pci_scan_bridge(bus, dev, max, pass);
1040                 }
1041
1042         /*
1043          * We've scanned the bus and so we know all about what's on
1044          * the other side of any bridges that may be on this bus plus
1045          * any devices.
1046          *
1047          * Return how far we've got finding sub-buses.
1048          */
1049         pr_debug("PCI: Bus scan for %04x:%02x returning with max=%02x\n",
1050                 pci_domain_nr(bus), bus->number, max);
1051         return max;
1052 }
1053
1054 struct pci_bus * pci_create_bus(struct device *parent,
1055                 int bus, struct pci_ops *ops, void *sysdata)
1056 {
1057         int error;
1058         struct pci_bus *b;
1059         struct device *dev;
1060
1061         b = pci_alloc_bus();
1062         if (!b)
1063                 return NULL;
1064
1065         dev = kmalloc(sizeof(*dev), GFP_KERNEL);
1066         if (!dev){
1067                 kfree(b);
1068                 return NULL;
1069         }
1070
1071         b->sysdata = sysdata;
1072         b->ops = ops;
1073
1074         if (pci_find_bus(pci_domain_nr(b), bus)) {
1075                 /* If we already got to this bus through a different bridge, ignore it */
1076                 pr_debug("PCI: Bus %04x:%02x already known\n", pci_domain_nr(b), bus);
1077                 goto err_out;
1078         }
1079
1080         down_write(&pci_bus_sem);
1081         list_add_tail(&b->node, &pci_root_buses);
1082         up_write(&pci_bus_sem);
1083
1084         memset(dev, 0, sizeof(*dev));
1085         dev->parent = parent;
1086         dev->release = pci_release_bus_bridge_dev;
1087         sprintf(dev->bus_id, "pci%04x:%02x", pci_domain_nr(b), bus);
1088         error = device_register(dev);
1089         if (error)
1090                 goto dev_reg_err;
1091         b->bridge = get_device(dev);
1092
1093         b->dev.class = &pcibus_class;
1094         b->dev.parent = b->bridge;
1095         sprintf(b->dev.bus_id, "%04x:%02x", pci_domain_nr(b), bus);
1096         error = device_register(&b->dev);
1097         if (error)
1098                 goto class_dev_reg_err;
1099         error = device_create_file(&b->dev, &dev_attr_cpuaffinity);
1100         if (error)
1101                 goto dev_create_file_err;
1102
1103         /* Create legacy_io and legacy_mem files for this bus */
1104         pci_create_legacy_files(b);
1105
1106         b->number = b->secondary = bus;
1107         b->resource[0] = &ioport_resource;
1108         b->resource[1] = &iomem_resource;
1109
1110         return b;
1111
1112 dev_create_file_err:
1113         device_unregister(&b->dev);
1114 class_dev_reg_err:
1115         device_unregister(dev);
1116 dev_reg_err:
1117         down_write(&pci_bus_sem);
1118         list_del(&b->node);
1119         up_write(&pci_bus_sem);
1120 err_out:
1121         kfree(dev);
1122         kfree(b);
1123         return NULL;
1124 }
1125
1126 struct pci_bus * __devinit pci_scan_bus_parented(struct device *parent,
1127                 int bus, struct pci_ops *ops, void *sysdata)
1128 {
1129         struct pci_bus *b;
1130
1131         b = pci_create_bus(parent, bus, ops, sysdata);
1132         if (b)
1133                 b->subordinate = pci_scan_child_bus(b);
1134         return b;
1135 }
1136 EXPORT_SYMBOL(pci_scan_bus_parented);
1137
1138 #ifdef CONFIG_HOTPLUG
1139 EXPORT_SYMBOL(pci_add_new_bus);
1140 EXPORT_SYMBOL(pci_scan_slot);
1141 EXPORT_SYMBOL(pci_scan_bridge);
1142 EXPORT_SYMBOL_GPL(pci_scan_child_bus);
1143 #endif
1144
1145 static int __init pci_sort_bf_cmp(const struct pci_dev *a, const struct pci_dev *b)
1146 {
1147         if      (pci_domain_nr(a->bus) < pci_domain_nr(b->bus)) return -1;
1148         else if (pci_domain_nr(a->bus) > pci_domain_nr(b->bus)) return  1;
1149
1150         if      (a->bus->number < b->bus->number) return -1;
1151         else if (a->bus->number > b->bus->number) return  1;
1152
1153         if      (a->devfn < b->devfn) return -1;
1154         else if (a->devfn > b->devfn) return  1;
1155
1156         return 0;
1157 }
1158
1159 /*
1160  * Yes, this forcably breaks the klist abstraction temporarily.  It
1161  * just wants to sort the klist, not change reference counts and
1162  * take/drop locks rapidly in the process.  It does all this while
1163  * holding the lock for the list, so objects can't otherwise be
1164  * added/removed while we're swizzling.
1165  */
1166 static void __init pci_insertion_sort_klist(struct pci_dev *a, struct list_head *list)
1167 {
1168         struct list_head *pos;
1169         struct klist_node *n;
1170         struct device *dev;
1171         struct pci_dev *b;
1172
1173         list_for_each(pos, list) {
1174                 n = container_of(pos, struct klist_node, n_node);
1175                 dev = container_of(n, struct device, knode_bus);
1176                 b = to_pci_dev(dev);
1177                 if (pci_sort_bf_cmp(a, b) <= 0) {
1178                         list_move_tail(&a->dev.knode_bus.n_node, &b->dev.knode_bus.n_node);
1179                         return;
1180                 }
1181         }
1182         list_move_tail(&a->dev.knode_bus.n_node, list);
1183 }
1184
1185 void __init pci_sort_breadthfirst(void)
1186 {
1187         LIST_HEAD(sorted_devices);
1188         struct list_head *pos, *tmp;
1189         struct klist_node *n;
1190         struct device *dev;
1191         struct pci_dev *pdev;
1192         struct klist *device_klist;
1193
1194         device_klist = bus_get_device_klist(&pci_bus_type);
1195
1196         spin_lock(&device_klist->k_lock);
1197         list_for_each_safe(pos, tmp, &device_klist->k_list) {
1198                 n = container_of(pos, struct klist_node, n_node);
1199                 dev = container_of(n, struct device, knode_bus);
1200                 pdev = to_pci_dev(dev);
1201                 pci_insertion_sort_klist(pdev, &sorted_devices);
1202         }
1203         list_splice(&sorted_devices, &device_klist->k_list);
1204         spin_unlock(&device_klist->k_lock);
1205 }