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