git.oblomov.eu Git - 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         for(i=0; i<3; i++)
 302                 child->resource[i] = &dev->resource[PCI_BRIDGE_RESOURCES+i];
 303
 304         res = child->resource[0];
 305         pci_read_config_byte(dev, PCI_IO_BASE, &io_base_lo);
 306         pci_read_config_byte(dev, PCI_IO_LIMIT, &io_limit_lo);
 307         base = (io_base_lo & PCI_IO_RANGE_MASK) << 8;
 308         limit = (io_limit_lo & PCI_IO_RANGE_MASK) << 8;
 309
 310         if ((io_base_lo & PCI_IO_RANGE_TYPE_MASK) == PCI_IO_RANGE_TYPE_32) {
 311                 u16 io_base_hi, io_limit_hi;
 312                 pci_read_config_word(dev, PCI_IO_BASE_UPPER16, &io_base_hi);
 313                 pci_read_config_word(dev, PCI_IO_LIMIT_UPPER16, &io_limit_hi);
 314                 base |= (io_base_hi << 16);
 315                 limit |= (io_limit_hi << 16);
 316         }
 317
 318         if (base <= limit) {
 319                 res->flags = (io_base_lo & PCI_IO_RANGE_TYPE_MASK) | IORESOURCE_IO;
 320                 if (!res->start)
 321                         res->start = base;
 322                 if (!res->end)
 323                         res->end = limit + 0xfff;
 324                 dev_printk(KERN_DEBUG, &dev->dev, "bridge io port: %pR\n", res);
 325         }
 326
 327         res = child->resource[1];
 328         pci_read_config_word(dev, PCI_MEMORY_BASE, &mem_base_lo);
 329         pci_read_config_word(dev, PCI_MEMORY_LIMIT, &mem_limit_lo);
 330         base = (mem_base_lo & PCI_MEMORY_RANGE_MASK) << 16;
 331         limit = (mem_limit_lo & PCI_MEMORY_RANGE_MASK) << 16;
 332         if (base <= limit) {
 333                 res->flags = (mem_base_lo & PCI_MEMORY_RANGE_TYPE_MASK) | IORESOURCE_MEM;
 334                 res->start = base;
 335                 res->end = limit + 0xfffff;
 336                 dev_printk(KERN_DEBUG, &dev->dev, "bridge 32bit mmio: %pR\n",
 337                         res);
 338         }
 339
 340         res = child->resource[2];
 341         pci_read_config_word(dev, PCI_PREF_MEMORY_BASE, &mem_base_lo);
 342         pci_read_config_word(dev, PCI_PREF_MEMORY_LIMIT, &mem_limit_lo);
 343         base = (mem_base_lo & PCI_PREF_RANGE_MASK) << 16;
 344         limit = (mem_limit_lo & PCI_PREF_RANGE_MASK) << 16;
 345
 346         if ((mem_base_lo & PCI_PREF_RANGE_TYPE_MASK) == PCI_PREF_RANGE_TYPE_64) {
 347                 u32 mem_base_hi, mem_limit_hi;
 348                 pci_read_config_dword(dev, PCI_PREF_BASE_UPPER32, &mem_base_hi);
 349                 pci_read_config_dword(dev, PCI_PREF_LIMIT_UPPER32, &mem_limit_hi);
 350
 351                 /*
 352                  * Some bridges set the base > limit by default, and some
 353                  * (broken) BIOSes do not initialize them.  If we find
 354                  * this, just assume they are not being used.
 355                  */
 356                 if (mem_base_hi <= mem_limit_hi) {
 357 #if BITS_PER_LONG == 64
 358                         base |= ((long) mem_base_hi) << 32;
 359                         limit |= ((long) mem_limit_hi) << 32;
 360 #else
 361                         if (mem_base_hi || mem_limit_hi) {
 362                                 dev_err(&dev->dev, "can't handle 64-bit "
 363                                         "address space for bridge\n");
 364                                 return;
 365                         }
 366 #endif
 367                 }
 368         }
 369         if (base <= limit) {
 370                 res->flags = (mem_base_lo & PCI_MEMORY_RANGE_TYPE_MASK) | IORESOURCE_MEM | IORESOURCE_PREFETCH;
 371                 res->start = base;
 372                 res->end = limit + 0xfffff;
 373                 dev_printk(KERN_DEBUG, &dev->dev, "bridge %sbit mmio pref: %pR\n",
 374                         (res->flags & PCI_PREF_RANGE_TYPE_64) ? "64" : "32",
 375                         res);
 376         }
 377 }
 378
 379 static struct pci_bus * pci_alloc_bus(void)
 380 {
 381         struct pci_bus *b;
 382
 383         b = kzalloc(sizeof(*b), GFP_KERNEL);
 384         if (b) {
 385                 INIT_LIST_HEAD(&b->node);
 386                 INIT_LIST_HEAD(&b->children);
 387                 INIT_LIST_HEAD(&b->devices);
 388                 INIT_LIST_HEAD(&b->slots);
 389         }
 390         return b;
 391 }
 392
 393 static struct pci_bus *pci_alloc_child_bus(struct pci_bus *parent,
 394                                            struct pci_dev *bridge, int busnr)
 395 {
 396         struct pci_bus *child;
 397         int i;
 398
 399         /*
 400          * Allocate a new bus, and inherit stuff from the parent..
 401          */
 402         child = pci_alloc_bus();
 403         if (!child)
 404                 return NULL;
 405
 406         child->self = bridge;
 407         child->parent = parent;
 408         child->ops = parent->ops;
 409         child->sysdata = parent->sysdata;
 410         child->bus_flags = parent->bus_flags;
 411         child->bridge = get_device(&bridge->dev);
 412
 413         /* initialize some portions of the bus device, but don't register it
 414          * now as the parent is not properly set up yet.  This device will get
 415          * registered later in pci_bus_add_devices()
 416          */
 417         child->dev.class = &pcibus_class;
 418         sprintf(child->dev.bus_id, "%04x:%02x", pci_domain_nr(child), busnr);
 419
 420         /*
 421          * Set up the primary, secondary and subordinate
 422          * bus numbers.
 423          */
 424         child->number = child->secondary = busnr;
 425         child->primary = parent->secondary;
 426         child->subordinate = 0xff;
 427
 428         /* Set up default resource pointers and names.. */
 429         for (i = 0; i < 4; i++) {
 430                 child->resource[i] = &bridge->resource[PCI_BRIDGE_RESOURCES+i];
 431                 child->resource[i]->name = child->name;
 432         }
 433         bridge->subordinate = child;
 434
 435         return child;
 436 }
 437
 438 struct pci_bus *__ref pci_add_new_bus(struct pci_bus *parent, struct pci_dev *dev, int busnr)
 439 {
 440         struct pci_bus *child;
 441
 442         child = pci_alloc_child_bus(parent, dev, busnr);
 443         if (child) {
 444                 down_write(&pci_bus_sem);
 445                 list_add_tail(&child->node, &parent->children);
 446                 up_write(&pci_bus_sem);
 447         }
 448         return child;
 449 }
 450
 451 static void pci_fixup_parent_subordinate_busnr(struct pci_bus *child, int max)
 452 {
 453         struct pci_bus *parent = child->parent;
 454
 455         /* Attempts to fix that up are really dangerous unless
 456            we're going to re-assign all bus numbers. */
 457         if (!pcibios_assign_all_busses())
 458                 return;
 459
 460         while (parent->parent && parent->subordinate < max) {
 461                 parent->subordinate = max;
 462                 pci_write_config_byte(parent->self, PCI_SUBORDINATE_BUS, max);
 463                 parent = parent->parent;
 464         }
 465 }
 466
 467 /*
 468  * If it's a bridge, configure it and scan the bus behind it.
 469  * For CardBus bridges, we don't scan behind as the devices will
 470  * be handled by the bridge driver itself.
 471  *
 472  * We need to process bridges in two passes -- first we scan those
 473  * already configured by the BIOS and after we are done with all of
 474  * them, we proceed to assigning numbers to the remaining buses in
 475  * order to avoid overlaps between old and new bus numbers.
 476  */
 477 int __devinit pci_scan_bridge(struct pci_bus *bus, struct pci_dev *dev, int max, int pass)
 478 {
 479         struct pci_bus *child;
 480         int is_cardbus = (dev->hdr_type == PCI_HEADER_TYPE_CARDBUS);
 481         u32 buses, i, j = 0;
 482         u16 bctl;
 483         int broken = 0;
 484
 485         pci_read_config_dword(dev, PCI_PRIMARY_BUS, &buses);
 486
 487         dev_dbg(&dev->dev, "scanning behind bridge, config %06x, pass %d\n",
 488                 buses & 0xffffff, pass);
 489
 490         /* Check if setup is sensible at all */
 491         if (!pass &&
 492             ((buses & 0xff) != bus->number || ((buses >> 8) & 0xff) <= bus->number)) {
 493                 dev_dbg(&dev->dev, "bus configuration invalid, reconfiguring\n");
 494                 broken = 1;
 495         }
 496
 497         /* Disable MasterAbortMode during probing to avoid reporting
 498            of bus errors (in some architectures) */
 499         pci_read_config_word(dev, PCI_BRIDGE_CONTROL, &bctl);
 500         pci_write_config_word(dev, PCI_BRIDGE_CONTROL,
 501                               bctl & ~PCI_BRIDGE_CTL_MASTER_ABORT);
 502
 503         if ((buses & 0xffff00) && !pcibios_assign_all_busses() && !is_cardbus && !broken) {
 504                 unsigned int cmax, busnr;
 505                 /*
 506                  * Bus already configured by firmware, process it in the first
 507                  * pass and just note the configuration.
 508                  */
 509                 if (pass)
 510                         goto out;
 511                 busnr = (buses >> 8) & 0xFF;
 512
 513                 /*
 514                  * If we already got to this bus through a different bridge,
 515                  * ignore it.  This can happen with the i450NX chipset.
 516                  */
 517                 if (pci_find_bus(pci_domain_nr(bus), busnr)) {
 518                         dev_info(&dev->dev, "bus %04x:%02x already known\n",
 519                                  pci_domain_nr(bus), busnr);
 520                         goto out;
 521                 }
 522
 523                 child = pci_add_new_bus(bus, dev, busnr);
 524                 if (!child)
 525                         goto out;
 526                 child->primary = buses & 0xFF;
 527                 child->subordinate = (buses >> 16) & 0xFF;
 528                 child->bridge_ctl = bctl;
 529
 530                 cmax = pci_scan_child_bus(child);
 531                 if (cmax > max)
 532                         max = cmax;
 533                 if (child->subordinate > max)
 534                         max = child->subordinate;
 535         } else {
 536                 /*
 537                  * We need to assign a number to this bus which we always
 538                  * do in the second pass.
 539                  */
 540                 if (!pass) {
 541                         if (pcibios_assign_all_busses() || broken)
 542                                 /* Temporarily disable forwarding of the
 543                                    configuration cycles on all bridges in
 544                                    this bus segment to avoid possible
 545                                    conflicts in the second pass between two
 546                                    bridges programmed with overlapping
 547                                    bus ranges. */
 548                                 pci_write_config_dword(dev, PCI_PRIMARY_BUS,
 549                                                        buses & ~0xffffff);
 550                         goto out;
 551                 }
 552
 553                 /* Clear errors */
 554                 pci_write_config_word(dev, PCI_STATUS, 0xffff);
 555
 556                 /* Prevent assigning a bus number that already exists.
 557                  * This can happen when a bridge is hot-plugged */
 558                 if (pci_find_bus(pci_domain_nr(bus), max+1))
 559                         goto out;
 560                 child = pci_add_new_bus(bus, dev, ++max);
 561                 buses = (buses & 0xff000000)
 562                       | ((unsigned int)(child->primary)     <<  0)
 563                       | ((unsigned int)(child->secondary)   <<  8)
 564                       | ((unsigned int)(child->subordinate) << 16);
 565
 566                 /*
 567                  * yenta.c forces a secondary latency timer of 176.
 568                  * Copy that behaviour here.
 569                  */
 570                 if (is_cardbus) {
 571                         buses &= ~0xff000000;
 572                         buses |= CARDBUS_LATENCY_TIMER << 24;
 573                 }
 574
 575                 /*
 576                  * We need to blast all three values with a single write.
 577                  */
 578                 pci_write_config_dword(dev, PCI_PRIMARY_BUS, buses);
 579
 580                 if (!is_cardbus) {
 581                         child->bridge_ctl = bctl;
 582                         /*
 583                          * Adjust subordinate busnr in parent buses.
 584                          * We do this before scanning for children because
 585                          * some devices may not be detected if the bios
 586                          * was lazy.
 587                          */
 588                         pci_fixup_parent_subordinate_busnr(child, max);
 589                         /* Now we can scan all subordinate buses... */
 590                         max = pci_scan_child_bus(child);
 591                         /*
 592                          * now fix it up again since we have found
 593                          * the real value of max.
 594                          */
 595                         pci_fixup_parent_subordinate_busnr(child, max);
 596                 } else {
 597                         /*
 598                          * For CardBus bridges, we leave 4 bus numbers
 599                          * as cards with a PCI-to-PCI bridge can be
 600                          * inserted later.
 601                          */
 602                         for (i=0; i<CARDBUS_RESERVE_BUSNR; i++) {
 603                                 struct pci_bus *parent = bus;
 604                                 if (pci_find_bus(pci_domain_nr(bus),
 605                                                         max+i+1))
 606                                         break;
 607                                 while (parent->parent) {
 608                                         if ((!pcibios_assign_all_busses()) &&
 609                                             (parent->subordinate > max) &&
 610                                             (parent->subordinate <= max+i)) {
 611                                                 j = 1;
 612                                         }
 613                                         parent = parent->parent;
 614                                 }
 615                                 if (j) {
 616                                         /*
 617                                          * Often, there are two cardbus bridges
 618                                          * -- try to leave one valid bus number
 619                                          * for each one.
 620                                          */
 621                                         i /= 2;
 622                                         break;
 623                                 }
 624                         }
 625                         max += i;
 626                         pci_fixup_parent_subordinate_busnr(child, max);
 627                 }
 628                 /*
 629                  * Set the subordinate bus number to its real value.
 630                  */
 631                 child->subordinate = max;
 632                 pci_write_config_byte(dev, PCI_SUBORDINATE_BUS, max);
 633         }
 634
 635         sprintf(child->name,
 636                 (is_cardbus ? "PCI CardBus %04x:%02x" : "PCI Bus %04x:%02x"),
 637                 pci_domain_nr(bus), child->number);
 638
 639         /* Has only triggered on CardBus, fixup is in yenta_socket */
 640         while (bus->parent) {
 641                 if ((child->subordinate > bus->subordinate) ||
 642                     (child->number > bus->subordinate) ||
 643                     (child->number < bus->number) ||
 644                     (child->subordinate < bus->number)) {
 645                         pr_debug("PCI: Bus #%02x (-#%02x) is %s "
 646                                 "hidden behind%s bridge #%02x (-#%02x)\n",
 647                                 child->number, child->subordinate,
 648                                 (bus->number > child->subordinate &&
 649                                  bus->subordinate < child->number) ?
 650                                         "wholly" : "partially",
 651                                 bus->self->transparent ? " transparent" : "",
 652                                 bus->number, bus->subordinate);
 653                 }
 654                 bus = bus->parent;
 655         }
 656
 657 out:
 658         pci_write_config_word(dev, PCI_BRIDGE_CONTROL, bctl);
 659
 660         return max;
 661 }
 662
 663 /*
 664  * Read interrupt line and base address registers.
 665  * The architecture-dependent code can tweak these, of course.
 666  */
 667 static void pci_read_irq(struct pci_dev *dev)
 668 {
 669         unsigned char irq;
 670
 671         pci_read_config_byte(dev, PCI_INTERRUPT_PIN, &irq);
 672         dev->pin = irq;
 673         if (irq)
 674                 pci_read_config_byte(dev, PCI_INTERRUPT_LINE, &irq);
 675         dev->irq = irq;
 676 }
 677
 678 #define LEGACY_IO_RESOURCE      (IORESOURCE_IO | IORESOURCE_PCI_FIXED)
 679
 680 /**
 681  * pci_setup_device - fill in class and map information of a device
 682  * @dev: the device structure to fill
 683  *
 684  * Initialize the device structure with information about the device's
 685  * vendor,class,memory and IO-space addresses,IRQ lines etc.
 686  * Called at initialisation of the PCI subsystem and by CardBus services.
 687  * Returns 0 on success and -1 if unknown type of device (not normal, bridge
 688  * or CardBus).
 689  */
 690 static int pci_setup_device(struct pci_dev * dev)
 691 {
 692         u32 class;
 693
 694         dev_set_name(&dev->dev, "%04x:%02x:%02x.%d", pci_domain_nr(dev->bus),
 695                      dev->bus->number, PCI_SLOT(dev->devfn),
 696                      PCI_FUNC(dev->devfn));
 697
 698         pci_read_config_dword(dev, PCI_CLASS_REVISION, &class);
 699         dev->revision = class & 0xff;
 700         class >>= 8;                                /* upper 3 bytes */
 701         dev->class = class;
 702         class >>= 8;
 703
 704         dev_dbg(&dev->dev, "found [%04x:%04x] class %06x header type %02x\n",
 705                  dev->vendor, dev->device, class, dev->hdr_type);
 706
 707         /* "Unknown power state" */
 708         dev->current_state = PCI_UNKNOWN;
 709
 710         /* Early fixups, before probing the BARs */
 711         pci_fixup_device(pci_fixup_early, dev);
 712         class = dev->class >> 8;
 713
 714         switch (dev->hdr_type) {                    /* header type */
 715         case PCI_HEADER_TYPE_NORMAL:                /* standard header */
 716                 if (class == PCI_CLASS_BRIDGE_PCI)
 717                         goto bad;
 718                 pci_read_irq(dev);
 719                 pci_read_bases(dev, 6, PCI_ROM_ADDRESS);
 720                 pci_read_config_word(dev, PCI_SUBSYSTEM_VENDOR_ID, &dev->subsystem_vendor);
 721                 pci_read_config_word(dev, PCI_SUBSYSTEM_ID, &dev->subsystem_device);
 722
 723                 /*
 724                  *      Do the ugly legacy mode stuff here rather than broken chip
 725                  *      quirk code. Legacy mode ATA controllers have fixed
 726                  *      addresses. These are not always echoed in BAR0-3, and
 727                  *      BAR0-3 in a few cases contain junk!
 728                  */
 729                 if (class == PCI_CLASS_STORAGE_IDE) {
 730                         u8 progif;
 731                         pci_read_config_byte(dev, PCI_CLASS_PROG, &progif);
 732                         if ((progif & 1) == 0) {
 733                                 dev->resource[0].start = 0x1F0;
 734                                 dev->resource[0].end = 0x1F7;
 735                                 dev->resource[0].flags = LEGACY_IO_RESOURCE;
 736                                 dev->resource[1].start = 0x3F6;
 737                                 dev->resource[1].end = 0x3F6;
 738                                 dev->resource[1].flags = LEGACY_IO_RESOURCE;
 739                         }
 740                         if ((progif & 4) == 0) {
 741                                 dev->resource[2].start = 0x170;
 742                                 dev->resource[2].end = 0x177;
 743                                 dev->resource[2].flags = LEGACY_IO_RESOURCE;
 744                                 dev->resource[3].start = 0x376;
 745                                 dev->resource[3].end = 0x376;
 746                                 dev->resource[3].flags = LEGACY_IO_RESOURCE;
 747                         }
 748                 }
 749                 break;
 750
 751         case PCI_HEADER_TYPE_BRIDGE:                /* bridge header */
 752                 if (class != PCI_CLASS_BRIDGE_PCI)
 753                         goto bad;
 754                 /* The PCI-to-PCI bridge spec requires that subtractive
 755                    decoding (i.e. transparent) bridge must have programming
 756                    interface code of 0x01. */
 757                 pci_read_irq(dev);
 758                 dev->transparent = ((dev->class & 0xff) == 1);
 759                 pci_read_bases(dev, 2, PCI_ROM_ADDRESS1);
 760                 break;
 761
 762         case PCI_HEADER_TYPE_CARDBUS:               /* CardBus bridge header */
 763                 if (class != PCI_CLASS_BRIDGE_CARDBUS)
 764                         goto bad;
 765                 pci_read_irq(dev);
 766                 pci_read_bases(dev, 1, 0);
 767                 pci_read_config_word(dev, PCI_CB_SUBSYSTEM_VENDOR_ID, &dev->subsystem_vendor);
 768                 pci_read_config_word(dev, PCI_CB_SUBSYSTEM_ID, &dev->subsystem_device);
 769                 break;
 770
 771         default:                                    /* unknown header */
 772                 dev_err(&dev->dev, "unknown header type %02x, "
 773                         "ignoring device\n", dev->hdr_type);
 774                 return -1;
 775
 776         bad:
 777                 dev_err(&dev->dev, "ignoring class %02x (doesn't match header "
 778                         "type %02x)\n", class, dev->hdr_type);
 779                 dev->class = PCI_CLASS_NOT_DEFINED;
 780         }
 781
 782         /* We found a fine healthy device, go go go... */
 783         return 0;
 784 }
 785
 786 static void pci_release_capabilities(struct pci_dev *dev)
 787 {
 788         pci_vpd_release(dev);
 789 }
 790
 791 /**
 792  * pci_release_dev - free a pci device structure when all users of it are finished.
 793  * @dev: device that's been disconnected
 794  *
 795  * Will be called only by the device core when all users of this pci device are
 796  * done.
 797  */
 798 static void pci_release_dev(struct device *dev)
 799 {
 800         struct pci_dev *pci_dev;
 801
 802         pci_dev = to_pci_dev(dev);
 803         pci_release_capabilities(pci_dev);
 804         kfree(pci_dev);
 805 }
 806
 807 static void set_pcie_port_type(struct pci_dev *pdev)
 808 {
 809         int pos;
 810         u16 reg16;
 811
 812         pos = pci_find_capability(pdev, PCI_CAP_ID_EXP);
 813         if (!pos)
 814                 return;
 815         pdev->is_pcie = 1;
 816         pci_read_config_word(pdev, pos + PCI_EXP_FLAGS, &reg16);
 817         pdev->pcie_type = (reg16 & PCI_EXP_FLAGS_TYPE) >> 4;
 818 }
 819
 820 /**
 821  * pci_cfg_space_size - get the configuration space size of the PCI device.
 822  * @dev: PCI device
 823  *
 824  * Regular PCI devices have 256 bytes, but PCI-X 2 and PCI Express devices
 825  * have 4096 bytes.  Even if the device is capable, that doesn't mean we can
 826  * access it.  Maybe we don't have a way to generate extended config space
 827  * accesses, or the device is behind a reverse Express bridge.  So we try
 828  * reading the dword at 0x100 which must either be 0 or a valid extended
 829  * capability header.
 830  */
 831 int pci_cfg_space_size_ext(struct pci_dev *dev)
 832 {
 833         u32 status;
 834         int pos = PCI_CFG_SPACE_SIZE;
 835
 836         if (pci_read_config_dword(dev, pos, &status) != PCIBIOS_SUCCESSFUL)
 837                 goto fail;
 838         if (status == 0xffffffff)
 839                 goto fail;
 840
 841         return PCI_CFG_SPACE_EXP_SIZE;
 842
 843  fail:
 844         return PCI_CFG_SPACE_SIZE;
 845 }
 846
 847 int pci_cfg_space_size(struct pci_dev *dev)
 848 {
 849         int pos;
 850         u32 status;
 851
 852         pos = pci_find_capability(dev, PCI_CAP_ID_EXP);
 853         if (!pos) {
 854                 pos = pci_find_capability(dev, PCI_CAP_ID_PCIX);
 855                 if (!pos)
 856                         goto fail;
 857
 858                 pci_read_config_dword(dev, pos + PCI_X_STATUS, &status);
 859                 if (!(status & (PCI_X_STATUS_266MHZ | PCI_X_STATUS_533MHZ)))
 860                         goto fail;
 861         }
 862
 863         return pci_cfg_space_size_ext(dev);
 864
 865  fail:
 866         return PCI_CFG_SPACE_SIZE;
 867 }
 868
 869 static void pci_release_bus_bridge_dev(struct device *dev)
 870 {
 871         kfree(dev);
 872 }
 873
 874 struct pci_dev *alloc_pci_dev(void)
 875 {
 876         struct pci_dev *dev;
 877
 878         dev = kzalloc(sizeof(struct pci_dev), GFP_KERNEL);
 879         if (!dev)
 880                 return NULL;
 881
 882         INIT_LIST_HEAD(&dev->bus_list);
 883
 884         return dev;
 885 }
 886 EXPORT_SYMBOL(alloc_pci_dev);
 887
 888 /*
 889  * Read the config data for a PCI device, sanity-check it
 890  * and fill in the dev structure...
 891  */
 892 static struct pci_dev *pci_scan_device(struct pci_bus *bus, int devfn)
 893 {
 894         struct pci_dev *dev;
 895         struct pci_slot *slot;
 896         u32 l;
 897         u8 hdr_type;
 898         int delay = 1;
 899
 900         if (pci_bus_read_config_dword(bus, devfn, PCI_VENDOR_ID, &l))
 901                 return NULL;
 902
 903         /* some broken boards return 0 or ~0 if a slot is empty: */
 904         if (l == 0xffffffff || l == 0x00000000 ||
 905             l == 0x0000ffff || l == 0xffff0000)
 906                 return NULL;
 907
 908         /* Configuration request Retry Status */
 909         while (l == 0xffff0001) {
 910                 msleep(delay);
 911                 delay *= 2;
 912                 if (pci_bus_read_config_dword(bus, devfn, PCI_VENDOR_ID, &l))
 913                         return NULL;
 914                 /* Card hasn't responded in 60 seconds?  Must be stuck. */
 915                 if (delay > 60 * 1000) {
 916                         printk(KERN_WARNING "pci %04x:%02x:%02x.%d: not "
 917                                         "responding\n", pci_domain_nr(bus),
 918                                         bus->number, PCI_SLOT(devfn),
 919                                         PCI_FUNC(devfn));
 920                         return NULL;
 921                 }
 922         }
 923
 924         if (pci_bus_read_config_byte(bus, devfn, PCI_HEADER_TYPE, &hdr_type))
 925                 return NULL;
 926
 927         dev = alloc_pci_dev();
 928         if (!dev)
 929                 return NULL;
 930
 931         dev->bus = bus;
 932         dev->sysdata = bus->sysdata;
 933         dev->dev.parent = bus->bridge;
 934         dev->dev.bus = &pci_bus_type;
 935         dev->devfn = devfn;
 936         dev->hdr_type = hdr_type & 0x7f;
 937         dev->multifunction = !!(hdr_type & 0x80);
 938         dev->vendor = l & 0xffff;
 939         dev->device = (l >> 16) & 0xffff;
 940         dev->cfg_size = pci_cfg_space_size(dev);
 941         dev->error_state = pci_channel_io_normal;
 942         set_pcie_port_type(dev);
 943
 944         list_for_each_entry(slot, &bus->slots, list)
 945                 if (PCI_SLOT(devfn) == slot->number)
 946                         dev->slot = slot;
 947
 948         /* Assume 32-bit PCI; let 64-bit PCI cards (which are far rarer)
 949            set this higher, assuming the system even supports it.  */
 950         dev->dma_mask = 0xffffffff;
 951         if (pci_setup_device(dev) < 0) {
 952                 kfree(dev);
 953                 return NULL;
 954         }
 955
 956         return dev;
 957 }
 958
 959 static void pci_init_capabilities(struct pci_dev *dev)
 960 {
 961         /* MSI/MSI-X list */
 962         pci_msi_init_pci_dev(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         sprintf(dev->bus_id, "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         sprintf(b->dev.bus_id, "%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 }