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