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