SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/pci/probe.c

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