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