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 328 if (!pci_use_crs) { 329 dev_printk(KERN_DEBUG, &info->bridge->dev, 330 "host bridge window %pR (ignored)\n", res); 331 return AE_OK; 332 } 333 334 info->res_num++; 335 336 return AE_OK; 337 } 338 339 static void coalesce_windows(struct pci_root_info *info, unsigned long type) 340 { 341 int i, j; 342 struct resource *res1, *res2; 343 344 for (i = 0; i < info->res_num; i++) { 345 res1 = &info->res[i]; 346 if (!(res1->flags & type)) 347 continue; 348 349 for (j = i + 1; j < info->res_num; j++) { 350 res2 = &info->res[j]; 351 if (!(res2->flags & type)) 352 continue; 353 354 /* 355 * I don't like throwing away windows because then 356 * our resources no longer match the ACPI _CRS, but 357 * the kernel resource tree doesn't allow overlaps. 358 */ 359 if (resource_overlaps(res1, res2)) { 360 res1->start = min(res1->start, res2->start); 361 res1->end = max(res1->end, res2->end); 362 dev_info(&info->bridge->dev, 363 "host bridge window expanded to %pR; %pR ignored\n", 364 res1, res2); 365 res2->flags = 0; 366 } 367 } 368 } 369 } 370 371 static void add_resources(struct pci_root_info *info, 372 struct list_head *resources) 373 { 374 int i; 375 struct resource *res, *root, *conflict; 376 377 coalesce_windows(info, IORESOURCE_MEM); 378 coalesce_windows(info, IORESOURCE_IO); 379 380 for (i = 0; i < info->res_num; i++) { 381 res = &info->res[i]; 382 383 if (res->flags & IORESOURCE_MEM) 384 root = &iomem_resource; 385 else if (res->flags & IORESOURCE_IO) 386 root = &ioport_resource; 387 else 388 continue; 389 390 conflict = insert_resource_conflict(root, res); 391 if (conflict) 392 dev_info(&info->bridge->dev, 393 "ignoring host bridge window %pR (conflicts with %s %pR)\n", 394 res, conflict->name, conflict); 395 else 396 pci_add_resource_offset(resources, res, 397 info->res_offset[i]); 398 } 399 } 400 401 static void free_pci_root_info_res(struct pci_root_info *info) 402 { 403 kfree(info->res); 404 info->res = NULL; 405 kfree(info->res_offset); 406 info->res_offset = NULL; 407 info->res_num = 0; 408 } 409 410 static void __release_pci_root_info(struct pci_root_info *info) 411 { 412 int i; 413 struct resource *res; 414 415 for (i = 0; i < info->res_num; i++) { 416 res = &info->res[i]; 417 418 if (!res->parent) 419 continue; 420 421 if (!(res->flags & (IORESOURCE_MEM | IORESOURCE_IO))) 422 continue; 423 424 release_resource(res); 425 } 426 427 free_pci_root_info_res(info); 428 429 teardown_mcfg_map(info); 430 431 kfree(info); 432 } 433 434 static void release_pci_root_info(struct pci_host_bridge *bridge) 435 { 436 struct pci_root_info *info = bridge->release_data; 437 438 __release_pci_root_info(info); 439 } 440 441 static void 442 probe_pci_root_info(struct pci_root_info *info, struct acpi_device *device, 443 int busnum, int domain) 444 { 445 size_t size; 446 447 sprintf(info->name, "PCI Bus %04x:%02x", domain, busnum); 448 info->bridge = device; 449 450 info->res_num = 0; 451 acpi_walk_resources(device->handle, METHOD_NAME__CRS, count_resource, 452 info); 453 if (!info->res_num) 454 return; 455 456 size = sizeof(*info->res) * info->res_num; 457 info->res = kzalloc(size, GFP_KERNEL); 458 if (!info->res) { 459 info->res_num = 0; 460 return; 461 } 462 463 size = sizeof(*info->res_offset) * info->res_num; 464 info->res_num = 0; 465 info->res_offset = kzalloc(size, GFP_KERNEL); 466 if (!info->res_offset) { 467 kfree(info->res); 468 info->res = NULL; 469 return; 470 } 471 472 acpi_walk_resources(device->handle, METHOD_NAME__CRS, setup_resource, 473 info); 474 } 475 476 struct pci_bus *pci_acpi_scan_root(struct acpi_pci_root *root) 477 { 478 struct acpi_device *device = root->device; 479 struct pci_root_info *info = NULL; 480 int domain = root->segment; 481 int busnum = root->secondary.start; 482 LIST_HEAD(resources); 483 struct pci_bus *bus = NULL; 484 struct pci_sysdata *sd; 485 int node; 486 #ifdef CONFIG_ACPI_NUMA 487 int pxm; 488 #endif 489 490 if (pci_ignore_seg) 491 domain = 0; 492 493 if (domain && !pci_domains_supported) { 494 printk(KERN_WARNING "pci_bus %04x:%02x: " 495 "ignored (multiple domains not supported)\n", 496 domain, busnum); 497 return NULL; 498 } 499 500 node = -1; 501 #ifdef CONFIG_ACPI_NUMA 502 pxm = acpi_get_pxm(device->handle); 503 if (pxm >= 0) 504 node = pxm_to_node(pxm); 505 if (node != -1) 506 set_mp_bus_to_node(busnum, node); 507 else 508 #endif 509 node = get_mp_bus_to_node(busnum); 510 511 if (node != -1 && !node_online(node)) 512 node = -1; 513 514 info = kzalloc(sizeof(*info), GFP_KERNEL); 515 if (!info) { 516 printk(KERN_WARNING "pci_bus %04x:%02x: " 517 "ignored (out of memory)\n", domain, busnum); 518 return NULL; 519 } 520 521 sd = &info->sd; 522 sd->domain = domain; 523 sd->node = node; 524 sd->acpi = device->handle; 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 pcibios_root_bridge_prepare(struct pci_host_bridge *bridge) 597 { 598 struct pci_sysdata *sd = bridge->bus->sysdata; 599 600 ACPI_HANDLE_SET(&bridge->dev, sd->acpi); 601 return 0; 602 } 603 604 int __init pci_acpi_init(void) 605 { 606 struct pci_dev *dev = NULL; 607 608 if (acpi_noirq) 609 return -ENODEV; 610 611 printk(KERN_INFO "PCI: Using ACPI for IRQ routing\n"); 612 acpi_irq_penalty_init(); 613 pcibios_enable_irq = acpi_pci_irq_enable; 614 pcibios_disable_irq = acpi_pci_irq_disable; 615 x86_init.pci.init_irq = x86_init_noop; 616 617 if (pci_routeirq) { 618 /* 619 * PCI IRQ routing is set up by pci_enable_device(), but we 620 * also do it here in case there are still broken drivers that 621 * don't use pci_enable_device(). 622 */ 623 printk(KERN_INFO "PCI: Routing PCI interrupts for all devices because \"pci=routeirq\" specified\n"); 624 for_each_pci_dev(dev) 625 acpi_pci_irq_enable(dev); 626 } 627 628 return 0; 629 } 630