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