kernel/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         if (acpi_pci_disabled)
 261                 return -ENODEV;
 262
 263         handle = NULL;
 264         for (pbus = dev->bus; pbus; pbus = pbus->parent) {
 265                 handle = acpi_pci_get_bridge_handle(pbus);
 266                 if (handle)
 267                         break;
 268         }
 269
 270         /*
 271          * _HPP settings apply to all child buses, until another _HPP is
 272          * encountered. If we don't find an _HPP for the input pci dev,
 273          * look for it in the parent device scope since that would apply to
 274          * this pci dev.
 275          */
 276         while (handle) {
 277                 status = acpi_run_hpx(handle, hpp);
 278                 if (ACPI_SUCCESS(status))
 279                         return 0;
 280                 status = acpi_run_hpp(handle, hpp);
 281                 if (ACPI_SUCCESS(status))
 282                         return 0;
 283                 if (acpi_is_root_bridge(handle))
 284                         break;
 285                 status = acpi_get_parent(handle, &phandle);
 286                 if (ACPI_FAILURE(status))
 287                         break;
 288                 handle = phandle;
 289         }
 290         return -ENODEV;
 291 }
 292 EXPORT_SYMBOL_GPL(pci_get_hp_params);
 293
 294 /**
 295  * pci_acpi_wake_bus - Root bus wakeup notification fork function.
 296  * @work: Work item to handle.
 297  */
 298 static void pci_acpi_wake_bus(struct work_struct *work)
 299 {
 300         struct acpi_device *adev;
 301         struct acpi_pci_root *root;
 302
 303         adev = container_of(work, struct acpi_device, wakeup.context.work);
 304         root = acpi_driver_data(adev);
 305         pci_pme_wakeup_bus(root->bus);
 306 }
 307
 308 /**
 309  * pci_acpi_wake_dev - PCI device wakeup notification work function.
 310  * @handle: ACPI handle of a device the notification is for.
 311  * @work: Work item to handle.
 312  */
 313 static void pci_acpi_wake_dev(struct work_struct *work)
 314 {
 315         struct acpi_device_wakeup_context *context;
 316         struct pci_dev *pci_dev;
 317
 318         context = container_of(work, struct acpi_device_wakeup_context, work);
 319         pci_dev = to_pci_dev(context->dev);
 320
 321         if (pci_dev->pme_poll)
 322                 pci_dev->pme_poll = false;
 323
 324         if (pci_dev->current_state == PCI_D3cold) {
 325                 pci_wakeup_event(pci_dev);
 326                 pm_runtime_resume(&pci_dev->dev);
 327                 return;
 328         }
 329
 330         /* Clear PME Status if set. */
 331         if (pci_dev->pme_support)
 332                 pci_check_pme_status(pci_dev);
 333
 334         pci_wakeup_event(pci_dev);
 335         pm_runtime_resume(&pci_dev->dev);
 336
 337         pci_pme_wakeup_bus(pci_dev->subordinate);
 338 }
 339
 340 /**
 341  * pci_acpi_add_bus_pm_notifier - Register PM notifier for root PCI bus.
 342  * @dev: PCI root bridge ACPI device.
 343  */
 344 acpi_status pci_acpi_add_bus_pm_notifier(struct acpi_device *dev)
 345 {
 346         return acpi_add_pm_notifier(dev, NULL, pci_acpi_wake_bus);
 347 }
 348
 349 /**
 350  * pci_acpi_add_pm_notifier - Register PM notifier for given PCI device.
 351  * @dev: ACPI device to add the notifier for.
 352  * @pci_dev: PCI device to check for the PME status if an event is signaled.
 353  */
 354 acpi_status pci_acpi_add_pm_notifier(struct acpi_device *dev,
 355                                      struct pci_dev *pci_dev)
 356 {
 357         return acpi_add_pm_notifier(dev, &pci_dev->dev, pci_acpi_wake_dev);
 358 }
 359
 360 /*
 361  * _SxD returns the D-state with the highest power
 362  * (lowest D-state number) supported in the S-state "x".
 363  *
 364  * If the devices does not have a _PRW
 365  * (Power Resources for Wake) supporting system wakeup from "x"
 366  * then the OS is free to choose a lower power (higher number
 367  * D-state) than the return value from _SxD.
 368  *
 369  * But if _PRW is enabled at S-state "x", the OS
 370  * must not choose a power lower than _SxD --
 371  * unless the device has an _SxW method specifying
 372  * the lowest power (highest D-state number) the device
 373  * may enter while still able to wake the system.
 374  *
 375  * ie. depending on global OS policy:
 376  *
 377  * if (_PRW at S-state x)
 378  *      choose from highest power _SxD to lowest power _SxW
 379  * else // no _PRW at S-state x
 380  *      choose highest power _SxD or any lower power
 381  */
 382
 383 static pci_power_t acpi_pci_choose_state(struct pci_dev *pdev)
 384 {
 385         int acpi_state, d_max;
 386
 387         if (pdev->no_d3cold)
 388                 d_max = ACPI_STATE_D3_HOT;
 389         else
 390                 d_max = ACPI_STATE_D3_COLD;
 391         acpi_state = acpi_pm_device_sleep_state(&pdev->dev, NULL, d_max);
 392         if (acpi_state < 0)
 393                 return PCI_POWER_ERROR;
 394
 395         switch (acpi_state) {
 396         case ACPI_STATE_D0:
 397                 return PCI_D0;
 398         case ACPI_STATE_D1:
 399                 return PCI_D1;
 400         case ACPI_STATE_D2:
 401                 return PCI_D2;
 402         case ACPI_STATE_D3_HOT:
 403                 return PCI_D3hot;
 404         case ACPI_STATE_D3_COLD:
 405                 return PCI_D3cold;
 406         }
 407         return PCI_POWER_ERROR;
 408 }
 409
 410 static bool acpi_pci_power_manageable(struct pci_dev *dev)
 411 {
 412         struct acpi_device *adev = ACPI_COMPANION(&dev->dev);
 413         return adev ? acpi_device_power_manageable(adev) : false;
 414 }
 415
 416 static int acpi_pci_set_power_state(struct pci_dev *dev, pci_power_t state)
 417 {
 418         struct acpi_device *adev = ACPI_COMPANION(&dev->dev);
 419         static const u8 state_conv[] = {
 420                 [PCI_D0] = ACPI_STATE_D0,
 421                 [PCI_D1] = ACPI_STATE_D1,
 422                 [PCI_D2] = ACPI_STATE_D2,
 423                 [PCI_D3hot] = ACPI_STATE_D3_COLD,
 424                 [PCI_D3cold] = ACPI_STATE_D3_COLD,
 425         };
 426         int error = -EINVAL;
 427
 428         /* If the ACPI device has _EJ0, ignore the device */
 429         if (!adev || acpi_has_method(adev->handle, "_EJ0"))
 430                 return -ENODEV;
 431
 432         switch (state) {
 433         case PCI_D3cold:
 434                 if (dev_pm_qos_flags(&dev->dev, PM_QOS_FLAG_NO_POWER_OFF) ==
 435                                 PM_QOS_FLAGS_ALL) {
 436                         error = -EBUSY;
 437                         break;
 438                 }
 439         case PCI_D0:
 440         case PCI_D1:
 441         case PCI_D2:
 442         case PCI_D3hot:
 443                 error = acpi_device_set_power(adev, state_conv[state]);
 444         }
 445
 446         if (!error)
 447                 dev_dbg(&dev->dev, "power state changed by ACPI to %s\n",
 448                          acpi_power_state_string(state_conv[state]));
 449
 450         return error;
 451 }
 452
 453 static bool acpi_pci_can_wakeup(struct pci_dev *dev)
 454 {
 455         struct acpi_device *adev = ACPI_COMPANION(&dev->dev);
 456         return adev ? acpi_device_can_wakeup(adev) : false;
 457 }
 458
 459 static void acpi_pci_propagate_wakeup_enable(struct pci_bus *bus, bool enable)
 460 {
 461         while (bus->parent) {
 462                 if (!acpi_pm_device_sleep_wake(&bus->self->dev, enable))
 463                         return;
 464                 bus = bus->parent;
 465         }
 466
 467         /* We have reached the root bus. */
 468         if (bus->bridge)
 469                 acpi_pm_device_sleep_wake(bus->bridge, enable);
 470 }
 471
 472 static int acpi_pci_sleep_wake(struct pci_dev *dev, bool enable)
 473 {
 474         if (acpi_pci_can_wakeup(dev))
 475                 return acpi_pm_device_sleep_wake(&dev->dev, enable);
 476
 477         acpi_pci_propagate_wakeup_enable(dev->bus, enable);
 478         return 0;
 479 }
 480
 481 static void acpi_pci_propagate_run_wake(struct pci_bus *bus, bool enable)
 482 {
 483         while (bus->parent) {
 484                 struct pci_dev *bridge = bus->self;
 485
 486                 if (bridge->pme_interrupt)
 487                         return;
 488                 if (!acpi_pm_device_run_wake(&bridge->dev, enable))
 489                         return;
 490                 bus = bus->parent;
 491         }
 492
 493         /* We have reached the root bus. */
 494         if (bus->bridge)
 495                 acpi_pm_device_run_wake(bus->bridge, enable);
 496 }
 497
 498 static int acpi_pci_run_wake(struct pci_dev *dev, bool enable)
 499 {
 500         /*
 501          * Per PCI Express Base Specification Revision 2.0 section
 502          * 5.3.3.2 Link Wakeup, platform support is needed for D3cold
 503          * waking up to power on the main link even if there is PME
 504          * support for D3cold
 505          */
 506         if (dev->pme_interrupt && !dev->runtime_d3cold)
 507                 return 0;
 508
 509         if (!acpi_pm_device_run_wake(&dev->dev, enable))
 510                 return 0;
 511
 512         acpi_pci_propagate_run_wake(dev->bus, enable);
 513         return 0;
 514 }
 515
 516 static bool acpi_pci_need_resume(struct pci_dev *dev)
 517 {
 518         struct acpi_device *adev = ACPI_COMPANION(&dev->dev);
 519
 520         if (!adev || !acpi_device_power_manageable(adev))
 521                 return false;
 522
 523         if (device_may_wakeup(&dev->dev) != !!adev->wakeup.prepare_count)
 524                 return true;
 525
 526         if (acpi_target_system_state() == ACPI_STATE_S0)
 527                 return false;
 528
 529         return !!adev->power.flags.dsw_present;
 530 }
 531
 532 static struct pci_platform_pm_ops acpi_pci_platform_pm = {
 533         .is_manageable = acpi_pci_power_manageable,
 534         .set_state = acpi_pci_set_power_state,
 535         .choose_state = acpi_pci_choose_state,
 536         .sleep_wake = acpi_pci_sleep_wake,
 537         .run_wake = acpi_pci_run_wake,
 538         .need_resume = acpi_pci_need_resume,
 539 };
 540
 541 void acpi_pci_add_bus(struct pci_bus *bus)
 542 {
 543         union acpi_object *obj;
 544         struct pci_host_bridge *bridge;
 545
 546         if (acpi_pci_disabled || !bus->bridge)
 547                 return;
 548
 549         acpi_pci_slot_enumerate(bus);
 550         acpiphp_enumerate_slots(bus);
 551
 552         /*
 553          * For a host bridge, check its _DSM for function 8 and if
 554          * that is available, mark it in pci_host_bridge.
 555          */
 556         if (!pci_is_root_bus(bus))
 557                 return;
 558
 559         obj = acpi_evaluate_dsm(ACPI_HANDLE(bus->bridge), pci_acpi_dsm_uuid, 3,
 560                                 RESET_DELAY_DSM, NULL);
 561         if (!obj)
 562                 return;
 563
 564         if (obj->type == ACPI_TYPE_INTEGER && obj->integer.value == 1) {
 565                 bridge = pci_find_host_bridge(bus);
 566                 bridge->ignore_reset_delay = 1;
 567         }
 568         ACPI_FREE(obj);
 569 }
 570
 571 void acpi_pci_remove_bus(struct pci_bus *bus)
 572 {
 573         if (acpi_pci_disabled || !bus->bridge)
 574                 return;
 575
 576         acpiphp_remove_slots(bus);
 577         acpi_pci_slot_remove(bus);
 578 }
 579
 580 /* ACPI bus type */
 581 static struct acpi_device *acpi_pci_find_companion(struct device *dev)
 582 {
 583         struct pci_dev *pci_dev = to_pci_dev(dev);
 584         bool check_children;
 585         u64 addr;
 586
 587         check_children = pci_is_bridge(pci_dev);
 588         /* Please ref to ACPI spec for the syntax of _ADR */
 589         addr = (PCI_SLOT(pci_dev->devfn) << 16) | PCI_FUNC(pci_dev->devfn);
 590         return acpi_find_child_device(ACPI_COMPANION(dev->parent), addr,
 591                                       check_children);
 592 }
 593
 594 /**
 595  * pci_acpi_optimize_delay - optimize PCI D3 and D3cold delay from ACPI
 596  * @pdev: the PCI device whose delay is to be updated
 597  * @adev: the companion ACPI device of this PCI device
 598  *
 599  * Update the d3_delay and d3cold_delay of a PCI device from the ACPI _DSM
 600  * control method of either the device itself or the PCI host bridge.
 601  *
 602  * Function 8, "Reset Delay," applies to the entire hierarchy below a PCI
 603  * host bridge.  If it returns one, the OS may assume that all devices in
 604  * the hierarchy have already completed power-on reset delays.
 605  *
 606  * Function 9, "Device Readiness Durations," applies only to the object
 607  * where it is located.  It returns delay durations required after various
 608  * events if the device requires less time than the spec requires.  Delays
 609  * from this function take precedence over the Reset Delay function.
 610  *
 611  * These _DSM functions are defined by the draft ECN of January 28, 2014,
 612  * titled "ACPI additions for FW latency optimizations."
 613  */
 614 static void pci_acpi_optimize_delay(struct pci_dev *pdev,
 615                                     acpi_handle handle)
 616 {
 617         struct pci_host_bridge *bridge = pci_find_host_bridge(pdev->bus);
 618         int value;
 619         union acpi_object *obj, *elements;
 620
 621         if (bridge->ignore_reset_delay)
 622                 pdev->d3cold_delay = 0;
 623
 624         obj = acpi_evaluate_dsm(handle, pci_acpi_dsm_uuid, 3,
 625                                 FUNCTION_DELAY_DSM, NULL);
 626         if (!obj)
 627                 return;
 628
 629         if (obj->type == ACPI_TYPE_PACKAGE && obj->package.count == 5) {
 630                 elements = obj->package.elements;
 631                 if (elements[0].type == ACPI_TYPE_INTEGER) {
 632                         value = (int)elements[0].integer.value / 1000;
 633                         if (value < PCI_PM_D3COLD_WAIT)
 634                                 pdev->d3cold_delay = value;
 635                 }
 636                 if (elements[3].type == ACPI_TYPE_INTEGER) {
 637                         value = (int)elements[3].integer.value / 1000;
 638                         if (value < PCI_PM_D3_WAIT)
 639                                 pdev->d3_delay = value;
 640                 }
 641         }
 642         ACPI_FREE(obj);
 643 }
 644
 645 static void pci_acpi_setup(struct device *dev)
 646 {
 647         struct pci_dev *pci_dev = to_pci_dev(dev);
 648         struct acpi_device *adev = ACPI_COMPANION(dev);
 649
 650         if (!adev)
 651                 return;
 652
 653         pci_acpi_optimize_delay(pci_dev, adev->handle);
 654
 655         pci_acpi_add_pm_notifier(adev, pci_dev);
 656         if (!adev->wakeup.flags.valid)
 657                 return;
 658
 659         device_set_wakeup_capable(dev, true);
 660         acpi_pci_sleep_wake(pci_dev, false);
 661         if (adev->wakeup.flags.run_wake)
 662                 device_set_run_wake(dev, true);
 663 }
 664
 665 static void pci_acpi_cleanup(struct device *dev)
 666 {
 667         struct acpi_device *adev = ACPI_COMPANION(dev);
 668
 669         if (!adev)
 670                 return;
 671
 672         pci_acpi_remove_pm_notifier(adev);
 673         if (adev->wakeup.flags.valid) {
 674                 device_set_wakeup_capable(dev, false);
 675                 device_set_run_wake(dev, false);
 676         }
 677 }
 678
 679 static bool pci_acpi_bus_match(struct device *dev)
 680 {
 681         return dev_is_pci(dev);
 682 }
 683
 684 static struct acpi_bus_type acpi_pci_bus = {
 685         .name = "PCI",
 686         .match = pci_acpi_bus_match,
 687         .find_companion = acpi_pci_find_companion,
 688         .setup = pci_acpi_setup,
 689         .cleanup = pci_acpi_cleanup,
 690 };
 691
 692 static int __init acpi_pci_init(void)
 693 {
 694         int ret;
 695
 696         if (acpi_gbl_FADT.boot_flags & ACPI_FADT_NO_MSI) {
 697                 pr_info("ACPI FADT declares the system doesn't support MSI, so disable it\n");
 698                 pci_no_msi();
 699         }
 700
 701         if (acpi_gbl_FADT.boot_flags & ACPI_FADT_NO_ASPM) {
 702                 pr_info("ACPI FADT declares the system doesn't support PCIe ASPM, so disable it\n");
 703                 pcie_no_aspm();
 704         }
 705
 706         ret = register_acpi_bus_type(&acpi_pci_bus);
 707         if (ret)
 708                 return 0;
 709
 710         pci_set_platform_pm(&acpi_pci_platform_pm);
 711         acpi_pci_slot_init();
 712         acpiphp_init();
 713
 714         return 0;
 715 }
 716 arch_initcall(acpi_pci_init);