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 Devices
  47  */
  48 static ssize_t pci_bus_show_cpuaffinity(struct device *dev,
  49                                         int type,
  50                                         struct device_attribute *attr,
  51                                         char *buf)
  52 {
  53         int ret;
  54         cpumask_t cpumask;
  55
  56         cpumask = pcibus_to_cpumask(to_pci_bus(dev));
  57         ret = type?
  58                 cpulist_scnprintf(buf, PAGE_SIZE-2, &cpumask) :
  59                 cpumask_scnprintf(buf, PAGE_SIZE-2, &cpumask);
  60         buf[ret++] = '\n';
  61         buf[ret] = '\0';
  62         return ret;
  63 }
  64
  65 static ssize_t inline pci_bus_show_cpumaskaffinity(struct device *dev,
  66                                         struct device_attribute *attr,
  67                                         char *buf)
  68 {
  69         return pci_bus_show_cpuaffinity(dev, 0, attr, buf);
  70 }
  71
  72 static ssize_t inline pci_bus_show_cpulistaffinity(struct device *dev,
  73                                         struct device_attribute *attr,
  74                                         char *buf)
  75 {
  76         return pci_bus_show_cpuaffinity(dev, 1, attr, buf);
  77 }
  78
  79 DEVICE_ATTR(cpuaffinity,     S_IRUGO, pci_bus_show_cpumaskaffinity, NULL);
  80 DEVICE_ATTR(cpulistaffinity, S_IRUGO, pci_bus_show_cpulistaffinity, NULL);
  81
  82 /*
  83  * PCI Bus Class
  84  */
  85 static void release_pcibus_dev(struct device *dev)
  86 {
  87         struct pci_bus *pci_bus = to_pci_bus(dev);
  88
  89         if (pci_bus->bridge)
  90                 put_device(pci_bus->bridge);
  91         kfree(pci_bus);
  92 }
  93
  94 static struct class pcibus_class = {
  95         .name           = "pci_bus",
  96         .dev_release    = &release_pcibus_dev,
  97 };
  98
  99 static int __init pcibus_class_init(void)
 100 {
 101         return class_register(&pcibus_class);
 102 }
 103 postcore_initcall(pcibus_class_init);
 104
 105 /*
 106  * Translate the low bits of the PCI base
 107  * to the resource type
 108  */
 109 static inline unsigned int pci_calc_resource_flags(unsigned int flags)
 110 {
 111         if (flags & PCI_BASE_ADDRESS_SPACE_IO)
 112                 return IORESOURCE_IO;
 113
 114         if (flags & PCI_BASE_ADDRESS_MEM_PREFETCH)
 115                 return IORESOURCE_MEM | IORESOURCE_PREFETCH;
 116
 117         return IORESOURCE_MEM;
 118 }
 119
 120 static u64 pci_size(u64 base, u64 maxbase, u64 mask)
 121 {
 122         u64 size = mask & maxbase;      /* Find the significant bits */
 123         if (!size)
 124                 return 0;
 125
 126         /* Get the lowest of them to find the decode size, and
 127            from that the extent.  */
 128         size = (size & ~(size-1)) - 1;
 129
 130         /* base == maxbase can be valid only if the BAR has
 131            already been programmed with all 1s.  */
 132         if (base == maxbase && ((base | size) & mask) != mask)
 133                 return 0;
 134
 135         return size;
 136 }
 137
 138 static inline enum pci_bar_type decode_bar(struct resource *res, u32 bar)
 139 {
 140         if ((bar & PCI_BASE_ADDRESS_SPACE) == PCI_BASE_ADDRESS_SPACE_IO) {
 141                 res->flags = bar & ~PCI_BASE_ADDRESS_IO_MASK;
 142                 return pci_bar_io;
 143         }
 144
 145         res->flags = bar & ~PCI_BASE_ADDRESS_MEM_MASK;
 146
 147         if (res->flags & PCI_BASE_ADDRESS_MEM_TYPE_64)
 148                 return pci_bar_mem64;
 149         return pci_bar_mem32;
 150 }
 151
 152 /**
 153  * pci_read_base - read a PCI BAR
 154  * @dev: the PCI device
 155  * @type: type of the BAR
 156  * @res: resource buffer to be filled in
 157  * @pos: BAR position in the config space
 158  *
 159  * Returns 1 if the BAR is 64-bit, or 0 if 32-bit.
 160  */
 161 int __pci_read_base(struct pci_dev *dev, enum pci_bar_type type,
 162                         struct resource *res, unsigned int pos)
 163 {
 164         u32 l, sz, mask;
 165
 166         mask = type ? ~PCI_ROM_ADDRESS_ENABLE : ~0;
 167
 168         res->name = pci_name(dev);
 169
 170         pci_read_config_dword(dev, pos, &l);
 171         pci_write_config_dword(dev, pos, mask);
 172         pci_read_config_dword(dev, pos, &sz);
 173         pci_write_config_dword(dev, pos, l);
 174
 175         /*
 176          * All bits set in sz means the device isn't working properly.
 177          * If the BAR isn't implemented, all bits must be 0.  If it's a
 178          * memory BAR or a ROM, bit 0 must be clear; if it's an io BAR, bit
 179          * 1 must be clear.
 180          */
 181         if (!sz || sz == 0xffffffff)
 182                 goto fail;
 183
 184         /*
 185          * I don't know how l can have all bits set.  Copied from old code.
 186          * Maybe it fixes a bug on some ancient platform.
 187          */
 188         if (l == 0xffffffff)
 189                 l = 0;
 190
 191         if (type == pci_bar_unknown) {
 192                 type = decode_bar(res, l);
 193                 res->flags |= pci_calc_resource_flags(l) | IORESOURCE_SIZEALIGN;
 194                 if (type == pci_bar_io) {
 195                         l &= PCI_BASE_ADDRESS_IO_MASK;
 196                         mask = PCI_BASE_ADDRESS_IO_MASK & 0xffff;
 197                 } else {
 198                         l &= PCI_BASE_ADDRESS_MEM_MASK;
 199                         mask = (u32)PCI_BASE_ADDRESS_MEM_MASK;
 200                 }
 201         } else {
 202                 res->flags |= (l & IORESOURCE_ROM_ENABLE);
 203                 l &= PCI_ROM_ADDRESS_MASK;
 204                 mask = (u32)PCI_ROM_ADDRESS_MASK;
 205         }
 206
 207         if (type == pci_bar_mem64) {
 208                 u64 l64 = l;
 209                 u64 sz64 = sz;
 210                 u64 mask64 = mask | (u64)~0 << 32;
 211
 212                 pci_read_config_dword(dev, pos + 4, &l);
 213                 pci_write_config_dword(dev, pos + 4, ~0);
 214                 pci_read_config_dword(dev, pos + 4, &sz);
 215                 pci_write_config_dword(dev, pos + 4, l);
 216
 217                 l64 |= ((u64)l << 32);
 218                 sz64 |= ((u64)sz << 32);
 219
 220                 sz64 = pci_size(l64, sz64, mask64);
 221
 222                 if (!sz64)
 223                         goto fail;
 224
 225                 if ((sizeof(resource_size_t) < 8) && (sz64 > 0x100000000ULL)) {
 226                         dev_err(&dev->dev, "can't handle 64-bit BAR\n");
 227                         goto fail;
 228                 } else if ((sizeof(resource_size_t) < 8) && l) {
 229                         /* Address above 32-bit boundary; disable the BAR */
 230                         pci_write_config_dword(dev, pos, 0);
 231                         pci_write_config_dword(dev, pos + 4, 0);
 232                         res->start = 0;
 233                         res->end = sz64;
 234                 } else {
 235                         res->start = l64;
 236                         res->end = l64 + sz64;
 237                         dev_printk(KERN_DEBUG, &dev->dev,
 238                                 "reg %x 64bit mmio: %pR\n", pos, res);
 239                 }
 240         } else {
 241                 sz = pci_size(l, sz, mask);
 242
 243                 if (!sz)
 244                         goto fail;
 245
 246                 res->start = l;
 247                 res->end = l + sz;
 248
 249                 dev_printk(KERN_DEBUG, &dev->dev, "reg %x %s: %pR\n", pos,
 250                         (res->flags & IORESOURCE_IO) ? "io port" : "32bit mmio",
 251                         res);
 252         }
 253
 254  out:
 255         return (type == pci_bar_mem64) ? 1 : 0;
 256  fail:
 257         res->flags = 0;
 258         goto out;
 259 }
 260
 261 static void pci_read_bases(struct pci_dev *dev, unsigned int howmany, int rom)
 262 {
 263         unsigned int pos, reg;
 264
 265         for (pos = 0; pos < howmany; pos++) {
 266                 struct resource *res = &dev->resource[pos];
 267                 reg = PCI_BASE_ADDRESS_0 + (pos << 2);
 268                 pos += __pci_read_base(dev, pci_bar_unknown, res, reg);
 269         }
 270
 271         if (rom) {
 272                 struct resource *res = &dev->resource[PCI_ROM_RESOURCE];
 273                 dev->rom_base_reg = rom;
 274                 res->flags = IORESOURCE_MEM | IORESOURCE_PREFETCH |
 275                                 IORESOURCE_READONLY | IORESOURCE_CACHEABLE |
 276                                 IORESOURCE_SIZEALIGN;
 277                 __pci_read_base(dev, pci_bar_mem32, res, rom);
 278         }
 279 }
 280
 281 void __devinit pci_read_bridge_bases(struct pci_bus *child)
 282 {
 283         struct pci_dev *dev = child->self;
 284         u8 io_base_lo, io_limit_lo;
 285         u16 mem_base_lo, mem_limit_lo;
 286         unsigned long base, limit;
 287         struct resource *res;
 288         int i;
 289
 290         if (!dev)               /* It's a host bus, nothing to read */
 291                 return;
 292
 293         if (dev->transparent) {
 294                 dev_info(&dev->dev, "transparent bridge\n");
 295                 for(i = 3; i < PCI_BUS_NUM_RESOURCES; i++)
 296                         child->resource[i] = child->parent->resource[i - 3];
 297         }
 298
 299         res = child->resource[0];
 300         pci_read_config_byte(dev, PCI_IO_BASE, &io_base_lo);
 301         pci_read_config_byte(dev, PCI_IO_LIMIT, &io_limit_lo);
 302         base = (io_base_lo & PCI_IO_RANGE_MASK) << 8;
 303         limit = (io_limit_lo & PCI_IO_RANGE_MASK) << 8;
 304
 305         if ((io_base_lo & PCI_IO_RANGE_TYPE_MASK) == PCI_IO_RANGE_TYPE_32) {
 306                 u16 io_base_hi, io_limit_hi;
 307                 pci_read_config_word(dev, PCI_IO_BASE_UPPER16, &io_base_hi);
 308                 pci_read_config_word(dev, PCI_IO_LIMIT_UPPER16, &io_limit_hi);
 309                 base |= (io_base_hi << 16);
 310                 limit |= (io_limit_hi << 16);
 311         }
 312
 313         if (base <= limit) {
 314                 res->flags = (io_base_lo & PCI_IO_RANGE_TYPE_MASK) | IORESOURCE_IO;
 315                 if (!res->start)
 316                         res->start = base;
 317                 if (!res->end)
 318                         res->end = limit + 0xfff;
 319                 dev_printk(KERN_DEBUG, &dev->dev, "bridge io port: %pR\n", res);
 320         }
 321
 322         res = child->resource[1];
 323         pci_read_config_word(dev, PCI_MEMORY_BASE, &mem_base_lo);
 324         pci_read_config_word(dev, PCI_MEMORY_LIMIT, &mem_limit_lo);
 325         base = (mem_base_lo & PCI_MEMORY_RANGE_MASK) << 16;
 326         limit = (mem_limit_lo & PCI_MEMORY_RANGE_MASK) << 16;
 327         if (base <= limit) {
 328                 res->flags = (mem_base_lo & PCI_MEMORY_RANGE_TYPE_MASK) | IORESOURCE_MEM;
 329                 res->start = base;
 330                 res->end = limit + 0xfffff;
 331                 dev_printk(KERN_DEBUG, &dev->dev, "bridge 32bit mmio: %pR\n",
 332                         res);
 333         }
 334
 335         res = child->resource[2];
 336         pci_read_config_word(dev, PCI_PREF_MEMORY_BASE, &mem_base_lo);
 337         pci_read_config_word(dev, PCI_PREF_MEMORY_LIMIT, &mem_limit_lo);
 338         base = (mem_base_lo & PCI_PREF_RANGE_MASK) << 16;
 339         limit = (mem_limit_lo & PCI_PREF_RANGE_MASK) << 16;
 340
 341         if ((mem_base_lo & PCI_PREF_RANGE_TYPE_MASK) == PCI_PREF_RANGE_TYPE_64) {
 342                 u32 mem_base_hi, mem_limit_hi;
 343                 pci_read_config_dword(dev, PCI_PREF_BASE_UPPER32, &mem_base_hi);
 344                 pci_read_config_dword(dev, PCI_PREF_LIMIT_UPPER32, &mem_limit_hi);
 345
 346                 /*
 347                  * Some bridges set the base > limit by default, and some
 348                  * (broken) BIOSes do not initialize them.  If we find
 349                  * this, just assume they are not being used.
 350                  */
 351                 if (mem_base_hi <= mem_limit_hi) {
 352 #if BITS_PER_LONG == 64
 353                         base |= ((long) mem_base_hi) << 32;
 354                         limit |= ((long) mem_limit_hi) << 32;
 355 #else
 356                         if (mem_base_hi || mem_limit_hi) {
 357                                 dev_err(&dev->dev, "can't handle 64-bit "
 358                                         "address space for bridge\n");
 359                                 return;
 360                         }
 361 #endif
 362                 }
 363         }
 364         if (base <= limit) {
 365                 res->flags = (mem_base_lo & PCI_MEMORY_RANGE_TYPE_MASK) | IORESOURCE_MEM | IORESOURCE_PREFETCH;
 366                 res->start = base;
 367                 res->end = limit + 0xfffff;
 368                 dev_printk(KERN_DEBUG, &dev->dev, "bridge %sbit mmio pref: %pR\n",
 369                         (res->flags & PCI_PREF_RANGE_TYPE_64) ? "64" : "32",
 370                         res);
 371         }
 372 }
 373
 374 static struct pci_bus * pci_alloc_bus(void)
 375 {
 376         struct pci_bus *b;
 377
 378         b = kzalloc(sizeof(*b), GFP_KERNEL);
 379         if (b) {
 380                 INIT_LIST_HEAD(&b->node);
 381                 INIT_LIST_HEAD(&b->children);
 382                 INIT_LIST_HEAD(&b->devices);
 383                 INIT_LIST_HEAD(&b->slots);
 384         }
 385         return b;
 386 }
 387
 388 static struct pci_bus *pci_alloc_child_bus(struct pci_bus *parent,
 389                                            struct pci_dev *bridge, int busnr)
 390 {
 391         struct pci_bus *child;
 392         int i;
 393
 394         /*
 395          * Allocate a new bus, and inherit stuff from the parent..
 396          */
 397         child = pci_alloc_bus();
 398         if (!child)
 399                 return NULL;
 400
 401         child->self = bridge;
 402         child->parent = parent;
 403         child->ops = parent->ops;
 404         child->sysdata = parent->sysdata;
 405         child->bus_flags = parent->bus_flags;
 406         child->bridge = get_device(&bridge->dev);
 407
 408         /* initialize some portions of the bus device, but don't register it
 409          * now as the parent is not properly set up yet.  This device will get
 410          * registered later in pci_bus_add_devices()
 411          */
 412         child->dev.class = &pcibus_class;
 413         dev_set_name(&child->dev, "%04x:%02x", pci_domain_nr(child), busnr);
 414
 415         /*
 416          * Set up the primary, secondary and subordinate
 417          * bus numbers.
 418          */
 419         child->number = child->secondary = busnr;
 420         child->primary = parent->secondary;
 421         child->subordinate = 0xff;
 422
 423         /* Set up default resource pointers and names.. */
 424         for (i = 0; i < PCI_BRIDGE_RESOURCE_NUM; i++) {
 425                 child->resource[i] = &bridge->resource[PCI_BRIDGE_RESOURCES+i];
 426                 child->resource[i]->name = child->name;
 427         }
 428         bridge->subordinate = child;
 429
 430         return child;
 431 }
 432
 433 struct pci_bus *__ref pci_add_new_bus(struct pci_bus *parent, struct pci_dev *dev, int busnr)
 434 {
 435         struct pci_bus *child;
 436
 437         child = pci_alloc_child_bus(parent, dev, busnr);
 438         if (child) {
 439                 down_write(&pci_bus_sem);
 440                 list_add_tail(&child->node, &parent->children);
 441                 up_write(&pci_bus_sem);
 442         }
 443         return child;
 444 }
 445
 446 static void pci_fixup_parent_subordinate_busnr(struct pci_bus *child, int max)
 447 {
 448         struct pci_bus *parent = child->parent;
 449
 450         /* Attempts to fix that up are really dangerous unless
 451            we're going to re-assign all bus numbers. */
 452         if (!pcibios_assign_all_busses())
 453                 return;
 454
 455         while (parent->parent && parent->subordinate < max) {
 456                 parent->subordinate = max;
 457                 pci_write_config_byte(parent->self, PCI_SUBORDINATE_BUS, max);
 458                 parent = parent->parent;
 459         }
 460 }
 461
 462 /*
 463  * If it's a bridge, configure it and scan the bus behind it.
 464  * For CardBus bridges, we don't scan behind as the devices will
 465  * be handled by the bridge driver itself.
 466  *
 467  * We need to process bridges in two passes -- first we scan those
 468  * already configured by the BIOS and after we are done with all of
 469  * them, we proceed to assigning numbers to the remaining buses in
 470  * order to avoid overlaps between old and new bus numbers.
 471  */
 472 int __devinit pci_scan_bridge(struct pci_bus *bus, struct pci_dev *dev, int max, int pass)
 473 {
 474         struct pci_bus *child;
 475         int is_cardbus = (dev->hdr_type == PCI_HEADER_TYPE_CARDBUS);
 476         u32 buses, i, j = 0;
 477         u16 bctl;
 478         int broken = 0;
 479
 480         pci_read_config_dword(dev, PCI_PRIMARY_BUS, &buses);
 481
 482         dev_dbg(&dev->dev, "scanning behind bridge, config %06x, pass %d\n",
 483                 buses & 0xffffff, pass);
 484
 485         /* Check if setup is sensible at all */
 486         if (!pass &&
 487             ((buses & 0xff) != bus->number || ((buses >> 8) & 0xff) <= bus->number)) {
 488                 dev_dbg(&dev->dev, "bus configuration invalid, reconfiguring\n");
 489                 broken = 1;
 490         }
 491
 492         /* Disable MasterAbortMode during probing to avoid reporting
 493            of bus errors (in some architectures) */
 494         pci_read_config_word(dev, PCI_BRIDGE_CONTROL, &bctl);
 495         pci_write_config_word(dev, PCI_BRIDGE_CONTROL,
 496                               bctl & ~PCI_BRIDGE_CTL_MASTER_ABORT);
 497
 498         if ((buses & 0xffff00) && !pcibios_assign_all_busses() && !is_cardbus && !broken) {
 499                 unsigned int cmax, busnr;
 500                 /*
 501                  * Bus already configured by firmware, process it in the first
 502                  * pass and just note the configuration.
 503                  */
 504                 if (pass)
 505                         goto out;
 506                 busnr = (buses >> 8) & 0xFF;
 507
 508                 /*
 509                  * If we already got to this bus through a different bridge,
 510                  * ignore it.  This can happen with the i450NX chipset.
 511                  */
 512                 if (pci_find_bus(pci_domain_nr(bus), busnr)) {
 513                         dev_info(&dev->dev, "bus %04x:%02x already known\n",
 514                                  pci_domain_nr(bus), busnr);
 515                         goto out;
 516                 }
 517
 518                 child = pci_add_new_bus(bus, dev, busnr);
 519                 if (!child)
 520                         goto out;
 521                 child->primary = buses & 0xFF;
 522                 child->subordinate = (buses >> 16) & 0xFF;
 523                 child->bridge_ctl = bctl;
 524
 525                 cmax = pci_scan_child_bus(child);
 526                 if (cmax > max)
 527                         max = cmax;
 528                 if (child->subordinate > max)
 529                         max = child->subordinate;
 530         } else {
 531                 /*
 532                  * We need to assign a number to this bus which we always
 533                  * do in the second pass.
 534                  */
 535                 if (!pass) {
 536                         if (pcibios_assign_all_busses() || broken)
 537                                 /* Temporarily disable forwarding of the
 538                                    configuration cycles on all bridges in
 539                                    this bus segment to avoid possible
 540                                    conflicts in the second pass between two
 541                                    bridges programmed with overlapping
 542                                    bus ranges. */
 543                                 pci_write_config_dword(dev, PCI_PRIMARY_BUS,
 544                                                        buses & ~0xffffff);
 545                         goto out;
 546                 }
 547
 548                 /* Clear errors */
 549                 pci_write_config_word(dev, PCI_STATUS, 0xffff);
 550
 551                 /* Prevent assigning a bus number that already exists.
 552                  * This can happen when a bridge is hot-plugged */
 553                 if (pci_find_bus(pci_domain_nr(bus), max+1))
 554                         goto out;
 555                 child = pci_add_new_bus(bus, dev, ++max);
 556                 buses = (buses & 0xff000000)
 557                       | ((unsigned int)(child->primary)     <<  0)
 558                       | ((unsigned int)(child->secondary)   <<  8)
 559                       | ((unsigned int)(child->subordinate) << 16);
 560
 561                 /*
 562                  * yenta.c forces a secondary latency timer of 176.
 563                  * Copy that behaviour here.
 564                  */
 565                 if (is_cardbus) {
 566                         buses &= ~0xff000000;
 567                         buses |= CARDBUS_LATENCY_TIMER << 24;
 568                 }
 569
 570                 /*
 571                  * We need to blast all three values with a single write.
 572                  */
 573                 pci_write_config_dword(dev, PCI_PRIMARY_BUS, buses);
 574
 575                 if (!is_cardbus) {
 576                         child->bridge_ctl = bctl;
 577                         /*
 578                          * Adjust subordinate busnr in parent buses.
 579                          * We do this before scanning for children because
 580                          * some devices may not be detected if the bios
 581                          * was lazy.
 582                          */
 583                         pci_fixup_parent_subordinate_busnr(child, max);
 584                         /* Now we can scan all subordinate buses... */
 585                         max = pci_scan_child_bus(child);
 586                         /*
 587                          * now fix it up again since we have found
 588                          * the real value of max.
 589                          */
 590                         pci_fixup_parent_subordinate_busnr(child, max);
 591                 } else {
 592                         /*
 593                          * For CardBus bridges, we leave 4 bus numbers
 594                          * as cards with a PCI-to-PCI bridge can be
 595                          * inserted later.
 596                          */
 597                         for (i=0; i<CARDBUS_RESERVE_BUSNR; i++) {
 598                                 struct pci_bus *parent = bus;
 599                                 if (pci_find_bus(pci_domain_nr(bus),
 600                                                         max+i+1))
 601                                         break;
 602                                 while (parent->parent) {
 603                                         if ((!pcibios_assign_all_busses()) &&
 604                                             (parent->subordinate > max) &&
 605                                             (parent->subordinate <= max+i)) {
 606                                                 j = 1;
 607                                         }
 608                                         parent = parent->parent;
 609                                 }
 610                                 if (j) {
 611                                         /*
 612                                          * Often, there are two cardbus bridges
 613                                          * -- try to leave one valid bus number
 614                                          * for each one.
 615                                          */
 616                                         i /= 2;
 617                                         break;
 618                                 }
 619                         }
 620                         max += i;
 621                         pci_fixup_parent_subordinate_busnr(child, max);
 622                 }
 623                 /*
 624                  * Set the subordinate bus number to its real value.
 625                  */
 626                 child->subordinate = max;
 627                 pci_write_config_byte(dev, PCI_SUBORDINATE_BUS, max);
 628         }
 629
 630         sprintf(child->name,
 631                 (is_cardbus ? "PCI CardBus %04x:%02x" : "PCI Bus %04x:%02x"),
 632                 pci_domain_nr(bus), child->number);
 633
 634         /* Has only triggered on CardBus, fixup is in yenta_socket */
 635         while (bus->parent) {
 636                 if ((child->subordinate > bus->subordinate) ||
 637                     (child->number > bus->subordinate) ||
 638                     (child->number < bus->number) ||
 639                     (child->subordinate < bus->number)) {
 640                         pr_debug("PCI: Bus #%02x (-#%02x) is %s "
 641                                 "hidden behind%s bridge #%02x (-#%02x)\n",
 642                                 child->number, child->subordinate,
 643                                 (bus->number > child->subordinate &&
 644                                  bus->subordinate < child->number) ?
 645                                         "wholly" : "partially",
 646                                 bus->self->transparent ? " transparent" : "",
 647                                 bus->number, bus->subordinate);
 648                 }
 649                 bus = bus->parent;
 650         }
 651
 652 out:
 653         pci_write_config_word(dev, PCI_BRIDGE_CONTROL, bctl);
 654
 655         return max;
 656 }
 657
 658 /*
 659  * Read interrupt line and base address registers.
 660  * The architecture-dependent code can tweak these, of course.
 661  */
 662 static void pci_read_irq(struct pci_dev *dev)
 663 {
 664         unsigned char irq;
 665
 666         pci_read_config_byte(dev, PCI_INTERRUPT_PIN, &irq);
 667         dev->pin = irq;
 668         if (irq)
 669                 pci_read_config_byte(dev, PCI_INTERRUPT_LINE, &irq);
 670         dev->irq = irq;
 671 }
 672
 673 #define LEGACY_IO_RESOURCE      (IORESOURCE_IO | IORESOURCE_PCI_FIXED)
 674
 675 /**
 676  * pci_setup_device - fill in class and map information of a device
 677  * @dev: the device structure to fill
 678  *
 679  * Initialize the device structure with information about the device's
 680  * vendor,class,memory and IO-space addresses,IRQ lines etc.
 681  * Called at initialisation of the PCI subsystem and by CardBus services.
 682  * Returns 0 on success and -1 if unknown type of device (not normal, bridge
 683  * or CardBus).
 684  */
 685 static int pci_setup_device(struct pci_dev * dev)
 686 {
 687         u32 class;
 688
 689         dev_set_name(&dev->dev, "%04x:%02x:%02x.%d", pci_domain_nr(dev->bus),
 690                      dev->bus->number, PCI_SLOT(dev->devfn),
 691                      PCI_FUNC(dev->devfn));
 692
 693         pci_read_config_dword(dev, PCI_CLASS_REVISION, &class);
 694         dev->revision = class & 0xff;
 695         class >>= 8;                                /* upper 3 bytes */
 696         dev->class = class;
 697         class >>= 8;
 698
 699         dev_dbg(&dev->dev, "found [%04x:%04x] class %06x header type %02x\n",
 700                  dev->vendor, dev->device, class, dev->hdr_type);
 701
 702         /* "Unknown power state" */
 703         dev->current_state = PCI_UNKNOWN;
 704
 705         /* Early fixups, before probing the BARs */
 706         pci_fixup_device(pci_fixup_early, dev);
 707         class = dev->class >> 8;
 708
 709         switch (dev->hdr_type) {                    /* header type */
 710         case PCI_HEADER_TYPE_NORMAL:                /* standard header */
 711                 if (class == PCI_CLASS_BRIDGE_PCI)
 712                         goto bad;
 713                 pci_read_irq(dev);
 714                 pci_read_bases(dev, 6, PCI_ROM_ADDRESS);
 715                 pci_read_config_word(dev, PCI_SUBSYSTEM_VENDOR_ID, &dev->subsystem_vendor);
 716                 pci_read_config_word(dev, PCI_SUBSYSTEM_ID, &dev->subsystem_device);
 717
 718                 /*
 719                  *      Do the ugly legacy mode stuff here rather than broken chip
 720                  *      quirk code. Legacy mode ATA controllers have fixed
 721                  *      addresses. These are not always echoed in BAR0-3, and
 722                  *      BAR0-3 in a few cases contain junk!
 723                  */
 724                 if (class == PCI_CLASS_STORAGE_IDE) {
 725                         u8 progif;
 726                         pci_read_config_byte(dev, PCI_CLASS_PROG, &progif);
 727                         if ((progif & 1) == 0) {
 728                                 dev->resource[0].start = 0x1F0;
 729                                 dev->resource[0].end = 0x1F7;
 730                                 dev->resource[0].flags = LEGACY_IO_RESOURCE;
 731                                 dev->resource[1].start = 0x3F6;
 732                                 dev->resource[1].end = 0x3F6;
 733                                 dev->resource[1].flags = LEGACY_IO_RESOURCE;
 734                         }
 735                         if ((progif & 4) == 0) {
 736                                 dev->resource[2].start = 0x170;
 737                                 dev->resource[2].end = 0x177;
 738                                 dev->resource[2].flags = LEGACY_IO_RESOURCE;
 739                                 dev->resource[3].start = 0x376;
 740                                 dev->resource[3].end = 0x376;
 741                                 dev->resource[3].flags = LEGACY_IO_RESOURCE;
 742                         }
 743                 }
 744                 break;
 745
 746         case PCI_HEADER_TYPE_BRIDGE:                /* bridge header */
 747                 if (class != PCI_CLASS_BRIDGE_PCI)
 748                         goto bad;
 749                 /* The PCI-to-PCI bridge spec requires that subtractive
 750                    decoding (i.e. transparent) bridge must have programming
 751                    interface code of 0x01. */
 752                 pci_read_irq(dev);
 753                 dev->transparent = ((dev->class & 0xff) == 1);
 754                 pci_read_bases(dev, 2, PCI_ROM_ADDRESS1);
 755                 break;
 756
 757         case PCI_HEADER_TYPE_CARDBUS:               /* CardBus bridge header */
 758                 if (class != PCI_CLASS_BRIDGE_CARDBUS)
 759                         goto bad;
 760                 pci_read_irq(dev);
 761                 pci_read_bases(dev, 1, 0);
 762                 pci_read_config_word(dev, PCI_CB_SUBSYSTEM_VENDOR_ID, &dev->subsystem_vendor);
 763                 pci_read_config_word(dev, PCI_CB_SUBSYSTEM_ID, &dev->subsystem_device);
 764                 break;
 765
 766         default:                                    /* unknown header */
 767                 dev_err(&dev->dev, "unknown header type %02x, "
 768                         "ignoring device\n", dev->hdr_type);
 769                 return -1;
 770
 771         bad:
 772                 dev_err(&dev->dev, "ignoring class %02x (doesn't match header "
 773                         "type %02x)\n", class, dev->hdr_type);
 774                 dev->class = PCI_CLASS_NOT_DEFINED;
 775         }
 776
 777         /* We found a fine healthy device, go go go... */
 778         return 0;
 779 }
 780
 781 static void pci_release_capabilities(struct pci_dev *dev)
 782 {
 783         pci_vpd_release(dev);
 784 }
 785
 786 /**
 787  * pci_release_dev - free a pci device structure when all users of it are finished.
 788  * @dev: device that's been disconnected
 789  *
 790  * Will be called only by the device core when all users of this pci device are
 791  * done.
 792  */
 793 static void pci_release_dev(struct device *dev)
 794 {
 795         struct pci_dev *pci_dev;
 796
 797         pci_dev = to_pci_dev(dev);
 798         pci_release_capabilities(pci_dev);
 799         kfree(pci_dev);
 800 }
 801
 802 static void set_pcie_port_type(struct pci_dev *pdev)
 803 {
 804         int pos;
 805         u16 reg16;
 806
 807         pos = pci_find_capability(pdev, PCI_CAP_ID_EXP);
 808         if (!pos)
 809                 return;
 810         pdev->is_pcie = 1;
 811         pci_read_config_word(pdev, pos + PCI_EXP_FLAGS, &reg16);
 812         pdev->pcie_type = (reg16 & PCI_EXP_FLAGS_TYPE) >> 4;
 813 }
 814
 815 /**
 816  * pci_cfg_space_size - get the configuration space size of the PCI device.
 817  * @dev: PCI device
 818  *
 819  * Regular PCI devices have 256 bytes, but PCI-X 2 and PCI Express devices
 820  * have 4096 bytes.  Even if the device is capable, that doesn't mean we can
 821  * access it.  Maybe we don't have a way to generate extended config space
 822  * accesses, or the device is behind a reverse Express bridge.  So we try
 823  * reading the dword at 0x100 which must either be 0 or a valid extended
 824  * capability header.
 825  */
 826 int pci_cfg_space_size_ext(struct pci_dev *dev)
 827 {
 828         u32 status;
 829         int pos = PCI_CFG_SPACE_SIZE;
 830
 831         if (pci_read_config_dword(dev, pos, &status) != PCIBIOS_SUCCESSFUL)
 832                 goto fail;
 833         if (status == 0xffffffff)
 834                 goto fail;
 835
 836         return PCI_CFG_SPACE_EXP_SIZE;
 837
 838  fail:
 839         return PCI_CFG_SPACE_SIZE;
 840 }
 841
 842 int pci_cfg_space_size(struct pci_dev *dev)
 843 {
 844         int pos;
 845         u32 status;
 846
 847         pos = pci_find_capability(dev, PCI_CAP_ID_EXP);
 848         if (!pos) {
 849                 pos = pci_find_capability(dev, PCI_CAP_ID_PCIX);
 850                 if (!pos)
 851                         goto fail;
 852
 853                 pci_read_config_dword(dev, pos + PCI_X_STATUS, &status);
 854                 if (!(status & (PCI_X_STATUS_266MHZ | PCI_X_STATUS_533MHZ)))
 855                         goto fail;
 856         }
 857
 858         return pci_cfg_space_size_ext(dev);
 859
 860  fail:
 861         return PCI_CFG_SPACE_SIZE;
 862 }
 863
 864 static void pci_release_bus_bridge_dev(struct device *dev)
 865 {
 866         kfree(dev);
 867 }
 868
 869 struct pci_dev *alloc_pci_dev(void)
 870 {
 871         struct pci_dev *dev;
 872
 873         dev = kzalloc(sizeof(struct pci_dev), GFP_KERNEL);
 874         if (!dev)
 875                 return NULL;
 876
 877         INIT_LIST_HEAD(&dev->bus_list);
 878
 879         return dev;
 880 }
 881 EXPORT_SYMBOL(alloc_pci_dev);
 882
 883 /*
 884  * Read the config data for a PCI device, sanity-check it
 885  * and fill in the dev structure...
 886  */
 887 static struct pci_dev *pci_scan_device(struct pci_bus *bus, int devfn)
 888 {
 889         struct pci_dev *dev;
 890         struct pci_slot *slot;
 891         u32 l;
 892         u8 hdr_type;
 893         int delay = 1;
 894
 895         if (pci_bus_read_config_dword(bus, devfn, PCI_VENDOR_ID, &l))
 896                 return NULL;
 897
 898         /* some broken boards return 0 or ~0 if a slot is empty: */
 899         if (l == 0xffffffff || l == 0x00000000 ||
 900             l == 0x0000ffff || l == 0xffff0000)
 901                 return NULL;
 902
 903         /* Configuration request Retry Status */
 904         while (l == 0xffff0001) {
 905                 msleep(delay);
 906                 delay *= 2;
 907                 if (pci_bus_read_config_dword(bus, devfn, PCI_VENDOR_ID, &l))
 908                         return NULL;
 909                 /* Card hasn't responded in 60 seconds?  Must be stuck. */
 910                 if (delay > 60 * 1000) {
 911                         printk(KERN_WARNING "pci %04x:%02x:%02x.%d: not "
 912                                         "responding\n", pci_domain_nr(bus),
 913                                         bus->number, PCI_SLOT(devfn),
 914                                         PCI_FUNC(devfn));
 915                         return NULL;
 916                 }
 917         }
 918
 919         if (pci_bus_read_config_byte(bus, devfn, PCI_HEADER_TYPE, &hdr_type))
 920                 return NULL;
 921
 922         dev = alloc_pci_dev();
 923         if (!dev)
 924                 return NULL;
 925
 926         dev->bus = bus;
 927         dev->sysdata = bus->sysdata;
 928         dev->dev.parent = bus->bridge;
 929         dev->dev.bus = &pci_bus_type;
 930         dev->devfn = devfn;
 931         dev->hdr_type = hdr_type & 0x7f;
 932         dev->multifunction = !!(hdr_type & 0x80);
 933         dev->vendor = l & 0xffff;
 934         dev->device = (l >> 16) & 0xffff;
 935         dev->cfg_size = pci_cfg_space_size(dev);
 936         dev->error_state = pci_channel_io_normal;
 937         set_pcie_port_type(dev);
 938
 939         list_for_each_entry(slot, &bus->slots, list)
 940                 if (PCI_SLOT(devfn) == slot->number)
 941                         dev->slot = slot;
 942
 943         /* Assume 32-bit PCI; let 64-bit PCI cards (which are far rarer)
 944            set this higher, assuming the system even supports it.  */
 945         dev->dma_mask = 0xffffffff;
 946         if (pci_setup_device(dev) < 0) {
 947                 kfree(dev);
 948                 return NULL;
 949         }
 950
 951         return dev;
 952 }
 953
 954 static void pci_init_capabilities(struct pci_dev *dev)
 955 {
 956         /* MSI/MSI-X list */
 957         pci_msi_init_pci_dev(dev);
 958
 959         /* Buffers for saving PCIe and PCI-X capabilities */
 960         pci_allocate_cap_save_buffers(dev);
 961
 962         /* Power Management */
 963         pci_pm_init(dev);
 964
 965         /* Vital Product Data */
 966         pci_vpd_pci22_init(dev);
 967
 968         /* Alternative Routing-ID Forwarding */
 969         pci_enable_ari(dev);
 970 }
 971
 972 void pci_device_add(struct pci_dev *dev, struct pci_bus *bus)
 973 {
 974         device_initialize(&dev->dev);
 975         dev->dev.release = pci_release_dev;
 976         pci_dev_get(dev);
 977
 978         dev->dev.dma_mask = &dev->dma_mask;
 979         dev->dev.dma_parms = &dev->dma_parms;
 980         dev->dev.coherent_dma_mask = 0xffffffffull;
 981
 982         pci_set_dma_max_seg_size(dev, 65536);
 983         pci_set_dma_seg_boundary(dev, 0xffffffff);
 984
 985         /* Fix up broken headers */
 986         pci_fixup_device(pci_fixup_header, dev);
 987
 988         /* Initialize various capabilities */
 989         pci_init_capabilities(dev);
 990
 991         /*
 992          * Add the device to our list of discovered devices
 993          * and the bus list for fixup functions, etc.
 994          */
 995         down_write(&pci_bus_sem);
 996         list_add_tail(&dev->bus_list, &bus->devices);
 997         up_write(&pci_bus_sem);
 998 }
 999
1000 struct pci_dev *__ref pci_scan_single_device(struct pci_bus *bus, int devfn)
1001 {
1002         struct pci_dev *dev;
1003
1004         dev = pci_scan_device(bus, devfn);
1005         if (!dev)
1006                 return NULL;
1007
1008         pci_device_add(dev, bus);
1009
1010         return dev;
1011 }
1012 EXPORT_SYMBOL(pci_scan_single_device);
1013
1014 /**
1015  * pci_scan_slot - scan a PCI slot on a bus for devices.
1016  * @bus: PCI bus to scan
1017  * @devfn: slot number to scan (must have zero function.)
1018  *
1019  * Scan a PCI slot on the specified PCI bus for devices, adding
1020  * discovered devices to the @bus->devices list.  New devices
1021  * will not have is_added set.
1022  */
1023 int pci_scan_slot(struct pci_bus *bus, int devfn)
1024 {
1025         int func, nr = 0;
1026         int scan_all_fns;
1027
1028         scan_all_fns = pcibios_scan_all_fns(bus, devfn);
1029
1030         for (func = 0; func < 8; func++, devfn++) {
1031                 struct pci_dev *dev;
1032
1033                 dev = pci_scan_single_device(bus, devfn);
1034                 if (dev) {
1035                         nr++;
1036
1037                         /*
1038                          * If this is a single function device,
1039                          * don't scan past the first function.
1040                          */
1041                         if (!dev->multifunction) {
1042                                 if (func > 0) {
1043                                         dev->multifunction = 1;
1044                                 } else {
1045                                         break;
1046                                 }
1047                         }
1048                 } else {
1049                         if (func == 0 && !scan_all_fns)
1050                                 break;
1051                 }
1052         }
1053
1054         /* only one slot has pcie device */
1055         if (bus->self && nr)
1056                 pcie_aspm_init_link_state(bus->self);
1057
1058         return nr;
1059 }
1060
1061 unsigned int __devinit pci_scan_child_bus(struct pci_bus *bus)
1062 {
1063         unsigned int devfn, pass, max = bus->secondary;
1064         struct pci_dev *dev;
1065
1066         pr_debug("PCI: Scanning bus %04x:%02x\n", pci_domain_nr(bus), bus->number);
1067
1068         /* Go find them, Rover! */
1069         for (devfn = 0; devfn < 0x100; devfn += 8)
1070                 pci_scan_slot(bus, devfn);
1071
1072         /*
1073          * After performing arch-dependent fixup of the bus, look behind
1074          * all PCI-to-PCI bridges on this bus.
1075          */
1076         pr_debug("PCI: Fixups for bus %04x:%02x\n", pci_domain_nr(bus), bus->number);
1077         pcibios_fixup_bus(bus);
1078         for (pass=0; pass < 2; pass++)
1079                 list_for_each_entry(dev, &bus->devices, bus_list) {
1080                         if (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE ||
1081                             dev->hdr_type == PCI_HEADER_TYPE_CARDBUS)
1082                                 max = pci_scan_bridge(bus, dev, max, pass);
1083                 }
1084
1085         /*
1086          * We've scanned the bus and so we know all about what's on
1087          * the other side of any bridges that may be on this bus plus
1088          * any devices.
1089          *
1090          * Return how far we've got finding sub-buses.
1091          */
1092         pr_debug("PCI: Bus scan for %04x:%02x returning with max=%02x\n",
1093                 pci_domain_nr(bus), bus->number, max);
1094         return max;
1095 }
1096
1097 void __attribute__((weak)) set_pci_bus_resources_arch_default(struct pci_bus *b)
1098 {
1099 }
1100
1101 struct pci_bus * pci_create_bus(struct device *parent,
1102                 int bus, struct pci_ops *ops, void *sysdata)
1103 {
1104         int error;
1105         struct pci_bus *b;
1106         struct device *dev;
1107
1108         b = pci_alloc_bus();
1109         if (!b)
1110                 return NULL;
1111
1112         dev = kmalloc(sizeof(*dev), GFP_KERNEL);
1113         if (!dev){
1114                 kfree(b);
1115                 return NULL;
1116         }
1117
1118         b->sysdata = sysdata;
1119         b->ops = ops;
1120
1121         if (pci_find_bus(pci_domain_nr(b), bus)) {
1122                 /* If we already got to this bus through a different bridge, ignore it */
1123                 pr_debug("PCI: Bus %04x:%02x already known\n", pci_domain_nr(b), bus);
1124                 goto err_out;
1125         }
1126
1127         down_write(&pci_bus_sem);
1128         list_add_tail(&b->node, &pci_root_buses);
1129         up_write(&pci_bus_sem);
1130
1131         memset(dev, 0, sizeof(*dev));
1132         dev->parent = parent;
1133         dev->release = pci_release_bus_bridge_dev;
1134         dev_set_name(dev, "pci%04x:%02x", pci_domain_nr(b), bus);
1135         error = device_register(dev);
1136         if (error)
1137                 goto dev_reg_err;
1138         b->bridge = get_device(dev);
1139
1140         if (!parent)
1141                 set_dev_node(b->bridge, pcibus_to_node(b));
1142
1143         b->dev.class = &pcibus_class;
1144         b->dev.parent = b->bridge;
1145         dev_set_name(&b->dev, "%04x:%02x", pci_domain_nr(b), bus);
1146         error = device_register(&b->dev);
1147         if (error)
1148                 goto class_dev_reg_err;
1149         error = device_create_file(&b->dev, &dev_attr_cpuaffinity);
1150         if (error)
1151                 goto dev_create_file_err;
1152
1153         /* Create legacy_io and legacy_mem files for this bus */
1154         pci_create_legacy_files(b);
1155
1156         b->number = b->secondary = bus;
1157         b->resource[0] = &ioport_resource;
1158         b->resource[1] = &iomem_resource;
1159
1160         set_pci_bus_resources_arch_default(b);
1161
1162         return b;
1163
1164 dev_create_file_err:
1165         device_unregister(&b->dev);
1166 class_dev_reg_err:
1167         device_unregister(dev);
1168 dev_reg_err:
1169         down_write(&pci_bus_sem);
1170         list_del(&b->node);
1171         up_write(&pci_bus_sem);
1172 err_out:
1173         kfree(dev);
1174         kfree(b);
1175         return NULL;
1176 }
1177
1178 struct pci_bus * __devinit pci_scan_bus_parented(struct device *parent,
1179                 int bus, struct pci_ops *ops, void *sysdata)
1180 {
1181         struct pci_bus *b;
1182
1183         b = pci_create_bus(parent, bus, ops, sysdata);
1184         if (b)
1185                 b->subordinate = pci_scan_child_bus(b);
1186         return b;
1187 }
1188 EXPORT_SYMBOL(pci_scan_bus_parented);
1189
1190 #ifdef CONFIG_HOTPLUG
1191 EXPORT_SYMBOL(pci_add_new_bus);
1192 EXPORT_SYMBOL(pci_scan_slot);
1193 EXPORT_SYMBOL(pci_scan_bridge);
1194 EXPORT_SYMBOL_GPL(pci_scan_child_bus);
1195 #endif
1196
1197 static int __init pci_sort_bf_cmp(const struct device *d_a, const struct device *d_b)
1198 {
1199         const struct pci_dev *a = to_pci_dev(d_a);
1200         const struct pci_dev *b = to_pci_dev(d_b);
1201
1202         if      (pci_domain_nr(a->bus) < pci_domain_nr(b->bus)) return -1;
1203         else if (pci_domain_nr(a->bus) > pci_domain_nr(b->bus)) return  1;
1204
1205         if      (a->bus->number < b->bus->number) return -1;
1206         else if (a->bus->number > b->bus->number) return  1;
1207
1208         if      (a->devfn < b->devfn) return -1;
1209         else if (a->devfn > b->devfn) return  1;
1210
1211         return 0;
1212 }
1213
1214 void __init pci_sort_breadthfirst(void)
1215 {
1216         bus_sort_breadthfirst(&pci_bus_type, &pci_sort_bf_cmp);
1217 }