err.no Git - linux-2.6/blob - 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 LIST_HEAD(pci_devices);
  24
  25 /*
  26  * Some device drivers need know if pci is initiated.
  27  * Basically, we think pci is not initiated when there
  28  * is no device in list of pci_devices.
  29  */
  30 int no_pci_devices(void)
  31 {
  32         return list_empty(&pci_devices);
  33 }
  34
  35 EXPORT_SYMBOL(no_pci_devices);
  36
  37 #ifdef HAVE_PCI_LEGACY
  38 /**
  39  * pci_create_legacy_files - create legacy I/O port and memory files
  40  * @b: bus to create files under
  41  *
  42  * Some platforms allow access to legacy I/O port and ISA memory space on
  43  * a per-bus basis.  This routine creates the files and ties them into
  44  * their associated read, write and mmap files from pci-sysfs.c
  45  */
  46 static void pci_create_legacy_files(struct pci_bus *b)
  47 {
  48         b->legacy_io = kzalloc(sizeof(struct bin_attribute) * 2,
  49                                GFP_ATOMIC);
  50         if (b->legacy_io) {
  51                 b->legacy_io->attr.name = "legacy_io";
  52                 b->legacy_io->size = 0xffff;
  53                 b->legacy_io->attr.mode = S_IRUSR | S_IWUSR;
  54                 b->legacy_io->read = pci_read_legacy_io;
  55                 b->legacy_io->write = pci_write_legacy_io;
  56                 class_device_create_bin_file(&b->class_dev, b->legacy_io);
  57
  58                 /* Allocated above after the legacy_io struct */
  59                 b->legacy_mem = b->legacy_io + 1;
  60                 b->legacy_mem->attr.name = "legacy_mem";
  61                 b->legacy_mem->size = 1024*1024;
  62                 b->legacy_mem->attr.mode = S_IRUSR | S_IWUSR;
  63                 b->legacy_mem->mmap = pci_mmap_legacy_mem;
  64                 class_device_create_bin_file(&b->class_dev, b->legacy_mem);
  65         }
  66 }
  67
  68 void pci_remove_legacy_files(struct pci_bus *b)
  69 {
  70         if (b->legacy_io) {
  71                 class_device_remove_bin_file(&b->class_dev, b->legacy_io);
  72                 class_device_remove_bin_file(&b->class_dev, b->legacy_mem);
  73                 kfree(b->legacy_io); /* both are allocated here */
  74         }
  75 }
  76 #else /* !HAVE_PCI_LEGACY */
  77 static inline void pci_create_legacy_files(struct pci_bus *bus) { return; }
  78 void pci_remove_legacy_files(struct pci_bus *bus) { return; }
  79 #endif /* HAVE_PCI_LEGACY */
  80
  81 /*
  82  * PCI Bus Class Devices
  83  */
  84 static ssize_t pci_bus_show_cpuaffinity(struct class_device *class_dev,
  85                                         char *buf)
  86 {
  87         int ret;
  88         cpumask_t cpumask;
  89
  90         cpumask = pcibus_to_cpumask(to_pci_bus(class_dev));
  91         ret = cpumask_scnprintf(buf, PAGE_SIZE, cpumask);
  92         if (ret < PAGE_SIZE)
  93                 buf[ret++] = '\n';
  94         return ret;
  95 }
  96 CLASS_DEVICE_ATTR(cpuaffinity, S_IRUGO, pci_bus_show_cpuaffinity, NULL);
  97
  98 /*
  99  * PCI Bus Class
 100  */
 101 static void release_pcibus_dev(struct class_device *class_dev)
 102 {
 103         struct pci_bus *pci_bus = to_pci_bus(class_dev);
 104
 105         if (pci_bus->bridge)
 106                 put_device(pci_bus->bridge);
 107         kfree(pci_bus);
 108 }
 109
 110 static struct class pcibus_class = {
 111         .name           = "pci_bus",
 112         .release        = &release_pcibus_dev,
 113 };
 114
 115 static int __init pcibus_class_init(void)
 116 {
 117         return class_register(&pcibus_class);
 118 }
 119 postcore_initcall(pcibus_class_init);
 120
 121 /*
 122  * Translate the low bits of the PCI base
 123  * to the resource type
 124  */
 125 static inline unsigned int pci_calc_resource_flags(unsigned int flags)
 126 {
 127         if (flags & PCI_BASE_ADDRESS_SPACE_IO)
 128                 return IORESOURCE_IO;
 129
 130         if (flags & PCI_BASE_ADDRESS_MEM_PREFETCH)
 131                 return IORESOURCE_MEM | IORESOURCE_PREFETCH;
 132
 133         return IORESOURCE_MEM;
 134 }
 135
 136 /*
 137  * Find the extent of a PCI decode..
 138  */
 139 static u32 pci_size(u32 base, u32 maxbase, u32 mask)
 140 {
 141         u32 size = mask & maxbase;      /* Find the significant bits */
 142         if (!size)
 143                 return 0;
 144
 145         /* Get the lowest of them to find the decode size, and
 146            from that the extent.  */
 147         size = (size & ~(size-1)) - 1;
 148
 149         /* base == maxbase can be valid only if the BAR has
 150            already been programmed with all 1s.  */
 151         if (base == maxbase && ((base | size) & mask) != mask)
 152                 return 0;
 153
 154         return size;
 155 }
 156
 157 static u64 pci_size64(u64 base, u64 maxbase, u64 mask)
 158 {
 159         u64 size = mask & maxbase;      /* Find the significant bits */
 160         if (!size)
 161                 return 0;
 162
 163         /* Get the lowest of them to find the decode size, and
 164            from that the extent.  */
 165         size = (size & ~(size-1)) - 1;
 166
 167         /* base == maxbase can be valid only if the BAR has
 168            already been programmed with all 1s.  */
 169         if (base == maxbase && ((base | size) & mask) != mask)
 170                 return 0;
 171
 172         return size;
 173 }
 174
 175 static inline int is_64bit_memory(u32 mask)
 176 {
 177         if ((mask & (PCI_BASE_ADDRESS_SPACE|PCI_BASE_ADDRESS_MEM_TYPE_MASK)) ==
 178             (PCI_BASE_ADDRESS_SPACE_MEMORY|PCI_BASE_ADDRESS_MEM_TYPE_64))
 179                 return 1;
 180         return 0;
 181 }
 182
 183 static void pci_read_bases(struct pci_dev *dev, unsigned int howmany, int rom)
 184 {
 185         unsigned int pos, reg, next;
 186         u32 l, sz;
 187         struct resource *res;
 188
 189         for(pos=0; pos<howmany; pos = next) {
 190                 u64 l64;
 191                 u64 sz64;
 192                 u32 raw_sz;
 193
 194                 next = pos+1;
 195                 res = &dev->resource[pos];
 196                 res->name = pci_name(dev);
 197                 reg = PCI_BASE_ADDRESS_0 + (pos << 2);
 198                 pci_read_config_dword(dev, reg, &l);
 199                 pci_write_config_dword(dev, reg, ~0);
 200                 pci_read_config_dword(dev, reg, &sz);
 201                 pci_write_config_dword(dev, reg, l);
 202                 if (!sz || sz == 0xffffffff)
 203                         continue;
 204                 if (l == 0xffffffff)
 205                         l = 0;
 206                 raw_sz = sz;
 207                 if ((l & PCI_BASE_ADDRESS_SPACE) ==
 208                                 PCI_BASE_ADDRESS_SPACE_MEMORY) {
 209                         sz = pci_size(l, sz, (u32)PCI_BASE_ADDRESS_MEM_MASK);
 210                         /*
 211                          * For 64bit prefetchable memory sz could be 0, if the
 212                          * real size is bigger than 4G, so we need to check
 213                          * szhi for that.
 214                          */
 215                         if (!is_64bit_memory(l) && !sz)
 216                                 continue;
 217                         res->start = l & PCI_BASE_ADDRESS_MEM_MASK;
 218                         res->flags |= l & ~PCI_BASE_ADDRESS_MEM_MASK;
 219                 } else {
 220                         sz = pci_size(l, sz, PCI_BASE_ADDRESS_IO_MASK & 0xffff);
 221                         if (!sz)
 222                                 continue;
 223                         res->start = l & PCI_BASE_ADDRESS_IO_MASK;
 224                         res->flags |= l & ~PCI_BASE_ADDRESS_IO_MASK;
 225                 }
 226                 res->end = res->start + (unsigned long) sz;
 227                 res->flags |= pci_calc_resource_flags(l);
 228                 if (is_64bit_memory(l)) {
 229                         u32 szhi, lhi;
 230
 231                         pci_read_config_dword(dev, reg+4, &lhi);
 232                         pci_write_config_dword(dev, reg+4, ~0);
 233                         pci_read_config_dword(dev, reg+4, &szhi);
 234                         pci_write_config_dword(dev, reg+4, lhi);
 235                         sz64 = ((u64)szhi << 32) | raw_sz;
 236                         l64 = ((u64)lhi << 32) | l;
 237                         sz64 = pci_size64(l64, sz64, PCI_BASE_ADDRESS_MEM_MASK);
 238                         next++;
 239 #if BITS_PER_LONG == 64
 240                         if (!sz64) {
 241                                 res->start = 0;
 242                                 res->end = 0;
 243                                 res->flags = 0;
 244                                 continue;
 245                         }
 246                         res->start = l64 & PCI_BASE_ADDRESS_MEM_MASK;
 247                         res->end = res->start + sz64;
 248 #else
 249                         if (sz64 > 0x100000000ULL) {
 250                                 printk(KERN_ERR "PCI: Unable to handle 64-bit "
 251                                         "BAR for device %s\n", pci_name(dev));
 252                                 res->start = 0;
 253                                 res->flags = 0;
 254                         } else if (lhi) {
 255                                 /* 64-bit wide address, treat as disabled */
 256                                 pci_write_config_dword(dev, reg,
 257                                         l & ~(u32)PCI_BASE_ADDRESS_MEM_MASK);
 258                                 pci_write_config_dword(dev, reg+4, 0);
 259                                 res->start = 0;
 260                                 res->end = sz;
 261                         }
 262 #endif
 263                 }
 264         }
 265         if (rom) {
 266                 dev->rom_base_reg = rom;
 267                 res = &dev->resource[PCI_ROM_RESOURCE];
 268                 res->name = pci_name(dev);
 269                 pci_read_config_dword(dev, rom, &l);
 270                 pci_write_config_dword(dev, rom, ~PCI_ROM_ADDRESS_ENABLE);
 271                 pci_read_config_dword(dev, rom, &sz);
 272                 pci_write_config_dword(dev, rom, l);
 273                 if (l == 0xffffffff)
 274                         l = 0;
 275                 if (sz && sz != 0xffffffff) {
 276                         sz = pci_size(l, sz, (u32)PCI_ROM_ADDRESS_MASK);
 277                         if (sz) {
 278                                 res->flags = (l & IORESOURCE_ROM_ENABLE) |
 279                                   IORESOURCE_MEM | IORESOURCE_PREFETCH |
 280                                   IORESOURCE_READONLY | IORESOURCE_CACHEABLE;
 281                                 res->start = l & PCI_ROM_ADDRESS_MASK;
 282                                 res->end = res->start + (unsigned long) sz;
 283                         }
 284                 }
 285         }
 286 }
 287
 288 void pci_read_bridge_bases(struct pci_bus *child)
 289 {
 290         struct pci_dev *dev = child->self;
 291         u8 io_base_lo, io_limit_lo;
 292         u16 mem_base_lo, mem_limit_lo;
 293         unsigned long base, limit;
 294         struct resource *res;
 295         int i;
 296
 297         if (!dev)               /* It's a host bus, nothing to read */
 298                 return;
 299
 300         if (dev->transparent) {
 301                 printk(KERN_INFO "PCI: Transparent bridge - %s\n", pci_name(dev));
 302                 for(i = 3; i < PCI_BUS_NUM_RESOURCES; i++)
 303                         child->resource[i] = child->parent->resource[i - 3];
 304         }
 305
 306         for(i=0; i<3; i++)
 307                 child->resource[i] = &dev->resource[PCI_BRIDGE_RESOURCES+i];
 308
 309         res = child->resource[0];
 310         pci_read_config_byte(dev, PCI_IO_BASE, &io_base_lo);
 311         pci_read_config_byte(dev, PCI_IO_LIMIT, &io_limit_lo);
 312         base = (io_base_lo & PCI_IO_RANGE_MASK) << 8;
 313         limit = (io_limit_lo & PCI_IO_RANGE_MASK) << 8;
 314
 315         if ((io_base_lo & PCI_IO_RANGE_TYPE_MASK) == PCI_IO_RANGE_TYPE_32) {
 316                 u16 io_base_hi, io_limit_hi;
 317                 pci_read_config_word(dev, PCI_IO_BASE_UPPER16, &io_base_hi);
 318                 pci_read_config_word(dev, PCI_IO_LIMIT_UPPER16, &io_limit_hi);
 319                 base |= (io_base_hi << 16);
 320                 limit |= (io_limit_hi << 16);
 321         }
 322
 323         if (base <= limit) {
 324                 res->flags = (io_base_lo & PCI_IO_RANGE_TYPE_MASK) | IORESOURCE_IO;
 325                 if (!res->start)
 326                         res->start = base;
 327                 if (!res->end)
 328                         res->end = limit + 0xfff;
 329         }
 330
 331         res = child->resource[1];
 332         pci_read_config_word(dev, PCI_MEMORY_BASE, &mem_base_lo);
 333         pci_read_config_word(dev, PCI_MEMORY_LIMIT, &mem_limit_lo);
 334         base = (mem_base_lo & PCI_MEMORY_RANGE_MASK) << 16;
 335         limit = (mem_limit_lo & PCI_MEMORY_RANGE_MASK) << 16;
 336         if (base <= limit) {
 337                 res->flags = (mem_base_lo & PCI_MEMORY_RANGE_TYPE_MASK) | IORESOURCE_MEM;
 338                 res->start = base;
 339                 res->end = limit + 0xfffff;
 340         }
 341
 342         res = child->resource[2];
 343         pci_read_config_word(dev, PCI_PREF_MEMORY_BASE, &mem_base_lo);
 344         pci_read_config_word(dev, PCI_PREF_MEMORY_LIMIT, &mem_limit_lo);
 345         base = (mem_base_lo & PCI_PREF_RANGE_MASK) << 16;
 346         limit = (mem_limit_lo & PCI_PREF_RANGE_MASK) << 16;
 347
 348         if ((mem_base_lo & PCI_PREF_RANGE_TYPE_MASK) == PCI_PREF_RANGE_TYPE_64) {
 349                 u32 mem_base_hi, mem_limit_hi;
 350                 pci_read_config_dword(dev, PCI_PREF_BASE_UPPER32, &mem_base_hi);
 351                 pci_read_config_dword(dev, PCI_PREF_LIMIT_UPPER32, &mem_limit_hi);
 352
 353                 /*
 354                  * Some bridges set the base > limit by default, and some
 355                  * (broken) BIOSes do not initialize them.  If we find
 356                  * this, just assume they are not being used.
 357                  */
 358                 if (mem_base_hi <= mem_limit_hi) {
 359 #if BITS_PER_LONG == 64
 360                         base |= ((long) mem_base_hi) << 32;
 361                         limit |= ((long) mem_limit_hi) << 32;
 362 #else
 363                         if (mem_base_hi || mem_limit_hi) {
 364                                 printk(KERN_ERR "PCI: Unable to handle 64-bit address space for bridge %s\n", pci_name(dev));
 365                                 return;
 366                         }
 367 #endif
 368                 }
 369         }
 370         if (base <= limit) {
 371                 res->flags = (mem_base_lo & PCI_MEMORY_RANGE_TYPE_MASK) | IORESOURCE_MEM | IORESOURCE_PREFETCH;
 372                 res->start = base;
 373                 res->end = limit + 0xfffff;
 374         }
 375 }
 376
 377 static struct pci_bus * pci_alloc_bus(void)
 378 {
 379         struct pci_bus *b;
 380
 381         b = kzalloc(sizeof(*b), GFP_KERNEL);
 382         if (b) {
 383                 INIT_LIST_HEAD(&b->node);
 384                 INIT_LIST_HEAD(&b->children);
 385                 INIT_LIST_HEAD(&b->devices);
 386         }
 387         return b;
 388 }
 389
 390 static struct pci_bus * __devinit
 391 pci_alloc_child_bus(struct pci_bus *parent, struct pci_dev *bridge, int busnr)
 392 {
 393         struct pci_bus *child;
 394         int i;
 395         int retval;
 396
 397         /*
 398          * Allocate a new bus, and inherit stuff from the parent..
 399          */
 400         child = pci_alloc_bus();
 401         if (!child)
 402                 return NULL;
 403
 404         child->self = bridge;
 405         child->parent = parent;
 406         child->ops = parent->ops;
 407         child->sysdata = parent->sysdata;
 408         child->bus_flags = parent->bus_flags;
 409         child->bridge = get_device(&bridge->dev);
 410
 411         child->class_dev.class = &pcibus_class;
 412         sprintf(child->class_dev.class_id, "%04x:%02x", pci_domain_nr(child), busnr);
 413         retval = class_device_register(&child->class_dev);
 414         if (retval)
 415                 goto error_register;
 416         retval = class_device_create_file(&child->class_dev,
 417                                           &class_device_attr_cpuaffinity);
 418         if (retval)
 419                 goto error_file_create;
 420
 421         /*
 422          * Set up the primary, secondary and subordinate
 423          * bus numbers.
 424          */
 425         child->number = child->secondary = busnr;
 426         child->primary = parent->secondary;
 427         child->subordinate = 0xff;
 428
 429         /* Set up default resource pointers and names.. */
 430         for (i = 0; i < 4; i++) {
 431                 child->resource[i] = &bridge->resource[PCI_BRIDGE_RESOURCES+i];
 432                 child->resource[i]->name = child->name;
 433         }
 434         bridge->subordinate = child;
 435
 436         return child;
 437
 438 error_file_create:
 439         class_device_unregister(&child->class_dev);
 440 error_register:
 441         kfree(child);
 442         return NULL;
 443 }
 444
 445 struct pci_bus *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 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->global_list);
 862         INIT_LIST_HEAD(&dev->bus_list);
 863
 864         pci_msi_init_pci_dev(dev);
 865
 866         return dev;
 867 }
 868 EXPORT_SYMBOL(alloc_pci_dev);
 869
 870 /*
 871  * Read the config data for a PCI device, sanity-check it
 872  * and fill in the dev structure...
 873  */
 874 static struct pci_dev * __devinit
 875 pci_scan_device(struct pci_bus *bus, int devfn)
 876 {
 877         struct pci_dev *dev;
 878         u32 l;
 879         u8 hdr_type;
 880         int delay = 1;
 881
 882         if (pci_bus_read_config_dword(bus, devfn, PCI_VENDOR_ID, &l))
 883                 return NULL;
 884
 885         /* some broken boards return 0 or ~0 if a slot is empty: */
 886         if (l == 0xffffffff || l == 0x00000000 ||
 887             l == 0x0000ffff || l == 0xffff0000)
 888                 return NULL;
 889
 890         /* Configuration request Retry Status */
 891         while (l == 0xffff0001) {
 892                 msleep(delay);
 893                 delay *= 2;
 894                 if (pci_bus_read_config_dword(bus, devfn, PCI_VENDOR_ID, &l))
 895                         return NULL;
 896                 /* Card hasn't responded in 60 seconds?  Must be stuck. */
 897                 if (delay > 60 * 1000) {
 898                         printk(KERN_WARNING "Device %04x:%02x:%02x.%d not "
 899                                         "responding\n", pci_domain_nr(bus),
 900                                         bus->number, PCI_SLOT(devfn),
 901                                         PCI_FUNC(devfn));
 902                         return NULL;
 903                 }
 904         }
 905
 906         if (pci_bus_read_config_byte(bus, devfn, PCI_HEADER_TYPE, &hdr_type))
 907                 return NULL;
 908
 909         dev = alloc_pci_dev();
 910         if (!dev)
 911                 return NULL;
 912
 913         dev->bus = bus;
 914         dev->sysdata = bus->sysdata;
 915         dev->dev.parent = bus->bridge;
 916         dev->dev.bus = &pci_bus_type;
 917         dev->devfn = devfn;
 918         dev->hdr_type = hdr_type & 0x7f;
 919         dev->multifunction = !!(hdr_type & 0x80);
 920         dev->vendor = l & 0xffff;
 921         dev->device = (l >> 16) & 0xffff;
 922         dev->cfg_size = pci_cfg_space_size(dev);
 923         dev->error_state = pci_channel_io_normal;
 924         set_pcie_port_type(dev);
 925
 926         /* Assume 32-bit PCI; let 64-bit PCI cards (which are far rarer)
 927            set this higher, assuming the system even supports it.  */
 928         dev->dma_mask = 0xffffffff;
 929         if (pci_setup_device(dev) < 0) {
 930                 kfree(dev);
 931                 return NULL;
 932         }
 933
 934         return dev;
 935 }
 936
 937 void pci_device_add(struct pci_dev *dev, struct pci_bus *bus)
 938 {
 939         device_initialize(&dev->dev);
 940         dev->dev.release = pci_release_dev;
 941         pci_dev_get(dev);
 942
 943         set_dev_node(&dev->dev, pcibus_to_node(bus));
 944         dev->dev.dma_mask = &dev->dma_mask;
 945         dev->dev.coherent_dma_mask = 0xffffffffull;
 946
 947         /* Fix up broken headers */
 948         pci_fixup_device(pci_fixup_header, dev);
 949
 950         /*
 951          * Add the device to our list of discovered devices
 952          * and the bus list for fixup functions, etc.
 953          */
 954         INIT_LIST_HEAD(&dev->global_list);
 955         down_write(&pci_bus_sem);
 956         list_add_tail(&dev->bus_list, &bus->devices);
 957         up_write(&pci_bus_sem);
 958 }
 959
 960 struct pci_dev *pci_scan_single_device(struct pci_bus *bus, int devfn)
 961 {
 962         struct pci_dev *dev;
 963
 964         dev = pci_scan_device(bus, devfn);
 965         if (!dev)
 966                 return NULL;
 967
 968         pci_device_add(dev, bus);
 969
 970         return dev;
 971 }
 972 EXPORT_SYMBOL(pci_scan_single_device);
 973
 974 /**
 975  * pci_scan_slot - scan a PCI slot on a bus for devices.
 976  * @bus: PCI bus to scan
 977  * @devfn: slot number to scan (must have zero function.)
 978  *
 979  * Scan a PCI slot on the specified PCI bus for devices, adding
 980  * discovered devices to the @bus->devices list.  New devices
 981  * will have an empty dev->global_list head.
 982  */
 983 int pci_scan_slot(struct pci_bus *bus, int devfn)
 984 {
 985         int func, nr = 0;
 986         int scan_all_fns;
 987
 988         scan_all_fns = pcibios_scan_all_fns(bus, devfn);
 989
 990         for (func = 0; func < 8; func++, devfn++) {
 991                 struct pci_dev *dev;
 992
 993                 dev = pci_scan_single_device(bus, devfn);
 994                 if (dev) {
 995                         nr++;
 996
 997                         /*
 998                          * If this is a single function device,
 999                          * don't scan past the first function.
1000                          */
1001                         if (!dev->multifunction) {
1002                                 if (func > 0) {
1003                                         dev->multifunction = 1;
1004                                 } else {
1005                                         break;
1006                                 }
1007                         }
1008                 } else {
1009                         if (func == 0 && !scan_all_fns)
1010                                 break;
1011                 }
1012         }
1013         return nr;
1014 }
1015
1016 unsigned int pci_scan_child_bus(struct pci_bus *bus)
1017 {
1018         unsigned int devfn, pass, max = bus->secondary;
1019         struct pci_dev *dev;
1020
1021         pr_debug("PCI: Scanning bus %04x:%02x\n", pci_domain_nr(bus), bus->number);
1022
1023         /* Go find them, Rover! */
1024         for (devfn = 0; devfn < 0x100; devfn += 8)
1025                 pci_scan_slot(bus, devfn);
1026
1027         /*
1028          * After performing arch-dependent fixup of the bus, look behind
1029          * all PCI-to-PCI bridges on this bus.
1030          */
1031         pr_debug("PCI: Fixups for bus %04x:%02x\n", pci_domain_nr(bus), bus->number);
1032         pcibios_fixup_bus(bus);
1033         for (pass=0; pass < 2; pass++)
1034                 list_for_each_entry(dev, &bus->devices, bus_list) {
1035                         if (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE ||
1036                             dev->hdr_type == PCI_HEADER_TYPE_CARDBUS)
1037                                 max = pci_scan_bridge(bus, dev, max, pass);
1038                 }
1039
1040         /*
1041          * We've scanned the bus and so we know all about what's on
1042          * the other side of any bridges that may be on this bus plus
1043          * any devices.
1044          *
1045          * Return how far we've got finding sub-buses.
1046          */
1047         pr_debug("PCI: Bus scan for %04x:%02x returning with max=%02x\n",
1048                 pci_domain_nr(bus), bus->number, max);
1049         return max;
1050 }
1051
1052 unsigned int __devinit pci_do_scan_bus(struct pci_bus *bus)
1053 {
1054         unsigned int max;
1055
1056         max = pci_scan_child_bus(bus);
1057
1058         /*
1059          * Make the discovered devices available.
1060          */
1061         pci_bus_add_devices(bus);
1062
1063         return max;
1064 }
1065
1066 struct pci_bus * pci_create_bus(struct device *parent,
1067                 int bus, struct pci_ops *ops, void *sysdata)
1068 {
1069         int error;
1070         struct pci_bus *b;
1071         struct device *dev;
1072
1073         b = pci_alloc_bus();
1074         if (!b)
1075                 return NULL;
1076
1077         dev = kmalloc(sizeof(*dev), GFP_KERNEL);
1078         if (!dev){
1079                 kfree(b);
1080                 return NULL;
1081         }
1082
1083         b->sysdata = sysdata;
1084         b->ops = ops;
1085
1086         if (pci_find_bus(pci_domain_nr(b), bus)) {
1087                 /* If we already got to this bus through a different bridge, ignore it */
1088                 pr_debug("PCI: Bus %04x:%02x already known\n", pci_domain_nr(b), bus);
1089                 goto err_out;
1090         }
1091
1092         down_write(&pci_bus_sem);
1093         list_add_tail(&b->node, &pci_root_buses);
1094         up_write(&pci_bus_sem);
1095
1096         memset(dev, 0, sizeof(*dev));
1097         dev->parent = parent;
1098         dev->release = pci_release_bus_bridge_dev;
1099         sprintf(dev->bus_id, "pci%04x:%02x", pci_domain_nr(b), bus);
1100         error = device_register(dev);
1101         if (error)
1102                 goto dev_reg_err;
1103         b->bridge = get_device(dev);
1104
1105         b->class_dev.class = &pcibus_class;
1106         sprintf(b->class_dev.class_id, "%04x:%02x", pci_domain_nr(b), bus);
1107         error = class_device_register(&b->class_dev);
1108         if (error)
1109                 goto class_dev_reg_err;
1110         error = class_device_create_file(&b->class_dev, &class_device_attr_cpuaffinity);
1111         if (error)
1112                 goto class_dev_create_file_err;
1113
1114         /* Create legacy_io and legacy_mem files for this bus */
1115         pci_create_legacy_files(b);
1116
1117         error = sysfs_create_link(&b->class_dev.kobj, &b->bridge->kobj, "bridge");
1118         if (error)
1119                 goto sys_create_link_err;
1120
1121         b->number = b->secondary = bus;
1122         b->resource[0] = &ioport_resource;
1123         b->resource[1] = &iomem_resource;
1124
1125         return b;
1126
1127 sys_create_link_err:
1128         class_device_remove_file(&b->class_dev, &class_device_attr_cpuaffinity);
1129 class_dev_create_file_err:
1130         class_device_unregister(&b->class_dev);
1131 class_dev_reg_err:
1132         device_unregister(dev);
1133 dev_reg_err:
1134         down_write(&pci_bus_sem);
1135         list_del(&b->node);
1136         up_write(&pci_bus_sem);
1137 err_out:
1138         kfree(dev);
1139         kfree(b);
1140         return NULL;
1141 }
1142
1143 struct pci_bus *pci_scan_bus_parented(struct device *parent,
1144                 int bus, struct pci_ops *ops, void *sysdata)
1145 {
1146         struct pci_bus *b;
1147
1148         b = pci_create_bus(parent, bus, ops, sysdata);
1149         if (b)
1150                 b->subordinate = pci_scan_child_bus(b);
1151         return b;
1152 }
1153 EXPORT_SYMBOL(pci_scan_bus_parented);
1154
1155 #ifdef CONFIG_HOTPLUG
1156 EXPORT_SYMBOL(pci_add_new_bus);
1157 EXPORT_SYMBOL(pci_do_scan_bus);
1158 EXPORT_SYMBOL(pci_scan_slot);
1159 EXPORT_SYMBOL(pci_scan_bridge);
1160 EXPORT_SYMBOL_GPL(pci_scan_child_bus);
1161 #endif
1162
1163 static int __init pci_sort_bf_cmp(const struct pci_dev *a, const struct pci_dev *b)
1164 {
1165         if      (pci_domain_nr(a->bus) < pci_domain_nr(b->bus)) return -1;
1166         else if (pci_domain_nr(a->bus) > pci_domain_nr(b->bus)) return  1;
1167
1168         if      (a->bus->number < b->bus->number) return -1;
1169         else if (a->bus->number > b->bus->number) return  1;
1170
1171         if      (a->devfn < b->devfn) return -1;
1172         else if (a->devfn > b->devfn) return  1;
1173
1174         return 0;
1175 }
1176
1177 /*
1178  * Yes, this forcably breaks the klist abstraction temporarily.  It
1179  * just wants to sort the klist, not change reference counts and
1180  * take/drop locks rapidly in the process.  It does all this while
1181  * holding the lock for the list, so objects can't otherwise be
1182  * added/removed while we're swizzling.
1183  */
1184 static void __init pci_insertion_sort_klist(struct pci_dev *a, struct list_head *list)
1185 {
1186         struct list_head *pos;
1187         struct klist_node *n;
1188         struct device *dev;
1189         struct pci_dev *b;
1190
1191         list_for_each(pos, list) {
1192                 n = container_of(pos, struct klist_node, n_node);
1193                 dev = container_of(n, struct device, knode_bus);
1194                 b = to_pci_dev(dev);
1195                 if (pci_sort_bf_cmp(a, b) <= 0) {
1196                         list_move_tail(&a->dev.knode_bus.n_node, &b->dev.knode_bus.n_node);
1197                         return;
1198                 }
1199         }
1200         list_move_tail(&a->dev.knode_bus.n_node, list);
1201 }
1202
1203 static void __init pci_sort_breadthfirst_klist(void)
1204 {
1205         LIST_HEAD(sorted_devices);
1206         struct list_head *pos, *tmp;
1207         struct klist_node *n;
1208         struct device *dev;
1209         struct pci_dev *pdev;
1210         struct klist *device_klist;
1211
1212         device_klist = bus_get_device_klist(&pci_bus_type);
1213
1214         spin_lock(&device_klist->k_lock);
1215         list_for_each_safe(pos, tmp, &device_klist->k_list) {
1216                 n = container_of(pos, struct klist_node, n_node);
1217                 dev = container_of(n, struct device, knode_bus);
1218                 pdev = to_pci_dev(dev);
1219                 pci_insertion_sort_klist(pdev, &sorted_devices);
1220         }
1221         list_splice(&sorted_devices, &device_klist->k_list);
1222         spin_unlock(&device_klist->k_lock);
1223 }
1224
1225 static void __init pci_insertion_sort_devices(struct pci_dev *a, struct list_head *list)
1226 {
1227         struct pci_dev *b;
1228
1229         list_for_each_entry(b, list, global_list) {
1230                 if (pci_sort_bf_cmp(a, b) <= 0) {
1231                         list_move_tail(&a->global_list, &b->global_list);
1232                         return;
1233                 }
1234         }
1235         list_move_tail(&a->global_list, list);
1236 }
1237
1238 static void __init pci_sort_breadthfirst_devices(void)
1239 {
1240         LIST_HEAD(sorted_devices);
1241         struct pci_dev *dev, *tmp;
1242
1243         down_write(&pci_bus_sem);
1244         list_for_each_entry_safe(dev, tmp, &pci_devices, global_list) {
1245                 pci_insertion_sort_devices(dev, &sorted_devices);
1246         }
1247         list_splice(&sorted_devices, &pci_devices);
1248         up_write(&pci_bus_sem);
1249 }
1250
1251 void __init pci_sort_breadthfirst(void)
1252 {
1253         pci_sort_breadthfirst_devices();
1254         pci_sort_breadthfirst_klist();
1255 }
1256