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