1/* 2 * pci_root.c - ACPI PCI Root Bridge Driver ($Revision: 40 $) 3 * 4 * Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com> 5 * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com> 6 * 7 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License as published by 11 * the Free Software Foundation; either version 2 of the License, or (at 12 * your option) any later version. 13 * 14 * This program is distributed in the hope that it will be useful, but 15 * WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 17 * General Public License for more details. 18 * 19 * You should have received a copy of the GNU General Public License along 20 * with this program; if not, write to the Free Software Foundation, Inc., 21 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. 22 * 23 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 24 */ 25 26#include <linux/kernel.h> 27#include <linux/module.h> 28#include <linux/init.h> 29#include <linux/types.h> 30#include <linux/mutex.h> 31#include <linux/pm.h> 32#include <linux/pm_runtime.h> 33#include <linux/pci.h> 34#include <linux/pci-acpi.h> 35#include <linux/pci-aspm.h> 36#include <linux/acpi.h> 37#include <linux/slab.h> 38#include <linux/dmi.h> 39#include <acpi/apei.h> /* for acpi_hest_init() */ 40 41#include "internal.h" 42 43#define _COMPONENT ACPI_PCI_COMPONENT 44ACPI_MODULE_NAME("pci_root"); 45#define ACPI_PCI_ROOT_CLASS "pci_bridge" 46#define ACPI_PCI_ROOT_DEVICE_NAME "PCI Root Bridge" 47static int acpi_pci_root_add(struct acpi_device *device, 48 const struct acpi_device_id *not_used); 49static void acpi_pci_root_remove(struct acpi_device *device); 50 51static int acpi_pci_root_scan_dependent(struct acpi_device *adev) 52{ 53 acpiphp_check_host_bridge(adev); 54 return 0; 55} 56 57#define ACPI_PCIE_REQ_SUPPORT (OSC_PCI_EXT_CONFIG_SUPPORT \ 58 | OSC_PCI_ASPM_SUPPORT \ 59 | OSC_PCI_CLOCK_PM_SUPPORT \ 60 | OSC_PCI_MSI_SUPPORT) 61 62static const struct acpi_device_id root_device_ids[] = { 63 {"PNP0A03", 0}, 64 {"", 0}, 65}; 66 67static struct acpi_scan_handler pci_root_handler = { 68 .ids = root_device_ids, 69 .attach = acpi_pci_root_add, 70 .detach = acpi_pci_root_remove, 71 .hotplug = { 72 .enabled = true, 73 .scan_dependent = acpi_pci_root_scan_dependent, 74 }, 75}; 76 77static DEFINE_MUTEX(osc_lock); 78 79/** 80 * acpi_is_root_bridge - determine whether an ACPI CA node is a PCI root bridge 81 * @handle - the ACPI CA node in question. 82 * 83 * Note: we could make this API take a struct acpi_device * instead, but 84 * for now, it's more convenient to operate on an acpi_handle. 85 */ 86int acpi_is_root_bridge(acpi_handle handle) 87{ 88 int ret; 89 struct acpi_device *device; 90 91 ret = acpi_bus_get_device(handle, &device); 92 if (ret) 93 return 0; 94 95 ret = acpi_match_device_ids(device, root_device_ids); 96 if (ret) 97 return 0; 98 else 99 return 1; 100} 101EXPORT_SYMBOL_GPL(acpi_is_root_bridge); 102 103static acpi_status 104get_root_bridge_busnr_callback(struct acpi_resource *resource, void *data) 105{ 106 struct resource *res = data; 107 struct acpi_resource_address64 address; 108 acpi_status status; 109 110 status = acpi_resource_to_address64(resource, &address); 111 if (ACPI_FAILURE(status)) 112 return AE_OK; 113 114 if ((address.address_length > 0) && 115 (address.resource_type == ACPI_BUS_NUMBER_RANGE)) { 116 res->start = address.minimum; 117 res->end = address.minimum + address.address_length - 1; 118 } 119 120 return AE_OK; 121} 122 123static acpi_status try_get_root_bridge_busnr(acpi_handle handle, 124 struct resource *res) 125{ 126 acpi_status status; 127 128 res->start = -1; 129 status = 130 acpi_walk_resources(handle, METHOD_NAME__CRS, 131 get_root_bridge_busnr_callback, res); 132 if (ACPI_FAILURE(status)) 133 return status; 134 if (res->start == -1) 135 return AE_ERROR; 136 return AE_OK; 137} 138 139struct pci_osc_bit_struct { 140 u32 bit; 141 char *desc; 142}; 143 144static struct pci_osc_bit_struct pci_osc_support_bit[] = { 145 { OSC_PCI_EXT_CONFIG_SUPPORT, "ExtendedConfig" }, 146 { OSC_PCI_ASPM_SUPPORT, "ASPM" }, 147 { OSC_PCI_CLOCK_PM_SUPPORT, "ClockPM" }, 148 { OSC_PCI_SEGMENT_GROUPS_SUPPORT, "Segments" }, 149 { OSC_PCI_MSI_SUPPORT, "MSI" }, 150}; 151 152static struct pci_osc_bit_struct pci_osc_control_bit[] = { 153 { OSC_PCI_EXPRESS_NATIVE_HP_CONTROL, "PCIeHotplug" }, 154 { OSC_PCI_SHPC_NATIVE_HP_CONTROL, "SHPCHotplug" }, 155 { OSC_PCI_EXPRESS_PME_CONTROL, "PME" }, 156 { OSC_PCI_EXPRESS_AER_CONTROL, "AER" }, 157 { OSC_PCI_EXPRESS_CAPABILITY_CONTROL, "PCIeCapability" }, 158}; 159 160static void decode_osc_bits(struct acpi_pci_root *root, char *msg, u32 word, 161 struct pci_osc_bit_struct *table, int size) 162{ 163 char buf[80]; 164 int i, len = 0; 165 struct pci_osc_bit_struct *entry; 166 167 buf[0] = '\0'; 168 for (i = 0, entry = table; i < size; i++, entry++) 169 if (word & entry->bit) 170 len += snprintf(buf + len, sizeof(buf) - len, "%s%s", 171 len ? " " : "", entry->desc); 172 173 dev_info(&root->device->dev, "_OSC: %s [%s]\n", msg, buf); 174} 175 176static void decode_osc_support(struct acpi_pci_root *root, char *msg, u32 word) 177{ 178 decode_osc_bits(root, msg, word, pci_osc_support_bit, 179 ARRAY_SIZE(pci_osc_support_bit)); 180} 181 182static void decode_osc_control(struct acpi_pci_root *root, char *msg, u32 word) 183{ 184 decode_osc_bits(root, msg, word, pci_osc_control_bit, 185 ARRAY_SIZE(pci_osc_control_bit)); 186} 187 188static u8 pci_osc_uuid_str[] = "33DB4D5B-1FF7-401C-9657-7441C03DD766"; 189 190static acpi_status acpi_pci_run_osc(acpi_handle handle, 191 const u32 *capbuf, u32 *retval) 192{ 193 struct acpi_osc_context context = { 194 .uuid_str = pci_osc_uuid_str, 195 .rev = 1, 196 .cap.length = 12, 197 .cap.pointer = (void *)capbuf, 198 }; 199 acpi_status status; 200 201 status = acpi_run_osc(handle, &context); 202 if (ACPI_SUCCESS(status)) { 203 *retval = *((u32 *)(context.ret.pointer + 8)); 204 kfree(context.ret.pointer); 205 } 206 return status; 207} 208 209static acpi_status acpi_pci_query_osc(struct acpi_pci_root *root, 210 u32 support, 211 u32 *control) 212{ 213 acpi_status status; 214 u32 result, capbuf[3]; 215 216 support &= OSC_PCI_SUPPORT_MASKS; 217 support |= root->osc_support_set; 218 219 capbuf[OSC_QUERY_DWORD] = OSC_QUERY_ENABLE; 220 capbuf[OSC_SUPPORT_DWORD] = support; 221 if (control) { 222 *control &= OSC_PCI_CONTROL_MASKS; 223 capbuf[OSC_CONTROL_DWORD] = *control | root->osc_control_set; 224 } else { 225 /* Run _OSC query only with existing controls. */ 226 capbuf[OSC_CONTROL_DWORD] = root->osc_control_set; 227 } 228 229 status = acpi_pci_run_osc(root->device->handle, capbuf, &result); 230 if (ACPI_SUCCESS(status)) { 231 root->osc_support_set = support; 232 if (control) 233 *control = result; 234 } 235 return status; 236} 237 238static acpi_status acpi_pci_osc_support(struct acpi_pci_root *root, u32 flags) 239{ 240 acpi_status status; 241 242 mutex_lock(&osc_lock); 243 status = acpi_pci_query_osc(root, flags, NULL); 244 mutex_unlock(&osc_lock); 245 return status; 246} 247 248struct acpi_pci_root *acpi_pci_find_root(acpi_handle handle) 249{ 250 struct acpi_pci_root *root; 251 struct acpi_device *device; 252 253 if (acpi_bus_get_device(handle, &device) || 254 acpi_match_device_ids(device, root_device_ids)) 255 return NULL; 256 257 root = acpi_driver_data(device); 258 259 return root; 260} 261EXPORT_SYMBOL_GPL(acpi_pci_find_root); 262 263struct acpi_handle_node { 264 struct list_head node; 265 acpi_handle handle; 266}; 267 268/** 269 * acpi_get_pci_dev - convert ACPI CA handle to struct pci_dev 270 * @handle: the handle in question 271 * 272 * Given an ACPI CA handle, the desired PCI device is located in the 273 * list of PCI devices. 274 * 275 * If the device is found, its reference count is increased and this 276 * function returns a pointer to its data structure. The caller must 277 * decrement the reference count by calling pci_dev_put(). 278 * If no device is found, %NULL is returned. 279 */ 280struct pci_dev *acpi_get_pci_dev(acpi_handle handle) 281{ 282 int dev, fn; 283 unsigned long long adr; 284 acpi_status status; 285 acpi_handle phandle; 286 struct pci_bus *pbus; 287 struct pci_dev *pdev = NULL; 288 struct acpi_handle_node *node, *tmp; 289 struct acpi_pci_root *root; 290 LIST_HEAD(device_list); 291 292 /* 293 * Walk up the ACPI CA namespace until we reach a PCI root bridge. 294 */ 295 phandle = handle; 296 while (!acpi_is_root_bridge(phandle)) { 297 node = kzalloc(sizeof(struct acpi_handle_node), GFP_KERNEL); 298 if (!node) 299 goto out; 300 301 INIT_LIST_HEAD(&node->node); 302 node->handle = phandle; 303 list_add(&node->node, &device_list); 304 305 status = acpi_get_parent(phandle, &phandle); 306 if (ACPI_FAILURE(status)) 307 goto out; 308 } 309 310 root = acpi_pci_find_root(phandle); 311 if (!root) 312 goto out; 313 314 pbus = root->bus; 315 316 /* 317 * Now, walk back down the PCI device tree until we return to our 318 * original handle. Assumes that everything between the PCI root 319 * bridge and the device we're looking for must be a P2P bridge. 320 */ 321 list_for_each_entry(node, &device_list, node) { 322 acpi_handle hnd = node->handle; 323 status = acpi_evaluate_integer(hnd, "_ADR", NULL, &adr); 324 if (ACPI_FAILURE(status)) 325 goto out; 326 dev = (adr >> 16) & 0xffff; 327 fn = adr & 0xffff; 328 329 pdev = pci_get_slot(pbus, PCI_DEVFN(dev, fn)); 330 if (!pdev || hnd == handle) 331 break; 332 333 pbus = pdev->subordinate; 334 pci_dev_put(pdev); 335 336 /* 337 * This function may be called for a non-PCI device that has a 338 * PCI parent (eg. a disk under a PCI SATA controller). In that 339 * case pdev->subordinate will be NULL for the parent. 340 */ 341 if (!pbus) { 342 dev_dbg(&pdev->dev, "Not a PCI-to-PCI bridge\n"); 343 pdev = NULL; 344 break; 345 } 346 } 347out: 348 list_for_each_entry_safe(node, tmp, &device_list, node) 349 kfree(node); 350 351 return pdev; 352} 353EXPORT_SYMBOL_GPL(acpi_get_pci_dev); 354 355/** 356 * acpi_pci_osc_control_set - Request control of PCI root _OSC features. 357 * @handle: ACPI handle of a PCI root bridge (or PCIe Root Complex). 358 * @mask: Mask of _OSC bits to request control of, place to store control mask. 359 * @req: Mask of _OSC bits the control of is essential to the caller. 360 * 361 * Run _OSC query for @mask and if that is successful, compare the returned 362 * mask of control bits with @req. If all of the @req bits are set in the 363 * returned mask, run _OSC request for it. 364 * 365 * The variable at the @mask address may be modified regardless of whether or 366 * not the function returns success. On success it will contain the mask of 367 * _OSC bits the BIOS has granted control of, but its contents are meaningless 368 * on failure. 369 **/ 370acpi_status acpi_pci_osc_control_set(acpi_handle handle, u32 *mask, u32 req) 371{ 372 struct acpi_pci_root *root; 373 acpi_status status = AE_OK; 374 u32 ctrl, capbuf[3]; 375 376 if (!mask) 377 return AE_BAD_PARAMETER; 378 379 ctrl = *mask & OSC_PCI_CONTROL_MASKS; 380 if ((ctrl & req) != req) 381 return AE_TYPE; 382 383 root = acpi_pci_find_root(handle); 384 if (!root) 385 return AE_NOT_EXIST; 386 387 mutex_lock(&osc_lock); 388 389 *mask = ctrl | root->osc_control_set; 390 /* No need to evaluate _OSC if the control was already granted. */ 391 if ((root->osc_control_set & ctrl) == ctrl) 392 goto out; 393 394 /* Need to check the available controls bits before requesting them. */ 395 while (*mask) { 396 status = acpi_pci_query_osc(root, root->osc_support_set, mask); 397 if (ACPI_FAILURE(status)) 398 goto out; 399 if (ctrl == *mask) 400 break; 401 decode_osc_control(root, "platform does not support", 402 ctrl & ~(*mask)); 403 ctrl = *mask; 404 } 405 406 if ((ctrl & req) != req) { 407 decode_osc_control(root, "not requesting control; platform does not support", 408 req & ~(ctrl)); 409 status = AE_SUPPORT; 410 goto out; 411 } 412 413 capbuf[OSC_QUERY_DWORD] = 0; 414 capbuf[OSC_SUPPORT_DWORD] = root->osc_support_set; 415 capbuf[OSC_CONTROL_DWORD] = ctrl; 416 status = acpi_pci_run_osc(handle, capbuf, mask); 417 if (ACPI_SUCCESS(status)) 418 root->osc_control_set = *mask; 419out: 420 mutex_unlock(&osc_lock); 421 return status; 422} 423EXPORT_SYMBOL(acpi_pci_osc_control_set); 424 425static void negotiate_os_control(struct acpi_pci_root *root, int *no_aspm, 426 int *clear_aspm) 427{ 428 u32 support, control, requested; 429 acpi_status status; 430 struct acpi_device *device = root->device; 431 acpi_handle handle = device->handle; 432 433 /* 434 * Apple always return failure on _OSC calls when _OSI("Darwin") has 435 * been called successfully. We know the feature set supported by the 436 * platform, so avoid calling _OSC at all 437 */ 438 439 if (dmi_match(DMI_SYS_VENDOR, "Apple Inc.")) { 440 root->osc_control_set = ~OSC_PCI_EXPRESS_PME_CONTROL; 441 decode_osc_control(root, "OS assumes control of", 442 root->osc_control_set); 443 return; 444 } 445 446 /* 447 * All supported architectures that use ACPI have support for 448 * PCI domains, so we indicate this in _OSC support capabilities. 449 */ 450 support = OSC_PCI_SEGMENT_GROUPS_SUPPORT; 451 if (pci_ext_cfg_avail()) 452 support |= OSC_PCI_EXT_CONFIG_SUPPORT; 453 if (pcie_aspm_support_enabled()) 454 support |= OSC_PCI_ASPM_SUPPORT | OSC_PCI_CLOCK_PM_SUPPORT; 455 if (pci_msi_enabled()) 456 support |= OSC_PCI_MSI_SUPPORT; 457 458 decode_osc_support(root, "OS supports", support); 459 status = acpi_pci_osc_support(root, support); 460 if (ACPI_FAILURE(status)) { 461 dev_info(&device->dev, "_OSC failed (%s); disabling ASPM\n", 462 acpi_format_exception(status)); 463 *no_aspm = 1; 464 return; 465 } 466 467 if (pcie_ports_disabled) { 468 dev_info(&device->dev, "PCIe port services disabled; not requesting _OSC control\n"); 469 return; 470 } 471 472 if ((support & ACPI_PCIE_REQ_SUPPORT) != ACPI_PCIE_REQ_SUPPORT) { 473 decode_osc_support(root, "not requesting OS control; OS requires", 474 ACPI_PCIE_REQ_SUPPORT); 475 return; 476 } 477 478 control = OSC_PCI_EXPRESS_CAPABILITY_CONTROL 479 | OSC_PCI_EXPRESS_NATIVE_HP_CONTROL 480 | OSC_PCI_EXPRESS_PME_CONTROL; 481 482 if (pci_aer_available()) { 483 if (aer_acpi_firmware_first()) 484 dev_info(&device->dev, 485 "PCIe AER handled by firmware\n"); 486 else 487 control |= OSC_PCI_EXPRESS_AER_CONTROL; 488 } 489 490 requested = control; 491 status = acpi_pci_osc_control_set(handle, &control, 492 OSC_PCI_EXPRESS_CAPABILITY_CONTROL); 493 if (ACPI_SUCCESS(status)) { 494 decode_osc_control(root, "OS now controls", control); 495 if (acpi_gbl_FADT.boot_flags & ACPI_FADT_NO_ASPM) { 496 /* 497 * We have ASPM control, but the FADT indicates 498 * that it's unsupported. Clear it. 499 */ 500 *clear_aspm = 1; 501 } 502 } else { 503 decode_osc_control(root, "OS requested", requested); 504 decode_osc_control(root, "platform willing to grant", control); 505 dev_info(&device->dev, "_OSC failed (%s); disabling ASPM\n", 506 acpi_format_exception(status)); 507 508 /* 509 * We want to disable ASPM here, but aspm_disabled 510 * needs to remain in its state from boot so that we 511 * properly handle PCIe 1.1 devices. So we set this 512 * flag here, to defer the action until after the ACPI 513 * root scan. 514 */ 515 *no_aspm = 1; 516 } 517} 518 519static int acpi_pci_root_add(struct acpi_device *device, 520 const struct acpi_device_id *not_used) 521{ 522 unsigned long long segment, bus; 523 acpi_status status; 524 int result; 525 struct acpi_pci_root *root; 526 acpi_handle handle = device->handle; 527 int no_aspm = 0, clear_aspm = 0; 528 529 root = kzalloc(sizeof(struct acpi_pci_root), GFP_KERNEL); 530 if (!root) 531 return -ENOMEM; 532 533 segment = 0; 534 status = acpi_evaluate_integer(handle, METHOD_NAME__SEG, NULL, 535 &segment); 536 if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) { 537 dev_err(&device->dev, "can't evaluate _SEG\n"); 538 result = -ENODEV; 539 goto end; 540 } 541 542 /* Check _CRS first, then _BBN. If no _BBN, default to zero. */ 543 root->secondary.flags = IORESOURCE_BUS; 544 status = try_get_root_bridge_busnr(handle, &root->secondary); 545 if (ACPI_FAILURE(status)) { 546 /* 547 * We need both the start and end of the downstream bus range 548 * to interpret _CBA (MMCONFIG base address), so it really is 549 * supposed to be in _CRS. If we don't find it there, all we 550 * can do is assume [_BBN-0xFF] or [0-0xFF]. 551 */ 552 root->secondary.end = 0xFF; 553 dev_warn(&device->dev, 554 FW_BUG "no secondary bus range in _CRS\n"); 555 status = acpi_evaluate_integer(handle, METHOD_NAME__BBN, 556 NULL, &bus); 557 if (ACPI_SUCCESS(status)) 558 root->secondary.start = bus; 559 else if (status == AE_NOT_FOUND) 560 root->secondary.start = 0; 561 else { 562 dev_err(&device->dev, "can't evaluate _BBN\n"); 563 result = -ENODEV; 564 goto end; 565 } 566 } 567 568 root->device = device; 569 root->segment = segment & 0xFFFF; 570 strcpy(acpi_device_name(device), ACPI_PCI_ROOT_DEVICE_NAME); 571 strcpy(acpi_device_class(device), ACPI_PCI_ROOT_CLASS); 572 device->driver_data = root; 573 574 pr_info(PREFIX "%s [%s] (domain %04x %pR)\n", 575 acpi_device_name(device), acpi_device_bid(device), 576 root->segment, &root->secondary); 577 578 root->mcfg_addr = acpi_pci_root_get_mcfg_addr(handle); 579 580 negotiate_os_control(root, &no_aspm, &clear_aspm); 581 582 /* 583 * TBD: Need PCI interface for enumeration/configuration of roots. 584 */ 585 586 /* 587 * Scan the Root Bridge 588 * -------------------- 589 * Must do this prior to any attempt to bind the root device, as the 590 * PCI namespace does not get created until this call is made (and 591 * thus the root bridge's pci_dev does not exist). 592 */ 593 root->bus = pci_acpi_scan_root(root); 594 if (!root->bus) { 595 dev_err(&device->dev, 596 "Bus %04x:%02x not present in PCI namespace\n", 597 root->segment, (unsigned int)root->secondary.start); 598 device->driver_data = NULL; 599 result = -ENODEV; 600 goto end; 601 } 602 603 if (clear_aspm) { 604 dev_info(&device->dev, "Disabling ASPM (FADT indicates it is unsupported)\n"); 605 pcie_clear_aspm(root->bus); 606 } 607 if (no_aspm) 608 pcie_no_aspm(); 609 610 pci_acpi_add_bus_pm_notifier(device); 611 if (device->wakeup.flags.run_wake) 612 device_set_run_wake(root->bus->bridge, true); 613 614 if (system_state != SYSTEM_BOOTING) { 615 pcibios_resource_survey_bus(root->bus); 616 pci_assign_unassigned_root_bus_resources(root->bus); 617 } 618 619 pci_lock_rescan_remove(); 620 pci_bus_add_devices(root->bus); 621 pci_unlock_rescan_remove(); 622 return 1; 623 624end: 625 kfree(root); 626 return result; 627} 628 629static void acpi_pci_root_remove(struct acpi_device *device) 630{ 631 struct acpi_pci_root *root = acpi_driver_data(device); 632 633 pci_lock_rescan_remove(); 634 635 pci_stop_root_bus(root->bus); 636 637 device_set_run_wake(root->bus->bridge, false); 638 pci_acpi_remove_bus_pm_notifier(device); 639 640 pci_remove_root_bus(root->bus); 641 642 pci_unlock_rescan_remove(); 643 644 kfree(root); 645} 646 647void __init acpi_pci_root_init(void) 648{ 649 acpi_hest_init(); 650 if (acpi_pci_disabled) 651 return; 652 653 pci_acpi_crs_quirks(); 654 acpi_scan_add_handler_with_hotplug(&pci_root_handler, "pci_root"); 655} 656