]> git.karo-electronics.de Git - karo-tx-linux.git/blob - drivers/acpi/device_pm.c
Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/sage/ceph...
[karo-tx-linux.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/acpi.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 "internal.h"
32
33 #define _COMPONENT      ACPI_POWER_COMPONENT
34 ACPI_MODULE_NAME("device_pm");
35
36 /**
37  * acpi_power_state_string - String representation of ACPI device power state.
38  * @state: ACPI device power state to return the string representation of.
39  */
40 const char *acpi_power_state_string(int state)
41 {
42         switch (state) {
43         case ACPI_STATE_D0:
44                 return "D0";
45         case ACPI_STATE_D1:
46                 return "D1";
47         case ACPI_STATE_D2:
48                 return "D2";
49         case ACPI_STATE_D3_HOT:
50                 return "D3hot";
51         case ACPI_STATE_D3_COLD:
52                 return "D3cold";
53         default:
54                 return "(unknown)";
55         }
56 }
57
58 /**
59  * acpi_device_get_power - Get power state of an ACPI device.
60  * @device: Device to get the power state of.
61  * @state: Place to store the power state of the device.
62  *
63  * This function does not update the device's power.state field, but it may
64  * update its parent's power.state field (when the parent's power state is
65  * unknown and the device's power state turns out to be D0).
66  */
67 int acpi_device_get_power(struct acpi_device *device, int *state)
68 {
69         int result = ACPI_STATE_UNKNOWN;
70
71         if (!device || !state)
72                 return -EINVAL;
73
74         if (!device->flags.power_manageable) {
75                 /* TBD: Non-recursive algorithm for walking up hierarchy. */
76                 *state = device->parent ?
77                         device->parent->power.state : ACPI_STATE_D0;
78                 goto out;
79         }
80
81         /*
82          * Get the device's power state from power resources settings and _PSC,
83          * if available.
84          */
85         if (device->power.flags.power_resources) {
86                 int error = acpi_power_get_inferred_state(device, &result);
87                 if (error)
88                         return error;
89         }
90         if (device->power.flags.explicit_get) {
91                 acpi_handle handle = device->handle;
92                 unsigned long long psc;
93                 acpi_status status;
94
95                 status = acpi_evaluate_integer(handle, "_PSC", NULL, &psc);
96                 if (ACPI_FAILURE(status))
97                         return -ENODEV;
98
99                 /*
100                  * The power resources settings may indicate a power state
101                  * shallower than the actual power state of the device.
102                  *
103                  * Moreover, on systems predating ACPI 4.0, if the device
104                  * doesn't depend on any power resources and _PSC returns 3,
105                  * that means "power off".  We need to maintain compatibility
106                  * with those systems.
107                  */
108                 if (psc > result && psc < ACPI_STATE_D3_COLD)
109                         result = psc;
110                 else if (result == ACPI_STATE_UNKNOWN)
111                         result = psc > ACPI_STATE_D2 ? ACPI_STATE_D3_COLD : psc;
112         }
113
114         /*
115          * If we were unsure about the device parent's power state up to this
116          * point, the fact that the device is in D0 implies that the parent has
117          * to be in D0 too, except if ignore_parent is set.
118          */
119         if (!device->power.flags.ignore_parent && device->parent
120             && device->parent->power.state == ACPI_STATE_UNKNOWN
121             && result == ACPI_STATE_D0)
122                 device->parent->power.state = ACPI_STATE_D0;
123
124         *state = result;
125
126  out:
127         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] power state is %s\n",
128                           device->pnp.bus_id, acpi_power_state_string(*state)));
129
130         return 0;
131 }
132
133 static int acpi_dev_pm_explicit_set(struct acpi_device *adev, int state)
134 {
135         if (adev->power.states[state].flags.explicit_set) {
136                 char method[5] = { '_', 'P', 'S', '0' + state, '\0' };
137                 acpi_status status;
138
139                 status = acpi_evaluate_object(adev->handle, method, NULL, NULL);
140                 if (ACPI_FAILURE(status))
141                         return -ENODEV;
142         }
143         return 0;
144 }
145
146 /**
147  * acpi_device_set_power - Set power state of an ACPI device.
148  * @device: Device to set the power state of.
149  * @state: New power state to set.
150  *
151  * Callers must ensure that the device is power manageable before using this
152  * function.
153  */
154 int acpi_device_set_power(struct acpi_device *device, int state)
155 {
156         int result = 0;
157         bool cut_power = false;
158
159         if (!device || !device->flags.power_manageable
160             || (state < ACPI_STATE_D0) || (state > ACPI_STATE_D3_COLD))
161                 return -EINVAL;
162
163         /* Make sure this is a valid target state */
164
165         if (state == device->power.state) {
166                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] already in %s\n",
167                                   device->pnp.bus_id,
168                                   acpi_power_state_string(state)));
169                 return 0;
170         }
171
172         if (!device->power.states[state].flags.valid) {
173                 dev_warn(&device->dev, "Power state %s not supported\n",
174                          acpi_power_state_string(state));
175                 return -ENODEV;
176         }
177         if (!device->power.flags.ignore_parent &&
178             device->parent && (state < device->parent->power.state)) {
179                 dev_warn(&device->dev,
180                          "Cannot transition to power state %s for parent in %s\n",
181                          acpi_power_state_string(state),
182                          acpi_power_state_string(device->parent->power.state));
183                 return -ENODEV;
184         }
185
186         /* For D3cold we should first transition into D3hot. */
187         if (state == ACPI_STATE_D3_COLD
188             && device->power.states[ACPI_STATE_D3_COLD].flags.os_accessible) {
189                 state = ACPI_STATE_D3_HOT;
190                 cut_power = true;
191         }
192
193         if (state < device->power.state && state != ACPI_STATE_D0
194             && device->power.state >= ACPI_STATE_D3_HOT) {
195                 dev_warn(&device->dev,
196                          "Cannot transition to non-D0 state from D3\n");
197                 return -ENODEV;
198         }
199
200         /*
201          * Transition Power
202          * ----------------
203          * In accordance with the ACPI specification first apply power (via
204          * power resources) and then evalute _PSx.
205          */
206         if (device->power.flags.power_resources) {
207                 result = acpi_power_transition(device, state);
208                 if (result)
209                         goto end;
210         }
211         result = acpi_dev_pm_explicit_set(device, state);
212         if (result)
213                 goto end;
214
215         if (cut_power) {
216                 device->power.state = state;
217                 state = ACPI_STATE_D3_COLD;
218                 result = acpi_power_transition(device, state);
219         }
220
221  end:
222         if (result) {
223                 dev_warn(&device->dev, "Failed to change power state to %s\n",
224                          acpi_power_state_string(state));
225         } else {
226                 device->power.state = state;
227                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
228                                   "Device [%s] transitioned to %s\n",
229                                   device->pnp.bus_id,
230                                   acpi_power_state_string(state)));
231         }
232
233         return result;
234 }
235 EXPORT_SYMBOL(acpi_device_set_power);
236
237 int acpi_bus_set_power(acpi_handle handle, int state)
238 {
239         struct acpi_device *device;
240         int result;
241
242         result = acpi_bus_get_device(handle, &device);
243         if (result)
244                 return result;
245
246         return acpi_device_set_power(device, state);
247 }
248 EXPORT_SYMBOL(acpi_bus_set_power);
249
250 int acpi_bus_init_power(struct acpi_device *device)
251 {
252         int state;
253         int result;
254
255         if (!device)
256                 return -EINVAL;
257
258         device->power.state = ACPI_STATE_UNKNOWN;
259         if (!acpi_device_is_present(device))
260                 return 0;
261
262         result = acpi_device_get_power(device, &state);
263         if (result)
264                 return result;
265
266         if (state < ACPI_STATE_D3_COLD && device->power.flags.power_resources) {
267                 result = acpi_power_on_resources(device, state);
268                 if (result)
269                         return result;
270
271                 result = acpi_dev_pm_explicit_set(device, state);
272                 if (result)
273                         return result;
274         } else if (state == ACPI_STATE_UNKNOWN) {
275                 /*
276                  * No power resources and missing _PSC?  Cross fingers and make
277                  * it D0 in hope that this is what the BIOS put the device into.
278                  * [We tried to force D0 here by executing _PS0, but that broke
279                  * Toshiba P870-303 in a nasty way.]
280                  */
281                 state = ACPI_STATE_D0;
282         }
283         device->power.state = state;
284         return 0;
285 }
286
287 /**
288  * acpi_device_fix_up_power - Force device with missing _PSC into D0.
289  * @device: Device object whose power state is to be fixed up.
290  *
291  * Devices without power resources and _PSC, but having _PS0 and _PS3 defined,
292  * are assumed to be put into D0 by the BIOS.  However, in some cases that may
293  * not be the case and this function should be used then.
294  */
295 int acpi_device_fix_up_power(struct acpi_device *device)
296 {
297         int ret = 0;
298
299         if (!device->power.flags.power_resources
300             && !device->power.flags.explicit_get
301             && device->power.state == ACPI_STATE_D0)
302                 ret = acpi_dev_pm_explicit_set(device, ACPI_STATE_D0);
303
304         return ret;
305 }
306
307 int acpi_device_update_power(struct acpi_device *device, int *state_p)
308 {
309         int state;
310         int result;
311
312         if (device->power.state == ACPI_STATE_UNKNOWN) {
313                 result = acpi_bus_init_power(device);
314                 if (!result && state_p)
315                         *state_p = device->power.state;
316
317                 return result;
318         }
319
320         result = acpi_device_get_power(device, &state);
321         if (result)
322                 return result;
323
324         if (state == ACPI_STATE_UNKNOWN) {
325                 state = ACPI_STATE_D0;
326                 result = acpi_device_set_power(device, state);
327                 if (result)
328                         return result;
329         } else {
330                 if (device->power.flags.power_resources) {
331                         /*
332                          * We don't need to really switch the state, bu we need
333                          * to update the power resources' reference counters.
334                          */
335                         result = acpi_power_transition(device, state);
336                         if (result)
337                                 return result;
338                 }
339                 device->power.state = state;
340         }
341         if (state_p)
342                 *state_p = state;
343
344         return 0;
345 }
346
347 int acpi_bus_update_power(acpi_handle handle, int *state_p)
348 {
349         struct acpi_device *device;
350         int result;
351
352         result = acpi_bus_get_device(handle, &device);
353         return result ? result : acpi_device_update_power(device, state_p);
354 }
355 EXPORT_SYMBOL_GPL(acpi_bus_update_power);
356
357 bool acpi_bus_power_manageable(acpi_handle handle)
358 {
359         struct acpi_device *device;
360         int result;
361
362         result = acpi_bus_get_device(handle, &device);
363         return result ? false : device->flags.power_manageable;
364 }
365 EXPORT_SYMBOL(acpi_bus_power_manageable);
366
367 #ifdef CONFIG_PM
368 static DEFINE_MUTEX(acpi_pm_notifier_lock);
369
370 static void acpi_pm_notify_handler(acpi_handle handle, u32 val, void *not_used)
371 {
372         struct acpi_device *adev;
373
374         if (val != ACPI_NOTIFY_DEVICE_WAKE)
375                 return;
376
377         adev = acpi_bus_get_acpi_device(handle);
378         if (!adev)
379                 return;
380
381         mutex_lock(&acpi_pm_notifier_lock);
382
383         if (adev->wakeup.flags.notifier_present) {
384                 __pm_wakeup_event(adev->wakeup.ws, 0);
385                 if (adev->wakeup.context.work.func)
386                         queue_pm_work(&adev->wakeup.context.work);
387         }
388
389         mutex_unlock(&acpi_pm_notifier_lock);
390
391         acpi_bus_put_acpi_device(adev);
392 }
393
394 /**
395  * acpi_add_pm_notifier - Register PM notify handler for given ACPI device.
396  * @adev: ACPI device to add the notify handler for.
397  * @dev: Device to generate a wakeup event for while handling the notification.
398  * @work_func: Work function to execute when handling the notification.
399  *
400  * NOTE: @adev need not be a run-wake or wakeup device to be a valid source of
401  * PM wakeup events.  For example, wakeup events may be generated for bridges
402  * if one of the devices below the bridge is signaling wakeup, even if the
403  * bridge itself doesn't have a wakeup GPE associated with it.
404  */
405 acpi_status acpi_add_pm_notifier(struct acpi_device *adev, struct device *dev,
406                                  void (*work_func)(struct work_struct *work))
407 {
408         acpi_status status = AE_ALREADY_EXISTS;
409
410         if (!dev && !work_func)
411                 return AE_BAD_PARAMETER;
412
413         mutex_lock(&acpi_pm_notifier_lock);
414
415         if (adev->wakeup.flags.notifier_present)
416                 goto out;
417
418         adev->wakeup.ws = wakeup_source_register(dev_name(&adev->dev));
419         adev->wakeup.context.dev = dev;
420         if (work_func)
421                 INIT_WORK(&adev->wakeup.context.work, work_func);
422
423         status = acpi_install_notify_handler(adev->handle, ACPI_SYSTEM_NOTIFY,
424                                              acpi_pm_notify_handler, NULL);
425         if (ACPI_FAILURE(status))
426                 goto out;
427
428         adev->wakeup.flags.notifier_present = true;
429
430  out:
431         mutex_unlock(&acpi_pm_notifier_lock);
432         return status;
433 }
434
435 /**
436  * acpi_remove_pm_notifier - Unregister PM notifier from given ACPI device.
437  * @adev: ACPI device to remove the notifier from.
438  */
439 acpi_status acpi_remove_pm_notifier(struct acpi_device *adev)
440 {
441         acpi_status status = AE_BAD_PARAMETER;
442
443         mutex_lock(&acpi_pm_notifier_lock);
444
445         if (!adev->wakeup.flags.notifier_present)
446                 goto out;
447
448         status = acpi_remove_notify_handler(adev->handle,
449                                             ACPI_SYSTEM_NOTIFY,
450                                             acpi_pm_notify_handler);
451         if (ACPI_FAILURE(status))
452                 goto out;
453
454         if (adev->wakeup.context.work.func) {
455                 cancel_work_sync(&adev->wakeup.context.work);
456                 adev->wakeup.context.work.func = NULL;
457         }
458         adev->wakeup.context.dev = NULL;
459         wakeup_source_unregister(adev->wakeup.ws);
460
461         adev->wakeup.flags.notifier_present = false;
462
463  out:
464         mutex_unlock(&acpi_pm_notifier_lock);
465         return status;
466 }
467
468 bool acpi_bus_can_wakeup(acpi_handle handle)
469 {
470         struct acpi_device *device;
471         int result;
472
473         result = acpi_bus_get_device(handle, &device);
474         return result ? false : device->wakeup.flags.valid;
475 }
476 EXPORT_SYMBOL(acpi_bus_can_wakeup);
477
478 /**
479  * acpi_dev_pm_get_state - Get preferred power state of ACPI device.
480  * @dev: Device whose preferred target power state to return.
481  * @adev: ACPI device node corresponding to @dev.
482  * @target_state: System state to match the resultant device state.
483  * @d_min_p: Location to store the highest power state available to the device.
484  * @d_max_p: Location to store the lowest power state available to the device.
485  *
486  * Find the lowest power (highest number) and highest power (lowest number) ACPI
487  * device power states that the device can be in while the system is in the
488  * state represented by @target_state.  Store the integer numbers representing
489  * those stats in the memory locations pointed to by @d_max_p and @d_min_p,
490  * respectively.
491  *
492  * Callers must ensure that @dev and @adev are valid pointers and that @adev
493  * actually corresponds to @dev before using this function.
494  *
495  * Returns 0 on success or -ENODATA when one of the ACPI methods fails or
496  * returns a value that doesn't make sense.  The memory locations pointed to by
497  * @d_max_p and @d_min_p are only modified on success.
498  */
499 static int acpi_dev_pm_get_state(struct device *dev, struct acpi_device *adev,
500                                  u32 target_state, int *d_min_p, int *d_max_p)
501 {
502         char method[] = { '_', 'S', '0' + target_state, 'D', '\0' };
503         acpi_handle handle = adev->handle;
504         unsigned long long ret;
505         int d_min, d_max;
506         bool wakeup = false;
507         acpi_status status;
508
509         /*
510          * If the system state is S0, the lowest power state the device can be
511          * in is D3cold, unless the device has _S0W and is supposed to signal
512          * wakeup, in which case the return value of _S0W has to be used as the
513          * lowest power state available to the device.
514          */
515         d_min = ACPI_STATE_D0;
516         d_max = ACPI_STATE_D3_COLD;
517
518         /*
519          * If present, _SxD methods return the minimum D-state (highest power
520          * state) we can use for the corresponding S-states.  Otherwise, the
521          * minimum D-state is D0 (ACPI 3.x).
522          */
523         if (target_state > ACPI_STATE_S0) {
524                 /*
525                  * We rely on acpi_evaluate_integer() not clobbering the integer
526                  * provided if AE_NOT_FOUND is returned.
527                  */
528                 ret = d_min;
529                 status = acpi_evaluate_integer(handle, method, NULL, &ret);
530                 if ((ACPI_FAILURE(status) && status != AE_NOT_FOUND)
531                     || ret > ACPI_STATE_D3_COLD)
532                         return -ENODATA;
533
534                 /*
535                  * We need to handle legacy systems where D3hot and D3cold are
536                  * the same and 3 is returned in both cases, so fall back to
537                  * D3cold if D3hot is not a valid state.
538                  */
539                 if (!adev->power.states[ret].flags.valid) {
540                         if (ret == ACPI_STATE_D3_HOT)
541                                 ret = ACPI_STATE_D3_COLD;
542                         else
543                                 return -ENODATA;
544                 }
545                 d_min = ret;
546                 wakeup = device_may_wakeup(dev) && adev->wakeup.flags.valid
547                         && adev->wakeup.sleep_state >= target_state;
548         } else if (dev_pm_qos_flags(dev, PM_QOS_FLAG_REMOTE_WAKEUP) !=
549                         PM_QOS_FLAGS_NONE) {
550                 wakeup = adev->wakeup.flags.valid;
551         }
552
553         /*
554          * If _PRW says we can wake up the system from the target sleep state,
555          * the D-state returned by _SxD is sufficient for that (we assume a
556          * wakeup-aware driver if wake is set).  Still, if _SxW exists
557          * (ACPI 3.x), it should return the maximum (lowest power) D-state that
558          * can wake the system.  _S0W may be valid, too.
559          */
560         if (wakeup) {
561                 method[3] = 'W';
562                 status = acpi_evaluate_integer(handle, method, NULL, &ret);
563                 if (status == AE_NOT_FOUND) {
564                         if (target_state > ACPI_STATE_S0)
565                                 d_max = d_min;
566                 } else if (ACPI_SUCCESS(status) && ret <= ACPI_STATE_D3_COLD) {
567                         /* Fall back to D3cold if ret is not a valid state. */
568                         if (!adev->power.states[ret].flags.valid)
569                                 ret = ACPI_STATE_D3_COLD;
570
571                         d_max = ret > d_min ? ret : d_min;
572                 } else {
573                         return -ENODATA;
574                 }
575         }
576
577         if (d_min_p)
578                 *d_min_p = d_min;
579
580         if (d_max_p)
581                 *d_max_p = d_max;
582
583         return 0;
584 }
585
586 /**
587  * acpi_pm_device_sleep_state - Get preferred power state of ACPI device.
588  * @dev: Device whose preferred target power state to return.
589  * @d_min_p: Location to store the upper limit of the allowed states range.
590  * @d_max_in: Deepest low-power state to take into consideration.
591  * Return value: Preferred power state of the device on success, -ENODEV
592  * if there's no 'struct acpi_device' for @dev, -EINVAL if @d_max_in is
593  * incorrect, or -ENODATA on ACPI method failure.
594  *
595  * The caller must ensure that @dev is valid before using this function.
596  */
597 int acpi_pm_device_sleep_state(struct device *dev, int *d_min_p, int d_max_in)
598 {
599         struct acpi_device *adev;
600         int ret, d_min, d_max;
601
602         if (d_max_in < ACPI_STATE_D0 || d_max_in > ACPI_STATE_D3_COLD)
603                 return -EINVAL;
604
605         if (d_max_in > ACPI_STATE_D3_HOT) {
606                 enum pm_qos_flags_status stat;
607
608                 stat = dev_pm_qos_flags(dev, PM_QOS_FLAG_NO_POWER_OFF);
609                 if (stat == PM_QOS_FLAGS_ALL)
610                         d_max_in = ACPI_STATE_D3_HOT;
611         }
612
613         adev = ACPI_COMPANION(dev);
614         if (!adev) {
615                 dev_dbg(dev, "ACPI companion missing in %s!\n", __func__);
616                 return -ENODEV;
617         }
618
619         ret = acpi_dev_pm_get_state(dev, adev, acpi_target_system_state(),
620                                     &d_min, &d_max);
621         if (ret)
622                 return ret;
623
624         if (d_max_in < d_min)
625                 return -EINVAL;
626
627         if (d_max > d_max_in) {
628                 for (d_max = d_max_in; d_max > d_min; d_max--) {
629                         if (adev->power.states[d_max].flags.valid)
630                                 break;
631                 }
632         }
633
634         if (d_min_p)
635                 *d_min_p = d_min;
636
637         return d_max;
638 }
639 EXPORT_SYMBOL(acpi_pm_device_sleep_state);
640
641 /**
642  * acpi_pm_notify_work_func - ACPI devices wakeup notification work function.
643  * @work: Work item to handle.
644  */
645 static void acpi_pm_notify_work_func(struct work_struct *work)
646 {
647         struct device *dev;
648
649         dev = container_of(work, struct acpi_device_wakeup_context, work)->dev;
650         if (dev) {
651                 pm_wakeup_event(dev, 0);
652                 pm_runtime_resume(dev);
653         }
654 }
655
656 /**
657  * acpi_device_wakeup - Enable/disable wakeup functionality for device.
658  * @adev: ACPI device to enable/disable wakeup functionality for.
659  * @target_state: State the system is transitioning into.
660  * @enable: Whether to enable or disable the wakeup functionality.
661  *
662  * Enable/disable the GPE associated with @adev so that it can generate
663  * wakeup signals for the device in response to external (remote) events and
664  * enable/disable device wakeup power.
665  *
666  * Callers must ensure that @adev is a valid ACPI device node before executing
667  * this function.
668  */
669 static int acpi_device_wakeup(struct acpi_device *adev, u32 target_state,
670                               bool enable)
671 {
672         struct acpi_device_wakeup *wakeup = &adev->wakeup;
673
674         if (enable) {
675                 acpi_status res;
676                 int error;
677
678                 error = acpi_enable_wakeup_device_power(adev, target_state);
679                 if (error)
680                         return error;
681
682                 res = acpi_enable_gpe(wakeup->gpe_device, wakeup->gpe_number);
683                 if (ACPI_FAILURE(res)) {
684                         acpi_disable_wakeup_device_power(adev);
685                         return -EIO;
686                 }
687         } else {
688                 acpi_disable_gpe(wakeup->gpe_device, wakeup->gpe_number);
689                 acpi_disable_wakeup_device_power(adev);
690         }
691         return 0;
692 }
693
694 #ifdef CONFIG_PM_RUNTIME
695 /**
696  * acpi_pm_device_run_wake - Enable/disable remote wakeup for given device.
697  * @dev: Device to enable/disable the platform to wake up.
698  * @enable: Whether to enable or disable the wakeup functionality.
699  */
700 int acpi_pm_device_run_wake(struct device *phys_dev, bool enable)
701 {
702         struct acpi_device *adev;
703
704         if (!device_run_wake(phys_dev))
705                 return -EINVAL;
706
707         adev = ACPI_COMPANION(phys_dev);
708         if (!adev) {
709                 dev_dbg(phys_dev, "ACPI companion missing in %s!\n", __func__);
710                 return -ENODEV;
711         }
712
713         return acpi_device_wakeup(adev, enable, ACPI_STATE_S0);
714 }
715 EXPORT_SYMBOL(acpi_pm_device_run_wake);
716 #endif /* CONFIG_PM_RUNTIME */
717
718 #ifdef CONFIG_PM_SLEEP
719 /**
720  * acpi_pm_device_sleep_wake - Enable or disable device to wake up the system.
721  * @dev: Device to enable/desible to wake up the system from sleep states.
722  * @enable: Whether to enable or disable @dev to wake up the system.
723  */
724 int acpi_pm_device_sleep_wake(struct device *dev, bool enable)
725 {
726         struct acpi_device *adev;
727         int error;
728
729         if (!device_can_wakeup(dev))
730                 return -EINVAL;
731
732         adev = ACPI_COMPANION(dev);
733         if (!adev) {
734                 dev_dbg(dev, "ACPI companion missing in %s!\n", __func__);
735                 return -ENODEV;
736         }
737
738         error = acpi_device_wakeup(adev, acpi_target_system_state(), enable);
739         if (!error)
740                 dev_info(dev, "System wakeup %s by ACPI\n",
741                                 enable ? "enabled" : "disabled");
742
743         return error;
744 }
745 #endif /* CONFIG_PM_SLEEP */
746
747 /**
748  * acpi_dev_pm_low_power - Put ACPI device into a low-power state.
749  * @dev: Device to put into a low-power state.
750  * @adev: ACPI device node corresponding to @dev.
751  * @system_state: System state to choose the device state for.
752  */
753 static int acpi_dev_pm_low_power(struct device *dev, struct acpi_device *adev,
754                                  u32 system_state)
755 {
756         int ret, state;
757
758         if (!acpi_device_power_manageable(adev))
759                 return 0;
760
761         ret = acpi_dev_pm_get_state(dev, adev, system_state, NULL, &state);
762         return ret ? ret : acpi_device_set_power(adev, state);
763 }
764
765 /**
766  * acpi_dev_pm_full_power - Put ACPI device into the full-power state.
767  * @adev: ACPI device node to put into the full-power state.
768  */
769 static int acpi_dev_pm_full_power(struct acpi_device *adev)
770 {
771         return acpi_device_power_manageable(adev) ?
772                 acpi_device_set_power(adev, ACPI_STATE_D0) : 0;
773 }
774
775 #ifdef CONFIG_PM_RUNTIME
776 /**
777  * acpi_dev_runtime_suspend - Put device into a low-power state using ACPI.
778  * @dev: Device to put into a low-power state.
779  *
780  * Put the given device into a runtime low-power state using the standard ACPI
781  * mechanism.  Set up remote wakeup if desired, choose the state to put the
782  * device into (this checks if remote wakeup is expected to work too), and set
783  * the power state of the device.
784  */
785 int acpi_dev_runtime_suspend(struct device *dev)
786 {
787         struct acpi_device *adev = ACPI_COMPANION(dev);
788         bool remote_wakeup;
789         int error;
790
791         if (!adev)
792                 return 0;
793
794         remote_wakeup = dev_pm_qos_flags(dev, PM_QOS_FLAG_REMOTE_WAKEUP) >
795                                 PM_QOS_FLAGS_NONE;
796         error = acpi_device_wakeup(adev, ACPI_STATE_S0, remote_wakeup);
797         if (remote_wakeup && error)
798                 return -EAGAIN;
799
800         error = acpi_dev_pm_low_power(dev, adev, ACPI_STATE_S0);
801         if (error)
802                 acpi_device_wakeup(adev, ACPI_STATE_S0, false);
803
804         return error;
805 }
806 EXPORT_SYMBOL_GPL(acpi_dev_runtime_suspend);
807
808 /**
809  * acpi_dev_runtime_resume - Put device into the full-power state using ACPI.
810  * @dev: Device to put into the full-power state.
811  *
812  * Put the given device into the full-power state using the standard ACPI
813  * mechanism at run time.  Set the power state of the device to ACPI D0 and
814  * disable remote wakeup.
815  */
816 int acpi_dev_runtime_resume(struct device *dev)
817 {
818         struct acpi_device *adev = ACPI_COMPANION(dev);
819         int error;
820
821         if (!adev)
822                 return 0;
823
824         error = acpi_dev_pm_full_power(adev);
825         acpi_device_wakeup(adev, ACPI_STATE_S0, false);
826         return error;
827 }
828 EXPORT_SYMBOL_GPL(acpi_dev_runtime_resume);
829
830 /**
831  * acpi_subsys_runtime_suspend - Suspend device using ACPI.
832  * @dev: Device to suspend.
833  *
834  * Carry out the generic runtime suspend procedure for @dev and use ACPI to put
835  * it into a runtime low-power state.
836  */
837 int acpi_subsys_runtime_suspend(struct device *dev)
838 {
839         int ret = pm_generic_runtime_suspend(dev);
840         return ret ? ret : acpi_dev_runtime_suspend(dev);
841 }
842 EXPORT_SYMBOL_GPL(acpi_subsys_runtime_suspend);
843
844 /**
845  * acpi_subsys_runtime_resume - Resume device using ACPI.
846  * @dev: Device to Resume.
847  *
848  * Use ACPI to put the given device into the full-power state and carry out the
849  * generic runtime resume procedure for it.
850  */
851 int acpi_subsys_runtime_resume(struct device *dev)
852 {
853         int ret = acpi_dev_runtime_resume(dev);
854         return ret ? ret : pm_generic_runtime_resume(dev);
855 }
856 EXPORT_SYMBOL_GPL(acpi_subsys_runtime_resume);
857 #endif /* CONFIG_PM_RUNTIME */
858
859 #ifdef CONFIG_PM_SLEEP
860 /**
861  * acpi_dev_suspend_late - Put device into a low-power state using ACPI.
862  * @dev: Device to put into a low-power state.
863  *
864  * Put the given device into a low-power state during system transition to a
865  * sleep state using the standard ACPI mechanism.  Set up system wakeup if
866  * desired, choose the state to put the device into (this checks if system
867  * wakeup is expected to work too), and set the power state of the device.
868  */
869 int acpi_dev_suspend_late(struct device *dev)
870 {
871         struct acpi_device *adev = ACPI_COMPANION(dev);
872         u32 target_state;
873         bool wakeup;
874         int error;
875
876         if (!adev)
877                 return 0;
878
879         target_state = acpi_target_system_state();
880         wakeup = device_may_wakeup(dev);
881         error = acpi_device_wakeup(adev, target_state, wakeup);
882         if (wakeup && error)
883                 return error;
884
885         error = acpi_dev_pm_low_power(dev, adev, target_state);
886         if (error)
887                 acpi_device_wakeup(adev, ACPI_STATE_UNKNOWN, false);
888
889         return error;
890 }
891 EXPORT_SYMBOL_GPL(acpi_dev_suspend_late);
892
893 /**
894  * acpi_dev_resume_early - Put device into the full-power state using ACPI.
895  * @dev: Device to put into the full-power state.
896  *
897  * Put the given device into the full-power state using the standard ACPI
898  * mechanism during system transition to the working state.  Set the power
899  * state of the device to ACPI D0 and disable remote wakeup.
900  */
901 int acpi_dev_resume_early(struct device *dev)
902 {
903         struct acpi_device *adev = ACPI_COMPANION(dev);
904         int error;
905
906         if (!adev)
907                 return 0;
908
909         error = acpi_dev_pm_full_power(adev);
910         acpi_device_wakeup(adev, ACPI_STATE_UNKNOWN, false);
911         return error;
912 }
913 EXPORT_SYMBOL_GPL(acpi_dev_resume_early);
914
915 /**
916  * acpi_subsys_prepare - Prepare device for system transition to a sleep state.
917  * @dev: Device to prepare.
918  */
919 int acpi_subsys_prepare(struct device *dev)
920 {
921         struct acpi_device *adev = ACPI_COMPANION(dev);
922         u32 sys_target;
923         int ret, state;
924
925         ret = pm_generic_prepare(dev);
926         if (ret < 0)
927                 return ret;
928
929         if (!adev || !pm_runtime_suspended(dev)
930             || device_may_wakeup(dev) != !!adev->wakeup.prepare_count)
931                 return 0;
932
933         sys_target = acpi_target_system_state();
934         if (sys_target == ACPI_STATE_S0)
935                 return 1;
936
937         if (adev->power.flags.dsw_present)
938                 return 0;
939
940         ret = acpi_dev_pm_get_state(dev, adev, sys_target, NULL, &state);
941         return !ret && state == adev->power.state;
942 }
943 EXPORT_SYMBOL_GPL(acpi_subsys_prepare);
944
945 /**
946  * acpi_subsys_complete - Finalize device's resume during system resume.
947  * @dev: Device to handle.
948  */
949 void acpi_subsys_complete(struct device *dev)
950 {
951         /*
952          * If the device had been runtime-suspended before the system went into
953          * the sleep state it is going out of and it has never been resumed till
954          * now, resume it in case the firmware powered it up.
955          */
956         if (dev->power.direct_complete)
957                 pm_request_resume(dev);
958 }
959 EXPORT_SYMBOL_GPL(acpi_subsys_complete);
960
961 /**
962  * acpi_subsys_suspend - Run the device driver's suspend callback.
963  * @dev: Device to handle.
964  *
965  * Follow PCI and resume devices suspended at run time before running their
966  * system suspend callbacks.
967  */
968 int acpi_subsys_suspend(struct device *dev)
969 {
970         pm_runtime_resume(dev);
971         return pm_generic_suspend(dev);
972 }
973 EXPORT_SYMBOL_GPL(acpi_subsys_suspend);
974
975 /**
976  * acpi_subsys_suspend_late - Suspend device using ACPI.
977  * @dev: Device to suspend.
978  *
979  * Carry out the generic late suspend procedure for @dev and use ACPI to put
980  * it into a low-power state during system transition into a sleep state.
981  */
982 int acpi_subsys_suspend_late(struct device *dev)
983 {
984         int ret = pm_generic_suspend_late(dev);
985         return ret ? ret : acpi_dev_suspend_late(dev);
986 }
987 EXPORT_SYMBOL_GPL(acpi_subsys_suspend_late);
988
989 /**
990  * acpi_subsys_resume_early - Resume device using ACPI.
991  * @dev: Device to Resume.
992  *
993  * Use ACPI to put the given device into the full-power state and carry out the
994  * generic early resume procedure for it during system transition into the
995  * working state.
996  */
997 int acpi_subsys_resume_early(struct device *dev)
998 {
999         int ret = acpi_dev_resume_early(dev);
1000         return ret ? ret : pm_generic_resume_early(dev);
1001 }
1002 EXPORT_SYMBOL_GPL(acpi_subsys_resume_early);
1003
1004 /**
1005  * acpi_subsys_freeze - Run the device driver's freeze callback.
1006  * @dev: Device to handle.
1007  */
1008 int acpi_subsys_freeze(struct device *dev)
1009 {
1010         /*
1011          * This used to be done in acpi_subsys_prepare() for all devices and
1012          * some drivers may depend on it, so do it here.  Ideally, however,
1013          * runtime-suspended devices should not be touched during freeze/thaw
1014          * transitions.
1015          */
1016         pm_runtime_resume(dev);
1017         return pm_generic_freeze(dev);
1018 }
1019 EXPORT_SYMBOL_GPL(acpi_subsys_freeze);
1020
1021 #endif /* CONFIG_PM_SLEEP */
1022
1023 static struct dev_pm_domain acpi_general_pm_domain = {
1024         .ops = {
1025 #ifdef CONFIG_PM_RUNTIME
1026                 .runtime_suspend = acpi_subsys_runtime_suspend,
1027                 .runtime_resume = acpi_subsys_runtime_resume,
1028 #endif
1029 #ifdef CONFIG_PM_SLEEP
1030                 .prepare = acpi_subsys_prepare,
1031                 .complete = acpi_subsys_complete,
1032                 .suspend = acpi_subsys_suspend,
1033                 .suspend_late = acpi_subsys_suspend_late,
1034                 .resume_early = acpi_subsys_resume_early,
1035                 .freeze = acpi_subsys_freeze,
1036                 .poweroff = acpi_subsys_suspend,
1037                 .poweroff_late = acpi_subsys_suspend_late,
1038                 .restore_early = acpi_subsys_resume_early,
1039 #endif
1040         },
1041 };
1042
1043 /**
1044  * acpi_dev_pm_attach - Prepare device for ACPI power management.
1045  * @dev: Device to prepare.
1046  * @power_on: Whether or not to power on the device.
1047  *
1048  * If @dev has a valid ACPI handle that has a valid struct acpi_device object
1049  * attached to it, install a wakeup notification handler for the device and
1050  * add it to the general ACPI PM domain.  If @power_on is set, the device will
1051  * be put into the ACPI D0 state before the function returns.
1052  *
1053  * This assumes that the @dev's bus type uses generic power management callbacks
1054  * (or doesn't use any power management callbacks at all).
1055  *
1056  * Callers must ensure proper synchronization of this function with power
1057  * management callbacks.
1058  */
1059 int acpi_dev_pm_attach(struct device *dev, bool power_on)
1060 {
1061         struct acpi_device *adev = ACPI_COMPANION(dev);
1062
1063         if (!adev)
1064                 return -ENODEV;
1065
1066         if (dev->pm_domain)
1067                 return -EEXIST;
1068
1069         acpi_add_pm_notifier(adev, dev, acpi_pm_notify_work_func);
1070         dev->pm_domain = &acpi_general_pm_domain;
1071         if (power_on) {
1072                 acpi_dev_pm_full_power(adev);
1073                 acpi_device_wakeup(adev, ACPI_STATE_S0, false);
1074         }
1075         return 0;
1076 }
1077 EXPORT_SYMBOL_GPL(acpi_dev_pm_attach);
1078
1079 /**
1080  * acpi_dev_pm_detach - Remove ACPI power management from the device.
1081  * @dev: Device to take care of.
1082  * @power_off: Whether or not to try to remove power from the device.
1083  *
1084  * Remove the device from the general ACPI PM domain and remove its wakeup
1085  * notifier.  If @power_off is set, additionally remove power from the device if
1086  * possible.
1087  *
1088  * Callers must ensure proper synchronization of this function with power
1089  * management callbacks.
1090  */
1091 void acpi_dev_pm_detach(struct device *dev, bool power_off)
1092 {
1093         struct acpi_device *adev = ACPI_COMPANION(dev);
1094
1095         if (adev && dev->pm_domain == &acpi_general_pm_domain) {
1096                 dev->pm_domain = NULL;
1097                 acpi_remove_pm_notifier(adev);
1098                 if (power_off) {
1099                         /*
1100                          * If the device's PM QoS resume latency limit or flags
1101                          * have been exposed to user space, they have to be
1102                          * hidden at this point, so that they don't affect the
1103                          * choice of the low-power state to put the device into.
1104                          */
1105                         dev_pm_qos_hide_latency_limit(dev);
1106                         dev_pm_qos_hide_flags(dev);
1107                         acpi_device_wakeup(adev, ACPI_STATE_S0, false);
1108                         acpi_dev_pm_low_power(dev, adev, ACPI_STATE_S0);
1109                 }
1110         }
1111 }
1112 EXPORT_SYMBOL_GPL(acpi_dev_pm_detach);
1113 #endif /* CONFIG_PM */