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/module.h>
  14 #include <linux/pci-aspm.h>
  15 #include <linux/pci-acpi.h>
  16 #include <linux/pm_runtime.h>
  17 #include <linux/pm_qos.h>
  18 #include "pci.h"
  19
  20 /**
  21  * pci_acpi_wake_bus - Root bus wakeup notification fork function.
  22  * @work: Work item to handle.
  23  */
  24 static void pci_acpi_wake_bus(struct work_struct *work)
  25 {
  26         struct acpi_device *adev;
  27         struct acpi_pci_root *root;
  28
  29         adev = container_of(work, struct acpi_device, wakeup.context.work);
  30         root = acpi_driver_data(adev);
  31         pci_pme_wakeup_bus(root->bus);
  32 }
  33
  34 /**
  35  * pci_acpi_wake_dev - PCI device wakeup notification work function.
  36  * @handle: ACPI handle of a device the notification is for.
  37  * @work: Work item to handle.
  38  */
  39 static void pci_acpi_wake_dev(struct work_struct *work)
  40 {
  41         struct acpi_device_wakeup_context *context;
  42         struct pci_dev *pci_dev;
  43
  44         context = container_of(work, struct acpi_device_wakeup_context, work);
  45         pci_dev = to_pci_dev(context->dev);
  46
  47         if (pci_dev->pme_poll)
  48                 pci_dev->pme_poll = false;
  49
  50         if (pci_dev->current_state == PCI_D3cold) {
  51                 pci_wakeup_event(pci_dev);
  52                 pm_runtime_resume(&pci_dev->dev);
  53                 return;
  54         }
  55
  56         /* Clear PME Status if set. */
  57         if (pci_dev->pme_support)
  58                 pci_check_pme_status(pci_dev);
  59
  60         pci_wakeup_event(pci_dev);
  61         pm_runtime_resume(&pci_dev->dev);
  62
  63         if (pci_dev->subordinate)
  64                 pci_pme_wakeup_bus(pci_dev->subordinate);
  65 }
  66
  67 /**
  68  * pci_acpi_add_bus_pm_notifier - Register PM notifier for root PCI bus.
  69  * @dev: PCI root bridge ACPI device.
  70  */
  71 acpi_status pci_acpi_add_bus_pm_notifier(struct acpi_device *dev)
  72 {
  73         return acpi_add_pm_notifier(dev, NULL, pci_acpi_wake_bus);
  74 }
  75
  76 /**
  77  * pci_acpi_add_pm_notifier - Register PM notifier for given PCI device.
  78  * @dev: ACPI device to add the notifier for.
  79  * @pci_dev: PCI device to check for the PME status if an event is signaled.
  80  */
  81 acpi_status pci_acpi_add_pm_notifier(struct acpi_device *dev,
  82                                      struct pci_dev *pci_dev)
  83 {
  84         return acpi_add_pm_notifier(dev, &pci_dev->dev, pci_acpi_wake_dev);
  85 }
  86
  87 phys_addr_t acpi_pci_root_get_mcfg_addr(acpi_handle handle)
  88 {
  89         acpi_status status = AE_NOT_EXIST;
  90         unsigned long long mcfg_addr;
  91
  92         if (handle)
  93                 status = acpi_evaluate_integer(handle, METHOD_NAME__CBA,
  94                                                NULL, &mcfg_addr);
  95         if (ACPI_FAILURE(status))
  96                 return 0;
  97
  98         return (phys_addr_t)mcfg_addr;
  99 }
 100
 101 /*
 102  * _SxD returns the D-state with the highest power
 103  * (lowest D-state number) supported in the S-state "x".
 104  *
 105  * If the devices does not have a _PRW
 106  * (Power Resources for Wake) supporting system wakeup from "x"
 107  * then the OS is free to choose a lower power (higher number
 108  * D-state) than the return value from _SxD.
 109  *
 110  * But if _PRW is enabled at S-state "x", the OS
 111  * must not choose a power lower than _SxD --
 112  * unless the device has an _SxW method specifying
 113  * the lowest power (highest D-state number) the device
 114  * may enter while still able to wake the system.
 115  *
 116  * ie. depending on global OS policy:
 117  *
 118  * if (_PRW at S-state x)
 119  *      choose from highest power _SxD to lowest power _SxW
 120  * else // no _PRW at S-state x
 121  *      choose highest power _SxD or any lower power
 122  */
 123
 124 static pci_power_t acpi_pci_choose_state(struct pci_dev *pdev)
 125 {
 126         int acpi_state, d_max;
 127
 128         if (pdev->no_d3cold)
 129                 d_max = ACPI_STATE_D3_HOT;
 130         else
 131                 d_max = ACPI_STATE_D3_COLD;
 132         acpi_state = acpi_pm_device_sleep_state(&pdev->dev, NULL, d_max);
 133         if (acpi_state < 0)
 134                 return PCI_POWER_ERROR;
 135
 136         switch (acpi_state) {
 137         case ACPI_STATE_D0:
 138                 return PCI_D0;
 139         case ACPI_STATE_D1:
 140                 return PCI_D1;
 141         case ACPI_STATE_D2:
 142                 return PCI_D2;
 143         case ACPI_STATE_D3_HOT:
 144                 return PCI_D3hot;
 145         case ACPI_STATE_D3_COLD:
 146                 return PCI_D3cold;
 147         }
 148         return PCI_POWER_ERROR;
 149 }
 150
 151 static bool acpi_pci_power_manageable(struct pci_dev *dev)
 152 {
 153         struct acpi_device *adev = ACPI_COMPANION(&dev->dev);
 154         return adev ? acpi_device_power_manageable(adev) : false;
 155 }
 156
 157 static int acpi_pci_set_power_state(struct pci_dev *dev, pci_power_t state)
 158 {
 159         struct acpi_device *adev = ACPI_COMPANION(&dev->dev);
 160         static const u8 state_conv[] = {
 161                 [PCI_D0] = ACPI_STATE_D0,
 162                 [PCI_D1] = ACPI_STATE_D1,
 163                 [PCI_D2] = ACPI_STATE_D2,
 164                 [PCI_D3hot] = ACPI_STATE_D3_COLD,
 165                 [PCI_D3cold] = ACPI_STATE_D3_COLD,
 166         };
 167         int error = -EINVAL;
 168
 169         /* If the ACPI device has _EJ0, ignore the device */
 170         if (!adev || acpi_has_method(adev->handle, "_EJ0"))
 171                 return -ENODEV;
 172
 173         switch (state) {
 174         case PCI_D3cold:
 175                 if (dev_pm_qos_flags(&dev->dev, PM_QOS_FLAG_NO_POWER_OFF) ==
 176                                 PM_QOS_FLAGS_ALL) {
 177                         error = -EBUSY;
 178                         break;
 179                 }
 180         case PCI_D0:
 181         case PCI_D1:
 182         case PCI_D2:
 183         case PCI_D3hot:
 184                 error = acpi_device_set_power(adev, state_conv[state]);
 185         }
 186
 187         if (!error)
 188                 dev_dbg(&dev->dev, "power state changed by ACPI to %s\n",
 189                          acpi_power_state_string(state_conv[state]));
 190
 191         return error;
 192 }
 193
 194 static bool acpi_pci_can_wakeup(struct pci_dev *dev)
 195 {
 196         struct acpi_device *adev = ACPI_COMPANION(&dev->dev);
 197         return adev ? acpi_device_can_wakeup(adev) : false;
 198 }
 199
 200 static void acpi_pci_propagate_wakeup_enable(struct pci_bus *bus, bool enable)
 201 {
 202         while (bus->parent) {
 203                 if (!acpi_pm_device_sleep_wake(&bus->self->dev, enable))
 204                         return;
 205                 bus = bus->parent;
 206         }
 207
 208         /* We have reached the root bus. */
 209         if (bus->bridge)
 210                 acpi_pm_device_sleep_wake(bus->bridge, enable);
 211 }
 212
 213 static int acpi_pci_sleep_wake(struct pci_dev *dev, bool enable)
 214 {
 215         if (acpi_pci_can_wakeup(dev))
 216                 return acpi_pm_device_sleep_wake(&dev->dev, enable);
 217
 218         acpi_pci_propagate_wakeup_enable(dev->bus, enable);
 219         return 0;
 220 }
 221
 222 static void acpi_pci_propagate_run_wake(struct pci_bus *bus, bool enable)
 223 {
 224         while (bus->parent) {
 225                 struct pci_dev *bridge = bus->self;
 226
 227                 if (bridge->pme_interrupt)
 228                         return;
 229                 if (!acpi_pm_device_run_wake(&bridge->dev, enable))
 230                         return;
 231                 bus = bus->parent;
 232         }
 233
 234         /* We have reached the root bus. */
 235         if (bus->bridge)
 236                 acpi_pm_device_run_wake(bus->bridge, enable);
 237 }
 238
 239 static int acpi_pci_run_wake(struct pci_dev *dev, bool enable)
 240 {
 241         /*
 242          * Per PCI Express Base Specification Revision 2.0 section
 243          * 5.3.3.2 Link Wakeup, platform support is needed for D3cold
 244          * waking up to power on the main link even if there is PME
 245          * support for D3cold
 246          */
 247         if (dev->pme_interrupt && !dev->runtime_d3cold)
 248                 return 0;
 249
 250         if (!acpi_pm_device_run_wake(&dev->dev, enable))
 251                 return 0;
 252
 253         acpi_pci_propagate_run_wake(dev->bus, enable);
 254         return 0;
 255 }
 256
 257 static struct pci_platform_pm_ops acpi_pci_platform_pm = {
 258         .is_manageable = acpi_pci_power_manageable,
 259         .set_state = acpi_pci_set_power_state,
 260         .choose_state = acpi_pci_choose_state,
 261         .sleep_wake = acpi_pci_sleep_wake,
 262         .run_wake = acpi_pci_run_wake,
 263 };
 264
 265 void acpi_pci_add_bus(struct pci_bus *bus)
 266 {
 267         if (acpi_pci_disabled || !bus->bridge)
 268                 return;
 269
 270         acpi_pci_slot_enumerate(bus);
 271         acpiphp_enumerate_slots(bus);
 272 }
 273
 274 void acpi_pci_remove_bus(struct pci_bus *bus)
 275 {
 276         if (acpi_pci_disabled || !bus->bridge)
 277                 return;
 278
 279         acpiphp_remove_slots(bus);
 280         acpi_pci_slot_remove(bus);
 281 }
 282
 283 /* ACPI bus type */
 284 static struct acpi_device *acpi_pci_find_companion(struct device *dev)
 285 {
 286         struct pci_dev *pci_dev = to_pci_dev(dev);
 287         bool check_children;
 288         u64 addr;
 289
 290         check_children = pci_is_bridge(pci_dev);
 291         /* Please ref to ACPI spec for the syntax of _ADR */
 292         addr = (PCI_SLOT(pci_dev->devfn) << 16) | PCI_FUNC(pci_dev->devfn);
 293         return acpi_find_child_device(ACPI_COMPANION(dev->parent), addr,
 294                                       check_children);
 295 }
 296
 297 static void pci_acpi_setup(struct device *dev)
 298 {
 299         struct pci_dev *pci_dev = to_pci_dev(dev);
 300         struct acpi_device *adev = ACPI_COMPANION(dev);
 301
 302         if (!adev)
 303                 return;
 304
 305         pci_acpi_add_pm_notifier(adev, pci_dev);
 306         if (!adev->wakeup.flags.valid)
 307                 return;
 308
 309         device_set_wakeup_capable(dev, true);
 310         acpi_pci_sleep_wake(pci_dev, false);
 311         if (adev->wakeup.flags.run_wake)
 312                 device_set_run_wake(dev, true);
 313 }
 314
 315 static void pci_acpi_cleanup(struct device *dev)
 316 {
 317         struct acpi_device *adev = ACPI_COMPANION(dev);
 318
 319         if (!adev)
 320                 return;
 321
 322         pci_acpi_remove_pm_notifier(adev);
 323         if (adev->wakeup.flags.valid) {
 324                 device_set_wakeup_capable(dev, false);
 325                 device_set_run_wake(dev, false);
 326         }
 327 }
 328
 329 static bool pci_acpi_bus_match(struct device *dev)
 330 {
 331         return dev_is_pci(dev);
 332 }
 333
 334 static struct acpi_bus_type acpi_pci_bus = {
 335         .name = "PCI",
 336         .match = pci_acpi_bus_match,
 337         .find_companion = acpi_pci_find_companion,
 338         .setup = pci_acpi_setup,
 339         .cleanup = pci_acpi_cleanup,
 340 };
 341
 342 static int __init acpi_pci_init(void)
 343 {
 344         int ret;
 345
 346         if (acpi_gbl_FADT.boot_flags & ACPI_FADT_NO_MSI) {
 347                 pr_info("ACPI FADT declares the system doesn't support MSI, so disable it\n");
 348                 pci_no_msi();
 349         }
 350
 351         if (acpi_gbl_FADT.boot_flags & ACPI_FADT_NO_ASPM) {
 352                 pr_info("ACPI FADT declares the system doesn't support PCIe ASPM, so disable it\n");
 353                 pcie_no_aspm();
 354         }
 355
 356         ret = register_acpi_bus_type(&acpi_pci_bus);
 357         if (ret)
 358                 return 0;
 359
 360         pci_set_platform_pm(&acpi_pci_platform_pm);
 361         acpi_pci_slot_init();
 362         acpiphp_init();
 363
 364         return 0;
 365 }
 366 arch_initcall(acpi_pci_init);