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/of_device.h>
  10 #include <linux/of_pci.h>
  11 #include <linux/pci_hotplug.h>
  12 #include <linux/slab.h>
  13 #include <linux/module.h>
  14 #include <linux/cpumask.h>
  15 #include <linux/pci-aspm.h>
  16 #include <linux/aer.h>
  17 #include <linux/acpi.h>
  18 #include <linux/irqdomain.h>
  19 #include <linux/pm_runtime.h>
  20 #include "pci.h"
  21
  22 #define CARDBUS_LATENCY_TIMER   176     /* secondary latency timer */
  23 #define CARDBUS_RESERVE_BUSNR   3
  24
  25 static struct resource busn_resource = {
  26         .name   = "PCI busn",
  27         .start  = 0,
  28         .end    = 255,
  29         .flags  = IORESOURCE_BUS,
  30 };
  31
  32 /* Ugh.  Need to stop exporting this to modules. */
  33 LIST_HEAD(pci_root_buses);
  34 EXPORT_SYMBOL(pci_root_buses);
  35
  36 static LIST_HEAD(pci_domain_busn_res_list);
  37
  38 struct pci_domain_busn_res {
  39         struct list_head list;
  40         struct resource res;
  41         int domain_nr;
  42 };
  43
  44 static struct resource *get_pci_domain_busn_res(int domain_nr)
  45 {
  46         struct pci_domain_busn_res *r;
  47
  48         list_for_each_entry(r, &pci_domain_busn_res_list, list)
  49                 if (r->domain_nr == domain_nr)
  50                         return &r->res;
  51
  52         r = kzalloc(sizeof(*r), GFP_KERNEL);
  53         if (!r)
  54                 return NULL;
  55
  56         r->domain_nr = domain_nr;
  57         r->res.start = 0;
  58         r->res.end = 0xff;
  59         r->res.flags = IORESOURCE_BUS | IORESOURCE_PCI_FIXED;
  60
  61         list_add_tail(&r->list, &pci_domain_busn_res_list);
  62
  63         return &r->res;
  64 }
  65
  66 static int find_anything(struct device *dev, void *data)
  67 {
  68         return 1;
  69 }
  70
  71 /*
  72  * Some device drivers need know if pci is initiated.
  73  * Basically, we think pci is not initiated when there
  74  * is no device to be found on the pci_bus_type.
  75  */
  76 int no_pci_devices(void)
  77 {
  78         struct device *dev;
  79         int no_devices;
  80
  81         dev = bus_find_device(&pci_bus_type, NULL, NULL, find_anything);
  82         no_devices = (dev == NULL);
  83         put_device(dev);
  84         return no_devices;
  85 }
  86 EXPORT_SYMBOL(no_pci_devices);
  87
  88 /*
  89  * PCI Bus Class
  90  */
  91 static void release_pcibus_dev(struct device *dev)
  92 {
  93         struct pci_bus *pci_bus = to_pci_bus(dev);
  94
  95         put_device(pci_bus->bridge);
  96         pci_bus_remove_resources(pci_bus);
  97         pci_release_bus_of_node(pci_bus);
  98         kfree(pci_bus);
  99 }
 100
 101 static struct class pcibus_class = {
 102         .name           = "pci_bus",
 103         .dev_release    = &release_pcibus_dev,
 104         .dev_groups     = pcibus_groups,
 105 };
 106
 107 static int __init pcibus_class_init(void)
 108 {
 109         return class_register(&pcibus_class);
 110 }
 111 postcore_initcall(pcibus_class_init);
 112
 113 static u64 pci_size(u64 base, u64 maxbase, u64 mask)
 114 {
 115         u64 size = mask & maxbase;      /* Find the significant bits */
 116         if (!size)
 117                 return 0;
 118
 119         /* Get the lowest of them to find the decode size, and
 120            from that the extent.  */
 121         size = (size & ~(size-1)) - 1;
 122
 123         /* base == maxbase can be valid only if the BAR has
 124            already been programmed with all 1s.  */
 125         if (base == maxbase && ((base | size) & mask) != mask)
 126                 return 0;
 127
 128         return size;
 129 }
 130
 131 static inline unsigned long decode_bar(struct pci_dev *dev, u32 bar)
 132 {
 133         u32 mem_type;
 134         unsigned long flags;
 135
 136         if ((bar & PCI_BASE_ADDRESS_SPACE) == PCI_BASE_ADDRESS_SPACE_IO) {
 137                 flags = bar & ~PCI_BASE_ADDRESS_IO_MASK;
 138                 flags |= IORESOURCE_IO;
 139                 return flags;
 140         }
 141
 142         flags = bar & ~PCI_BASE_ADDRESS_MEM_MASK;
 143         flags |= IORESOURCE_MEM;
 144         if (flags & PCI_BASE_ADDRESS_MEM_PREFETCH)
 145                 flags |= IORESOURCE_PREFETCH;
 146
 147         mem_type = bar & PCI_BASE_ADDRESS_MEM_TYPE_MASK;
 148         switch (mem_type) {
 149         case PCI_BASE_ADDRESS_MEM_TYPE_32:
 150                 break;
 151         case PCI_BASE_ADDRESS_MEM_TYPE_1M:
 152                 /* 1M mem BAR treated as 32-bit BAR */
 153                 break;
 154         case PCI_BASE_ADDRESS_MEM_TYPE_64:
 155                 flags |= IORESOURCE_MEM_64;
 156                 break;
 157         default:
 158                 /* mem unknown type treated as 32-bit BAR */
 159                 break;
 160         }
 161         return flags;
 162 }
 163
 164 #define PCI_COMMAND_DECODE_ENABLE       (PCI_COMMAND_MEMORY | PCI_COMMAND_IO)
 165
 166 /**
 167  * pci_read_base - read a PCI BAR
 168  * @dev: the PCI device
 169  * @type: type of the BAR
 170  * @res: resource buffer to be filled in
 171  * @pos: BAR position in the config space
 172  *
 173  * Returns 1 if the BAR is 64-bit, or 0 if 32-bit.
 174  */
 175 int __pci_read_base(struct pci_dev *dev, enum pci_bar_type type,
 176                     struct resource *res, unsigned int pos)
 177 {
 178         u32 l = 0, sz = 0, mask;
 179         u64 l64, sz64, mask64;
 180         u16 orig_cmd;
 181         struct pci_bus_region region, inverted_region;
 182
 183         mask = type ? PCI_ROM_ADDRESS_MASK : ~0;
 184
 185         /* No printks while decoding is disabled! */
 186         if (!dev->mmio_always_on) {
 187                 pci_read_config_word(dev, PCI_COMMAND, &orig_cmd);
 188                 if (orig_cmd & PCI_COMMAND_DECODE_ENABLE) {
 189                         pci_write_config_word(dev, PCI_COMMAND,
 190                                 orig_cmd & ~PCI_COMMAND_DECODE_ENABLE);
 191                 }
 192         }
 193
 194         res->name = pci_name(dev);
 195
 196         pci_read_config_dword(dev, pos, &l);
 197         pci_write_config_dword(dev, pos, l | mask);
 198         pci_read_config_dword(dev, pos, &sz);
 199         pci_write_config_dword(dev, pos, l);
 200
 201         /*
 202          * All bits set in sz means the device isn't working properly.
 203          * If the BAR isn't implemented, all bits must be 0.  If it's a
 204          * memory BAR or a ROM, bit 0 must be clear; if it's an io BAR, bit
 205          * 1 must be clear.
 206          */
 207         if (sz == 0xffffffff)
 208                 sz = 0;
 209
 210         /*
 211          * I don't know how l can have all bits set.  Copied from old code.
 212          * Maybe it fixes a bug on some ancient platform.
 213          */
 214         if (l == 0xffffffff)
 215                 l = 0;
 216
 217         if (type == pci_bar_unknown) {
 218                 res->flags = decode_bar(dev, l);
 219                 res->flags |= IORESOURCE_SIZEALIGN;
 220                 if (res->flags & IORESOURCE_IO) {
 221                         l64 = l & PCI_BASE_ADDRESS_IO_MASK;
 222                         sz64 = sz & PCI_BASE_ADDRESS_IO_MASK;
 223                         mask64 = PCI_BASE_ADDRESS_IO_MASK & (u32)IO_SPACE_LIMIT;
 224                 } else {
 225                         l64 = l & PCI_BASE_ADDRESS_MEM_MASK;
 226                         sz64 = sz & PCI_BASE_ADDRESS_MEM_MASK;
 227                         mask64 = (u32)PCI_BASE_ADDRESS_MEM_MASK;
 228                 }
 229         } else {
 230                 if (l & PCI_ROM_ADDRESS_ENABLE)
 231                         res->flags |= IORESOURCE_ROM_ENABLE;
 232                 l64 = l & PCI_ROM_ADDRESS_MASK;
 233                 sz64 = sz & PCI_ROM_ADDRESS_MASK;
 234                 mask64 = PCI_ROM_ADDRESS_MASK;
 235         }
 236
 237         if (res->flags & IORESOURCE_MEM_64) {
 238                 pci_read_config_dword(dev, pos + 4, &l);
 239                 pci_write_config_dword(dev, pos + 4, ~0);
 240                 pci_read_config_dword(dev, pos + 4, &sz);
 241                 pci_write_config_dword(dev, pos + 4, l);
 242
 243                 l64 |= ((u64)l << 32);
 244                 sz64 |= ((u64)sz << 32);
 245                 mask64 |= ((u64)~0 << 32);
 246         }
 247
 248         if (!dev->mmio_always_on && (orig_cmd & PCI_COMMAND_DECODE_ENABLE))
 249                 pci_write_config_word(dev, PCI_COMMAND, orig_cmd);
 250
 251         if (!sz64)
 252                 goto fail;
 253
 254         sz64 = pci_size(l64, sz64, mask64);
 255         if (!sz64) {
 256                 dev_info(&dev->dev, FW_BUG "reg 0x%x: invalid BAR (can't size)\n",
 257                          pos);
 258                 goto fail;
 259         }
 260
 261         if (res->flags & IORESOURCE_MEM_64) {
 262                 if ((sizeof(pci_bus_addr_t) < 8 || sizeof(resource_size_t) < 8)
 263                     && sz64 > 0x100000000ULL) {
 264                         res->flags |= IORESOURCE_UNSET | IORESOURCE_DISABLED;
 265                         res->start = 0;
 266                         res->end = 0;
 267                         dev_err(&dev->dev, "reg 0x%x: can't handle BAR larger than 4GB (size %#010llx)\n",
 268                                 pos, (unsigned long long)sz64);
 269                         goto out;
 270                 }
 271
 272                 if ((sizeof(pci_bus_addr_t) < 8) && l) {
 273                         /* Above 32-bit boundary; try to reallocate */
 274                         res->flags |= IORESOURCE_UNSET;
 275                         res->start = 0;
 276                         res->end = sz64;
 277                         dev_info(&dev->dev, "reg 0x%x: can't handle BAR above 4GB (bus address %#010llx)\n",
 278                                  pos, (unsigned long long)l64);
 279                         goto out;
 280                 }
 281         }
 282
 283         region.start = l64;
 284         region.end = l64 + sz64;
 285
 286         pcibios_bus_to_resource(dev->bus, res, &region);
 287         pcibios_resource_to_bus(dev->bus, &inverted_region, res);
 288
 289         /*
 290          * If "A" is a BAR value (a bus address), "bus_to_resource(A)" is
 291          * the corresponding resource address (the physical address used by
 292          * the CPU.  Converting that resource address back to a bus address
 293          * should yield the original BAR value:
 294          *
 295          *     resource_to_bus(bus_to_resource(A)) == A
 296          *
 297          * If it doesn't, CPU accesses to "bus_to_resource(A)" will not
 298          * be claimed by the device.
 299          */
 300         if (inverted_region.start != region.start) {
 301                 res->flags |= IORESOURCE_UNSET;
 302                 res->start = 0;
 303                 res->end = region.end - region.start;
 304                 dev_info(&dev->dev, "reg 0x%x: initial BAR value %#010llx invalid\n",
 305                          pos, (unsigned long long)region.start);
 306         }
 307
 308         goto out;
 309
 310
 311 fail:
 312         res->flags = 0;
 313 out:
 314         if (res->flags)
 315                 dev_printk(KERN_DEBUG, &dev->dev, "reg 0x%x: %pR\n", pos, res);
 316
 317         return (res->flags & IORESOURCE_MEM_64) ? 1 : 0;
 318 }
 319
 320 static void pci_read_bases(struct pci_dev *dev, unsigned int howmany, int rom)
 321 {
 322         unsigned int pos, reg;
 323
 324         if (dev->non_compliant_bars)
 325                 return;
 326
 327         for (pos = 0; pos < howmany; pos++) {
 328                 struct resource *res = &dev->resource[pos];
 329                 reg = PCI_BASE_ADDRESS_0 + (pos << 2);
 330                 pos += __pci_read_base(dev, pci_bar_unknown, res, reg);
 331         }
 332
 333         if (rom) {
 334                 struct resource *res = &dev->resource[PCI_ROM_RESOURCE];
 335                 dev->rom_base_reg = rom;
 336                 res->flags = IORESOURCE_MEM | IORESOURCE_PREFETCH |
 337                                 IORESOURCE_READONLY | IORESOURCE_SIZEALIGN;
 338                 __pci_read_base(dev, pci_bar_mem32, res, rom);
 339         }
 340 }
 341
 342 static void pci_read_bridge_io(struct pci_bus *child)
 343 {
 344         struct pci_dev *dev = child->self;
 345         u8 io_base_lo, io_limit_lo;
 346         unsigned long io_mask, io_granularity, base, limit;
 347         struct pci_bus_region region;
 348         struct resource *res;
 349
 350         io_mask = PCI_IO_RANGE_MASK;
 351         io_granularity = 0x1000;
 352         if (dev->io_window_1k) {
 353                 /* Support 1K I/O space granularity */
 354                 io_mask = PCI_IO_1K_RANGE_MASK;
 355                 io_granularity = 0x400;
 356         }
 357
 358         res = child->resource[0];
 359         pci_read_config_byte(dev, PCI_IO_BASE, &io_base_lo);
 360         pci_read_config_byte(dev, PCI_IO_LIMIT, &io_limit_lo);
 361         base = (io_base_lo & io_mask) << 8;
 362         limit = (io_limit_lo & io_mask) << 8;
 363
 364         if ((io_base_lo & PCI_IO_RANGE_TYPE_MASK) == PCI_IO_RANGE_TYPE_32) {
 365                 u16 io_base_hi, io_limit_hi;
 366
 367                 pci_read_config_word(dev, PCI_IO_BASE_UPPER16, &io_base_hi);
 368                 pci_read_config_word(dev, PCI_IO_LIMIT_UPPER16, &io_limit_hi);
 369                 base |= ((unsigned long) io_base_hi << 16);
 370                 limit |= ((unsigned long) io_limit_hi << 16);
 371         }
 372
 373         if (base <= limit) {
 374                 res->flags = (io_base_lo & PCI_IO_RANGE_TYPE_MASK) | IORESOURCE_IO;
 375                 region.start = base;
 376                 region.end = limit + io_granularity - 1;
 377                 pcibios_bus_to_resource(dev->bus, res, &region);
 378                 dev_printk(KERN_DEBUG, &dev->dev, "  bridge window %pR\n", res);
 379         }
 380 }
 381
 382 static void pci_read_bridge_mmio(struct pci_bus *child)
 383 {
 384         struct pci_dev *dev = child->self;
 385         u16 mem_base_lo, mem_limit_lo;
 386         unsigned long base, limit;
 387         struct pci_bus_region region;
 388         struct resource *res;
 389
 390         res = child->resource[1];
 391         pci_read_config_word(dev, PCI_MEMORY_BASE, &mem_base_lo);
 392         pci_read_config_word(dev, PCI_MEMORY_LIMIT, &mem_limit_lo);
 393         base = ((unsigned long) mem_base_lo & PCI_MEMORY_RANGE_MASK) << 16;
 394         limit = ((unsigned long) mem_limit_lo & PCI_MEMORY_RANGE_MASK) << 16;
 395         if (base <= limit) {
 396                 res->flags = (mem_base_lo & PCI_MEMORY_RANGE_TYPE_MASK) | IORESOURCE_MEM;
 397                 region.start = base;
 398                 region.end = limit + 0xfffff;
 399                 pcibios_bus_to_resource(dev->bus, res, &region);
 400                 dev_printk(KERN_DEBUG, &dev->dev, "  bridge window %pR\n", res);
 401         }
 402 }
 403
 404 static void pci_read_bridge_mmio_pref(struct pci_bus *child)
 405 {
 406         struct pci_dev *dev = child->self;
 407         u16 mem_base_lo, mem_limit_lo;
 408         u64 base64, limit64;
 409         pci_bus_addr_t base, limit;
 410         struct pci_bus_region region;
 411         struct resource *res;
 412
 413         res = child->resource[2];
 414         pci_read_config_word(dev, PCI_PREF_MEMORY_BASE, &mem_base_lo);
 415         pci_read_config_word(dev, PCI_PREF_MEMORY_LIMIT, &mem_limit_lo);
 416         base64 = (mem_base_lo & PCI_PREF_RANGE_MASK) << 16;
 417         limit64 = (mem_limit_lo & PCI_PREF_RANGE_MASK) << 16;
 418
 419         if ((mem_base_lo & PCI_PREF_RANGE_TYPE_MASK) == PCI_PREF_RANGE_TYPE_64) {
 420                 u32 mem_base_hi, mem_limit_hi;
 421
 422                 pci_read_config_dword(dev, PCI_PREF_BASE_UPPER32, &mem_base_hi);
 423                 pci_read_config_dword(dev, PCI_PREF_LIMIT_UPPER32, &mem_limit_hi);
 424
 425                 /*
 426                  * Some bridges set the base > limit by default, and some
 427                  * (broken) BIOSes do not initialize them.  If we find
 428                  * this, just assume they are not being used.
 429                  */
 430                 if (mem_base_hi <= mem_limit_hi) {
 431                         base64 |= (u64) mem_base_hi << 32;
 432                         limit64 |= (u64) mem_limit_hi << 32;
 433                 }
 434         }
 435
 436         base = (pci_bus_addr_t) base64;
 437         limit = (pci_bus_addr_t) limit64;
 438
 439         if (base != base64) {
 440                 dev_err(&dev->dev, "can't handle bridge window above 4GB (bus address %#010llx)\n",
 441                         (unsigned long long) base64);
 442                 return;
 443         }
 444
 445         if (base <= limit) {
 446                 res->flags = (mem_base_lo & PCI_PREF_RANGE_TYPE_MASK) |
 447                                          IORESOURCE_MEM | IORESOURCE_PREFETCH;
 448                 if (res->flags & PCI_PREF_RANGE_TYPE_64)
 449                         res->flags |= IORESOURCE_MEM_64;
 450                 region.start = base;
 451                 region.end = limit + 0xfffff;
 452                 pcibios_bus_to_resource(dev->bus, res, &region);
 453                 dev_printk(KERN_DEBUG, &dev->dev, "  bridge window %pR\n", res);
 454         }
 455 }
 456
 457 void pci_read_bridge_bases(struct pci_bus *child)
 458 {
 459         struct pci_dev *dev = child->self;
 460         struct resource *res;
 461         int i;
 462
 463         if (pci_is_root_bus(child))     /* It's a host bus, nothing to read */
 464                 return;
 465
 466         dev_info(&dev->dev, "PCI bridge to %pR%s\n",
 467                  &child->busn_res,
 468                  dev->transparent ? " (subtractive decode)" : "");
 469
 470         pci_bus_remove_resources(child);
 471         for (i = 0; i < PCI_BRIDGE_RESOURCE_NUM; i++)
 472                 child->resource[i] = &dev->resource[PCI_BRIDGE_RESOURCES+i];
 473
 474         pci_read_bridge_io(child);
 475         pci_read_bridge_mmio(child);
 476         pci_read_bridge_mmio_pref(child);
 477
 478         if (dev->transparent) {
 479                 pci_bus_for_each_resource(child->parent, res, i) {
 480                         if (res && res->flags) {
 481                                 pci_bus_add_resource(child, res,
 482                                                      PCI_SUBTRACTIVE_DECODE);
 483                                 dev_printk(KERN_DEBUG, &dev->dev,
 484                                            "  bridge window %pR (subtractive decode)\n",
 485                                            res);
 486                         }
 487                 }
 488         }
 489 }
 490
 491 static struct pci_bus *pci_alloc_bus(struct pci_bus *parent)
 492 {
 493         struct pci_bus *b;
 494
 495         b = kzalloc(sizeof(*b), GFP_KERNEL);
 496         if (!b)
 497                 return NULL;
 498
 499         INIT_LIST_HEAD(&b->node);
 500         INIT_LIST_HEAD(&b->children);
 501         INIT_LIST_HEAD(&b->devices);
 502         INIT_LIST_HEAD(&b->slots);
 503         INIT_LIST_HEAD(&b->resources);
 504         b->max_bus_speed = PCI_SPEED_UNKNOWN;
 505         b->cur_bus_speed = PCI_SPEED_UNKNOWN;
 506 #ifdef CONFIG_PCI_DOMAINS_GENERIC
 507         if (parent)
 508                 b->domain_nr = parent->domain_nr;
 509 #endif
 510         return b;
 511 }
 512
 513 static void devm_pci_release_host_bridge_dev(struct device *dev)
 514 {
 515         struct pci_host_bridge *bridge = to_pci_host_bridge(dev);
 516
 517         if (bridge->release_fn)
 518                 bridge->release_fn(bridge);
 519 }
 520
 521 static void pci_release_host_bridge_dev(struct device *dev)
 522 {
 523         devm_pci_release_host_bridge_dev(dev);
 524         pci_free_host_bridge(to_pci_host_bridge(dev));
 525 }
 526
 527 struct pci_host_bridge *pci_alloc_host_bridge(size_t priv)
 528 {
 529         struct pci_host_bridge *bridge;
 530
 531         bridge = kzalloc(sizeof(*bridge) + priv, GFP_KERNEL);
 532         if (!bridge)
 533                 return NULL;
 534
 535         INIT_LIST_HEAD(&bridge->windows);
 536         bridge->dev.release = pci_release_host_bridge_dev;
 537
 538         return bridge;
 539 }
 540 EXPORT_SYMBOL(pci_alloc_host_bridge);
 541
 542 struct pci_host_bridge *devm_pci_alloc_host_bridge(struct device *dev,
 543                                                    size_t priv)
 544 {
 545         struct pci_host_bridge *bridge;
 546
 547         bridge = devm_kzalloc(dev, sizeof(*bridge) + priv, GFP_KERNEL);
 548         if (!bridge)
 549                 return NULL;
 550
 551         INIT_LIST_HEAD(&bridge->windows);
 552         bridge->dev.release = devm_pci_release_host_bridge_dev;
 553
 554         return bridge;
 555 }
 556 EXPORT_SYMBOL(devm_pci_alloc_host_bridge);
 557
 558 void pci_free_host_bridge(struct pci_host_bridge *bridge)
 559 {
 560         pci_free_resource_list(&bridge->windows);
 561
 562         kfree(bridge);
 563 }
 564 EXPORT_SYMBOL(pci_free_host_bridge);
 565
 566 static const unsigned char pcix_bus_speed[] = {
 567         PCI_SPEED_UNKNOWN,              /* 0 */
 568         PCI_SPEED_66MHz_PCIX,           /* 1 */
 569         PCI_SPEED_100MHz_PCIX,          /* 2 */
 570         PCI_SPEED_133MHz_PCIX,          /* 3 */
 571         PCI_SPEED_UNKNOWN,              /* 4 */
 572         PCI_SPEED_66MHz_PCIX_ECC,       /* 5 */
 573         PCI_SPEED_100MHz_PCIX_ECC,      /* 6 */
 574         PCI_SPEED_133MHz_PCIX_ECC,      /* 7 */
 575         PCI_SPEED_UNKNOWN,              /* 8 */
 576         PCI_SPEED_66MHz_PCIX_266,       /* 9 */
 577         PCI_SPEED_100MHz_PCIX_266,      /* A */
 578         PCI_SPEED_133MHz_PCIX_266,      /* B */
 579         PCI_SPEED_UNKNOWN,              /* C */
 580         PCI_SPEED_66MHz_PCIX_533,       /* D */
 581         PCI_SPEED_100MHz_PCIX_533,      /* E */
 582         PCI_SPEED_133MHz_PCIX_533       /* F */
 583 };
 584
 585 const unsigned char pcie_link_speed[] = {
 586         PCI_SPEED_UNKNOWN,              /* 0 */
 587         PCIE_SPEED_2_5GT,               /* 1 */
 588         PCIE_SPEED_5_0GT,               /* 2 */
 589         PCIE_SPEED_8_0GT,               /* 3 */
 590         PCI_SPEED_UNKNOWN,              /* 4 */
 591         PCI_SPEED_UNKNOWN,              /* 5 */
 592         PCI_SPEED_UNKNOWN,              /* 6 */
 593         PCI_SPEED_UNKNOWN,              /* 7 */
 594         PCI_SPEED_UNKNOWN,              /* 8 */
 595         PCI_SPEED_UNKNOWN,              /* 9 */
 596         PCI_SPEED_UNKNOWN,              /* A */
 597         PCI_SPEED_UNKNOWN,              /* B */
 598         PCI_SPEED_UNKNOWN,              /* C */
 599         PCI_SPEED_UNKNOWN,              /* D */
 600         PCI_SPEED_UNKNOWN,              /* E */
 601         PCI_SPEED_UNKNOWN               /* F */
 602 };
 603
 604 void pcie_update_link_speed(struct pci_bus *bus, u16 linksta)
 605 {
 606         bus->cur_bus_speed = pcie_link_speed[linksta & PCI_EXP_LNKSTA_CLS];
 607 }
 608 EXPORT_SYMBOL_GPL(pcie_update_link_speed);
 609
 610 static unsigned char agp_speeds[] = {
 611         AGP_UNKNOWN,
 612         AGP_1X,
 613         AGP_2X,
 614         AGP_4X,
 615         AGP_8X
 616 };
 617
 618 static enum pci_bus_speed agp_speed(int agp3, int agpstat)
 619 {
 620         int index = 0;
 621
 622         if (agpstat & 4)
 623                 index = 3;
 624         else if (agpstat & 2)
 625                 index = 2;
 626         else if (agpstat & 1)
 627                 index = 1;
 628         else
 629                 goto out;
 630
 631         if (agp3) {
 632                 index += 2;
 633                 if (index == 5)
 634                         index = 0;
 635         }
 636
 637  out:
 638         return agp_speeds[index];
 639 }
 640
 641 static void pci_set_bus_speed(struct pci_bus *bus)
 642 {
 643         struct pci_dev *bridge = bus->self;
 644         int pos;
 645
 646         pos = pci_find_capability(bridge, PCI_CAP_ID_AGP);
 647         if (!pos)
 648                 pos = pci_find_capability(bridge, PCI_CAP_ID_AGP3);
 649         if (pos) {
 650                 u32 agpstat, agpcmd;
 651
 652                 pci_read_config_dword(bridge, pos + PCI_AGP_STATUS, &agpstat);
 653                 bus->max_bus_speed = agp_speed(agpstat & 8, agpstat & 7);
 654
 655                 pci_read_config_dword(bridge, pos + PCI_AGP_COMMAND, &agpcmd);
 656                 bus->cur_bus_speed = agp_speed(agpstat & 8, agpcmd & 7);
 657         }
 658
 659         pos = pci_find_capability(bridge, PCI_CAP_ID_PCIX);
 660         if (pos) {
 661                 u16 status;
 662                 enum pci_bus_speed max;
 663
 664                 pci_read_config_word(bridge, pos + PCI_X_BRIDGE_SSTATUS,
 665                                      &status);
 666
 667                 if (status & PCI_X_SSTATUS_533MHZ) {
 668                         max = PCI_SPEED_133MHz_PCIX_533;
 669                 } else if (status & PCI_X_SSTATUS_266MHZ) {
 670                         max = PCI_SPEED_133MHz_PCIX_266;
 671                 } else if (status & PCI_X_SSTATUS_133MHZ) {
 672                         if ((status & PCI_X_SSTATUS_VERS) == PCI_X_SSTATUS_V2)
 673                                 max = PCI_SPEED_133MHz_PCIX_ECC;
 674                         else
 675                                 max = PCI_SPEED_133MHz_PCIX;
 676                 } else {
 677                         max = PCI_SPEED_66MHz_PCIX;
 678                 }
 679
 680                 bus->max_bus_speed = max;
 681                 bus->cur_bus_speed = pcix_bus_speed[
 682                         (status & PCI_X_SSTATUS_FREQ) >> 6];
 683
 684                 return;
 685         }
 686
 687         if (pci_is_pcie(bridge)) {
 688                 u32 linkcap;
 689                 u16 linksta;
 690
 691                 pcie_capability_read_dword(bridge, PCI_EXP_LNKCAP, &linkcap);
 692                 bus->max_bus_speed = pcie_link_speed[linkcap & PCI_EXP_LNKCAP_SLS];
 693
 694                 pcie_capability_read_word(bridge, PCI_EXP_LNKSTA, &linksta);
 695                 pcie_update_link_speed(bus, linksta);
 696         }
 697 }
 698
 699 static struct irq_domain *pci_host_bridge_msi_domain(struct pci_bus *bus)
 700 {
 701         struct irq_domain *d;
 702
 703         /*
 704          * Any firmware interface that can resolve the msi_domain
 705          * should be called from here.
 706          */
 707         d = pci_host_bridge_of_msi_domain(bus);
 708         if (!d)
 709                 d = pci_host_bridge_acpi_msi_domain(bus);
 710
 711 #ifdef CONFIG_PCI_MSI_IRQ_DOMAIN
 712         /*
 713          * If no IRQ domain was found via the OF tree, try looking it up
 714          * directly through the fwnode_handle.
 715          */
 716         if (!d) {
 717                 struct fwnode_handle *fwnode = pci_root_bus_fwnode(bus);
 718
 719                 if (fwnode)
 720                         d = irq_find_matching_fwnode(fwnode,
 721                                                      DOMAIN_BUS_PCI_MSI);
 722         }
 723 #endif
 724
 725         return d;
 726 }
 727
 728 static void pci_set_bus_msi_domain(struct pci_bus *bus)
 729 {
 730         struct irq_domain *d;
 731         struct pci_bus *b;
 732
 733         /*
 734          * The bus can be a root bus, a subordinate bus, or a virtual bus
 735          * created by an SR-IOV device.  Walk up to the first bridge device
 736          * found or derive the domain from the host bridge.
 737          */
 738         for (b = bus, d = NULL; !d && !pci_is_root_bus(b); b = b->parent) {
 739                 if (b->self)
 740                         d = dev_get_msi_domain(&b->self->dev);
 741         }
 742
 743         if (!d)
 744                 d = pci_host_bridge_msi_domain(b);
 745
 746         dev_set_msi_domain(&bus->dev, d);
 747 }
 748
 749 int pci_register_host_bridge(struct pci_host_bridge *bridge)
 750 {
 751         struct device *parent = bridge->dev.parent;
 752         struct resource_entry *window, *n;
 753         struct pci_bus *bus, *b;
 754         resource_size_t offset;
 755         LIST_HEAD(resources);
 756         struct resource *res;
 757         char addr[64], *fmt;
 758         const char *name;
 759         int err;
 760
 761         bus = pci_alloc_bus(NULL);
 762         if (!bus)
 763                 return -ENOMEM;
 764
 765         bridge->bus = bus;
 766
 767         /* temporarily move resources off the list */
 768         list_splice_init(&bridge->windows, &resources);
 769         bus->sysdata = bridge->sysdata;
 770         bus->msi = bridge->msi;
 771         bus->ops = bridge->ops;
 772         bus->number = bus->busn_res.start = bridge->busnr;
 773 #ifdef CONFIG_PCI_DOMAINS_GENERIC
 774         bus->domain_nr = pci_bus_find_domain_nr(bus, parent);
 775 #endif
 776
 777         b = pci_find_bus(pci_domain_nr(bus), bridge->busnr);
 778         if (b) {
 779                 /* If we already got to this bus through a different bridge, ignore it */
 780                 dev_dbg(&b->dev, "bus already known\n");
 781                 err = -EEXIST;
 782                 goto free;
 783         }
 784
 785         dev_set_name(&bridge->dev, "pci%04x:%02x", pci_domain_nr(bus),
 786                      bridge->busnr);
 787
 788         err = pcibios_root_bridge_prepare(bridge);
 789         if (err)
 790                 goto free;
 791
 792         err = device_register(&bridge->dev);
 793         if (err)
 794                 put_device(&bridge->dev);
 795
 796         bus->bridge = get_device(&bridge->dev);
 797         device_enable_async_suspend(bus->bridge);
 798         pci_set_bus_of_node(bus);
 799         pci_set_bus_msi_domain(bus);
 800
 801         if (!parent)
 802                 set_dev_node(bus->bridge, pcibus_to_node(bus));
 803
 804         bus->dev.class = &pcibus_class;
 805         bus->dev.parent = bus->bridge;
 806
 807         dev_set_name(&bus->dev, "%04x:%02x", pci_domain_nr(bus), bus->number);
 808         name = dev_name(&bus->dev);
 809
 810         err = device_register(&bus->dev);
 811         if (err)
 812                 goto unregister;
 813
 814         pcibios_add_bus(bus);
 815
 816         /* Create legacy_io and legacy_mem files for this bus */
 817         pci_create_legacy_files(bus);
 818
 819         if (parent)
 820                 dev_info(parent, "PCI host bridge to bus %s\n", name);
 821         else
 822                 pr_info("PCI host bridge to bus %s\n", name);
 823
 824         /* Add initial resources to the bus */
 825         resource_list_for_each_entry_safe(window, n, &resources) {
 826                 list_move_tail(&window->node, &bridge->windows);
 827                 offset = window->offset;
 828                 res = window->res;
 829
 830                 if (res->flags & IORESOURCE_BUS)
 831                         pci_bus_insert_busn_res(bus, bus->number, res->end);
 832                 else
 833                         pci_bus_add_resource(bus, res, 0);
 834
 835                 if (offset) {
 836                         if (resource_type(res) == IORESOURCE_IO)
 837                                 fmt = " (bus address [%#06llx-%#06llx])";
 838                         else
 839                                 fmt = " (bus address [%#010llx-%#010llx])";
 840
 841                         snprintf(addr, sizeof(addr), fmt,
 842                                  (unsigned long long)(res->start - offset),
 843                                  (unsigned long long)(res->end - offset));
 844                 } else
 845                         addr[0] = '\0';
 846
 847                 dev_info(&bus->dev, "root bus resource %pR%s\n", res, addr);
 848         }
 849
 850         down_write(&pci_bus_sem);
 851         list_add_tail(&bus->node, &pci_root_buses);
 852         up_write(&pci_bus_sem);
 853
 854         return 0;
 855
 856 unregister:
 857         put_device(&bridge->dev);
 858         device_unregister(&bridge->dev);
 859
 860 free:
 861         kfree(bus);
 862         return err;
 863 }
 864 EXPORT_SYMBOL(pci_register_host_bridge);
 865
 866 static struct pci_bus *pci_alloc_child_bus(struct pci_bus *parent,
 867                                            struct pci_dev *bridge, int busnr)
 868 {
 869         struct pci_bus *child;
 870         int i;
 871         int ret;
 872
 873         /*
 874          * Allocate a new bus, and inherit stuff from the parent..
 875          */
 876         child = pci_alloc_bus(parent);
 877         if (!child)
 878                 return NULL;
 879
 880         child->parent = parent;
 881         child->ops = parent->ops;
 882         child->msi = parent->msi;
 883         child->sysdata = parent->sysdata;
 884         child->bus_flags = parent->bus_flags;
 885
 886         /* initialize some portions of the bus device, but don't register it
 887          * now as the parent is not properly set up yet.
 888          */
 889         child->dev.class = &pcibus_class;
 890         dev_set_name(&child->dev, "%04x:%02x", pci_domain_nr(child), busnr);
 891
 892         /*
 893          * Set up the primary, secondary and subordinate
 894          * bus numbers.
 895          */
 896         child->number = child->busn_res.start = busnr;
 897         child->primary = parent->busn_res.start;
 898         child->busn_res.end = 0xff;
 899
 900         if (!bridge) {
 901                 child->dev.parent = parent->bridge;
 902                 goto add_dev;
 903         }
 904
 905         child->self = bridge;
 906         child->bridge = get_device(&bridge->dev);
 907         child->dev.parent = child->bridge;
 908         pci_set_bus_of_node(child);
 909         pci_set_bus_speed(child);
 910
 911         /* Set up default resource pointers and names.. */
 912         for (i = 0; i < PCI_BRIDGE_RESOURCE_NUM; i++) {
 913                 child->resource[i] = &bridge->resource[PCI_BRIDGE_RESOURCES+i];
 914                 child->resource[i]->name = child->name;
 915         }
 916         bridge->subordinate = child;
 917
 918 add_dev:
 919         pci_set_bus_msi_domain(child);
 920         ret = device_register(&child->dev);
 921         WARN_ON(ret < 0);
 922
 923         pcibios_add_bus(child);
 924
 925         if (child->ops->add_bus) {
 926                 ret = child->ops->add_bus(child);
 927                 if (WARN_ON(ret < 0))
 928                         dev_err(&child->dev, "failed to add bus: %d\n", ret);
 929         }
 930
 931         /* Create legacy_io and legacy_mem files for this bus */
 932         pci_create_legacy_files(child);
 933
 934         return child;
 935 }
 936
 937 struct pci_bus *pci_add_new_bus(struct pci_bus *parent, struct pci_dev *dev,
 938                                 int busnr)
 939 {
 940         struct pci_bus *child;
 941
 942         child = pci_alloc_child_bus(parent, dev, busnr);
 943         if (child) {
 944                 down_write(&pci_bus_sem);
 945                 list_add_tail(&child->node, &parent->children);
 946                 up_write(&pci_bus_sem);
 947         }
 948         return child;
 949 }
 950 EXPORT_SYMBOL(pci_add_new_bus);
 951
 952 static void pci_enable_crs(struct pci_dev *pdev)
 953 {
 954         u16 root_cap = 0;
 955
 956         /* Enable CRS Software Visibility if supported */
 957         pcie_capability_read_word(pdev, PCI_EXP_RTCAP, &root_cap);
 958         if (root_cap & PCI_EXP_RTCAP_CRSVIS)
 959                 pcie_capability_set_word(pdev, PCI_EXP_RTCTL,
 960                                          PCI_EXP_RTCTL_CRSSVE);
 961 }
 962
 963 /*
 964  * If it's a bridge, configure it and scan the bus behind it.
 965  * For CardBus bridges, we don't scan behind as the devices will
 966  * be handled by the bridge driver itself.
 967  *
 968  * We need to process bridges in two passes -- first we scan those
 969  * already configured by the BIOS and after we are done with all of
 970  * them, we proceed to assigning numbers to the remaining buses in
 971  * order to avoid overlaps between old and new bus numbers.
 972  */
 973 int pci_scan_bridge(struct pci_bus *bus, struct pci_dev *dev, int max, int pass)
 974 {
 975         struct pci_bus *child;
 976         int is_cardbus = (dev->hdr_type == PCI_HEADER_TYPE_CARDBUS);
 977         u32 buses, i, j = 0;
 978         u16 bctl;
 979         u8 primary, secondary, subordinate;
 980         int broken = 0;
 981
 982         /*
 983          * Make sure the bridge is powered on to be able to access config
 984          * space of devices below it.
 985          */
 986         pm_runtime_get_sync(&dev->dev);
 987
 988         pci_read_config_dword(dev, PCI_PRIMARY_BUS, &buses);
 989         primary = buses & 0xFF;
 990         secondary = (buses >> 8) & 0xFF;
 991         subordinate = (buses >> 16) & 0xFF;
 992
 993         dev_dbg(&dev->dev, "scanning [bus %02x-%02x] behind bridge, pass %d\n",
 994                 secondary, subordinate, pass);
 995
 996         if (!primary && (primary != bus->number) && secondary && subordinate) {
 997                 dev_warn(&dev->dev, "Primary bus is hard wired to 0\n");
 998                 primary = bus->number;
 999         }
1000
1001         /* Check if setup is sensible at all */
1002         if (!pass &&
1003             (primary != bus->number || secondary <= bus->number ||
1004              secondary > subordinate)) {
1005                 dev_info(&dev->dev, "bridge configuration invalid ([bus %02x-%02x]), reconfiguring\n",
1006                          secondary, subordinate);
1007                 broken = 1;
1008         }
1009
1010         /* Disable MasterAbortMode during probing to avoid reporting
1011            of bus errors (in some architectures) */
1012         pci_read_config_word(dev, PCI_BRIDGE_CONTROL, &bctl);
1013         pci_write_config_word(dev, PCI_BRIDGE_CONTROL,
1014                               bctl & ~PCI_BRIDGE_CTL_MASTER_ABORT);
1015
1016         pci_enable_crs(dev);
1017
1018         if ((secondary || subordinate) && !pcibios_assign_all_busses() &&
1019             !is_cardbus && !broken) {
1020                 unsigned int cmax;
1021                 /*
1022                  * Bus already configured by firmware, process it in the first
1023                  * pass and just note the configuration.
1024                  */
1025                 if (pass)
1026                         goto out;
1027
1028                 /*
1029                  * The bus might already exist for two reasons: Either we are
1030                  * rescanning the bus or the bus is reachable through more than
1031                  * one bridge. The second case can happen with the i450NX
1032                  * chipset.
1033                  */
1034                 child = pci_find_bus(pci_domain_nr(bus), secondary);
1035                 if (!child) {
1036                         child = pci_add_new_bus(bus, dev, secondary);
1037                         if (!child)
1038                                 goto out;
1039                         child->primary = primary;
1040                         pci_bus_insert_busn_res(child, secondary, subordinate);
1041                         child->bridge_ctl = bctl;
1042                 }
1043
1044                 cmax = pci_scan_child_bus(child);
1045                 if (cmax > subordinate)
1046                         dev_warn(&dev->dev, "bridge has subordinate %02x but max busn %02x\n",
1047                                  subordinate, cmax);
1048                 /* subordinate should equal child->busn_res.end */
1049                 if (subordinate > max)
1050                         max = subordinate;
1051         } else {
1052                 /*
1053                  * We need to assign a number to this bus which we always
1054                  * do in the second pass.
1055                  */
1056                 if (!pass) {
1057                         if (pcibios_assign_all_busses() || broken || is_cardbus)
1058                                 /* Temporarily disable forwarding of the
1059                                    configuration cycles on all bridges in
1060                                    this bus segment to avoid possible
1061                                    conflicts in the second pass between two
1062                                    bridges programmed with overlapping
1063                                    bus ranges. */
1064                                 pci_write_config_dword(dev, PCI_PRIMARY_BUS,
1065                                                        buses & ~0xffffff);
1066                         goto out;
1067                 }
1068
1069                 /* Clear errors */
1070                 pci_write_config_word(dev, PCI_STATUS, 0xffff);
1071
1072                 /* Prevent assigning a bus number that already exists.
1073                  * This can happen when a bridge is hot-plugged, so in
1074                  * this case we only re-scan this bus. */
1075                 child = pci_find_bus(pci_domain_nr(bus), max+1);
1076                 if (!child) {
1077                         child = pci_add_new_bus(bus, dev, max+1);
1078                         if (!child)
1079                                 goto out;
1080                         pci_bus_insert_busn_res(child, max+1, 0xff);
1081                 }
1082                 max++;
1083                 buses = (buses & 0xff000000)
1084                       | ((unsigned int)(child->primary)     <<  0)
1085                       | ((unsigned int)(child->busn_res.start)   <<  8)
1086                       | ((unsigned int)(child->busn_res.end) << 16);
1087
1088                 /*
1089                  * yenta.c forces a secondary latency timer of 176.
1090                  * Copy that behaviour here.
1091                  */
1092                 if (is_cardbus) {
1093                         buses &= ~0xff000000;
1094                         buses |= CARDBUS_LATENCY_TIMER << 24;
1095                 }
1096
1097                 /*
1098                  * We need to blast all three values with a single write.
1099                  */
1100                 pci_write_config_dword(dev, PCI_PRIMARY_BUS, buses);
1101
1102                 if (!is_cardbus) {
1103                         child->bridge_ctl = bctl;
1104                         max = pci_scan_child_bus(child);
1105                 } else {
1106                         /*
1107                          * For CardBus bridges, we leave 4 bus numbers
1108                          * as cards with a PCI-to-PCI bridge can be
1109                          * inserted later.
1110                          */
1111                         for (i = 0; i < CARDBUS_RESERVE_BUSNR; i++) {
1112                                 struct pci_bus *parent = bus;
1113                                 if (pci_find_bus(pci_domain_nr(bus),
1114                                                         max+i+1))
1115                                         break;
1116                                 while (parent->parent) {
1117                                         if ((!pcibios_assign_all_busses()) &&
1118                                             (parent->busn_res.end > max) &&
1119                                             (parent->busn_res.end <= max+i)) {
1120                                                 j = 1;
1121                                         }
1122                                         parent = parent->parent;
1123                                 }
1124                                 if (j) {
1125                                         /*
1126                                          * Often, there are two cardbus bridges
1127                                          * -- try to leave one valid bus number
1128                                          * for each one.
1129                                          */
1130                                         i /= 2;
1131                                         break;
1132                                 }
1133                         }
1134                         max += i;
1135                 }
1136                 /*
1137                  * Set the subordinate bus number to its real value.
1138                  */
1139                 pci_bus_update_busn_res_end(child, max);
1140                 pci_write_config_byte(dev, PCI_SUBORDINATE_BUS, max);
1141         }
1142
1143         sprintf(child->name,
1144                 (is_cardbus ? "PCI CardBus %04x:%02x" : "PCI Bus %04x:%02x"),
1145                 pci_domain_nr(bus), child->number);
1146
1147         /* Has only triggered on CardBus, fixup is in yenta_socket */
1148         while (bus->parent) {
1149                 if ((child->busn_res.end > bus->busn_res.end) ||
1150                     (child->number > bus->busn_res.end) ||
1151                     (child->number < bus->number) ||
1152                     (child->busn_res.end < bus->number)) {
1153                         dev_info(&child->dev, "%pR %s hidden behind%s bridge %s %pR\n",
1154                                 &child->busn_res,
1155                                 (bus->number > child->busn_res.end &&
1156                                  bus->busn_res.end < child->number) ?
1157                                         "wholly" : "partially",
1158                                 bus->self->transparent ? " transparent" : "",
1159                                 dev_name(&bus->dev),
1160                                 &bus->busn_res);
1161                 }
1162                 bus = bus->parent;
1163         }
1164
1165 out:
1166         pci_write_config_word(dev, PCI_BRIDGE_CONTROL, bctl);
1167
1168         pm_runtime_put(&dev->dev);
1169
1170         return max;
1171 }
1172 EXPORT_SYMBOL(pci_scan_bridge);
1173
1174 /*
1175  * Read interrupt line and base address registers.
1176  * The architecture-dependent code can tweak these, of course.
1177  */
1178 static void pci_read_irq(struct pci_dev *dev)
1179 {
1180         unsigned char irq;
1181
1182         pci_read_config_byte(dev, PCI_INTERRUPT_PIN, &irq);
1183         dev->pin = irq;
1184         if (irq)
1185                 pci_read_config_byte(dev, PCI_INTERRUPT_LINE, &irq);
1186         dev->irq = irq;
1187 }
1188
1189 void set_pcie_port_type(struct pci_dev *pdev)
1190 {
1191         int pos;
1192         u16 reg16;
1193         int type;
1194         struct pci_dev *parent;
1195
1196         pos = pci_find_capability(pdev, PCI_CAP_ID_EXP);
1197         if (!pos)
1198                 return;
1199
1200         pdev->pcie_cap = pos;
1201         pci_read_config_word(pdev, pos + PCI_EXP_FLAGS, &reg16);
1202         pdev->pcie_flags_reg = reg16;
1203         pci_read_config_word(pdev, pos + PCI_EXP_DEVCAP, &reg16);
1204         pdev->pcie_mpss = reg16 & PCI_EXP_DEVCAP_PAYLOAD;
1205
1206         /*
1207          * A Root Port or a PCI-to-PCIe bridge is always the upstream end
1208          * of a Link.  No PCIe component has two Links.  Two Links are
1209          * connected by a Switch that has a Port on each Link and internal
1210          * logic to connect the two Ports.
1211          */
1212         type = pci_pcie_type(pdev);
1213         if (type == PCI_EXP_TYPE_ROOT_PORT ||
1214             type == PCI_EXP_TYPE_PCIE_BRIDGE)
1215                 pdev->has_secondary_link = 1;
1216         else if (type == PCI_EXP_TYPE_UPSTREAM ||
1217                  type == PCI_EXP_TYPE_DOWNSTREAM) {
1218                 parent = pci_upstream_bridge(pdev);
1219
1220                 /*
1221                  * Usually there's an upstream device (Root Port or Switch
1222                  * Downstream Port), but we can't assume one exists.
1223                  */
1224                 if (parent && !parent->has_secondary_link)
1225                         pdev->has_secondary_link = 1;
1226         }
1227 }
1228
1229 void set_pcie_hotplug_bridge(struct pci_dev *pdev)
1230 {
1231         u32 reg32;
1232
1233         pcie_capability_read_dword(pdev, PCI_EXP_SLTCAP, &reg32);
1234         if (reg32 & PCI_EXP_SLTCAP_HPC)
1235                 pdev->is_hotplug_bridge = 1;
1236 }
1237
1238 static void set_pcie_thunderbolt(struct pci_dev *dev)
1239 {
1240         int vsec = 0;
1241         u32 header;
1242
1243         while ((vsec = pci_find_next_ext_capability(dev, vsec,
1244                                                     PCI_EXT_CAP_ID_VNDR))) {
1245                 pci_read_config_dword(dev, vsec + PCI_VNDR_HEADER, &header);
1246
1247                 /* Is the device part of a Thunderbolt controller? */
1248                 if (dev->vendor == PCI_VENDOR_ID_INTEL &&
1249                     PCI_VNDR_HEADER_ID(header) == PCI_VSEC_ID_INTEL_TBT) {
1250                         dev->is_thunderbolt = 1;
1251                         return;
1252                 }
1253         }
1254 }
1255
1256 /**
1257  * pci_ext_cfg_is_aliased - is ext config space just an alias of std config?
1258  * @dev: PCI device
1259  *
1260  * PCI Express to PCI/PCI-X Bridge Specification, rev 1.0, 4.1.4 says that
1261  * when forwarding a type1 configuration request the bridge must check that
1262  * the extended register address field is zero.  The bridge is not permitted
1263  * to forward the transactions and must handle it as an Unsupported Request.
1264  * Some bridges do not follow this rule and simply drop the extended register
1265  * bits, resulting in the standard config space being aliased, every 256
1266  * bytes across the entire configuration space.  Test for this condition by
1267  * comparing the first dword of each potential alias to the vendor/device ID.
1268  * Known offenders:
1269  *   ASM1083/1085 PCIe-to-PCI Reversible Bridge (1b21:1080, rev 01 & 03)
1270  *   AMD/ATI SBx00 PCI to PCI Bridge (1002:4384, rev 40)
1271  */
1272 static bool pci_ext_cfg_is_aliased(struct pci_dev *dev)
1273 {
1274 #ifdef CONFIG_PCI_QUIRKS
1275         int pos;
1276         u32 header, tmp;
1277
1278         pci_read_config_dword(dev, PCI_VENDOR_ID, &header);
1279
1280         for (pos = PCI_CFG_SPACE_SIZE;
1281              pos < PCI_CFG_SPACE_EXP_SIZE; pos += PCI_CFG_SPACE_SIZE) {
1282                 if (pci_read_config_dword(dev, pos, &tmp) != PCIBIOS_SUCCESSFUL
1283                     || header != tmp)
1284                         return false;
1285         }
1286
1287         return true;
1288 #else
1289         return false;
1290 #endif
1291 }
1292
1293 /**
1294  * pci_cfg_space_size - get the configuration space size of the PCI device.
1295  * @dev: PCI device
1296  *
1297  * Regular PCI devices have 256 bytes, but PCI-X 2 and PCI Express devices
1298  * have 4096 bytes.  Even if the device is capable, that doesn't mean we can
1299  * access it.  Maybe we don't have a way to generate extended config space
1300  * accesses, or the device is behind a reverse Express bridge.  So we try
1301  * reading the dword at 0x100 which must either be 0 or a valid extended
1302  * capability header.
1303  */
1304 static int pci_cfg_space_size_ext(struct pci_dev *dev)
1305 {
1306         u32 status;
1307         int pos = PCI_CFG_SPACE_SIZE;
1308
1309         if (pci_read_config_dword(dev, pos, &status) != PCIBIOS_SUCCESSFUL)
1310                 return PCI_CFG_SPACE_SIZE;
1311         if (status == 0xffffffff || pci_ext_cfg_is_aliased(dev))
1312                 return PCI_CFG_SPACE_SIZE;
1313
1314         return PCI_CFG_SPACE_EXP_SIZE;
1315 }
1316
1317 int pci_cfg_space_size(struct pci_dev *dev)
1318 {
1319         int pos;
1320         u32 status;
1321         u16 class;
1322
1323         class = dev->class >> 8;
1324         if (class == PCI_CLASS_BRIDGE_HOST)
1325                 return pci_cfg_space_size_ext(dev);
1326
1327         if (pci_is_pcie(dev))
1328                 return pci_cfg_space_size_ext(dev);
1329
1330         pos = pci_find_capability(dev, PCI_CAP_ID_PCIX);
1331         if (!pos)
1332                 return PCI_CFG_SPACE_SIZE;
1333
1334         pci_read_config_dword(dev, pos + PCI_X_STATUS, &status);
1335         if (status & (PCI_X_STATUS_266MHZ | PCI_X_STATUS_533MHZ))
1336                 return pci_cfg_space_size_ext(dev);
1337
1338         return PCI_CFG_SPACE_SIZE;
1339 }
1340
1341 #define LEGACY_IO_RESOURCE      (IORESOURCE_IO | IORESOURCE_PCI_FIXED)
1342
1343 static void pci_msi_setup_pci_dev(struct pci_dev *dev)
1344 {
1345         /*
1346          * Disable the MSI hardware to avoid screaming interrupts
1347          * during boot.  This is the power on reset default so
1348          * usually this should be a noop.
1349          */
1350         dev->msi_cap = pci_find_capability(dev, PCI_CAP_ID_MSI);
1351         if (dev->msi_cap)
1352                 pci_msi_set_enable(dev, 0);
1353
1354         dev->msix_cap = pci_find_capability(dev, PCI_CAP_ID_MSIX);
1355         if (dev->msix_cap)
1356                 pci_msix_clear_and_set_ctrl(dev, PCI_MSIX_FLAGS_ENABLE, 0);
1357 }
1358
1359 /**
1360  * pci_setup_device - fill in class and map information of a device
1361  * @dev: the device structure to fill
1362  *
1363  * Initialize the device structure with information about the device's
1364  * vendor,class,memory and IO-space addresses,IRQ lines etc.
1365  * Called at initialisation of the PCI subsystem and by CardBus services.
1366  * Returns 0 on success and negative if unknown type of device (not normal,
1367  * bridge or CardBus).
1368  */
1369 int pci_setup_device(struct pci_dev *dev)
1370 {
1371         u32 class;
1372         u16 cmd;
1373         u8 hdr_type;
1374         int pos = 0;
1375         struct pci_bus_region region;
1376         struct resource *res;
1377
1378         if (pci_read_config_byte(dev, PCI_HEADER_TYPE, &hdr_type))
1379                 return -EIO;
1380
1381         dev->sysdata = dev->bus->sysdata;
1382         dev->dev.parent = dev->bus->bridge;
1383         dev->dev.bus = &pci_bus_type;
1384         dev->hdr_type = hdr_type & 0x7f;
1385         dev->multifunction = !!(hdr_type & 0x80);
1386         dev->error_state = pci_channel_io_normal;
1387         set_pcie_port_type(dev);
1388
1389         pci_dev_assign_slot(dev);
1390         /* Assume 32-bit PCI; let 64-bit PCI cards (which are far rarer)
1391            set this higher, assuming the system even supports it.  */
1392         dev->dma_mask = 0xffffffff;
1393
1394         dev_set_name(&dev->dev, "%04x:%02x:%02x.%d", pci_domain_nr(dev->bus),
1395                      dev->bus->number, PCI_SLOT(dev->devfn),
1396                      PCI_FUNC(dev->devfn));
1397
1398         pci_read_config_dword(dev, PCI_CLASS_REVISION, &class);
1399         dev->revision = class & 0xff;
1400         dev->class = class >> 8;                    /* upper 3 bytes */
1401
1402         dev_printk(KERN_DEBUG, &dev->dev, "[%04x:%04x] type %02x class %#08x\n",
1403                    dev->vendor, dev->device, dev->hdr_type, dev->class);
1404
1405         /* need to have dev->class ready */
1406         dev->cfg_size = pci_cfg_space_size(dev);
1407
1408         /* need to have dev->cfg_size ready */
1409         set_pcie_thunderbolt(dev);
1410
1411         /* "Unknown power state" */
1412         dev->current_state = PCI_UNKNOWN;
1413
1414         /* Early fixups, before probing the BARs */
1415         pci_fixup_device(pci_fixup_early, dev);
1416         /* device class may be changed after fixup */
1417         class = dev->class >> 8;
1418
1419         if (dev->non_compliant_bars) {
1420                 pci_read_config_word(dev, PCI_COMMAND, &cmd);
1421                 if (cmd & (PCI_COMMAND_IO | PCI_COMMAND_MEMORY)) {
1422                         dev_info(&dev->dev, "device has non-compliant BARs; disabling IO/MEM decoding\n");
1423                         cmd &= ~PCI_COMMAND_IO;
1424                         cmd &= ~PCI_COMMAND_MEMORY;
1425                         pci_write_config_word(dev, PCI_COMMAND, cmd);
1426                 }
1427         }
1428
1429         switch (dev->hdr_type) {                    /* header type */
1430         case PCI_HEADER_TYPE_NORMAL:                /* standard header */
1431                 if (class == PCI_CLASS_BRIDGE_PCI)
1432                         goto bad;
1433                 pci_read_irq(dev);
1434                 pci_read_bases(dev, 6, PCI_ROM_ADDRESS);
1435                 pci_read_config_word(dev, PCI_SUBSYSTEM_VENDOR_ID, &dev->subsystem_vendor);
1436                 pci_read_config_word(dev, PCI_SUBSYSTEM_ID, &dev->subsystem_device);
1437
1438                 /*
1439                  * Do the ugly legacy mode stuff here rather than broken chip
1440                  * quirk code. Legacy mode ATA controllers have fixed
1441                  * addresses. These are not always echoed in BAR0-3, and
1442                  * BAR0-3 in a few cases contain junk!
1443                  */
1444                 if (class == PCI_CLASS_STORAGE_IDE) {
1445                         u8 progif;
1446                         pci_read_config_byte(dev, PCI_CLASS_PROG, &progif);
1447                         if ((progif & 1) == 0) {
1448                                 region.start = 0x1F0;
1449                                 region.end = 0x1F7;
1450                                 res = &dev->resource[0];
1451                                 res->flags = LEGACY_IO_RESOURCE;
1452                                 pcibios_bus_to_resource(dev->bus, res, &region);
1453                                 dev_info(&dev->dev, "legacy IDE quirk: reg 0x10: %pR\n",
1454                                          res);
1455                                 region.start = 0x3F6;
1456                                 region.end = 0x3F6;
1457                                 res = &dev->resource[1];
1458                                 res->flags = LEGACY_IO_RESOURCE;
1459                                 pcibios_bus_to_resource(dev->bus, res, &region);
1460                                 dev_info(&dev->dev, "legacy IDE quirk: reg 0x14: %pR\n",
1461                                          res);
1462                         }
1463                         if ((progif & 4) == 0) {
1464                                 region.start = 0x170;
1465                                 region.end = 0x177;
1466                                 res = &dev->resource[2];
1467                                 res->flags = LEGACY_IO_RESOURCE;
1468                                 pcibios_bus_to_resource(dev->bus, res, &region);
1469                                 dev_info(&dev->dev, "legacy IDE quirk: reg 0x18: %pR\n",
1470                                          res);
1471                                 region.start = 0x376;
1472                                 region.end = 0x376;
1473                                 res = &dev->resource[3];
1474                                 res->flags = LEGACY_IO_RESOURCE;
1475                                 pcibios_bus_to_resource(dev->bus, res, &region);
1476                                 dev_info(&dev->dev, "legacy IDE quirk: reg 0x1c: %pR\n",
1477                                          res);
1478                         }
1479                 }
1480                 break;
1481
1482         case PCI_HEADER_TYPE_BRIDGE:                /* bridge header */
1483                 if (class != PCI_CLASS_BRIDGE_PCI)
1484                         goto bad;
1485                 /* The PCI-to-PCI bridge spec requires that subtractive
1486                    decoding (i.e. transparent) bridge must have programming
1487                    interface code of 0x01. */
1488                 pci_read_irq(dev);
1489                 dev->transparent = ((dev->class & 0xff) == 1);
1490                 pci_read_bases(dev, 2, PCI_ROM_ADDRESS1);
1491                 set_pcie_hotplug_bridge(dev);
1492                 pos = pci_find_capability(dev, PCI_CAP_ID_SSVID);
1493                 if (pos) {
1494                         pci_read_config_word(dev, pos + PCI_SSVID_VENDOR_ID, &dev->subsystem_vendor);
1495                         pci_read_config_word(dev, pos + PCI_SSVID_DEVICE_ID, &dev->subsystem_device);
1496                 }
1497                 break;
1498
1499         case PCI_HEADER_TYPE_CARDBUS:               /* CardBus bridge header */
1500                 if (class != PCI_CLASS_BRIDGE_CARDBUS)
1501                         goto bad;
1502                 pci_read_irq(dev);
1503                 pci_read_bases(dev, 1, 0);
1504                 pci_read_config_word(dev, PCI_CB_SUBSYSTEM_VENDOR_ID, &dev->subsystem_vendor);
1505                 pci_read_config_word(dev, PCI_CB_SUBSYSTEM_ID, &dev->subsystem_device);
1506                 break;
1507
1508         default:                                    /* unknown header */
1509                 dev_err(&dev->dev, "unknown header type %02x, ignoring device\n",
1510                         dev->hdr_type);
1511                 return -EIO;
1512
1513         bad:
1514                 dev_err(&dev->dev, "ignoring class %#08x (doesn't match header type %02x)\n",
1515                         dev->class, dev->hdr_type);
1516                 dev->class = PCI_CLASS_NOT_DEFINED << 8;
1517         }
1518
1519         /* We found a fine healthy device, go go go... */
1520         return 0;
1521 }
1522
1523 static void pci_configure_mps(struct pci_dev *dev)
1524 {
1525         struct pci_dev *bridge = pci_upstream_bridge(dev);
1526         int mps, p_mps, rc;
1527
1528         if (!pci_is_pcie(dev) || !bridge || !pci_is_pcie(bridge))
1529                 return;
1530
1531         mps = pcie_get_mps(dev);
1532         p_mps = pcie_get_mps(bridge);
1533
1534         if (mps == p_mps)
1535                 return;
1536
1537         if (pcie_bus_config == PCIE_BUS_TUNE_OFF) {
1538                 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",
1539                          mps, pci_name(bridge), p_mps);
1540                 return;
1541         }
1542
1543         /*
1544          * Fancier MPS configuration is done later by
1545          * pcie_bus_configure_settings()
1546          */
1547         if (pcie_bus_config != PCIE_BUS_DEFAULT)
1548                 return;
1549
1550         rc = pcie_set_mps(dev, p_mps);
1551         if (rc) {
1552                 dev_warn(&dev->dev, "can't set Max Payload Size to %d; if necessary, use \"pci=pcie_bus_safe\" and report a bug\n",
1553                          p_mps);
1554                 return;
1555         }
1556
1557         dev_info(&dev->dev, "Max Payload Size set to %d (was %d, max %d)\n",
1558                  p_mps, mps, 128 << dev->pcie_mpss);
1559 }
1560
1561 static struct hpp_type0 pci_default_type0 = {
1562         .revision = 1,
1563         .cache_line_size = 8,
1564         .latency_timer = 0x40,
1565         .enable_serr = 0,
1566         .enable_perr = 0,
1567 };
1568
1569 static void program_hpp_type0(struct pci_dev *dev, struct hpp_type0 *hpp)
1570 {
1571         u16 pci_cmd, pci_bctl;
1572
1573         if (!hpp)
1574                 hpp = &pci_default_type0;
1575
1576         if (hpp->revision > 1) {
1577                 dev_warn(&dev->dev,
1578                          "PCI settings rev %d not supported; using defaults\n",
1579                          hpp->revision);
1580                 hpp = &pci_default_type0;
1581         }
1582
1583         pci_write_config_byte(dev, PCI_CACHE_LINE_SIZE, hpp->cache_line_size);
1584         pci_write_config_byte(dev, PCI_LATENCY_TIMER, hpp->latency_timer);
1585         pci_read_config_word(dev, PCI_COMMAND, &pci_cmd);
1586         if (hpp->enable_serr)
1587                 pci_cmd |= PCI_COMMAND_SERR;
1588         if (hpp->enable_perr)
1589                 pci_cmd |= PCI_COMMAND_PARITY;
1590         pci_write_config_word(dev, PCI_COMMAND, pci_cmd);
1591
1592         /* Program bridge control value */
1593         if ((dev->class >> 8) == PCI_CLASS_BRIDGE_PCI) {
1594                 pci_write_config_byte(dev, PCI_SEC_LATENCY_TIMER,
1595                                       hpp->latency_timer);
1596                 pci_read_config_word(dev, PCI_BRIDGE_CONTROL, &pci_bctl);
1597                 if (hpp->enable_serr)
1598                         pci_bctl |= PCI_BRIDGE_CTL_SERR;
1599                 if (hpp->enable_perr)
1600                         pci_bctl |= PCI_BRIDGE_CTL_PARITY;
1601                 pci_write_config_word(dev, PCI_BRIDGE_CONTROL, pci_bctl);
1602         }
1603 }
1604
1605 static void program_hpp_type1(struct pci_dev *dev, struct hpp_type1 *hpp)
1606 {
1607         int pos;
1608
1609         if (!hpp)
1610                 return;
1611
1612         pos = pci_find_capability(dev, PCI_CAP_ID_PCIX);
1613         if (!pos)
1614                 return;
1615
1616         dev_warn(&dev->dev, "PCI-X settings not supported\n");
1617 }
1618
1619 static bool pcie_root_rcb_set(struct pci_dev *dev)
1620 {
1621         struct pci_dev *rp = pcie_find_root_port(dev);
1622         u16 lnkctl;
1623
1624         if (!rp)
1625                 return false;
1626
1627         pcie_capability_read_word(rp, PCI_EXP_LNKCTL, &lnkctl);
1628         if (lnkctl & PCI_EXP_LNKCTL_RCB)
1629                 return true;
1630
1631         return false;
1632 }
1633
1634 static void program_hpp_type2(struct pci_dev *dev, struct hpp_type2 *hpp)
1635 {
1636         int pos;
1637         u32 reg32;
1638
1639         if (!hpp)
1640                 return;
1641
1642         if (!pci_is_pcie(dev))
1643                 return;
1644
1645         if (hpp->revision > 1) {
1646                 dev_warn(&dev->dev, "PCIe settings rev %d not supported\n",
1647                          hpp->revision);
1648                 return;
1649         }
1650
1651         /*
1652          * Don't allow _HPX to change MPS or MRRS settings.  We manage
1653          * those to make sure they're consistent with the rest of the
1654          * platform.
1655          */
1656         hpp->pci_exp_devctl_and |= PCI_EXP_DEVCTL_PAYLOAD |
1657                                     PCI_EXP_DEVCTL_READRQ;
1658         hpp->pci_exp_devctl_or &= ~(PCI_EXP_DEVCTL_PAYLOAD |
1659                                     PCI_EXP_DEVCTL_READRQ);
1660
1661         /* Initialize Device Control Register */
1662         pcie_capability_clear_and_set_word(dev, PCI_EXP_DEVCTL,
1663                         ~hpp->pci_exp_devctl_and, hpp->pci_exp_devctl_or);
1664
1665         /* Initialize Link Control Register */
1666         if (pcie_cap_has_lnkctl(dev)) {
1667
1668                 /*
1669                  * If the Root Port supports Read Completion Boundary of
1670                  * 128, set RCB to 128.  Otherwise, clear it.
1671                  */
1672                 hpp->pci_exp_lnkctl_and |= PCI_EXP_LNKCTL_RCB;
1673                 hpp->pci_exp_lnkctl_or &= ~PCI_EXP_LNKCTL_RCB;
1674                 if (pcie_root_rcb_set(dev))
1675                         hpp->pci_exp_lnkctl_or |= PCI_EXP_LNKCTL_RCB;
1676
1677                 pcie_capability_clear_and_set_word(dev, PCI_EXP_LNKCTL,
1678                         ~hpp->pci_exp_lnkctl_and, hpp->pci_exp_lnkctl_or);
1679         }
1680
1681         /* Find Advanced Error Reporting Enhanced Capability */
1682         pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ERR);
1683         if (!pos)
1684                 return;
1685
1686         /* Initialize Uncorrectable Error Mask Register */
1687         pci_read_config_dword(dev, pos + PCI_ERR_UNCOR_MASK, &reg32);
1688         reg32 = (reg32 & hpp->unc_err_mask_and) | hpp->unc_err_mask_or;
1689         pci_write_config_dword(dev, pos + PCI_ERR_UNCOR_MASK, reg32);
1690
1691         /* Initialize Uncorrectable Error Severity Register */
1692         pci_read_config_dword(dev, pos + PCI_ERR_UNCOR_SEVER, &reg32);
1693         reg32 = (reg32 & hpp->unc_err_sever_and) | hpp->unc_err_sever_or;
1694         pci_write_config_dword(dev, pos + PCI_ERR_UNCOR_SEVER, reg32);
1695
1696         /* Initialize Correctable Error Mask Register */
1697         pci_read_config_dword(dev, pos + PCI_ERR_COR_MASK, &reg32);
1698         reg32 = (reg32 & hpp->cor_err_mask_and) | hpp->cor_err_mask_or;
1699         pci_write_config_dword(dev, pos + PCI_ERR_COR_MASK, reg32);
1700
1701         /* Initialize Advanced Error Capabilities and Control Register */
1702         pci_read_config_dword(dev, pos + PCI_ERR_CAP, &reg32);
1703         reg32 = (reg32 & hpp->adv_err_cap_and) | hpp->adv_err_cap_or;
1704         pci_write_config_dword(dev, pos + PCI_ERR_CAP, reg32);
1705
1706         /*
1707          * FIXME: The following two registers are not supported yet.
1708          *
1709          *   o Secondary Uncorrectable Error Severity Register
1710          *   o Secondary Uncorrectable Error Mask Register
1711          */
1712 }
1713
1714 static void pci_configure_extended_tags(struct pci_dev *dev)
1715 {
1716         u32 dev_cap;
1717         int ret;
1718
1719         if (!pci_is_pcie(dev))
1720                 return;
1721
1722         ret = pcie_capability_read_dword(dev, PCI_EXP_DEVCAP, &dev_cap);
1723         if (ret)
1724                 return;
1725
1726         if (dev_cap & PCI_EXP_DEVCAP_EXT_TAG)
1727                 pcie_capability_set_word(dev, PCI_EXP_DEVCTL,
1728                                          PCI_EXP_DEVCTL_EXT_TAG);
1729 }
1730
1731 static void pci_configure_device(struct pci_dev *dev)
1732 {
1733         struct hotplug_params hpp;
1734         int ret;
1735
1736         pci_configure_mps(dev);
1737         pci_configure_extended_tags(dev);
1738
1739         memset(&hpp, 0, sizeof(hpp));
1740         ret = pci_get_hp_params(dev, &hpp);
1741         if (ret)
1742                 return;
1743
1744         program_hpp_type2(dev, hpp.t2);
1745         program_hpp_type1(dev, hpp.t1);
1746         program_hpp_type0(dev, hpp.t0);
1747 }
1748
1749 static void pci_release_capabilities(struct pci_dev *dev)
1750 {
1751         pci_vpd_release(dev);
1752         pci_iov_release(dev);
1753         pci_free_cap_save_buffers(dev);
1754 }
1755
1756 /**
1757  * pci_release_dev - free a pci device structure when all users of it are finished.
1758  * @dev: device that's been disconnected
1759  *
1760  * Will be called only by the device core when all users of this pci device are
1761  * done.
1762  */
1763 static void pci_release_dev(struct device *dev)
1764 {
1765         struct pci_dev *pci_dev;
1766
1767         pci_dev = to_pci_dev(dev);
1768         pci_release_capabilities(pci_dev);
1769         pci_release_of_node(pci_dev);
1770         pcibios_release_device(pci_dev);
1771         pci_bus_put(pci_dev->bus);
1772         kfree(pci_dev->driver_override);
1773         kfree(pci_dev->dma_alias_mask);
1774         kfree(pci_dev);
1775 }
1776
1777 struct pci_dev *pci_alloc_dev(struct pci_bus *bus)
1778 {
1779         struct pci_dev *dev;
1780
1781         dev = kzalloc(sizeof(struct pci_dev), GFP_KERNEL);
1782         if (!dev)
1783                 return NULL;
1784
1785         INIT_LIST_HEAD(&dev->bus_list);
1786         dev->dev.type = &pci_dev_type;
1787         dev->bus = pci_bus_get(bus);
1788
1789         return dev;
1790 }
1791 EXPORT_SYMBOL(pci_alloc_dev);
1792
1793 bool pci_bus_read_dev_vendor_id(struct pci_bus *bus, int devfn, u32 *l,
1794                                 int crs_timeout)
1795 {
1796         int delay = 1;
1797
1798         if (pci_bus_read_config_dword(bus, devfn, PCI_VENDOR_ID, l))
1799                 return false;
1800
1801         /* some broken boards return 0 or ~0 if a slot is empty: */
1802         if (*l == 0xffffffff || *l == 0x00000000 ||
1803             *l == 0x0000ffff || *l == 0xffff0000)
1804                 return false;
1805
1806         /*
1807          * Configuration Request Retry Status.  Some root ports return the
1808          * actual device ID instead of the synthetic ID (0xFFFF) required
1809          * by the PCIe spec.  Ignore the device ID and only check for
1810          * (vendor id == 1).
1811          */
1812         while ((*l & 0xffff) == 0x0001) {
1813                 if (!crs_timeout)
1814                         return false;
1815
1816                 msleep(delay);
1817                 delay *= 2;
1818                 if (pci_bus_read_config_dword(bus, devfn, PCI_VENDOR_ID, l))
1819                         return false;
1820                 /* Card hasn't responded in 60 seconds?  Must be stuck. */
1821                 if (delay > crs_timeout) {
1822                         printk(KERN_WARNING "pci %04x:%02x:%02x.%d: not responding\n",
1823                                pci_domain_nr(bus), bus->number, PCI_SLOT(devfn),
1824                                PCI_FUNC(devfn));
1825                         return false;
1826                 }
1827         }
1828
1829         return true;
1830 }
1831 EXPORT_SYMBOL(pci_bus_read_dev_vendor_id);
1832
1833 /*
1834  * Read the config data for a PCI device, sanity-check it
1835  * and fill in the dev structure...
1836  */
1837 static struct pci_dev *pci_scan_device(struct pci_bus *bus, int devfn)
1838 {
1839         struct pci_dev *dev;
1840         u32 l;
1841
1842         if (!pci_bus_read_dev_vendor_id(bus, devfn, &l, 60*1000))
1843                 return NULL;
1844
1845         dev = pci_alloc_dev(bus);
1846         if (!dev)
1847                 return NULL;
1848
1849         dev->devfn = devfn;
1850         dev->vendor = l & 0xffff;
1851         dev->device = (l >> 16) & 0xffff;
1852
1853         pci_set_of_node(dev);
1854
1855         if (pci_setup_device(dev)) {
1856                 pci_bus_put(dev->bus);
1857                 kfree(dev);
1858                 return NULL;
1859         }
1860
1861         return dev;
1862 }
1863
1864 static void pci_init_capabilities(struct pci_dev *dev)
1865 {
1866         /* Enhanced Allocation */
1867         pci_ea_init(dev);
1868
1869         /* Setup MSI caps & disable MSI/MSI-X interrupts */
1870         pci_msi_setup_pci_dev(dev);
1871
1872         /* Buffers for saving PCIe and PCI-X capabilities */
1873         pci_allocate_cap_save_buffers(dev);
1874
1875         /* Power Management */
1876         pci_pm_init(dev);
1877
1878         /* Vital Product Data */
1879         pci_vpd_init(dev);
1880
1881         /* Alternative Routing-ID Forwarding */
1882         pci_configure_ari(dev);
1883
1884         /* Single Root I/O Virtualization */
1885         pci_iov_init(dev);
1886
1887         /* Address Translation Services */
1888         pci_ats_init(dev);
1889
1890         /* Enable ACS P2P upstream forwarding */
1891         pci_enable_acs(dev);
1892
1893         /* Precision Time Measurement */
1894         pci_ptm_init(dev);
1895
1896         /* Advanced Error Reporting */
1897         pci_aer_init(dev);
1898 }
1899
1900 /*
1901  * This is the equivalent of pci_host_bridge_msi_domain that acts on
1902  * devices. Firmware interfaces that can select the MSI domain on a
1903  * per-device basis should be called from here.
1904  */
1905 static struct irq_domain *pci_dev_msi_domain(struct pci_dev *dev)
1906 {
1907         struct irq_domain *d;
1908
1909         /*
1910          * If a domain has been set through the pcibios_add_device
1911          * callback, then this is the one (platform code knows best).
1912          */
1913         d = dev_get_msi_domain(&dev->dev);
1914         if (d)
1915                 return d;
1916
1917         /*
1918          * Let's see if we have a firmware interface able to provide
1919          * the domain.
1920          */
1921         d = pci_msi_get_device_domain(dev);
1922         if (d)
1923                 return d;
1924
1925         return NULL;
1926 }
1927
1928 static void pci_set_msi_domain(struct pci_dev *dev)
1929 {
1930         struct irq_domain *d;
1931
1932         /*
1933          * If the platform or firmware interfaces cannot supply a
1934          * device-specific MSI domain, then inherit the default domain
1935          * from the host bridge itself.
1936          */
1937         d = pci_dev_msi_domain(dev);
1938         if (!d)
1939                 d = dev_get_msi_domain(&dev->bus->dev);
1940
1941         dev_set_msi_domain(&dev->dev, d);
1942 }
1943
1944 void pci_device_add(struct pci_dev *dev, struct pci_bus *bus)
1945 {
1946         int ret;
1947
1948         pci_configure_device(dev);
1949
1950         device_initialize(&dev->dev);
1951         dev->dev.release = pci_release_dev;
1952
1953         set_dev_node(&dev->dev, pcibus_to_node(bus));
1954         dev->dev.dma_mask = &dev->dma_mask;
1955         dev->dev.dma_parms = &dev->dma_parms;
1956         dev->dev.coherent_dma_mask = 0xffffffffull;
1957
1958         pci_set_dma_max_seg_size(dev, 65536);
1959         pci_set_dma_seg_boundary(dev, 0xffffffff);
1960
1961         /* Fix up broken headers */
1962         pci_fixup_device(pci_fixup_header, dev);
1963
1964         /* moved out from quirk header fixup code */
1965         pci_reassigndev_resource_alignment(dev);
1966
1967         /* Clear the state_saved flag. */
1968         dev->state_saved = false;
1969
1970         /* Initialize various capabilities */
1971         pci_init_capabilities(dev);
1972
1973         /*
1974          * Add the device to our list of discovered devices
1975          * and the bus list for fixup functions, etc.
1976          */
1977         down_write(&pci_bus_sem);
1978         list_add_tail(&dev->bus_list, &bus->devices);
1979         up_write(&pci_bus_sem);
1980
1981         ret = pcibios_add_device(dev);
1982         WARN_ON(ret < 0);
1983
1984         /* Setup MSI irq domain */
1985         pci_set_msi_domain(dev);
1986
1987         /* Notifier could use PCI capabilities */
1988         dev->match_driver = false;
1989         ret = device_add(&dev->dev);
1990         WARN_ON(ret < 0);
1991 }
1992
1993 struct pci_dev *pci_scan_single_device(struct pci_bus *bus, int devfn)
1994 {
1995         struct pci_dev *dev;
1996
1997         dev = pci_get_slot(bus, devfn);
1998         if (dev) {
1999                 pci_dev_put(dev);
2000                 return dev;
2001         }
2002
2003         dev = pci_scan_device(bus, devfn);
2004         if (!dev)
2005                 return NULL;
2006
2007         pci_device_add(dev, bus);
2008
2009         return dev;
2010 }
2011 EXPORT_SYMBOL(pci_scan_single_device);
2012
2013 static unsigned next_fn(struct pci_bus *bus, struct pci_dev *dev, unsigned fn)
2014 {
2015         int pos;
2016         u16 cap = 0;
2017         unsigned next_fn;
2018
2019         if (pci_ari_enabled(bus)) {
2020                 if (!dev)
2021                         return 0;
2022                 pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ARI);
2023                 if (!pos)
2024                         return 0;
2025
2026                 pci_read_config_word(dev, pos + PCI_ARI_CAP, &cap);
2027                 next_fn = PCI_ARI_CAP_NFN(cap);
2028                 if (next_fn <= fn)
2029                         return 0;       /* protect against malformed list */
2030
2031                 return next_fn;
2032         }
2033
2034         /* dev may be NULL for non-contiguous multifunction devices */
2035         if (!dev || dev->multifunction)
2036                 return (fn + 1) % 8;
2037
2038         return 0;
2039 }
2040
2041 static int only_one_child(struct pci_bus *bus)
2042 {
2043         struct pci_dev *parent = bus->self;
2044
2045         if (!parent || !pci_is_pcie(parent))
2046                 return 0;
2047         if (pci_pcie_type(parent) == PCI_EXP_TYPE_ROOT_PORT)
2048                 return 1;
2049
2050         /*
2051          * PCIe downstream ports are bridges that normally lead to only a
2052          * device 0, but if PCI_SCAN_ALL_PCIE_DEVS is set, scan all
2053          * possible devices, not just device 0.  See PCIe spec r3.0,
2054          * sec 7.3.1.
2055          */
2056         if (parent->has_secondary_link &&
2057             !pci_has_flag(PCI_SCAN_ALL_PCIE_DEVS))
2058                 return 1;
2059         return 0;
2060 }
2061
2062 /**
2063  * pci_scan_slot - scan a PCI slot on a bus for devices.
2064  * @bus: PCI bus to scan
2065  * @devfn: slot number to scan (must have zero function.)
2066  *
2067  * Scan a PCI slot on the specified PCI bus for devices, adding
2068  * discovered devices to the @bus->devices list.  New devices
2069  * will not have is_added set.
2070  *
2071  * Returns the number of new devices found.
2072  */
2073 int pci_scan_slot(struct pci_bus *bus, int devfn)
2074 {
2075         unsigned fn, nr = 0;
2076         struct pci_dev *dev;
2077
2078         if (only_one_child(bus) && (devfn > 0))
2079                 return 0; /* Already scanned the entire slot */
2080
2081         dev = pci_scan_single_device(bus, devfn);
2082         if (!dev)
2083                 return 0;
2084         if (!dev->is_added)
2085                 nr++;
2086
2087         for (fn = next_fn(bus, dev, 0); fn > 0; fn = next_fn(bus, dev, fn)) {
2088                 dev = pci_scan_single_device(bus, devfn + fn);
2089                 if (dev) {
2090                         if (!dev->is_added)
2091                                 nr++;
2092                         dev->multifunction = 1;
2093                 }
2094         }
2095
2096         /* only one slot has pcie device */
2097         if (bus->self && nr)
2098                 pcie_aspm_init_link_state(bus->self);
2099
2100         return nr;
2101 }
2102 EXPORT_SYMBOL(pci_scan_slot);
2103
2104 static int pcie_find_smpss(struct pci_dev *dev, void *data)
2105 {
2106         u8 *smpss = data;
2107
2108         if (!pci_is_pcie(dev))
2109                 return 0;
2110
2111         /*
2112          * We don't have a way to change MPS settings on devices that have
2113          * drivers attached.  A hot-added device might support only the minimum
2114          * MPS setting (MPS=128).  Therefore, if the fabric contains a bridge
2115          * where devices may be hot-added, we limit the fabric MPS to 128 so
2116          * hot-added devices will work correctly.
2117          *
2118          * However, if we hot-add a device to a slot directly below a Root
2119          * Port, it's impossible for there to be other existing devices below
2120          * the port.  We don't limit the MPS in this case because we can
2121          * reconfigure MPS on both the Root Port and the hot-added device,
2122          * and there are no other devices involved.
2123          *
2124          * Note that this PCIE_BUS_SAFE path assumes no peer-to-peer DMA.
2125          */
2126         if (dev->is_hotplug_bridge &&
2127             pci_pcie_type(dev) != PCI_EXP_TYPE_ROOT_PORT)
2128                 *smpss = 0;
2129
2130         if (*smpss > dev->pcie_mpss)
2131                 *smpss = dev->pcie_mpss;
2132
2133         return 0;
2134 }
2135
2136 static void pcie_write_mps(struct pci_dev *dev, int mps)
2137 {
2138         int rc;
2139
2140         if (pcie_bus_config == PCIE_BUS_PERFORMANCE) {
2141                 mps = 128 << dev->pcie_mpss;
2142
2143                 if (pci_pcie_type(dev) != PCI_EXP_TYPE_ROOT_PORT &&
2144                     dev->bus->self)
2145                         /* For "Performance", the assumption is made that
2146                          * downstream communication will never be larger than
2147                          * the MRRS.  So, the MPS only needs to be configured
2148                          * for the upstream communication.  This being the case,
2149                          * walk from the top down and set the MPS of the child
2150                          * to that of the parent bus.
2151                          *
2152                          * Configure the device MPS with the smaller of the
2153                          * device MPSS or the bridge MPS (which is assumed to be
2154                          * properly configured at this point to the largest
2155                          * allowable MPS based on its parent bus).
2156                          */
2157                         mps = min(mps, pcie_get_mps(dev->bus->self));
2158         }
2159
2160         rc = pcie_set_mps(dev, mps);
2161         if (rc)
2162                 dev_err(&dev->dev, "Failed attempting to set the MPS\n");
2163 }
2164
2165 static void pcie_write_mrrs(struct pci_dev *dev)
2166 {
2167         int rc, mrrs;
2168
2169         /* In the "safe" case, do not configure the MRRS.  There appear to be
2170          * issues with setting MRRS to 0 on a number of devices.
2171          */
2172         if (pcie_bus_config != PCIE_BUS_PERFORMANCE)
2173                 return;
2174
2175         /* For Max performance, the MRRS must be set to the largest supported
2176          * value.  However, it cannot be configured larger than the MPS the
2177          * device or the bus can support.  This should already be properly
2178          * configured by a prior call to pcie_write_mps.
2179          */
2180         mrrs = pcie_get_mps(dev);
2181
2182         /* MRRS is a R/W register.  Invalid values can be written, but a
2183          * subsequent read will verify if the value is acceptable or not.
2184          * If the MRRS value provided is not acceptable (e.g., too large),
2185          * shrink the value until it is acceptable to the HW.
2186          */
2187         while (mrrs != pcie_get_readrq(dev) && mrrs >= 128) {
2188                 rc = pcie_set_readrq(dev, mrrs);
2189                 if (!rc)
2190                         break;
2191
2192                 dev_warn(&dev->dev, "Failed attempting to set the MRRS\n");
2193                 mrrs /= 2;
2194         }
2195
2196         if (mrrs < 128)
2197                 dev_err(&dev->dev, "MRRS was unable to be configured with a safe value.  If problems are experienced, try running with pci=pcie_bus_safe\n");
2198 }
2199
2200 static int pcie_bus_configure_set(struct pci_dev *dev, void *data)
2201 {
2202         int mps, orig_mps;
2203
2204         if (!pci_is_pcie(dev))
2205                 return 0;
2206
2207         if (pcie_bus_config == PCIE_BUS_TUNE_OFF ||
2208             pcie_bus_config == PCIE_BUS_DEFAULT)
2209                 return 0;
2210
2211         mps = 128 << *(u8 *)data;
2212         orig_mps = pcie_get_mps(dev);
2213
2214         pcie_write_mps(dev, mps);
2215         pcie_write_mrrs(dev);
2216
2217         dev_info(&dev->dev, "Max Payload Size set to %4d/%4d (was %4d), Max Read Rq %4d\n",
2218                  pcie_get_mps(dev), 128 << dev->pcie_mpss,
2219                  orig_mps, pcie_get_readrq(dev));
2220
2221         return 0;
2222 }
2223
2224 /* pcie_bus_configure_settings requires that pci_walk_bus work in a top-down,
2225  * parents then children fashion.  If this changes, then this code will not
2226  * work as designed.
2227  */
2228 void pcie_bus_configure_settings(struct pci_bus *bus)
2229 {
2230         u8 smpss = 0;
2231
2232         if (!bus->self)
2233                 return;
2234
2235         if (!pci_is_pcie(bus->self))
2236                 return;
2237
2238         /* FIXME - Peer to peer DMA is possible, though the endpoint would need
2239          * to be aware of the MPS of the destination.  To work around this,
2240          * simply force the MPS of the entire system to the smallest possible.
2241          */
2242         if (pcie_bus_config == PCIE_BUS_PEER2PEER)
2243                 smpss = 0;
2244
2245         if (pcie_bus_config == PCIE_BUS_SAFE) {
2246                 smpss = bus->self->pcie_mpss;
2247
2248                 pcie_find_smpss(bus->self, &smpss);
2249                 pci_walk_bus(bus, pcie_find_smpss, &smpss);
2250         }
2251
2252         pcie_bus_configure_set(bus->self, &smpss);
2253         pci_walk_bus(bus, pcie_bus_configure_set, &smpss);
2254 }
2255 EXPORT_SYMBOL_GPL(pcie_bus_configure_settings);
2256
2257 unsigned int pci_scan_child_bus(struct pci_bus *bus)
2258 {
2259         unsigned int devfn, pass, max = bus->busn_res.start;
2260         struct pci_dev *dev;
2261
2262         dev_dbg(&bus->dev, "scanning bus\n");
2263
2264         /* Go find them, Rover! */
2265         for (devfn = 0; devfn < 0x100; devfn += 8)
2266                 pci_scan_slot(bus, devfn);
2267
2268         /* Reserve buses for SR-IOV capability. */
2269         max += pci_iov_bus_range(bus);
2270
2271         /*
2272          * After performing arch-dependent fixup of the bus, look behind
2273          * all PCI-to-PCI bridges on this bus.
2274          */
2275         if (!bus->is_added) {
2276                 dev_dbg(&bus->dev, "fixups for bus\n");
2277                 pcibios_fixup_bus(bus);
2278                 bus->is_added = 1;
2279         }
2280
2281         for (pass = 0; pass < 2; pass++)
2282                 list_for_each_entry(dev, &bus->devices, bus_list) {
2283                         if (pci_is_bridge(dev))
2284                                 max = pci_scan_bridge(bus, dev, max, pass);
2285                 }
2286
2287         /*
2288          * Make sure a hotplug bridge has at least the minimum requested
2289          * number of buses.
2290          */
2291         if (bus->self && bus->self->is_hotplug_bridge && pci_hotplug_bus_size) {
2292                 if (max - bus->busn_res.start < pci_hotplug_bus_size - 1)
2293                         max = bus->busn_res.start + pci_hotplug_bus_size - 1;
2294         }
2295
2296         /*
2297          * We've scanned the bus and so we know all about what's on
2298          * the other side of any bridges that may be on this bus plus
2299          * any devices.
2300          *
2301          * Return how far we've got finding sub-buses.
2302          */
2303         dev_dbg(&bus->dev, "bus scan returning with max=%02x\n", max);
2304         return max;
2305 }
2306 EXPORT_SYMBOL_GPL(pci_scan_child_bus);
2307
2308 /**
2309  * pcibios_root_bridge_prepare - Platform-specific host bridge setup.
2310  * @bridge: Host bridge to set up.
2311  *
2312  * Default empty implementation.  Replace with an architecture-specific setup
2313  * routine, if necessary.
2314  */
2315 int __weak pcibios_root_bridge_prepare(struct pci_host_bridge *bridge)
2316 {
2317         return 0;
2318 }
2319
2320 void __weak pcibios_add_bus(struct pci_bus *bus)
2321 {
2322 }
2323
2324 void __weak pcibios_remove_bus(struct pci_bus *bus)
2325 {
2326 }
2327
2328 static struct pci_bus *pci_create_root_bus_msi(struct device *parent,
2329                 int bus, struct pci_ops *ops, void *sysdata,
2330                 struct list_head *resources, struct msi_controller *msi)
2331 {
2332         int error;
2333         struct pci_host_bridge *bridge;
2334
2335         bridge = pci_alloc_host_bridge(0);
2336         if (!bridge)
2337                 return NULL;
2338
2339         bridge->dev.parent = parent;
2340
2341         list_splice_init(resources, &bridge->windows);
2342         bridge->sysdata = sysdata;
2343         bridge->busnr = bus;
2344         bridge->ops = ops;
2345         bridge->msi = msi;
2346
2347         error = pci_register_host_bridge(bridge);
2348         if (error < 0)
2349                 goto err_out;
2350
2351         return bridge->bus;
2352
2353 err_out:
2354         kfree(bridge);
2355         return NULL;
2356 }
2357
2358 struct pci_bus *pci_create_root_bus(struct device *parent, int bus,
2359                 struct pci_ops *ops, void *sysdata, struct list_head *resources)
2360 {
2361         return pci_create_root_bus_msi(parent, bus, ops, sysdata, resources,
2362                                        NULL);
2363 }
2364 EXPORT_SYMBOL_GPL(pci_create_root_bus);
2365
2366 int pci_bus_insert_busn_res(struct pci_bus *b, int bus, int bus_max)
2367 {
2368         struct resource *res = &b->busn_res;
2369         struct resource *parent_res, *conflict;
2370
2371         res->start = bus;
2372         res->end = bus_max;
2373         res->flags = IORESOURCE_BUS;
2374
2375         if (!pci_is_root_bus(b))
2376                 parent_res = &b->parent->busn_res;
2377         else {
2378                 parent_res = get_pci_domain_busn_res(pci_domain_nr(b));
2379                 res->flags |= IORESOURCE_PCI_FIXED;
2380         }
2381
2382         conflict = request_resource_conflict(parent_res, res);
2383
2384         if (conflict)
2385                 dev_printk(KERN_DEBUG, &b->dev,
2386                            "busn_res: can not insert %pR under %s%pR (conflicts with %s %pR)\n",
2387                             res, pci_is_root_bus(b) ? "domain " : "",
2388                             parent_res, conflict->name, conflict);
2389
2390         return conflict == NULL;
2391 }
2392
2393 int pci_bus_update_busn_res_end(struct pci_bus *b, int bus_max)
2394 {
2395         struct resource *res = &b->busn_res;
2396         struct resource old_res = *res;
2397         resource_size_t size;
2398         int ret;
2399
2400         if (res->start > bus_max)
2401                 return -EINVAL;
2402
2403         size = bus_max - res->start + 1;
2404         ret = adjust_resource(res, res->start, size);
2405         dev_printk(KERN_DEBUG, &b->dev,
2406                         "busn_res: %pR end %s updated to %02x\n",
2407                         &old_res, ret ? "can not be" : "is", bus_max);
2408
2409         if (!ret && !res->parent)
2410                 pci_bus_insert_busn_res(b, res->start, res->end);
2411
2412         return ret;
2413 }
2414
2415 void pci_bus_release_busn_res(struct pci_bus *b)
2416 {
2417         struct resource *res = &b->busn_res;
2418         int ret;
2419
2420         if (!res->flags || !res->parent)
2421                 return;
2422
2423         ret = release_resource(res);
2424         dev_printk(KERN_DEBUG, &b->dev,
2425                         "busn_res: %pR %s released\n",
2426                         res, ret ? "can not be" : "is");
2427 }
2428
2429 int pci_scan_root_bus_bridge(struct pci_host_bridge *bridge)
2430 {
2431         struct resource_entry *window;
2432         bool found = false;
2433         struct pci_bus *b;
2434         int max, bus, ret;
2435
2436         if (!bridge)
2437                 return -EINVAL;
2438
2439         resource_list_for_each_entry(window, &bridge->windows)
2440                 if (window->res->flags & IORESOURCE_BUS) {
2441                         found = true;
2442                         break;
2443                 }
2444
2445         ret = pci_register_host_bridge(bridge);
2446         if (ret < 0)
2447                 return ret;
2448
2449         b = bridge->bus;
2450         bus = bridge->busnr;
2451
2452         if (!found) {
2453                 dev_info(&b->dev,
2454                  "No busn resource found for root bus, will use [bus %02x-ff]\n",
2455                         bus);
2456                 pci_bus_insert_busn_res(b, bus, 255);
2457         }
2458
2459         max = pci_scan_child_bus(b);
2460
2461         if (!found)
2462                 pci_bus_update_busn_res_end(b, max);
2463
2464         return 0;
2465 }
2466 EXPORT_SYMBOL(pci_scan_root_bus_bridge);
2467
2468 struct pci_bus *pci_scan_root_bus_msi(struct device *parent, int bus,
2469                 struct pci_ops *ops, void *sysdata,
2470                 struct list_head *resources, struct msi_controller *msi)
2471 {
2472         struct resource_entry *window;
2473         bool found = false;
2474         struct pci_bus *b;
2475         int max;
2476
2477         resource_list_for_each_entry(window, resources)
2478                 if (window->res->flags & IORESOURCE_BUS) {
2479                         found = true;
2480                         break;
2481                 }
2482
2483         b = pci_create_root_bus_msi(parent, bus, ops, sysdata, resources, msi);
2484         if (!b)
2485                 return NULL;
2486
2487         if (!found) {
2488                 dev_info(&b->dev,
2489                  "No busn resource found for root bus, will use [bus %02x-ff]\n",
2490                         bus);
2491                 pci_bus_insert_busn_res(b, bus, 255);
2492         }
2493
2494         max = pci_scan_child_bus(b);
2495
2496         if (!found)
2497                 pci_bus_update_busn_res_end(b, max);
2498
2499         return b;
2500 }
2501
2502 struct pci_bus *pci_scan_root_bus(struct device *parent, int bus,
2503                 struct pci_ops *ops, void *sysdata, struct list_head *resources)
2504 {
2505         return pci_scan_root_bus_msi(parent, bus, ops, sysdata, resources,
2506                                      NULL);
2507 }
2508 EXPORT_SYMBOL(pci_scan_root_bus);
2509
2510 struct pci_bus *pci_scan_bus(int bus, struct pci_ops *ops,
2511                                         void *sysdata)
2512 {
2513         LIST_HEAD(resources);
2514         struct pci_bus *b;
2515
2516         pci_add_resource(&resources, &ioport_resource);
2517         pci_add_resource(&resources, &iomem_resource);
2518         pci_add_resource(&resources, &busn_resource);
2519         b = pci_create_root_bus(NULL, bus, ops, sysdata, &resources);
2520         if (b) {
2521                 pci_scan_child_bus(b);
2522         } else {
2523                 pci_free_resource_list(&resources);
2524         }
2525         return b;
2526 }
2527 EXPORT_SYMBOL(pci_scan_bus);
2528
2529 /**
2530  * pci_rescan_bus_bridge_resize - scan a PCI bus for devices.
2531  * @bridge: PCI bridge for the bus to scan
2532  *
2533  * Scan a PCI bus and child buses for new devices, add them,
2534  * and enable them, resizing bridge mmio/io resource if necessary
2535  * and possible.  The caller must ensure the child devices are already
2536  * removed for resizing to occur.
2537  *
2538  * Returns the max number of subordinate bus discovered.
2539  */
2540 unsigned int pci_rescan_bus_bridge_resize(struct pci_dev *bridge)
2541 {
2542         unsigned int max;
2543         struct pci_bus *bus = bridge->subordinate;
2544
2545         max = pci_scan_child_bus(bus);
2546
2547         pci_assign_unassigned_bridge_resources(bridge);
2548
2549         pci_bus_add_devices(bus);
2550
2551         return max;
2552 }
2553
2554 /**
2555  * pci_rescan_bus - scan a PCI bus for devices.
2556  * @bus: PCI bus to scan
2557  *
2558  * Scan a PCI bus and child buses for new devices, adds them,
2559  * and enables them.
2560  *
2561  * Returns the max number of subordinate bus discovered.
2562  */
2563 unsigned int pci_rescan_bus(struct pci_bus *bus)
2564 {
2565         unsigned int max;
2566
2567         max = pci_scan_child_bus(bus);
2568         pci_assign_unassigned_bus_resources(bus);
2569         pci_bus_add_devices(bus);
2570
2571         return max;
2572 }
2573 EXPORT_SYMBOL_GPL(pci_rescan_bus);
2574
2575 /*
2576  * pci_rescan_bus(), pci_rescan_bus_bridge_resize() and PCI device removal
2577  * routines should always be executed under this mutex.
2578  */
2579 static DEFINE_MUTEX(pci_rescan_remove_lock);
2580
2581 void pci_lock_rescan_remove(void)
2582 {
2583         mutex_lock(&pci_rescan_remove_lock);
2584 }
2585 EXPORT_SYMBOL_GPL(pci_lock_rescan_remove);
2586
2587 void pci_unlock_rescan_remove(void)
2588 {
2589         mutex_unlock(&pci_rescan_remove_lock);
2590 }
2591 EXPORT_SYMBOL_GPL(pci_unlock_rescan_remove);
2592
2593 static int __init pci_sort_bf_cmp(const struct device *d_a,
2594                                   const struct device *d_b)
2595 {
2596         const struct pci_dev *a = to_pci_dev(d_a);
2597         const struct pci_dev *b = to_pci_dev(d_b);
2598
2599         if      (pci_domain_nr(a->bus) < pci_domain_nr(b->bus)) return -1;
2600         else if (pci_domain_nr(a->bus) > pci_domain_nr(b->bus)) return  1;
2601
2602         if      (a->bus->number < b->bus->number) return -1;
2603         else if (a->bus->number > b->bus->number) return  1;
2604
2605         if      (a->devfn < b->devfn) return -1;
2606         else if (a->devfn > b->devfn) return  1;
2607
2608         return 0;
2609 }
2610
2611 void __init pci_sort_breadthfirst(void)
2612 {
2613         bus_sort_breadthfirst(&pci_bus_type, &pci_sort_bf_cmp);
2614 }