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