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