SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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 <acpi/acpi_hest.h>
  14 #include "pci.h"
  15
  16 #define CARDBUS_LATENCY_TIMER   176     /* secondary latency timer */
  17 #define CARDBUS_RESERVE_BUSNR   3
  18
  19 /* Ugh.  Need to stop exporting this to modules. */
  20 LIST_HEAD(pci_root_buses);
  21 EXPORT_SYMBOL(pci_root_buses);
  22
  23
  24 static int find_anything(struct device *dev, void *data)
  25 {
  26         return 1;
  27 }
  28
  29 /*
  30  * Some device drivers need know if pci is initiated.
  31  * Basically, we think pci is not initiated when there
  32  * is no device to be found on the pci_bus_type.
  33  */
  34 int no_pci_devices(void)
  35 {
  36         struct device *dev;
  37         int no_devices;
  38
  39         dev = bus_find_device(&pci_bus_type, NULL, NULL, find_anything);
  40         no_devices = (dev == NULL);
  41         put_device(dev);
  42         return no_devices;
  43 }
  44 EXPORT_SYMBOL(no_pci_devices);
  45
  46 /*
  47  * PCI Bus Class Devices
  48  */
  49 static ssize_t pci_bus_show_cpuaffinity(struct device *dev,
  50                                         int type,
  51                                         struct device_attribute *attr,
  52                                         char *buf)
  53 {
  54         int ret;
  55         const struct cpumask *cpumask;
  56
  57         cpumask = cpumask_of_pcibus(to_pci_bus(dev));
  58         ret = type?
  59                 cpulist_scnprintf(buf, PAGE_SIZE-2, cpumask) :
  60                 cpumask_scnprintf(buf, PAGE_SIZE-2, cpumask);
  61         buf[ret++] = '\n';
  62         buf[ret] = '\0';
  63         return ret;
  64 }
  65
  66 static ssize_t inline pci_bus_show_cpumaskaffinity(struct device *dev,
  67                                         struct device_attribute *attr,
  68                                         char *buf)
  69 {
  70         return pci_bus_show_cpuaffinity(dev, 0, attr, buf);
  71 }
  72
  73 static ssize_t inline pci_bus_show_cpulistaffinity(struct device *dev,
  74                                         struct device_attribute *attr,
  75                                         char *buf)
  76 {
  77         return pci_bus_show_cpuaffinity(dev, 1, attr, buf);
  78 }
  79
  80 DEVICE_ATTR(cpuaffinity,     S_IRUGO, pci_bus_show_cpumaskaffinity, NULL);
  81 DEVICE_ATTR(cpulistaffinity, S_IRUGO, pci_bus_show_cpulistaffinity, NULL);
  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         kfree(pci_bus);
  93 }
  94
  95 static struct class pcibus_class = {
  96         .name           = "pci_bus",
  97         .dev_release    = &release_pcibus_dev,
  98 };
  99
 100 static int __init pcibus_class_init(void)
 101 {
 102         return class_register(&pcibus_class);
 103 }
 104 postcore_initcall(pcibus_class_init);
 105
 106 /*
 107  * Translate the low bits of the PCI base
 108  * to the resource type
 109  */
 110 static inline unsigned int pci_calc_resource_flags(unsigned int flags)
 111 {
 112         if (flags & PCI_BASE_ADDRESS_SPACE_IO)
 113                 return IORESOURCE_IO;
 114
 115         if (flags & PCI_BASE_ADDRESS_MEM_PREFETCH)
 116                 return IORESOURCE_MEM | IORESOURCE_PREFETCH;
 117
 118         return IORESOURCE_MEM;
 119 }
 120
 121 static u64 pci_size(u64 base, u64 maxbase, u64 mask)
 122 {
 123         u64 size = mask & maxbase;      /* Find the significant bits */
 124         if (!size)
 125                 return 0;
 126
 127         /* Get the lowest of them to find the decode size, and
 128            from that the extent.  */
 129         size = (size & ~(size-1)) - 1;
 130
 131         /* base == maxbase can be valid only if the BAR has
 132            already been programmed with all 1s.  */
 133         if (base == maxbase && ((base | size) & mask) != mask)
 134                 return 0;
 135
 136         return size;
 137 }
 138
 139 static inline enum pci_bar_type decode_bar(struct resource *res, u32 bar)
 140 {
 141         if ((bar & PCI_BASE_ADDRESS_SPACE) == PCI_BASE_ADDRESS_SPACE_IO) {
 142                 res->flags = bar & ~PCI_BASE_ADDRESS_IO_MASK;
 143                 return pci_bar_io;
 144         }
 145
 146         res->flags = bar & ~PCI_BASE_ADDRESS_MEM_MASK;
 147
 148         if (res->flags & PCI_BASE_ADDRESS_MEM_TYPE_64)
 149                 return pci_bar_mem64;
 150         return pci_bar_mem32;
 151 }
 152
 153 /**
 154  * pci_read_base - read a PCI BAR
 155  * @dev: the PCI device
 156  * @type: type of the BAR
 157  * @res: resource buffer to be filled in
 158  * @pos: BAR position in the config space
 159  *
 160  * Returns 1 if the BAR is 64-bit, or 0 if 32-bit.
 161  */
 162 int __pci_read_base(struct pci_dev *dev, enum pci_bar_type type,
 163                         struct resource *res, unsigned int pos)
 164 {
 165         u32 l, sz, mask;
 166
 167         mask = type ? PCI_ROM_ADDRESS_MASK : ~0;
 168
 169         res->name = pci_name(dev);
 170
 171         pci_read_config_dword(dev, pos, &l);
 172         pci_write_config_dword(dev, pos, l | mask);
 173         pci_read_config_dword(dev, pos, &sz);
 174         pci_write_config_dword(dev, pos, l);
 175
 176         /*
 177          * All bits set in sz means the device isn't working properly.
 178          * If the BAR isn't implemented, all bits must be 0.  If it's a
 179          * memory BAR or a ROM, bit 0 must be clear; if it's an io BAR, bit
 180          * 1 must be clear.
 181          */
 182         if (!sz || sz == 0xffffffff)
 183                 goto fail;
 184
 185         /*
 186          * I don't know how l can have all bits set.  Copied from old code.
 187          * Maybe it fixes a bug on some ancient platform.
 188          */
 189         if (l == 0xffffffff)
 190                 l = 0;
 191
 192         if (type == pci_bar_unknown) {
 193                 type = decode_bar(res, l);
 194                 res->flags |= pci_calc_resource_flags(l) | IORESOURCE_SIZEALIGN;
 195                 if (type == pci_bar_io) {
 196                         l &= PCI_BASE_ADDRESS_IO_MASK;
 197                         mask = PCI_BASE_ADDRESS_IO_MASK & IO_SPACE_LIMIT;
 198                 } else {
 199                         l &= PCI_BASE_ADDRESS_MEM_MASK;
 200                         mask = (u32)PCI_BASE_ADDRESS_MEM_MASK;
 201                 }
 202         } else {
 203                 res->flags |= (l & IORESOURCE_ROM_ENABLE);
 204                 l &= PCI_ROM_ADDRESS_MASK;
 205                 mask = (u32)PCI_ROM_ADDRESS_MASK;
 206         }
 207
 208         if (type == pci_bar_mem64) {
 209                 u64 l64 = l;
 210                 u64 sz64 = sz;
 211                 u64 mask64 = mask | (u64)~0 << 32;
 212
 213                 pci_read_config_dword(dev, pos + 4, &l);
 214                 pci_write_config_dword(dev, pos + 4, ~0);
 215                 pci_read_config_dword(dev, pos + 4, &sz);
 216                 pci_write_config_dword(dev, pos + 4, l);
 217
 218                 l64 |= ((u64)l << 32);
 219                 sz64 |= ((u64)sz << 32);
 220
 221                 sz64 = pci_size(l64, sz64, mask64);
 222
 223                 if (!sz64)
 224                         goto fail;
 225
 226                 if ((sizeof(resource_size_t) < 8) && (sz64 > 0x100000000ULL)) {
 227                         dev_err(&dev->dev, "reg %x: can't handle 64-bit BAR\n",
 228                                 pos);
 229                         goto fail;
 230                 }
 231
 232                 res->flags |= IORESOURCE_MEM_64;
 233                 if ((sizeof(resource_size_t) < 8) && l) {
 234                         /* Address above 32-bit boundary; disable the BAR */
 235                         pci_write_config_dword(dev, pos, 0);
 236                         pci_write_config_dword(dev, pos + 4, 0);
 237                         res->start = 0;
 238                         res->end = sz64;
 239                 } else {
 240                         res->start = l64;
 241                         res->end = l64 + sz64;
 242                         dev_printk(KERN_DEBUG, &dev->dev, "reg %x: %pR\n",
 243                                    pos, res);
 244                 }
 245         } else {
 246                 sz = pci_size(l, sz, mask);
 247
 248                 if (!sz)
 249                         goto fail;
 250
 251                 res->start = l;
 252                 res->end = l + sz;
 253
 254                 dev_printk(KERN_DEBUG, &dev->dev, "reg %x: %pR\n", pos, res);
 255         }
 256
 257  out:
 258         return (type == pci_bar_mem64) ? 1 : 0;
 259  fail:
 260         res->flags = 0;
 261         goto out;
 262 }
 263
 264 static void pci_read_bases(struct pci_dev *dev, unsigned int howmany, int rom)
 265 {
 266         unsigned int pos, reg;
 267
 268         for (pos = 0; pos < howmany; pos++) {
 269                 struct resource *res = &dev->resource[pos];
 270                 reg = PCI_BASE_ADDRESS_0 + (pos << 2);
 271                 pos += __pci_read_base(dev, pci_bar_unknown, res, reg);
 272         }
 273
 274         if (rom) {
 275                 struct resource *res = &dev->resource[PCI_ROM_RESOURCE];
 276                 dev->rom_base_reg = rom;
 277                 res->flags = IORESOURCE_MEM | IORESOURCE_PREFETCH |
 278                                 IORESOURCE_READONLY | IORESOURCE_CACHEABLE |
 279                                 IORESOURCE_SIZEALIGN;
 280                 __pci_read_base(dev, pci_bar_mem32, res, rom);
 281         }
 282 }
 283
 284 void __devinit pci_read_bridge_bases(struct pci_bus *child)
 285 {
 286         struct pci_dev *dev = child->self;
 287         u8 io_base_lo, io_limit_lo;
 288         u16 mem_base_lo, mem_limit_lo;
 289         unsigned long base, limit;
 290         struct resource *res;
 291         int i;
 292
 293         if (pci_is_root_bus(child))     /* It's a host bus, nothing to read */
 294                 return;
 295
 296         dev_info(&dev->dev, "PCI bridge to [bus %02x-%02x]%s\n",
 297                  child->secondary, child->subordinate,
 298                  dev->transparent ? " (subtractive decode)": "");
 299
 300         if (dev->transparent) {
 301                 for(i = 3; i < PCI_BUS_NUM_RESOURCES; i++)
 302                         child->resource[i] = child->parent->resource[i - 3];
 303         }
 304
 305         res = child->resource[0];
 306         pci_read_config_byte(dev, PCI_IO_BASE, &io_base_lo);
 307         pci_read_config_byte(dev, PCI_IO_LIMIT, &io_limit_lo);
 308         base = (io_base_lo & PCI_IO_RANGE_MASK) << 8;
 309         limit = (io_limit_lo & PCI_IO_RANGE_MASK) << 8;
 310
 311         if ((io_base_lo & PCI_IO_RANGE_TYPE_MASK) == PCI_IO_RANGE_TYPE_32) {
 312                 u16 io_base_hi, io_limit_hi;
 313                 pci_read_config_word(dev, PCI_IO_BASE_UPPER16, &io_base_hi);
 314                 pci_read_config_word(dev, PCI_IO_LIMIT_UPPER16, &io_limit_hi);
 315                 base |= (io_base_hi << 16);
 316                 limit |= (io_limit_hi << 16);
 317         }
 318
 319         if (base && base <= limit) {
 320                 res->flags = (io_base_lo & PCI_IO_RANGE_TYPE_MASK) | IORESOURCE_IO;
 321                 if (!res->start)
 322                         res->start = base;
 323                 if (!res->end)
 324                         res->end = limit + 0xfff;
 325                 dev_printk(KERN_DEBUG, &dev->dev, "  bridge window %pR\n", res);
 326         } else {
 327                 dev_printk(KERN_DEBUG, &dev->dev,
 328                          "  bridge window [io  %04lx - %04lx] reg reading\n",
 329                                  base, limit);
 330         }
 331
 332         res = child->resource[1];
 333         pci_read_config_word(dev, PCI_MEMORY_BASE, &mem_base_lo);
 334         pci_read_config_word(dev, PCI_MEMORY_LIMIT, &mem_limit_lo);
 335         base = (mem_base_lo & PCI_MEMORY_RANGE_MASK) << 16;
 336         limit = (mem_limit_lo & PCI_MEMORY_RANGE_MASK) << 16;
 337         if (base && base <= limit) {
 338                 res->flags = (mem_base_lo & PCI_MEMORY_RANGE_TYPE_MASK) | IORESOURCE_MEM;
 339                 res->start = base;
 340                 res->end = limit + 0xfffff;
 341                 dev_printk(KERN_DEBUG, &dev->dev, "  bridge window %pR\n", res);
 342         } else {
 343                 dev_printk(KERN_DEBUG, &dev->dev,
 344                         "  bridge window [mem 0x%08lx - 0x%08lx] reg reading\n",
 345                                          base, limit + 0xfffff);
 346         }
 347
 348         res = child->resource[2];
 349         pci_read_config_word(dev, PCI_PREF_MEMORY_BASE, &mem_base_lo);
 350         pci_read_config_word(dev, PCI_PREF_MEMORY_LIMIT, &mem_limit_lo);
 351         base = (mem_base_lo & PCI_PREF_RANGE_MASK) << 16;
 352         limit = (mem_limit_lo & PCI_PREF_RANGE_MASK) << 16;
 353
 354         if ((mem_base_lo & PCI_PREF_RANGE_TYPE_MASK) == PCI_PREF_RANGE_TYPE_64) {
 355                 u32 mem_base_hi, mem_limit_hi;
 356                 pci_read_config_dword(dev, PCI_PREF_BASE_UPPER32, &mem_base_hi);
 357                 pci_read_config_dword(dev, PCI_PREF_LIMIT_UPPER32, &mem_limit_hi);
 358
 359                 /*
 360                  * Some bridges set the base > limit by default, and some
 361                  * (broken) BIOSes do not initialize them.  If we find
 362                  * this, just assume they are not being used.
 363                  */
 364                 if (mem_base_hi <= mem_limit_hi) {
 365 #if BITS_PER_LONG == 64
 366                         base |= ((long) mem_base_hi) << 32;
 367                         limit |= ((long) mem_limit_hi) << 32;
 368 #else
 369                         if (mem_base_hi || mem_limit_hi) {
 370                                 dev_err(&dev->dev, "can't handle 64-bit "
 371                                         "address space for bridge\n");
 372                                 return;
 373                         }
 374 #endif
 375                 }
 376         }
 377         if (base && base <= limit) {
 378                 res->flags = (mem_base_lo & PCI_PREF_RANGE_TYPE_MASK) |
 379                                          IORESOURCE_MEM | IORESOURCE_PREFETCH;
 380                 if (res->flags & PCI_PREF_RANGE_TYPE_64)
 381                         res->flags |= IORESOURCE_MEM_64;
 382                 res->start = base;
 383                 res->end = limit + 0xfffff;
 384                 dev_printk(KERN_DEBUG, &dev->dev, "  bridge window %pR\n", res);
 385         } else {
 386                 dev_printk(KERN_DEBUG, &dev->dev,
 387                      "  bridge window [mem 0x%08lx - %08lx pref] reg reading\n",
 388                                          base, limit + 0xfffff);
 389         }
 390 }
 391
 392 static struct pci_bus * pci_alloc_bus(void)
 393 {
 394         struct pci_bus *b;
 395
 396         b = kzalloc(sizeof(*b), GFP_KERNEL);
 397         if (b) {
 398                 INIT_LIST_HEAD(&b->node);
 399                 INIT_LIST_HEAD(&b->children);
 400                 INIT_LIST_HEAD(&b->devices);
 401                 INIT_LIST_HEAD(&b->slots);
 402                 b->max_bus_speed = PCI_SPEED_UNKNOWN;
 403                 b->cur_bus_speed = PCI_SPEED_UNKNOWN;
 404         }
 405         return b;
 406 }
 407
 408 static unsigned char pcix_bus_speed[] = {
 409         PCI_SPEED_UNKNOWN,              /* 0 */
 410         PCI_SPEED_66MHz_PCIX,           /* 1 */
 411         PCI_SPEED_100MHz_PCIX,          /* 2 */
 412         PCI_SPEED_133MHz_PCIX,          /* 3 */
 413         PCI_SPEED_UNKNOWN,              /* 4 */
 414         PCI_SPEED_66MHz_PCIX_ECC,       /* 5 */
 415         PCI_SPEED_100MHz_PCIX_ECC,      /* 6 */
 416         PCI_SPEED_133MHz_PCIX_ECC,      /* 7 */
 417         PCI_SPEED_UNKNOWN,              /* 8 */
 418         PCI_SPEED_66MHz_PCIX_266,       /* 9 */
 419         PCI_SPEED_100MHz_PCIX_266,      /* A */
 420         PCI_SPEED_133MHz_PCIX_266,      /* B */
 421         PCI_SPEED_UNKNOWN,              /* C */
 422         PCI_SPEED_66MHz_PCIX_533,       /* D */
 423         PCI_SPEED_100MHz_PCIX_533,      /* E */
 424         PCI_SPEED_133MHz_PCIX_533       /* F */
 425 };
 426
 427 static unsigned char pcie_link_speed[] = {
 428         PCI_SPEED_UNKNOWN,              /* 0 */
 429         PCIE_SPEED_2_5GT,               /* 1 */
 430         PCIE_SPEED_5_0GT,               /* 2 */
 431         PCIE_SPEED_8_0GT,               /* 3 */
 432         PCI_SPEED_UNKNOWN,              /* 4 */
 433         PCI_SPEED_UNKNOWN,              /* 5 */
 434         PCI_SPEED_UNKNOWN,              /* 6 */
 435         PCI_SPEED_UNKNOWN,              /* 7 */
 436         PCI_SPEED_UNKNOWN,              /* 8 */
 437         PCI_SPEED_UNKNOWN,              /* 9 */
 438         PCI_SPEED_UNKNOWN,              /* A */
 439         PCI_SPEED_UNKNOWN,              /* B */
 440         PCI_SPEED_UNKNOWN,              /* C */
 441         PCI_SPEED_UNKNOWN,              /* D */
 442         PCI_SPEED_UNKNOWN,              /* E */
 443         PCI_SPEED_UNKNOWN               /* F */
 444 };
 445
 446 void pcie_update_link_speed(struct pci_bus *bus, u16 linksta)
 447 {
 448         bus->cur_bus_speed = pcie_link_speed[linksta & 0xf];
 449 }
 450 EXPORT_SYMBOL_GPL(pcie_update_link_speed);
 451
 452 static unsigned char agp_speeds[] = {
 453         AGP_UNKNOWN,
 454         AGP_1X,
 455         AGP_2X,
 456         AGP_4X,
 457         AGP_8X
 458 };
 459
 460 static enum pci_bus_speed agp_speed(int agp3, int agpstat)
 461 {
 462         int index = 0;
 463
 464         if (agpstat & 4)
 465                 index = 3;
 466         else if (agpstat & 2)
 467                 index = 2;
 468         else if (agpstat & 1)
 469                 index = 1;
 470         else
 471                 goto out;
 472
 473         if (agp3) {
 474                 index += 2;
 475                 if (index == 5)
 476                         index = 0;
 477         }
 478
 479  out:
 480         return agp_speeds[index];
 481 }
 482
 483
 484 static void pci_set_bus_speed(struct pci_bus *bus)
 485 {
 486         struct pci_dev *bridge = bus->self;
 487         int pos;
 488
 489         pos = pci_find_capability(bridge, PCI_CAP_ID_AGP);
 490         if (!pos)
 491                 pos = pci_find_capability(bridge, PCI_CAP_ID_AGP3);
 492         if (pos) {
 493                 u32 agpstat, agpcmd;
 494
 495                 pci_read_config_dword(bridge, pos + PCI_AGP_STATUS, &agpstat);
 496                 bus->max_bus_speed = agp_speed(agpstat & 8, agpstat & 7);
 497
 498                 pci_read_config_dword(bridge, pos + PCI_AGP_COMMAND, &agpcmd);
 499                 bus->cur_bus_speed = agp_speed(agpstat & 8, agpcmd & 7);
 500         }
 501
 502         pos = pci_find_capability(bridge, PCI_CAP_ID_PCIX);
 503         if (pos) {
 504                 u16 status;
 505                 enum pci_bus_speed max;
 506                 pci_read_config_word(bridge, pos + 2, &status);
 507
 508                 if (status & 0x8000) {
 509                         max = PCI_SPEED_133MHz_PCIX_533;
 510                 } else if (status & 0x4000) {
 511                         max = PCI_SPEED_133MHz_PCIX_266;
 512                 } else if (status & 0x0002) {
 513                         if (((status >> 12) & 0x3) == 2) {
 514                                 max = PCI_SPEED_133MHz_PCIX_ECC;
 515                         } else {
 516                                 max = PCI_SPEED_133MHz_PCIX;
 517                         }
 518                 } else {
 519                         max = PCI_SPEED_66MHz_PCIX;
 520                 }
 521
 522                 bus->max_bus_speed = max;
 523                 bus->cur_bus_speed = pcix_bus_speed[(status >> 6) & 0xf];
 524
 525                 return;
 526         }
 527
 528         pos = pci_find_capability(bridge, PCI_CAP_ID_EXP);
 529         if (pos) {
 530                 u32 linkcap;
 531                 u16 linksta;
 532
 533                 pci_read_config_dword(bridge, pos + PCI_EXP_LNKCAP, &linkcap);
 534                 bus->max_bus_speed = pcie_link_speed[linkcap & 0xf];
 535
 536                 pci_read_config_word(bridge, pos + PCI_EXP_LNKSTA, &linksta);
 537                 pcie_update_link_speed(bus, linksta);
 538         }
 539 }
 540
 541
 542 static struct pci_bus *pci_alloc_child_bus(struct pci_bus *parent,
 543                                            struct pci_dev *bridge, int busnr)
 544 {
 545         struct pci_bus *child;
 546         int i;
 547
 548         /*
 549          * Allocate a new bus, and inherit stuff from the parent..
 550          */
 551         child = pci_alloc_bus();
 552         if (!child)
 553                 return NULL;
 554
 555         child->parent = parent;
 556         child->ops = parent->ops;
 557         child->sysdata = parent->sysdata;
 558         child->bus_flags = parent->bus_flags;
 559
 560         /* initialize some portions of the bus device, but don't register it
 561          * now as the parent is not properly set up yet.  This device will get
 562          * registered later in pci_bus_add_devices()
 563          */
 564         child->dev.class = &pcibus_class;
 565         dev_set_name(&child->dev, "%04x:%02x", pci_domain_nr(child), busnr);
 566
 567         /*
 568          * Set up the primary, secondary and subordinate
 569          * bus numbers.
 570          */
 571         child->number = child->secondary = busnr;
 572         child->primary = parent->secondary;
 573         child->subordinate = 0xff;
 574
 575         if (!bridge)
 576                 return child;
 577
 578         child->self = bridge;
 579         child->bridge = get_device(&bridge->dev);
 580
 581         pci_set_bus_speed(child);
 582
 583         /* Set up default resource pointers and names.. */
 584         for (i = 0; i < PCI_BRIDGE_RESOURCE_NUM; i++) {
 585                 child->resource[i] = &bridge->resource[PCI_BRIDGE_RESOURCES+i];
 586                 child->resource[i]->name = child->name;
 587         }
 588         bridge->subordinate = child;
 589
 590         return child;
 591 }
 592
 593 struct pci_bus *__ref pci_add_new_bus(struct pci_bus *parent, struct pci_dev *dev, int busnr)
 594 {
 595         struct pci_bus *child;
 596
 597         child = pci_alloc_child_bus(parent, dev, busnr);
 598         if (child) {
 599                 down_write(&pci_bus_sem);
 600                 list_add_tail(&child->node, &parent->children);
 601                 up_write(&pci_bus_sem);
 602         }
 603         return child;
 604 }
 605
 606 static void pci_fixup_parent_subordinate_busnr(struct pci_bus *child, int max)
 607 {
 608         struct pci_bus *parent = child->parent;
 609
 610         /* Attempts to fix that up are really dangerous unless
 611            we're going to re-assign all bus numbers. */
 612         if (!pcibios_assign_all_busses())
 613                 return;
 614
 615         while (parent->parent && parent->subordinate < max) {
 616                 parent->subordinate = max;
 617                 pci_write_config_byte(parent->self, PCI_SUBORDINATE_BUS, max);
 618                 parent = parent->parent;
 619         }
 620 }
 621
 622 /*
 623  * If it's a bridge, configure it and scan the bus behind it.
 624  * For CardBus bridges, we don't scan behind as the devices will
 625  * be handled by the bridge driver itself.
 626  *
 627  * We need to process bridges in two passes -- first we scan those
 628  * already configured by the BIOS and after we are done with all of
 629  * them, we proceed to assigning numbers to the remaining buses in
 630  * order to avoid overlaps between old and new bus numbers.
 631  */
 632 int __devinit pci_scan_bridge(struct pci_bus *bus, struct pci_dev *dev, int max, int pass)
 633 {
 634         struct pci_bus *child;
 635         int is_cardbus = (dev->hdr_type == PCI_HEADER_TYPE_CARDBUS);
 636         u32 buses, i, j = 0;
 637         u16 bctl;
 638         int broken = 0;
 639
 640         pci_read_config_dword(dev, PCI_PRIMARY_BUS, &buses);
 641
 642         dev_dbg(&dev->dev, "scanning behind bridge, config %06x, pass %d\n",
 643                 buses & 0xffffff, pass);
 644
 645         /* Check if setup is sensible at all */
 646         if (!pass &&
 647             ((buses & 0xff) != bus->number || ((buses >> 8) & 0xff) <= bus->number)) {
 648                 dev_dbg(&dev->dev, "bus configuration invalid, reconfiguring\n");
 649                 broken = 1;
 650         }
 651
 652         /* Disable MasterAbortMode during probing to avoid reporting
 653            of bus errors (in some architectures) */
 654         pci_read_config_word(dev, PCI_BRIDGE_CONTROL, &bctl);
 655         pci_write_config_word(dev, PCI_BRIDGE_CONTROL,
 656                               bctl & ~PCI_BRIDGE_CTL_MASTER_ABORT);
 657
 658         if ((buses & 0xffff00) && !pcibios_assign_all_busses() && !is_cardbus && !broken) {
 659                 unsigned int cmax, busnr;
 660                 /*
 661                  * Bus already configured by firmware, process it in the first
 662                  * pass and just note the configuration.
 663                  */
 664                 if (pass)
 665                         goto out;
 666                 busnr = (buses >> 8) & 0xFF;
 667
 668                 /*
 669                  * If we already got to this bus through a different bridge,
 670                  * don't re-add it. This can happen with the i450NX chipset.
 671                  *
 672                  * However, we continue to descend down the hierarchy and
 673                  * scan remaining child buses.
 674                  */
 675                 child = pci_find_bus(pci_domain_nr(bus), busnr);
 676                 if (!child) {
 677                         child = pci_add_new_bus(bus, dev, busnr);
 678                         if (!child)
 679                                 goto out;
 680                         child->primary = buses & 0xFF;
 681                         child->subordinate = (buses >> 16) & 0xFF;
 682                         child->bridge_ctl = bctl;
 683                 }
 684
 685                 cmax = pci_scan_child_bus(child);
 686                 if (cmax > max)
 687                         max = cmax;
 688                 if (child->subordinate > max)
 689                         max = child->subordinate;
 690         } else {
 691                 /*
 692                  * We need to assign a number to this bus which we always
 693                  * do in the second pass.
 694                  */
 695                 if (!pass) {
 696                         if (pcibios_assign_all_busses() || broken)
 697                                 /* Temporarily disable forwarding of the
 698                                    configuration cycles on all bridges in
 699                                    this bus segment to avoid possible
 700                                    conflicts in the second pass between two
 701                                    bridges programmed with overlapping
 702                                    bus ranges. */
 703                                 pci_write_config_dword(dev, PCI_PRIMARY_BUS,
 704                                                        buses & ~0xffffff);
 705                         goto out;
 706                 }
 707
 708                 /* Clear errors */
 709                 pci_write_config_word(dev, PCI_STATUS, 0xffff);
 710
 711                 /* Prevent assigning a bus number that already exists.
 712                  * This can happen when a bridge is hot-plugged */
 713                 if (pci_find_bus(pci_domain_nr(bus), max+1))
 714                         goto out;
 715                 child = pci_add_new_bus(bus, dev, ++max);
 716                 buses = (buses & 0xff000000)
 717                       | ((unsigned int)(child->primary)     <<  0)
 718                       | ((unsigned int)(child->secondary)   <<  8)
 719                       | ((unsigned int)(child->subordinate) << 16);
 720
 721                 /*
 722                  * yenta.c forces a secondary latency timer of 176.
 723                  * Copy that behaviour here.
 724                  */
 725                 if (is_cardbus) {
 726                         buses &= ~0xff000000;
 727                         buses |= CARDBUS_LATENCY_TIMER << 24;
 728                 }
 729
 730                 /*
 731                  * We need to blast all three values with a single write.
 732                  */
 733                 pci_write_config_dword(dev, PCI_PRIMARY_BUS, buses);
 734
 735                 if (!is_cardbus) {
 736                         child->bridge_ctl = bctl;
 737                         /*
 738                          * Adjust subordinate busnr in parent buses.
 739                          * We do this before scanning for children because
 740                          * some devices may not be detected if the bios
 741                          * was lazy.
 742                          */
 743                         pci_fixup_parent_subordinate_busnr(child, max);
 744                         /* Now we can scan all subordinate buses... */
 745                         max = pci_scan_child_bus(child);
 746                         /*
 747                          * now fix it up again since we have found
 748                          * the real value of max.
 749                          */
 750                         pci_fixup_parent_subordinate_busnr(child, max);
 751                 } else {
 752                         /*
 753                          * For CardBus bridges, we leave 4 bus numbers
 754                          * as cards with a PCI-to-PCI bridge can be
 755                          * inserted later.
 756                          */
 757                         for (i=0; i<CARDBUS_RESERVE_BUSNR; i++) {
 758                                 struct pci_bus *parent = bus;
 759                                 if (pci_find_bus(pci_domain_nr(bus),
 760                                                         max+i+1))
 761                                         break;
 762                                 while (parent->parent) {
 763                                         if ((!pcibios_assign_all_busses()) &&
 764                                             (parent->subordinate > max) &&
 765                                             (parent->subordinate <= max+i)) {
 766                                                 j = 1;
 767                                         }
 768                                         parent = parent->parent;
 769                                 }
 770                                 if (j) {
 771                                         /*
 772                                          * Often, there are two cardbus bridges
 773                                          * -- try to leave one valid bus number
 774                                          * for each one.
 775                                          */
 776                                         i /= 2;
 777                                         break;
 778                                 }
 779                         }
 780                         max += i;
 781                         pci_fixup_parent_subordinate_busnr(child, max);
 782                 }
 783                 /*
 784                  * Set the subordinate bus number to its real value.
 785                  */
 786                 child->subordinate = max;
 787                 pci_write_config_byte(dev, PCI_SUBORDINATE_BUS, max);
 788         }
 789
 790         sprintf(child->name,
 791                 (is_cardbus ? "PCI CardBus %04x:%02x" : "PCI Bus %04x:%02x"),
 792                 pci_domain_nr(bus), child->number);
 793
 794         /* Has only triggered on CardBus, fixup is in yenta_socket */
 795         while (bus->parent) {
 796                 if ((child->subordinate > bus->subordinate) ||
 797                     (child->number > bus->subordinate) ||
 798                     (child->number < bus->number) ||
 799                     (child->subordinate < bus->number)) {
 800                         dev_info(&child->dev, "[bus %02x-%02x] %s "
 801                                 "hidden behind%s bridge %s [bus %02x-%02x]\n",
 802                                 child->number, child->subordinate,
 803                                 (bus->number > child->subordinate &&
 804                                  bus->subordinate < child->number) ?
 805                                         "wholly" : "partially",
 806                                 bus->self->transparent ? " transparent" : "",
 807                                 dev_name(&bus->dev),
 808                                 bus->number, bus->subordinate);
 809                 }
 810                 bus = bus->parent;
 811         }
 812
 813 out:
 814         pci_write_config_word(dev, PCI_BRIDGE_CONTROL, bctl);
 815
 816         return max;
 817 }
 818
 819 /*
 820  * Read interrupt line and base address registers.
 821  * The architecture-dependent code can tweak these, of course.
 822  */
 823 static void pci_read_irq(struct pci_dev *dev)
 824 {
 825         unsigned char irq;
 826
 827         pci_read_config_byte(dev, PCI_INTERRUPT_PIN, &irq);
 828         dev->pin = irq;
 829         if (irq)
 830                 pci_read_config_byte(dev, PCI_INTERRUPT_LINE, &irq);
 831         dev->irq = irq;
 832 }
 833
 834 void set_pcie_port_type(struct pci_dev *pdev)
 835 {
 836         int pos;
 837         u16 reg16;
 838
 839         pos = pci_find_capability(pdev, PCI_CAP_ID_EXP);
 840         if (!pos)
 841                 return;
 842         pdev->is_pcie = 1;
 843         pdev->pcie_cap = pos;
 844         pci_read_config_word(pdev, pos + PCI_EXP_FLAGS, &reg16);
 845         pdev->pcie_type = (reg16 & PCI_EXP_FLAGS_TYPE) >> 4;
 846 }
 847
 848 void set_pcie_hotplug_bridge(struct pci_dev *pdev)
 849 {
 850         int pos;
 851         u16 reg16;
 852         u32 reg32;
 853
 854         pos = pci_pcie_cap(pdev);
 855         if (!pos)
 856                 return;
 857         pci_read_config_word(pdev, pos + PCI_EXP_FLAGS, &reg16);
 858         if (!(reg16 & PCI_EXP_FLAGS_SLOT))
 859                 return;
 860         pci_read_config_dword(pdev, pos + PCI_EXP_SLTCAP, &reg32);
 861         if (reg32 & PCI_EXP_SLTCAP_HPC)
 862                 pdev->is_hotplug_bridge = 1;
 863 }
 864
 865 static void set_pci_aer_firmware_first(struct pci_dev *pdev)
 866 {
 867         if (acpi_hest_firmware_first_pci(pdev))
 868                 pdev->aer_firmware_first = 1;
 869 }
 870
 871 #define LEGACY_IO_RESOURCE      (IORESOURCE_IO | IORESOURCE_PCI_FIXED)
 872
 873 /**
 874  * pci_setup_device - fill in class and map information of a device
 875  * @dev: the device structure to fill
 876  *
 877  * Initialize the device structure with information about the device's
 878  * vendor,class,memory and IO-space addresses,IRQ lines etc.
 879  * Called at initialisation of the PCI subsystem and by CardBus services.
 880  * Returns 0 on success and negative if unknown type of device (not normal,
 881  * bridge or CardBus).
 882  */
 883 int pci_setup_device(struct pci_dev *dev)
 884 {
 885         u32 class;
 886         u8 hdr_type;
 887         struct pci_slot *slot;
 888         int pos = 0;
 889
 890         if (pci_read_config_byte(dev, PCI_HEADER_TYPE, &hdr_type))
 891                 return -EIO;
 892
 893         dev->sysdata = dev->bus->sysdata;
 894         dev->dev.parent = dev->bus->bridge;
 895         dev->dev.bus = &pci_bus_type;
 896         dev->hdr_type = hdr_type & 0x7f;
 897         dev->multifunction = !!(hdr_type & 0x80);
 898         dev->error_state = pci_channel_io_normal;
 899         set_pcie_port_type(dev);
 900         set_pci_aer_firmware_first(dev);
 901
 902         list_for_each_entry(slot, &dev->bus->slots, list)
 903                 if (PCI_SLOT(dev->devfn) == slot->number)
 904                         dev->slot = slot;
 905
 906         /* Assume 32-bit PCI; let 64-bit PCI cards (which are far rarer)
 907            set this higher, assuming the system even supports it.  */
 908         dev->dma_mask = 0xffffffff;
 909
 910         dev_set_name(&dev->dev, "%04x:%02x:%02x.%d", pci_domain_nr(dev->bus),
 911                      dev->bus->number, PCI_SLOT(dev->devfn),
 912                      PCI_FUNC(dev->devfn));
 913
 914         pci_read_config_dword(dev, PCI_CLASS_REVISION, &class);
 915         dev->revision = class & 0xff;
 916         class >>= 8;                                /* upper 3 bytes */
 917         dev->class = class;
 918         class >>= 8;
 919
 920         dev_dbg(&dev->dev, "found [%04x:%04x] class %06x header type %02x\n",
 921                  dev->vendor, dev->device, class, dev->hdr_type);
 922
 923         /* need to have dev->class ready */
 924         dev->cfg_size = pci_cfg_space_size(dev);
 925
 926         /* "Unknown power state" */
 927         dev->current_state = PCI_UNKNOWN;
 928
 929         /* Early fixups, before probing the BARs */
 930         pci_fixup_device(pci_fixup_early, dev);
 931         /* device class may be changed after fixup */
 932         class = dev->class >> 8;
 933
 934         switch (dev->hdr_type) {                    /* header type */
 935         case PCI_HEADER_TYPE_NORMAL:                /* standard header */
 936                 if (class == PCI_CLASS_BRIDGE_PCI)
 937                         goto bad;
 938                 pci_read_irq(dev);
 939                 pci_read_bases(dev, 6, PCI_ROM_ADDRESS);
 940                 pci_read_config_word(dev, PCI_SUBSYSTEM_VENDOR_ID, &dev->subsystem_vendor);
 941                 pci_read_config_word(dev, PCI_SUBSYSTEM_ID, &dev->subsystem_device);
 942
 943                 /*
 944                  *      Do the ugly legacy mode stuff here rather than broken chip
 945                  *      quirk code. Legacy mode ATA controllers have fixed
 946                  *      addresses. These are not always echoed in BAR0-3, and
 947                  *      BAR0-3 in a few cases contain junk!
 948                  */
 949                 if (class == PCI_CLASS_STORAGE_IDE) {
 950                         u8 progif;
 951                         pci_read_config_byte(dev, PCI_CLASS_PROG, &progif);
 952                         if ((progif & 1) == 0) {
 953                                 dev->resource[0].start = 0x1F0;
 954                                 dev->resource[0].end = 0x1F7;
 955                                 dev->resource[0].flags = LEGACY_IO_RESOURCE;
 956                                 dev->resource[1].start = 0x3F6;
 957                                 dev->resource[1].end = 0x3F6;
 958                                 dev->resource[1].flags = LEGACY_IO_RESOURCE;
 959                         }
 960                         if ((progif & 4) == 0) {
 961                                 dev->resource[2].start = 0x170;
 962                                 dev->resource[2].end = 0x177;
 963                                 dev->resource[2].flags = LEGACY_IO_RESOURCE;
 964                                 dev->resource[3].start = 0x376;
 965                                 dev->resource[3].end = 0x376;
 966                                 dev->resource[3].flags = LEGACY_IO_RESOURCE;
 967                         }
 968                 }
 969                 break;
 970
 971         case PCI_HEADER_TYPE_BRIDGE:                /* bridge header */
 972                 if (class != PCI_CLASS_BRIDGE_PCI)
 973                         goto bad;
 974                 /* The PCI-to-PCI bridge spec requires that subtractive
 975                    decoding (i.e. transparent) bridge must have programming
 976                    interface code of 0x01. */
 977                 pci_read_irq(dev);
 978                 dev->transparent = ((dev->class & 0xff) == 1);
 979                 pci_read_bases(dev, 2, PCI_ROM_ADDRESS1);
 980                 set_pcie_hotplug_bridge(dev);
 981                 pos = pci_find_capability(dev, PCI_CAP_ID_SSVID);
 982                 if (pos) {
 983                         pci_read_config_word(dev, pos + PCI_SSVID_VENDOR_ID, &dev->subsystem_vendor);
 984                         pci_read_config_word(dev, pos + PCI_SSVID_DEVICE_ID, &dev->subsystem_device);
 985                 }
 986                 break;
 987
 988         case PCI_HEADER_TYPE_CARDBUS:               /* CardBus bridge header */
 989                 if (class != PCI_CLASS_BRIDGE_CARDBUS)
 990                         goto bad;
 991                 pci_read_irq(dev);
 992                 pci_read_bases(dev, 1, 0);
 993                 pci_read_config_word(dev, PCI_CB_SUBSYSTEM_VENDOR_ID, &dev->subsystem_vendor);
 994                 pci_read_config_word(dev, PCI_CB_SUBSYSTEM_ID, &dev->subsystem_device);
 995                 break;
 996
 997         default:                                    /* unknown header */
 998                 dev_err(&dev->dev, "unknown header type %02x, "
 999                         "ignoring device\n", dev->hdr_type);
1000                 return -EIO;
1001
1002         bad:
1003                 dev_err(&dev->dev, "ignoring class %02x (doesn't match header "
1004                         "type %02x)\n", class, dev->hdr_type);
1005                 dev->class = PCI_CLASS_NOT_DEFINED;
1006         }
1007
1008         /* We found a fine healthy device, go go go... */
1009         return 0;
1010 }
1011
1012 static void pci_release_capabilities(struct pci_dev *dev)
1013 {
1014         pci_vpd_release(dev);
1015         pci_iov_release(dev);
1016 }
1017
1018 /**
1019  * pci_release_dev - free a pci device structure when all users of it are finished.
1020  * @dev: device that's been disconnected
1021  *
1022  * Will be called only by the device core when all users of this pci device are
1023  * done.
1024  */
1025 static void pci_release_dev(struct device *dev)
1026 {
1027         struct pci_dev *pci_dev;
1028
1029         pci_dev = to_pci_dev(dev);
1030         pci_release_capabilities(pci_dev);
1031         kfree(pci_dev);
1032 }
1033
1034 /**
1035  * pci_cfg_space_size - get the configuration space size of the PCI device.
1036  * @dev: PCI device
1037  *
1038  * Regular PCI devices have 256 bytes, but PCI-X 2 and PCI Express devices
1039  * have 4096 bytes.  Even if the device is capable, that doesn't mean we can
1040  * access it.  Maybe we don't have a way to generate extended config space
1041  * accesses, or the device is behind a reverse Express bridge.  So we try
1042  * reading the dword at 0x100 which must either be 0 or a valid extended
1043  * capability header.
1044  */
1045 int pci_cfg_space_size_ext(struct pci_dev *dev)
1046 {
1047         u32 status;
1048         int pos = PCI_CFG_SPACE_SIZE;
1049
1050         if (pci_read_config_dword(dev, pos, &status) != PCIBIOS_SUCCESSFUL)
1051                 goto fail;
1052         if (status == 0xffffffff)
1053                 goto fail;
1054
1055         return PCI_CFG_SPACE_EXP_SIZE;
1056
1057  fail:
1058         return PCI_CFG_SPACE_SIZE;
1059 }
1060
1061 int pci_cfg_space_size(struct pci_dev *dev)
1062 {
1063         int pos;
1064         u32 status;
1065         u16 class;
1066
1067         class = dev->class >> 8;
1068         if (class == PCI_CLASS_BRIDGE_HOST)
1069                 return pci_cfg_space_size_ext(dev);
1070
1071         pos = pci_pcie_cap(dev);
1072         if (!pos) {
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 static void pci_release_bus_bridge_dev(struct device *dev)
1089 {
1090         kfree(dev);
1091 }
1092
1093 struct pci_dev *alloc_pci_dev(void)
1094 {
1095         struct pci_dev *dev;
1096
1097         dev = kzalloc(sizeof(struct pci_dev), GFP_KERNEL);
1098         if (!dev)
1099                 return NULL;
1100
1101         INIT_LIST_HEAD(&dev->bus_list);
1102
1103         return dev;
1104 }
1105 EXPORT_SYMBOL(alloc_pci_dev);
1106
1107 /*
1108  * Read the config data for a PCI device, sanity-check it
1109  * and fill in the dev structure...
1110  */
1111 static struct pci_dev *pci_scan_device(struct pci_bus *bus, int devfn)
1112 {
1113         struct pci_dev *dev;
1114         u32 l;
1115         int delay = 1;
1116
1117         if (pci_bus_read_config_dword(bus, devfn, PCI_VENDOR_ID, &l))
1118                 return NULL;
1119
1120         /* some broken boards return 0 or ~0 if a slot is empty: */
1121         if (l == 0xffffffff || l == 0x00000000 ||
1122             l == 0x0000ffff || l == 0xffff0000)
1123                 return NULL;
1124
1125         /* Configuration request Retry Status */
1126         while (l == 0xffff0001) {
1127                 msleep(delay);
1128                 delay *= 2;
1129                 if (pci_bus_read_config_dword(bus, devfn, PCI_VENDOR_ID, &l))
1130                         return NULL;
1131                 /* Card hasn't responded in 60 seconds?  Must be stuck. */
1132                 if (delay > 60 * 1000) {
1133                         printk(KERN_WARNING "pci %04x:%02x:%02x.%d: not "
1134                                         "responding\n", pci_domain_nr(bus),
1135                                         bus->number, PCI_SLOT(devfn),
1136                                         PCI_FUNC(devfn));
1137                         return NULL;
1138                 }
1139         }
1140
1141         dev = alloc_pci_dev();
1142         if (!dev)
1143                 return NULL;
1144
1145         dev->bus = bus;
1146         dev->devfn = devfn;
1147         dev->vendor = l & 0xffff;
1148         dev->device = (l >> 16) & 0xffff;
1149
1150         if (pci_setup_device(dev)) {
1151                 kfree(dev);
1152                 return NULL;
1153         }
1154
1155         return dev;
1156 }
1157
1158 static void pci_init_capabilities(struct pci_dev *dev)
1159 {
1160         /* MSI/MSI-X list */
1161         pci_msi_init_pci_dev(dev);
1162
1163         /* Buffers for saving PCIe and PCI-X capabilities */
1164         pci_allocate_cap_save_buffers(dev);
1165
1166         /* Power Management */
1167         pci_pm_init(dev);
1168         platform_pci_wakeup_init(dev);
1169
1170         /* Vital Product Data */
1171         pci_vpd_pci22_init(dev);
1172
1173         /* Alternative Routing-ID Forwarding */
1174         pci_enable_ari(dev);
1175
1176         /* Single Root I/O Virtualization */
1177         pci_iov_init(dev);
1178
1179         /* Enable ACS P2P upstream forwarding */
1180         pci_enable_acs(dev);
1181 }
1182
1183 void pci_device_add(struct pci_dev *dev, struct pci_bus *bus)
1184 {
1185         device_initialize(&dev->dev);
1186         dev->dev.release = pci_release_dev;
1187         pci_dev_get(dev);
1188
1189         dev->dev.dma_mask = &dev->dma_mask;
1190         dev->dev.dma_parms = &dev->dma_parms;
1191         dev->dev.coherent_dma_mask = 0xffffffffull;
1192
1193         pci_set_dma_max_seg_size(dev, 65536);
1194         pci_set_dma_seg_boundary(dev, 0xffffffff);
1195
1196         /* Fix up broken headers */
1197         pci_fixup_device(pci_fixup_header, dev);
1198
1199         /* Clear the state_saved flag. */
1200         dev->state_saved = false;
1201
1202         /* Initialize various capabilities */
1203         pci_init_capabilities(dev);
1204
1205         /*
1206          * Add the device to our list of discovered devices
1207          * and the bus list for fixup functions, etc.
1208          */
1209         down_write(&pci_bus_sem);
1210         list_add_tail(&dev->bus_list, &bus->devices);
1211         up_write(&pci_bus_sem);
1212 }
1213
1214 struct pci_dev *__ref pci_scan_single_device(struct pci_bus *bus, int devfn)
1215 {
1216         struct pci_dev *dev;
1217
1218         dev = pci_get_slot(bus, devfn);
1219         if (dev) {
1220                 pci_dev_put(dev);
1221                 return dev;
1222         }
1223
1224         dev = pci_scan_device(bus, devfn);
1225         if (!dev)
1226                 return NULL;
1227
1228         pci_device_add(dev, bus);
1229
1230         return dev;
1231 }
1232 EXPORT_SYMBOL(pci_scan_single_device);
1233
1234 static unsigned next_ari_fn(struct pci_dev *dev, unsigned fn)
1235 {
1236         u16 cap;
1237         unsigned pos, next_fn;
1238
1239         if (!dev)
1240                 return 0;
1241
1242         pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ARI);
1243         if (!pos)
1244                 return 0;
1245         pci_read_config_word(dev, pos + 4, &cap);
1246         next_fn = cap >> 8;
1247         if (next_fn <= fn)
1248                 return 0;
1249         return next_fn;
1250 }
1251
1252 static unsigned next_trad_fn(struct pci_dev *dev, unsigned fn)
1253 {
1254         return (fn + 1) % 8;
1255 }
1256
1257 static unsigned no_next_fn(struct pci_dev *dev, unsigned fn)
1258 {
1259         return 0;
1260 }
1261
1262 static int only_one_child(struct pci_bus *bus)
1263 {
1264         struct pci_dev *parent = bus->self;
1265         if (!parent || !pci_is_pcie(parent))
1266                 return 0;
1267         if (parent->pcie_type == PCI_EXP_TYPE_ROOT_PORT ||
1268             parent->pcie_type == PCI_EXP_TYPE_DOWNSTREAM)
1269                 return 1;
1270         return 0;
1271 }
1272
1273 /**
1274  * pci_scan_slot - scan a PCI slot on a bus for devices.
1275  * @bus: PCI bus to scan
1276  * @devfn: slot number to scan (must have zero function.)
1277  *
1278  * Scan a PCI slot on the specified PCI bus for devices, adding
1279  * discovered devices to the @bus->devices list.  New devices
1280  * will not have is_added set.
1281  *
1282  * Returns the number of new devices found.
1283  */
1284 int pci_scan_slot(struct pci_bus *bus, int devfn)
1285 {
1286         unsigned fn, nr = 0;
1287         struct pci_dev *dev;
1288         unsigned (*next_fn)(struct pci_dev *, unsigned) = no_next_fn;
1289
1290         if (only_one_child(bus) && (devfn > 0))
1291                 return 0; /* Already scanned the entire slot */
1292
1293         dev = pci_scan_single_device(bus, devfn);
1294         if (!dev)
1295                 return 0;
1296         if (!dev->is_added)
1297                 nr++;
1298
1299         if (pci_ari_enabled(bus))
1300                 next_fn = next_ari_fn;
1301         else if (dev->multifunction)
1302                 next_fn = next_trad_fn;
1303
1304         for (fn = next_fn(dev, 0); fn > 0; fn = next_fn(dev, fn)) {
1305                 dev = pci_scan_single_device(bus, devfn + fn);
1306                 if (dev) {
1307                         if (!dev->is_added)
1308                                 nr++;
1309                         dev->multifunction = 1;
1310                 }
1311         }
1312
1313         /* only one slot has pcie device */
1314         if (bus->self && nr)
1315                 pcie_aspm_init_link_state(bus->self);
1316
1317         return nr;
1318 }
1319
1320 unsigned int __devinit pci_scan_child_bus(struct pci_bus *bus)
1321 {
1322         unsigned int devfn, pass, max = bus->secondary;
1323         struct pci_dev *dev;
1324
1325         dev_dbg(&bus->dev, "scanning bus\n");
1326
1327         /* Go find them, Rover! */
1328         for (devfn = 0; devfn < 0x100; devfn += 8)
1329                 pci_scan_slot(bus, devfn);
1330
1331         /* Reserve buses for SR-IOV capability. */
1332         max += pci_iov_bus_range(bus);
1333
1334         /*
1335          * After performing arch-dependent fixup of the bus, look behind
1336          * all PCI-to-PCI bridges on this bus.
1337          */
1338         if (!bus->is_added) {
1339                 dev_dbg(&bus->dev, "fixups for bus\n");
1340                 pcibios_fixup_bus(bus);
1341                 if (pci_is_root_bus(bus))
1342                         bus->is_added = 1;
1343         }
1344
1345         for (pass=0; pass < 2; pass++)
1346                 list_for_each_entry(dev, &bus->devices, bus_list) {
1347                         if (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE ||
1348                             dev->hdr_type == PCI_HEADER_TYPE_CARDBUS)
1349                                 max = pci_scan_bridge(bus, dev, max, pass);
1350                 }
1351
1352         /*
1353          * We've scanned the bus and so we know all about what's on
1354          * the other side of any bridges that may be on this bus plus
1355          * any devices.
1356          *
1357          * Return how far we've got finding sub-buses.
1358          */
1359         dev_dbg(&bus->dev, "bus scan returning with max=%02x\n", max);
1360         return max;
1361 }
1362
1363 struct pci_bus * pci_create_bus(struct device *parent,
1364                 int bus, struct pci_ops *ops, void *sysdata)
1365 {
1366         int error;
1367         struct pci_bus *b, *b2;
1368         struct device *dev;
1369
1370         b = pci_alloc_bus();
1371         if (!b)
1372                 return NULL;
1373
1374         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1375         if (!dev){
1376                 kfree(b);
1377                 return NULL;
1378         }
1379
1380         b->sysdata = sysdata;
1381         b->ops = ops;
1382
1383         b2 = pci_find_bus(pci_domain_nr(b), bus);
1384         if (b2) {
1385                 /* If we already got to this bus through a different bridge, ignore it */
1386                 dev_dbg(&b2->dev, "bus already known\n");
1387                 goto err_out;
1388         }
1389
1390         down_write(&pci_bus_sem);
1391         list_add_tail(&b->node, &pci_root_buses);
1392         up_write(&pci_bus_sem);
1393
1394         dev->parent = parent;
1395         dev->release = pci_release_bus_bridge_dev;
1396         dev_set_name(dev, "pci%04x:%02x", pci_domain_nr(b), bus);
1397         error = device_register(dev);
1398         if (error)
1399                 goto dev_reg_err;
1400         b->bridge = get_device(dev);
1401
1402         if (!parent)
1403                 set_dev_node(b->bridge, pcibus_to_node(b));
1404
1405         b->dev.class = &pcibus_class;
1406         b->dev.parent = b->bridge;
1407         dev_set_name(&b->dev, "%04x:%02x", pci_domain_nr(b), bus);
1408         error = device_register(&b->dev);
1409         if (error)
1410                 goto class_dev_reg_err;
1411         error = device_create_file(&b->dev, &dev_attr_cpuaffinity);
1412         if (error)
1413                 goto dev_create_file_err;
1414
1415         /* Create legacy_io and legacy_mem files for this bus */
1416         pci_create_legacy_files(b);
1417
1418         b->number = b->secondary = bus;
1419         b->resource[0] = &ioport_resource;
1420         b->resource[1] = &iomem_resource;
1421
1422         return b;
1423
1424 dev_create_file_err:
1425         device_unregister(&b->dev);
1426 class_dev_reg_err:
1427         device_unregister(dev);
1428 dev_reg_err:
1429         down_write(&pci_bus_sem);
1430         list_del(&b->node);
1431         up_write(&pci_bus_sem);
1432 err_out:
1433         kfree(dev);
1434         kfree(b);
1435         return NULL;
1436 }
1437
1438 struct pci_bus * __devinit pci_scan_bus_parented(struct device *parent,
1439                 int bus, struct pci_ops *ops, void *sysdata)
1440 {
1441         struct pci_bus *b;
1442
1443         b = pci_create_bus(parent, bus, ops, sysdata);
1444         if (b)
1445                 b->subordinate = pci_scan_child_bus(b);
1446         return b;
1447 }
1448 EXPORT_SYMBOL(pci_scan_bus_parented);
1449
1450 #ifdef CONFIG_HOTPLUG
1451 /**
1452  * pci_rescan_bus - scan a PCI bus for devices.
1453  * @bus: PCI bus to scan
1454  *
1455  * Scan a PCI bus and child buses for new devices, adds them,
1456  * and enables them.
1457  *
1458  * Returns the max number of subordinate bus discovered.
1459  */
1460 unsigned int __ref pci_rescan_bus(struct pci_bus *bus)
1461 {
1462         unsigned int max;
1463         struct pci_dev *dev;
1464
1465         max = pci_scan_child_bus(bus);
1466
1467         down_read(&pci_bus_sem);
1468         list_for_each_entry(dev, &bus->devices, bus_list)
1469                 if (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE ||
1470                     dev->hdr_type == PCI_HEADER_TYPE_CARDBUS)
1471                         if (dev->subordinate)
1472                                 pci_bus_size_bridges(dev->subordinate);
1473         up_read(&pci_bus_sem);
1474
1475         pci_bus_assign_resources(bus);
1476         pci_enable_bridges(bus);
1477         pci_bus_add_devices(bus);
1478
1479         return max;
1480 }
1481 EXPORT_SYMBOL_GPL(pci_rescan_bus);
1482
1483 EXPORT_SYMBOL(pci_add_new_bus);
1484 EXPORT_SYMBOL(pci_scan_slot);
1485 EXPORT_SYMBOL(pci_scan_bridge);
1486 EXPORT_SYMBOL_GPL(pci_scan_child_bus);
1487 #endif
1488
1489 static int __init pci_sort_bf_cmp(const struct device *d_a, const struct device *d_b)
1490 {
1491         const struct pci_dev *a = to_pci_dev(d_a);
1492         const struct pci_dev *b = to_pci_dev(d_b);
1493
1494         if      (pci_domain_nr(a->bus) < pci_domain_nr(b->bus)) return -1;
1495         else if (pci_domain_nr(a->bus) > pci_domain_nr(b->bus)) return  1;
1496
1497         if      (a->bus->number < b->bus->number) return -1;
1498         else if (a->bus->number > b->bus->number) return  1;
1499
1500         if      (a->devfn < b->devfn) return -1;
1501         else if (a->devfn > b->devfn) return  1;
1502
1503         return 0;
1504 }
1505
1506 void __init pci_sort_breadthfirst(void)
1507 {
1508         bus_sort_breadthfirst(&pci_bus_type, &pci_sort_bf_cmp);
1509 }