1 /* 2 * File: pci-acpi.c 3 * Purpose: Provide PCI support in ACPI 4 * 5 * Copyright (C) 2005 David Shaohua Li <shaohua.li@intel.com> 6 * Copyright (C) 2004 Tom Long Nguyen <tom.l.nguyen@intel.com> 7 * Copyright (C) 2004 Intel Corp. 8 */ 9 10 #include <linux/delay.h> 11 #include <linux/init.h> 12 #include <linux/irqdomain.h> 13 #include <linux/pci.h> 14 #include <linux/msi.h> 15 #include <linux/pci_hotplug.h> 16 #include <linux/module.h> 17 #include <linux/pci-aspm.h> 18 #include <linux/pci-acpi.h> 19 #include <linux/pm_runtime.h> 20 #include <linux/pm_qos.h> 21 #include "pci.h" 22 23 /* 24 * The UUID is defined in the PCI Firmware Specification available here: 25 * https://www.pcisig.com/members/downloads/pcifw_r3_1_13Dec10.pdf 26 */ 27 const u8 pci_acpi_dsm_uuid[] = { 28 0xd0, 0x37, 0xc9, 0xe5, 0x53, 0x35, 0x7a, 0x4d, 29 0x91, 0x17, 0xea, 0x4d, 0x19, 0xc3, 0x43, 0x4d 30 }; 31 32 #if defined(CONFIG_PCI_QUIRKS) && defined(CONFIG_ARM64) 33 static int acpi_get_rc_addr(struct acpi_device *adev, struct resource *res) 34 { 35 struct device *dev = &adev->dev; 36 struct resource_entry *entry; 37 struct list_head list; 38 unsigned long flags; 39 int ret; 40 41 INIT_LIST_HEAD(&list); 42 flags = IORESOURCE_MEM; 43 ret = acpi_dev_get_resources(adev, &list, 44 acpi_dev_filter_resource_type_cb, 45 (void *) flags); 46 if (ret < 0) { 47 dev_err(dev, "failed to parse _CRS method, error code %d\n", 48 ret); 49 return ret; 50 } 51 52 if (ret == 0) { 53 dev_err(dev, "no IO and memory resources present in _CRS\n"); 54 return -EINVAL; 55 } 56 57 entry = list_first_entry(&list, struct resource_entry, node); 58 *res = *entry->res; 59 acpi_dev_free_resource_list(&list); 60 return 0; 61 } 62 63 static acpi_status acpi_match_rc(acpi_handle handle, u32 lvl, void *context, 64 void **retval) 65 { 66 u16 *segment = context; 67 unsigned long long uid; 68 acpi_status status; 69 70 status = acpi_evaluate_integer(handle, "_UID", NULL, &uid); 71 if (ACPI_FAILURE(status) || uid != *segment) 72 return AE_CTRL_DEPTH; 73 74 *(acpi_handle *)retval = handle; 75 return AE_CTRL_TERMINATE; 76 } 77 78 int acpi_get_rc_resources(struct device *dev, const char *hid, u16 segment, 79 struct resource *res) 80 { 81 struct acpi_device *adev; 82 acpi_status status; 83 acpi_handle handle; 84 int ret; 85 86 status = acpi_get_devices(hid, acpi_match_rc, &segment, &handle); 87 if (ACPI_FAILURE(status)) { 88 dev_err(dev, "can't find _HID %s device to locate resources\n", 89 hid); 90 return -ENODEV; 91 } 92 93 ret = acpi_bus_get_device(handle, &adev); 94 if (ret) 95 return ret; 96 97 ret = acpi_get_rc_addr(adev, res); 98 if (ret) { 99 dev_err(dev, "can't get resource from %s\n", 100 dev_name(&adev->dev)); 101 return ret; 102 } 103 104 return 0; 105 } 106 #endif 107 108 phys_addr_t acpi_pci_root_get_mcfg_addr(acpi_handle handle) 109 { 110 acpi_status status = AE_NOT_EXIST; 111 unsigned long long mcfg_addr; 112 113 if (handle) 114 status = acpi_evaluate_integer(handle, METHOD_NAME__CBA, 115 NULL, &mcfg_addr); 116 if (ACPI_FAILURE(status)) 117 return 0; 118 119 return (phys_addr_t)mcfg_addr; 120 } 121 122 static acpi_status decode_type0_hpx_record(union acpi_object *record, 123 struct hotplug_params *hpx) 124 { 125 int i; 126 union acpi_object *fields = record->package.elements; 127 u32 revision = fields[1].integer.value; 128 129 switch (revision) { 130 case 1: 131 if (record->package.count != 6) 132 return AE_ERROR; 133 for (i = 2; i < 6; i++) 134 if (fields[i].type != ACPI_TYPE_INTEGER) 135 return AE_ERROR; 136 hpx->t0 = &hpx->type0_data; 137 hpx->t0->revision = revision; 138 hpx->t0->cache_line_size = fields[2].integer.value; 139 hpx->t0->latency_timer = fields[3].integer.value; 140 hpx->t0->enable_serr = fields[4].integer.value; 141 hpx->t0->enable_perr = fields[5].integer.value; 142 break; 143 default: 144 printk(KERN_WARNING 145 "%s: Type 0 Revision %d record not supported\n", 146 __func__, revision); 147 return AE_ERROR; 148 } 149 return AE_OK; 150 } 151 152 static acpi_status decode_type1_hpx_record(union acpi_object *record, 153 struct hotplug_params *hpx) 154 { 155 int i; 156 union acpi_object *fields = record->package.elements; 157 u32 revision = fields[1].integer.value; 158 159 switch (revision) { 160 case 1: 161 if (record->package.count != 5) 162 return AE_ERROR; 163 for (i = 2; i < 5; i++) 164 if (fields[i].type != ACPI_TYPE_INTEGER) 165 return AE_ERROR; 166 hpx->t1 = &hpx->type1_data; 167 hpx->t1->revision = revision; 168 hpx->t1->max_mem_read = fields[2].integer.value; 169 hpx->t1->avg_max_split = fields[3].integer.value; 170 hpx->t1->tot_max_split = fields[4].integer.value; 171 break; 172 default: 173 printk(KERN_WARNING 174 "%s: Type 1 Revision %d record not supported\n", 175 __func__, revision); 176 return AE_ERROR; 177 } 178 return AE_OK; 179 } 180 181 static acpi_status decode_type2_hpx_record(union acpi_object *record, 182 struct hotplug_params *hpx) 183 { 184 int i; 185 union acpi_object *fields = record->package.elements; 186 u32 revision = fields[1].integer.value; 187 188 switch (revision) { 189 case 1: 190 if (record->package.count != 18) 191 return AE_ERROR; 192 for (i = 2; i < 18; i++) 193 if (fields[i].type != ACPI_TYPE_INTEGER) 194 return AE_ERROR; 195 hpx->t2 = &hpx->type2_data; 196 hpx->t2->revision = revision; 197 hpx->t2->unc_err_mask_and = fields[2].integer.value; 198 hpx->t2->unc_err_mask_or = fields[3].integer.value; 199 hpx->t2->unc_err_sever_and = fields[4].integer.value; 200 hpx->t2->unc_err_sever_or = fields[5].integer.value; 201 hpx->t2->cor_err_mask_and = fields[6].integer.value; 202 hpx->t2->cor_err_mask_or = fields[7].integer.value; 203 hpx->t2->adv_err_cap_and = fields[8].integer.value; 204 hpx->t2->adv_err_cap_or = fields[9].integer.value; 205 hpx->t2->pci_exp_devctl_and = fields[10].integer.value; 206 hpx->t2->pci_exp_devctl_or = fields[11].integer.value; 207 hpx->t2->pci_exp_lnkctl_and = fields[12].integer.value; 208 hpx->t2->pci_exp_lnkctl_or = fields[13].integer.value; 209 hpx->t2->sec_unc_err_sever_and = fields[14].integer.value; 210 hpx->t2->sec_unc_err_sever_or = fields[15].integer.value; 211 hpx->t2->sec_unc_err_mask_and = fields[16].integer.value; 212 hpx->t2->sec_unc_err_mask_or = fields[17].integer.value; 213 break; 214 default: 215 printk(KERN_WARNING 216 "%s: Type 2 Revision %d record not supported\n", 217 __func__, revision); 218 return AE_ERROR; 219 } 220 return AE_OK; 221 } 222 223 static acpi_status acpi_run_hpx(acpi_handle handle, struct hotplug_params *hpx) 224 { 225 acpi_status status; 226 struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL}; 227 union acpi_object *package, *record, *fields; 228 u32 type; 229 int i; 230 231 /* Clear the return buffer with zeros */ 232 memset(hpx, 0, sizeof(struct hotplug_params)); 233 234 status = acpi_evaluate_object(handle, "_HPX", NULL, &buffer); 235 if (ACPI_FAILURE(status)) 236 return status; 237 238 package = (union acpi_object *)buffer.pointer; 239 if (package->type != ACPI_TYPE_PACKAGE) { 240 status = AE_ERROR; 241 goto exit; 242 } 243 244 for (i = 0; i < package->package.count; i++) { 245 record = &package->package.elements[i]; 246 if (record->type != ACPI_TYPE_PACKAGE) { 247 status = AE_ERROR; 248 goto exit; 249 } 250 251 fields = record->package.elements; 252 if (fields[0].type != ACPI_TYPE_INTEGER || 253 fields[1].type != ACPI_TYPE_INTEGER) { 254 status = AE_ERROR; 255 goto exit; 256 } 257 258 type = fields[0].integer.value; 259 switch (type) { 260 case 0: 261 status = decode_type0_hpx_record(record, hpx); 262 if (ACPI_FAILURE(status)) 263 goto exit; 264 break; 265 case 1: 266 status = decode_type1_hpx_record(record, hpx); 267 if (ACPI_FAILURE(status)) 268 goto exit; 269 break; 270 case 2: 271 status = decode_type2_hpx_record(record, hpx); 272 if (ACPI_FAILURE(status)) 273 goto exit; 274 break; 275 default: 276 printk(KERN_ERR "%s: Type %d record not supported\n", 277 __func__, type); 278 status = AE_ERROR; 279 goto exit; 280 } 281 } 282 exit: 283 kfree(buffer.pointer); 284 return status; 285 } 286 287 static acpi_status acpi_run_hpp(acpi_handle handle, struct hotplug_params *hpp) 288 { 289 acpi_status status; 290 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 291 union acpi_object *package, *fields; 292 int i; 293 294 memset(hpp, 0, sizeof(struct hotplug_params)); 295 296 status = acpi_evaluate_object(handle, "_HPP", NULL, &buffer); 297 if (ACPI_FAILURE(status)) 298 return status; 299 300 package = (union acpi_object *) buffer.pointer; 301 if (package->type != ACPI_TYPE_PACKAGE || 302 package->package.count != 4) { 303 status = AE_ERROR; 304 goto exit; 305 } 306 307 fields = package->package.elements; 308 for (i = 0; i < 4; i++) { 309 if (fields[i].type != ACPI_TYPE_INTEGER) { 310 status = AE_ERROR; 311 goto exit; 312 } 313 } 314 315 hpp->t0 = &hpp->type0_data; 316 hpp->t0->revision = 1; 317 hpp->t0->cache_line_size = fields[0].integer.value; 318 hpp->t0->latency_timer = fields[1].integer.value; 319 hpp->t0->enable_serr = fields[2].integer.value; 320 hpp->t0->enable_perr = fields[3].integer.value; 321 322 exit: 323 kfree(buffer.pointer); 324 return status; 325 } 326 327 /* pci_get_hp_params 328 * 329 * @dev - the pci_dev for which we want parameters 330 * @hpp - allocated by the caller 331 */ 332 int pci_get_hp_params(struct pci_dev *dev, struct hotplug_params *hpp) 333 { 334 acpi_status status; 335 acpi_handle handle, phandle; 336 struct pci_bus *pbus; 337 338 if (acpi_pci_disabled) 339 return -ENODEV; 340 341 handle = NULL; 342 for (pbus = dev->bus; pbus; pbus = pbus->parent) { 343 handle = acpi_pci_get_bridge_handle(pbus); 344 if (handle) 345 break; 346 } 347 348 /* 349 * _HPP settings apply to all child buses, until another _HPP is 350 * encountered. If we don't find an _HPP for the input pci dev, 351 * look for it in the parent device scope since that would apply to 352 * this pci dev. 353 */ 354 while (handle) { 355 status = acpi_run_hpx(handle, hpp); 356 if (ACPI_SUCCESS(status)) 357 return 0; 358 status = acpi_run_hpp(handle, hpp); 359 if (ACPI_SUCCESS(status)) 360 return 0; 361 if (acpi_is_root_bridge(handle)) 362 break; 363 status = acpi_get_parent(handle, &phandle); 364 if (ACPI_FAILURE(status)) 365 break; 366 handle = phandle; 367 } 368 return -ENODEV; 369 } 370 EXPORT_SYMBOL_GPL(pci_get_hp_params); 371 372 /** 373 * pciehp_is_native - Check whether a hotplug port is handled by the OS 374 * @pdev: Hotplug port to check 375 * 376 * Walk up from @pdev to the host bridge, obtain its cached _OSC Control Field 377 * and return the value of the "PCI Express Native Hot Plug control" bit. 378 * On failure to obtain the _OSC Control Field return %false. 379 */ 380 bool pciehp_is_native(struct pci_dev *pdev) 381 { 382 struct acpi_pci_root *root; 383 acpi_handle handle; 384 385 handle = acpi_find_root_bridge_handle(pdev); 386 if (!handle) 387 return false; 388 389 root = acpi_pci_find_root(handle); 390 if (!root) 391 return false; 392 393 return root->osc_control_set & OSC_PCI_EXPRESS_NATIVE_HP_CONTROL; 394 } 395 396 /** 397 * pci_acpi_wake_bus - Root bus wakeup notification fork function. 398 * @work: Work item to handle. 399 */ 400 static void pci_acpi_wake_bus(struct work_struct *work) 401 { 402 struct acpi_device *adev; 403 struct acpi_pci_root *root; 404 405 adev = container_of(work, struct acpi_device, wakeup.context.work); 406 root = acpi_driver_data(adev); 407 pci_pme_wakeup_bus(root->bus); 408 } 409 410 /** 411 * pci_acpi_wake_dev - PCI device wakeup notification work function. 412 * @handle: ACPI handle of a device the notification is for. 413 * @work: Work item to handle. 414 */ 415 static void pci_acpi_wake_dev(struct work_struct *work) 416 { 417 struct acpi_device_wakeup_context *context; 418 struct pci_dev *pci_dev; 419 420 context = container_of(work, struct acpi_device_wakeup_context, work); 421 pci_dev = to_pci_dev(context->dev); 422 423 if (pci_dev->pme_poll) 424 pci_dev->pme_poll = false; 425 426 if (pci_dev->current_state == PCI_D3cold) { 427 pci_wakeup_event(pci_dev); 428 pm_runtime_resume(&pci_dev->dev); 429 return; 430 } 431 432 /* Clear PME Status if set. */ 433 if (pci_dev->pme_support) 434 pci_check_pme_status(pci_dev); 435 436 pci_wakeup_event(pci_dev); 437 pm_runtime_resume(&pci_dev->dev); 438 439 pci_pme_wakeup_bus(pci_dev->subordinate); 440 } 441 442 /** 443 * pci_acpi_add_bus_pm_notifier - Register PM notifier for root PCI bus. 444 * @dev: PCI root bridge ACPI device. 445 */ 446 acpi_status pci_acpi_add_bus_pm_notifier(struct acpi_device *dev) 447 { 448 return acpi_add_pm_notifier(dev, NULL, pci_acpi_wake_bus); 449 } 450 451 /** 452 * pci_acpi_add_pm_notifier - Register PM notifier for given PCI device. 453 * @dev: ACPI device to add the notifier for. 454 * @pci_dev: PCI device to check for the PME status if an event is signaled. 455 */ 456 acpi_status pci_acpi_add_pm_notifier(struct acpi_device *dev, 457 struct pci_dev *pci_dev) 458 { 459 return acpi_add_pm_notifier(dev, &pci_dev->dev, pci_acpi_wake_dev); 460 } 461 462 /* 463 * _SxD returns the D-state with the highest power 464 * (lowest D-state number) supported in the S-state "x". 465 * 466 * If the devices does not have a _PRW 467 * (Power Resources for Wake) supporting system wakeup from "x" 468 * then the OS is free to choose a lower power (higher number 469 * D-state) than the return value from _SxD. 470 * 471 * But if _PRW is enabled at S-state "x", the OS 472 * must not choose a power lower than _SxD -- 473 * unless the device has an _SxW method specifying 474 * the lowest power (highest D-state number) the device 475 * may enter while still able to wake the system. 476 * 477 * ie. depending on global OS policy: 478 * 479 * if (_PRW at S-state x) 480 * choose from highest power _SxD to lowest power _SxW 481 * else // no _PRW at S-state x 482 * choose highest power _SxD or any lower power 483 */ 484 485 static pci_power_t acpi_pci_choose_state(struct pci_dev *pdev) 486 { 487 int acpi_state, d_max; 488 489 if (pdev->no_d3cold) 490 d_max = ACPI_STATE_D3_HOT; 491 else 492 d_max = ACPI_STATE_D3_COLD; 493 acpi_state = acpi_pm_device_sleep_state(&pdev->dev, NULL, d_max); 494 if (acpi_state < 0) 495 return PCI_POWER_ERROR; 496 497 switch (acpi_state) { 498 case ACPI_STATE_D0: 499 return PCI_D0; 500 case ACPI_STATE_D1: 501 return PCI_D1; 502 case ACPI_STATE_D2: 503 return PCI_D2; 504 case ACPI_STATE_D3_HOT: 505 return PCI_D3hot; 506 case ACPI_STATE_D3_COLD: 507 return PCI_D3cold; 508 } 509 return PCI_POWER_ERROR; 510 } 511 512 static bool acpi_pci_power_manageable(struct pci_dev *dev) 513 { 514 struct acpi_device *adev = ACPI_COMPANION(&dev->dev); 515 return adev ? acpi_device_power_manageable(adev) : false; 516 } 517 518 static int acpi_pci_set_power_state(struct pci_dev *dev, pci_power_t state) 519 { 520 struct acpi_device *adev = ACPI_COMPANION(&dev->dev); 521 static const u8 state_conv[] = { 522 [PCI_D0] = ACPI_STATE_D0, 523 [PCI_D1] = ACPI_STATE_D1, 524 [PCI_D2] = ACPI_STATE_D2, 525 [PCI_D3hot] = ACPI_STATE_D3_HOT, 526 [PCI_D3cold] = ACPI_STATE_D3_COLD, 527 }; 528 int error = -EINVAL; 529 530 /* If the ACPI device has _EJ0, ignore the device */ 531 if (!adev || acpi_has_method(adev->handle, "_EJ0")) 532 return -ENODEV; 533 534 switch (state) { 535 case PCI_D3cold: 536 if (dev_pm_qos_flags(&dev->dev, PM_QOS_FLAG_NO_POWER_OFF) == 537 PM_QOS_FLAGS_ALL) { 538 error = -EBUSY; 539 break; 540 } 541 case PCI_D0: 542 case PCI_D1: 543 case PCI_D2: 544 case PCI_D3hot: 545 error = acpi_device_set_power(adev, state_conv[state]); 546 } 547 548 if (!error) 549 dev_dbg(&dev->dev, "power state changed by ACPI to %s\n", 550 acpi_power_state_string(state_conv[state])); 551 552 return error; 553 } 554 555 static pci_power_t acpi_pci_get_power_state(struct pci_dev *dev) 556 { 557 struct acpi_device *adev = ACPI_COMPANION(&dev->dev); 558 static const pci_power_t state_conv[] = { 559 [ACPI_STATE_D0] = PCI_D0, 560 [ACPI_STATE_D1] = PCI_D1, 561 [ACPI_STATE_D2] = PCI_D2, 562 [ACPI_STATE_D3_HOT] = PCI_D3hot, 563 [ACPI_STATE_D3_COLD] = PCI_D3cold, 564 }; 565 int state; 566 567 if (!adev || !acpi_device_power_manageable(adev)) 568 return PCI_UNKNOWN; 569 570 if (acpi_device_get_power(adev, &state) || state == ACPI_STATE_UNKNOWN) 571 return PCI_UNKNOWN; 572 573 return state_conv[state]; 574 } 575 576 static bool acpi_pci_can_wakeup(struct pci_dev *dev) 577 { 578 struct acpi_device *adev = ACPI_COMPANION(&dev->dev); 579 return adev ? acpi_device_can_wakeup(adev) : false; 580 } 581 582 static void acpi_pci_propagate_wakeup_enable(struct pci_bus *bus, bool enable) 583 { 584 while (bus->parent) { 585 if (!acpi_pm_device_sleep_wake(&bus->self->dev, enable)) 586 return; 587 bus = bus->parent; 588 } 589 590 /* We have reached the root bus. */ 591 if (bus->bridge) 592 acpi_pm_device_sleep_wake(bus->bridge, enable); 593 } 594 595 static int acpi_pci_sleep_wake(struct pci_dev *dev, bool enable) 596 { 597 if (acpi_pci_can_wakeup(dev)) 598 return acpi_pm_device_sleep_wake(&dev->dev, enable); 599 600 acpi_pci_propagate_wakeup_enable(dev->bus, enable); 601 return 0; 602 } 603 604 static void acpi_pci_propagate_run_wake(struct pci_bus *bus, bool enable) 605 { 606 while (bus->parent) { 607 struct pci_dev *bridge = bus->self; 608 609 if (bridge->pme_interrupt) 610 return; 611 if (!acpi_pm_device_run_wake(&bridge->dev, enable)) 612 return; 613 bus = bus->parent; 614 } 615 616 /* We have reached the root bus. */ 617 if (bus->bridge) 618 acpi_pm_device_run_wake(bus->bridge, enable); 619 } 620 621 static int acpi_pci_run_wake(struct pci_dev *dev, bool enable) 622 { 623 /* 624 * Per PCI Express Base Specification Revision 2.0 section 625 * 5.3.3.2 Link Wakeup, platform support is needed for D3cold 626 * waking up to power on the main link even if there is PME 627 * support for D3cold 628 */ 629 if (dev->pme_interrupt && !dev->runtime_d3cold) 630 return 0; 631 632 if (!acpi_pm_device_run_wake(&dev->dev, enable)) 633 return 0; 634 635 acpi_pci_propagate_run_wake(dev->bus, enable); 636 return 0; 637 } 638 639 static bool acpi_pci_need_resume(struct pci_dev *dev) 640 { 641 struct acpi_device *adev = ACPI_COMPANION(&dev->dev); 642 643 if (!adev || !acpi_device_power_manageable(adev)) 644 return false; 645 646 if (device_may_wakeup(&dev->dev) != !!adev->wakeup.prepare_count) 647 return true; 648 649 if (acpi_target_system_state() == ACPI_STATE_S0) 650 return false; 651 652 return !!adev->power.flags.dsw_present; 653 } 654 655 static const struct pci_platform_pm_ops acpi_pci_platform_pm = { 656 .is_manageable = acpi_pci_power_manageable, 657 .set_state = acpi_pci_set_power_state, 658 .get_state = acpi_pci_get_power_state, 659 .choose_state = acpi_pci_choose_state, 660 .sleep_wake = acpi_pci_sleep_wake, 661 .run_wake = acpi_pci_run_wake, 662 .need_resume = acpi_pci_need_resume, 663 }; 664 665 void acpi_pci_add_bus(struct pci_bus *bus) 666 { 667 union acpi_object *obj; 668 struct pci_host_bridge *bridge; 669 670 if (acpi_pci_disabled || !bus->bridge) 671 return; 672 673 acpi_pci_slot_enumerate(bus); 674 acpiphp_enumerate_slots(bus); 675 676 /* 677 * For a host bridge, check its _DSM for function 8 and if 678 * that is available, mark it in pci_host_bridge. 679 */ 680 if (!pci_is_root_bus(bus)) 681 return; 682 683 obj = acpi_evaluate_dsm(ACPI_HANDLE(bus->bridge), pci_acpi_dsm_uuid, 3, 684 RESET_DELAY_DSM, NULL); 685 if (!obj) 686 return; 687 688 if (obj->type == ACPI_TYPE_INTEGER && obj->integer.value == 1) { 689 bridge = pci_find_host_bridge(bus); 690 bridge->ignore_reset_delay = 1; 691 } 692 ACPI_FREE(obj); 693 } 694 695 void acpi_pci_remove_bus(struct pci_bus *bus) 696 { 697 if (acpi_pci_disabled || !bus->bridge) 698 return; 699 700 acpiphp_remove_slots(bus); 701 acpi_pci_slot_remove(bus); 702 } 703 704 /* ACPI bus type */ 705 static struct acpi_device *acpi_pci_find_companion(struct device *dev) 706 { 707 struct pci_dev *pci_dev = to_pci_dev(dev); 708 bool check_children; 709 u64 addr; 710 711 check_children = pci_is_bridge(pci_dev); 712 /* Please ref to ACPI spec for the syntax of _ADR */ 713 addr = (PCI_SLOT(pci_dev->devfn) << 16) | PCI_FUNC(pci_dev->devfn); 714 return acpi_find_child_device(ACPI_COMPANION(dev->parent), addr, 715 check_children); 716 } 717 718 /** 719 * pci_acpi_optimize_delay - optimize PCI D3 and D3cold delay from ACPI 720 * @pdev: the PCI device whose delay is to be updated 721 * @handle: ACPI handle of this device 722 * 723 * Update the d3_delay and d3cold_delay of a PCI device from the ACPI _DSM 724 * control method of either the device itself or the PCI host bridge. 725 * 726 * Function 8, "Reset Delay," applies to the entire hierarchy below a PCI 727 * host bridge. If it returns one, the OS may assume that all devices in 728 * the hierarchy have already completed power-on reset delays. 729 * 730 * Function 9, "Device Readiness Durations," applies only to the object 731 * where it is located. It returns delay durations required after various 732 * events if the device requires less time than the spec requires. Delays 733 * from this function take precedence over the Reset Delay function. 734 * 735 * These _DSM functions are defined by the draft ECN of January 28, 2014, 736 * titled "ACPI additions for FW latency optimizations." 737 */ 738 static void pci_acpi_optimize_delay(struct pci_dev *pdev, 739 acpi_handle handle) 740 { 741 struct pci_host_bridge *bridge = pci_find_host_bridge(pdev->bus); 742 int value; 743 union acpi_object *obj, *elements; 744 745 if (bridge->ignore_reset_delay) 746 pdev->d3cold_delay = 0; 747 748 obj = acpi_evaluate_dsm(handle, pci_acpi_dsm_uuid, 3, 749 FUNCTION_DELAY_DSM, NULL); 750 if (!obj) 751 return; 752 753 if (obj->type == ACPI_TYPE_PACKAGE && obj->package.count == 5) { 754 elements = obj->package.elements; 755 if (elements[0].type == ACPI_TYPE_INTEGER) { 756 value = (int)elements[0].integer.value / 1000; 757 if (value < PCI_PM_D3COLD_WAIT) 758 pdev->d3cold_delay = value; 759 } 760 if (elements[3].type == ACPI_TYPE_INTEGER) { 761 value = (int)elements[3].integer.value / 1000; 762 if (value < PCI_PM_D3_WAIT) 763 pdev->d3_delay = value; 764 } 765 } 766 ACPI_FREE(obj); 767 } 768 769 static void pci_acpi_setup(struct device *dev) 770 { 771 struct pci_dev *pci_dev = to_pci_dev(dev); 772 struct acpi_device *adev = ACPI_COMPANION(dev); 773 774 if (!adev) 775 return; 776 777 pci_acpi_optimize_delay(pci_dev, adev->handle); 778 779 pci_acpi_add_pm_notifier(adev, pci_dev); 780 if (!adev->wakeup.flags.valid) 781 return; 782 783 device_set_wakeup_capable(dev, true); 784 acpi_pci_sleep_wake(pci_dev, false); 785 if (adev->wakeup.flags.run_wake) 786 device_set_run_wake(dev, true); 787 } 788 789 static void pci_acpi_cleanup(struct device *dev) 790 { 791 struct acpi_device *adev = ACPI_COMPANION(dev); 792 793 if (!adev) 794 return; 795 796 pci_acpi_remove_pm_notifier(adev); 797 if (adev->wakeup.flags.valid) { 798 device_set_wakeup_capable(dev, false); 799 device_set_run_wake(dev, false); 800 } 801 } 802 803 static bool pci_acpi_bus_match(struct device *dev) 804 { 805 return dev_is_pci(dev); 806 } 807 808 static struct acpi_bus_type acpi_pci_bus = { 809 .name = "PCI", 810 .match = pci_acpi_bus_match, 811 .find_companion = acpi_pci_find_companion, 812 .setup = pci_acpi_setup, 813 .cleanup = pci_acpi_cleanup, 814 }; 815 816 817 static struct fwnode_handle *(*pci_msi_get_fwnode_cb)(struct device *dev); 818 819 /** 820 * pci_msi_register_fwnode_provider - Register callback to retrieve fwnode 821 * @fn: Callback matching a device to a fwnode that identifies a PCI 822 * MSI domain. 823 * 824 * This should be called by irqchip driver, which is the parent of 825 * the MSI domain to provide callback interface to query fwnode. 826 */ 827 void 828 pci_msi_register_fwnode_provider(struct fwnode_handle *(*fn)(struct device *)) 829 { 830 pci_msi_get_fwnode_cb = fn; 831 } 832 833 /** 834 * pci_host_bridge_acpi_msi_domain - Retrieve MSI domain of a PCI host bridge 835 * @bus: The PCI host bridge bus. 836 * 837 * This function uses the callback function registered by 838 * pci_msi_register_fwnode_provider() to retrieve the irq_domain with 839 * type DOMAIN_BUS_PCI_MSI of the specified host bridge bus. 840 * This returns NULL on error or when the domain is not found. 841 */ 842 struct irq_domain *pci_host_bridge_acpi_msi_domain(struct pci_bus *bus) 843 { 844 struct fwnode_handle *fwnode; 845 846 if (!pci_msi_get_fwnode_cb) 847 return NULL; 848 849 fwnode = pci_msi_get_fwnode_cb(&bus->dev); 850 if (!fwnode) 851 return NULL; 852 853 return irq_find_matching_fwnode(fwnode, DOMAIN_BUS_PCI_MSI); 854 } 855 856 static int __init acpi_pci_init(void) 857 { 858 int ret; 859 860 if (acpi_gbl_FADT.boot_flags & ACPI_FADT_NO_MSI) { 861 pr_info("ACPI FADT declares the system doesn't support MSI, so disable it\n"); 862 pci_no_msi(); 863 } 864 865 if (acpi_gbl_FADT.boot_flags & ACPI_FADT_NO_ASPM) { 866 pr_info("ACPI FADT declares the system doesn't support PCIe ASPM, so disable it\n"); 867 pcie_no_aspm(); 868 } 869 870 ret = register_acpi_bus_type(&acpi_pci_bus); 871 if (ret) 872 return 0; 873 874 pci_set_platform_pm(&acpi_pci_platform_pm); 875 acpi_pci_slot_init(); 876 acpiphp_init(); 877 878 return 0; 879 } 880 arch_initcall(acpi_pci_init); 881