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