ACPI / PM: Allow device power states to be used for CONFIG_PM unset
[linux-3.10.git] / drivers / acpi / device_pm.c
1 /*
2  * drivers/acpi/device_pm.c - ACPI device power management routines.
3  *
4  * Copyright (C) 2012, Intel Corp.
5  * Author: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
6  *
7  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
8  *
9  *  This program is free software; you can redistribute it and/or modify
10  *  it under the terms of the GNU General Public License version 2 as published
11  *  by the Free Software Foundation.
12  *
13  *  This program is distributed in the hope that it will be useful, but
14  *  WITHOUT ANY WARRANTY; without even the implied warranty of
15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  *  General Public License for more details.
17  *
18  *  You should have received a copy of the GNU General Public License along
19  *  with this program; if not, write to the Free Software Foundation, Inc.,
20  *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
21  *
22  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
23  */
24
25 #include <linux/device.h>
26 #include <linux/export.h>
27 #include <linux/mutex.h>
28 #include <linux/pm_qos.h>
29 #include <linux/pm_runtime.h>
30
31 #include <acpi/acpi.h>
32 #include <acpi/acpi_bus.h>
33 #include <acpi/acpi_drivers.h>
34
35 #include "internal.h"
36
37 #define _COMPONENT      ACPI_POWER_COMPONENT
38 ACPI_MODULE_NAME("device_pm");
39
40 /**
41  * acpi_power_state_string - String representation of ACPI device power state.
42  * @state: ACPI device power state to return the string representation of.
43  */
44 const char *acpi_power_state_string(int state)
45 {
46         switch (state) {
47         case ACPI_STATE_D0:
48                 return "D0";
49         case ACPI_STATE_D1:
50                 return "D1";
51         case ACPI_STATE_D2:
52                 return "D2";
53         case ACPI_STATE_D3_HOT:
54                 return "D3hot";
55         case ACPI_STATE_D3_COLD:
56                 return "D3cold";
57         default:
58                 return "(unknown)";
59         }
60 }
61
62 /**
63  * acpi_device_get_power - Get power state of an ACPI device.
64  * @device: Device to get the power state of.
65  * @state: Place to store the power state of the device.
66  *
67  * This function does not update the device's power.state field, but it may
68  * update its parent's power.state field (when the parent's power state is
69  * unknown and the device's power state turns out to be D0).
70  */
71 int acpi_device_get_power(struct acpi_device *device, int *state)
72 {
73         int result = ACPI_STATE_UNKNOWN;
74
75         if (!device || !state)
76                 return -EINVAL;
77
78         if (!device->flags.power_manageable) {
79                 /* TBD: Non-recursive algorithm for walking up hierarchy. */
80                 *state = device->parent ?
81                         device->parent->power.state : ACPI_STATE_D0;
82                 goto out;
83         }
84
85         /*
86          * Get the device's power state from power resources settings and _PSC,
87          * if available.
88          */
89         if (device->power.flags.power_resources) {
90                 int error = acpi_power_get_inferred_state(device, &result);
91                 if (error)
92                         return error;
93         }
94         if (device->power.flags.explicit_get) {
95                 acpi_handle handle = device->handle;
96                 unsigned long long psc;
97                 acpi_status status;
98
99                 status = acpi_evaluate_integer(handle, "_PSC", NULL, &psc);
100                 if (ACPI_FAILURE(status))
101                         return -ENODEV;
102
103                 /*
104                  * The power resources settings may indicate a power state
105                  * shallower than the actual power state of the device.
106                  *
107                  * Moreover, on systems predating ACPI 4.0, if the device
108                  * doesn't depend on any power resources and _PSC returns 3,
109                  * that means "power off".  We need to maintain compatibility
110                  * with those systems.
111                  */
112                 if (psc > result && psc < ACPI_STATE_D3_COLD)
113                         result = psc;
114                 else if (result == ACPI_STATE_UNKNOWN)
115                         result = psc > ACPI_STATE_D2 ? ACPI_STATE_D3_COLD : psc;
116         }
117
118         /*
119          * If we were unsure about the device parent's power state up to this
120          * point, the fact that the device is in D0 implies that the parent has
121          * to be in D0 too.
122          */
123         if (device->parent && device->parent->power.state == ACPI_STATE_UNKNOWN
124             && result == ACPI_STATE_D0)
125                 device->parent->power.state = ACPI_STATE_D0;
126
127         *state = result;
128
129  out:
130         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] power state is %s\n",
131                           device->pnp.bus_id, acpi_power_state_string(*state)));
132
133         return 0;
134 }
135
136 static int acpi_dev_pm_explicit_set(struct acpi_device *adev, int state)
137 {
138         if (adev->power.states[state].flags.explicit_set) {
139                 char method[5] = { '_', 'P', 'S', '0' + state, '\0' };
140                 acpi_status status;
141
142                 status = acpi_evaluate_object(adev->handle, method, NULL, NULL);
143                 if (ACPI_FAILURE(status))
144                         return -ENODEV;
145         }
146         return 0;
147 }
148
149 /**
150  * acpi_device_set_power - Set power state of an ACPI device.
151  * @device: Device to set the power state of.
152  * @state: New power state to set.
153  *
154  * Callers must ensure that the device is power manageable before using this
155  * function.
156  */
157 int acpi_device_set_power(struct acpi_device *device, int state)
158 {
159         int result = 0;
160         bool cut_power = false;
161
162         if (!device || (state < ACPI_STATE_D0) || (state > ACPI_STATE_D3_COLD))
163                 return -EINVAL;
164
165         /* Make sure this is a valid target state */
166
167         if (state == device->power.state) {
168                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device is already at %s\n",
169                                   acpi_power_state_string(state)));
170                 return 0;
171         }
172
173         if (!device->power.states[state].flags.valid) {
174                 printk(KERN_WARNING PREFIX "Device does not support %s\n",
175                        acpi_power_state_string(state));
176                 return -ENODEV;
177         }
178         if (device->parent && (state < device->parent->power.state)) {
179                 printk(KERN_WARNING PREFIX
180                               "Cannot set device to a higher-powered"
181                               " state than parent\n");
182                 return -ENODEV;
183         }
184
185         /* For D3cold we should first transition into D3hot. */
186         if (state == ACPI_STATE_D3_COLD
187             && device->power.states[ACPI_STATE_D3_COLD].flags.os_accessible) {
188                 state = ACPI_STATE_D3_HOT;
189                 cut_power = true;
190         }
191
192         if (state < device->power.state && state != ACPI_STATE_D0
193             && device->power.state >= ACPI_STATE_D3_HOT) {
194                 printk(KERN_WARNING PREFIX
195                         "Cannot transition to non-D0 state from D3\n");
196                 return -ENODEV;
197         }
198
199         /*
200          * Transition Power
201          * ----------------
202          * In accordance with the ACPI specification first apply power (via
203          * power resources) and then evalute _PSx.
204          */
205         if (device->power.flags.power_resources) {
206                 result = acpi_power_transition(device, state);
207                 if (result)
208                         goto end;
209         }
210         result = acpi_dev_pm_explicit_set(device, state);
211         if (result)
212                 goto end;
213
214         if (cut_power) {
215                 device->power.state = state;
216                 state = ACPI_STATE_D3_COLD;
217                 result = acpi_power_transition(device, state);
218         }
219
220  end:
221         if (result) {
222                 printk(KERN_WARNING PREFIX
223                               "Device [%s] failed to transition to %s\n",
224                               device->pnp.bus_id,
225                               acpi_power_state_string(state));
226         } else {
227                 device->power.state = state;
228                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
229                                   "Device [%s] transitioned to %s\n",
230                                   device->pnp.bus_id,
231                                   acpi_power_state_string(state)));
232         }
233
234         return result;
235 }
236 EXPORT_SYMBOL(acpi_device_set_power);
237
238 int acpi_bus_set_power(acpi_handle handle, int state)
239 {
240         struct acpi_device *device;
241         int result;
242
243         result = acpi_bus_get_device(handle, &device);
244         if (result)
245                 return result;
246
247         if (!device->flags.power_manageable) {
248                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
249                                 "Device [%s] is not power manageable\n",
250                                 dev_name(&device->dev)));
251                 return -ENODEV;
252         }
253
254         return acpi_device_set_power(device, state);
255 }
256 EXPORT_SYMBOL(acpi_bus_set_power);
257
258 int acpi_bus_init_power(struct acpi_device *device)
259 {
260         int state;
261         int result;
262
263         if (!device)
264                 return -EINVAL;
265
266         device->power.state = ACPI_STATE_UNKNOWN;
267
268         result = acpi_device_get_power(device, &state);
269         if (result)
270                 return result;
271
272         if (state < ACPI_STATE_D3_COLD && device->power.flags.power_resources) {
273                 result = acpi_power_on_resources(device, state);
274                 if (result)
275                         return result;
276
277                 result = acpi_dev_pm_explicit_set(device, state);
278                 if (result)
279                         return result;
280         } else if (state == ACPI_STATE_UNKNOWN) {
281                 /* No power resources and missing _PSC? Try to force D0. */
282                 state = ACPI_STATE_D0;
283                 result = acpi_dev_pm_explicit_set(device, state);
284                 if (result)
285                         return result;
286         }
287         device->power.state = state;
288         return 0;
289 }
290
291 int acpi_bus_update_power(acpi_handle handle, int *state_p)
292 {
293         struct acpi_device *device;
294         int state;
295         int result;
296
297         result = acpi_bus_get_device(handle, &device);
298         if (result)
299                 return result;
300
301         result = acpi_device_get_power(device, &state);
302         if (result)
303                 return result;
304
305         if (state == ACPI_STATE_UNKNOWN)
306                 state = ACPI_STATE_D0;
307
308         result = acpi_device_set_power(device, state);
309         if (!result && state_p)
310                 *state_p = state;
311
312         return result;
313 }
314 EXPORT_SYMBOL_GPL(acpi_bus_update_power);
315
316 bool acpi_bus_power_manageable(acpi_handle handle)
317 {
318         struct acpi_device *device;
319         int result;
320
321         result = acpi_bus_get_device(handle, &device);
322         return result ? false : device->flags.power_manageable;
323 }
324 EXPORT_SYMBOL(acpi_bus_power_manageable);
325
326 #ifdef CONFIG_PM
327 static DEFINE_MUTEX(acpi_pm_notifier_lock);
328
329 /**
330  * acpi_add_pm_notifier - Register PM notifier for given ACPI device.
331  * @adev: ACPI device to add the notifier for.
332  * @context: Context information to pass to the notifier routine.
333  *
334  * NOTE: @adev need not be a run-wake or wakeup device to be a valid source of
335  * PM wakeup events.  For example, wakeup events may be generated for bridges
336  * if one of the devices below the bridge is signaling wakeup, even if the
337  * bridge itself doesn't have a wakeup GPE associated with it.
338  */
339 acpi_status acpi_add_pm_notifier(struct acpi_device *adev,
340                                  acpi_notify_handler handler, void *context)
341 {
342         acpi_status status = AE_ALREADY_EXISTS;
343
344         mutex_lock(&acpi_pm_notifier_lock);
345
346         if (adev->wakeup.flags.notifier_present)
347                 goto out;
348
349         status = acpi_install_notify_handler(adev->handle,
350                                              ACPI_SYSTEM_NOTIFY,
351                                              handler, context);
352         if (ACPI_FAILURE(status))
353                 goto out;
354
355         adev->wakeup.flags.notifier_present = true;
356
357  out:
358         mutex_unlock(&acpi_pm_notifier_lock);
359         return status;
360 }
361
362 /**
363  * acpi_remove_pm_notifier - Unregister PM notifier from given ACPI device.
364  * @adev: ACPI device to remove the notifier from.
365  */
366 acpi_status acpi_remove_pm_notifier(struct acpi_device *adev,
367                                     acpi_notify_handler handler)
368 {
369         acpi_status status = AE_BAD_PARAMETER;
370
371         mutex_lock(&acpi_pm_notifier_lock);
372
373         if (!adev->wakeup.flags.notifier_present)
374                 goto out;
375
376         status = acpi_remove_notify_handler(adev->handle,
377                                             ACPI_SYSTEM_NOTIFY,
378                                             handler);
379         if (ACPI_FAILURE(status))
380                 goto out;
381
382         adev->wakeup.flags.notifier_present = false;
383
384  out:
385         mutex_unlock(&acpi_pm_notifier_lock);
386         return status;
387 }
388
389 bool acpi_bus_can_wakeup(acpi_handle handle)
390 {
391         struct acpi_device *device;
392         int result;
393
394         result = acpi_bus_get_device(handle, &device);
395         return result ? false : device->wakeup.flags.valid;
396 }
397 EXPORT_SYMBOL(acpi_bus_can_wakeup);
398
399 /**
400  * acpi_device_power_state - Get preferred power state of ACPI device.
401  * @dev: Device whose preferred target power state to return.
402  * @adev: ACPI device node corresponding to @dev.
403  * @target_state: System state to match the resultant device state.
404  * @d_max_in: Deepest low-power state to take into consideration.
405  * @d_min_p: Location to store the upper limit of the allowed states range.
406  * Return value: Preferred power state of the device on success, -ENODEV
407  * (if there's no 'struct acpi_device' for @dev) or -EINVAL on failure
408  *
409  * Find the lowest power (highest number) ACPI device power state that the
410  * device can be in while the system is in the state represented by
411  * @target_state.  If @d_min_p is set, the highest power (lowest number) device
412  * power state that @dev can be in for the given system sleep state is stored
413  * at the location pointed to by it.
414  *
415  * Callers must ensure that @dev and @adev are valid pointers and that @adev
416  * actually corresponds to @dev before using this function.
417  */
418 int acpi_device_power_state(struct device *dev, struct acpi_device *adev,
419                             u32 target_state, int d_max_in, int *d_min_p)
420 {
421         char acpi_method[] = "_SxD";
422         unsigned long long d_min, d_max;
423         bool wakeup = false;
424
425         if (d_max_in < ACPI_STATE_D0 || d_max_in > ACPI_STATE_D3)
426                 return -EINVAL;
427
428         if (d_max_in > ACPI_STATE_D3_HOT) {
429                 enum pm_qos_flags_status stat;
430
431                 stat = dev_pm_qos_flags(dev, PM_QOS_FLAG_NO_POWER_OFF);
432                 if (stat == PM_QOS_FLAGS_ALL)
433                         d_max_in = ACPI_STATE_D3_HOT;
434         }
435
436         acpi_method[2] = '0' + target_state;
437         /*
438          * If the sleep state is S0, the lowest limit from ACPI is D3,
439          * but if the device has _S0W, we will use the value from _S0W
440          * as the lowest limit from ACPI.  Finally, we will constrain
441          * the lowest limit with the specified one.
442          */
443         d_min = ACPI_STATE_D0;
444         d_max = ACPI_STATE_D3;
445
446         /*
447          * If present, _SxD methods return the minimum D-state (highest power
448          * state) we can use for the corresponding S-states.  Otherwise, the
449          * minimum D-state is D0 (ACPI 3.x).
450          *
451          * NOTE: We rely on acpi_evaluate_integer() not clobbering the integer
452          * provided -- that's our fault recovery, we ignore retval.
453          */
454         if (target_state > ACPI_STATE_S0) {
455                 acpi_evaluate_integer(adev->handle, acpi_method, NULL, &d_min);
456                 wakeup = device_may_wakeup(dev) && adev->wakeup.flags.valid
457                         && adev->wakeup.sleep_state >= target_state;
458         } else if (dev_pm_qos_flags(dev, PM_QOS_FLAG_REMOTE_WAKEUP) !=
459                         PM_QOS_FLAGS_NONE) {
460                 wakeup = adev->wakeup.flags.valid;
461         }
462
463         /*
464          * If _PRW says we can wake up the system from the target sleep state,
465          * the D-state returned by _SxD is sufficient for that (we assume a
466          * wakeup-aware driver if wake is set).  Still, if _SxW exists
467          * (ACPI 3.x), it should return the maximum (lowest power) D-state that
468          * can wake the system.  _S0W may be valid, too.
469          */
470         if (wakeup) {
471                 acpi_status status;
472
473                 acpi_method[3] = 'W';
474                 status = acpi_evaluate_integer(adev->handle, acpi_method, NULL,
475                                                 &d_max);
476                 if (ACPI_FAILURE(status)) {
477                         if (target_state != ACPI_STATE_S0 ||
478                             status != AE_NOT_FOUND)
479                                 d_max = d_min;
480                 } else if (d_max < d_min) {
481                         /* Warn the user of the broken DSDT */
482                         printk(KERN_WARNING "ACPI: Wrong value from %s\n",
483                                 acpi_method);
484                         /* Sanitize it */
485                         d_min = d_max;
486                 }
487         }
488
489         if (d_max_in < d_min)
490                 return -EINVAL;
491         if (d_min_p)
492                 *d_min_p = d_min;
493         /* constrain d_max with specified lowest limit (max number) */
494         if (d_max > d_max_in) {
495                 for (d_max = d_max_in; d_max > d_min; d_max--) {
496                         if (adev->power.states[d_max].flags.valid)
497                                 break;
498                 }
499         }
500         return d_max;
501 }
502 EXPORT_SYMBOL_GPL(acpi_device_power_state);
503
504 /**
505  * acpi_pm_device_sleep_state - Get preferred power state of ACPI device.
506  * @dev: Device whose preferred target power state to return.
507  * @d_min_p: Location to store the upper limit of the allowed states range.
508  * @d_max_in: Deepest low-power state to take into consideration.
509  * Return value: Preferred power state of the device on success, -ENODEV
510  * (if there's no 'struct acpi_device' for @dev) or -EINVAL on failure
511  *
512  * The caller must ensure that @dev is valid before using this function.
513  */
514 int acpi_pm_device_sleep_state(struct device *dev, int *d_min_p, int d_max_in)
515 {
516         acpi_handle handle = DEVICE_ACPI_HANDLE(dev);
517         struct acpi_device *adev;
518
519         if (!handle || acpi_bus_get_device(handle, &adev)) {
520                 dev_dbg(dev, "ACPI handle without context in %s!\n", __func__);
521                 return -ENODEV;
522         }
523
524         return acpi_device_power_state(dev, adev, acpi_target_system_state(),
525                                        d_max_in, d_min_p);
526 }
527 EXPORT_SYMBOL(acpi_pm_device_sleep_state);
528
529 #ifdef CONFIG_PM_RUNTIME
530 /**
531  * acpi_wakeup_device - Wakeup notification handler for ACPI devices.
532  * @handle: ACPI handle of the device the notification is for.
533  * @event: Type of the signaled event.
534  * @context: Device corresponding to @handle.
535  */
536 static void acpi_wakeup_device(acpi_handle handle, u32 event, void *context)
537 {
538         struct device *dev = context;
539
540         if (event == ACPI_NOTIFY_DEVICE_WAKE && dev) {
541                 pm_wakeup_event(dev, 0);
542                 pm_runtime_resume(dev);
543         }
544 }
545
546 /**
547  * __acpi_device_run_wake - Enable/disable runtime remote wakeup for device.
548  * @adev: ACPI device to enable/disable the remote wakeup for.
549  * @enable: Whether to enable or disable the wakeup functionality.
550  *
551  * Enable/disable the GPE associated with @adev so that it can generate
552  * wakeup signals for the device in response to external (remote) events and
553  * enable/disable device wakeup power.
554  *
555  * Callers must ensure that @adev is a valid ACPI device node before executing
556  * this function.
557  */
558 int __acpi_device_run_wake(struct acpi_device *adev, bool enable)
559 {
560         struct acpi_device_wakeup *wakeup = &adev->wakeup;
561
562         if (enable) {
563                 acpi_status res;
564                 int error;
565
566                 error = acpi_enable_wakeup_device_power(adev, ACPI_STATE_S0);
567                 if (error)
568                         return error;
569
570                 res = acpi_enable_gpe(wakeup->gpe_device, wakeup->gpe_number);
571                 if (ACPI_FAILURE(res)) {
572                         acpi_disable_wakeup_device_power(adev);
573                         return -EIO;
574                 }
575         } else {
576                 acpi_disable_gpe(wakeup->gpe_device, wakeup->gpe_number);
577                 acpi_disable_wakeup_device_power(adev);
578         }
579         return 0;
580 }
581
582 /**
583  * acpi_pm_device_run_wake - Enable/disable remote wakeup for given device.
584  * @dev: Device to enable/disable the platform to wake up.
585  * @enable: Whether to enable or disable the wakeup functionality.
586  */
587 int acpi_pm_device_run_wake(struct device *phys_dev, bool enable)
588 {
589         struct acpi_device *adev;
590         acpi_handle handle;
591
592         if (!device_run_wake(phys_dev))
593                 return -EINVAL;
594
595         handle = DEVICE_ACPI_HANDLE(phys_dev);
596         if (!handle || acpi_bus_get_device(handle, &adev)) {
597                 dev_dbg(phys_dev, "ACPI handle without context in %s!\n",
598                         __func__);
599                 return -ENODEV;
600         }
601
602         return __acpi_device_run_wake(adev, enable);
603 }
604 EXPORT_SYMBOL(acpi_pm_device_run_wake);
605 #else
606 static inline void acpi_wakeup_device(acpi_handle handle, u32 event,
607                                       void *context) {}
608 #endif /* CONFIG_PM_RUNTIME */
609
610 #ifdef CONFIG_PM_SLEEP
611 /**
612  * __acpi_device_sleep_wake - Enable or disable device to wake up the system.
613  * @dev: Device to enable/desible to wake up the system.
614  * @target_state: System state the device is supposed to wake up from.
615  * @enable: Whether to enable or disable @dev to wake up the system.
616  */
617 int __acpi_device_sleep_wake(struct acpi_device *adev, u32 target_state,
618                              bool enable)
619 {
620         return enable ?
621                 acpi_enable_wakeup_device_power(adev, target_state) :
622                 acpi_disable_wakeup_device_power(adev);
623 }
624
625 /**
626  * acpi_pm_device_sleep_wake - Enable or disable device to wake up the system.
627  * @dev: Device to enable/desible to wake up the system from sleep states.
628  * @enable: Whether to enable or disable @dev to wake up the system.
629  */
630 int acpi_pm_device_sleep_wake(struct device *dev, bool enable)
631 {
632         acpi_handle handle;
633         struct acpi_device *adev;
634         int error;
635
636         if (!device_can_wakeup(dev))
637                 return -EINVAL;
638
639         handle = DEVICE_ACPI_HANDLE(dev);
640         if (!handle || acpi_bus_get_device(handle, &adev)) {
641                 dev_dbg(dev, "ACPI handle without context in %s!\n", __func__);
642                 return -ENODEV;
643         }
644
645         error = __acpi_device_sleep_wake(adev, acpi_target_system_state(),
646                                          enable);
647         if (!error)
648                 dev_info(dev, "System wakeup %s by ACPI\n",
649                                 enable ? "enabled" : "disabled");
650
651         return error;
652 }
653 #endif /* CONFIG_PM_SLEEP */
654
655 /**
656  * acpi_dev_pm_get_node - Get ACPI device node for the given physical device.
657  * @dev: Device to get the ACPI node for.
658  */
659 struct acpi_device *acpi_dev_pm_get_node(struct device *dev)
660 {
661         acpi_handle handle = DEVICE_ACPI_HANDLE(dev);
662         struct acpi_device *adev;
663
664         return handle && !acpi_bus_get_device(handle, &adev) ? adev : NULL;
665 }
666
667 /**
668  * acpi_dev_pm_low_power - Put ACPI device into a low-power state.
669  * @dev: Device to put into a low-power state.
670  * @adev: ACPI device node corresponding to @dev.
671  * @system_state: System state to choose the device state for.
672  */
673 static int acpi_dev_pm_low_power(struct device *dev, struct acpi_device *adev,
674                                  u32 system_state)
675 {
676         int power_state;
677
678         if (!acpi_device_power_manageable(adev))
679                 return 0;
680
681         power_state = acpi_device_power_state(dev, adev, system_state,
682                                               ACPI_STATE_D3, NULL);
683         if (power_state < ACPI_STATE_D0 || power_state > ACPI_STATE_D3)
684                 return -EIO;
685
686         return acpi_device_set_power(adev, power_state);
687 }
688
689 /**
690  * acpi_dev_pm_full_power - Put ACPI device into the full-power state.
691  * @adev: ACPI device node to put into the full-power state.
692  */
693 static int acpi_dev_pm_full_power(struct acpi_device *adev)
694 {
695         return acpi_device_power_manageable(adev) ?
696                 acpi_device_set_power(adev, ACPI_STATE_D0) : 0;
697 }
698
699 #ifdef CONFIG_PM_RUNTIME
700 /**
701  * acpi_dev_runtime_suspend - Put device into a low-power state using ACPI.
702  * @dev: Device to put into a low-power state.
703  *
704  * Put the given device into a runtime low-power state using the standard ACPI
705  * mechanism.  Set up remote wakeup if desired, choose the state to put the
706  * device into (this checks if remote wakeup is expected to work too), and set
707  * the power state of the device.
708  */
709 int acpi_dev_runtime_suspend(struct device *dev)
710 {
711         struct acpi_device *adev = acpi_dev_pm_get_node(dev);
712         bool remote_wakeup;
713         int error;
714
715         if (!adev)
716                 return 0;
717
718         remote_wakeup = dev_pm_qos_flags(dev, PM_QOS_FLAG_REMOTE_WAKEUP) >
719                                 PM_QOS_FLAGS_NONE;
720         error = __acpi_device_run_wake(adev, remote_wakeup);
721         if (remote_wakeup && error)
722                 return -EAGAIN;
723
724         error = acpi_dev_pm_low_power(dev, adev, ACPI_STATE_S0);
725         if (error)
726                 __acpi_device_run_wake(adev, false);
727
728         return error;
729 }
730 EXPORT_SYMBOL_GPL(acpi_dev_runtime_suspend);
731
732 /**
733  * acpi_dev_runtime_resume - Put device into the full-power state using ACPI.
734  * @dev: Device to put into the full-power state.
735  *
736  * Put the given device into the full-power state using the standard ACPI
737  * mechanism at run time.  Set the power state of the device to ACPI D0 and
738  * disable remote wakeup.
739  */
740 int acpi_dev_runtime_resume(struct device *dev)
741 {
742         struct acpi_device *adev = acpi_dev_pm_get_node(dev);
743         int error;
744
745         if (!adev)
746                 return 0;
747
748         error = acpi_dev_pm_full_power(adev);
749         __acpi_device_run_wake(adev, false);
750         return error;
751 }
752 EXPORT_SYMBOL_GPL(acpi_dev_runtime_resume);
753
754 /**
755  * acpi_subsys_runtime_suspend - Suspend device using ACPI.
756  * @dev: Device to suspend.
757  *
758  * Carry out the generic runtime suspend procedure for @dev and use ACPI to put
759  * it into a runtime low-power state.
760  */
761 int acpi_subsys_runtime_suspend(struct device *dev)
762 {
763         int ret = pm_generic_runtime_suspend(dev);
764         return ret ? ret : acpi_dev_runtime_suspend(dev);
765 }
766 EXPORT_SYMBOL_GPL(acpi_subsys_runtime_suspend);
767
768 /**
769  * acpi_subsys_runtime_resume - Resume device using ACPI.
770  * @dev: Device to Resume.
771  *
772  * Use ACPI to put the given device into the full-power state and carry out the
773  * generic runtime resume procedure for it.
774  */
775 int acpi_subsys_runtime_resume(struct device *dev)
776 {
777         int ret = acpi_dev_runtime_resume(dev);
778         return ret ? ret : pm_generic_runtime_resume(dev);
779 }
780 EXPORT_SYMBOL_GPL(acpi_subsys_runtime_resume);
781 #endif /* CONFIG_PM_RUNTIME */
782
783 #ifdef CONFIG_PM_SLEEP
784 /**
785  * acpi_dev_suspend_late - Put device into a low-power state using ACPI.
786  * @dev: Device to put into a low-power state.
787  *
788  * Put the given device into a low-power state during system transition to a
789  * sleep state using the standard ACPI mechanism.  Set up system wakeup if
790  * desired, choose the state to put the device into (this checks if system
791  * wakeup is expected to work too), and set the power state of the device.
792  */
793 int acpi_dev_suspend_late(struct device *dev)
794 {
795         struct acpi_device *adev = acpi_dev_pm_get_node(dev);
796         u32 target_state;
797         bool wakeup;
798         int error;
799
800         if (!adev)
801                 return 0;
802
803         target_state = acpi_target_system_state();
804         wakeup = device_may_wakeup(dev);
805         error = __acpi_device_sleep_wake(adev, target_state, wakeup);
806         if (wakeup && error)
807                 return error;
808
809         error = acpi_dev_pm_low_power(dev, adev, target_state);
810         if (error)
811                 __acpi_device_sleep_wake(adev, ACPI_STATE_UNKNOWN, false);
812
813         return error;
814 }
815 EXPORT_SYMBOL_GPL(acpi_dev_suspend_late);
816
817 /**
818  * acpi_dev_resume_early - Put device into the full-power state using ACPI.
819  * @dev: Device to put into the full-power state.
820  *
821  * Put the given device into the full-power state using the standard ACPI
822  * mechanism during system transition to the working state.  Set the power
823  * state of the device to ACPI D0 and disable remote wakeup.
824  */
825 int acpi_dev_resume_early(struct device *dev)
826 {
827         struct acpi_device *adev = acpi_dev_pm_get_node(dev);
828         int error;
829
830         if (!adev)
831                 return 0;
832
833         error = acpi_dev_pm_full_power(adev);
834         __acpi_device_sleep_wake(adev, ACPI_STATE_UNKNOWN, false);
835         return error;
836 }
837 EXPORT_SYMBOL_GPL(acpi_dev_resume_early);
838
839 /**
840  * acpi_subsys_prepare - Prepare device for system transition to a sleep state.
841  * @dev: Device to prepare.
842  */
843 int acpi_subsys_prepare(struct device *dev)
844 {
845         /*
846          * Follow PCI and resume devices suspended at run time before running
847          * their system suspend callbacks.
848          */
849         pm_runtime_resume(dev);
850         return pm_generic_prepare(dev);
851 }
852 EXPORT_SYMBOL_GPL(acpi_subsys_prepare);
853
854 /**
855  * acpi_subsys_suspend_late - Suspend device using ACPI.
856  * @dev: Device to suspend.
857  *
858  * Carry out the generic late suspend procedure for @dev and use ACPI to put
859  * it into a low-power state during system transition into a sleep state.
860  */
861 int acpi_subsys_suspend_late(struct device *dev)
862 {
863         int ret = pm_generic_suspend_late(dev);
864         return ret ? ret : acpi_dev_suspend_late(dev);
865 }
866 EXPORT_SYMBOL_GPL(acpi_subsys_suspend_late);
867
868 /**
869  * acpi_subsys_resume_early - Resume device using ACPI.
870  * @dev: Device to Resume.
871  *
872  * Use ACPI to put the given device into the full-power state and carry out the
873  * generic early resume procedure for it during system transition into the
874  * working state.
875  */
876 int acpi_subsys_resume_early(struct device *dev)
877 {
878         int ret = acpi_dev_resume_early(dev);
879         return ret ? ret : pm_generic_resume_early(dev);
880 }
881 EXPORT_SYMBOL_GPL(acpi_subsys_resume_early);
882 #endif /* CONFIG_PM_SLEEP */
883
884 static struct dev_pm_domain acpi_general_pm_domain = {
885         .ops = {
886 #ifdef CONFIG_PM_RUNTIME
887                 .runtime_suspend = acpi_subsys_runtime_suspend,
888                 .runtime_resume = acpi_subsys_runtime_resume,
889                 .runtime_idle = pm_generic_runtime_idle,
890 #endif
891 #ifdef CONFIG_PM_SLEEP
892                 .prepare = acpi_subsys_prepare,
893                 .suspend_late = acpi_subsys_suspend_late,
894                 .resume_early = acpi_subsys_resume_early,
895                 .poweroff_late = acpi_subsys_suspend_late,
896                 .restore_early = acpi_subsys_resume_early,
897 #endif
898         },
899 };
900
901 /**
902  * acpi_dev_pm_attach - Prepare device for ACPI power management.
903  * @dev: Device to prepare.
904  * @power_on: Whether or not to power on the device.
905  *
906  * If @dev has a valid ACPI handle that has a valid struct acpi_device object
907  * attached to it, install a wakeup notification handler for the device and
908  * add it to the general ACPI PM domain.  If @power_on is set, the device will
909  * be put into the ACPI D0 state before the function returns.
910  *
911  * This assumes that the @dev's bus type uses generic power management callbacks
912  * (or doesn't use any power management callbacks at all).
913  *
914  * Callers must ensure proper synchronization of this function with power
915  * management callbacks.
916  */
917 int acpi_dev_pm_attach(struct device *dev, bool power_on)
918 {
919         struct acpi_device *adev = acpi_dev_pm_get_node(dev);
920
921         if (!adev)
922                 return -ENODEV;
923
924         if (dev->pm_domain)
925                 return -EEXIST;
926
927         acpi_add_pm_notifier(adev, acpi_wakeup_device, dev);
928         dev->pm_domain = &acpi_general_pm_domain;
929         if (power_on) {
930                 acpi_dev_pm_full_power(adev);
931                 __acpi_device_run_wake(adev, false);
932         }
933         return 0;
934 }
935 EXPORT_SYMBOL_GPL(acpi_dev_pm_attach);
936
937 /**
938  * acpi_dev_pm_detach - Remove ACPI power management from the device.
939  * @dev: Device to take care of.
940  * @power_off: Whether or not to try to remove power from the device.
941  *
942  * Remove the device from the general ACPI PM domain and remove its wakeup
943  * notifier.  If @power_off is set, additionally remove power from the device if
944  * possible.
945  *
946  * Callers must ensure proper synchronization of this function with power
947  * management callbacks.
948  */
949 void acpi_dev_pm_detach(struct device *dev, bool power_off)
950 {
951         struct acpi_device *adev = acpi_dev_pm_get_node(dev);
952
953         if (adev && dev->pm_domain == &acpi_general_pm_domain) {
954                 dev->pm_domain = NULL;
955                 acpi_remove_pm_notifier(adev, acpi_wakeup_device);
956                 if (power_off) {
957                         /*
958                          * If the device's PM QoS resume latency limit or flags
959                          * have been exposed to user space, they have to be
960                          * hidden at this point, so that they don't affect the
961                          * choice of the low-power state to put the device into.
962                          */
963                         dev_pm_qos_hide_latency_limit(dev);
964                         dev_pm_qos_hide_flags(dev);
965                         __acpi_device_run_wake(adev, false);
966                         acpi_dev_pm_low_power(dev, adev, ACPI_STATE_S0);
967                 }
968         }
969 }
970 EXPORT_SYMBOL_GPL(acpi_dev_pm_detach);
971
972 /**
973  * acpi_dev_pm_add_dependent - Add physical device depending for PM.
974  * @handle: Handle of ACPI device node.
975  * @depdev: Device depending on that node for PM.
976  */
977 void acpi_dev_pm_add_dependent(acpi_handle handle, struct device *depdev)
978 {
979         struct acpi_device_physical_node *dep;
980         struct acpi_device *adev;
981
982         if (!depdev || acpi_bus_get_device(handle, &adev))
983                 return;
984
985         mutex_lock(&adev->physical_node_lock);
986
987         list_for_each_entry(dep, &adev->power_dependent, node)
988                 if (dep->dev == depdev)
989                         goto out;
990
991         dep = kzalloc(sizeof(*dep), GFP_KERNEL);
992         if (dep) {
993                 dep->dev = depdev;
994                 list_add_tail(&dep->node, &adev->power_dependent);
995         }
996
997  out:
998         mutex_unlock(&adev->physical_node_lock);
999 }
1000 EXPORT_SYMBOL_GPL(acpi_dev_pm_add_dependent);
1001
1002 /**
1003  * acpi_dev_pm_remove_dependent - Remove physical device depending for PM.
1004  * @handle: Handle of ACPI device node.
1005  * @depdev: Device depending on that node for PM.
1006  */
1007 void acpi_dev_pm_remove_dependent(acpi_handle handle, struct device *depdev)
1008 {
1009         struct acpi_device_physical_node *dep;
1010         struct acpi_device *adev;
1011
1012         if (!depdev || acpi_bus_get_device(handle, &adev))
1013                 return;
1014
1015         mutex_lock(&adev->physical_node_lock);
1016
1017         list_for_each_entry(dep, &adev->power_dependent, node)
1018                 if (dep->dev == depdev) {
1019                         list_del(&dep->node);
1020                         kfree(dep);
1021                         break;
1022                 }
1023
1024         mutex_unlock(&adev->physical_node_lock);
1025 }
1026 EXPORT_SYMBOL_GPL(acpi_dev_pm_remove_dependent);
1027 #endif /* CONFIG_PM */