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/pci.h> 13 #include <linux/pci_hotplug.h> 14 #include <linux/module.h> 15 #include <linux/pci-aspm.h> 16 #include <linux/pci-acpi.h> 17 #include <linux/pm_runtime.h> 18 #include <linux/pm_qos.h> 19 #include "pci.h" 20 21 phys_addr_t acpi_pci_root_get_mcfg_addr(acpi_handle handle) 22 { 23 acpi_status status = AE_NOT_EXIST; 24 unsigned long long mcfg_addr; 25 26 if (handle) 27 status = acpi_evaluate_integer(handle, METHOD_NAME__CBA, 28 NULL, &mcfg_addr); 29 if (ACPI_FAILURE(status)) 30 return 0; 31 32 return (phys_addr_t)mcfg_addr; 33 } 34 35 static acpi_status decode_type0_hpx_record(union acpi_object *record, 36 struct hotplug_params *hpx) 37 { 38 int i; 39 union acpi_object *fields = record->package.elements; 40 u32 revision = fields[1].integer.value; 41 42 switch (revision) { 43 case 1: 44 if (record->package.count != 6) 45 return AE_ERROR; 46 for (i = 2; i < 6; i++) 47 if (fields[i].type != ACPI_TYPE_INTEGER) 48 return AE_ERROR; 49 hpx->t0 = &hpx->type0_data; 50 hpx->t0->revision = revision; 51 hpx->t0->cache_line_size = fields[2].integer.value; 52 hpx->t0->latency_timer = fields[3].integer.value; 53 hpx->t0->enable_serr = fields[4].integer.value; 54 hpx->t0->enable_perr = fields[5].integer.value; 55 break; 56 default: 57 printk(KERN_WARNING 58 "%s: Type 0 Revision %d record not supported\n", 59 __func__, revision); 60 return AE_ERROR; 61 } 62 return AE_OK; 63 } 64 65 static acpi_status decode_type1_hpx_record(union acpi_object *record, 66 struct hotplug_params *hpx) 67 { 68 int i; 69 union acpi_object *fields = record->package.elements; 70 u32 revision = fields[1].integer.value; 71 72 switch (revision) { 73 case 1: 74 if (record->package.count != 5) 75 return AE_ERROR; 76 for (i = 2; i < 5; i++) 77 if (fields[i].type != ACPI_TYPE_INTEGER) 78 return AE_ERROR; 79 hpx->t1 = &hpx->type1_data; 80 hpx->t1->revision = revision; 81 hpx->t1->max_mem_read = fields[2].integer.value; 82 hpx->t1->avg_max_split = fields[3].integer.value; 83 hpx->t1->tot_max_split = fields[4].integer.value; 84 break; 85 default: 86 printk(KERN_WARNING 87 "%s: Type 1 Revision %d record not supported\n", 88 __func__, revision); 89 return AE_ERROR; 90 } 91 return AE_OK; 92 } 93 94 static acpi_status decode_type2_hpx_record(union acpi_object *record, 95 struct hotplug_params *hpx) 96 { 97 int i; 98 union acpi_object *fields = record->package.elements; 99 u32 revision = fields[1].integer.value; 100 101 switch (revision) { 102 case 1: 103 if (record->package.count != 18) 104 return AE_ERROR; 105 for (i = 2; i < 18; i++) 106 if (fields[i].type != ACPI_TYPE_INTEGER) 107 return AE_ERROR; 108 hpx->t2 = &hpx->type2_data; 109 hpx->t2->revision = revision; 110 hpx->t2->unc_err_mask_and = fields[2].integer.value; 111 hpx->t2->unc_err_mask_or = fields[3].integer.value; 112 hpx->t2->unc_err_sever_and = fields[4].integer.value; 113 hpx->t2->unc_err_sever_or = fields[5].integer.value; 114 hpx->t2->cor_err_mask_and = fields[6].integer.value; 115 hpx->t2->cor_err_mask_or = fields[7].integer.value; 116 hpx->t2->adv_err_cap_and = fields[8].integer.value; 117 hpx->t2->adv_err_cap_or = fields[9].integer.value; 118 hpx->t2->pci_exp_devctl_and = fields[10].integer.value; 119 hpx->t2->pci_exp_devctl_or = fields[11].integer.value; 120 hpx->t2->pci_exp_lnkctl_and = fields[12].integer.value; 121 hpx->t2->pci_exp_lnkctl_or = fields[13].integer.value; 122 hpx->t2->sec_unc_err_sever_and = fields[14].integer.value; 123 hpx->t2->sec_unc_err_sever_or = fields[15].integer.value; 124 hpx->t2->sec_unc_err_mask_and = fields[16].integer.value; 125 hpx->t2->sec_unc_err_mask_or = fields[17].integer.value; 126 break; 127 default: 128 printk(KERN_WARNING 129 "%s: Type 2 Revision %d record not supported\n", 130 __func__, revision); 131 return AE_ERROR; 132 } 133 return AE_OK; 134 } 135 136 static acpi_status acpi_run_hpx(acpi_handle handle, struct hotplug_params *hpx) 137 { 138 acpi_status status; 139 struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL}; 140 union acpi_object *package, *record, *fields; 141 u32 type; 142 int i; 143 144 /* Clear the return buffer with zeros */ 145 memset(hpx, 0, sizeof(struct hotplug_params)); 146 147 status = acpi_evaluate_object(handle, "_HPX", NULL, &buffer); 148 if (ACPI_FAILURE(status)) 149 return status; 150 151 package = (union acpi_object *)buffer.pointer; 152 if (package->type != ACPI_TYPE_PACKAGE) { 153 status = AE_ERROR; 154 goto exit; 155 } 156 157 for (i = 0; i < package->package.count; i++) { 158 record = &package->package.elements[i]; 159 if (record->type != ACPI_TYPE_PACKAGE) { 160 status = AE_ERROR; 161 goto exit; 162 } 163 164 fields = record->package.elements; 165 if (fields[0].type != ACPI_TYPE_INTEGER || 166 fields[1].type != ACPI_TYPE_INTEGER) { 167 status = AE_ERROR; 168 goto exit; 169 } 170 171 type = fields[0].integer.value; 172 switch (type) { 173 case 0: 174 status = decode_type0_hpx_record(record, hpx); 175 if (ACPI_FAILURE(status)) 176 goto exit; 177 break; 178 case 1: 179 status = decode_type1_hpx_record(record, hpx); 180 if (ACPI_FAILURE(status)) 181 goto exit; 182 break; 183 case 2: 184 status = decode_type2_hpx_record(record, hpx); 185 if (ACPI_FAILURE(status)) 186 goto exit; 187 break; 188 default: 189 printk(KERN_ERR "%s: Type %d record not supported\n", 190 __func__, type); 191 status = AE_ERROR; 192 goto exit; 193 } 194 } 195 exit: 196 kfree(buffer.pointer); 197 return status; 198 } 199 200 static acpi_status acpi_run_hpp(acpi_handle handle, struct hotplug_params *hpp) 201 { 202 acpi_status status; 203 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 204 union acpi_object *package, *fields; 205 int i; 206 207 memset(hpp, 0, sizeof(struct hotplug_params)); 208 209 status = acpi_evaluate_object(handle, "_HPP", NULL, &buffer); 210 if (ACPI_FAILURE(status)) 211 return status; 212 213 package = (union acpi_object *) buffer.pointer; 214 if (package->type != ACPI_TYPE_PACKAGE || 215 package->package.count != 4) { 216 status = AE_ERROR; 217 goto exit; 218 } 219 220 fields = package->package.elements; 221 for (i = 0; i < 4; i++) { 222 if (fields[i].type != ACPI_TYPE_INTEGER) { 223 status = AE_ERROR; 224 goto exit; 225 } 226 } 227 228 hpp->t0 = &hpp->type0_data; 229 hpp->t0->revision = 1; 230 hpp->t0->cache_line_size = fields[0].integer.value; 231 hpp->t0->latency_timer = fields[1].integer.value; 232 hpp->t0->enable_serr = fields[2].integer.value; 233 hpp->t0->enable_perr = fields[3].integer.value; 234 235 exit: 236 kfree(buffer.pointer); 237 return status; 238 } 239 240 /* pci_get_hp_params 241 * 242 * @dev - the pci_dev for which we want parameters 243 * @hpp - allocated by the caller 244 */ 245 int pci_get_hp_params(struct pci_dev *dev, struct hotplug_params *hpp) 246 { 247 acpi_status status; 248 acpi_handle handle, phandle; 249 struct pci_bus *pbus; 250 251 if (acpi_pci_disabled) 252 return -ENODEV; 253 254 handle = NULL; 255 for (pbus = dev->bus; pbus; pbus = pbus->parent) { 256 handle = acpi_pci_get_bridge_handle(pbus); 257 if (handle) 258 break; 259 } 260 261 /* 262 * _HPP settings apply to all child buses, until another _HPP is 263 * encountered. If we don't find an _HPP for the input pci dev, 264 * look for it in the parent device scope since that would apply to 265 * this pci dev. 266 */ 267 while (handle) { 268 status = acpi_run_hpx(handle, hpp); 269 if (ACPI_SUCCESS(status)) 270 return 0; 271 status = acpi_run_hpp(handle, hpp); 272 if (ACPI_SUCCESS(status)) 273 return 0; 274 if (acpi_is_root_bridge(handle)) 275 break; 276 status = acpi_get_parent(handle, &phandle); 277 if (ACPI_FAILURE(status)) 278 break; 279 handle = phandle; 280 } 281 return -ENODEV; 282 } 283 EXPORT_SYMBOL_GPL(pci_get_hp_params); 284 285 /** 286 * pci_acpi_wake_bus - Root bus wakeup notification fork function. 287 * @work: Work item to handle. 288 */ 289 static void pci_acpi_wake_bus(struct work_struct *work) 290 { 291 struct acpi_device *adev; 292 struct acpi_pci_root *root; 293 294 adev = container_of(work, struct acpi_device, wakeup.context.work); 295 root = acpi_driver_data(adev); 296 pci_pme_wakeup_bus(root->bus); 297 } 298 299 /** 300 * pci_acpi_wake_dev - PCI device wakeup notification work function. 301 * @handle: ACPI handle of a device the notification is for. 302 * @work: Work item to handle. 303 */ 304 static void pci_acpi_wake_dev(struct work_struct *work) 305 { 306 struct acpi_device_wakeup_context *context; 307 struct pci_dev *pci_dev; 308 309 context = container_of(work, struct acpi_device_wakeup_context, work); 310 pci_dev = to_pci_dev(context->dev); 311 312 if (pci_dev->pme_poll) 313 pci_dev->pme_poll = false; 314 315 if (pci_dev->current_state == PCI_D3cold) { 316 pci_wakeup_event(pci_dev); 317 pm_runtime_resume(&pci_dev->dev); 318 return; 319 } 320 321 /* Clear PME Status if set. */ 322 if (pci_dev->pme_support) 323 pci_check_pme_status(pci_dev); 324 325 pci_wakeup_event(pci_dev); 326 pm_runtime_resume(&pci_dev->dev); 327 328 pci_pme_wakeup_bus(pci_dev->subordinate); 329 } 330 331 /** 332 * pci_acpi_add_bus_pm_notifier - Register PM notifier for root PCI bus. 333 * @dev: PCI root bridge ACPI device. 334 */ 335 acpi_status pci_acpi_add_bus_pm_notifier(struct acpi_device *dev) 336 { 337 return acpi_add_pm_notifier(dev, NULL, pci_acpi_wake_bus); 338 } 339 340 /** 341 * pci_acpi_add_pm_notifier - Register PM notifier for given PCI device. 342 * @dev: ACPI device to add the notifier for. 343 * @pci_dev: PCI device to check for the PME status if an event is signaled. 344 */ 345 acpi_status pci_acpi_add_pm_notifier(struct acpi_device *dev, 346 struct pci_dev *pci_dev) 347 { 348 return acpi_add_pm_notifier(dev, &pci_dev->dev, pci_acpi_wake_dev); 349 } 350 351 /* 352 * _SxD returns the D-state with the highest power 353 * (lowest D-state number) supported in the S-state "x". 354 * 355 * If the devices does not have a _PRW 356 * (Power Resources for Wake) supporting system wakeup from "x" 357 * then the OS is free to choose a lower power (higher number 358 * D-state) than the return value from _SxD. 359 * 360 * But if _PRW is enabled at S-state "x", the OS 361 * must not choose a power lower than _SxD -- 362 * unless the device has an _SxW method specifying 363 * the lowest power (highest D-state number) the device 364 * may enter while still able to wake the system. 365 * 366 * ie. depending on global OS policy: 367 * 368 * if (_PRW at S-state x) 369 * choose from highest power _SxD to lowest power _SxW 370 * else // no _PRW at S-state x 371 * choose highest power _SxD or any lower power 372 */ 373 374 static pci_power_t acpi_pci_choose_state(struct pci_dev *pdev) 375 { 376 int acpi_state, d_max; 377 378 if (pdev->no_d3cold) 379 d_max = ACPI_STATE_D3_HOT; 380 else 381 d_max = ACPI_STATE_D3_COLD; 382 acpi_state = acpi_pm_device_sleep_state(&pdev->dev, NULL, d_max); 383 if (acpi_state < 0) 384 return PCI_POWER_ERROR; 385 386 switch (acpi_state) { 387 case ACPI_STATE_D0: 388 return PCI_D0; 389 case ACPI_STATE_D1: 390 return PCI_D1; 391 case ACPI_STATE_D2: 392 return PCI_D2; 393 case ACPI_STATE_D3_HOT: 394 return PCI_D3hot; 395 case ACPI_STATE_D3_COLD: 396 return PCI_D3cold; 397 } 398 return PCI_POWER_ERROR; 399 } 400 401 static bool acpi_pci_power_manageable(struct pci_dev *dev) 402 { 403 struct acpi_device *adev = ACPI_COMPANION(&dev->dev); 404 return adev ? acpi_device_power_manageable(adev) : false; 405 } 406 407 static int acpi_pci_set_power_state(struct pci_dev *dev, pci_power_t state) 408 { 409 struct acpi_device *adev = ACPI_COMPANION(&dev->dev); 410 static const u8 state_conv[] = { 411 [PCI_D0] = ACPI_STATE_D0, 412 [PCI_D1] = ACPI_STATE_D1, 413 [PCI_D2] = ACPI_STATE_D2, 414 [PCI_D3hot] = ACPI_STATE_D3_COLD, 415 [PCI_D3cold] = ACPI_STATE_D3_COLD, 416 }; 417 int error = -EINVAL; 418 419 /* If the ACPI device has _EJ0, ignore the device */ 420 if (!adev || acpi_has_method(adev->handle, "_EJ0")) 421 return -ENODEV; 422 423 switch (state) { 424 case PCI_D3cold: 425 if (dev_pm_qos_flags(&dev->dev, PM_QOS_FLAG_NO_POWER_OFF) == 426 PM_QOS_FLAGS_ALL) { 427 error = -EBUSY; 428 break; 429 } 430 case PCI_D0: 431 case PCI_D1: 432 case PCI_D2: 433 case PCI_D3hot: 434 error = acpi_device_set_power(adev, state_conv[state]); 435 } 436 437 if (!error) 438 dev_dbg(&dev->dev, "power state changed by ACPI to %s\n", 439 acpi_power_state_string(state_conv[state])); 440 441 return error; 442 } 443 444 static bool acpi_pci_can_wakeup(struct pci_dev *dev) 445 { 446 struct acpi_device *adev = ACPI_COMPANION(&dev->dev); 447 return adev ? acpi_device_can_wakeup(adev) : false; 448 } 449 450 static void acpi_pci_propagate_wakeup_enable(struct pci_bus *bus, bool enable) 451 { 452 while (bus->parent) { 453 if (!acpi_pm_device_sleep_wake(&bus->self->dev, enable)) 454 return; 455 bus = bus->parent; 456 } 457 458 /* We have reached the root bus. */ 459 if (bus->bridge) 460 acpi_pm_device_sleep_wake(bus->bridge, enable); 461 } 462 463 static int acpi_pci_sleep_wake(struct pci_dev *dev, bool enable) 464 { 465 if (acpi_pci_can_wakeup(dev)) 466 return acpi_pm_device_sleep_wake(&dev->dev, enable); 467 468 acpi_pci_propagate_wakeup_enable(dev->bus, enable); 469 return 0; 470 } 471 472 static void acpi_pci_propagate_run_wake(struct pci_bus *bus, bool enable) 473 { 474 while (bus->parent) { 475 struct pci_dev *bridge = bus->self; 476 477 if (bridge->pme_interrupt) 478 return; 479 if (!acpi_pm_device_run_wake(&bridge->dev, enable)) 480 return; 481 bus = bus->parent; 482 } 483 484 /* We have reached the root bus. */ 485 if (bus->bridge) 486 acpi_pm_device_run_wake(bus->bridge, enable); 487 } 488 489 static int acpi_pci_run_wake(struct pci_dev *dev, bool enable) 490 { 491 /* 492 * Per PCI Express Base Specification Revision 2.0 section 493 * 5.3.3.2 Link Wakeup, platform support is needed for D3cold 494 * waking up to power on the main link even if there is PME 495 * support for D3cold 496 */ 497 if (dev->pme_interrupt && !dev->runtime_d3cold) 498 return 0; 499 500 if (!acpi_pm_device_run_wake(&dev->dev, enable)) 501 return 0; 502 503 acpi_pci_propagate_run_wake(dev->bus, enable); 504 return 0; 505 } 506 507 static bool acpi_pci_need_resume(struct pci_dev *dev) 508 { 509 struct acpi_device *adev = ACPI_COMPANION(&dev->dev); 510 511 if (!adev || !acpi_device_power_manageable(adev)) 512 return false; 513 514 if (device_may_wakeup(&dev->dev) != !!adev->wakeup.prepare_count) 515 return true; 516 517 if (acpi_target_system_state() == ACPI_STATE_S0) 518 return false; 519 520 return !!adev->power.flags.dsw_present; 521 } 522 523 static struct pci_platform_pm_ops acpi_pci_platform_pm = { 524 .is_manageable = acpi_pci_power_manageable, 525 .set_state = acpi_pci_set_power_state, 526 .choose_state = acpi_pci_choose_state, 527 .sleep_wake = acpi_pci_sleep_wake, 528 .run_wake = acpi_pci_run_wake, 529 .need_resume = acpi_pci_need_resume, 530 }; 531 532 void acpi_pci_add_bus(struct pci_bus *bus) 533 { 534 if (acpi_pci_disabled || !bus->bridge) 535 return; 536 537 acpi_pci_slot_enumerate(bus); 538 acpiphp_enumerate_slots(bus); 539 } 540 541 void acpi_pci_remove_bus(struct pci_bus *bus) 542 { 543 if (acpi_pci_disabled || !bus->bridge) 544 return; 545 546 acpiphp_remove_slots(bus); 547 acpi_pci_slot_remove(bus); 548 } 549 550 /* ACPI bus type */ 551 static struct acpi_device *acpi_pci_find_companion(struct device *dev) 552 { 553 struct pci_dev *pci_dev = to_pci_dev(dev); 554 bool check_children; 555 u64 addr; 556 557 check_children = pci_is_bridge(pci_dev); 558 /* Please ref to ACPI spec for the syntax of _ADR */ 559 addr = (PCI_SLOT(pci_dev->devfn) << 16) | PCI_FUNC(pci_dev->devfn); 560 return acpi_find_child_device(ACPI_COMPANION(dev->parent), addr, 561 check_children); 562 } 563 564 static void pci_acpi_setup(struct device *dev) 565 { 566 struct pci_dev *pci_dev = to_pci_dev(dev); 567 struct acpi_device *adev = ACPI_COMPANION(dev); 568 569 if (!adev) 570 return; 571 572 pci_acpi_add_pm_notifier(adev, pci_dev); 573 if (!adev->wakeup.flags.valid) 574 return; 575 576 device_set_wakeup_capable(dev, true); 577 acpi_pci_sleep_wake(pci_dev, false); 578 if (adev->wakeup.flags.run_wake) 579 device_set_run_wake(dev, true); 580 } 581 582 static void pci_acpi_cleanup(struct device *dev) 583 { 584 struct acpi_device *adev = ACPI_COMPANION(dev); 585 586 if (!adev) 587 return; 588 589 pci_acpi_remove_pm_notifier(adev); 590 if (adev->wakeup.flags.valid) { 591 device_set_wakeup_capable(dev, false); 592 device_set_run_wake(dev, false); 593 } 594 } 595 596 static bool pci_acpi_bus_match(struct device *dev) 597 { 598 return dev_is_pci(dev); 599 } 600 601 static struct acpi_bus_type acpi_pci_bus = { 602 .name = "PCI", 603 .match = pci_acpi_bus_match, 604 .find_companion = acpi_pci_find_companion, 605 .setup = pci_acpi_setup, 606 .cleanup = pci_acpi_cleanup, 607 }; 608 609 static int __init acpi_pci_init(void) 610 { 611 int ret; 612 613 if (acpi_gbl_FADT.boot_flags & ACPI_FADT_NO_MSI) { 614 pr_info("ACPI FADT declares the system doesn't support MSI, so disable it\n"); 615 pci_no_msi(); 616 } 617 618 if (acpi_gbl_FADT.boot_flags & ACPI_FADT_NO_ASPM) { 619 pr_info("ACPI FADT declares the system doesn't support PCIe ASPM, so disable it\n"); 620 pcie_no_aspm(); 621 } 622 623 ret = register_acpi_bus_type(&acpi_pci_bus); 624 if (ret) 625 return 0; 626 627 pci_set_platform_pm(&acpi_pci_platform_pm); 628 acpi_pci_slot_init(); 629 acpiphp_init(); 630 631 return 0; 632 } 633 arch_initcall(acpi_pci_init); 634