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