drivers/pci/probe.c

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