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