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 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);