drivers/pci/pci-acpi.c

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