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->msi = parent->msi;
 641         child->sysdata = parent->sysdata;
 642         child->bus_flags = parent->bus_flags;
 643
 644         /* initialize some portions of the bus device, but don't register it
 645          * now as the parent is not properly set up yet.
 646          */
 647         child->dev.class = &pcibus_class;
 648         dev_set_name(&child->dev, "%04x:%02x", pci_domain_nr(child), busnr);
 649
 650         /*
 651          * Set up the primary, secondary and subordinate
 652          * bus numbers.
 653          */
 654         child->number = child->busn_res.start = busnr;
 655         child->primary = parent->busn_res.start;
 656         child->busn_res.end = 0xff;
 657
 658         if (!bridge) {
 659                 child->dev.parent = parent->bridge;
 660                 goto add_dev;
 661         }
 662
 663         child->self = bridge;
 664         child->bridge = get_device(&bridge->dev);
 665         child->dev.parent = child->bridge;
 666         pci_set_bus_of_node(child);
 667         pci_set_bus_speed(child);
 668
 669         /* Set up default resource pointers and names.. */
 670         for (i = 0; i < PCI_BRIDGE_RESOURCE_NUM; i++) {
 671                 child->resource[i] = &bridge->resource[PCI_BRIDGE_RESOURCES+i];
 672                 child->resource[i]->name = child->name;
 673         }
 674         bridge->subordinate = child;
 675
 676 add_dev:
 677         ret = device_register(&child->dev);
 678         WARN_ON(ret < 0);
 679
 680         pcibios_add_bus(child);
 681
 682         /* Create legacy_io and legacy_mem files for this bus */
 683         pci_create_legacy_files(child);
 684
 685         return child;
 686 }
 687
 688 struct pci_bus *__ref pci_add_new_bus(struct pci_bus *parent, struct pci_dev *dev, int busnr)
 689 {
 690         struct pci_bus *child;
 691
 692         child = pci_alloc_child_bus(parent, dev, busnr);
 693         if (child) {
 694                 down_write(&pci_bus_sem);
 695                 list_add_tail(&child->node, &parent->children);
 696                 up_write(&pci_bus_sem);
 697         }
 698         return child;
 699 }
 700
 701 static void pci_fixup_parent_subordinate_busnr(struct pci_bus *child, int max)
 702 {
 703         struct pci_bus *parent = child->parent;
 704
 705         /* Attempts to fix that up are really dangerous unless
 706            we're going to re-assign all bus numbers. */
 707         if (!pcibios_assign_all_busses())
 708                 return;
 709
 710         while (parent->parent && parent->busn_res.end < max) {
 711                 parent->busn_res.end = max;
 712                 pci_write_config_byte(parent->self, PCI_SUBORDINATE_BUS, max);
 713                 parent = parent->parent;
 714         }
 715 }
 716
 717 /*
 718  * If it's a bridge, configure it and scan the bus behind it.
 719  * For CardBus bridges, we don't scan behind as the devices will
 720  * be handled by the bridge driver itself.
 721  *
 722  * We need to process bridges in two passes -- first we scan those
 723  * already configured by the BIOS and after we are done with all of
 724  * them, we proceed to assigning numbers to the remaining buses in
 725  * order to avoid overlaps between old and new bus numbers.
 726  */
 727 int pci_scan_bridge(struct pci_bus *bus, struct pci_dev *dev, int max, int pass)
 728 {
 729         struct pci_bus *child;
 730         int is_cardbus = (dev->hdr_type == PCI_HEADER_TYPE_CARDBUS);
 731         u32 buses, i, j = 0;
 732         u16 bctl;
 733         u8 primary, secondary, subordinate;
 734         int broken = 0;
 735
 736         pci_read_config_dword(dev, PCI_PRIMARY_BUS, &buses);
 737         primary = buses & 0xFF;
 738         secondary = (buses >> 8) & 0xFF;
 739         subordinate = (buses >> 16) & 0xFF;
 740
 741         dev_dbg(&dev->dev, "scanning [bus %02x-%02x] behind bridge, pass %d\n",
 742                 secondary, subordinate, pass);
 743
 744         if (!primary && (primary != bus->number) && secondary && subordinate) {
 745                 dev_warn(&dev->dev, "Primary bus is hard wired to 0\n");
 746                 primary = bus->number;
 747         }
 748
 749         /* Check if setup is sensible at all */
 750         if (!pass &&
 751             (primary != bus->number || secondary <= bus->number ||
 752              secondary > subordinate)) {
 753                 dev_info(&dev->dev, "bridge configuration invalid ([bus %02x-%02x]), reconfiguring\n",
 754                          secondary, subordinate);
 755                 broken = 1;
 756         }
 757
 758         /* Disable MasterAbortMode during probing to avoid reporting
 759            of bus errors (in some architectures) */
 760         pci_read_config_word(dev, PCI_BRIDGE_CONTROL, &bctl);
 761         pci_write_config_word(dev, PCI_BRIDGE_CONTROL,
 762                               bctl & ~PCI_BRIDGE_CTL_MASTER_ABORT);
 763
 764         if ((secondary || subordinate) && !pcibios_assign_all_busses() &&
 765             !is_cardbus && !broken) {
 766                 unsigned int cmax;
 767                 /*
 768                  * Bus already configured by firmware, process it in the first
 769                  * pass and just note the configuration.
 770                  */
 771                 if (pass)
 772                         goto out;
 773
 774                 /*
 775                  * If we already got to this bus through a different bridge,
 776                  * don't re-add it. This can happen with the i450NX chipset.
 777                  *
 778                  * However, we continue to descend down the hierarchy and
 779                  * scan remaining child buses.
 780                  */
 781                 child = pci_find_bus(pci_domain_nr(bus), secondary);
 782                 if (!child) {
 783                         child = pci_add_new_bus(bus, dev, secondary);
 784                         if (!child)
 785                                 goto out;
 786                         child->primary = primary;
 787                         pci_bus_insert_busn_res(child, secondary, subordinate);
 788                         child->bridge_ctl = bctl;
 789                 }
 790
 791                 cmax = pci_scan_child_bus(child);
 792                 if (cmax > max)
 793                         max = cmax;
 794                 if (child->busn_res.end > max)
 795                         max = child->busn_res.end;
 796         } else {
 797                 /*
 798                  * We need to assign a number to this bus which we always
 799                  * do in the second pass.
 800                  */
 801                 if (!pass) {
 802                         if (pcibios_assign_all_busses() || broken)
 803                                 /* Temporarily disable forwarding of the
 804                                    configuration cycles on all bridges in
 805                                    this bus segment to avoid possible
 806                                    conflicts in the second pass between two
 807                                    bridges programmed with overlapping
 808                                    bus ranges. */
 809                                 pci_write_config_dword(dev, PCI_PRIMARY_BUS,
 810                                                        buses & ~0xffffff);
 811                         goto out;
 812                 }
 813
 814                 /* Clear errors */
 815                 pci_write_config_word(dev, PCI_STATUS, 0xffff);
 816
 817                 /* Prevent assigning a bus number that already exists.
 818                  * This can happen when a bridge is hot-plugged, so in
 819                  * this case we only re-scan this bus. */
 820                 child = pci_find_bus(pci_domain_nr(bus), max+1);
 821                 if (!child) {
 822                         child = pci_add_new_bus(bus, dev, ++max);
 823                         if (!child)
 824                                 goto out;
 825                         pci_bus_insert_busn_res(child, max, 0xff);
 826                 }
 827                 buses = (buses & 0xff000000)
 828                       | ((unsigned int)(child->primary)     <<  0)
 829                       | ((unsigned int)(child->busn_res.start)   <<  8)
 830                       | ((unsigned int)(child->busn_res.end) << 16);
 831
 832                 /*
 833                  * yenta.c forces a secondary latency timer of 176.
 834                  * Copy that behaviour here.
 835                  */
 836                 if (is_cardbus) {
 837                         buses &= ~0xff000000;
 838                         buses |= CARDBUS_LATENCY_TIMER << 24;
 839                 }
 840
 841                 /*
 842                  * We need to blast all three values with a single write.
 843                  */
 844                 pci_write_config_dword(dev, PCI_PRIMARY_BUS, buses);
 845
 846                 if (!is_cardbus) {
 847                         child->bridge_ctl = bctl;
 848                         /*
 849                          * Adjust subordinate busnr in parent buses.
 850                          * We do this before scanning for children because
 851                          * some devices may not be detected if the bios
 852                          * was lazy.
 853                          */
 854                         pci_fixup_parent_subordinate_busnr(child, max);
 855                         /* Now we can scan all subordinate buses... */
 856                         max = pci_scan_child_bus(child);
 857                         /*
 858                          * now fix it up again since we have found
 859                          * the real value of max.
 860                          */
 861                         pci_fixup_parent_subordinate_busnr(child, max);
 862                 } else {
 863                         /*
 864                          * For CardBus bridges, we leave 4 bus numbers
 865                          * as cards with a PCI-to-PCI bridge can be
 866                          * inserted later.
 867                          */
 868                         for (i=0; i<CARDBUS_RESERVE_BUSNR; i++) {
 869                                 struct pci_bus *parent = bus;
 870                                 if (pci_find_bus(pci_domain_nr(bus),
 871                                                         max+i+1))
 872                                         break;
 873                                 while (parent->parent) {
 874                                         if ((!pcibios_assign_all_busses()) &&
 875                                             (parent->busn_res.end > max) &&
 876                                             (parent->busn_res.end <= max+i)) {
 877                                                 j = 1;
 878                                         }
 879                                         parent = parent->parent;
 880                                 }
 881                                 if (j) {
 882                                         /*
 883                                          * Often, there are two cardbus bridges
 884                                          * -- try to leave one valid bus number
 885                                          * for each one.
 886                                          */
 887                                         i /= 2;
 888                                         break;
 889                                 }
 890                         }
 891                         max += i;
 892                         pci_fixup_parent_subordinate_busnr(child, max);
 893                 }
 894                 /*
 895                  * Set the subordinate bus number to its real value.
 896                  */
 897                 pci_bus_update_busn_res_end(child, max);
 898                 pci_write_config_byte(dev, PCI_SUBORDINATE_BUS, max);
 899         }
 900
 901         sprintf(child->name,
 902                 (is_cardbus ? "PCI CardBus %04x:%02x" : "PCI Bus %04x:%02x"),
 903                 pci_domain_nr(bus), child->number);
 904
 905         /* Has only triggered on CardBus, fixup is in yenta_socket */
 906         while (bus->parent) {
 907                 if ((child->busn_res.end > bus->busn_res.end) ||
 908                     (child->number > bus->busn_res.end) ||
 909                     (child->number < bus->number) ||
 910                     (child->busn_res.end < bus->number)) {
 911                         dev_info(&child->dev, "%pR %s "
 912                                 "hidden behind%s bridge %s %pR\n",
 913                                 &child->busn_res,
 914                                 (bus->number > child->busn_res.end &&
 915                                  bus->busn_res.end < child->number) ?
 916                                         "wholly" : "partially",
 917                                 bus->self->transparent ? " transparent" : "",
 918                                 dev_name(&bus->dev),
 919                                 &bus->busn_res);
 920                 }
 921                 bus = bus->parent;
 922         }
 923
 924 out:
 925         pci_write_config_word(dev, PCI_BRIDGE_CONTROL, bctl);
 926
 927         return max;
 928 }
 929
 930 /*
 931  * Read interrupt line and base address registers.
 932  * The architecture-dependent code can tweak these, of course.
 933  */
 934 static void pci_read_irq(struct pci_dev *dev)
 935 {
 936         unsigned char irq;
 937
 938         pci_read_config_byte(dev, PCI_INTERRUPT_PIN, &irq);
 939         dev->pin = irq;
 940         if (irq)
 941                 pci_read_config_byte(dev, PCI_INTERRUPT_LINE, &irq);
 942         dev->irq = irq;
 943 }
 944
 945 void set_pcie_port_type(struct pci_dev *pdev)
 946 {
 947         int pos;
 948         u16 reg16;
 949
 950         pos = pci_find_capability(pdev, PCI_CAP_ID_EXP);
 951         if (!pos)
 952                 return;
 953         pdev->is_pcie = 1;
 954         pdev->pcie_cap = pos;
 955         pci_read_config_word(pdev, pos + PCI_EXP_FLAGS, &reg16);
 956         pdev->pcie_flags_reg = reg16;
 957         pci_read_config_word(pdev, pos + PCI_EXP_DEVCAP, &reg16);
 958         pdev->pcie_mpss = reg16 & PCI_EXP_DEVCAP_PAYLOAD;
 959 }
 960
 961 void set_pcie_hotplug_bridge(struct pci_dev *pdev)
 962 {
 963         u32 reg32;
 964
 965         pcie_capability_read_dword(pdev, PCI_EXP_SLTCAP, &reg32);
 966         if (reg32 & PCI_EXP_SLTCAP_HPC)
 967                 pdev->is_hotplug_bridge = 1;
 968 }
 969
 970 #define LEGACY_IO_RESOURCE      (IORESOURCE_IO | IORESOURCE_PCI_FIXED)
 971
 972 /**
 973  * pci_setup_device - fill in class and map information of a device
 974  * @dev: the device structure to fill
 975  *
 976  * Initialize the device structure with information about the device's
 977  * vendor,class,memory and IO-space addresses,IRQ lines etc.
 978  * Called at initialisation of the PCI subsystem and by CardBus services.
 979  * Returns 0 on success and negative if unknown type of device (not normal,
 980  * bridge or CardBus).
 981  */
 982 int pci_setup_device(struct pci_dev *dev)
 983 {
 984         u32 class;
 985         u8 hdr_type;
 986         struct pci_slot *slot;
 987         int pos = 0;
 988         struct pci_bus_region region;
 989         struct resource *res;
 990
 991         if (pci_read_config_byte(dev, PCI_HEADER_TYPE, &hdr_type))
 992                 return -EIO;
 993
 994         dev->sysdata = dev->bus->sysdata;
 995         dev->dev.parent = dev->bus->bridge;
 996         dev->dev.bus = &pci_bus_type;
 997         dev->hdr_type = hdr_type & 0x7f;
 998         dev->multifunction = !!(hdr_type & 0x80);
 999         dev->error_state = pci_channel_io_normal;
1000         set_pcie_port_type(dev);
1001
1002         list_for_each_entry(slot, &dev->bus->slots, list)
1003                 if (PCI_SLOT(dev->devfn) == slot->number)
1004                         dev->slot = slot;
1005
1006         /* Assume 32-bit PCI; let 64-bit PCI cards (which are far rarer)
1007            set this higher, assuming the system even supports it.  */
1008         dev->dma_mask = 0xffffffff;
1009
1010         dev_set_name(&dev->dev, "%04x:%02x:%02x.%d", pci_domain_nr(dev->bus),
1011                      dev->bus->number, PCI_SLOT(dev->devfn),
1012                      PCI_FUNC(dev->devfn));
1013
1014         pci_read_config_dword(dev, PCI_CLASS_REVISION, &class);
1015         dev->revision = class & 0xff;
1016         dev->class = class >> 8;                    /* upper 3 bytes */
1017
1018         dev_printk(KERN_DEBUG, &dev->dev, "[%04x:%04x] type %02x class %#08x\n",
1019                    dev->vendor, dev->device, dev->hdr_type, dev->class);
1020
1021         /* need to have dev->class ready */
1022         dev->cfg_size = pci_cfg_space_size(dev);
1023
1024         /* "Unknown power state" */
1025         dev->current_state = PCI_UNKNOWN;
1026
1027         /* Early fixups, before probing the BARs */
1028         pci_fixup_device(pci_fixup_early, dev);
1029         /* device class may be changed after fixup */
1030         class = dev->class >> 8;
1031
1032         switch (dev->hdr_type) {                    /* header type */
1033         case PCI_HEADER_TYPE_NORMAL:                /* standard header */
1034                 if (class == PCI_CLASS_BRIDGE_PCI)
1035                         goto bad;
1036                 pci_read_irq(dev);
1037                 pci_read_bases(dev, 6, PCI_ROM_ADDRESS);
1038                 pci_read_config_word(dev, PCI_SUBSYSTEM_VENDOR_ID, &dev->subsystem_vendor);
1039                 pci_read_config_word(dev, PCI_SUBSYSTEM_ID, &dev->subsystem_device);
1040
1041                 /*
1042                  *      Do the ugly legacy mode stuff here rather than broken chip
1043                  *      quirk code. Legacy mode ATA controllers have fixed
1044                  *      addresses. These are not always echoed in BAR0-3, and
1045                  *      BAR0-3 in a few cases contain junk!
1046                  */
1047                 if (class == PCI_CLASS_STORAGE_IDE) {
1048                         u8 progif;
1049                         pci_read_config_byte(dev, PCI_CLASS_PROG, &progif);
1050                         if ((progif & 1) == 0) {
1051                                 region.start = 0x1F0;
1052                                 region.end = 0x1F7;
1053                                 res = &dev->resource[0];
1054                                 res->flags = LEGACY_IO_RESOURCE;
1055                                 pcibios_bus_to_resource(dev, res, &region);
1056                                 region.start = 0x3F6;
1057                                 region.end = 0x3F6;
1058                                 res = &dev->resource[1];
1059                                 res->flags = LEGACY_IO_RESOURCE;
1060                                 pcibios_bus_to_resource(dev, res, &region);
1061                         }
1062                         if ((progif & 4) == 0) {
1063                                 region.start = 0x170;
1064                                 region.end = 0x177;
1065                                 res = &dev->resource[2];
1066                                 res->flags = LEGACY_IO_RESOURCE;
1067                                 pcibios_bus_to_resource(dev, res, &region);
1068                                 region.start = 0x376;
1069                                 region.end = 0x376;
1070                                 res = &dev->resource[3];
1071                                 res->flags = LEGACY_IO_RESOURCE;
1072                                 pcibios_bus_to_resource(dev, res, &region);
1073                         }
1074                 }
1075                 break;
1076
1077         case PCI_HEADER_TYPE_BRIDGE:                /* bridge header */
1078                 if (class != PCI_CLASS_BRIDGE_PCI)
1079                         goto bad;
1080                 /* The PCI-to-PCI bridge spec requires that subtractive
1081                    decoding (i.e. transparent) bridge must have programming
1082                    interface code of 0x01. */
1083                 pci_read_irq(dev);
1084                 dev->transparent = ((dev->class & 0xff) == 1);
1085                 pci_read_bases(dev, 2, PCI_ROM_ADDRESS1);
1086                 set_pcie_hotplug_bridge(dev);
1087                 pos = pci_find_capability(dev, PCI_CAP_ID_SSVID);
1088                 if (pos) {
1089                         pci_read_config_word(dev, pos + PCI_SSVID_VENDOR_ID, &dev->subsystem_vendor);
1090                         pci_read_config_word(dev, pos + PCI_SSVID_DEVICE_ID, &dev->subsystem_device);
1091                 }
1092                 break;
1093
1094         case PCI_HEADER_TYPE_CARDBUS:               /* CardBus bridge header */
1095                 if (class != PCI_CLASS_BRIDGE_CARDBUS)
1096                         goto bad;
1097                 pci_read_irq(dev);
1098                 pci_read_bases(dev, 1, 0);
1099                 pci_read_config_word(dev, PCI_CB_SUBSYSTEM_VENDOR_ID, &dev->subsystem_vendor);
1100                 pci_read_config_word(dev, PCI_CB_SUBSYSTEM_ID, &dev->subsystem_device);
1101                 break;
1102
1103         default:                                    /* unknown header */
1104                 dev_err(&dev->dev, "unknown header type %02x, "
1105                         "ignoring device\n", dev->hdr_type);
1106                 return -EIO;
1107
1108         bad:
1109                 dev_err(&dev->dev, "ignoring class %#08x (doesn't match header "
1110                         "type %02x)\n", dev->class, dev->hdr_type);
1111                 dev->class = PCI_CLASS_NOT_DEFINED;
1112         }
1113
1114         /* We found a fine healthy device, go go go... */
1115         return 0;
1116 }
1117
1118 static void pci_release_capabilities(struct pci_dev *dev)
1119 {
1120         pci_vpd_release(dev);
1121         pci_iov_release(dev);
1122         pci_free_cap_save_buffers(dev);
1123 }
1124
1125 /**
1126  * pci_release_dev - free a pci device structure when all users of it are finished.
1127  * @dev: device that's been disconnected
1128  *
1129  * Will be called only by the device core when all users of this pci device are
1130  * done.
1131  */
1132 static void pci_release_dev(struct device *dev)
1133 {
1134         struct pci_dev *pci_dev;
1135
1136         pci_dev = to_pci_dev(dev);
1137         pci_release_capabilities(pci_dev);
1138         pci_release_of_node(pci_dev);
1139         kfree(pci_dev);
1140 }
1141
1142 /**
1143  * pci_cfg_space_size - get the configuration space size of the PCI device.
1144  * @dev: PCI device
1145  *
1146  * Regular PCI devices have 256 bytes, but PCI-X 2 and PCI Express devices
1147  * have 4096 bytes.  Even if the device is capable, that doesn't mean we can
1148  * access it.  Maybe we don't have a way to generate extended config space
1149  * accesses, or the device is behind a reverse Express bridge.  So we try
1150  * reading the dword at 0x100 which must either be 0 or a valid extended
1151  * capability header.
1152  */
1153 int pci_cfg_space_size_ext(struct pci_dev *dev)
1154 {
1155         u32 status;
1156         int pos = PCI_CFG_SPACE_SIZE;
1157
1158         if (pci_read_config_dword(dev, pos, &status) != PCIBIOS_SUCCESSFUL)
1159                 goto fail;
1160         if (status == 0xffffffff)
1161                 goto fail;
1162
1163         return PCI_CFG_SPACE_EXP_SIZE;
1164
1165  fail:
1166         return PCI_CFG_SPACE_SIZE;
1167 }
1168
1169 int pci_cfg_space_size(struct pci_dev *dev)
1170 {
1171         int pos;
1172         u32 status;
1173         u16 class;
1174
1175         class = dev->class >> 8;
1176         if (class == PCI_CLASS_BRIDGE_HOST)
1177                 return pci_cfg_space_size_ext(dev);
1178
1179         if (!pci_is_pcie(dev)) {
1180                 pos = pci_find_capability(dev, PCI_CAP_ID_PCIX);
1181                 if (!pos)
1182                         goto fail;
1183
1184                 pci_read_config_dword(dev, pos + PCI_X_STATUS, &status);
1185                 if (!(status & (PCI_X_STATUS_266MHZ | PCI_X_STATUS_533MHZ)))
1186                         goto fail;
1187         }
1188
1189         return pci_cfg_space_size_ext(dev);
1190
1191  fail:
1192         return PCI_CFG_SPACE_SIZE;
1193 }
1194
1195 static void pci_release_bus_bridge_dev(struct device *dev)
1196 {
1197         struct pci_host_bridge *bridge = to_pci_host_bridge(dev);
1198
1199         if (bridge->release_fn)
1200                 bridge->release_fn(bridge);
1201
1202         pci_free_resource_list(&bridge->windows);
1203
1204         kfree(bridge);
1205 }
1206
1207 struct pci_dev *alloc_pci_dev(void)
1208 {
1209         struct pci_dev *dev;
1210
1211         dev = kzalloc(sizeof(struct pci_dev), GFP_KERNEL);
1212         if (!dev)
1213                 return NULL;
1214
1215         INIT_LIST_HEAD(&dev->bus_list);
1216         dev->dev.type = &pci_dev_type;
1217
1218         return dev;
1219 }
1220 EXPORT_SYMBOL(alloc_pci_dev);
1221
1222 bool pci_bus_read_dev_vendor_id(struct pci_bus *bus, int devfn, u32 *l,
1223                                  int crs_timeout)
1224 {
1225         int delay = 1;
1226
1227         if (pci_bus_read_config_dword(bus, devfn, PCI_VENDOR_ID, l))
1228                 return false;
1229
1230         /* some broken boards return 0 or ~0 if a slot is empty: */
1231         if (*l == 0xffffffff || *l == 0x00000000 ||
1232             *l == 0x0000ffff || *l == 0xffff0000)
1233                 return false;
1234
1235         /* Configuration request Retry Status */
1236         while (*l == 0xffff0001) {
1237                 if (!crs_timeout)
1238                         return false;
1239
1240                 msleep(delay);
1241                 delay *= 2;
1242                 if (pci_bus_read_config_dword(bus, devfn, PCI_VENDOR_ID, l))
1243                         return false;
1244                 /* Card hasn't responded in 60 seconds?  Must be stuck. */
1245                 if (delay > crs_timeout) {
1246                         printk(KERN_WARNING "pci %04x:%02x:%02x.%d: not "
1247                                         "responding\n", pci_domain_nr(bus),
1248                                         bus->number, PCI_SLOT(devfn),
1249                                         PCI_FUNC(devfn));
1250                         return false;
1251                 }
1252         }
1253
1254         return true;
1255 }
1256 EXPORT_SYMBOL(pci_bus_read_dev_vendor_id);
1257
1258 /*
1259  * Read the config data for a PCI device, sanity-check it
1260  * and fill in the dev structure...
1261  */
1262 static struct pci_dev *pci_scan_device(struct pci_bus *bus, int devfn)
1263 {
1264         struct pci_dev *dev;
1265         u32 l;
1266
1267         if (!pci_bus_read_dev_vendor_id(bus, devfn, &l, 60*1000))
1268                 return NULL;
1269
1270         dev = alloc_pci_dev();
1271         if (!dev)
1272                 return NULL;
1273
1274         dev->bus = bus;
1275         dev->devfn = devfn;
1276         dev->vendor = l & 0xffff;
1277         dev->device = (l >> 16) & 0xffff;
1278
1279         pci_set_of_node(dev);
1280
1281         if (pci_setup_device(dev)) {
1282                 kfree(dev);
1283                 return NULL;
1284         }
1285
1286         return dev;
1287 }
1288
1289 static void pci_init_capabilities(struct pci_dev *dev)
1290 {
1291         /* MSI/MSI-X list */
1292         pci_msi_init_pci_dev(dev);
1293
1294         /* Buffers for saving PCIe and PCI-X capabilities */
1295         pci_allocate_cap_save_buffers(dev);
1296
1297         /* Power Management */
1298         pci_pm_init(dev);
1299
1300         /* Vital Product Data */
1301         pci_vpd_pci22_init(dev);
1302
1303         /* Alternative Routing-ID Forwarding */
1304         pci_configure_ari(dev);
1305
1306         /* Single Root I/O Virtualization */
1307         pci_iov_init(dev);
1308
1309         /* Enable ACS P2P upstream forwarding */
1310         pci_enable_acs(dev);
1311 }
1312
1313 void pci_device_add(struct pci_dev *dev, struct pci_bus *bus)
1314 {
1315         int ret;
1316
1317         device_initialize(&dev->dev);
1318         dev->dev.release = pci_release_dev;
1319
1320         set_dev_node(&dev->dev, pcibus_to_node(bus));
1321         dev->dev.dma_mask = &dev->dma_mask;
1322         dev->dev.dma_parms = &dev->dma_parms;
1323         dev->dev.coherent_dma_mask = 0xffffffffull;
1324
1325         pci_set_dma_max_seg_size(dev, 65536);
1326         pci_set_dma_seg_boundary(dev, 0xffffffff);
1327
1328         /* Fix up broken headers */
1329         pci_fixup_device(pci_fixup_header, dev);
1330
1331         /* moved out from quirk header fixup code */
1332         pci_reassigndev_resource_alignment(dev);
1333
1334         /* Clear the state_saved flag. */
1335         dev->state_saved = false;
1336
1337         /* Initialize various capabilities */
1338         pci_init_capabilities(dev);
1339
1340         /*
1341          * Add the device to our list of discovered devices
1342          * and the bus list for fixup functions, etc.
1343          */
1344         down_write(&pci_bus_sem);
1345         list_add_tail(&dev->bus_list, &bus->devices);
1346         up_write(&pci_bus_sem);
1347
1348         ret = pcibios_add_device(dev);
1349         WARN_ON(ret < 0);
1350
1351         /* Notifier could use PCI capabilities */
1352         dev->match_driver = false;
1353         ret = device_add(&dev->dev);
1354         WARN_ON(ret < 0);
1355
1356         pci_proc_attach_device(dev);
1357 }
1358
1359 struct pci_dev *__ref pci_scan_single_device(struct pci_bus *bus, int devfn)
1360 {
1361         struct pci_dev *dev;
1362
1363         dev = pci_get_slot(bus, devfn);
1364         if (dev) {
1365                 pci_dev_put(dev);
1366                 return dev;
1367         }
1368
1369         dev = pci_scan_device(bus, devfn);
1370         if (!dev)
1371                 return NULL;
1372
1373         pci_device_add(dev, bus);
1374
1375         return dev;
1376 }
1377 EXPORT_SYMBOL(pci_scan_single_device);
1378
1379 static unsigned next_fn(struct pci_bus *bus, struct pci_dev *dev, unsigned fn)
1380 {
1381         int pos;
1382         u16 cap = 0;
1383         unsigned next_fn;
1384
1385         if (pci_ari_enabled(bus)) {
1386                 if (!dev)
1387                         return 0;
1388                 pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ARI);
1389                 if (!pos)
1390                         return 0;
1391
1392                 pci_read_config_word(dev, pos + PCI_ARI_CAP, &cap);
1393                 next_fn = PCI_ARI_CAP_NFN(cap);
1394                 if (next_fn <= fn)
1395                         return 0;       /* protect against malformed list */
1396
1397                 return next_fn;
1398         }
1399
1400         /* dev may be NULL for non-contiguous multifunction devices */
1401         if (!dev || dev->multifunction)
1402                 return (fn + 1) % 8;
1403
1404         return 0;
1405 }
1406
1407 static int only_one_child(struct pci_bus *bus)
1408 {
1409         struct pci_dev *parent = bus->self;
1410
1411         if (!parent || !pci_is_pcie(parent))
1412                 return 0;
1413         if (pci_pcie_type(parent) == PCI_EXP_TYPE_ROOT_PORT)
1414                 return 1;
1415         if (pci_pcie_type(parent) == PCI_EXP_TYPE_DOWNSTREAM &&
1416             !pci_has_flag(PCI_SCAN_ALL_PCIE_DEVS))
1417                 return 1;
1418         return 0;
1419 }
1420
1421 /**
1422  * pci_scan_slot - scan a PCI slot on a bus for devices.
1423  * @bus: PCI bus to scan
1424  * @devfn: slot number to scan (must have zero function.)
1425  *
1426  * Scan a PCI slot on the specified PCI bus for devices, adding
1427  * discovered devices to the @bus->devices list.  New devices
1428  * will not have is_added set.
1429  *
1430  * Returns the number of new devices found.
1431  */
1432 int pci_scan_slot(struct pci_bus *bus, int devfn)
1433 {
1434         unsigned fn, nr = 0;
1435         struct pci_dev *dev;
1436
1437         if (only_one_child(bus) && (devfn > 0))
1438                 return 0; /* Already scanned the entire slot */
1439
1440         dev = pci_scan_single_device(bus, devfn);
1441         if (!dev)
1442                 return 0;
1443         if (!dev->is_added)
1444                 nr++;
1445
1446         for (fn = next_fn(bus, dev, 0); fn > 0; fn = next_fn(bus, dev, fn)) {
1447                 dev = pci_scan_single_device(bus, devfn + fn);
1448                 if (dev) {
1449                         if (!dev->is_added)
1450                                 nr++;
1451                         dev->multifunction = 1;
1452                 }
1453         }
1454
1455         /* only one slot has pcie device */
1456         if (bus->self && nr)
1457                 pcie_aspm_init_link_state(bus->self);
1458
1459         return nr;
1460 }
1461
1462 static int pcie_find_smpss(struct pci_dev *dev, void *data)
1463 {
1464         u8 *smpss = data;
1465
1466         if (!pci_is_pcie(dev))
1467                 return 0;
1468
1469         /* For PCIE hotplug enabled slots not connected directly to a
1470          * PCI-E root port, there can be problems when hotplugging
1471          * devices.  This is due to the possibility of hotplugging a
1472          * device into the fabric with a smaller MPS that the devices
1473          * currently running have configured.  Modifying the MPS on the
1474          * running devices could cause a fatal bus error due to an
1475          * incoming frame being larger than the newly configured MPS.
1476          * To work around this, the MPS for the entire fabric must be
1477          * set to the minimum size.  Any devices hotplugged into this
1478          * fabric will have the minimum MPS set.  If the PCI hotplug
1479          * slot is directly connected to the root port and there are not
1480          * other devices on the fabric (which seems to be the most
1481          * common case), then this is not an issue and MPS discovery
1482          * will occur as normal.
1483          */
1484         if (dev->is_hotplug_bridge && (!list_is_singular(&dev->bus->devices) ||
1485              (dev->bus->self &&
1486               pci_pcie_type(dev->bus->self) != PCI_EXP_TYPE_ROOT_PORT)))
1487                 *smpss = 0;
1488
1489         if (*smpss > dev->pcie_mpss)
1490                 *smpss = dev->pcie_mpss;
1491
1492         return 0;
1493 }
1494
1495 static void pcie_write_mps(struct pci_dev *dev, int mps)
1496 {
1497         int rc;
1498
1499         if (pcie_bus_config == PCIE_BUS_PERFORMANCE) {
1500                 mps = 128 << dev->pcie_mpss;
1501
1502                 if (pci_pcie_type(dev) != PCI_EXP_TYPE_ROOT_PORT &&
1503                     dev->bus->self)
1504                         /* For "Performance", the assumption is made that
1505                          * downstream communication will never be larger than
1506                          * the MRRS.  So, the MPS only needs to be configured
1507                          * for the upstream communication.  This being the case,
1508                          * walk from the top down and set the MPS of the child
1509                          * to that of the parent bus.
1510                          *
1511                          * Configure the device MPS with the smaller of the
1512                          * device MPSS or the bridge MPS (which is assumed to be
1513                          * properly configured at this point to the largest
1514                          * allowable MPS based on its parent bus).
1515                          */
1516                         mps = min(mps, pcie_get_mps(dev->bus->self));
1517         }
1518
1519         rc = pcie_set_mps(dev, mps);
1520         if (rc)
1521                 dev_err(&dev->dev, "Failed attempting to set the MPS\n");
1522 }
1523
1524 static void pcie_write_mrrs(struct pci_dev *dev)
1525 {
1526         int rc, mrrs;
1527
1528         /* In the "safe" case, do not configure the MRRS.  There appear to be
1529          * issues with setting MRRS to 0 on a number of devices.
1530          */
1531         if (pcie_bus_config != PCIE_BUS_PERFORMANCE)
1532                 return;
1533
1534         /* For Max performance, the MRRS must be set to the largest supported
1535          * value.  However, it cannot be configured larger than the MPS the
1536          * device or the bus can support.  This should already be properly
1537          * configured by a prior call to pcie_write_mps.
1538          */
1539         mrrs = pcie_get_mps(dev);
1540
1541         /* MRRS is a R/W register.  Invalid values can be written, but a
1542          * subsequent read will verify if the value is acceptable or not.
1543          * If the MRRS value provided is not acceptable (e.g., too large),
1544          * shrink the value until it is acceptable to the HW.
1545          */
1546         while (mrrs != pcie_get_readrq(dev) && mrrs >= 128) {
1547                 rc = pcie_set_readrq(dev, mrrs);
1548                 if (!rc)
1549                         break;
1550
1551                 dev_warn(&dev->dev, "Failed attempting to set the MRRS\n");
1552                 mrrs /= 2;
1553         }
1554
1555         if (mrrs < 128)
1556                 dev_err(&dev->dev, "MRRS was unable to be configured with a "
1557                         "safe value.  If problems are experienced, try running "
1558                         "with pci=pcie_bus_safe.\n");
1559 }
1560
1561 static int pcie_bus_configure_set(struct pci_dev *dev, void *data)
1562 {
1563         int mps, orig_mps;
1564
1565         if (!pci_is_pcie(dev))
1566                 return 0;
1567
1568         mps = 128 << *(u8 *)data;
1569         orig_mps = pcie_get_mps(dev);
1570
1571         pcie_write_mps(dev, mps);
1572         pcie_write_mrrs(dev);
1573
1574         dev_info(&dev->dev, "PCI-E Max Payload Size set to %4d/%4d (was %4d), "
1575                  "Max Read Rq %4d\n", pcie_get_mps(dev), 128 << dev->pcie_mpss,
1576                  orig_mps, pcie_get_readrq(dev));
1577
1578         return 0;
1579 }
1580
1581 /* pcie_bus_configure_settings requires that pci_walk_bus work in a top-down,
1582  * parents then children fashion.  If this changes, then this code will not
1583  * work as designed.
1584  */
1585 void pcie_bus_configure_settings(struct pci_bus *bus)
1586 {
1587         u8 smpss = 0;
1588
1589         if (!bus->self)
1590                 return;
1591
1592         if (!pci_is_pcie(bus->self))
1593                 return;
1594
1595         if (pcie_bus_config == PCIE_BUS_TUNE_OFF)
1596                 return;
1597
1598         /* FIXME - Peer to peer DMA is possible, though the endpoint would need
1599          * to be aware to the MPS of the destination.  To work around this,
1600          * simply force the MPS of the entire system to the smallest possible.
1601          */
1602         if (pcie_bus_config == PCIE_BUS_PEER2PEER)
1603                 smpss = 0;
1604
1605         if (pcie_bus_config == PCIE_BUS_SAFE) {
1606                 smpss = bus->self->pcie_mpss;
1607
1608                 pcie_find_smpss(bus->self, &smpss);
1609                 pci_walk_bus(bus, pcie_find_smpss, &smpss);
1610         }
1611
1612         pcie_bus_configure_set(bus->self, &smpss);
1613         pci_walk_bus(bus, pcie_bus_configure_set, &smpss);
1614 }
1615 EXPORT_SYMBOL_GPL(pcie_bus_configure_settings);
1616
1617 unsigned int pci_scan_child_bus(struct pci_bus *bus)
1618 {
1619         unsigned int devfn, pass, max = bus->busn_res.start;
1620         struct pci_dev *dev;
1621
1622         dev_dbg(&bus->dev, "scanning bus\n");
1623
1624         /* Go find them, Rover! */
1625         for (devfn = 0; devfn < 0x100; devfn += 8)
1626                 pci_scan_slot(bus, devfn);
1627
1628         /* Reserve buses for SR-IOV capability. */
1629         max += pci_iov_bus_range(bus);
1630
1631         /*
1632          * After performing arch-dependent fixup of the bus, look behind
1633          * all PCI-to-PCI bridges on this bus.
1634          */
1635         if (!bus->is_added) {
1636                 dev_dbg(&bus->dev, "fixups for bus\n");
1637                 pcibios_fixup_bus(bus);
1638                 bus->is_added = 1;
1639         }
1640
1641         for (pass=0; pass < 2; pass++)
1642                 list_for_each_entry(dev, &bus->devices, bus_list) {
1643                         if (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE ||
1644                             dev->hdr_type == PCI_HEADER_TYPE_CARDBUS)
1645                                 max = pci_scan_bridge(bus, dev, max, pass);
1646                 }
1647
1648         /*
1649          * We've scanned the bus and so we know all about what's on
1650          * the other side of any bridges that may be on this bus plus
1651          * any devices.
1652          *
1653          * Return how far we've got finding sub-buses.
1654          */
1655         dev_dbg(&bus->dev, "bus scan returning with max=%02x\n", max);
1656         return max;
1657 }
1658
1659 /**
1660  * pcibios_root_bridge_prepare - Platform-specific host bridge setup.
1661  * @bridge: Host bridge to set up.
1662  *
1663  * Default empty implementation.  Replace with an architecture-specific setup
1664  * routine, if necessary.
1665  */
1666 int __weak pcibios_root_bridge_prepare(struct pci_host_bridge *bridge)
1667 {
1668         return 0;
1669 }
1670
1671 void __weak pcibios_add_bus(struct pci_bus *bus)
1672 {
1673 }
1674
1675 void __weak pcibios_remove_bus(struct pci_bus *bus)
1676 {
1677 }
1678
1679 struct pci_bus *pci_create_root_bus(struct device *parent, int bus,
1680                 struct pci_ops *ops, void *sysdata, struct list_head *resources)
1681 {
1682         int error;
1683         struct pci_host_bridge *bridge;
1684         struct pci_bus *b, *b2;
1685         struct pci_host_bridge_window *window, *n;
1686         struct resource *res;
1687         resource_size_t offset;
1688         char bus_addr[64];
1689         char *fmt;
1690
1691         b = pci_alloc_bus();
1692         if (!b)
1693                 return NULL;
1694
1695         b->sysdata = sysdata;
1696         b->ops = ops;
1697         b->number = b->busn_res.start = bus;
1698         b2 = pci_find_bus(pci_domain_nr(b), bus);
1699         if (b2) {
1700                 /* If we already got to this bus through a different bridge, ignore it */
1701                 dev_dbg(&b2->dev, "bus already known\n");
1702                 goto err_out;
1703         }
1704
1705         bridge = pci_alloc_host_bridge(b);
1706         if (!bridge)
1707                 goto err_out;
1708
1709         bridge->dev.parent = parent;
1710         bridge->dev.release = pci_release_bus_bridge_dev;
1711         dev_set_name(&bridge->dev, "pci%04x:%02x", pci_domain_nr(b), bus);
1712         error = pcibios_root_bridge_prepare(bridge);
1713         if (error) {
1714                 kfree(bridge);
1715                 goto err_out;
1716         }
1717
1718         error = device_register(&bridge->dev);
1719         if (error) {
1720                 put_device(&bridge->dev);
1721                 goto err_out;
1722         }
1723         b->bridge = get_device(&bridge->dev);
1724         device_enable_async_suspend(b->bridge);
1725         pci_set_bus_of_node(b);
1726
1727         if (!parent)
1728                 set_dev_node(b->bridge, pcibus_to_node(b));
1729
1730         b->dev.class = &pcibus_class;
1731         b->dev.parent = b->bridge;
1732         dev_set_name(&b->dev, "%04x:%02x", pci_domain_nr(b), bus);
1733         error = device_register(&b->dev);
1734         if (error)
1735                 goto class_dev_reg_err;
1736
1737         pcibios_add_bus(b);
1738
1739         /* Create legacy_io and legacy_mem files for this bus */
1740         pci_create_legacy_files(b);
1741
1742         if (parent)
1743                 dev_info(parent, "PCI host bridge to bus %s\n", dev_name(&b->dev));
1744         else
1745                 printk(KERN_INFO "PCI host bridge to bus %s\n", dev_name(&b->dev));
1746
1747         /* Add initial resources to the bus */
1748         list_for_each_entry_safe(window, n, resources, list) {
1749                 list_move_tail(&window->list, &bridge->windows);
1750                 res = window->res;
1751                 offset = window->offset;
1752                 if (res->flags & IORESOURCE_BUS)
1753                         pci_bus_insert_busn_res(b, bus, res->end);
1754                 else
1755                         pci_bus_add_resource(b, res, 0);
1756                 if (offset) {
1757                         if (resource_type(res) == IORESOURCE_IO)
1758                                 fmt = " (bus address [%#06llx-%#06llx])";
1759                         else
1760                                 fmt = " (bus address [%#010llx-%#010llx])";
1761                         snprintf(bus_addr, sizeof(bus_addr), fmt,
1762                                  (unsigned long long) (res->start - offset),
1763                                  (unsigned long long) (res->end - offset));
1764                 } else
1765                         bus_addr[0] = '\0';
1766                 dev_info(&b->dev, "root bus resource %pR%s\n", res, bus_addr);
1767         }
1768
1769         down_write(&pci_bus_sem);
1770         list_add_tail(&b->node, &pci_root_buses);
1771         up_write(&pci_bus_sem);
1772
1773         return b;
1774
1775 class_dev_reg_err:
1776         put_device(&bridge->dev);
1777         device_unregister(&bridge->dev);
1778 err_out:
1779         kfree(b);
1780         return NULL;
1781 }
1782 EXPORT_SYMBOL(pci_create_root_bus);
1783
1784 int pci_bus_insert_busn_res(struct pci_bus *b, int bus, int bus_max)
1785 {
1786         struct resource *res = &b->busn_res;
1787         struct resource *parent_res, *conflict;
1788
1789         res->start = bus;
1790         res->end = bus_max;
1791         res->flags = IORESOURCE_BUS;
1792
1793         if (!pci_is_root_bus(b))
1794                 parent_res = &b->parent->busn_res;
1795         else {
1796                 parent_res = get_pci_domain_busn_res(pci_domain_nr(b));
1797                 res->flags |= IORESOURCE_PCI_FIXED;
1798         }
1799
1800         conflict = insert_resource_conflict(parent_res, res);
1801
1802         if (conflict)
1803                 dev_printk(KERN_DEBUG, &b->dev,
1804                            "busn_res: can not insert %pR under %s%pR (conflicts with %s %pR)\n",
1805                             res, pci_is_root_bus(b) ? "domain " : "",
1806                             parent_res, conflict->name, conflict);
1807
1808         return conflict == NULL;
1809 }
1810
1811 int pci_bus_update_busn_res_end(struct pci_bus *b, int bus_max)
1812 {
1813         struct resource *res = &b->busn_res;
1814         struct resource old_res = *res;
1815         resource_size_t size;
1816         int ret;
1817
1818         if (res->start > bus_max)
1819                 return -EINVAL;
1820
1821         size = bus_max - res->start + 1;
1822         ret = adjust_resource(res, res->start, size);
1823         dev_printk(KERN_DEBUG, &b->dev,
1824                         "busn_res: %pR end %s updated to %02x\n",
1825                         &old_res, ret ? "can not be" : "is", bus_max);
1826
1827         if (!ret && !res->parent)
1828                 pci_bus_insert_busn_res(b, res->start, res->end);
1829
1830         return ret;
1831 }
1832
1833 void pci_bus_release_busn_res(struct pci_bus *b)
1834 {
1835         struct resource *res = &b->busn_res;
1836         int ret;
1837
1838         if (!res->flags || !res->parent)
1839                 return;
1840
1841         ret = release_resource(res);
1842         dev_printk(KERN_DEBUG, &b->dev,
1843                         "busn_res: %pR %s released\n",
1844                         res, ret ? "can not be" : "is");
1845 }
1846
1847 struct pci_bus *pci_scan_root_bus(struct device *parent, int bus,
1848                 struct pci_ops *ops, void *sysdata, struct list_head *resources)
1849 {
1850         struct pci_host_bridge_window *window;
1851         bool found = false;
1852         struct pci_bus *b;
1853         int max;
1854
1855         list_for_each_entry(window, resources, list)
1856                 if (window->res->flags & IORESOURCE_BUS) {
1857                         found = true;
1858                         break;
1859                 }
1860
1861         b = pci_create_root_bus(parent, bus, ops, sysdata, resources);
1862         if (!b)
1863                 return NULL;
1864
1865         if (!found) {
1866                 dev_info(&b->dev,
1867                  "No busn resource found for root bus, will use [bus %02x-ff]\n",
1868                         bus);
1869                 pci_bus_insert_busn_res(b, bus, 255);
1870         }
1871
1872         max = pci_scan_child_bus(b);
1873
1874         if (!found)
1875                 pci_bus_update_busn_res_end(b, max);
1876
1877         pci_bus_add_devices(b);
1878         return b;
1879 }
1880 EXPORT_SYMBOL(pci_scan_root_bus);
1881
1882 /* Deprecated; use pci_scan_root_bus() instead */
1883 struct pci_bus *pci_scan_bus_parented(struct device *parent,
1884                 int bus, struct pci_ops *ops, void *sysdata)
1885 {
1886         LIST_HEAD(resources);
1887         struct pci_bus *b;
1888
1889         pci_add_resource(&resources, &ioport_resource);
1890         pci_add_resource(&resources, &iomem_resource);
1891         pci_add_resource(&resources, &busn_resource);
1892         b = pci_create_root_bus(parent, bus, ops, sysdata, &resources);
1893         if (b)
1894                 pci_scan_child_bus(b);
1895         else
1896                 pci_free_resource_list(&resources);
1897         return b;
1898 }
1899 EXPORT_SYMBOL(pci_scan_bus_parented);
1900
1901 struct pci_bus *pci_scan_bus(int bus, struct pci_ops *ops,
1902                                         void *sysdata)
1903 {
1904         LIST_HEAD(resources);
1905         struct pci_bus *b;
1906
1907         pci_add_resource(&resources, &ioport_resource);
1908         pci_add_resource(&resources, &iomem_resource);
1909         pci_add_resource(&resources, &busn_resource);
1910         b = pci_create_root_bus(NULL, bus, ops, sysdata, &resources);
1911         if (b) {
1912                 pci_scan_child_bus(b);
1913                 pci_bus_add_devices(b);
1914         } else {
1915                 pci_free_resource_list(&resources);
1916         }
1917         return b;
1918 }
1919 EXPORT_SYMBOL(pci_scan_bus);
1920
1921 /**
1922  * pci_rescan_bus_bridge_resize - scan a PCI bus for devices.
1923  * @bridge: PCI bridge for the bus to scan
1924  *
1925  * Scan a PCI bus and child buses for new devices, add them,
1926  * and enable them, resizing bridge mmio/io resource if necessary
1927  * and possible.  The caller must ensure the child devices are already
1928  * removed for resizing to occur.
1929  *
1930  * Returns the max number of subordinate bus discovered.
1931  */
1932 unsigned int __ref pci_rescan_bus_bridge_resize(struct pci_dev *bridge)
1933 {
1934         unsigned int max;
1935         struct pci_bus *bus = bridge->subordinate;
1936
1937         max = pci_scan_child_bus(bus);
1938
1939         pci_assign_unassigned_bridge_resources(bridge);
1940
1941         pci_bus_add_devices(bus);
1942
1943         return max;
1944 }
1945
1946 /**
1947  * pci_rescan_bus - scan a PCI bus for devices.
1948  * @bus: PCI bus to scan
1949  *
1950  * Scan a PCI bus and child buses for new devices, adds them,
1951  * and enables them.
1952  *
1953  * Returns the max number of subordinate bus discovered.
1954  */
1955 unsigned int __ref pci_rescan_bus(struct pci_bus *bus)
1956 {
1957         unsigned int max;
1958
1959         max = pci_scan_child_bus(bus);
1960         pci_assign_unassigned_bus_resources(bus);
1961         pci_enable_bridges(bus);
1962         pci_bus_add_devices(bus);
1963
1964         return max;
1965 }
1966 EXPORT_SYMBOL_GPL(pci_rescan_bus);
1967
1968 EXPORT_SYMBOL(pci_add_new_bus);
1969 EXPORT_SYMBOL(pci_scan_slot);
1970 EXPORT_SYMBOL(pci_scan_bridge);
1971 EXPORT_SYMBOL_GPL(pci_scan_child_bus);
1972
1973 static int __init pci_sort_bf_cmp(const struct device *d_a, const struct device *d_b)
1974 {
1975         const struct pci_dev *a = to_pci_dev(d_a);
1976         const struct pci_dev *b = to_pci_dev(d_b);
1977
1978         if      (pci_domain_nr(a->bus) < pci_domain_nr(b->bus)) return -1;
1979         else if (pci_domain_nr(a->bus) > pci_domain_nr(b->bus)) return  1;
1980
1981         if      (a->bus->number < b->bus->number) return -1;
1982         else if (a->bus->number > b->bus->number) return  1;
1983
1984         if      (a->devfn < b->devfn) return -1;
1985         else if (a->devfn > b->devfn) return  1;
1986
1987         return 0;
1988 }
1989
1990 void __init pci_sort_breadthfirst(void)
1991 {
1992         bus_sort_breadthfirst(&pci_bus_type, &pci_sort_bf_cmp);
1993 }