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         pci_set_dma_seg_boundary(dev, 0xffffffff);
 941
 942         /* Fix up broken headers */
 943         pci_fixup_device(pci_fixup_header, dev);
 944
 945         /*
 946          * Add the device to our list of discovered devices
 947          * and the bus list for fixup functions, etc.
 948          */
 949         INIT_LIST_HEAD(&dev->global_list);
 950         down_write(&pci_bus_sem);
 951         list_add_tail(&dev->bus_list, &bus->devices);
 952         up_write(&pci_bus_sem);
 953 }
 954
 955 struct pci_dev *__ref pci_scan_single_device(struct pci_bus *bus, int devfn)
 956 {
 957         struct pci_dev *dev;
 958
 959         dev = pci_scan_device(bus, devfn);
 960         if (!dev)
 961                 return NULL;
 962
 963         pci_device_add(dev, bus);
 964
 965         return dev;
 966 }
 967 EXPORT_SYMBOL(pci_scan_single_device);
 968
 969 /**
 970  * pci_scan_slot - scan a PCI slot on a bus for devices.
 971  * @bus: PCI bus to scan
 972  * @devfn: slot number to scan (must have zero function.)
 973  *
 974  * Scan a PCI slot on the specified PCI bus for devices, adding
 975  * discovered devices to the @bus->devices list.  New devices
 976  * will have an empty dev->global_list head.
 977  */
 978 int pci_scan_slot(struct pci_bus *bus, int devfn)
 979 {
 980         int func, nr = 0;
 981         int scan_all_fns;
 982
 983         scan_all_fns = pcibios_scan_all_fns(bus, devfn);
 984
 985         for (func = 0; func < 8; func++, devfn++) {
 986                 struct pci_dev *dev;
 987
 988                 dev = pci_scan_single_device(bus, devfn);
 989                 if (dev) {
 990                         nr++;
 991
 992                         /*
 993                          * If this is a single function device,
 994                          * don't scan past the first function.
 995                          */
 996                         if (!dev->multifunction) {
 997                                 if (func > 0) {
 998                                         dev->multifunction = 1;
 999                                 } else {
1000                                         break;
1001                                 }
1002                         }
1003                 } else {
1004                         if (func == 0 && !scan_all_fns)
1005                                 break;
1006                 }
1007         }
1008         return nr;
1009 }
1010
1011 unsigned int pci_scan_child_bus(struct pci_bus *bus)
1012 {
1013         unsigned int devfn, pass, max = bus->secondary;
1014         struct pci_dev *dev;
1015
1016         pr_debug("PCI: Scanning bus %04x:%02x\n", pci_domain_nr(bus), bus->number);
1017
1018         /* Go find them, Rover! */
1019         for (devfn = 0; devfn < 0x100; devfn += 8)
1020                 pci_scan_slot(bus, devfn);
1021
1022         /*
1023          * After performing arch-dependent fixup of the bus, look behind
1024          * all PCI-to-PCI bridges on this bus.
1025          */
1026         pr_debug("PCI: Fixups for bus %04x:%02x\n", pci_domain_nr(bus), bus->number);
1027         pcibios_fixup_bus(bus);
1028         for (pass=0; pass < 2; pass++)
1029                 list_for_each_entry(dev, &bus->devices, bus_list) {
1030                         if (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE ||
1031                             dev->hdr_type == PCI_HEADER_TYPE_CARDBUS)
1032                                 max = pci_scan_bridge(bus, dev, max, pass);
1033                 }
1034
1035         /*
1036          * We've scanned the bus and so we know all about what's on
1037          * the other side of any bridges that may be on this bus plus
1038          * any devices.
1039          *
1040          * Return how far we've got finding sub-buses.
1041          */
1042         pr_debug("PCI: Bus scan for %04x:%02x returning with max=%02x\n",
1043                 pci_domain_nr(bus), bus->number, max);
1044         return max;
1045 }
1046
1047 struct pci_bus * pci_create_bus(struct device *parent,
1048                 int bus, struct pci_ops *ops, void *sysdata)
1049 {
1050         int error;
1051         struct pci_bus *b;
1052         struct device *dev;
1053
1054         b = pci_alloc_bus();
1055         if (!b)
1056                 return NULL;
1057
1058         dev = kmalloc(sizeof(*dev), GFP_KERNEL);
1059         if (!dev){
1060                 kfree(b);
1061                 return NULL;
1062         }
1063
1064         b->sysdata = sysdata;
1065         b->ops = ops;
1066
1067         if (pci_find_bus(pci_domain_nr(b), bus)) {
1068                 /* If we already got to this bus through a different bridge, ignore it */
1069                 pr_debug("PCI: Bus %04x:%02x already known\n", pci_domain_nr(b), bus);
1070                 goto err_out;
1071         }
1072
1073         down_write(&pci_bus_sem);
1074         list_add_tail(&b->node, &pci_root_buses);
1075         up_write(&pci_bus_sem);
1076
1077         memset(dev, 0, sizeof(*dev));
1078         dev->parent = parent;
1079         dev->release = pci_release_bus_bridge_dev;
1080         sprintf(dev->bus_id, "pci%04x:%02x", pci_domain_nr(b), bus);
1081         error = device_register(dev);
1082         if (error)
1083                 goto dev_reg_err;
1084         b->bridge = get_device(dev);
1085
1086         b->dev.class = &pcibus_class;
1087         b->dev.parent = b->bridge;
1088         sprintf(b->dev.bus_id, "%04x:%02x", pci_domain_nr(b), bus);
1089         error = device_register(&b->dev);
1090         if (error)
1091                 goto class_dev_reg_err;
1092         error = device_create_file(&b->dev, &dev_attr_cpuaffinity);
1093         if (error)
1094                 goto dev_create_file_err;
1095
1096         /* Create legacy_io and legacy_mem files for this bus */
1097         pci_create_legacy_files(b);
1098
1099         b->number = b->secondary = bus;
1100         b->resource[0] = &ioport_resource;
1101         b->resource[1] = &iomem_resource;
1102
1103         return b;
1104
1105 dev_create_file_err:
1106         device_unregister(&b->dev);
1107 class_dev_reg_err:
1108         device_unregister(dev);
1109 dev_reg_err:
1110         down_write(&pci_bus_sem);
1111         list_del(&b->node);
1112         up_write(&pci_bus_sem);
1113 err_out:
1114         kfree(dev);
1115         kfree(b);
1116         return NULL;
1117 }
1118
1119 struct pci_bus *pci_scan_bus_parented(struct device *parent,
1120                 int bus, struct pci_ops *ops, void *sysdata)
1121 {
1122         struct pci_bus *b;
1123
1124         b = pci_create_bus(parent, bus, ops, sysdata);
1125         if (b)
1126                 b->subordinate = pci_scan_child_bus(b);
1127         return b;
1128 }
1129 EXPORT_SYMBOL(pci_scan_bus_parented);
1130
1131 #ifdef CONFIG_HOTPLUG
1132 EXPORT_SYMBOL(pci_add_new_bus);
1133 EXPORT_SYMBOL(pci_scan_slot);
1134 EXPORT_SYMBOL(pci_scan_bridge);
1135 EXPORT_SYMBOL_GPL(pci_scan_child_bus);
1136 #endif
1137
1138 static int __init pci_sort_bf_cmp(const struct pci_dev *a, const struct pci_dev *b)
1139 {
1140         if      (pci_domain_nr(a->bus) < pci_domain_nr(b->bus)) return -1;
1141         else if (pci_domain_nr(a->bus) > pci_domain_nr(b->bus)) return  1;
1142
1143         if      (a->bus->number < b->bus->number) return -1;
1144         else if (a->bus->number > b->bus->number) return  1;
1145
1146         if      (a->devfn < b->devfn) return -1;
1147         else if (a->devfn > b->devfn) return  1;
1148
1149         return 0;
1150 }
1151
1152 /*
1153  * Yes, this forcably breaks the klist abstraction temporarily.  It
1154  * just wants to sort the klist, not change reference counts and
1155  * take/drop locks rapidly in the process.  It does all this while
1156  * holding the lock for the list, so objects can't otherwise be
1157  * added/removed while we're swizzling.
1158  */
1159 static void __init pci_insertion_sort_klist(struct pci_dev *a, struct list_head *list)
1160 {
1161         struct list_head *pos;
1162         struct klist_node *n;
1163         struct device *dev;
1164         struct pci_dev *b;
1165
1166         list_for_each(pos, list) {
1167                 n = container_of(pos, struct klist_node, n_node);
1168                 dev = container_of(n, struct device, knode_bus);
1169                 b = to_pci_dev(dev);
1170                 if (pci_sort_bf_cmp(a, b) <= 0) {
1171                         list_move_tail(&a->dev.knode_bus.n_node, &b->dev.knode_bus.n_node);
1172                         return;
1173                 }
1174         }
1175         list_move_tail(&a->dev.knode_bus.n_node, list);
1176 }
1177
1178 static void __init pci_sort_breadthfirst_klist(void)
1179 {
1180         LIST_HEAD(sorted_devices);
1181         struct list_head *pos, *tmp;
1182         struct klist_node *n;
1183         struct device *dev;
1184         struct pci_dev *pdev;
1185         struct klist *device_klist;
1186
1187         device_klist = bus_get_device_klist(&pci_bus_type);
1188
1189         spin_lock(&device_klist->k_lock);
1190         list_for_each_safe(pos, tmp, &device_klist->k_list) {
1191                 n = container_of(pos, struct klist_node, n_node);
1192                 dev = container_of(n, struct device, knode_bus);
1193                 pdev = to_pci_dev(dev);
1194                 pci_insertion_sort_klist(pdev, &sorted_devices);
1195         }
1196         list_splice(&sorted_devices, &device_klist->k_list);
1197         spin_unlock(&device_klist->k_lock);
1198 }
1199
1200 static void __init pci_insertion_sort_devices(struct pci_dev *a, struct list_head *list)
1201 {
1202         struct pci_dev *b;
1203
1204         list_for_each_entry(b, list, global_list) {
1205                 if (pci_sort_bf_cmp(a, b) <= 0) {
1206                         list_move_tail(&a->global_list, &b->global_list);
1207                         return;
1208                 }
1209         }
1210         list_move_tail(&a->global_list, list);
1211 }
1212
1213 static void __init pci_sort_breadthfirst_devices(void)
1214 {
1215         LIST_HEAD(sorted_devices);
1216         struct pci_dev *dev, *tmp;
1217
1218         down_write(&pci_bus_sem);
1219         list_for_each_entry_safe(dev, tmp, &pci_devices, global_list) {
1220                 pci_insertion_sort_devices(dev, &sorted_devices);
1221         }
1222         list_splice(&sorted_devices, &pci_devices);
1223         up_write(&pci_bus_sem);
1224 }
1225
1226 void __init pci_sort_breadthfirst(void)
1227 {
1228         pci_sort_breadthfirst_devices();
1229         pci_sort_breadthfirst_klist();
1230 }
1231