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