drivers/acpi/device_pm.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * drivers/acpi/device_pm.c - ACPI device power management routines.
   4  *
   5  * Copyright (C) 2012, Intel Corp.
   6  * Author: Rafael J. Wysocki <[email protected]>
   7  *
   8  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   9  *
  10  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  11  */
  12
  13 #define pr_fmt(fmt) "PM: " fmt
  14
  15 #include <linux/acpi.h>
  16 #include <linux/export.h>
  17 #include <linux/mutex.h>
  18 #include <linux/pm_qos.h>
  19 #include <linux/pm_domain.h>
  20 #include <linux/pm_runtime.h>
  21 #include <linux/suspend.h>
  22
  23 #include "fan.h"
  24 #include "internal.h"
  25
  26 /**
  27  * acpi_power_state_string - String representation of ACPI device power state.
  28  * @state: ACPI device power state to return the string representation of.
  29  */
  30 const char *acpi_power_state_string(int state)
  31 {
  32         switch (state) {
  33         case ACPI_STATE_D0:
  34                 return "D0";
  35         case ACPI_STATE_D1:
  36                 return "D1";
  37         case ACPI_STATE_D2:
  38                 return "D2";
  39         case ACPI_STATE_D3_HOT:
  40                 return "D3hot";
  41         case ACPI_STATE_D3_COLD:
  42                 return "D3cold";
  43         default:
  44                 return "(unknown)";
  45         }
  46 }
  47
  48 static int acpi_dev_pm_explicit_get(struct acpi_device *device, int *state)
  49 {
  50         unsigned long long psc;
  51         acpi_status status;
  52
  53         status = acpi_evaluate_integer(device->handle, "_PSC", NULL, &psc);
  54         if (ACPI_FAILURE(status))
  55                 return -ENODEV;
  56
  57         *state = psc;
  58         return 0;
  59 }
  60
  61 /**
  62  * acpi_device_get_power - Get power state of an ACPI device.
  63  * @device: Device to get the power state of.
  64  * @state: Place to store the power state of the device.
  65  *
  66  * This function does not update the device's power.state field, but it may
  67  * update its parent's power.state field (when the parent's power state is
  68  * unknown and the device's power state turns out to be D0).
  69  *
  70  * Also, it does not update power resource reference counters to ensure that
  71  * the power state returned by it will be persistent and it may return a power
  72  * state shallower than previously set by acpi_device_set_power() for @device
  73  * (if that power state depends on any power resources).
  74  */
  75 int acpi_device_get_power(struct acpi_device *device, int *state)
  76 {
  77         int result = ACPI_STATE_UNKNOWN;
  78         int error;
  79
  80         if (!device || !state)
  81                 return -EINVAL;
  82
  83         if (!device->flags.power_manageable) {
  84                 /* TBD: Non-recursive algorithm for walking up hierarchy. */
  85                 *state = device->parent ?
  86                         device->parent->power.state : ACPI_STATE_D0;
  87                 goto out;
  88         }
  89
  90         /*
  91          * Get the device's power state from power resources settings and _PSC,
  92          * if available.
  93          */
  94         if (device->power.flags.power_resources) {
  95                 error = acpi_power_get_inferred_state(device, &result);
  96                 if (error)
  97                         return error;
  98         }
  99         if (device->power.flags.explicit_get) {
 100                 int psc;
 101
 102                 error = acpi_dev_pm_explicit_get(device, &psc);
 103                 if (error)
 104                         return error;
 105
 106                 /*
 107                  * The power resources settings may indicate a power state
 108                  * shallower than the actual power state of the device, because
 109                  * the same power resources may be referenced by other devices.
 110                  *
 111                  * For systems predating ACPI 4.0 we assume that D3hot is the
 112                  * deepest state that can be supported.
 113                  */
 114                 if (psc > result && psc < ACPI_STATE_D3_COLD)
 115                         result = psc;
 116                 else if (result == ACPI_STATE_UNKNOWN)
 117                         result = psc > ACPI_STATE_D2 ? ACPI_STATE_D3_HOT : psc;
 118         }
 119
 120         /*
 121          * If we were unsure about the device parent's power state up to this
 122          * point, the fact that the device is in D0 implies that the parent has
 123          * to be in D0 too, except if ignore_parent is set.
 124          */
 125         if (!device->power.flags.ignore_parent && device->parent
 126             && device->parent->power.state == ACPI_STATE_UNKNOWN
 127             && result == ACPI_STATE_D0)
 128                 device->parent->power.state = ACPI_STATE_D0;
 129
 130         *state = result;
 131
 132  out:
 133         acpi_handle_debug(device->handle, "Power state: %s\n",
 134                           acpi_power_state_string(*state));
 135
 136         return 0;
 137 }
 138
 139 static int acpi_dev_pm_explicit_set(struct acpi_device *adev, int state)
 140 {
 141         if (adev->power.states[state].flags.explicit_set) {
 142                 char method[5] = { '_', 'P', 'S', '0' + state, '\0' };
 143                 acpi_status status;
 144
 145                 status = acpi_evaluate_object(adev->handle, method, NULL, NULL);
 146                 if (ACPI_FAILURE(status))
 147                         return -ENODEV;
 148         }
 149         return 0;
 150 }
 151
 152 /**
 153  * acpi_device_set_power - Set power state of an ACPI device.
 154  * @device: Device to set the power state of.
 155  * @state: New power state to set.
 156  *
 157  * Callers must ensure that the device is power manageable before using this
 158  * function.
 159  */
 160 int acpi_device_set_power(struct acpi_device *device, int state)
 161 {
 162         int target_state = state;
 163         int result = 0;
 164
 165         if (!device || !device->flags.power_manageable
 166             || (state < ACPI_STATE_D0) || (state > ACPI_STATE_D3_COLD))
 167                 return -EINVAL;
 168
 169         acpi_handle_debug(device->handle, "Power state change: %s -> %s\n",
 170                           acpi_power_state_string(device->power.state),
 171                           acpi_power_state_string(state));
 172
 173         /* Make sure this is a valid target state */
 174
 175         /* There is a special case for D0 addressed below. */
 176         if (state > ACPI_STATE_D0 && state == device->power.state)
 177                 goto no_change;
 178
 179         if (state == ACPI_STATE_D3_COLD) {
 180                 /*
 181                  * For transitions to D3cold we need to execute _PS3 and then
 182                  * possibly drop references to the power resources in use.
 183                  */
 184                 state = ACPI_STATE_D3_HOT;
 185                 /* If D3cold is not supported, use D3hot as the target state. */
 186                 if (!device->power.states[ACPI_STATE_D3_COLD].flags.valid)
 187                         target_state = state;
 188         } else if (!device->power.states[state].flags.valid) {
 189                 acpi_handle_debug(device->handle, "Power state %s not supported\n",
 190                                   acpi_power_state_string(state));
 191                 return -ENODEV;
 192         }
 193
 194         if (!device->power.flags.ignore_parent && device->parent &&
 195             state < device->parent->power.state) {
 196                 acpi_handle_debug(device->handle,
 197                                   "Cannot transition to %s for parent in %s\n",
 198                                   acpi_power_state_string(state),
 199                                   acpi_power_state_string(device->parent->power.state));
 200                 return -ENODEV;
 201         }
 202
 203         /*
 204          * Transition Power
 205          * ----------------
 206          * In accordance with ACPI 6, _PSx is executed before manipulating power
 207          * resources, unless the target state is D0, in which case _PS0 is
 208          * supposed to be executed after turning the power resources on.
 209          */
 210         if (state > ACPI_STATE_D0) {
 211                 /*
 212                  * According to ACPI 6, devices cannot go from lower-power
 213                  * (deeper) states to higher-power (shallower) states.
 214                  */
 215                 if (state < device->power.state) {
 216                         acpi_handle_debug(device->handle,
 217                                           "Cannot transition from %s to %s\n",
 218                                           acpi_power_state_string(device->power.state),
 219                                           acpi_power_state_string(state));
 220                         return -ENODEV;
 221                 }
 222
 223                 /*
 224                  * If the device goes from D3hot to D3cold, _PS3 has been
 225                  * evaluated for it already, so skip it in that case.
 226                  */
 227                 if (device->power.state < ACPI_STATE_D3_HOT) {
 228                         result = acpi_dev_pm_explicit_set(device, state);
 229                         if (result)
 230                                 goto end;
 231                 }
 232
 233                 if (device->power.flags.power_resources)
 234                         result = acpi_power_transition(device, target_state);
 235         } else {
 236                 int cur_state = device->power.state;
 237
 238                 if (device->power.flags.power_resources) {
 239                         result = acpi_power_transition(device, ACPI_STATE_D0);
 240                         if (result)
 241                                 goto end;
 242                 }
 243
 244                 if (cur_state == ACPI_STATE_D0) {
 245                         int psc;
 246
 247                         /* Nothing to do here if _PSC is not present. */
 248                         if (!device->power.flags.explicit_get)
 249                                 goto no_change;
 250
 251                         /*
 252                          * The power state of the device was set to D0 last
 253                          * time, but that might have happened before a
 254                          * system-wide transition involving the platform
 255                          * firmware, so it may be necessary to evaluate _PS0
 256                          * for the device here.  However, use extra care here
 257                          * and evaluate _PSC to check the device's current power
 258                          * state, and only invoke _PS0 if the evaluation of _PSC
 259                          * is successful and it returns a power state different
 260                          * from D0.
 261                          */
 262                         result = acpi_dev_pm_explicit_get(device, &psc);
 263                         if (result || psc == ACPI_STATE_D0)
 264                                 goto no_change;
 265                 }
 266
 267                 result = acpi_dev_pm_explicit_set(device, ACPI_STATE_D0);
 268         }
 269
 270 end:
 271         if (result) {
 272                 acpi_handle_debug(device->handle,
 273                                   "Failed to change power state to %s\n",
 274                                   acpi_power_state_string(target_state));
 275         } else {
 276                 device->power.state = target_state;
 277                 acpi_handle_debug(device->handle, "Power state changed to %s\n",
 278                                   acpi_power_state_string(target_state));
 279         }
 280
 281         return result;
 282
 283 no_change:
 284         acpi_handle_debug(device->handle, "Already in %s\n",
 285                           acpi_power_state_string(state));
 286         return 0;
 287 }
 288 EXPORT_SYMBOL(acpi_device_set_power);
 289
 290 int acpi_bus_set_power(acpi_handle handle, int state)
 291 {
 292         struct acpi_device *device = acpi_fetch_acpi_dev(handle);
 293
 294         if (device)
 295                 return acpi_device_set_power(device, state);
 296
 297         return -ENODEV;
 298 }
 299 EXPORT_SYMBOL(acpi_bus_set_power);
 300
 301 int acpi_bus_init_power(struct acpi_device *device)
 302 {
 303         int state;
 304         int result;
 305
 306         if (!device)
 307                 return -EINVAL;
 308
 309         device->power.state = ACPI_STATE_UNKNOWN;
 310         if (!acpi_device_is_present(device)) {
 311                 device->flags.initialized = false;
 312                 return -ENXIO;
 313         }
 314
 315         result = acpi_device_get_power(device, &state);
 316         if (result)
 317                 return result;
 318
 319         if (state < ACPI_STATE_D3_COLD && device->power.flags.power_resources) {
 320                 /* Reference count the power resources. */
 321                 result = acpi_power_on_resources(device, state);
 322                 if (result)
 323                         return result;
 324
 325                 if (state == ACPI_STATE_D0) {
 326                         /*
 327                          * If _PSC is not present and the state inferred from
 328                          * power resources appears to be D0, it still may be
 329                          * necessary to execute _PS0 at this point, because
 330                          * another device using the same power resources may
 331                          * have been put into D0 previously and that's why we
 332                          * see D0 here.
 333                          */
 334                         result = acpi_dev_pm_explicit_set(device, state);
 335                         if (result)
 336                                 return result;
 337                 }
 338         } else if (state == ACPI_STATE_UNKNOWN) {
 339                 /*
 340                  * No power resources and missing _PSC?  Cross fingers and make
 341                  * it D0 in hope that this is what the BIOS put the device into.
 342                  * [We tried to force D0 here by executing _PS0, but that broke
 343                  * Toshiba P870-303 in a nasty way.]
 344                  */
 345                 state = ACPI_STATE_D0;
 346         }
 347         device->power.state = state;
 348         return 0;
 349 }
 350
 351 /**
 352  * acpi_device_fix_up_power - Force device with missing _PSC into D0.
 353  * @device: Device object whose power state is to be fixed up.
 354  *
 355  * Devices without power resources and _PSC, but having _PS0 and _PS3 defined,
 356  * are assumed to be put into D0 by the BIOS.  However, in some cases that may
 357  * not be the case and this function should be used then.
 358  */
 359 int acpi_device_fix_up_power(struct acpi_device *device)
 360 {
 361         int ret = 0;
 362
 363         if (!device->power.flags.power_resources
 364             && !device->power.flags.explicit_get
 365             && device->power.state == ACPI_STATE_D0)
 366                 ret = acpi_dev_pm_explicit_set(device, ACPI_STATE_D0);
 367
 368         return ret;
 369 }
 370 EXPORT_SYMBOL_GPL(acpi_device_fix_up_power);
 371
 372 static int fix_up_power_if_applicable(struct acpi_device *adev, void *not_used)
 373 {
 374         if (adev->status.present && adev->status.enabled)
 375                 acpi_device_fix_up_power(adev);
 376
 377         return 0;
 378 }
 379
 380 /**
 381  * acpi_device_fix_up_power_extended - Force device and its children into D0.
 382  * @adev: Parent device object whose power state is to be fixed up.
 383  *
 384  * Call acpi_device_fix_up_power() for @adev and its children so long as they
 385  * are reported as present and enabled.
 386  */
 387 void acpi_device_fix_up_power_extended(struct acpi_device *adev)
 388 {
 389         acpi_device_fix_up_power(adev);
 390         acpi_dev_for_each_child(adev, fix_up_power_if_applicable, NULL);
 391 }
 392 EXPORT_SYMBOL_GPL(acpi_device_fix_up_power_extended);
 393
 394 int acpi_device_update_power(struct acpi_device *device, int *state_p)
 395 {
 396         int state;
 397         int result;
 398
 399         if (device->power.state == ACPI_STATE_UNKNOWN) {
 400                 result = acpi_bus_init_power(device);
 401                 if (!result && state_p)
 402                         *state_p = device->power.state;
 403
 404                 return result;
 405         }
 406
 407         result = acpi_device_get_power(device, &state);
 408         if (result)
 409                 return result;
 410
 411         if (state == ACPI_STATE_UNKNOWN) {
 412                 state = ACPI_STATE_D0;
 413                 result = acpi_device_set_power(device, state);
 414                 if (result)
 415                         return result;
 416         } else {
 417                 if (device->power.flags.power_resources) {
 418                         /*
 419                          * We don't need to really switch the state, bu we need
 420                          * to update the power resources' reference counters.
 421                          */
 422                         result = acpi_power_transition(device, state);
 423                         if (result)
 424                                 return result;
 425                 }
 426                 device->power.state = state;
 427         }
 428         if (state_p)
 429                 *state_p = state;
 430
 431         return 0;
 432 }
 433 EXPORT_SYMBOL_GPL(acpi_device_update_power);
 434
 435 int acpi_bus_update_power(acpi_handle handle, int *state_p)
 436 {
 437         struct acpi_device *device = acpi_fetch_acpi_dev(handle);
 438
 439         if (device)
 440                 return acpi_device_update_power(device, state_p);
 441
 442         return -ENODEV;
 443 }
 444 EXPORT_SYMBOL_GPL(acpi_bus_update_power);
 445
 446 bool acpi_bus_power_manageable(acpi_handle handle)
 447 {
 448         struct acpi_device *device = acpi_fetch_acpi_dev(handle);
 449
 450         return device && device->flags.power_manageable;
 451 }
 452 EXPORT_SYMBOL(acpi_bus_power_manageable);
 453
 454 static int acpi_power_up_if_adr_present(struct acpi_device *adev, void *not_used)
 455 {
 456         if (!(adev->flags.power_manageable && adev->pnp.type.bus_address))
 457                 return 0;
 458
 459         acpi_handle_debug(adev->handle, "Power state: %s\n",
 460                           acpi_power_state_string(adev->power.state));
 461
 462         if (adev->power.state == ACPI_STATE_D3_COLD)
 463                 return acpi_device_set_power(adev, ACPI_STATE_D0);
 464
 465         return 0;
 466 }
 467
 468 /**
 469  * acpi_dev_power_up_children_with_adr - Power up childres with valid _ADR
 470  * @adev: Parent ACPI device object.
 471  *
 472  * Change the power states of the direct children of @adev that are in D3cold
 473  * and hold valid _ADR objects to D0 in order to allow bus (e.g. PCI)
 474  * enumeration code to access them.
 475  */
 476 void acpi_dev_power_up_children_with_adr(struct acpi_device *adev)
 477 {
 478         acpi_dev_for_each_child(adev, acpi_power_up_if_adr_present, NULL);
 479 }
 480
 481 #ifdef CONFIG_PM
 482 static DEFINE_MUTEX(acpi_pm_notifier_lock);
 483 static DEFINE_MUTEX(acpi_pm_notifier_install_lock);
 484
 485 void acpi_pm_wakeup_event(struct device *dev)
 486 {
 487         pm_wakeup_dev_event(dev, 0, acpi_s2idle_wakeup());
 488 }
 489 EXPORT_SYMBOL_GPL(acpi_pm_wakeup_event);
 490
 491 static void acpi_pm_notify_handler(acpi_handle handle, u32 val, void *not_used)
 492 {
 493         struct acpi_device *adev;
 494
 495         if (val != ACPI_NOTIFY_DEVICE_WAKE)
 496                 return;
 497
 498         acpi_handle_debug(handle, "Wake notify\n");
 499
 500         adev = acpi_bus_get_acpi_device(handle);
 501         if (!adev)
 502                 return;
 503
 504         mutex_lock(&acpi_pm_notifier_lock);
 505
 506         if (adev->wakeup.flags.notifier_present) {
 507                 pm_wakeup_ws_event(adev->wakeup.ws, 0, acpi_s2idle_wakeup());
 508                 if (adev->wakeup.context.func) {
 509                         acpi_handle_debug(handle, "Running %pS for %s\n",
 510                                           adev->wakeup.context.func,
 511                                           dev_name(adev->wakeup.context.dev));
 512                         adev->wakeup.context.func(&adev->wakeup.context);
 513                 }
 514         }
 515
 516         mutex_unlock(&acpi_pm_notifier_lock);
 517
 518         acpi_bus_put_acpi_device(adev);
 519 }
 520
 521 /**
 522  * acpi_add_pm_notifier - Register PM notify handler for given ACPI device.
 523  * @adev: ACPI device to add the notify handler for.
 524  * @dev: Device to generate a wakeup event for while handling the notification.
 525  * @func: Work function to execute when handling the notification.
 526  *
 527  * NOTE: @adev need not be a run-wake or wakeup device to be a valid source of
 528  * PM wakeup events.  For example, wakeup events may be generated for bridges
 529  * if one of the devices below the bridge is signaling wakeup, even if the
 530  * bridge itself doesn't have a wakeup GPE associated with it.
 531  */
 532 acpi_status acpi_add_pm_notifier(struct acpi_device *adev, struct device *dev,
 533                         void (*func)(struct acpi_device_wakeup_context *context))
 534 {
 535         acpi_status status = AE_ALREADY_EXISTS;
 536
 537         if (!dev && !func)
 538                 return AE_BAD_PARAMETER;
 539
 540         mutex_lock(&acpi_pm_notifier_install_lock);
 541
 542         if (adev->wakeup.flags.notifier_present)
 543                 goto out;
 544
 545         status = acpi_install_notify_handler(adev->handle, ACPI_SYSTEM_NOTIFY,
 546                                              acpi_pm_notify_handler, NULL);
 547         if (ACPI_FAILURE(status))
 548                 goto out;
 549
 550         mutex_lock(&acpi_pm_notifier_lock);
 551         adev->wakeup.ws = wakeup_source_register(&adev->dev,
 552                                                  dev_name(&adev->dev));
 553         adev->wakeup.context.dev = dev;
 554         adev->wakeup.context.func = func;
 555         adev->wakeup.flags.notifier_present = true;
 556         mutex_unlock(&acpi_pm_notifier_lock);
 557
 558  out:
 559         mutex_unlock(&acpi_pm_notifier_install_lock);
 560         return status;
 561 }
 562
 563 /**
 564  * acpi_remove_pm_notifier - Unregister PM notifier from given ACPI device.
 565  * @adev: ACPI device to remove the notifier from.
 566  */
 567 acpi_status acpi_remove_pm_notifier(struct acpi_device *adev)
 568 {
 569         acpi_status status = AE_BAD_PARAMETER;
 570
 571         mutex_lock(&acpi_pm_notifier_install_lock);
 572
 573         if (!adev->wakeup.flags.notifier_present)
 574                 goto out;
 575
 576         status = acpi_remove_notify_handler(adev->handle,
 577                                             ACPI_SYSTEM_NOTIFY,
 578                                             acpi_pm_notify_handler);
 579         if (ACPI_FAILURE(status))
 580                 goto out;
 581
 582         mutex_lock(&acpi_pm_notifier_lock);
 583         adev->wakeup.context.func = NULL;
 584         adev->wakeup.context.dev = NULL;
 585         wakeup_source_unregister(adev->wakeup.ws);
 586         adev->wakeup.flags.notifier_present = false;
 587         mutex_unlock(&acpi_pm_notifier_lock);
 588
 589  out:
 590         mutex_unlock(&acpi_pm_notifier_install_lock);
 591         return status;
 592 }
 593
 594 bool acpi_bus_can_wakeup(acpi_handle handle)
 595 {
 596         struct acpi_device *device = acpi_fetch_acpi_dev(handle);
 597
 598         return device && device->wakeup.flags.valid;
 599 }
 600 EXPORT_SYMBOL(acpi_bus_can_wakeup);
 601
 602 bool acpi_pm_device_can_wakeup(struct device *dev)
 603 {
 604         struct acpi_device *adev = ACPI_COMPANION(dev);
 605
 606         return adev ? acpi_device_can_wakeup(adev) : false;
 607 }
 608
 609 /**
 610  * acpi_dev_pm_get_state - Get preferred power state of ACPI device.
 611  * @dev: Device whose preferred target power state to return.
 612  * @adev: ACPI device node corresponding to @dev.
 613  * @target_state: System state to match the resultant device state.
 614  * @d_min_p: Location to store the highest power state available to the device.
 615  * @d_max_p: Location to store the lowest power state available to the device.
 616  *
 617  * Find the lowest power (highest number) and highest power (lowest number) ACPI
 618  * device power states that the device can be in while the system is in the
 619  * state represented by @target_state.  Store the integer numbers representing
 620  * those stats in the memory locations pointed to by @d_max_p and @d_min_p,
 621  * respectively.
 622  *
 623  * Callers must ensure that @dev and @adev are valid pointers and that @adev
 624  * actually corresponds to @dev before using this function.
 625  *
 626  * Returns 0 on success or -ENODATA when one of the ACPI methods fails or
 627  * returns a value that doesn't make sense.  The memory locations pointed to by
 628  * @d_max_p and @d_min_p are only modified on success.
 629  */
 630 static int acpi_dev_pm_get_state(struct device *dev, struct acpi_device *adev,
 631                                  u32 target_state, int *d_min_p, int *d_max_p)
 632 {
 633         char method[] = { '_', 'S', '0' + target_state, 'D', '\0' };
 634         acpi_handle handle = adev->handle;
 635         unsigned long long ret;
 636         int d_min, d_max;
 637         bool wakeup = false;
 638         bool has_sxd = false;
 639         acpi_status status;
 640
 641         /*
 642          * If the system state is S0, the lowest power state the device can be
 643          * in is D3cold, unless the device has _S0W and is supposed to signal
 644          * wakeup, in which case the return value of _S0W has to be used as the
 645          * lowest power state available to the device.
 646          */
 647         d_min = ACPI_STATE_D0;
 648         d_max = ACPI_STATE_D3_COLD;
 649
 650         /*
 651          * If present, _SxD methods return the minimum D-state (highest power
 652          * state) we can use for the corresponding S-states.  Otherwise, the
 653          * minimum D-state is D0 (ACPI 3.x).
 654          */
 655         if (target_state > ACPI_STATE_S0) {
 656                 /*
 657                  * We rely on acpi_evaluate_integer() not clobbering the integer
 658                  * provided if AE_NOT_FOUND is returned.
 659                  */
 660                 ret = d_min;
 661                 status = acpi_evaluate_integer(handle, method, NULL, &ret);
 662                 if ((ACPI_FAILURE(status) && status != AE_NOT_FOUND)
 663                     || ret > ACPI_STATE_D3_COLD)
 664                         return -ENODATA;
 665
 666                 /*
 667                  * We need to handle legacy systems where D3hot and D3cold are
 668                  * the same and 3 is returned in both cases, so fall back to
 669                  * D3cold if D3hot is not a valid state.
 670                  */
 671                 if (!adev->power.states[ret].flags.valid) {
 672                         if (ret == ACPI_STATE_D3_HOT)
 673                                 ret = ACPI_STATE_D3_COLD;
 674                         else
 675                                 return -ENODATA;
 676                 }
 677
 678                 if (status == AE_OK)
 679                         has_sxd = true;
 680
 681                 d_min = ret;
 682                 wakeup = device_may_wakeup(dev) && adev->wakeup.flags.valid
 683                         && adev->wakeup.sleep_state >= target_state;
 684         } else {
 685                 wakeup = adev->wakeup.flags.valid;
 686         }
 687
 688         /*
 689          * If _PRW says we can wake up the system from the target sleep state,
 690          * the D-state returned by _SxD is sufficient for that (we assume a
 691          * wakeup-aware driver if wake is set).  Still, if _SxW exists
 692          * (ACPI 3.x), it should return the maximum (lowest power) D-state that
 693          * can wake the system.  _S0W may be valid, too.
 694          */
 695         if (wakeup) {
 696                 method[3] = 'W';
 697                 status = acpi_evaluate_integer(handle, method, NULL, &ret);
 698                 if (status == AE_NOT_FOUND) {
 699                         /* No _SxW. In this case, the ACPI spec says that we
 700                          * must not go into any power state deeper than the
 701                          * value returned from _SxD.
 702                          */
 703                         if (has_sxd && target_state > ACPI_STATE_S0)
 704                                 d_max = d_min;
 705                 } else if (ACPI_SUCCESS(status) && ret <= ACPI_STATE_D3_COLD) {
 706                         /* Fall back to D3cold if ret is not a valid state. */
 707                         if (!adev->power.states[ret].flags.valid)
 708                                 ret = ACPI_STATE_D3_COLD;
 709
 710                         d_max = ret > d_min ? ret : d_min;
 711                 } else {
 712                         return -ENODATA;
 713                 }
 714         }
 715
 716         if (d_min_p)
 717                 *d_min_p = d_min;
 718
 719         if (d_max_p)
 720                 *d_max_p = d_max;
 721
 722         return 0;
 723 }
 724
 725 /**
 726  * acpi_pm_device_sleep_state - Get preferred power state of ACPI device.
 727  * @dev: Device whose preferred target power state to return.
 728  * @d_min_p: Location to store the upper limit of the allowed states range.
 729  * @d_max_in: Deepest low-power state to take into consideration.
 730  * Return value: Preferred power state of the device on success, -ENODEV
 731  * if there's no 'struct acpi_device' for @dev, -EINVAL if @d_max_in is
 732  * incorrect, or -ENODATA on ACPI method failure.
 733  *
 734  * The caller must ensure that @dev is valid before using this function.
 735  */
 736 int acpi_pm_device_sleep_state(struct device *dev, int *d_min_p, int d_max_in)
 737 {
 738         struct acpi_device *adev;
 739         int ret, d_min, d_max;
 740
 741         if (d_max_in < ACPI_STATE_D0 || d_max_in > ACPI_STATE_D3_COLD)
 742                 return -EINVAL;
 743
 744         if (d_max_in > ACPI_STATE_D2) {
 745                 enum pm_qos_flags_status stat;
 746
 747                 stat = dev_pm_qos_flags(dev, PM_QOS_FLAG_NO_POWER_OFF);
 748                 if (stat == PM_QOS_FLAGS_ALL)
 749                         d_max_in = ACPI_STATE_D2;
 750         }
 751
 752         adev = ACPI_COMPANION(dev);
 753         if (!adev) {
 754                 dev_dbg(dev, "ACPI companion missing in %s!\n", __func__);
 755                 return -ENODEV;
 756         }
 757
 758         ret = acpi_dev_pm_get_state(dev, adev, acpi_target_system_state(),
 759                                     &d_min, &d_max);
 760         if (ret)
 761                 return ret;
 762
 763         if (d_max_in < d_min)
 764                 return -EINVAL;
 765
 766         if (d_max > d_max_in) {
 767                 for (d_max = d_max_in; d_max > d_min; d_max--) {
 768                         if (adev->power.states[d_max].flags.valid)
 769                                 break;
 770                 }
 771         }
 772
 773         if (d_min_p)
 774                 *d_min_p = d_min;
 775
 776         return d_max;
 777 }
 778 EXPORT_SYMBOL(acpi_pm_device_sleep_state);
 779
 780 /**
 781  * acpi_pm_notify_work_func - ACPI devices wakeup notification work function.
 782  * @context: Device wakeup context.
 783  */
 784 static void acpi_pm_notify_work_func(struct acpi_device_wakeup_context *context)
 785 {
 786         struct device *dev = context->dev;
 787
 788         if (dev) {
 789                 pm_wakeup_event(dev, 0);
 790                 pm_request_resume(dev);
 791         }
 792 }
 793
 794 static DEFINE_MUTEX(acpi_wakeup_lock);
 795
 796 static int __acpi_device_wakeup_enable(struct acpi_device *adev,
 797                                        u32 target_state)
 798 {
 799         struct acpi_device_wakeup *wakeup = &adev->wakeup;
 800         acpi_status status;
 801         int error = 0;
 802
 803         mutex_lock(&acpi_wakeup_lock);
 804
 805         /*
 806          * If the device wakeup power is already enabled, disable it and enable
 807          * it again in case it depends on the configuration of subordinate
 808          * devices and the conditions have changed since it was enabled last
 809          * time.
 810          */
 811         if (wakeup->enable_count > 0)
 812                 acpi_disable_wakeup_device_power(adev);
 813
 814         error = acpi_enable_wakeup_device_power(adev, target_state);
 815         if (error) {
 816                 if (wakeup->enable_count > 0) {
 817                         acpi_disable_gpe(wakeup->gpe_device, wakeup->gpe_number);
 818                         wakeup->enable_count = 0;
 819                 }
 820                 goto out;
 821         }
 822
 823         if (wakeup->enable_count > 0)
 824                 goto inc;
 825
 826         status = acpi_enable_gpe(wakeup->gpe_device, wakeup->gpe_number);
 827         if (ACPI_FAILURE(status)) {
 828                 acpi_disable_wakeup_device_power(adev);
 829                 error = -EIO;
 830                 goto out;
 831         }
 832
 833         acpi_handle_debug(adev->handle, "GPE%2X enabled for wakeup\n",
 834                           (unsigned int)wakeup->gpe_number);
 835
 836 inc:
 837         if (wakeup->enable_count < INT_MAX)
 838                 wakeup->enable_count++;
 839         else
 840                 acpi_handle_info(adev->handle, "Wakeup enable count out of bounds!\n");
 841
 842 out:
 843         mutex_unlock(&acpi_wakeup_lock);
 844         return error;
 845 }
 846
 847 /**
 848  * acpi_device_wakeup_enable - Enable wakeup functionality for device.
 849  * @adev: ACPI device to enable wakeup functionality for.
 850  * @target_state: State the system is transitioning into.
 851  *
 852  * Enable the GPE associated with @adev so that it can generate wakeup signals
 853  * for the device in response to external (remote) events and enable wakeup
 854  * power for it.
 855  *
 856  * Callers must ensure that @adev is a valid ACPI device node before executing
 857  * this function.
 858  */
 859 static int acpi_device_wakeup_enable(struct acpi_device *adev, u32 target_state)
 860 {
 861         return __acpi_device_wakeup_enable(adev, target_state);
 862 }
 863
 864 /**
 865  * acpi_device_wakeup_disable - Disable wakeup functionality for device.
 866  * @adev: ACPI device to disable wakeup functionality for.
 867  *
 868  * Disable the GPE associated with @adev and disable wakeup power for it.
 869  *
 870  * Callers must ensure that @adev is a valid ACPI device node before executing
 871  * this function.
 872  */
 873 static void acpi_device_wakeup_disable(struct acpi_device *adev)
 874 {
 875         struct acpi_device_wakeup *wakeup = &adev->wakeup;
 876
 877         mutex_lock(&acpi_wakeup_lock);
 878
 879         if (!wakeup->enable_count)
 880                 goto out;
 881
 882         acpi_disable_gpe(wakeup->gpe_device, wakeup->gpe_number);
 883         acpi_disable_wakeup_device_power(adev);
 884
 885         wakeup->enable_count--;
 886
 887 out:
 888         mutex_unlock(&acpi_wakeup_lock);
 889 }
 890
 891 /**
 892  * acpi_pm_set_device_wakeup - Enable/disable remote wakeup for given device.
 893  * @dev: Device to enable/disable to generate wakeup events.
 894  * @enable: Whether to enable or disable the wakeup functionality.
 895  */
 896 int acpi_pm_set_device_wakeup(struct device *dev, bool enable)
 897 {
 898         struct acpi_device *adev;
 899         int error;
 900
 901         adev = ACPI_COMPANION(dev);
 902         if (!adev) {
 903                 dev_dbg(dev, "ACPI companion missing in %s!\n", __func__);
 904                 return -ENODEV;
 905         }
 906
 907         if (!acpi_device_can_wakeup(adev))
 908                 return -EINVAL;
 909
 910         if (!enable) {
 911                 acpi_device_wakeup_disable(adev);
 912                 dev_dbg(dev, "Wakeup disabled by ACPI\n");
 913                 return 0;
 914         }
 915
 916         error = __acpi_device_wakeup_enable(adev, acpi_target_system_state());
 917         if (!error)
 918                 dev_dbg(dev, "Wakeup enabled by ACPI\n");
 919
 920         return error;
 921 }
 922 EXPORT_SYMBOL_GPL(acpi_pm_set_device_wakeup);
 923
 924 /**
 925  * acpi_dev_pm_low_power - Put ACPI device into a low-power state.
 926  * @dev: Device to put into a low-power state.
 927  * @adev: ACPI device node corresponding to @dev.
 928  * @system_state: System state to choose the device state for.
 929  */
 930 static int acpi_dev_pm_low_power(struct device *dev, struct acpi_device *adev,
 931                                  u32 system_state)
 932 {
 933         int ret, state;
 934
 935         if (!acpi_device_power_manageable(adev))
 936                 return 0;
 937
 938         ret = acpi_dev_pm_get_state(dev, adev, system_state, NULL, &state);
 939         return ret ? ret : acpi_device_set_power(adev, state);
 940 }
 941
 942 /**
 943  * acpi_dev_pm_full_power - Put ACPI device into the full-power state.
 944  * @adev: ACPI device node to put into the full-power state.
 945  */
 946 static int acpi_dev_pm_full_power(struct acpi_device *adev)
 947 {
 948         return acpi_device_power_manageable(adev) ?
 949                 acpi_device_set_power(adev, ACPI_STATE_D0) : 0;
 950 }
 951
 952 /**
 953  * acpi_dev_suspend - Put device into a low-power state using ACPI.
 954  * @dev: Device to put into a low-power state.
 955  * @wakeup: Whether or not to enable wakeup for the device.
 956  *
 957  * Put the given device into a low-power state using the standard ACPI
 958  * mechanism.  Set up remote wakeup if desired, choose the state to put the
 959  * device into (this checks if remote wakeup is expected to work too), and set
 960  * the power state of the device.
 961  */
 962 int acpi_dev_suspend(struct device *dev, bool wakeup)
 963 {
 964         struct acpi_device *adev = ACPI_COMPANION(dev);
 965         u32 target_state = acpi_target_system_state();
 966         int error;
 967
 968         if (!adev)
 969                 return 0;
 970
 971         if (wakeup && acpi_device_can_wakeup(adev)) {
 972                 error = acpi_device_wakeup_enable(adev, target_state);
 973                 if (error)
 974                         return -EAGAIN;
 975         } else {
 976                 wakeup = false;
 977         }
 978
 979         error = acpi_dev_pm_low_power(dev, adev, target_state);
 980         if (error && wakeup)
 981                 acpi_device_wakeup_disable(adev);
 982
 983         return error;
 984 }
 985 EXPORT_SYMBOL_GPL(acpi_dev_suspend);
 986
 987 /**
 988  * acpi_dev_resume - Put device into the full-power state using ACPI.
 989  * @dev: Device to put into the full-power state.
 990  *
 991  * Put the given device into the full-power state using the standard ACPI
 992  * mechanism.  Set the power state of the device to ACPI D0 and disable wakeup.
 993  */
 994 int acpi_dev_resume(struct device *dev)
 995 {
 996         struct acpi_device *adev = ACPI_COMPANION(dev);
 997         int error;
 998
 999         if (!adev)
1000                 return 0;
1001
1002         error = acpi_dev_pm_full_power(adev);
1003         acpi_device_wakeup_disable(adev);
1004         return error;
1005 }
1006 EXPORT_SYMBOL_GPL(acpi_dev_resume);
1007
1008 /**
1009  * acpi_subsys_runtime_suspend - Suspend device using ACPI.
1010  * @dev: Device to suspend.
1011  *
1012  * Carry out the generic runtime suspend procedure for @dev and use ACPI to put
1013  * it into a runtime low-power state.
1014  */
1015 int acpi_subsys_runtime_suspend(struct device *dev)
1016 {
1017         int ret = pm_generic_runtime_suspend(dev);
1018
1019         return ret ? ret : acpi_dev_suspend(dev, true);
1020 }
1021 EXPORT_SYMBOL_GPL(acpi_subsys_runtime_suspend);
1022
1023 /**
1024  * acpi_subsys_runtime_resume - Resume device using ACPI.
1025  * @dev: Device to Resume.
1026  *
1027  * Use ACPI to put the given device into the full-power state and carry out the
1028  * generic runtime resume procedure for it.
1029  */
1030 int acpi_subsys_runtime_resume(struct device *dev)
1031 {
1032         int ret = acpi_dev_resume(dev);
1033
1034         return ret ? ret : pm_generic_runtime_resume(dev);
1035 }
1036 EXPORT_SYMBOL_GPL(acpi_subsys_runtime_resume);
1037
1038 #ifdef CONFIG_PM_SLEEP
1039 static bool acpi_dev_needs_resume(struct device *dev, struct acpi_device *adev)
1040 {
1041         u32 sys_target = acpi_target_system_state();
1042         int ret, state;
1043
1044         if (!pm_runtime_suspended(dev) || !adev || (adev->wakeup.flags.valid &&
1045             device_may_wakeup(dev) != !!adev->wakeup.prepare_count))
1046                 return true;
1047
1048         if (sys_target == ACPI_STATE_S0)
1049                 return false;
1050
1051         if (adev->power.flags.dsw_present)
1052                 return true;
1053
1054         ret = acpi_dev_pm_get_state(dev, adev, sys_target, NULL, &state);
1055         if (ret)
1056                 return true;
1057
1058         return state != adev->power.state;
1059 }
1060
1061 /**
1062  * acpi_subsys_prepare - Prepare device for system transition to a sleep state.
1063  * @dev: Device to prepare.
1064  */
1065 int acpi_subsys_prepare(struct device *dev)
1066 {
1067         struct acpi_device *adev = ACPI_COMPANION(dev);
1068
1069         if (dev->driver && dev->driver->pm && dev->driver->pm->prepare) {
1070                 int ret = dev->driver->pm->prepare(dev);
1071
1072                 if (ret < 0)
1073                         return ret;
1074
1075                 if (!ret && dev_pm_test_driver_flags(dev, DPM_FLAG_SMART_PREPARE))
1076                         return 0;
1077         }
1078
1079         return !acpi_dev_needs_resume(dev, adev);
1080 }
1081 EXPORT_SYMBOL_GPL(acpi_subsys_prepare);
1082
1083 /**
1084  * acpi_subsys_complete - Finalize device's resume during system resume.
1085  * @dev: Device to handle.
1086  */
1087 void acpi_subsys_complete(struct device *dev)
1088 {
1089         pm_generic_complete(dev);
1090         /*
1091          * If the device had been runtime-suspended before the system went into
1092          * the sleep state it is going out of and it has never been resumed till
1093          * now, resume it in case the firmware powered it up.
1094          */
1095         if (pm_runtime_suspended(dev) && pm_resume_via_firmware())
1096                 pm_request_resume(dev);
1097 }
1098 EXPORT_SYMBOL_GPL(acpi_subsys_complete);
1099
1100 /**
1101  * acpi_subsys_suspend - Run the device driver's suspend callback.
1102  * @dev: Device to handle.
1103  *
1104  * Follow PCI and resume devices from runtime suspend before running their
1105  * system suspend callbacks, unless the driver can cope with runtime-suspended
1106  * devices during system suspend and there are no ACPI-specific reasons for
1107  * resuming them.
1108  */
1109 int acpi_subsys_suspend(struct device *dev)
1110 {
1111         if (!dev_pm_test_driver_flags(dev, DPM_FLAG_SMART_SUSPEND) ||
1112             acpi_dev_needs_resume(dev, ACPI_COMPANION(dev)))
1113                 pm_runtime_resume(dev);
1114
1115         return pm_generic_suspend(dev);
1116 }
1117 EXPORT_SYMBOL_GPL(acpi_subsys_suspend);
1118
1119 /**
1120  * acpi_subsys_suspend_late - Suspend device using ACPI.
1121  * @dev: Device to suspend.
1122  *
1123  * Carry out the generic late suspend procedure for @dev and use ACPI to put
1124  * it into a low-power state during system transition into a sleep state.
1125  */
1126 int acpi_subsys_suspend_late(struct device *dev)
1127 {
1128         int ret;
1129
1130         if (dev_pm_skip_suspend(dev))
1131                 return 0;
1132
1133         ret = pm_generic_suspend_late(dev);
1134         return ret ? ret : acpi_dev_suspend(dev, device_may_wakeup(dev));
1135 }
1136 EXPORT_SYMBOL_GPL(acpi_subsys_suspend_late);
1137
1138 /**
1139  * acpi_subsys_suspend_noirq - Run the device driver's "noirq" suspend callback.
1140  * @dev: Device to suspend.
1141  */
1142 int acpi_subsys_suspend_noirq(struct device *dev)
1143 {
1144         int ret;
1145
1146         if (dev_pm_skip_suspend(dev))
1147                 return 0;
1148
1149         ret = pm_generic_suspend_noirq(dev);
1150         if (ret)
1151                 return ret;
1152
1153         /*
1154          * If the target system sleep state is suspend-to-idle, it is sufficient
1155          * to check whether or not the device's wakeup settings are good for
1156          * runtime PM.  Otherwise, the pm_resume_via_firmware() check will cause
1157          * acpi_subsys_complete() to take care of fixing up the device's state
1158          * anyway, if need be.
1159          */
1160         if (device_can_wakeup(dev) && !device_may_wakeup(dev))
1161                 dev->power.may_skip_resume = false;
1162
1163         return 0;
1164 }
1165 EXPORT_SYMBOL_GPL(acpi_subsys_suspend_noirq);
1166
1167 /**
1168  * acpi_subsys_resume_noirq - Run the device driver's "noirq" resume callback.
1169  * @dev: Device to handle.
1170  */
1171 static int acpi_subsys_resume_noirq(struct device *dev)
1172 {
1173         if (dev_pm_skip_resume(dev))
1174                 return 0;
1175
1176         return pm_generic_resume_noirq(dev);
1177 }
1178
1179 /**
1180  * acpi_subsys_resume_early - Resume device using ACPI.
1181  * @dev: Device to Resume.
1182  *
1183  * Use ACPI to put the given device into the full-power state and carry out the
1184  * generic early resume procedure for it during system transition into the
1185  * working state, but only do that if device either defines early resume
1186  * handler, or does not define power operations at all. Otherwise powering up
1187  * of the device is postponed to the normal resume phase.
1188  */
1189 static int acpi_subsys_resume_early(struct device *dev)
1190 {
1191         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1192         int ret;
1193
1194         if (dev_pm_skip_resume(dev))
1195                 return 0;
1196
1197         if (pm && !pm->resume_early) {
1198                 dev_dbg(dev, "postponing D0 transition to normal resume stage\n");
1199                 return 0;
1200         }
1201
1202         ret = acpi_dev_resume(dev);
1203         return ret ? ret : pm_generic_resume_early(dev);
1204 }
1205
1206 /**
1207  * acpi_subsys_resume - Resume device using ACPI.
1208  * @dev: Device to Resume.
1209  *
1210  * Use ACPI to put the given device into the full-power state if it has not been
1211  * powered up during early resume phase, and carry out the generic resume
1212  * procedure for it during system transition into the working state.
1213  */
1214 static int acpi_subsys_resume(struct device *dev)
1215 {
1216         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1217         int ret = 0;
1218
1219         if (!dev_pm_skip_resume(dev) && pm && !pm->resume_early) {
1220                 dev_dbg(dev, "executing postponed D0 transition\n");
1221                 ret = acpi_dev_resume(dev);
1222         }
1223
1224         return ret ? ret : pm_generic_resume(dev);
1225 }
1226
1227 /**
1228  * acpi_subsys_freeze - Run the device driver's freeze callback.
1229  * @dev: Device to handle.
1230  */
1231 int acpi_subsys_freeze(struct device *dev)
1232 {
1233         /*
1234          * Resume all runtime-suspended devices before creating a snapshot
1235          * image of system memory, because the restore kernel generally cannot
1236          * be expected to always handle them consistently and they need to be
1237          * put into the runtime-active metastate during system resume anyway,
1238          * so it is better to ensure that the state saved in the image will be
1239          * always consistent with that.
1240          */
1241         pm_runtime_resume(dev);
1242
1243         return pm_generic_freeze(dev);
1244 }
1245 EXPORT_SYMBOL_GPL(acpi_subsys_freeze);
1246
1247 /**
1248  * acpi_subsys_restore_early - Restore device using ACPI.
1249  * @dev: Device to restore.
1250  */
1251 int acpi_subsys_restore_early(struct device *dev)
1252 {
1253         int ret = acpi_dev_resume(dev);
1254
1255         return ret ? ret : pm_generic_restore_early(dev);
1256 }
1257 EXPORT_SYMBOL_GPL(acpi_subsys_restore_early);
1258
1259 /**
1260  * acpi_subsys_poweroff - Run the device driver's poweroff callback.
1261  * @dev: Device to handle.
1262  *
1263  * Follow PCI and resume devices from runtime suspend before running their
1264  * system poweroff callbacks, unless the driver can cope with runtime-suspended
1265  * devices during system suspend and there are no ACPI-specific reasons for
1266  * resuming them.
1267  */
1268 int acpi_subsys_poweroff(struct device *dev)
1269 {
1270         if (!dev_pm_test_driver_flags(dev, DPM_FLAG_SMART_SUSPEND) ||
1271             acpi_dev_needs_resume(dev, ACPI_COMPANION(dev)))
1272                 pm_runtime_resume(dev);
1273
1274         return pm_generic_poweroff(dev);
1275 }
1276 EXPORT_SYMBOL_GPL(acpi_subsys_poweroff);
1277
1278 /**
1279  * acpi_subsys_poweroff_late - Run the device driver's poweroff callback.
1280  * @dev: Device to handle.
1281  *
1282  * Carry out the generic late poweroff procedure for @dev and use ACPI to put
1283  * it into a low-power state during system transition into a sleep state.
1284  */
1285 static int acpi_subsys_poweroff_late(struct device *dev)
1286 {
1287         int ret;
1288
1289         if (dev_pm_skip_suspend(dev))
1290                 return 0;
1291
1292         ret = pm_generic_poweroff_late(dev);
1293         if (ret)
1294                 return ret;
1295
1296         return acpi_dev_suspend(dev, device_may_wakeup(dev));
1297 }
1298
1299 /**
1300  * acpi_subsys_poweroff_noirq - Run the driver's "noirq" poweroff callback.
1301  * @dev: Device to suspend.
1302  */
1303 static int acpi_subsys_poweroff_noirq(struct device *dev)
1304 {
1305         if (dev_pm_skip_suspend(dev))
1306                 return 0;
1307
1308         return pm_generic_poweroff_noirq(dev);
1309 }
1310 #endif /* CONFIG_PM_SLEEP */
1311
1312 static struct dev_pm_domain acpi_general_pm_domain = {
1313         .ops = {
1314                 .runtime_suspend = acpi_subsys_runtime_suspend,
1315                 .runtime_resume = acpi_subsys_runtime_resume,
1316 #ifdef CONFIG_PM_SLEEP
1317                 .prepare = acpi_subsys_prepare,
1318                 .complete = acpi_subsys_complete,
1319                 .suspend = acpi_subsys_suspend,
1320                 .resume = acpi_subsys_resume,
1321                 .suspend_late = acpi_subsys_suspend_late,
1322                 .suspend_noirq = acpi_subsys_suspend_noirq,
1323                 .resume_noirq = acpi_subsys_resume_noirq,
1324                 .resume_early = acpi_subsys_resume_early,
1325                 .freeze = acpi_subsys_freeze,
1326                 .poweroff = acpi_subsys_poweroff,
1327                 .poweroff_late = acpi_subsys_poweroff_late,
1328                 .poweroff_noirq = acpi_subsys_poweroff_noirq,
1329                 .restore_early = acpi_subsys_restore_early,
1330 #endif
1331         },
1332 };
1333
1334 /**
1335  * acpi_dev_pm_detach - Remove ACPI power management from the device.
1336  * @dev: Device to take care of.
1337  * @power_off: Whether or not to try to remove power from the device.
1338  *
1339  * Remove the device from the general ACPI PM domain and remove its wakeup
1340  * notifier.  If @power_off is set, additionally remove power from the device if
1341  * possible.
1342  *
1343  * Callers must ensure proper synchronization of this function with power
1344  * management callbacks.
1345  */
1346 static void acpi_dev_pm_detach(struct device *dev, bool power_off)
1347 {
1348         struct acpi_device *adev = ACPI_COMPANION(dev);
1349
1350         if (adev && dev->pm_domain == &acpi_general_pm_domain) {
1351                 dev_pm_domain_set(dev, NULL);
1352                 acpi_remove_pm_notifier(adev);
1353                 if (power_off) {
1354                         /*
1355                          * If the device's PM QoS resume latency limit or flags
1356                          * have been exposed to user space, they have to be
1357                          * hidden at this point, so that they don't affect the
1358                          * choice of the low-power state to put the device into.
1359                          */
1360                         dev_pm_qos_hide_latency_limit(dev);
1361                         dev_pm_qos_hide_flags(dev);
1362                         acpi_device_wakeup_disable(adev);
1363                         acpi_dev_pm_low_power(dev, adev, ACPI_STATE_S0);
1364                 }
1365         }
1366 }
1367
1368 /**
1369  * acpi_dev_pm_attach - Prepare device for ACPI power management.
1370  * @dev: Device to prepare.
1371  * @power_on: Whether or not to power on the device.
1372  *
1373  * If @dev has a valid ACPI handle that has a valid struct acpi_device object
1374  * attached to it, install a wakeup notification handler for the device and
1375  * add it to the general ACPI PM domain.  If @power_on is set, the device will
1376  * be put into the ACPI D0 state before the function returns.
1377  *
1378  * This assumes that the @dev's bus type uses generic power management callbacks
1379  * (or doesn't use any power management callbacks at all).
1380  *
1381  * Callers must ensure proper synchronization of this function with power
1382  * management callbacks.
1383  */
1384 int acpi_dev_pm_attach(struct device *dev, bool power_on)
1385 {
1386         /*
1387          * Skip devices whose ACPI companions match the device IDs below,
1388          * because they require special power management handling incompatible
1389          * with the generic ACPI PM domain.
1390          */
1391         static const struct acpi_device_id special_pm_ids[] = {
1392                 ACPI_FAN_DEVICE_IDS,
1393                 {}
1394         };
1395         struct acpi_device *adev = ACPI_COMPANION(dev);
1396
1397         if (!adev || !acpi_match_device_ids(adev, special_pm_ids))
1398                 return 0;
1399
1400         /*
1401          * Only attach the power domain to the first device if the
1402          * companion is shared by multiple. This is to prevent doing power
1403          * management twice.
1404          */
1405         if (!acpi_device_is_first_physical_node(adev, dev))
1406                 return 0;
1407
1408         acpi_add_pm_notifier(adev, dev, acpi_pm_notify_work_func);
1409         dev_pm_domain_set(dev, &acpi_general_pm_domain);
1410         if (power_on) {
1411                 acpi_dev_pm_full_power(adev);
1412                 acpi_device_wakeup_disable(adev);
1413         }
1414
1415         dev->pm_domain->detach = acpi_dev_pm_detach;
1416         return 1;
1417 }
1418 EXPORT_SYMBOL_GPL(acpi_dev_pm_attach);
1419
1420 /**
1421  * acpi_storage_d3 - Check if D3 should be used in the suspend path
1422  * @dev: Device to check
1423  *
1424  * Return %true if the platform firmware wants @dev to be programmed
1425  * into D3hot or D3cold (if supported) in the suspend path, or %false
1426  * when there is no specific preference. On some platforms, if this
1427  * hint is ignored, @dev may remain unresponsive after suspending the
1428  * platform as a whole.
1429  *
1430  * Although the property has storage in the name it actually is
1431  * applied to the PCIe slot and plugging in a non-storage device the
1432  * same platform restrictions will likely apply.
1433  */
1434 bool acpi_storage_d3(struct device *dev)
1435 {
1436         struct acpi_device *adev = ACPI_COMPANION(dev);
1437         u8 val;
1438
1439         if (force_storage_d3())
1440                 return true;
1441
1442         if (!adev)
1443                 return false;
1444         if (fwnode_property_read_u8(acpi_fwnode_handle(adev), "StorageD3Enable",
1445                         &val))
1446                 return false;
1447         return val == 1;
1448 }
1449 EXPORT_SYMBOL_GPL(acpi_storage_d3);
1450
1451 /**
1452  * acpi_dev_state_d0 - Tell if the device is in D0 power state
1453  * @dev: Physical device the ACPI power state of which to check
1454  *
1455  * On a system without ACPI, return true. On a system with ACPI, return true if
1456  * the current ACPI power state of the device is D0, or false otherwise.
1457  *
1458  * Note that the power state of a device is not well-defined after it has been
1459  * passed to acpi_device_set_power() and before that function returns, so it is
1460  * not valid to ask for the ACPI power state of the device in that time frame.
1461  *
1462  * This function is intended to be used in a driver's probe or remove
1463  * function. See Documentation/firmware-guide/acpi/low-power-probe.rst for
1464  * more information.
1465  */
1466 bool acpi_dev_state_d0(struct device *dev)
1467 {
1468         struct acpi_device *adev = ACPI_COMPANION(dev);
1469
1470         if (!adev)
1471                 return true;
1472
1473         return adev->power.state == ACPI_STATE_D0;
1474 }
1475 EXPORT_SYMBOL_GPL(acpi_dev_state_d0);
1476
1477 #endif /* CONFIG_PM */