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