drivers/pci/pci-acpi.c

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