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