1 #include <linux/pci.h> 2 #include <linux/acpi.h> 3 #include <linux/init.h> 4 #include <linux/irq.h> 5 #include <linux/dmi.h> 6 #include <linux/slab.h> 7 #include <asm/numa.h> 8 #include <asm/pci_x86.h> 9 10 struct pci_root_info { 11 struct acpi_device *bridge; 12 char name[16]; 13 unsigned int res_num; 14 struct resource *res; 15 resource_size_t *res_offset; 16 struct pci_sysdata sd; 17 #ifdef CONFIG_PCI_MMCONFIG 18 bool mcfg_added; 19 u16 segment; 20 u8 start_bus; 21 u8 end_bus; 22 #endif 23 }; 24 25 static bool pci_use_crs = true; 26 static bool pci_ignore_seg = false; 27 28 static int __init set_use_crs(const struct dmi_system_id *id) 29 { 30 pci_use_crs = true; 31 return 0; 32 } 33 34 static int __init set_nouse_crs(const struct dmi_system_id *id) 35 { 36 pci_use_crs = false; 37 return 0; 38 } 39 40 static int __init set_ignore_seg(const struct dmi_system_id *id) 41 { 42 printk(KERN_INFO "PCI: %s detected: ignoring ACPI _SEG\n", id->ident); 43 pci_ignore_seg = true; 44 return 0; 45 } 46 47 static const struct dmi_system_id pci_crs_quirks[] __initconst = { 48 /* http://bugzilla.kernel.org/show_bug.cgi?id=14183 */ 49 { 50 .callback = set_use_crs, 51 .ident = "IBM System x3800", 52 .matches = { 53 DMI_MATCH(DMI_SYS_VENDOR, "IBM"), 54 DMI_MATCH(DMI_PRODUCT_NAME, "x3800"), 55 }, 56 }, 57 /* https://bugzilla.kernel.org/show_bug.cgi?id=16007 */ 58 /* 2006 AMD HT/VIA system with two host bridges */ 59 { 60 .callback = set_use_crs, 61 .ident = "ASRock ALiveSATA2-GLAN", 62 .matches = { 63 DMI_MATCH(DMI_PRODUCT_NAME, "ALiveSATA2-GLAN"), 64 }, 65 }, 66 /* https://bugzilla.kernel.org/show_bug.cgi?id=30552 */ 67 /* 2006 AMD HT/VIA system with two host bridges */ 68 { 69 .callback = set_use_crs, 70 .ident = "ASUS M2V-MX SE", 71 .matches = { 72 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."), 73 DMI_MATCH(DMI_BOARD_NAME, "M2V-MX SE"), 74 DMI_MATCH(DMI_BIOS_VENDOR, "American Megatrends Inc."), 75 }, 76 }, 77 /* https://bugzilla.kernel.org/show_bug.cgi?id=42619 */ 78 { 79 .callback = set_use_crs, 80 .ident = "MSI MS-7253", 81 .matches = { 82 DMI_MATCH(DMI_BOARD_VENDOR, "MICRO-STAR INTERNATIONAL CO., LTD"), 83 DMI_MATCH(DMI_BOARD_NAME, "MS-7253"), 84 DMI_MATCH(DMI_BIOS_VENDOR, "Phoenix Technologies, LTD"), 85 }, 86 }, 87 88 /* Now for the blacklist.. */ 89 90 /* https://bugzilla.redhat.com/show_bug.cgi?id=769657 */ 91 { 92 .callback = set_nouse_crs, 93 .ident = "Dell Studio 1557", 94 .matches = { 95 DMI_MATCH(DMI_BOARD_VENDOR, "Dell Inc."), 96 DMI_MATCH(DMI_PRODUCT_NAME, "Studio 1557"), 97 DMI_MATCH(DMI_BIOS_VERSION, "A09"), 98 }, 99 }, 100 /* https://bugzilla.redhat.com/show_bug.cgi?id=769657 */ 101 { 102 .callback = set_nouse_crs, 103 .ident = "Thinkpad SL510", 104 .matches = { 105 DMI_MATCH(DMI_BOARD_VENDOR, "LENOVO"), 106 DMI_MATCH(DMI_BOARD_NAME, "2847DFG"), 107 DMI_MATCH(DMI_BIOS_VERSION, "6JET85WW (1.43 )"), 108 }, 109 }, 110 111 /* https://bugzilla.kernel.org/show_bug.cgi?id=15362 */ 112 { 113 .callback = set_ignore_seg, 114 .ident = "HP xw9300", 115 .matches = { 116 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"), 117 DMI_MATCH(DMI_PRODUCT_NAME, "HP xw9300 Workstation"), 118 }, 119 }, 120 {} 121 }; 122 123 void __init pci_acpi_crs_quirks(void) 124 { 125 int year; 126 127 if (dmi_get_date(DMI_BIOS_DATE, &year, NULL, NULL) && year < 2008) 128 pci_use_crs = false; 129 130 dmi_check_system(pci_crs_quirks); 131 132 /* 133 * If the user specifies "pci=use_crs" or "pci=nocrs" explicitly, that 134 * takes precedence over anything we figured out above. 135 */ 136 if (pci_probe & PCI_ROOT_NO_CRS) 137 pci_use_crs = false; 138 else if (pci_probe & PCI_USE__CRS) 139 pci_use_crs = true; 140 141 printk(KERN_INFO "PCI: %s host bridge windows from ACPI; " 142 "if necessary, use \"pci=%s\" and report a bug\n", 143 pci_use_crs ? "Using" : "Ignoring", 144 pci_use_crs ? "nocrs" : "use_crs"); 145 } 146 147 #ifdef CONFIG_PCI_MMCONFIG 148 static int __devinit check_segment(u16 seg, struct device *dev, char *estr) 149 { 150 if (seg) { 151 dev_err(dev, 152 "%s can't access PCI configuration " 153 "space under this host bridge.\n", 154 estr); 155 return -EIO; 156 } 157 158 /* 159 * Failure in adding MMCFG information is not fatal, 160 * just can't access extended configuration space of 161 * devices under this host bridge. 162 */ 163 dev_warn(dev, 164 "%s can't access extended PCI configuration " 165 "space under this bridge.\n", 166 estr); 167 168 return 0; 169 } 170 171 static int __devinit setup_mcfg_map(struct pci_root_info *info, 172 u16 seg, u8 start, u8 end, 173 phys_addr_t addr) 174 { 175 int result; 176 struct device *dev = &info->bridge->dev; 177 178 info->start_bus = start; 179 info->end_bus = end; 180 info->mcfg_added = false; 181 182 /* return success if MMCFG is not in use */ 183 if (raw_pci_ext_ops && raw_pci_ext_ops != &pci_mmcfg) 184 return 0; 185 186 if (!(pci_probe & PCI_PROBE_MMCONF)) 187 return check_segment(seg, dev, "MMCONFIG is disabled,"); 188 189 result = pci_mmconfig_insert(dev, seg, start, end, addr); 190 if (result == 0) { 191 /* enable MMCFG if it hasn't been enabled yet */ 192 if (raw_pci_ext_ops == NULL) 193 raw_pci_ext_ops = &pci_mmcfg; 194 info->mcfg_added = true; 195 } else if (result != -EEXIST) 196 return check_segment(seg, dev, 197 "fail to add MMCONFIG information,"); 198 199 return 0; 200 } 201 202 static void teardown_mcfg_map(struct pci_root_info *info) 203 { 204 if (info->mcfg_added) { 205 pci_mmconfig_delete(info->segment, info->start_bus, 206 info->end_bus); 207 info->mcfg_added = false; 208 } 209 } 210 #else 211 static int __devinit setup_mcfg_map(struct pci_root_info *info, 212 u16 seg, u8 start, u8 end, 213 phys_addr_t addr) 214 { 215 return 0; 216 } 217 static void teardown_mcfg_map(struct pci_root_info *info) 218 { 219 } 220 #endif 221 222 static acpi_status 223 resource_to_addr(struct acpi_resource *resource, 224 struct acpi_resource_address64 *addr) 225 { 226 acpi_status status; 227 struct acpi_resource_memory24 *memory24; 228 struct acpi_resource_memory32 *memory32; 229 struct acpi_resource_fixed_memory32 *fixed_memory32; 230 231 memset(addr, 0, sizeof(*addr)); 232 switch (resource->type) { 233 case ACPI_RESOURCE_TYPE_MEMORY24: 234 memory24 = &resource->data.memory24; 235 addr->resource_type = ACPI_MEMORY_RANGE; 236 addr->minimum = memory24->minimum; 237 addr->address_length = memory24->address_length; 238 addr->maximum = addr->minimum + addr->address_length - 1; 239 return AE_OK; 240 case ACPI_RESOURCE_TYPE_MEMORY32: 241 memory32 = &resource->data.memory32; 242 addr->resource_type = ACPI_MEMORY_RANGE; 243 addr->minimum = memory32->minimum; 244 addr->address_length = memory32->address_length; 245 addr->maximum = addr->minimum + addr->address_length - 1; 246 return AE_OK; 247 case ACPI_RESOURCE_TYPE_FIXED_MEMORY32: 248 fixed_memory32 = &resource->data.fixed_memory32; 249 addr->resource_type = ACPI_MEMORY_RANGE; 250 addr->minimum = fixed_memory32->address; 251 addr->address_length = fixed_memory32->address_length; 252 addr->maximum = addr->minimum + addr->address_length - 1; 253 return AE_OK; 254 case ACPI_RESOURCE_TYPE_ADDRESS16: 255 case ACPI_RESOURCE_TYPE_ADDRESS32: 256 case ACPI_RESOURCE_TYPE_ADDRESS64: 257 status = acpi_resource_to_address64(resource, addr); 258 if (ACPI_SUCCESS(status) && 259 (addr->resource_type == ACPI_MEMORY_RANGE || 260 addr->resource_type == ACPI_IO_RANGE) && 261 addr->address_length > 0) { 262 return AE_OK; 263 } 264 break; 265 } 266 return AE_ERROR; 267 } 268 269 static acpi_status 270 count_resource(struct acpi_resource *acpi_res, void *data) 271 { 272 struct pci_root_info *info = data; 273 struct acpi_resource_address64 addr; 274 acpi_status status; 275 276 status = resource_to_addr(acpi_res, &addr); 277 if (ACPI_SUCCESS(status)) 278 info->res_num++; 279 return AE_OK; 280 } 281 282 static acpi_status 283 setup_resource(struct acpi_resource *acpi_res, void *data) 284 { 285 struct pci_root_info *info = data; 286 struct resource *res; 287 struct acpi_resource_address64 addr; 288 acpi_status status; 289 unsigned long flags; 290 u64 start, orig_end, end; 291 292 status = resource_to_addr(acpi_res, &addr); 293 if (!ACPI_SUCCESS(status)) 294 return AE_OK; 295 296 if (addr.resource_type == ACPI_MEMORY_RANGE) { 297 flags = IORESOURCE_MEM; 298 if (addr.info.mem.caching == ACPI_PREFETCHABLE_MEMORY) 299 flags |= IORESOURCE_PREFETCH; 300 } else if (addr.resource_type == ACPI_IO_RANGE) { 301 flags = IORESOURCE_IO; 302 } else 303 return AE_OK; 304 305 start = addr.minimum + addr.translation_offset; 306 orig_end = end = addr.maximum + addr.translation_offset; 307 308 /* Exclude non-addressable range or non-addressable portion of range */ 309 end = min(end, (u64)iomem_resource.end); 310 if (end <= start) { 311 dev_info(&info->bridge->dev, 312 "host bridge window [%#llx-%#llx] " 313 "(ignored, not CPU addressable)\n", start, orig_end); 314 return AE_OK; 315 } else if (orig_end != end) { 316 dev_info(&info->bridge->dev, 317 "host bridge window [%#llx-%#llx] " 318 "([%#llx-%#llx] ignored, not CPU addressable)\n", 319 start, orig_end, end + 1, orig_end); 320 } 321 322 res = &info->res[info->res_num]; 323 res->name = info->name; 324 res->flags = flags; 325 res->start = start; 326 res->end = end; 327 info->res_offset[info->res_num] = addr.translation_offset; 328 329 if (!pci_use_crs) { 330 dev_printk(KERN_DEBUG, &info->bridge->dev, 331 "host bridge window %pR (ignored)\n", res); 332 return AE_OK; 333 } 334 335 info->res_num++; 336 337 return AE_OK; 338 } 339 340 static void coalesce_windows(struct pci_root_info *info, unsigned long type) 341 { 342 int i, j; 343 struct resource *res1, *res2; 344 345 for (i = 0; i < info->res_num; i++) { 346 res1 = &info->res[i]; 347 if (!(res1->flags & type)) 348 continue; 349 350 for (j = i + 1; j < info->res_num; j++) { 351 res2 = &info->res[j]; 352 if (!(res2->flags & type)) 353 continue; 354 355 /* 356 * I don't like throwing away windows because then 357 * our resources no longer match the ACPI _CRS, but 358 * the kernel resource tree doesn't allow overlaps. 359 */ 360 if (resource_overlaps(res1, res2)) { 361 res1->start = min(res1->start, res2->start); 362 res1->end = max(res1->end, res2->end); 363 dev_info(&info->bridge->dev, 364 "host bridge window expanded to %pR; %pR ignored\n", 365 res1, res2); 366 res2->flags = 0; 367 } 368 } 369 } 370 } 371 372 static void add_resources(struct pci_root_info *info, 373 struct list_head *resources) 374 { 375 int i; 376 struct resource *res, *root, *conflict; 377 378 coalesce_windows(info, IORESOURCE_MEM); 379 coalesce_windows(info, IORESOURCE_IO); 380 381 for (i = 0; i < info->res_num; i++) { 382 res = &info->res[i]; 383 384 if (res->flags & IORESOURCE_MEM) 385 root = &iomem_resource; 386 else if (res->flags & IORESOURCE_IO) 387 root = &ioport_resource; 388 else 389 continue; 390 391 conflict = insert_resource_conflict(root, res); 392 if (conflict) 393 dev_info(&info->bridge->dev, 394 "ignoring host bridge window %pR (conflicts with %s %pR)\n", 395 res, conflict->name, conflict); 396 else 397 pci_add_resource_offset(resources, res, 398 info->res_offset[i]); 399 } 400 } 401 402 static void free_pci_root_info_res(struct pci_root_info *info) 403 { 404 kfree(info->res); 405 info->res = NULL; 406 kfree(info->res_offset); 407 info->res_offset = NULL; 408 info->res_num = 0; 409 } 410 411 static void __release_pci_root_info(struct pci_root_info *info) 412 { 413 int i; 414 struct resource *res; 415 416 for (i = 0; i < info->res_num; i++) { 417 res = &info->res[i]; 418 419 if (!res->parent) 420 continue; 421 422 if (!(res->flags & (IORESOURCE_MEM | IORESOURCE_IO))) 423 continue; 424 425 release_resource(res); 426 } 427 428 free_pci_root_info_res(info); 429 430 teardown_mcfg_map(info); 431 432 kfree(info); 433 } 434 435 static void release_pci_root_info(struct pci_host_bridge *bridge) 436 { 437 struct pci_root_info *info = bridge->release_data; 438 439 __release_pci_root_info(info); 440 } 441 442 static void 443 probe_pci_root_info(struct pci_root_info *info, struct acpi_device *device, 444 int busnum, int domain) 445 { 446 size_t size; 447 448 sprintf(info->name, "PCI Bus %04x:%02x", domain, busnum); 449 info->bridge = device; 450 451 info->res_num = 0; 452 acpi_walk_resources(device->handle, METHOD_NAME__CRS, count_resource, 453 info); 454 if (!info->res_num) 455 return; 456 457 size = sizeof(*info->res) * info->res_num; 458 info->res = kzalloc(size, GFP_KERNEL); 459 if (!info->res) { 460 info->res_num = 0; 461 return; 462 } 463 464 size = sizeof(*info->res_offset) * info->res_num; 465 info->res_num = 0; 466 info->res_offset = kzalloc(size, GFP_KERNEL); 467 if (!info->res_offset) { 468 kfree(info->res); 469 info->res = NULL; 470 return; 471 } 472 473 acpi_walk_resources(device->handle, METHOD_NAME__CRS, setup_resource, 474 info); 475 } 476 477 struct pci_bus * __devinit pci_acpi_scan_root(struct acpi_pci_root *root) 478 { 479 struct acpi_device *device = root->device; 480 struct pci_root_info *info = NULL; 481 int domain = root->segment; 482 int busnum = root->secondary.start; 483 LIST_HEAD(resources); 484 struct pci_bus *bus = NULL; 485 struct pci_sysdata *sd; 486 int node; 487 #ifdef CONFIG_ACPI_NUMA 488 int pxm; 489 #endif 490 491 if (pci_ignore_seg) 492 domain = 0; 493 494 if (domain && !pci_domains_supported) { 495 printk(KERN_WARNING "pci_bus %04x:%02x: " 496 "ignored (multiple domains not supported)\n", 497 domain, busnum); 498 return NULL; 499 } 500 501 node = -1; 502 #ifdef CONFIG_ACPI_NUMA 503 pxm = acpi_get_pxm(device->handle); 504 if (pxm >= 0) 505 node = pxm_to_node(pxm); 506 if (node != -1) 507 set_mp_bus_to_node(busnum, node); 508 else 509 #endif 510 node = get_mp_bus_to_node(busnum); 511 512 if (node != -1 && !node_online(node)) 513 node = -1; 514 515 info = kzalloc(sizeof(*info), GFP_KERNEL); 516 if (!info) { 517 printk(KERN_WARNING "pci_bus %04x:%02x: " 518 "ignored (out of memory)\n", domain, busnum); 519 return NULL; 520 } 521 522 sd = &info->sd; 523 sd->domain = domain; 524 sd->node = node; 525 /* 526 * Maybe the desired pci bus has been already scanned. In such case 527 * it is unnecessary to scan the pci bus with the given domain,busnum. 528 */ 529 bus = pci_find_bus(domain, busnum); 530 if (bus) { 531 /* 532 * If the desired bus exits, the content of bus->sysdata will 533 * be replaced by sd. 534 */ 535 memcpy(bus->sysdata, sd, sizeof(*sd)); 536 kfree(info); 537 } else { 538 probe_pci_root_info(info, device, busnum, domain); 539 540 /* insert busn res at first */ 541 pci_add_resource(&resources, &root->secondary); 542 /* 543 * _CRS with no apertures is normal, so only fall back to 544 * defaults or native bridge info if we're ignoring _CRS. 545 */ 546 if (pci_use_crs) 547 add_resources(info, &resources); 548 else { 549 free_pci_root_info_res(info); 550 x86_pci_root_bus_resources(busnum, &resources); 551 } 552 553 if (!setup_mcfg_map(info, domain, (u8)root->secondary.start, 554 (u8)root->secondary.end, root->mcfg_addr)) 555 bus = pci_create_root_bus(NULL, busnum, &pci_root_ops, 556 sd, &resources); 557 558 if (bus) { 559 pci_scan_child_bus(bus); 560 pci_set_host_bridge_release( 561 to_pci_host_bridge(bus->bridge), 562 release_pci_root_info, info); 563 } else { 564 pci_free_resource_list(&resources); 565 __release_pci_root_info(info); 566 } 567 } 568 569 /* After the PCI-E bus has been walked and all devices discovered, 570 * configure any settings of the fabric that might be necessary. 571 */ 572 if (bus) { 573 struct pci_bus *child; 574 list_for_each_entry(child, &bus->children, node) { 575 struct pci_dev *self = child->self; 576 if (!self) 577 continue; 578 579 pcie_bus_configure_settings(child, self->pcie_mpss); 580 } 581 } 582 583 if (bus && node != -1) { 584 #ifdef CONFIG_ACPI_NUMA 585 if (pxm >= 0) 586 dev_printk(KERN_DEBUG, &bus->dev, 587 "on NUMA node %d (pxm %d)\n", node, pxm); 588 #else 589 dev_printk(KERN_DEBUG, &bus->dev, "on NUMA node %d\n", node); 590 #endif 591 } 592 593 return bus; 594 } 595 596 int __init pci_acpi_init(void) 597 { 598 struct pci_dev *dev = NULL; 599 600 if (acpi_noirq) 601 return -ENODEV; 602 603 printk(KERN_INFO "PCI: Using ACPI for IRQ routing\n"); 604 acpi_irq_penalty_init(); 605 pcibios_enable_irq = acpi_pci_irq_enable; 606 pcibios_disable_irq = acpi_pci_irq_disable; 607 x86_init.pci.init_irq = x86_init_noop; 608 609 if (pci_routeirq) { 610 /* 611 * PCI IRQ routing is set up by pci_enable_device(), but we 612 * also do it here in case there are still broken drivers that 613 * don't use pci_enable_device(). 614 */ 615 printk(KERN_INFO "PCI: Routing PCI interrupts for all devices because \"pci=routeirq\" specified\n"); 616 for_each_pci_dev(dev) 617 acpi_pci_irq_enable(dev); 618 } 619 620 return 0; 621 } 622