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 %04lx - %04lx] reg reading\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 0x%08lx - 0x%08lx] reg reading\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 0x%08lx - %08lx pref] reg reading\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 int broken = 0; 677 678 pci_read_config_dword(dev, PCI_PRIMARY_BUS, &buses); 679 680 dev_dbg(&dev->dev, "scanning behind bridge, config %06x, pass %d\n", 681 buses & 0xffffff, pass); 682 683 /* Check if setup is sensible at all */ 684 if (!pass && 685 ((buses & 0xff) != bus->number || ((buses >> 8) & 0xff) <= bus->number)) { 686 dev_dbg(&dev->dev, "bus configuration invalid, reconfiguring\n"); 687 broken = 1; 688 } 689 690 /* Disable MasterAbortMode during probing to avoid reporting 691 of bus errors (in some architectures) */ 692 pci_read_config_word(dev, PCI_BRIDGE_CONTROL, &bctl); 693 pci_write_config_word(dev, PCI_BRIDGE_CONTROL, 694 bctl & ~PCI_BRIDGE_CTL_MASTER_ABORT); 695 696 if ((buses & 0xffff00) && !pcibios_assign_all_busses() && !is_cardbus && !broken) { 697 unsigned int cmax, busnr; 698 /* 699 * Bus already configured by firmware, process it in the first 700 * pass and just note the configuration. 701 */ 702 if (pass) 703 goto out; 704 busnr = (buses >> 8) & 0xFF; 705 706 /* 707 * If we already got to this bus through a different bridge, 708 * don't re-add it. This can happen with the i450NX chipset. 709 * 710 * However, we continue to descend down the hierarchy and 711 * scan remaining child buses. 712 */ 713 child = pci_find_bus(pci_domain_nr(bus), busnr); 714 if (!child) { 715 child = pci_add_new_bus(bus, dev, busnr); 716 if (!child) 717 goto out; 718 child->primary = buses & 0xFF; 719 child->subordinate = (buses >> 16) & 0xFF; 720 child->bridge_ctl = bctl; 721 } 722 723 cmax = pci_scan_child_bus(child); 724 if (cmax > max) 725 max = cmax; 726 if (child->subordinate > max) 727 max = child->subordinate; 728 } else { 729 /* 730 * We need to assign a number to this bus which we always 731 * do in the second pass. 732 */ 733 if (!pass) { 734 if (pcibios_assign_all_busses() || broken) 735 /* Temporarily disable forwarding of the 736 configuration cycles on all bridges in 737 this bus segment to avoid possible 738 conflicts in the second pass between two 739 bridges programmed with overlapping 740 bus ranges. */ 741 pci_write_config_dword(dev, PCI_PRIMARY_BUS, 742 buses & ~0xffffff); 743 goto out; 744 } 745 746 /* Clear errors */ 747 pci_write_config_word(dev, PCI_STATUS, 0xffff); 748 749 /* Prevent assigning a bus number that already exists. 750 * This can happen when a bridge is hot-plugged */ 751 if (pci_find_bus(pci_domain_nr(bus), max+1)) 752 goto out; 753 child = pci_add_new_bus(bus, dev, ++max); 754 buses = (buses & 0xff000000) 755 | ((unsigned int)(child->primary) << 0) 756 | ((unsigned int)(child->secondary) << 8) 757 | ((unsigned int)(child->subordinate) << 16); 758 759 /* 760 * yenta.c forces a secondary latency timer of 176. 761 * Copy that behaviour here. 762 */ 763 if (is_cardbus) { 764 buses &= ~0xff000000; 765 buses |= CARDBUS_LATENCY_TIMER << 24; 766 } 767 768 /* 769 * We need to blast all three values with a single write. 770 */ 771 pci_write_config_dword(dev, PCI_PRIMARY_BUS, buses); 772 773 if (!is_cardbus) { 774 child->bridge_ctl = bctl; 775 /* 776 * Adjust subordinate busnr in parent buses. 777 * We do this before scanning for children because 778 * some devices may not be detected if the bios 779 * was lazy. 780 */ 781 pci_fixup_parent_subordinate_busnr(child, max); 782 /* Now we can scan all subordinate buses... */ 783 max = pci_scan_child_bus(child); 784 /* 785 * now fix it up again since we have found 786 * the real value of max. 787 */ 788 pci_fixup_parent_subordinate_busnr(child, max); 789 } else { 790 /* 791 * For CardBus bridges, we leave 4 bus numbers 792 * as cards with a PCI-to-PCI bridge can be 793 * inserted later. 794 */ 795 for (i=0; i<CARDBUS_RESERVE_BUSNR; i++) { 796 struct pci_bus *parent = bus; 797 if (pci_find_bus(pci_domain_nr(bus), 798 max+i+1)) 799 break; 800 while (parent->parent) { 801 if ((!pcibios_assign_all_busses()) && 802 (parent->subordinate > max) && 803 (parent->subordinate <= max+i)) { 804 j = 1; 805 } 806 parent = parent->parent; 807 } 808 if (j) { 809 /* 810 * Often, there are two cardbus bridges 811 * -- try to leave one valid bus number 812 * for each one. 813 */ 814 i /= 2; 815 break; 816 } 817 } 818 max += i; 819 pci_fixup_parent_subordinate_busnr(child, max); 820 } 821 /* 822 * Set the subordinate bus number to its real value. 823 */ 824 child->subordinate = max; 825 pci_write_config_byte(dev, PCI_SUBORDINATE_BUS, max); 826 } 827 828 sprintf(child->name, 829 (is_cardbus ? "PCI CardBus %04x:%02x" : "PCI Bus %04x:%02x"), 830 pci_domain_nr(bus), child->number); 831 832 /* Has only triggered on CardBus, fixup is in yenta_socket */ 833 while (bus->parent) { 834 if ((child->subordinate > bus->subordinate) || 835 (child->number > bus->subordinate) || 836 (child->number < bus->number) || 837 (child->subordinate < bus->number)) { 838 dev_info(&child->dev, "[bus %02x-%02x] %s " 839 "hidden behind%s bridge %s [bus %02x-%02x]\n", 840 child->number, child->subordinate, 841 (bus->number > child->subordinate && 842 bus->subordinate < child->number) ? 843 "wholly" : "partially", 844 bus->self->transparent ? " transparent" : "", 845 dev_name(&bus->dev), 846 bus->number, bus->subordinate); 847 } 848 bus = bus->parent; 849 } 850 851 out: 852 pci_write_config_word(dev, PCI_BRIDGE_CONTROL, bctl); 853 854 return max; 855 } 856 857 /* 858 * Read interrupt line and base address registers. 859 * The architecture-dependent code can tweak these, of course. 860 */ 861 static void pci_read_irq(struct pci_dev *dev) 862 { 863 unsigned char irq; 864 865 pci_read_config_byte(dev, PCI_INTERRUPT_PIN, &irq); 866 dev->pin = irq; 867 if (irq) 868 pci_read_config_byte(dev, PCI_INTERRUPT_LINE, &irq); 869 dev->irq = irq; 870 } 871 872 void set_pcie_port_type(struct pci_dev *pdev) 873 { 874 int pos; 875 u16 reg16; 876 877 pos = pci_find_capability(pdev, PCI_CAP_ID_EXP); 878 if (!pos) 879 return; 880 pdev->is_pcie = 1; 881 pdev->pcie_cap = pos; 882 pci_read_config_word(pdev, pos + PCI_EXP_FLAGS, ®16); 883 pdev->pcie_type = (reg16 & PCI_EXP_FLAGS_TYPE) >> 4; 884 } 885 886 void set_pcie_hotplug_bridge(struct pci_dev *pdev) 887 { 888 int pos; 889 u16 reg16; 890 u32 reg32; 891 892 pos = pci_pcie_cap(pdev); 893 if (!pos) 894 return; 895 pci_read_config_word(pdev, pos + PCI_EXP_FLAGS, ®16); 896 if (!(reg16 & PCI_EXP_FLAGS_SLOT)) 897 return; 898 pci_read_config_dword(pdev, pos + PCI_EXP_SLTCAP, ®32); 899 if (reg32 & PCI_EXP_SLTCAP_HPC) 900 pdev->is_hotplug_bridge = 1; 901 } 902 903 static void set_pci_aer_firmware_first(struct pci_dev *pdev) 904 { 905 if (acpi_hest_firmware_first_pci(pdev)) 906 pdev->aer_firmware_first = 1; 907 } 908 909 #define LEGACY_IO_RESOURCE (IORESOURCE_IO | IORESOURCE_PCI_FIXED) 910 911 /** 912 * pci_setup_device - fill in class and map information of a device 913 * @dev: the device structure to fill 914 * 915 * Initialize the device structure with information about the device's 916 * vendor,class,memory and IO-space addresses,IRQ lines etc. 917 * Called at initialisation of the PCI subsystem and by CardBus services. 918 * Returns 0 on success and negative if unknown type of device (not normal, 919 * bridge or CardBus). 920 */ 921 int pci_setup_device(struct pci_dev *dev) 922 { 923 u32 class; 924 u8 hdr_type; 925 struct pci_slot *slot; 926 int pos = 0; 927 928 if (pci_read_config_byte(dev, PCI_HEADER_TYPE, &hdr_type)) 929 return -EIO; 930 931 dev->sysdata = dev->bus->sysdata; 932 dev->dev.parent = dev->bus->bridge; 933 dev->dev.bus = &pci_bus_type; 934 dev->hdr_type = hdr_type & 0x7f; 935 dev->multifunction = !!(hdr_type & 0x80); 936 dev->error_state = pci_channel_io_normal; 937 set_pcie_port_type(dev); 938 set_pci_aer_firmware_first(dev); 939 940 list_for_each_entry(slot, &dev->bus->slots, list) 941 if (PCI_SLOT(dev->devfn) == slot->number) 942 dev->slot = slot; 943 944 /* Assume 32-bit PCI; let 64-bit PCI cards (which are far rarer) 945 set this higher, assuming the system even supports it. */ 946 dev->dma_mask = 0xffffffff; 947 948 dev_set_name(&dev->dev, "%04x:%02x:%02x.%d", pci_domain_nr(dev->bus), 949 dev->bus->number, PCI_SLOT(dev->devfn), 950 PCI_FUNC(dev->devfn)); 951 952 pci_read_config_dword(dev, PCI_CLASS_REVISION, &class); 953 dev->revision = class & 0xff; 954 class >>= 8; /* upper 3 bytes */ 955 dev->class = class; 956 class >>= 8; 957 958 dev_dbg(&dev->dev, "found [%04x:%04x] class %06x header type %02x\n", 959 dev->vendor, dev->device, class, dev->hdr_type); 960 961 /* need to have dev->class ready */ 962 dev->cfg_size = pci_cfg_space_size(dev); 963 964 /* "Unknown power state" */ 965 dev->current_state = PCI_UNKNOWN; 966 967 /* Early fixups, before probing the BARs */ 968 pci_fixup_device(pci_fixup_early, dev); 969 /* device class may be changed after fixup */ 970 class = dev->class >> 8; 971 972 switch (dev->hdr_type) { /* header type */ 973 case PCI_HEADER_TYPE_NORMAL: /* standard header */ 974 if (class == PCI_CLASS_BRIDGE_PCI) 975 goto bad; 976 pci_read_irq(dev); 977 pci_read_bases(dev, 6, PCI_ROM_ADDRESS); 978 pci_read_config_word(dev, PCI_SUBSYSTEM_VENDOR_ID, &dev->subsystem_vendor); 979 pci_read_config_word(dev, PCI_SUBSYSTEM_ID, &dev->subsystem_device); 980 981 /* 982 * Do the ugly legacy mode stuff here rather than broken chip 983 * quirk code. Legacy mode ATA controllers have fixed 984 * addresses. These are not always echoed in BAR0-3, and 985 * BAR0-3 in a few cases contain junk! 986 */ 987 if (class == PCI_CLASS_STORAGE_IDE) { 988 u8 progif; 989 pci_read_config_byte(dev, PCI_CLASS_PROG, &progif); 990 if ((progif & 1) == 0) { 991 dev->resource[0].start = 0x1F0; 992 dev->resource[0].end = 0x1F7; 993 dev->resource[0].flags = LEGACY_IO_RESOURCE; 994 dev->resource[1].start = 0x3F6; 995 dev->resource[1].end = 0x3F6; 996 dev->resource[1].flags = LEGACY_IO_RESOURCE; 997 } 998 if ((progif & 4) == 0) { 999 dev->resource[2].start = 0x170; 1000 dev->resource[2].end = 0x177; 1001 dev->resource[2].flags = LEGACY_IO_RESOURCE; 1002 dev->resource[3].start = 0x376; 1003 dev->resource[3].end = 0x376; 1004 dev->resource[3].flags = LEGACY_IO_RESOURCE; 1005 } 1006 } 1007 break; 1008 1009 case PCI_HEADER_TYPE_BRIDGE: /* bridge header */ 1010 if (class != PCI_CLASS_BRIDGE_PCI) 1011 goto bad; 1012 /* The PCI-to-PCI bridge spec requires that subtractive 1013 decoding (i.e. transparent) bridge must have programming 1014 interface code of 0x01. */ 1015 pci_read_irq(dev); 1016 dev->transparent = ((dev->class & 0xff) == 1); 1017 pci_read_bases(dev, 2, PCI_ROM_ADDRESS1); 1018 set_pcie_hotplug_bridge(dev); 1019 pos = pci_find_capability(dev, PCI_CAP_ID_SSVID); 1020 if (pos) { 1021 pci_read_config_word(dev, pos + PCI_SSVID_VENDOR_ID, &dev->subsystem_vendor); 1022 pci_read_config_word(dev, pos + PCI_SSVID_DEVICE_ID, &dev->subsystem_device); 1023 } 1024 break; 1025 1026 case PCI_HEADER_TYPE_CARDBUS: /* CardBus bridge header */ 1027 if (class != PCI_CLASS_BRIDGE_CARDBUS) 1028 goto bad; 1029 pci_read_irq(dev); 1030 pci_read_bases(dev, 1, 0); 1031 pci_read_config_word(dev, PCI_CB_SUBSYSTEM_VENDOR_ID, &dev->subsystem_vendor); 1032 pci_read_config_word(dev, PCI_CB_SUBSYSTEM_ID, &dev->subsystem_device); 1033 break; 1034 1035 default: /* unknown header */ 1036 dev_err(&dev->dev, "unknown header type %02x, " 1037 "ignoring device\n", dev->hdr_type); 1038 return -EIO; 1039 1040 bad: 1041 dev_err(&dev->dev, "ignoring class %02x (doesn't match header " 1042 "type %02x)\n", class, dev->hdr_type); 1043 dev->class = PCI_CLASS_NOT_DEFINED; 1044 } 1045 1046 /* We found a fine healthy device, go go go... */ 1047 return 0; 1048 } 1049 1050 static void pci_release_capabilities(struct pci_dev *dev) 1051 { 1052 pci_vpd_release(dev); 1053 pci_iov_release(dev); 1054 } 1055 1056 /** 1057 * pci_release_dev - free a pci device structure when all users of it are finished. 1058 * @dev: device that's been disconnected 1059 * 1060 * Will be called only by the device core when all users of this pci device are 1061 * done. 1062 */ 1063 static void pci_release_dev(struct device *dev) 1064 { 1065 struct pci_dev *pci_dev; 1066 1067 pci_dev = to_pci_dev(dev); 1068 pci_release_capabilities(pci_dev); 1069 kfree(pci_dev); 1070 } 1071 1072 /** 1073 * pci_cfg_space_size - get the configuration space size of the PCI device. 1074 * @dev: PCI device 1075 * 1076 * Regular PCI devices have 256 bytes, but PCI-X 2 and PCI Express devices 1077 * have 4096 bytes. Even if the device is capable, that doesn't mean we can 1078 * access it. Maybe we don't have a way to generate extended config space 1079 * accesses, or the device is behind a reverse Express bridge. So we try 1080 * reading the dword at 0x100 which must either be 0 or a valid extended 1081 * capability header. 1082 */ 1083 int pci_cfg_space_size_ext(struct pci_dev *dev) 1084 { 1085 u32 status; 1086 int pos = PCI_CFG_SPACE_SIZE; 1087 1088 if (pci_read_config_dword(dev, pos, &status) != PCIBIOS_SUCCESSFUL) 1089 goto fail; 1090 if (status == 0xffffffff) 1091 goto fail; 1092 1093 return PCI_CFG_SPACE_EXP_SIZE; 1094 1095 fail: 1096 return PCI_CFG_SPACE_SIZE; 1097 } 1098 1099 int pci_cfg_space_size(struct pci_dev *dev) 1100 { 1101 int pos; 1102 u32 status; 1103 u16 class; 1104 1105 class = dev->class >> 8; 1106 if (class == PCI_CLASS_BRIDGE_HOST) 1107 return pci_cfg_space_size_ext(dev); 1108 1109 pos = pci_pcie_cap(dev); 1110 if (!pos) { 1111 pos = pci_find_capability(dev, PCI_CAP_ID_PCIX); 1112 if (!pos) 1113 goto fail; 1114 1115 pci_read_config_dword(dev, pos + PCI_X_STATUS, &status); 1116 if (!(status & (PCI_X_STATUS_266MHZ | PCI_X_STATUS_533MHZ))) 1117 goto fail; 1118 } 1119 1120 return pci_cfg_space_size_ext(dev); 1121 1122 fail: 1123 return PCI_CFG_SPACE_SIZE; 1124 } 1125 1126 static void pci_release_bus_bridge_dev(struct device *dev) 1127 { 1128 kfree(dev); 1129 } 1130 1131 struct pci_dev *alloc_pci_dev(void) 1132 { 1133 struct pci_dev *dev; 1134 1135 dev = kzalloc(sizeof(struct pci_dev), GFP_KERNEL); 1136 if (!dev) 1137 return NULL; 1138 1139 INIT_LIST_HEAD(&dev->bus_list); 1140 1141 return dev; 1142 } 1143 EXPORT_SYMBOL(alloc_pci_dev); 1144 1145 /* 1146 * Read the config data for a PCI device, sanity-check it 1147 * and fill in the dev structure... 1148 */ 1149 static struct pci_dev *pci_scan_device(struct pci_bus *bus, int devfn) 1150 { 1151 struct pci_dev *dev; 1152 u32 l; 1153 int delay = 1; 1154 1155 if (pci_bus_read_config_dword(bus, devfn, PCI_VENDOR_ID, &l)) 1156 return NULL; 1157 1158 /* some broken boards return 0 or ~0 if a slot is empty: */ 1159 if (l == 0xffffffff || l == 0x00000000 || 1160 l == 0x0000ffff || l == 0xffff0000) 1161 return NULL; 1162 1163 /* Configuration request Retry Status */ 1164 while (l == 0xffff0001) { 1165 msleep(delay); 1166 delay *= 2; 1167 if (pci_bus_read_config_dword(bus, devfn, PCI_VENDOR_ID, &l)) 1168 return NULL; 1169 /* Card hasn't responded in 60 seconds? Must be stuck. */ 1170 if (delay > 60 * 1000) { 1171 printk(KERN_WARNING "pci %04x:%02x:%02x.%d: not " 1172 "responding\n", pci_domain_nr(bus), 1173 bus->number, PCI_SLOT(devfn), 1174 PCI_FUNC(devfn)); 1175 return NULL; 1176 } 1177 } 1178 1179 dev = alloc_pci_dev(); 1180 if (!dev) 1181 return NULL; 1182 1183 dev->bus = bus; 1184 dev->devfn = devfn; 1185 dev->vendor = l & 0xffff; 1186 dev->device = (l >> 16) & 0xffff; 1187 1188 if (pci_setup_device(dev)) { 1189 kfree(dev); 1190 return NULL; 1191 } 1192 1193 return dev; 1194 } 1195 1196 static void pci_init_capabilities(struct pci_dev *dev) 1197 { 1198 /* MSI/MSI-X list */ 1199 pci_msi_init_pci_dev(dev); 1200 1201 /* Buffers for saving PCIe and PCI-X capabilities */ 1202 pci_allocate_cap_save_buffers(dev); 1203 1204 /* Power Management */ 1205 pci_pm_init(dev); 1206 platform_pci_wakeup_init(dev); 1207 1208 /* Vital Product Data */ 1209 pci_vpd_pci22_init(dev); 1210 1211 /* Alternative Routing-ID Forwarding */ 1212 pci_enable_ari(dev); 1213 1214 /* Single Root I/O Virtualization */ 1215 pci_iov_init(dev); 1216 1217 /* Enable ACS P2P upstream forwarding */ 1218 pci_enable_acs(dev); 1219 } 1220 1221 void pci_device_add(struct pci_dev *dev, struct pci_bus *bus) 1222 { 1223 device_initialize(&dev->dev); 1224 dev->dev.release = pci_release_dev; 1225 pci_dev_get(dev); 1226 1227 dev->dev.dma_mask = &dev->dma_mask; 1228 dev->dev.dma_parms = &dev->dma_parms; 1229 dev->dev.coherent_dma_mask = 0xffffffffull; 1230 1231 pci_set_dma_max_seg_size(dev, 65536); 1232 pci_set_dma_seg_boundary(dev, 0xffffffff); 1233 1234 /* Fix up broken headers */ 1235 pci_fixup_device(pci_fixup_header, dev); 1236 1237 /* Clear the state_saved flag. */ 1238 dev->state_saved = false; 1239 1240 /* Initialize various capabilities */ 1241 pci_init_capabilities(dev); 1242 1243 /* 1244 * Add the device to our list of discovered devices 1245 * and the bus list for fixup functions, etc. 1246 */ 1247 down_write(&pci_bus_sem); 1248 list_add_tail(&dev->bus_list, &bus->devices); 1249 up_write(&pci_bus_sem); 1250 } 1251 1252 struct pci_dev *__ref pci_scan_single_device(struct pci_bus *bus, int devfn) 1253 { 1254 struct pci_dev *dev; 1255 1256 dev = pci_get_slot(bus, devfn); 1257 if (dev) { 1258 pci_dev_put(dev); 1259 return dev; 1260 } 1261 1262 dev = pci_scan_device(bus, devfn); 1263 if (!dev) 1264 return NULL; 1265 1266 pci_device_add(dev, bus); 1267 1268 return dev; 1269 } 1270 EXPORT_SYMBOL(pci_scan_single_device); 1271 1272 static unsigned next_ari_fn(struct pci_dev *dev, unsigned fn) 1273 { 1274 u16 cap; 1275 unsigned pos, next_fn; 1276 1277 if (!dev) 1278 return 0; 1279 1280 pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ARI); 1281 if (!pos) 1282 return 0; 1283 pci_read_config_word(dev, pos + 4, &cap); 1284 next_fn = cap >> 8; 1285 if (next_fn <= fn) 1286 return 0; 1287 return next_fn; 1288 } 1289 1290 static unsigned next_trad_fn(struct pci_dev *dev, unsigned fn) 1291 { 1292 return (fn + 1) % 8; 1293 } 1294 1295 static unsigned no_next_fn(struct pci_dev *dev, unsigned fn) 1296 { 1297 return 0; 1298 } 1299 1300 static int only_one_child(struct pci_bus *bus) 1301 { 1302 struct pci_dev *parent = bus->self; 1303 if (!parent || !pci_is_pcie(parent)) 1304 return 0; 1305 if (parent->pcie_type == PCI_EXP_TYPE_ROOT_PORT || 1306 parent->pcie_type == PCI_EXP_TYPE_DOWNSTREAM) 1307 return 1; 1308 return 0; 1309 } 1310 1311 /** 1312 * pci_scan_slot - scan a PCI slot on a bus for devices. 1313 * @bus: PCI bus to scan 1314 * @devfn: slot number to scan (must have zero function.) 1315 * 1316 * Scan a PCI slot on the specified PCI bus for devices, adding 1317 * discovered devices to the @bus->devices list. New devices 1318 * will not have is_added set. 1319 * 1320 * Returns the number of new devices found. 1321 */ 1322 int pci_scan_slot(struct pci_bus *bus, int devfn) 1323 { 1324 unsigned fn, nr = 0; 1325 struct pci_dev *dev; 1326 unsigned (*next_fn)(struct pci_dev *, unsigned) = no_next_fn; 1327 1328 if (only_one_child(bus) && (devfn > 0)) 1329 return 0; /* Already scanned the entire slot */ 1330 1331 dev = pci_scan_single_device(bus, devfn); 1332 if (!dev) 1333 return 0; 1334 if (!dev->is_added) 1335 nr++; 1336 1337 if (pci_ari_enabled(bus)) 1338 next_fn = next_ari_fn; 1339 else if (dev->multifunction) 1340 next_fn = next_trad_fn; 1341 1342 for (fn = next_fn(dev, 0); fn > 0; fn = next_fn(dev, fn)) { 1343 dev = pci_scan_single_device(bus, devfn + fn); 1344 if (dev) { 1345 if (!dev->is_added) 1346 nr++; 1347 dev->multifunction = 1; 1348 } 1349 } 1350 1351 /* only one slot has pcie device */ 1352 if (bus->self && nr) 1353 pcie_aspm_init_link_state(bus->self); 1354 1355 return nr; 1356 } 1357 1358 unsigned int __devinit pci_scan_child_bus(struct pci_bus *bus) 1359 { 1360 unsigned int devfn, pass, max = bus->secondary; 1361 struct pci_dev *dev; 1362 1363 dev_dbg(&bus->dev, "scanning bus\n"); 1364 1365 /* Go find them, Rover! */ 1366 for (devfn = 0; devfn < 0x100; devfn += 8) 1367 pci_scan_slot(bus, devfn); 1368 1369 /* Reserve buses for SR-IOV capability. */ 1370 max += pci_iov_bus_range(bus); 1371 1372 /* 1373 * After performing arch-dependent fixup of the bus, look behind 1374 * all PCI-to-PCI bridges on this bus. 1375 */ 1376 if (!bus->is_added) { 1377 dev_dbg(&bus->dev, "fixups for bus\n"); 1378 pcibios_fixup_bus(bus); 1379 if (pci_is_root_bus(bus)) 1380 bus->is_added = 1; 1381 } 1382 1383 for (pass=0; pass < 2; pass++) 1384 list_for_each_entry(dev, &bus->devices, bus_list) { 1385 if (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE || 1386 dev->hdr_type == PCI_HEADER_TYPE_CARDBUS) 1387 max = pci_scan_bridge(bus, dev, max, pass); 1388 } 1389 1390 /* 1391 * We've scanned the bus and so we know all about what's on 1392 * the other side of any bridges that may be on this bus plus 1393 * any devices. 1394 * 1395 * Return how far we've got finding sub-buses. 1396 */ 1397 dev_dbg(&bus->dev, "bus scan returning with max=%02x\n", max); 1398 return max; 1399 } 1400 1401 struct pci_bus * pci_create_bus(struct device *parent, 1402 int bus, struct pci_ops *ops, void *sysdata) 1403 { 1404 int error; 1405 struct pci_bus *b, *b2; 1406 struct device *dev; 1407 1408 b = pci_alloc_bus(); 1409 if (!b) 1410 return NULL; 1411 1412 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 1413 if (!dev){ 1414 kfree(b); 1415 return NULL; 1416 } 1417 1418 b->sysdata = sysdata; 1419 b->ops = ops; 1420 1421 b2 = pci_find_bus(pci_domain_nr(b), bus); 1422 if (b2) { 1423 /* If we already got to this bus through a different bridge, ignore it */ 1424 dev_dbg(&b2->dev, "bus already known\n"); 1425 goto err_out; 1426 } 1427 1428 down_write(&pci_bus_sem); 1429 list_add_tail(&b->node, &pci_root_buses); 1430 up_write(&pci_bus_sem); 1431 1432 dev->parent = parent; 1433 dev->release = pci_release_bus_bridge_dev; 1434 dev_set_name(dev, "pci%04x:%02x", pci_domain_nr(b), bus); 1435 error = device_register(dev); 1436 if (error) 1437 goto dev_reg_err; 1438 b->bridge = get_device(dev); 1439 device_enable_async_suspend(b->bridge); 1440 1441 if (!parent) 1442 set_dev_node(b->bridge, pcibus_to_node(b)); 1443 1444 b->dev.class = &pcibus_class; 1445 b->dev.parent = b->bridge; 1446 dev_set_name(&b->dev, "%04x:%02x", pci_domain_nr(b), bus); 1447 error = device_register(&b->dev); 1448 if (error) 1449 goto class_dev_reg_err; 1450 error = device_create_file(&b->dev, &dev_attr_cpuaffinity); 1451 if (error) 1452 goto dev_create_file_err; 1453 1454 /* Create legacy_io and legacy_mem files for this bus */ 1455 pci_create_legacy_files(b); 1456 1457 b->number = b->secondary = bus; 1458 b->resource[0] = &ioport_resource; 1459 b->resource[1] = &iomem_resource; 1460 1461 return b; 1462 1463 dev_create_file_err: 1464 device_unregister(&b->dev); 1465 class_dev_reg_err: 1466 device_unregister(dev); 1467 dev_reg_err: 1468 down_write(&pci_bus_sem); 1469 list_del(&b->node); 1470 up_write(&pci_bus_sem); 1471 err_out: 1472 kfree(dev); 1473 kfree(b); 1474 return NULL; 1475 } 1476 1477 struct pci_bus * __devinit pci_scan_bus_parented(struct device *parent, 1478 int bus, struct pci_ops *ops, void *sysdata) 1479 { 1480 struct pci_bus *b; 1481 1482 b = pci_create_bus(parent, bus, ops, sysdata); 1483 if (b) 1484 b->subordinate = pci_scan_child_bus(b); 1485 return b; 1486 } 1487 EXPORT_SYMBOL(pci_scan_bus_parented); 1488 1489 #ifdef CONFIG_HOTPLUG 1490 /** 1491 * pci_rescan_bus - scan a PCI bus for devices. 1492 * @bus: PCI bus to scan 1493 * 1494 * Scan a PCI bus and child buses for new devices, adds them, 1495 * and enables them. 1496 * 1497 * Returns the max number of subordinate bus discovered. 1498 */ 1499 unsigned int __ref pci_rescan_bus(struct pci_bus *bus) 1500 { 1501 unsigned int max; 1502 struct pci_dev *dev; 1503 1504 max = pci_scan_child_bus(bus); 1505 1506 down_read(&pci_bus_sem); 1507 list_for_each_entry(dev, &bus->devices, bus_list) 1508 if (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE || 1509 dev->hdr_type == PCI_HEADER_TYPE_CARDBUS) 1510 if (dev->subordinate) 1511 pci_bus_size_bridges(dev->subordinate); 1512 up_read(&pci_bus_sem); 1513 1514 pci_bus_assign_resources(bus); 1515 pci_enable_bridges(bus); 1516 pci_bus_add_devices(bus); 1517 1518 return max; 1519 } 1520 EXPORT_SYMBOL_GPL(pci_rescan_bus); 1521 1522 EXPORT_SYMBOL(pci_add_new_bus); 1523 EXPORT_SYMBOL(pci_scan_slot); 1524 EXPORT_SYMBOL(pci_scan_bridge); 1525 EXPORT_SYMBOL_GPL(pci_scan_child_bus); 1526 #endif 1527 1528 static int __init pci_sort_bf_cmp(const struct device *d_a, const struct device *d_b) 1529 { 1530 const struct pci_dev *a = to_pci_dev(d_a); 1531 const struct pci_dev *b = to_pci_dev(d_b); 1532 1533 if (pci_domain_nr(a->bus) < pci_domain_nr(b->bus)) return -1; 1534 else if (pci_domain_nr(a->bus) > pci_domain_nr(b->bus)) return 1; 1535 1536 if (a->bus->number < b->bus->number) return -1; 1537 else if (a->bus->number > b->bus->number) return 1; 1538 1539 if (a->devfn < b->devfn) return -1; 1540 else if (a->devfn > b->devfn) return 1; 1541 1542 return 0; 1543 } 1544 1545 void __init pci_sort_breadthfirst(void) 1546 { 1547 bus_sort_breadthfirst(&pci_bus_type, &pci_sort_bf_cmp); 1548 } 1549