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