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