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