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 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 setup_mcfg_map(struct pci_root_info *info, u16 seg, u8 start, 172 u8 end, phys_addr_t addr) 173 { 174 int result; 175 struct device *dev = &info->bridge->dev; 176 177 info->start_bus = start; 178 info->end_bus = end; 179 info->mcfg_added = false; 180 181 /* return success if MMCFG is not in use */ 182 if (raw_pci_ext_ops && raw_pci_ext_ops != &pci_mmcfg) 183 return 0; 184 185 if (!(pci_probe & PCI_PROBE_MMCONF)) 186 return check_segment(seg, dev, "MMCONFIG is disabled,"); 187 188 result = pci_mmconfig_insert(dev, seg, start, end, addr); 189 if (result == 0) { 190 /* enable MMCFG if it hasn't been enabled yet */ 191 if (raw_pci_ext_ops == NULL) 192 raw_pci_ext_ops = &pci_mmcfg; 193 info->mcfg_added = true; 194 } else if (result != -EEXIST) 195 return check_segment(seg, dev, 196 "fail to add MMCONFIG information,"); 197 198 return 0; 199 } 200 201 static void teardown_mcfg_map(struct pci_root_info *info) 202 { 203 if (info->mcfg_added) { 204 pci_mmconfig_delete(info->segment, info->start_bus, 205 info->end_bus); 206 info->mcfg_added = false; 207 } 208 } 209 #else 210 static int setup_mcfg_map(struct pci_root_info *info, 211 u16 seg, u8 start, u8 end, 212 phys_addr_t addr) 213 { 214 return 0; 215 } 216 static void teardown_mcfg_map(struct pci_root_info *info) 217 { 218 } 219 #endif 220 221 static acpi_status 222 resource_to_addr(struct acpi_resource *resource, 223 struct acpi_resource_address64 *addr) 224 { 225 acpi_status status; 226 struct acpi_resource_memory24 *memory24; 227 struct acpi_resource_memory32 *memory32; 228 struct acpi_resource_fixed_memory32 *fixed_memory32; 229 230 memset(addr, 0, sizeof(*addr)); 231 switch (resource->type) { 232 case ACPI_RESOURCE_TYPE_MEMORY24: 233 memory24 = &resource->data.memory24; 234 addr->resource_type = ACPI_MEMORY_RANGE; 235 addr->minimum = memory24->minimum; 236 addr->address_length = memory24->address_length; 237 addr->maximum = addr->minimum + addr->address_length - 1; 238 return AE_OK; 239 case ACPI_RESOURCE_TYPE_MEMORY32: 240 memory32 = &resource->data.memory32; 241 addr->resource_type = ACPI_MEMORY_RANGE; 242 addr->minimum = memory32->minimum; 243 addr->address_length = memory32->address_length; 244 addr->maximum = addr->minimum + addr->address_length - 1; 245 return AE_OK; 246 case ACPI_RESOURCE_TYPE_FIXED_MEMORY32: 247 fixed_memory32 = &resource->data.fixed_memory32; 248 addr->resource_type = ACPI_MEMORY_RANGE; 249 addr->minimum = fixed_memory32->address; 250 addr->address_length = fixed_memory32->address_length; 251 addr->maximum = addr->minimum + addr->address_length - 1; 252 return AE_OK; 253 case ACPI_RESOURCE_TYPE_ADDRESS16: 254 case ACPI_RESOURCE_TYPE_ADDRESS32: 255 case ACPI_RESOURCE_TYPE_ADDRESS64: 256 status = acpi_resource_to_address64(resource, addr); 257 if (ACPI_SUCCESS(status) && 258 (addr->resource_type == ACPI_MEMORY_RANGE || 259 addr->resource_type == ACPI_IO_RANGE) && 260 addr->address_length > 0) { 261 return AE_OK; 262 } 263 break; 264 } 265 return AE_ERROR; 266 } 267 268 static acpi_status 269 count_resource(struct acpi_resource *acpi_res, void *data) 270 { 271 struct pci_root_info *info = data; 272 struct acpi_resource_address64 addr; 273 acpi_status status; 274 275 status = resource_to_addr(acpi_res, &addr); 276 if (ACPI_SUCCESS(status)) 277 info->res_num++; 278 return AE_OK; 279 } 280 281 static acpi_status 282 setup_resource(struct acpi_resource *acpi_res, void *data) 283 { 284 struct pci_root_info *info = data; 285 struct resource *res; 286 struct acpi_resource_address64 addr; 287 acpi_status status; 288 unsigned long flags; 289 u64 start, orig_end, end; 290 291 status = resource_to_addr(acpi_res, &addr); 292 if (!ACPI_SUCCESS(status)) 293 return AE_OK; 294 295 if (addr.resource_type == ACPI_MEMORY_RANGE) { 296 flags = IORESOURCE_MEM; 297 if (addr.info.mem.caching == ACPI_PREFETCHABLE_MEMORY) 298 flags |= IORESOURCE_PREFETCH; 299 } else if (addr.resource_type == ACPI_IO_RANGE) { 300 flags = IORESOURCE_IO; 301 } else 302 return AE_OK; 303 304 start = addr.minimum + addr.translation_offset; 305 orig_end = end = addr.maximum + addr.translation_offset; 306 307 /* Exclude non-addressable range or non-addressable portion of range */ 308 end = min(end, (u64)iomem_resource.end); 309 if (end <= start) { 310 dev_info(&info->bridge->dev, 311 "host bridge window [%#llx-%#llx] " 312 "(ignored, not CPU addressable)\n", start, orig_end); 313 return AE_OK; 314 } else if (orig_end != end) { 315 dev_info(&info->bridge->dev, 316 "host bridge window [%#llx-%#llx] " 317 "([%#llx-%#llx] ignored, not CPU addressable)\n", 318 start, orig_end, end + 1, orig_end); 319 } 320 321 res = &info->res[info->res_num]; 322 res->name = info->name; 323 res->flags = flags; 324 res->start = start; 325 res->end = end; 326 info->res_offset[info->res_num] = addr.translation_offset; 327 info->res_num++; 328 329 if (!pci_use_crs) 330 dev_printk(KERN_DEBUG, &info->bridge->dev, 331 "host bridge window %pR (ignored)\n", res); 332 333 return AE_OK; 334 } 335 336 static void coalesce_windows(struct pci_root_info *info, unsigned long type) 337 { 338 int i, j; 339 struct resource *res1, *res2; 340 341 for (i = 0; i < info->res_num; i++) { 342 res1 = &info->res[i]; 343 if (!(res1->flags & type)) 344 continue; 345 346 for (j = i + 1; j < info->res_num; j++) { 347 res2 = &info->res[j]; 348 if (!(res2->flags & type)) 349 continue; 350 351 /* 352 * I don't like throwing away windows because then 353 * our resources no longer match the ACPI _CRS, but 354 * the kernel resource tree doesn't allow overlaps. 355 */ 356 if (resource_overlaps(res1, res2)) { 357 res1->start = min(res1->start, res2->start); 358 res1->end = max(res1->end, res2->end); 359 dev_info(&info->bridge->dev, 360 "host bridge window expanded to %pR; %pR ignored\n", 361 res1, res2); 362 res2->flags = 0; 363 } 364 } 365 } 366 } 367 368 static void add_resources(struct pci_root_info *info, 369 struct list_head *resources) 370 { 371 int i; 372 struct resource *res, *root, *conflict; 373 374 coalesce_windows(info, IORESOURCE_MEM); 375 coalesce_windows(info, IORESOURCE_IO); 376 377 for (i = 0; i < info->res_num; i++) { 378 res = &info->res[i]; 379 380 if (res->flags & IORESOURCE_MEM) 381 root = &iomem_resource; 382 else if (res->flags & IORESOURCE_IO) 383 root = &ioport_resource; 384 else 385 continue; 386 387 conflict = insert_resource_conflict(root, res); 388 if (conflict) 389 dev_info(&info->bridge->dev, 390 "ignoring host bridge window %pR (conflicts with %s %pR)\n", 391 res, conflict->name, conflict); 392 else 393 pci_add_resource_offset(resources, res, 394 info->res_offset[i]); 395 } 396 } 397 398 static void free_pci_root_info_res(struct pci_root_info *info) 399 { 400 kfree(info->res); 401 info->res = NULL; 402 kfree(info->res_offset); 403 info->res_offset = NULL; 404 info->res_num = 0; 405 } 406 407 static void __release_pci_root_info(struct pci_root_info *info) 408 { 409 int i; 410 struct resource *res; 411 412 for (i = 0; i < info->res_num; i++) { 413 res = &info->res[i]; 414 415 if (!res->parent) 416 continue; 417 418 if (!(res->flags & (IORESOURCE_MEM | IORESOURCE_IO))) 419 continue; 420 421 release_resource(res); 422 } 423 424 free_pci_root_info_res(info); 425 426 teardown_mcfg_map(info); 427 428 kfree(info); 429 } 430 431 static void release_pci_root_info(struct pci_host_bridge *bridge) 432 { 433 struct pci_root_info *info = bridge->release_data; 434 435 __release_pci_root_info(info); 436 } 437 438 static void 439 probe_pci_root_info(struct pci_root_info *info, struct acpi_device *device, 440 int busnum, int domain) 441 { 442 size_t size; 443 444 sprintf(info->name, "PCI Bus %04x:%02x", domain, busnum); 445 info->bridge = device; 446 447 info->res_num = 0; 448 acpi_walk_resources(device->handle, METHOD_NAME__CRS, count_resource, 449 info); 450 if (!info->res_num) 451 return; 452 453 size = sizeof(*info->res) * info->res_num; 454 info->res = kzalloc(size, GFP_KERNEL); 455 if (!info->res) { 456 info->res_num = 0; 457 return; 458 } 459 460 size = sizeof(*info->res_offset) * info->res_num; 461 info->res_num = 0; 462 info->res_offset = kzalloc(size, GFP_KERNEL); 463 if (!info->res_offset) { 464 kfree(info->res); 465 info->res = NULL; 466 return; 467 } 468 469 acpi_walk_resources(device->handle, METHOD_NAME__CRS, setup_resource, 470 info); 471 } 472 473 struct pci_bus *pci_acpi_scan_root(struct acpi_pci_root *root) 474 { 475 struct acpi_device *device = root->device; 476 struct pci_root_info *info = NULL; 477 int domain = root->segment; 478 int busnum = root->secondary.start; 479 LIST_HEAD(resources); 480 struct pci_bus *bus = NULL; 481 struct pci_sysdata *sd; 482 int node; 483 #ifdef CONFIG_ACPI_NUMA 484 int pxm; 485 #endif 486 487 if (pci_ignore_seg) 488 domain = 0; 489 490 if (domain && !pci_domains_supported) { 491 printk(KERN_WARNING "pci_bus %04x:%02x: " 492 "ignored (multiple domains not supported)\n", 493 domain, busnum); 494 return NULL; 495 } 496 497 node = -1; 498 #ifdef CONFIG_ACPI_NUMA 499 pxm = acpi_get_pxm(device->handle); 500 if (pxm >= 0) 501 node = pxm_to_node(pxm); 502 if (node != -1) 503 set_mp_bus_to_node(busnum, node); 504 else 505 #endif 506 node = get_mp_bus_to_node(busnum); 507 508 if (node != -1 && !node_online(node)) 509 node = -1; 510 511 info = kzalloc(sizeof(*info), GFP_KERNEL); 512 if (!info) { 513 printk(KERN_WARNING "pci_bus %04x:%02x: " 514 "ignored (out of memory)\n", domain, busnum); 515 return NULL; 516 } 517 518 sd = &info->sd; 519 sd->domain = domain; 520 sd->node = node; 521 sd->acpi = device->handle; 522 /* 523 * Maybe the desired pci bus has been already scanned. In such case 524 * it is unnecessary to scan the pci bus with the given domain,busnum. 525 */ 526 bus = pci_find_bus(domain, busnum); 527 if (bus) { 528 /* 529 * If the desired bus exits, the content of bus->sysdata will 530 * be replaced by sd. 531 */ 532 memcpy(bus->sysdata, sd, sizeof(*sd)); 533 kfree(info); 534 } else { 535 probe_pci_root_info(info, device, busnum, domain); 536 537 /* insert busn res at first */ 538 pci_add_resource(&resources, &root->secondary); 539 /* 540 * _CRS with no apertures is normal, so only fall back to 541 * defaults or native bridge info if we're ignoring _CRS. 542 */ 543 if (pci_use_crs) 544 add_resources(info, &resources); 545 else { 546 free_pci_root_info_res(info); 547 x86_pci_root_bus_resources(busnum, &resources); 548 } 549 550 if (!setup_mcfg_map(info, domain, (u8)root->secondary.start, 551 (u8)root->secondary.end, root->mcfg_addr)) 552 bus = pci_create_root_bus(NULL, busnum, &pci_root_ops, 553 sd, &resources); 554 555 if (bus) { 556 pci_scan_child_bus(bus); 557 pci_set_host_bridge_release( 558 to_pci_host_bridge(bus->bridge), 559 release_pci_root_info, info); 560 } else { 561 pci_free_resource_list(&resources); 562 __release_pci_root_info(info); 563 } 564 } 565 566 /* After the PCI-E bus has been walked and all devices discovered, 567 * configure any settings of the fabric that might be necessary. 568 */ 569 if (bus) { 570 struct pci_bus *child; 571 list_for_each_entry(child, &bus->children, node) 572 pcie_bus_configure_settings(child); 573 } 574 575 if (bus && node != -1) { 576 #ifdef CONFIG_ACPI_NUMA 577 if (pxm >= 0) 578 dev_printk(KERN_DEBUG, &bus->dev, 579 "on NUMA node %d (pxm %d)\n", node, pxm); 580 #else 581 dev_printk(KERN_DEBUG, &bus->dev, "on NUMA node %d\n", node); 582 #endif 583 } 584 585 return bus; 586 } 587 588 int pcibios_root_bridge_prepare(struct pci_host_bridge *bridge) 589 { 590 struct pci_sysdata *sd = bridge->bus->sysdata; 591 592 ACPI_HANDLE_SET(&bridge->dev, sd->acpi); 593 return 0; 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