SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/pci/probe.c

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