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 <asm-generic/pci-bridge.h>
  14 #include "pci.h"
  15
  16 #define CARDBUS_LATENCY_TIMER   176     /* secondary latency timer */
  17 #define CARDBUS_RESERVE_BUSNR   3
  18
  19 struct resource busn_resource = {
  20         .name   = "PCI busn",
  21         .start  = 0,
  22         .end    = 255,
  23         .flags  = IORESOURCE_BUS,
  24 };
  25
  26 /* Ugh.  Need to stop exporting this to modules. */
  27 LIST_HEAD(pci_root_buses);
  28 EXPORT_SYMBOL(pci_root_buses);
  29
  30 static LIST_HEAD(pci_domain_busn_res_list);
  31
  32 struct pci_domain_busn_res {
  33         struct list_head list;
  34         struct resource res;
  35         int domain_nr;
  36 };
  37
  38 static struct resource *get_pci_domain_busn_res(int domain_nr)
  39 {
  40         struct pci_domain_busn_res *r;
  41
  42         list_for_each_entry(r, &pci_domain_busn_res_list, list)
  43                 if (r->domain_nr == domain_nr)
  44                         return &r->res;
  45
  46         r = kzalloc(sizeof(*r), GFP_KERNEL);
  47         if (!r)
  48                 return NULL;
  49
  50         r->domain_nr = domain_nr;
  51         r->res.start = 0;
  52         r->res.end = 0xff;
  53         r->res.flags = IORESOURCE_BUS | IORESOURCE_PCI_FIXED;
  54
  55         list_add_tail(&r->list, &pci_domain_busn_res_list);
  56
  57         return &r->res;
  58 }
  59
  60 static int find_anything(struct device *dev, void *data)
  61 {
  62         return 1;
  63 }
  64
  65 /*
  66  * Some device drivers need know if pci is initiated.
  67  * Basically, we think pci is not initiated when there
  68  * is no device to be found on the pci_bus_type.
  69  */
  70 int no_pci_devices(void)
  71 {
  72         struct device *dev;
  73         int no_devices;
  74
  75         dev = bus_find_device(&pci_bus_type, NULL, NULL, find_anything);
  76         no_devices = (dev == NULL);
  77         put_device(dev);
  78         return no_devices;
  79 }
  80 EXPORT_SYMBOL(no_pci_devices);
  81
  82 /*
  83  * PCI Bus Class
  84  */
  85 static void release_pcibus_dev(struct device *dev)
  86 {
  87         struct pci_bus *pci_bus = to_pci_bus(dev);
  88
  89         if (pci_bus->bridge)
  90                 put_device(pci_bus->bridge);
  91         pci_bus_remove_resources(pci_bus);
  92         pci_release_bus_of_node(pci_bus);
  93         kfree(pci_bus);
  94 }
  95
  96 static struct class pcibus_class = {
  97         .name           = "pci_bus",
  98         .dev_release    = &release_pcibus_dev,
  99         .dev_attrs      = pcibus_dev_attrs,
 100 };
 101
 102 static int __init pcibus_class_init(void)
 103 {
 104         return class_register(&pcibus_class);
 105 }
 106 postcore_initcall(pcibus_class_init);
 107
 108 static u64 pci_size(u64 base, u64 maxbase, u64 mask)
 109 {
 110         u64 size = mask & maxbase;      /* Find the significant bits */
 111         if (!size)
 112                 return 0;
 113
 114         /* Get the lowest of them to find the decode size, and
 115            from that the extent.  */
 116         size = (size & ~(size-1)) - 1;
 117
 118         /* base == maxbase can be valid only if the BAR has
 119            already been programmed with all 1s.  */
 120         if (base == maxbase && ((base | size) & mask) != mask)
 121                 return 0;
 122
 123         return size;
 124 }
 125
 126 static inline unsigned long decode_bar(struct pci_dev *dev, u32 bar)
 127 {
 128         u32 mem_type;
 129         unsigned long flags;
 130
 131         if ((bar & PCI_BASE_ADDRESS_SPACE) == PCI_BASE_ADDRESS_SPACE_IO) {
 132                 flags = bar & ~PCI_BASE_ADDRESS_IO_MASK;
 133                 flags |= IORESOURCE_IO;
 134                 return flags;
 135         }
 136
 137         flags = bar & ~PCI_BASE_ADDRESS_MEM_MASK;
 138         flags |= IORESOURCE_MEM;
 139         if (flags & PCI_BASE_ADDRESS_MEM_PREFETCH)
 140                 flags |= IORESOURCE_PREFETCH;
 141
 142         mem_type = bar & PCI_BASE_ADDRESS_MEM_TYPE_MASK;
 143         switch (mem_type) {
 144         case PCI_BASE_ADDRESS_MEM_TYPE_32:
 145                 break;
 146         case PCI_BASE_ADDRESS_MEM_TYPE_1M:
 147                 /* 1M mem BAR treated as 32-bit BAR */
 148                 break;
 149         case PCI_BASE_ADDRESS_MEM_TYPE_64:
 150                 flags |= IORESOURCE_MEM_64;
 151                 break;
 152         default:
 153                 /* mem unknown type treated as 32-bit BAR */
 154                 break;
 155         }
 156         return flags;
 157 }
 158
 159 /**
 160  * pci_read_base - read a PCI BAR
 161  * @dev: the PCI device
 162  * @type: type of the BAR
 163  * @res: resource buffer to be filled in
 164  * @pos: BAR position in the config space
 165  *
 166  * Returns 1 if the BAR is 64-bit, or 0 if 32-bit.
 167  */
 168 int __pci_read_base(struct pci_dev *dev, enum pci_bar_type type,
 169                         struct resource *res, unsigned int pos)
 170 {
 171         u32 l, sz, mask;
 172         u16 orig_cmd;
 173         struct pci_bus_region region;
 174         bool bar_too_big = false, bar_disabled = false;
 175
 176         mask = type ? PCI_ROM_ADDRESS_MASK : ~0;
 177
 178         /* No printks while decoding is disabled! */
 179         if (!dev->mmio_always_on) {
 180                 pci_read_config_word(dev, PCI_COMMAND, &orig_cmd);
 181                 pci_write_config_word(dev, PCI_COMMAND,
 182                         orig_cmd & ~(PCI_COMMAND_MEMORY | PCI_COMMAND_IO));
 183         }
 184
 185         res->name = pci_name(dev);
 186
 187         pci_read_config_dword(dev, pos, &l);
 188         pci_write_config_dword(dev, pos, l | mask);
 189         pci_read_config_dword(dev, pos, &sz);
 190         pci_write_config_dword(dev, pos, l);
 191
 192         /*
 193          * All bits set in sz means the device isn't working properly.
 194          * If the BAR isn't implemented, all bits must be 0.  If it's a
 195          * memory BAR or a ROM, bit 0 must be clear; if it's an io BAR, bit
 196          * 1 must be clear.
 197          */
 198         if (!sz || sz == 0xffffffff)
 199                 goto fail;
 200
 201         /*
 202          * I don't know how l can have all bits set.  Copied from old code.
 203          * Maybe it fixes a bug on some ancient platform.
 204          */
 205         if (l == 0xffffffff)
 206                 l = 0;
 207
 208         if (type == pci_bar_unknown) {
 209                 res->flags = decode_bar(dev, l);
 210                 res->flags |= IORESOURCE_SIZEALIGN;
 211                 if (res->flags & IORESOURCE_IO) {
 212                         l &= PCI_BASE_ADDRESS_IO_MASK;
 213                         sz &= PCI_BASE_ADDRESS_IO_MASK;
 214                         mask = PCI_BASE_ADDRESS_IO_MASK & (u32) IO_SPACE_LIMIT;
 215                 } else {
 216                         l &= PCI_BASE_ADDRESS_MEM_MASK;
 217                         sz &= PCI_BASE_ADDRESS_MEM_MASK;
 218                         mask = (u32)PCI_BASE_ADDRESS_MEM_MASK;
 219                 }
 220         } else {
 221                 res->flags |= (l & IORESOURCE_ROM_ENABLE);
 222                 l &= PCI_ROM_ADDRESS_MASK;
 223                 sz &= PCI_ROM_ADDRESS_MASK;
 224                 mask = (u32)PCI_ROM_ADDRESS_MASK;
 225         }
 226
 227         if (res->flags & IORESOURCE_MEM_64) {
 228                 u64 l64 = l;
 229                 u64 sz64 = sz;
 230                 u64 mask64 = mask | (u64)~0 << 32;
 231
 232                 pci_read_config_dword(dev, pos + 4, &l);
 233                 pci_write_config_dword(dev, pos + 4, ~0);
 234                 pci_read_config_dword(dev, pos + 4, &sz);
 235                 pci_write_config_dword(dev, pos + 4, l);
 236
 237                 l64 |= ((u64)l << 32);
 238                 sz64 |= ((u64)sz << 32);
 239
 240                 sz64 = pci_size(l64, sz64, mask64);
 241
 242                 if (!sz64)
 243                         goto fail;
 244
 245                 if ((sizeof(resource_size_t) < 8) && (sz64 > 0x100000000ULL)) {
 246                         bar_too_big = true;
 247                         goto fail;
 248                 }
 249
 250                 if ((sizeof(resource_size_t) < 8) && l) {
 251                         /* Address above 32-bit boundary; disable the BAR */
 252                         pci_write_config_dword(dev, pos, 0);
 253                         pci_write_config_dword(dev, pos + 4, 0);
 254                         region.start = 0;
 255                         region.end = sz64;
 256                         pcibios_bus_to_resource(dev, res, &region);
 257                         bar_disabled = true;
 258                 } else {
 259                         region.start = l64;
 260                         region.end = l64 + sz64;
 261                         pcibios_bus_to_resource(dev, res, &region);
 262                 }
 263         } else {
 264                 sz = pci_size(l, sz, mask);
 265
 266                 if (!sz)
 267                         goto fail;
 268
 269                 region.start = l;
 270                 region.end = l + sz;
 271                 pcibios_bus_to_resource(dev, res, &region);
 272         }
 273
 274         goto out;
 275
 276
 277 fail:
 278         res->flags = 0;
 279 out:
 280         if (!dev->mmio_always_on)
 281                 pci_write_config_word(dev, PCI_COMMAND, orig_cmd);
 282
 283         if (bar_too_big)
 284                 dev_err(&dev->dev, "reg %x: can't handle 64-bit BAR\n", pos);
 285         if (res->flags && !bar_disabled)
 286                 dev_printk(KERN_DEBUG, &dev->dev, "reg %x: %pR\n", pos, res);
 287
 288         return (res->flags & IORESOURCE_MEM_64) ? 1 : 0;
 289 }
 290
 291 static void pci_read_bases(struct pci_dev *dev, unsigned int howmany, int rom)
 292 {
 293         unsigned int pos, reg;
 294
 295         for (pos = 0; pos < howmany; pos++) {
 296                 struct resource *res = &dev->resource[pos];
 297                 reg = PCI_BASE_ADDRESS_0 + (pos << 2);
 298                 pos += __pci_read_base(dev, pci_bar_unknown, res, reg);
 299         }
 300
 301         if (rom) {
 302                 struct resource *res = &dev->resource[PCI_ROM_RESOURCE];
 303                 dev->rom_base_reg = rom;
 304                 res->flags = IORESOURCE_MEM | IORESOURCE_PREFETCH |
 305                                 IORESOURCE_READONLY | IORESOURCE_CACHEABLE |
 306                                 IORESOURCE_SIZEALIGN;
 307                 __pci_read_base(dev, pci_bar_mem32, res, rom);
 308         }
 309 }
 310
 311 static void pci_read_bridge_io(struct pci_bus *child)
 312 {
 313         struct pci_dev *dev = child->self;
 314         u8 io_base_lo, io_limit_lo;
 315         unsigned long io_mask, io_granularity, base, limit;
 316         struct pci_bus_region region;
 317         struct resource *res;
 318
 319         io_mask = PCI_IO_RANGE_MASK;
 320         io_granularity = 0x1000;
 321         if (dev->io_window_1k) {
 322                 /* Support 1K I/O space granularity */
 323                 io_mask = PCI_IO_1K_RANGE_MASK;
 324                 io_granularity = 0x400;
 325         }
 326
 327         res = child->resource[0];
 328         pci_read_config_byte(dev, PCI_IO_BASE, &io_base_lo);
 329         pci_read_config_byte(dev, PCI_IO_LIMIT, &io_limit_lo);
 330         base = (io_base_lo & io_mask) << 8;
 331         limit = (io_limit_lo & io_mask) << 8;
 332
 333         if ((io_base_lo & PCI_IO_RANGE_TYPE_MASK) == PCI_IO_RANGE_TYPE_32) {
 334                 u16 io_base_hi, io_limit_hi;
 335
 336                 pci_read_config_word(dev, PCI_IO_BASE_UPPER16, &io_base_hi);
 337                 pci_read_config_word(dev, PCI_IO_LIMIT_UPPER16, &io_limit_hi);
 338                 base |= ((unsigned long) io_base_hi << 16);
 339                 limit |= ((unsigned long) io_limit_hi << 16);
 340         }
 341
 342         if (base <= limit) {
 343                 res->flags = (io_base_lo & PCI_IO_RANGE_TYPE_MASK) | IORESOURCE_IO;
 344                 region.start = base;
 345                 region.end = limit + io_granularity - 1;
 346                 pcibios_bus_to_resource(dev, res, &region);
 347                 dev_printk(KERN_DEBUG, &dev->dev, "  bridge window %pR\n", res);
 348         }
 349 }
 350
 351 static void pci_read_bridge_mmio(struct pci_bus *child)
 352 {
 353         struct pci_dev *dev = child->self;
 354         u16 mem_base_lo, mem_limit_lo;
 355         unsigned long base, limit;
 356         struct pci_bus_region region;
 357         struct resource *res;
 358
 359         res = child->resource[1];
 360         pci_read_config_word(dev, PCI_MEMORY_BASE, &mem_base_lo);
 361         pci_read_config_word(dev, PCI_MEMORY_LIMIT, &mem_limit_lo);
 362         base = ((unsigned long) mem_base_lo & PCI_MEMORY_RANGE_MASK) << 16;
 363         limit = ((unsigned long) mem_limit_lo & PCI_MEMORY_RANGE_MASK) << 16;
 364         if (base <= limit) {
 365                 res->flags = (mem_base_lo & PCI_MEMORY_RANGE_TYPE_MASK) | IORESOURCE_MEM;
 366                 region.start = base;
 367                 region.end = limit + 0xfffff;
 368                 pcibios_bus_to_resource(dev, res, &region);
 369                 dev_printk(KERN_DEBUG, &dev->dev, "  bridge window %pR\n", res);
 370         }
 371 }
 372
 373 static void pci_read_bridge_mmio_pref(struct pci_bus *child)
 374 {
 375         struct pci_dev *dev = child->self;
 376         u16 mem_base_lo, mem_limit_lo;
 377         unsigned long base, limit;
 378         struct pci_bus_region region;
 379         struct resource *res;
 380
 381         res = child->resource[2];
 382         pci_read_config_word(dev, PCI_PREF_MEMORY_BASE, &mem_base_lo);
 383         pci_read_config_word(dev, PCI_PREF_MEMORY_LIMIT, &mem_limit_lo);
 384         base = ((unsigned long) mem_base_lo & PCI_PREF_RANGE_MASK) << 16;
 385         limit = ((unsigned long) mem_limit_lo & PCI_PREF_RANGE_MASK) << 16;
 386
 387         if ((mem_base_lo & PCI_PREF_RANGE_TYPE_MASK) == PCI_PREF_RANGE_TYPE_64) {
 388                 u32 mem_base_hi, mem_limit_hi;
 389
 390                 pci_read_config_dword(dev, PCI_PREF_BASE_UPPER32, &mem_base_hi);
 391                 pci_read_config_dword(dev, PCI_PREF_LIMIT_UPPER32, &mem_limit_hi);
 392
 393                 /*
 394                  * Some bridges set the base > limit by default, and some
 395                  * (broken) BIOSes do not initialize them.  If we find
 396                  * this, just assume they are not being used.
 397                  */
 398                 if (mem_base_hi <= mem_limit_hi) {
 399 #if BITS_PER_LONG == 64
 400                         base |= ((unsigned long) mem_base_hi) << 32;
 401                         limit |= ((unsigned long) mem_limit_hi) << 32;
 402 #else
 403                         if (mem_base_hi || mem_limit_hi) {
 404                                 dev_err(&dev->dev, "can't handle 64-bit "
 405                                         "address space for bridge\n");
 406                                 return;
 407                         }
 408 #endif
 409                 }
 410         }
 411         if (base <= limit) {
 412                 res->flags = (mem_base_lo & PCI_PREF_RANGE_TYPE_MASK) |
 413                                          IORESOURCE_MEM | IORESOURCE_PREFETCH;
 414                 if (res->flags & PCI_PREF_RANGE_TYPE_64)
 415                         res->flags |= IORESOURCE_MEM_64;
 416                 region.start = base;
 417                 region.end = limit + 0xfffff;
 418                 pcibios_bus_to_resource(dev, res, &region);
 419                 dev_printk(KERN_DEBUG, &dev->dev, "  bridge window %pR\n", res);
 420         }
 421 }
 422
 423 void pci_read_bridge_bases(struct pci_bus *child)
 424 {
 425         struct pci_dev *dev = child->self;
 426         struct resource *res;
 427         int i;
 428
 429         if (pci_is_root_bus(child))     /* It's a host bus, nothing to read */
 430                 return;
 431
 432         dev_info(&dev->dev, "PCI bridge to %pR%s\n",
 433                  &child->busn_res,
 434                  dev->transparent ? " (subtractive decode)" : "");
 435
 436         pci_bus_remove_resources(child);
 437         for (i = 0; i < PCI_BRIDGE_RESOURCE_NUM; i++)
 438                 child->resource[i] = &dev->resource[PCI_BRIDGE_RESOURCES+i];
 439
 440         pci_read_bridge_io(child);
 441         pci_read_bridge_mmio(child);
 442         pci_read_bridge_mmio_pref(child);
 443
 444         if (dev->transparent) {
 445                 pci_bus_for_each_resource(child->parent, res, i) {
 446                         if (res) {
 447                                 pci_bus_add_resource(child, res,
 448                                                      PCI_SUBTRACTIVE_DECODE);
 449                                 dev_printk(KERN_DEBUG, &dev->dev,
 450                                            "  bridge window %pR (subtractive decode)\n",
 451                                            res);
 452                         }
 453                 }
 454         }
 455 }
 456
 457 static struct pci_bus * pci_alloc_bus(void)
 458 {
 459         struct pci_bus *b;
 460
 461         b = kzalloc(sizeof(*b), GFP_KERNEL);
 462         if (b) {
 463                 INIT_LIST_HEAD(&b->node);
 464                 INIT_LIST_HEAD(&b->children);
 465                 INIT_LIST_HEAD(&b->devices);
 466                 INIT_LIST_HEAD(&b->slots);
 467                 INIT_LIST_HEAD(&b->resources);
 468                 b->max_bus_speed = PCI_SPEED_UNKNOWN;
 469                 b->cur_bus_speed = PCI_SPEED_UNKNOWN;
 470         }
 471         return b;
 472 }
 473
 474 static struct pci_host_bridge *pci_alloc_host_bridge(struct pci_bus *b)
 475 {
 476         struct pci_host_bridge *bridge;
 477
 478         bridge = kzalloc(sizeof(*bridge), GFP_KERNEL);
 479         if (bridge) {
 480                 INIT_LIST_HEAD(&bridge->windows);
 481                 bridge->bus = b;
 482         }
 483
 484         return bridge;
 485 }
 486
 487 static unsigned char pcix_bus_speed[] = {
 488         PCI_SPEED_UNKNOWN,              /* 0 */
 489         PCI_SPEED_66MHz_PCIX,           /* 1 */
 490         PCI_SPEED_100MHz_PCIX,          /* 2 */
 491         PCI_SPEED_133MHz_PCIX,          /* 3 */
 492         PCI_SPEED_UNKNOWN,              /* 4 */
 493         PCI_SPEED_66MHz_PCIX_ECC,       /* 5 */
 494         PCI_SPEED_100MHz_PCIX_ECC,      /* 6 */
 495         PCI_SPEED_133MHz_PCIX_ECC,      /* 7 */
 496         PCI_SPEED_UNKNOWN,              /* 8 */
 497         PCI_SPEED_66MHz_PCIX_266,       /* 9 */
 498         PCI_SPEED_100MHz_PCIX_266,      /* A */
 499         PCI_SPEED_133MHz_PCIX_266,      /* B */
 500         PCI_SPEED_UNKNOWN,              /* C */
 501         PCI_SPEED_66MHz_PCIX_533,       /* D */
 502         PCI_SPEED_100MHz_PCIX_533,      /* E */
 503         PCI_SPEED_133MHz_PCIX_533       /* F */
 504 };
 505
 506 static unsigned char pcie_link_speed[] = {
 507         PCI_SPEED_UNKNOWN,              /* 0 */
 508         PCIE_SPEED_2_5GT,               /* 1 */
 509         PCIE_SPEED_5_0GT,               /* 2 */
 510         PCIE_SPEED_8_0GT,               /* 3 */
 511         PCI_SPEED_UNKNOWN,              /* 4 */
 512         PCI_SPEED_UNKNOWN,              /* 5 */
 513         PCI_SPEED_UNKNOWN,              /* 6 */
 514         PCI_SPEED_UNKNOWN,              /* 7 */
 515         PCI_SPEED_UNKNOWN,              /* 8 */
 516         PCI_SPEED_UNKNOWN,              /* 9 */
 517         PCI_SPEED_UNKNOWN,              /* A */
 518         PCI_SPEED_UNKNOWN,              /* B */
 519         PCI_SPEED_UNKNOWN,              /* C */
 520         PCI_SPEED_UNKNOWN,              /* D */
 521         PCI_SPEED_UNKNOWN,              /* E */
 522         PCI_SPEED_UNKNOWN               /* F */
 523 };
 524
 525 void pcie_update_link_speed(struct pci_bus *bus, u16 linksta)
 526 {
 527         bus->cur_bus_speed = pcie_link_speed[linksta & PCI_EXP_LNKSTA_CLS];
 528 }
 529 EXPORT_SYMBOL_GPL(pcie_update_link_speed);
 530
 531 static unsigned char agp_speeds[] = {
 532         AGP_UNKNOWN,
 533         AGP_1X,
 534         AGP_2X,
 535         AGP_4X,
 536         AGP_8X
 537 };
 538
 539 static enum pci_bus_speed agp_speed(int agp3, int agpstat)
 540 {
 541         int index = 0;
 542
 543         if (agpstat & 4)
 544                 index = 3;
 545         else if (agpstat & 2)
 546                 index = 2;
 547         else if (agpstat & 1)
 548                 index = 1;
 549         else
 550                 goto out;
 551
 552         if (agp3) {
 553                 index += 2;
 554                 if (index == 5)
 555                         index = 0;
 556         }
 557
 558  out:
 559         return agp_speeds[index];
 560 }
 561
 562
 563 static void pci_set_bus_speed(struct pci_bus *bus)
 564 {
 565         struct pci_dev *bridge = bus->self;
 566         int pos;
 567
 568         pos = pci_find_capability(bridge, PCI_CAP_ID_AGP);
 569         if (!pos)
 570                 pos = pci_find_capability(bridge, PCI_CAP_ID_AGP3);
 571         if (pos) {
 572                 u32 agpstat, agpcmd;
 573
 574                 pci_read_config_dword(bridge, pos + PCI_AGP_STATUS, &agpstat);
 575                 bus->max_bus_speed = agp_speed(agpstat & 8, agpstat & 7);
 576
 577                 pci_read_config_dword(bridge, pos + PCI_AGP_COMMAND, &agpcmd);
 578                 bus->cur_bus_speed = agp_speed(agpstat & 8, agpcmd & 7);
 579         }
 580
 581         pos = pci_find_capability(bridge, PCI_CAP_ID_PCIX);
 582         if (pos) {
 583                 u16 status;
 584                 enum pci_bus_speed max;
 585
 586                 pci_read_config_word(bridge, pos + PCI_X_BRIDGE_SSTATUS,
 587                                      &status);
 588
 589                 if (status & PCI_X_SSTATUS_533MHZ) {
 590                         max = PCI_SPEED_133MHz_PCIX_533;
 591                 } else if (status & PCI_X_SSTATUS_266MHZ) {
 592                         max = PCI_SPEED_133MHz_PCIX_266;
 593                 } else if (status & PCI_X_SSTATUS_133MHZ) {
 594                         if ((status & PCI_X_SSTATUS_VERS) == PCI_X_SSTATUS_V2) {
 595                                 max = PCI_SPEED_133MHz_PCIX_ECC;
 596                         } else {
 597                                 max = PCI_SPEED_133MHz_PCIX;
 598                         }
 599                 } else {
 600                         max = PCI_SPEED_66MHz_PCIX;
 601                 }
 602
 603                 bus->max_bus_speed = max;
 604                 bus->cur_bus_speed = pcix_bus_speed[
 605                         (status & PCI_X_SSTATUS_FREQ) >> 6];
 606
 607                 return;
 608         }
 609
 610         pos = pci_find_capability(bridge, PCI_CAP_ID_EXP);
 611         if (pos) {
 612                 u32 linkcap;
 613                 u16 linksta;
 614
 615                 pcie_capability_read_dword(bridge, PCI_EXP_LNKCAP, &linkcap);
 616                 bus->max_bus_speed = pcie_link_speed[linkcap & PCI_EXP_LNKCAP_SLS];
 617
 618                 pcie_capability_read_word(bridge, PCI_EXP_LNKSTA, &linksta);
 619                 pcie_update_link_speed(bus, linksta);
 620         }
 621 }
 622
 623
 624 static struct pci_bus *pci_alloc_child_bus(struct pci_bus *parent,
 625                                            struct pci_dev *bridge, int busnr)
 626 {
 627         struct pci_bus *child;
 628         int i;
 629         int ret;
 630
 631         /*
 632          * Allocate a new bus, and inherit stuff from the parent..
 633          */
 634         child = pci_alloc_bus();
 635         if (!child)
 636                 return NULL;
 637
 638         child->parent = parent;
 639         child->ops = parent->ops;
 640         child->sysdata = parent->sysdata;
 641         child->bus_flags = parent->bus_flags;
 642
 643         /* initialize some portions of the bus device, but don't register it
 644          * now as the parent is not properly set up yet.
 645          */
 646         child->dev.class = &pcibus_class;
 647         dev_set_name(&child->dev, "%04x:%02x", pci_domain_nr(child), busnr);
 648
 649         /*
 650          * Set up the primary, secondary and subordinate
 651          * bus numbers.
 652          */
 653         child->number = child->busn_res.start = busnr;
 654         child->primary = parent->busn_res.start;
 655         child->busn_res.end = 0xff;
 656
 657         if (!bridge) {
 658                 child->dev.parent = parent->bridge;
 659                 goto add_dev;
 660         }
 661
 662         child->self = bridge;
 663         child->bridge = get_device(&bridge->dev);
 664         child->dev.parent = child->bridge;
 665         pci_set_bus_of_node(child);
 666         pci_set_bus_speed(child);
 667
 668         /* Set up default resource pointers and names.. */
 669         for (i = 0; i < PCI_BRIDGE_RESOURCE_NUM; i++) {
 670                 child->resource[i] = &bridge->resource[PCI_BRIDGE_RESOURCES+i];
 671                 child->resource[i]->name = child->name;
 672         }
 673         bridge->subordinate = child;
 674
 675 add_dev:
 676         ret = device_register(&child->dev);
 677         WARN_ON(ret < 0);
 678
 679         pcibios_add_bus(child);
 680
 681         /* Create legacy_io and legacy_mem files for this bus */
 682         pci_create_legacy_files(child);
 683
 684         return child;
 685 }
 686
 687 struct pci_bus *__ref pci_add_new_bus(struct pci_bus *parent, struct pci_dev *dev, int busnr)
 688 {
 689         struct pci_bus *child;
 690
 691         child = pci_alloc_child_bus(parent, dev, busnr);
 692         if (child) {
 693                 down_write(&pci_bus_sem);
 694                 list_add_tail(&child->node, &parent->children);
 695                 up_write(&pci_bus_sem);
 696         }
 697         return child;
 698 }
 699
 700 static void pci_fixup_parent_subordinate_busnr(struct pci_bus *child, int max)
 701 {
 702         struct pci_bus *parent = child->parent;
 703
 704         /* Attempts to fix that up are really dangerous unless
 705            we're going to re-assign all bus numbers. */
 706         if (!pcibios_assign_all_busses())
 707                 return;
 708
 709         while (parent->parent && parent->busn_res.end < max) {
 710                 parent->busn_res.end = max;
 711                 pci_write_config_byte(parent->self, PCI_SUBORDINATE_BUS, max);
 712                 parent = parent->parent;
 713         }
 714 }
 715
 716 /*
 717  * If it's a bridge, configure it and scan the bus behind it.
 718  * For CardBus bridges, we don't scan behind as the devices will
 719  * be handled by the bridge driver itself.
 720  *
 721  * We need to process bridges in two passes -- first we scan those
 722  * already configured by the BIOS and after we are done with all of
 723  * them, we proceed to assigning numbers to the remaining buses in
 724  * order to avoid overlaps between old and new bus numbers.
 725  */
 726 int pci_scan_bridge(struct pci_bus *bus, struct pci_dev *dev, int max, int pass)
 727 {
 728         struct pci_bus *child;
 729         int is_cardbus = (dev->hdr_type == PCI_HEADER_TYPE_CARDBUS);
 730         u32 buses, i, j = 0;
 731         u16 bctl;
 732         u8 primary, secondary, subordinate;
 733         int broken = 0;
 734
 735         pci_read_config_dword(dev, PCI_PRIMARY_BUS, &buses);
 736         primary = buses & 0xFF;
 737         secondary = (buses >> 8) & 0xFF;
 738         subordinate = (buses >> 16) & 0xFF;
 739
 740         dev_dbg(&dev->dev, "scanning [bus %02x-%02x] behind bridge, pass %d\n",
 741                 secondary, subordinate, pass);
 742
 743         if (!primary && (primary != bus->number) && secondary && subordinate) {
 744                 dev_warn(&dev->dev, "Primary bus is hard wired to 0\n");
 745                 primary = bus->number;
 746         }
 747
 748         /* Check if setup is sensible at all */
 749         if (!pass &&
 750             (primary != bus->number || secondary <= bus->number ||
 751              secondary > subordinate)) {
 752                 dev_info(&dev->dev, "bridge configuration invalid ([bus %02x-%02x]), reconfiguring\n",
 753                          secondary, subordinate);
 754                 broken = 1;
 755         }
 756
 757         /* Disable MasterAbortMode during probing to avoid reporting
 758            of bus errors (in some architectures) */
 759         pci_read_config_word(dev, PCI_BRIDGE_CONTROL, &bctl);
 760         pci_write_config_word(dev, PCI_BRIDGE_CONTROL,
 761                               bctl & ~PCI_BRIDGE_CTL_MASTER_ABORT);
 762
 763         if ((secondary || subordinate) && !pcibios_assign_all_busses() &&
 764             !is_cardbus && !broken) {
 765                 unsigned int cmax;
 766                 /*
 767                  * Bus already configured by firmware, process it in the first
 768                  * pass and just note the configuration.
 769                  */
 770                 if (pass)
 771                         goto out;
 772
 773                 /*
 774                  * If we already got to this bus through a different bridge,
 775                  * don't re-add it. This can happen with the i450NX chipset.
 776                  *
 777                  * However, we continue to descend down the hierarchy and
 778                  * scan remaining child buses.
 779                  */
 780                 child = pci_find_bus(pci_domain_nr(bus), secondary);
 781                 if (!child) {
 782                         child = pci_add_new_bus(bus, dev, secondary);
 783                         if (!child)
 784                                 goto out;
 785                         child->primary = primary;
 786                         pci_bus_insert_busn_res(child, secondary, subordinate);
 787                         child->bridge_ctl = bctl;
 788                 }
 789
 790                 cmax = pci_scan_child_bus(child);
 791                 if (cmax > max)
 792                         max = cmax;
 793                 if (child->busn_res.end > max)
 794                         max = child->busn_res.end;
 795         } else {
 796                 /*
 797                  * We need to assign a number to this bus which we always
 798                  * do in the second pass.
 799                  */
 800                 if (!pass) {
 801                         if (pcibios_assign_all_busses() || broken)
 802                                 /* Temporarily disable forwarding of the
 803                                    configuration cycles on all bridges in
 804                                    this bus segment to avoid possible
 805                                    conflicts in the second pass between two
 806                                    bridges programmed with overlapping
 807                                    bus ranges. */
 808                                 pci_write_config_dword(dev, PCI_PRIMARY_BUS,
 809                                                        buses & ~0xffffff);
 810                         goto out;
 811                 }
 812
 813                 /* Clear errors */
 814                 pci_write_config_word(dev, PCI_STATUS, 0xffff);
 815
 816                 /* Prevent assigning a bus number that already exists.
 817                  * This can happen when a bridge is hot-plugged, so in
 818                  * this case we only re-scan this bus. */
 819                 child = pci_find_bus(pci_domain_nr(bus), max+1);
 820                 if (!child) {
 821                         child = pci_add_new_bus(bus, dev, ++max);
 822                         if (!child)
 823                                 goto out;
 824                         pci_bus_insert_busn_res(child, max, 0xff);
 825                 }
 826                 buses = (buses & 0xff000000)
 827                       | ((unsigned int)(child->primary)     <<  0)
 828                       | ((unsigned int)(child->busn_res.start)   <<  8)
 829                       | ((unsigned int)(child->busn_res.end) << 16);
 830
 831                 /*
 832                  * yenta.c forces a secondary latency timer of 176.
 833                  * Copy that behaviour here.
 834                  */
 835                 if (is_cardbus) {
 836                         buses &= ~0xff000000;
 837                         buses |= CARDBUS_LATENCY_TIMER << 24;
 838                 }
 839
 840                 /*
 841                  * We need to blast all three values with a single write.
 842                  */
 843                 pci_write_config_dword(dev, PCI_PRIMARY_BUS, buses);
 844
 845                 if (!is_cardbus) {
 846                         child->bridge_ctl = bctl;
 847                         /*
 848                          * Adjust subordinate busnr in parent buses.
 849                          * We do this before scanning for children because
 850                          * some devices may not be detected if the bios
 851                          * was lazy.
 852                          */
 853                         pci_fixup_parent_subordinate_busnr(child, max);
 854                         /* Now we can scan all subordinate buses... */
 855                         max = pci_scan_child_bus(child);
 856                         /*
 857                          * now fix it up again since we have found
 858                          * the real value of max.
 859                          */
 860                         pci_fixup_parent_subordinate_busnr(child, max);
 861                 } else {
 862                         /*
 863                          * For CardBus bridges, we leave 4 bus numbers
 864                          * as cards with a PCI-to-PCI bridge can be
 865                          * inserted later.
 866                          */
 867                         for (i=0; i<CARDBUS_RESERVE_BUSNR; i++) {
 868                                 struct pci_bus *parent = bus;
 869                                 if (pci_find_bus(pci_domain_nr(bus),
 870                                                         max+i+1))
 871                                         break;
 872                                 while (parent->parent) {
 873                                         if ((!pcibios_assign_all_busses()) &&
 874                                             (parent->busn_res.end > max) &&
 875                                             (parent->busn_res.end <= max+i)) {
 876                                                 j = 1;
 877                                         }
 878                                         parent = parent->parent;
 879                                 }
 880                                 if (j) {
 881                                         /*
 882                                          * Often, there are two cardbus bridges
 883                                          * -- try to leave one valid bus number
 884                                          * for each one.
 885                                          */
 886                                         i /= 2;
 887                                         break;
 888                                 }
 889                         }
 890                         max += i;
 891                         pci_fixup_parent_subordinate_busnr(child, max);
 892                 }
 893                 /*
 894                  * Set the subordinate bus number to its real value.
 895                  */
 896                 pci_bus_update_busn_res_end(child, max);
 897                 pci_write_config_byte(dev, PCI_SUBORDINATE_BUS, max);
 898         }
 899
 900         sprintf(child->name,
 901                 (is_cardbus ? "PCI CardBus %04x:%02x" : "PCI Bus %04x:%02x"),
 902                 pci_domain_nr(bus), child->number);
 903
 904         /* Has only triggered on CardBus, fixup is in yenta_socket */
 905         while (bus->parent) {
 906                 if ((child->busn_res.end > bus->busn_res.end) ||
 907                     (child->number > bus->busn_res.end) ||
 908                     (child->number < bus->number) ||
 909                     (child->busn_res.end < bus->number)) {
 910                         dev_info(&child->dev, "%pR %s "
 911                                 "hidden behind%s bridge %s %pR\n",
 912                                 &child->busn_res,
 913                                 (bus->number > child->busn_res.end &&
 914                                  bus->busn_res.end < child->number) ?
 915                                         "wholly" : "partially",
 916                                 bus->self->transparent ? " transparent" : "",
 917                                 dev_name(&bus->dev),
 918                                 &bus->busn_res);
 919                 }
 920                 bus = bus->parent;
 921         }
 922
 923 out:
 924         pci_write_config_word(dev, PCI_BRIDGE_CONTROL, bctl);
 925
 926         return max;
 927 }
 928
 929 /*
 930  * Read interrupt line and base address registers.
 931  * The architecture-dependent code can tweak these, of course.
 932  */
 933 static void pci_read_irq(struct pci_dev *dev)
 934 {
 935         unsigned char irq;
 936
 937         pci_read_config_byte(dev, PCI_INTERRUPT_PIN, &irq);
 938         dev->pin = irq;
 939         if (irq)
 940                 pci_read_config_byte(dev, PCI_INTERRUPT_LINE, &irq);
 941         dev->irq = irq;
 942 }
 943
 944 void set_pcie_port_type(struct pci_dev *pdev)
 945 {
 946         int pos;
 947         u16 reg16;
 948
 949         pos = pci_find_capability(pdev, PCI_CAP_ID_EXP);
 950         if (!pos)
 951                 return;
 952         pdev->is_pcie = 1;
 953         pdev->pcie_cap = pos;
 954         pci_read_config_word(pdev, pos + PCI_EXP_FLAGS, &reg16);
 955         pdev->pcie_flags_reg = reg16;
 956         pci_read_config_word(pdev, pos + PCI_EXP_DEVCAP, &reg16);
 957         pdev->pcie_mpss = reg16 & PCI_EXP_DEVCAP_PAYLOAD;
 958 }
 959
 960 void set_pcie_hotplug_bridge(struct pci_dev *pdev)
 961 {
 962         u32 reg32;
 963
 964         pcie_capability_read_dword(pdev, PCI_EXP_SLTCAP, &reg32);
 965         if (reg32 & PCI_EXP_SLTCAP_HPC)
 966                 pdev->is_hotplug_bridge = 1;
 967 }
 968
 969 #define LEGACY_IO_RESOURCE      (IORESOURCE_IO | IORESOURCE_PCI_FIXED)
 970
 971 /**
 972  * pci_setup_device - fill in class and map information of a device
 973  * @dev: the device structure to fill
 974  *
 975  * Initialize the device structure with information about the device's
 976  * vendor,class,memory and IO-space addresses,IRQ lines etc.
 977  * Called at initialisation of the PCI subsystem and by CardBus services.
 978  * Returns 0 on success and negative if unknown type of device (not normal,
 979  * bridge or CardBus).
 980  */
 981 int pci_setup_device(struct pci_dev *dev)
 982 {
 983         u32 class;
 984         u8 hdr_type;
 985         struct pci_slot *slot;
 986         int pos = 0;
 987         struct pci_bus_region region;
 988         struct resource *res;
 989
 990         if (pci_read_config_byte(dev, PCI_HEADER_TYPE, &hdr_type))
 991                 return -EIO;
 992
 993         dev->sysdata = dev->bus->sysdata;
 994         dev->dev.parent = dev->bus->bridge;
 995         dev->dev.bus = &pci_bus_type;
 996         dev->hdr_type = hdr_type & 0x7f;
 997         dev->multifunction = !!(hdr_type & 0x80);
 998         dev->error_state = pci_channel_io_normal;
 999         set_pcie_port_type(dev);
1000
1001         list_for_each_entry(slot, &dev->bus->slots, list)
1002                 if (PCI_SLOT(dev->devfn) == slot->number)
1003                         dev->slot = slot;
1004
1005         /* Assume 32-bit PCI; let 64-bit PCI cards (which are far rarer)
1006            set this higher, assuming the system even supports it.  */
1007         dev->dma_mask = 0xffffffff;
1008
1009         dev_set_name(&dev->dev, "%04x:%02x:%02x.%d", pci_domain_nr(dev->bus),
1010                      dev->bus->number, PCI_SLOT(dev->devfn),
1011                      PCI_FUNC(dev->devfn));
1012
1013         pci_read_config_dword(dev, PCI_CLASS_REVISION, &class);
1014         dev->revision = class & 0xff;
1015         dev->class = class >> 8;                    /* upper 3 bytes */
1016
1017         dev_printk(KERN_DEBUG, &dev->dev, "[%04x:%04x] type %02x class %#08x\n",
1018                    dev->vendor, dev->device, dev->hdr_type, dev->class);
1019
1020         /* need to have dev->class ready */
1021         dev->cfg_size = pci_cfg_space_size(dev);
1022
1023         /* "Unknown power state" */
1024         dev->current_state = PCI_UNKNOWN;
1025
1026         /* Early fixups, before probing the BARs */
1027         pci_fixup_device(pci_fixup_early, dev);
1028         /* device class may be changed after fixup */
1029         class = dev->class >> 8;
1030
1031         switch (dev->hdr_type) {                    /* header type */
1032         case PCI_HEADER_TYPE_NORMAL:                /* standard header */
1033                 if (class == PCI_CLASS_BRIDGE_PCI)
1034                         goto bad;
1035                 pci_read_irq(dev);
1036                 pci_read_bases(dev, 6, PCI_ROM_ADDRESS);
1037                 pci_read_config_word(dev, PCI_SUBSYSTEM_VENDOR_ID, &dev->subsystem_vendor);
1038                 pci_read_config_word(dev, PCI_SUBSYSTEM_ID, &dev->subsystem_device);
1039
1040                 /*
1041                  *      Do the ugly legacy mode stuff here rather than broken chip
1042                  *      quirk code. Legacy mode ATA controllers have fixed
1043                  *      addresses. These are not always echoed in BAR0-3, and
1044                  *      BAR0-3 in a few cases contain junk!
1045                  */
1046                 if (class == PCI_CLASS_STORAGE_IDE) {
1047                         u8 progif;
1048                         pci_read_config_byte(dev, PCI_CLASS_PROG, &progif);
1049                         if ((progif & 1) == 0) {
1050                                 region.start = 0x1F0;
1051                                 region.end = 0x1F7;
1052                                 res = &dev->resource[0];
1053                                 res->flags = LEGACY_IO_RESOURCE;
1054                                 pcibios_bus_to_resource(dev, res, &region);
1055                                 region.start = 0x3F6;
1056                                 region.end = 0x3F6;
1057                                 res = &dev->resource[1];
1058                                 res->flags = LEGACY_IO_RESOURCE;
1059                                 pcibios_bus_to_resource(dev, res, &region);
1060                         }
1061                         if ((progif & 4) == 0) {
1062                                 region.start = 0x170;
1063                                 region.end = 0x177;
1064                                 res = &dev->resource[2];
1065                                 res->flags = LEGACY_IO_RESOURCE;
1066                                 pcibios_bus_to_resource(dev, res, &region);
1067                                 region.start = 0x376;
1068                                 region.end = 0x376;
1069                                 res = &dev->resource[3];
1070                                 res->flags = LEGACY_IO_RESOURCE;
1071                                 pcibios_bus_to_resource(dev, res, &region);
1072                         }
1073                 }
1074                 break;
1075
1076         case PCI_HEADER_TYPE_BRIDGE:                /* bridge header */
1077                 if (class != PCI_CLASS_BRIDGE_PCI)
1078                         goto bad;
1079                 /* The PCI-to-PCI bridge spec requires that subtractive
1080                    decoding (i.e. transparent) bridge must have programming
1081                    interface code of 0x01. */
1082                 pci_read_irq(dev);
1083                 dev->transparent = ((dev->class & 0xff) == 1);
1084                 pci_read_bases(dev, 2, PCI_ROM_ADDRESS1);
1085                 set_pcie_hotplug_bridge(dev);
1086                 pos = pci_find_capability(dev, PCI_CAP_ID_SSVID);
1087                 if (pos) {
1088                         pci_read_config_word(dev, pos + PCI_SSVID_VENDOR_ID, &dev->subsystem_vendor);
1089                         pci_read_config_word(dev, pos + PCI_SSVID_DEVICE_ID, &dev->subsystem_device);
1090                 }
1091                 break;
1092
1093         case PCI_HEADER_TYPE_CARDBUS:               /* CardBus bridge header */
1094                 if (class != PCI_CLASS_BRIDGE_CARDBUS)
1095                         goto bad;
1096                 pci_read_irq(dev);
1097                 pci_read_bases(dev, 1, 0);
1098                 pci_read_config_word(dev, PCI_CB_SUBSYSTEM_VENDOR_ID, &dev->subsystem_vendor);
1099                 pci_read_config_word(dev, PCI_CB_SUBSYSTEM_ID, &dev->subsystem_device);
1100                 break;
1101
1102         default:                                    /* unknown header */
1103                 dev_err(&dev->dev, "unknown header type %02x, "
1104                         "ignoring device\n", dev->hdr_type);
1105                 return -EIO;
1106
1107         bad:
1108                 dev_err(&dev->dev, "ignoring class %#08x (doesn't match header "
1109                         "type %02x)\n", dev->class, dev->hdr_type);
1110                 dev->class = PCI_CLASS_NOT_DEFINED;
1111         }
1112
1113         /* We found a fine healthy device, go go go... */
1114         return 0;
1115 }
1116
1117 static void pci_release_capabilities(struct pci_dev *dev)
1118 {
1119         pci_vpd_release(dev);
1120         pci_iov_release(dev);
1121         pci_free_cap_save_buffers(dev);
1122 }
1123
1124 /**
1125  * pci_release_dev - free a pci device structure when all users of it are finished.
1126  * @dev: device that's been disconnected
1127  *
1128  * Will be called only by the device core when all users of this pci device are
1129  * done.
1130  */
1131 static void pci_release_dev(struct device *dev)
1132 {
1133         struct pci_dev *pci_dev;
1134
1135         pci_dev = to_pci_dev(dev);
1136         pci_release_capabilities(pci_dev);
1137         pci_release_of_node(pci_dev);
1138         kfree(pci_dev);
1139 }
1140
1141 /**
1142  * pci_cfg_space_size - get the configuration space size of the PCI device.
1143  * @dev: PCI device
1144  *
1145  * Regular PCI devices have 256 bytes, but PCI-X 2 and PCI Express devices
1146  * have 4096 bytes.  Even if the device is capable, that doesn't mean we can
1147  * access it.  Maybe we don't have a way to generate extended config space
1148  * accesses, or the device is behind a reverse Express bridge.  So we try
1149  * reading the dword at 0x100 which must either be 0 or a valid extended
1150  * capability header.
1151  */
1152 int pci_cfg_space_size_ext(struct pci_dev *dev)
1153 {
1154         u32 status;
1155         int pos = PCI_CFG_SPACE_SIZE;
1156
1157         if (pci_read_config_dword(dev, pos, &status) != PCIBIOS_SUCCESSFUL)
1158                 goto fail;
1159         if (status == 0xffffffff)
1160                 goto fail;
1161
1162         return PCI_CFG_SPACE_EXP_SIZE;
1163
1164  fail:
1165         return PCI_CFG_SPACE_SIZE;
1166 }
1167
1168 int pci_cfg_space_size(struct pci_dev *dev)
1169 {
1170         int pos;
1171         u32 status;
1172         u16 class;
1173
1174         class = dev->class >> 8;
1175         if (class == PCI_CLASS_BRIDGE_HOST)
1176                 return pci_cfg_space_size_ext(dev);
1177
1178         if (!pci_is_pcie(dev)) {
1179                 pos = pci_find_capability(dev, PCI_CAP_ID_PCIX);
1180                 if (!pos)
1181                         goto fail;
1182
1183                 pci_read_config_dword(dev, pos + PCI_X_STATUS, &status);
1184                 if (!(status & (PCI_X_STATUS_266MHZ | PCI_X_STATUS_533MHZ)))
1185                         goto fail;
1186         }
1187
1188         return pci_cfg_space_size_ext(dev);
1189
1190  fail:
1191         return PCI_CFG_SPACE_SIZE;
1192 }
1193
1194 static void pci_release_bus_bridge_dev(struct device *dev)
1195 {
1196         struct pci_host_bridge *bridge = to_pci_host_bridge(dev);
1197
1198         if (bridge->release_fn)
1199                 bridge->release_fn(bridge);
1200
1201         pci_free_resource_list(&bridge->windows);
1202
1203         kfree(bridge);
1204 }
1205
1206 struct pci_dev *alloc_pci_dev(void)
1207 {
1208         struct pci_dev *dev;
1209
1210         dev = kzalloc(sizeof(struct pci_dev), GFP_KERNEL);
1211         if (!dev)
1212                 return NULL;
1213
1214         INIT_LIST_HEAD(&dev->bus_list);
1215         dev->dev.type = &pci_dev_type;
1216
1217         return dev;
1218 }
1219 EXPORT_SYMBOL(alloc_pci_dev);
1220
1221 bool pci_bus_read_dev_vendor_id(struct pci_bus *bus, int devfn, u32 *l,
1222                                  int crs_timeout)
1223 {
1224         int delay = 1;
1225
1226         if (pci_bus_read_config_dword(bus, devfn, PCI_VENDOR_ID, l))
1227                 return false;
1228
1229         /* some broken boards return 0 or ~0 if a slot is empty: */
1230         if (*l == 0xffffffff || *l == 0x00000000 ||
1231             *l == 0x0000ffff || *l == 0xffff0000)
1232                 return false;
1233
1234         /* Configuration request Retry Status */
1235         while (*l == 0xffff0001) {
1236                 if (!crs_timeout)
1237                         return false;
1238
1239                 msleep(delay);
1240                 delay *= 2;
1241                 if (pci_bus_read_config_dword(bus, devfn, PCI_VENDOR_ID, l))
1242                         return false;
1243                 /* Card hasn't responded in 60 seconds?  Must be stuck. */
1244                 if (delay > crs_timeout) {
1245                         printk(KERN_WARNING "pci %04x:%02x:%02x.%d: not "
1246                                         "responding\n", pci_domain_nr(bus),
1247                                         bus->number, PCI_SLOT(devfn),
1248                                         PCI_FUNC(devfn));
1249                         return false;
1250                 }
1251         }
1252
1253         return true;
1254 }
1255 EXPORT_SYMBOL(pci_bus_read_dev_vendor_id);
1256
1257 /*
1258  * Read the config data for a PCI device, sanity-check it
1259  * and fill in the dev structure...
1260  */
1261 static struct pci_dev *pci_scan_device(struct pci_bus *bus, int devfn)
1262 {
1263         struct pci_dev *dev;
1264         u32 l;
1265
1266         if (!pci_bus_read_dev_vendor_id(bus, devfn, &l, 60*1000))
1267                 return NULL;
1268
1269         dev = alloc_pci_dev();
1270         if (!dev)
1271                 return NULL;
1272
1273         dev->bus = bus;
1274         dev->devfn = devfn;
1275         dev->vendor = l & 0xffff;
1276         dev->device = (l >> 16) & 0xffff;
1277
1278         pci_set_of_node(dev);
1279
1280         if (pci_setup_device(dev)) {
1281                 kfree(dev);
1282                 return NULL;
1283         }
1284
1285         return dev;
1286 }
1287
1288 static void pci_init_capabilities(struct pci_dev *dev)
1289 {
1290         /* MSI/MSI-X list */
1291         pci_msi_init_pci_dev(dev);
1292
1293         /* Buffers for saving PCIe and PCI-X capabilities */
1294         pci_allocate_cap_save_buffers(dev);
1295
1296         /* Power Management */
1297         pci_pm_init(dev);
1298
1299         /* Vital Product Data */
1300         pci_vpd_pci22_init(dev);
1301
1302         /* Alternative Routing-ID Forwarding */
1303         pci_configure_ari(dev);
1304
1305         /* Single Root I/O Virtualization */
1306         pci_iov_init(dev);
1307
1308         /* Enable ACS P2P upstream forwarding */
1309         pci_enable_acs(dev);
1310 }
1311
1312 void pci_device_add(struct pci_dev *dev, struct pci_bus *bus)
1313 {
1314         int ret;
1315
1316         device_initialize(&dev->dev);
1317         dev->dev.release = pci_release_dev;
1318
1319         set_dev_node(&dev->dev, pcibus_to_node(bus));
1320         dev->dev.dma_mask = &dev->dma_mask;
1321         dev->dev.dma_parms = &dev->dma_parms;
1322         dev->dev.coherent_dma_mask = 0xffffffffull;
1323
1324         pci_set_dma_max_seg_size(dev, 65536);
1325         pci_set_dma_seg_boundary(dev, 0xffffffff);
1326
1327         /* Fix up broken headers */
1328         pci_fixup_device(pci_fixup_header, dev);
1329
1330         /* moved out from quirk header fixup code */
1331         pci_reassigndev_resource_alignment(dev);
1332
1333         /* Clear the state_saved flag. */
1334         dev->state_saved = false;
1335
1336         /* Initialize various capabilities */
1337         pci_init_capabilities(dev);
1338
1339         /*
1340          * Add the device to our list of discovered devices
1341          * and the bus list for fixup functions, etc.
1342          */
1343         down_write(&pci_bus_sem);
1344         list_add_tail(&dev->bus_list, &bus->devices);
1345         up_write(&pci_bus_sem);
1346
1347         ret = pcibios_add_device(dev);
1348         WARN_ON(ret < 0);
1349
1350         /* Notifier could use PCI capabilities */
1351         dev->match_driver = false;
1352         ret = device_add(&dev->dev);
1353         WARN_ON(ret < 0);
1354
1355         pci_proc_attach_device(dev);
1356 }
1357
1358 struct pci_dev *__ref pci_scan_single_device(struct pci_bus *bus, int devfn)
1359 {
1360         struct pci_dev *dev;
1361
1362         dev = pci_get_slot(bus, devfn);
1363         if (dev) {
1364                 pci_dev_put(dev);
1365                 return dev;
1366         }
1367
1368         dev = pci_scan_device(bus, devfn);
1369         if (!dev)
1370                 return NULL;
1371
1372         pci_device_add(dev, bus);
1373
1374         return dev;
1375 }
1376 EXPORT_SYMBOL(pci_scan_single_device);
1377
1378 static unsigned next_fn(struct pci_bus *bus, struct pci_dev *dev, unsigned fn)
1379 {
1380         int pos;
1381         u16 cap = 0;
1382         unsigned next_fn;
1383
1384         if (pci_ari_enabled(bus)) {
1385                 if (!dev)
1386                         return 0;
1387                 pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ARI);
1388                 if (!pos)
1389                         return 0;
1390
1391                 pci_read_config_word(dev, pos + PCI_ARI_CAP, &cap);
1392                 next_fn = PCI_ARI_CAP_NFN(cap);
1393                 if (next_fn <= fn)
1394                         return 0;       /* protect against malformed list */
1395
1396                 return next_fn;
1397         }
1398
1399         /* dev may be NULL for non-contiguous multifunction devices */
1400         if (!dev || dev->multifunction)
1401                 return (fn + 1) % 8;
1402
1403         return 0;
1404 }
1405
1406 static int only_one_child(struct pci_bus *bus)
1407 {
1408         struct pci_dev *parent = bus->self;
1409
1410         if (!parent || !pci_is_pcie(parent))
1411                 return 0;
1412         if (pci_pcie_type(parent) == PCI_EXP_TYPE_ROOT_PORT)
1413                 return 1;
1414         if (pci_pcie_type(parent) == PCI_EXP_TYPE_DOWNSTREAM &&
1415             !pci_has_flag(PCI_SCAN_ALL_PCIE_DEVS))
1416                 return 1;
1417         return 0;
1418 }
1419
1420 /**
1421  * pci_scan_slot - scan a PCI slot on a bus for devices.
1422  * @bus: PCI bus to scan
1423  * @devfn: slot number to scan (must have zero function.)
1424  *
1425  * Scan a PCI slot on the specified PCI bus for devices, adding
1426  * discovered devices to the @bus->devices list.  New devices
1427  * will not have is_added set.
1428  *
1429  * Returns the number of new devices found.
1430  */
1431 int pci_scan_slot(struct pci_bus *bus, int devfn)
1432 {
1433         unsigned fn, nr = 0;
1434         struct pci_dev *dev;
1435
1436         if (only_one_child(bus) && (devfn > 0))
1437                 return 0; /* Already scanned the entire slot */
1438
1439         dev = pci_scan_single_device(bus, devfn);
1440         if (!dev)
1441                 return 0;
1442         if (!dev->is_added)
1443                 nr++;
1444
1445         for (fn = next_fn(bus, dev, 0); fn > 0; fn = next_fn(bus, dev, fn)) {
1446                 dev = pci_scan_single_device(bus, devfn + fn);
1447                 if (dev) {
1448                         if (!dev->is_added)
1449                                 nr++;
1450                         dev->multifunction = 1;
1451                 }
1452         }
1453
1454         /* only one slot has pcie device */
1455         if (bus->self && nr)
1456                 pcie_aspm_init_link_state(bus->self);
1457
1458         return nr;
1459 }
1460
1461 static int pcie_find_smpss(struct pci_dev *dev, void *data)
1462 {
1463         u8 *smpss = data;
1464
1465         if (!pci_is_pcie(dev))
1466                 return 0;
1467
1468         /* For PCIE hotplug enabled slots not connected directly to a
1469          * PCI-E root port, there can be problems when hotplugging
1470          * devices.  This is due to the possibility of hotplugging a
1471          * device into the fabric with a smaller MPS that the devices
1472          * currently running have configured.  Modifying the MPS on the
1473          * running devices could cause a fatal bus error due to an
1474          * incoming frame being larger than the newly configured MPS.
1475          * To work around this, the MPS for the entire fabric must be
1476          * set to the minimum size.  Any devices hotplugged into this
1477          * fabric will have the minimum MPS set.  If the PCI hotplug
1478          * slot is directly connected to the root port and there are not
1479          * other devices on the fabric (which seems to be the most
1480          * common case), then this is not an issue and MPS discovery
1481          * will occur as normal.
1482          */
1483         if (dev->is_hotplug_bridge && (!list_is_singular(&dev->bus->devices) ||
1484              (dev->bus->self &&
1485               pci_pcie_type(dev->bus->self) != PCI_EXP_TYPE_ROOT_PORT)))
1486                 *smpss = 0;
1487
1488         if (*smpss > dev->pcie_mpss)
1489                 *smpss = dev->pcie_mpss;
1490
1491         return 0;
1492 }
1493
1494 static void pcie_write_mps(struct pci_dev *dev, int mps)
1495 {
1496         int rc;
1497
1498         if (pcie_bus_config == PCIE_BUS_PERFORMANCE) {
1499                 mps = 128 << dev->pcie_mpss;
1500
1501                 if (pci_pcie_type(dev) != PCI_EXP_TYPE_ROOT_PORT &&
1502                     dev->bus->self)
1503                         /* For "Performance", the assumption is made that
1504                          * downstream communication will never be larger than
1505                          * the MRRS.  So, the MPS only needs to be configured
1506                          * for the upstream communication.  This being the case,
1507                          * walk from the top down and set the MPS of the child
1508                          * to that of the parent bus.
1509                          *
1510                          * Configure the device MPS with the smaller of the
1511                          * device MPSS or the bridge MPS (which is assumed to be
1512                          * properly configured at this point to the largest
1513                          * allowable MPS based on its parent bus).
1514                          */
1515                         mps = min(mps, pcie_get_mps(dev->bus->self));
1516         }
1517
1518         rc = pcie_set_mps(dev, mps);
1519         if (rc)
1520                 dev_err(&dev->dev, "Failed attempting to set the MPS\n");
1521 }
1522
1523 static void pcie_write_mrrs(struct pci_dev *dev)
1524 {
1525         int rc, mrrs;
1526
1527         /* In the "safe" case, do not configure the MRRS.  There appear to be
1528          * issues with setting MRRS to 0 on a number of devices.
1529          */
1530         if (pcie_bus_config != PCIE_BUS_PERFORMANCE)
1531                 return;
1532
1533         /* For Max performance, the MRRS must be set to the largest supported
1534          * value.  However, it cannot be configured larger than the MPS the
1535          * device or the bus can support.  This should already be properly
1536          * configured by a prior call to pcie_write_mps.
1537          */
1538         mrrs = pcie_get_mps(dev);
1539
1540         /* MRRS is a R/W register.  Invalid values can be written, but a
1541          * subsequent read will verify if the value is acceptable or not.
1542          * If the MRRS value provided is not acceptable (e.g., too large),
1543          * shrink the value until it is acceptable to the HW.
1544          */
1545         while (mrrs != pcie_get_readrq(dev) && mrrs >= 128) {
1546                 rc = pcie_set_readrq(dev, mrrs);
1547                 if (!rc)
1548                         break;
1549
1550                 dev_warn(&dev->dev, "Failed attempting to set the MRRS\n");
1551                 mrrs /= 2;
1552         }
1553
1554         if (mrrs < 128)
1555                 dev_err(&dev->dev, "MRRS was unable to be configured with a "
1556                         "safe value.  If problems are experienced, try running "
1557                         "with pci=pcie_bus_safe.\n");
1558 }
1559
1560 static int pcie_bus_configure_set(struct pci_dev *dev, void *data)
1561 {
1562         int mps, orig_mps;
1563
1564         if (!pci_is_pcie(dev))
1565                 return 0;
1566
1567         mps = 128 << *(u8 *)data;
1568         orig_mps = pcie_get_mps(dev);
1569
1570         pcie_write_mps(dev, mps);
1571         pcie_write_mrrs(dev);
1572
1573         dev_info(&dev->dev, "PCI-E Max Payload Size set to %4d/%4d (was %4d), "
1574                  "Max Read Rq %4d\n", pcie_get_mps(dev), 128 << dev->pcie_mpss,
1575                  orig_mps, pcie_get_readrq(dev));
1576
1577         return 0;
1578 }
1579
1580 /* pcie_bus_configure_settings requires that pci_walk_bus work in a top-down,
1581  * parents then children fashion.  If this changes, then this code will not
1582  * work as designed.
1583  */
1584 void pcie_bus_configure_settings(struct pci_bus *bus, u8 mpss)
1585 {
1586         u8 smpss;
1587
1588         if (!pci_is_pcie(bus->self))
1589                 return;
1590
1591         if (pcie_bus_config == PCIE_BUS_TUNE_OFF)
1592                 return;
1593
1594         /* FIXME - Peer to peer DMA is possible, though the endpoint would need
1595          * to be aware to the MPS of the destination.  To work around this,
1596          * simply force the MPS of the entire system to the smallest possible.
1597          */
1598         if (pcie_bus_config == PCIE_BUS_PEER2PEER)
1599                 smpss = 0;
1600
1601         if (pcie_bus_config == PCIE_BUS_SAFE) {
1602                 smpss = mpss;
1603
1604                 pcie_find_smpss(bus->self, &smpss);
1605                 pci_walk_bus(bus, pcie_find_smpss, &smpss);
1606         }
1607
1608         pcie_bus_configure_set(bus->self, &smpss);
1609         pci_walk_bus(bus, pcie_bus_configure_set, &smpss);
1610 }
1611 EXPORT_SYMBOL_GPL(pcie_bus_configure_settings);
1612
1613 unsigned int pci_scan_child_bus(struct pci_bus *bus)
1614 {
1615         unsigned int devfn, pass, max = bus->busn_res.start;
1616         struct pci_dev *dev;
1617
1618         dev_dbg(&bus->dev, "scanning bus\n");
1619
1620         /* Go find them, Rover! */
1621         for (devfn = 0; devfn < 0x100; devfn += 8)
1622                 pci_scan_slot(bus, devfn);
1623
1624         /* Reserve buses for SR-IOV capability. */
1625         max += pci_iov_bus_range(bus);
1626
1627         /*
1628          * After performing arch-dependent fixup of the bus, look behind
1629          * all PCI-to-PCI bridges on this bus.
1630          */
1631         if (!bus->is_added) {
1632                 dev_dbg(&bus->dev, "fixups for bus\n");
1633                 pcibios_fixup_bus(bus);
1634                 bus->is_added = 1;
1635         }
1636
1637         for (pass=0; pass < 2; pass++)
1638                 list_for_each_entry(dev, &bus->devices, bus_list) {
1639                         if (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE ||
1640                             dev->hdr_type == PCI_HEADER_TYPE_CARDBUS)
1641                                 max = pci_scan_bridge(bus, dev, max, pass);
1642                 }
1643
1644         /*
1645          * We've scanned the bus and so we know all about what's on
1646          * the other side of any bridges that may be on this bus plus
1647          * any devices.
1648          *
1649          * Return how far we've got finding sub-buses.
1650          */
1651         dev_dbg(&bus->dev, "bus scan returning with max=%02x\n", max);
1652         return max;
1653 }
1654
1655 /**
1656  * pcibios_root_bridge_prepare - Platform-specific host bridge setup.
1657  * @bridge: Host bridge to set up.
1658  *
1659  * Default empty implementation.  Replace with an architecture-specific setup
1660  * routine, if necessary.
1661  */
1662 int __weak pcibios_root_bridge_prepare(struct pci_host_bridge *bridge)
1663 {
1664         return 0;
1665 }
1666
1667 void __weak pcibios_add_bus(struct pci_bus *bus)
1668 {
1669 }
1670
1671 void __weak pcibios_remove_bus(struct pci_bus *bus)
1672 {
1673 }
1674
1675 struct pci_bus *pci_create_root_bus(struct device *parent, int bus,
1676                 struct pci_ops *ops, void *sysdata, struct list_head *resources)
1677 {
1678         int error;
1679         struct pci_host_bridge *bridge;
1680         struct pci_bus *b, *b2;
1681         struct pci_host_bridge_window *window, *n;
1682         struct resource *res;
1683         resource_size_t offset;
1684         char bus_addr[64];
1685         char *fmt;
1686
1687         b = pci_alloc_bus();
1688         if (!b)
1689                 return NULL;
1690
1691         b->sysdata = sysdata;
1692         b->ops = ops;
1693         b->number = b->busn_res.start = bus;
1694         b2 = pci_find_bus(pci_domain_nr(b), bus);
1695         if (b2) {
1696                 /* If we already got to this bus through a different bridge, ignore it */
1697                 dev_dbg(&b2->dev, "bus already known\n");
1698                 goto err_out;
1699         }
1700
1701         bridge = pci_alloc_host_bridge(b);
1702         if (!bridge)
1703                 goto err_out;
1704
1705         bridge->dev.parent = parent;
1706         bridge->dev.release = pci_release_bus_bridge_dev;
1707         dev_set_name(&bridge->dev, "pci%04x:%02x", pci_domain_nr(b), bus);
1708         error = pcibios_root_bridge_prepare(bridge);
1709         if (error) {
1710                 kfree(bridge);
1711                 goto err_out;
1712         }
1713
1714         error = device_register(&bridge->dev);
1715         if (error) {
1716                 put_device(&bridge->dev);
1717                 goto err_out;
1718         }
1719         b->bridge = get_device(&bridge->dev);
1720         device_enable_async_suspend(b->bridge);
1721         pci_set_bus_of_node(b);
1722
1723         if (!parent)
1724                 set_dev_node(b->bridge, pcibus_to_node(b));
1725
1726         b->dev.class = &pcibus_class;
1727         b->dev.parent = b->bridge;
1728         dev_set_name(&b->dev, "%04x:%02x", pci_domain_nr(b), bus);
1729         error = device_register(&b->dev);
1730         if (error)
1731                 goto class_dev_reg_err;
1732
1733         pcibios_add_bus(b);
1734
1735         /* Create legacy_io and legacy_mem files for this bus */
1736         pci_create_legacy_files(b);
1737
1738         if (parent)
1739                 dev_info(parent, "PCI host bridge to bus %s\n", dev_name(&b->dev));
1740         else
1741                 printk(KERN_INFO "PCI host bridge to bus %s\n", dev_name(&b->dev));
1742
1743         /* Add initial resources to the bus */
1744         list_for_each_entry_safe(window, n, resources, list) {
1745                 list_move_tail(&window->list, &bridge->windows);
1746                 res = window->res;
1747                 offset = window->offset;
1748                 if (res->flags & IORESOURCE_BUS)
1749                         pci_bus_insert_busn_res(b, bus, res->end);
1750                 else
1751                         pci_bus_add_resource(b, res, 0);
1752                 if (offset) {
1753                         if (resource_type(res) == IORESOURCE_IO)
1754                                 fmt = " (bus address [%#06llx-%#06llx])";
1755                         else
1756                                 fmt = " (bus address [%#010llx-%#010llx])";
1757                         snprintf(bus_addr, sizeof(bus_addr), fmt,
1758                                  (unsigned long long) (res->start - offset),
1759                                  (unsigned long long) (res->end - offset));
1760                 } else
1761                         bus_addr[0] = '\0';
1762                 dev_info(&b->dev, "root bus resource %pR%s\n", res, bus_addr);
1763         }
1764
1765         down_write(&pci_bus_sem);
1766         list_add_tail(&b->node, &pci_root_buses);
1767         up_write(&pci_bus_sem);
1768
1769         return b;
1770
1771 class_dev_reg_err:
1772         put_device(&bridge->dev);
1773         device_unregister(&bridge->dev);
1774 err_out:
1775         kfree(b);
1776         return NULL;
1777 }
1778
1779 int pci_bus_insert_busn_res(struct pci_bus *b, int bus, int bus_max)
1780 {
1781         struct resource *res = &b->busn_res;
1782         struct resource *parent_res, *conflict;
1783
1784         res->start = bus;
1785         res->end = bus_max;
1786         res->flags = IORESOURCE_BUS;
1787
1788         if (!pci_is_root_bus(b))
1789                 parent_res = &b->parent->busn_res;
1790         else {
1791                 parent_res = get_pci_domain_busn_res(pci_domain_nr(b));
1792                 res->flags |= IORESOURCE_PCI_FIXED;
1793         }
1794
1795         conflict = insert_resource_conflict(parent_res, res);
1796
1797         if (conflict)
1798                 dev_printk(KERN_DEBUG, &b->dev,
1799                            "busn_res: can not insert %pR under %s%pR (conflicts with %s %pR)\n",
1800                             res, pci_is_root_bus(b) ? "domain " : "",
1801                             parent_res, conflict->name, conflict);
1802
1803         return conflict == NULL;
1804 }
1805
1806 int pci_bus_update_busn_res_end(struct pci_bus *b, int bus_max)
1807 {
1808         struct resource *res = &b->busn_res;
1809         struct resource old_res = *res;
1810         resource_size_t size;
1811         int ret;
1812
1813         if (res->start > bus_max)
1814                 return -EINVAL;
1815
1816         size = bus_max - res->start + 1;
1817         ret = adjust_resource(res, res->start, size);
1818         dev_printk(KERN_DEBUG, &b->dev,
1819                         "busn_res: %pR end %s updated to %02x\n",
1820                         &old_res, ret ? "can not be" : "is", bus_max);
1821
1822         if (!ret && !res->parent)
1823                 pci_bus_insert_busn_res(b, res->start, res->end);
1824
1825         return ret;
1826 }
1827
1828 void pci_bus_release_busn_res(struct pci_bus *b)
1829 {
1830         struct resource *res = &b->busn_res;
1831         int ret;
1832
1833         if (!res->flags || !res->parent)
1834                 return;
1835
1836         ret = release_resource(res);
1837         dev_printk(KERN_DEBUG, &b->dev,
1838                         "busn_res: %pR %s released\n",
1839                         res, ret ? "can not be" : "is");
1840 }
1841
1842 struct pci_bus *pci_scan_root_bus(struct device *parent, int bus,
1843                 struct pci_ops *ops, void *sysdata, struct list_head *resources)
1844 {
1845         struct pci_host_bridge_window *window;
1846         bool found = false;
1847         struct pci_bus *b;
1848         int max;
1849
1850         list_for_each_entry(window, resources, list)
1851                 if (window->res->flags & IORESOURCE_BUS) {
1852                         found = true;
1853                         break;
1854                 }
1855
1856         b = pci_create_root_bus(parent, bus, ops, sysdata, resources);
1857         if (!b)
1858                 return NULL;
1859
1860         if (!found) {
1861                 dev_info(&b->dev,
1862                  "No busn resource found for root bus, will use [bus %02x-ff]\n",
1863                         bus);
1864                 pci_bus_insert_busn_res(b, bus, 255);
1865         }
1866
1867         max = pci_scan_child_bus(b);
1868
1869         if (!found)
1870                 pci_bus_update_busn_res_end(b, max);
1871
1872         pci_bus_add_devices(b);
1873         return b;
1874 }
1875 EXPORT_SYMBOL(pci_scan_root_bus);
1876
1877 /* Deprecated; use pci_scan_root_bus() instead */
1878 struct pci_bus *pci_scan_bus_parented(struct device *parent,
1879                 int bus, struct pci_ops *ops, void *sysdata)
1880 {
1881         LIST_HEAD(resources);
1882         struct pci_bus *b;
1883
1884         pci_add_resource(&resources, &ioport_resource);
1885         pci_add_resource(&resources, &iomem_resource);
1886         pci_add_resource(&resources, &busn_resource);
1887         b = pci_create_root_bus(parent, bus, ops, sysdata, &resources);
1888         if (b)
1889                 pci_scan_child_bus(b);
1890         else
1891                 pci_free_resource_list(&resources);
1892         return b;
1893 }
1894 EXPORT_SYMBOL(pci_scan_bus_parented);
1895
1896 struct pci_bus *pci_scan_bus(int bus, struct pci_ops *ops,
1897                                         void *sysdata)
1898 {
1899         LIST_HEAD(resources);
1900         struct pci_bus *b;
1901
1902         pci_add_resource(&resources, &ioport_resource);
1903         pci_add_resource(&resources, &iomem_resource);
1904         pci_add_resource(&resources, &busn_resource);
1905         b = pci_create_root_bus(NULL, bus, ops, sysdata, &resources);
1906         if (b) {
1907                 pci_scan_child_bus(b);
1908                 pci_bus_add_devices(b);
1909         } else {
1910                 pci_free_resource_list(&resources);
1911         }
1912         return b;
1913 }
1914 EXPORT_SYMBOL(pci_scan_bus);
1915
1916 /**
1917  * pci_rescan_bus_bridge_resize - scan a PCI bus for devices.
1918  * @bridge: PCI bridge for the bus to scan
1919  *
1920  * Scan a PCI bus and child buses for new devices, add them,
1921  * and enable them, resizing bridge mmio/io resource if necessary
1922  * and possible.  The caller must ensure the child devices are already
1923  * removed for resizing to occur.
1924  *
1925  * Returns the max number of subordinate bus discovered.
1926  */
1927 unsigned int __ref pci_rescan_bus_bridge_resize(struct pci_dev *bridge)
1928 {
1929         unsigned int max;
1930         struct pci_bus *bus = bridge->subordinate;
1931
1932         max = pci_scan_child_bus(bus);
1933
1934         pci_assign_unassigned_bridge_resources(bridge);
1935
1936         pci_bus_add_devices(bus);
1937
1938         return max;
1939 }
1940
1941 /**
1942  * pci_rescan_bus - scan a PCI bus for devices.
1943  * @bus: PCI bus to scan
1944  *
1945  * Scan a PCI bus and child buses for new devices, adds them,
1946  * and enables them.
1947  *
1948  * Returns the max number of subordinate bus discovered.
1949  */
1950 unsigned int __ref pci_rescan_bus(struct pci_bus *bus)
1951 {
1952         unsigned int max;
1953
1954         max = pci_scan_child_bus(bus);
1955         pci_assign_unassigned_bus_resources(bus);
1956         pci_enable_bridges(bus);
1957         pci_bus_add_devices(bus);
1958
1959         return max;
1960 }
1961 EXPORT_SYMBOL_GPL(pci_rescan_bus);
1962
1963 EXPORT_SYMBOL(pci_add_new_bus);
1964 EXPORT_SYMBOL(pci_scan_slot);
1965 EXPORT_SYMBOL(pci_scan_bridge);
1966 EXPORT_SYMBOL_GPL(pci_scan_child_bus);
1967
1968 static int __init pci_sort_bf_cmp(const struct device *d_a, const struct device *d_b)
1969 {
1970         const struct pci_dev *a = to_pci_dev(d_a);
1971         const struct pci_dev *b = to_pci_dev(d_b);
1972
1973         if      (pci_domain_nr(a->bus) < pci_domain_nr(b->bus)) return -1;
1974         else if (pci_domain_nr(a->bus) > pci_domain_nr(b->bus)) return  1;
1975
1976         if      (a->bus->number < b->bus->number) return -1;
1977         else if (a->bus->number > b->bus->number) return  1;
1978
1979         if      (a->devfn < b->devfn) return -1;
1980         else if (a->devfn > b->devfn) return  1;
1981
1982         return 0;
1983 }
1984
1985 void __init pci_sort_breadthfirst(void)
1986 {
1987         bus_sort_breadthfirst(&pci_bus_type, &pci_sort_bf_cmp);
1988 }