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