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