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

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