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