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