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 | /** |
401 | * acpi_device_fix_up_power_children - Force a device's children into D0. |
402 | * @adev: Parent device object whose children's power state is to be fixed up. |
403 | * |
404 | * Call acpi_device_fix_up_power() for @adev's children so long as they |
405 | * are reported as present and enabled. |
406 | */ |
407 | void acpi_device_fix_up_power_children(struct acpi_device *adev) |
408 | { |
409 | acpi_dev_for_each_child(adev, fn: fix_up_power_if_applicable, NULL); |
410 | } |
411 | EXPORT_SYMBOL_GPL(acpi_device_fix_up_power_children); |
412 | |
413 | int acpi_device_update_power(struct acpi_device *device, int *state_p) |
414 | { |
415 | int state; |
416 | int result; |
417 | |
418 | if (device->power.state == ACPI_STATE_UNKNOWN) { |
419 | result = acpi_bus_init_power(device); |
420 | if (!result && state_p) |
421 | *state_p = device->power.state; |
422 | |
423 | return result; |
424 | } |
425 | |
426 | result = acpi_device_get_power(device, state: &state); |
427 | if (result) |
428 | return result; |
429 | |
430 | if (state == ACPI_STATE_UNKNOWN) { |
431 | state = ACPI_STATE_D0; |
432 | result = acpi_device_set_power(device, state); |
433 | if (result) |
434 | return result; |
435 | } else { |
436 | if (device->power.flags.power_resources) { |
437 | /* |
438 | * We don't need to really switch the state, bu we need |
439 | * to update the power resources' reference counters. |
440 | */ |
441 | result = acpi_power_transition(device, state); |
442 | if (result) |
443 | return result; |
444 | } |
445 | device->power.state = state; |
446 | } |
447 | if (state_p) |
448 | *state_p = state; |
449 | |
450 | return 0; |
451 | } |
452 | EXPORT_SYMBOL_GPL(acpi_device_update_power); |
453 | |
454 | int acpi_bus_update_power(acpi_handle handle, int *state_p) |
455 | { |
456 | struct acpi_device *device = acpi_fetch_acpi_dev(handle); |
457 | |
458 | if (device) |
459 | return acpi_device_update_power(device, state_p); |
460 | |
461 | return -ENODEV; |
462 | } |
463 | EXPORT_SYMBOL_GPL(acpi_bus_update_power); |
464 | |
465 | bool acpi_bus_power_manageable(acpi_handle handle) |
466 | { |
467 | struct acpi_device *device = acpi_fetch_acpi_dev(handle); |
468 | |
469 | return device && device->flags.power_manageable; |
470 | } |
471 | EXPORT_SYMBOL(acpi_bus_power_manageable); |
472 | |
473 | static int acpi_power_up_if_adr_present(struct acpi_device *adev, void *not_used) |
474 | { |
475 | if (!(adev->flags.power_manageable && adev->pnp.type.bus_address)) |
476 | return 0; |
477 | |
478 | acpi_handle_debug(adev->handle, "Power state: %s\n" , |
479 | acpi_power_state_string(adev->power.state)); |
480 | |
481 | if (adev->power.state == ACPI_STATE_D3_COLD) |
482 | return acpi_device_set_power(adev, ACPI_STATE_D0); |
483 | |
484 | return 0; |
485 | } |
486 | |
487 | /** |
488 | * acpi_dev_power_up_children_with_adr - Power up childres with valid _ADR |
489 | * @adev: Parent ACPI device object. |
490 | * |
491 | * Change the power states of the direct children of @adev that are in D3cold |
492 | * and hold valid _ADR objects to D0 in order to allow bus (e.g. PCI) |
493 | * enumeration code to access them. |
494 | */ |
495 | void acpi_dev_power_up_children_with_adr(struct acpi_device *adev) |
496 | { |
497 | acpi_dev_for_each_child(adev, fn: acpi_power_up_if_adr_present, NULL); |
498 | } |
499 | |
500 | /** |
501 | * acpi_dev_power_state_for_wake - Deepest power state for wakeup signaling |
502 | * @adev: ACPI companion of the target device. |
503 | * |
504 | * Evaluate _S0W for @adev and return the value produced by it or return |
505 | * ACPI_STATE_UNKNOWN on errors (including _S0W not present). |
506 | */ |
507 | u8 acpi_dev_power_state_for_wake(struct acpi_device *adev) |
508 | { |
509 | unsigned long long state; |
510 | acpi_status status; |
511 | |
512 | status = acpi_evaluate_integer(handle: adev->handle, pathname: "_S0W" , NULL, data: &state); |
513 | if (ACPI_FAILURE(status)) |
514 | return ACPI_STATE_UNKNOWN; |
515 | |
516 | return state; |
517 | } |
518 | |
519 | #ifdef CONFIG_PM |
520 | static DEFINE_MUTEX(acpi_pm_notifier_lock); |
521 | static DEFINE_MUTEX(acpi_pm_notifier_install_lock); |
522 | |
523 | void acpi_pm_wakeup_event(struct device *dev) |
524 | { |
525 | pm_wakeup_dev_event(dev, msec: 0, hard: acpi_s2idle_wakeup()); |
526 | } |
527 | EXPORT_SYMBOL_GPL(acpi_pm_wakeup_event); |
528 | |
529 | static void acpi_pm_notify_handler(acpi_handle handle, u32 val, void *not_used) |
530 | { |
531 | struct acpi_device *adev; |
532 | |
533 | if (val != ACPI_NOTIFY_DEVICE_WAKE) |
534 | return; |
535 | |
536 | acpi_handle_debug(handle, "Wake notify\n" ); |
537 | |
538 | adev = acpi_get_acpi_dev(handle); |
539 | if (!adev) |
540 | return; |
541 | |
542 | mutex_lock(&acpi_pm_notifier_lock); |
543 | |
544 | if (adev->wakeup.flags.notifier_present) { |
545 | pm_wakeup_ws_event(ws: adev->wakeup.ws, msec: 0, hard: acpi_s2idle_wakeup()); |
546 | if (adev->wakeup.context.func) { |
547 | acpi_handle_debug(handle, "Running %pS for %s\n" , |
548 | adev->wakeup.context.func, |
549 | dev_name(adev->wakeup.context.dev)); |
550 | adev->wakeup.context.func(&adev->wakeup.context); |
551 | } |
552 | } |
553 | |
554 | mutex_unlock(lock: &acpi_pm_notifier_lock); |
555 | |
556 | acpi_put_acpi_dev(adev); |
557 | } |
558 | |
559 | /** |
560 | * acpi_add_pm_notifier - Register PM notify handler for given ACPI device. |
561 | * @adev: ACPI device to add the notify handler for. |
562 | * @dev: Device to generate a wakeup event for while handling the notification. |
563 | * @func: Work function to execute when handling the notification. |
564 | * |
565 | * NOTE: @adev need not be a run-wake or wakeup device to be a valid source of |
566 | * PM wakeup events. For example, wakeup events may be generated for bridges |
567 | * if one of the devices below the bridge is signaling wakeup, even if the |
568 | * bridge itself doesn't have a wakeup GPE associated with it. |
569 | */ |
570 | acpi_status acpi_add_pm_notifier(struct acpi_device *adev, struct device *dev, |
571 | void (*func)(struct acpi_device_wakeup_context *context)) |
572 | { |
573 | acpi_status status = AE_ALREADY_EXISTS; |
574 | |
575 | if (!dev && !func) |
576 | return AE_BAD_PARAMETER; |
577 | |
578 | mutex_lock(&acpi_pm_notifier_install_lock); |
579 | |
580 | if (adev->wakeup.flags.notifier_present) |
581 | goto out; |
582 | |
583 | status = acpi_install_notify_handler(device: adev->handle, ACPI_SYSTEM_NOTIFY, |
584 | handler: acpi_pm_notify_handler, NULL); |
585 | if (ACPI_FAILURE(status)) |
586 | goto out; |
587 | |
588 | mutex_lock(&acpi_pm_notifier_lock); |
589 | adev->wakeup.ws = wakeup_source_register(dev: &adev->dev, |
590 | name: dev_name(dev: &adev->dev)); |
591 | adev->wakeup.context.dev = dev; |
592 | adev->wakeup.context.func = func; |
593 | adev->wakeup.flags.notifier_present = true; |
594 | mutex_unlock(lock: &acpi_pm_notifier_lock); |
595 | |
596 | out: |
597 | mutex_unlock(lock: &acpi_pm_notifier_install_lock); |
598 | return status; |
599 | } |
600 | |
601 | /** |
602 | * acpi_remove_pm_notifier - Unregister PM notifier from given ACPI device. |
603 | * @adev: ACPI device to remove the notifier from. |
604 | */ |
605 | acpi_status acpi_remove_pm_notifier(struct acpi_device *adev) |
606 | { |
607 | acpi_status status = AE_BAD_PARAMETER; |
608 | |
609 | mutex_lock(&acpi_pm_notifier_install_lock); |
610 | |
611 | if (!adev->wakeup.flags.notifier_present) |
612 | goto out; |
613 | |
614 | status = acpi_remove_notify_handler(device: adev->handle, |
615 | ACPI_SYSTEM_NOTIFY, |
616 | handler: acpi_pm_notify_handler); |
617 | if (ACPI_FAILURE(status)) |
618 | goto out; |
619 | |
620 | mutex_lock(&acpi_pm_notifier_lock); |
621 | adev->wakeup.context.func = NULL; |
622 | adev->wakeup.context.dev = NULL; |
623 | wakeup_source_unregister(ws: adev->wakeup.ws); |
624 | adev->wakeup.flags.notifier_present = false; |
625 | mutex_unlock(lock: &acpi_pm_notifier_lock); |
626 | |
627 | out: |
628 | mutex_unlock(lock: &acpi_pm_notifier_install_lock); |
629 | return status; |
630 | } |
631 | |
632 | bool acpi_bus_can_wakeup(acpi_handle handle) |
633 | { |
634 | struct acpi_device *device = acpi_fetch_acpi_dev(handle); |
635 | |
636 | return device && device->wakeup.flags.valid; |
637 | } |
638 | EXPORT_SYMBOL(acpi_bus_can_wakeup); |
639 | |
640 | bool acpi_pm_device_can_wakeup(struct device *dev) |
641 | { |
642 | struct acpi_device *adev = ACPI_COMPANION(dev); |
643 | |
644 | return adev ? acpi_device_can_wakeup(adev) : false; |
645 | } |
646 | |
647 | /** |
648 | * acpi_dev_pm_get_state - Get preferred power state of ACPI device. |
649 | * @dev: Device whose preferred target power state to return. |
650 | * @adev: ACPI device node corresponding to @dev. |
651 | * @target_state: System state to match the resultant device state. |
652 | * @d_min_p: Location to store the highest power state available to the device. |
653 | * @d_max_p: Location to store the lowest power state available to the device. |
654 | * |
655 | * Find the lowest power (highest number) and highest power (lowest number) ACPI |
656 | * device power states that the device can be in while the system is in the |
657 | * state represented by @target_state. Store the integer numbers representing |
658 | * those stats in the memory locations pointed to by @d_max_p and @d_min_p, |
659 | * respectively. |
660 | * |
661 | * Callers must ensure that @dev and @adev are valid pointers and that @adev |
662 | * actually corresponds to @dev before using this function. |
663 | * |
664 | * Returns 0 on success or -ENODATA when one of the ACPI methods fails or |
665 | * returns a value that doesn't make sense. The memory locations pointed to by |
666 | * @d_max_p and @d_min_p are only modified on success. |
667 | */ |
668 | static int acpi_dev_pm_get_state(struct device *dev, struct acpi_device *adev, |
669 | u32 target_state, int *d_min_p, int *d_max_p) |
670 | { |
671 | char method[] = { '_', 'S', '0' + target_state, 'D', '\0' }; |
672 | acpi_handle handle = adev->handle; |
673 | unsigned long long ret; |
674 | int d_min, d_max; |
675 | bool wakeup = false; |
676 | bool has_sxd = false; |
677 | acpi_status status; |
678 | |
679 | /* |
680 | * If the system state is S0, the lowest power state the device can be |
681 | * in is D3cold, unless the device has _S0W and is supposed to signal |
682 | * wakeup, in which case the return value of _S0W has to be used as the |
683 | * lowest power state available to the device. |
684 | */ |
685 | d_min = ACPI_STATE_D0; |
686 | d_max = ACPI_STATE_D3_COLD; |
687 | |
688 | /* |
689 | * If present, _SxD methods return the minimum D-state (highest power |
690 | * state) we can use for the corresponding S-states. Otherwise, the |
691 | * minimum D-state is D0 (ACPI 3.x). |
692 | */ |
693 | if (target_state > ACPI_STATE_S0) { |
694 | /* |
695 | * We rely on acpi_evaluate_integer() not clobbering the integer |
696 | * provided if AE_NOT_FOUND is returned. |
697 | */ |
698 | ret = d_min; |
699 | status = acpi_evaluate_integer(handle, pathname: method, NULL, data: &ret); |
700 | if ((ACPI_FAILURE(status) && status != AE_NOT_FOUND) |
701 | || ret > ACPI_STATE_D3_COLD) |
702 | return -ENODATA; |
703 | |
704 | /* |
705 | * We need to handle legacy systems where D3hot and D3cold are |
706 | * the same and 3 is returned in both cases, so fall back to |
707 | * D3cold if D3hot is not a valid state. |
708 | */ |
709 | if (!adev->power.states[ret].flags.valid) { |
710 | if (ret == ACPI_STATE_D3_HOT) |
711 | ret = ACPI_STATE_D3_COLD; |
712 | else |
713 | return -ENODATA; |
714 | } |
715 | |
716 | if (status == AE_OK) |
717 | has_sxd = true; |
718 | |
719 | d_min = ret; |
720 | wakeup = device_may_wakeup(dev) && adev->wakeup.flags.valid |
721 | && adev->wakeup.sleep_state >= target_state; |
722 | } else if (device_may_wakeup(dev) && dev->power.wakeirq) { |
723 | /* |
724 | * The ACPI subsystem doesn't manage the wake bit for IRQs |
725 | * defined with ExclusiveAndWake and SharedAndWake. Instead we |
726 | * expect them to be managed via the PM subsystem. Drivers |
727 | * should call dev_pm_set_wake_irq to register an IRQ as a wake |
728 | * source. |
729 | * |
730 | * If a device has a wake IRQ attached we need to check the |
731 | * _S0W method to get the correct wake D-state. Otherwise we |
732 | * end up putting the device into D3Cold which will more than |
733 | * likely disable wake functionality. |
734 | */ |
735 | wakeup = true; |
736 | } else { |
737 | /* ACPI GPE is specified in _PRW. */ |
738 | wakeup = adev->wakeup.flags.valid; |
739 | } |
740 | |
741 | /* |
742 | * If _PRW says we can wake up the system from the target sleep state, |
743 | * the D-state returned by _SxD is sufficient for that (we assume a |
744 | * wakeup-aware driver if wake is set). Still, if _SxW exists |
745 | * (ACPI 3.x), it should return the maximum (lowest power) D-state that |
746 | * can wake the system. _S0W may be valid, too. |
747 | */ |
748 | if (wakeup) { |
749 | method[3] = 'W'; |
750 | status = acpi_evaluate_integer(handle, pathname: method, NULL, data: &ret); |
751 | if (status == AE_NOT_FOUND) { |
752 | /* No _SxW. In this case, the ACPI spec says that we |
753 | * must not go into any power state deeper than the |
754 | * value returned from _SxD. |
755 | */ |
756 | if (has_sxd && target_state > ACPI_STATE_S0) |
757 | d_max = d_min; |
758 | } else if (ACPI_SUCCESS(status) && ret <= ACPI_STATE_D3_COLD) { |
759 | /* Fall back to D3cold if ret is not a valid state. */ |
760 | if (!adev->power.states[ret].flags.valid) |
761 | ret = ACPI_STATE_D3_COLD; |
762 | |
763 | d_max = ret > d_min ? ret : d_min; |
764 | } else { |
765 | return -ENODATA; |
766 | } |
767 | } |
768 | |
769 | if (d_min_p) |
770 | *d_min_p = d_min; |
771 | |
772 | if (d_max_p) |
773 | *d_max_p = d_max; |
774 | |
775 | return 0; |
776 | } |
777 | |
778 | /** |
779 | * acpi_pm_device_sleep_state - Get preferred power state of ACPI device. |
780 | * @dev: Device whose preferred target power state to return. |
781 | * @d_min_p: Location to store the upper limit of the allowed states range. |
782 | * @d_max_in: Deepest low-power state to take into consideration. |
783 | * Return value: Preferred power state of the device on success, -ENODEV |
784 | * if there's no 'struct acpi_device' for @dev, -EINVAL if @d_max_in is |
785 | * incorrect, or -ENODATA on ACPI method failure. |
786 | * |
787 | * The caller must ensure that @dev is valid before using this function. |
788 | */ |
789 | int acpi_pm_device_sleep_state(struct device *dev, int *d_min_p, int d_max_in) |
790 | { |
791 | struct acpi_device *adev; |
792 | int ret, d_min, d_max; |
793 | |
794 | if (d_max_in < ACPI_STATE_D0 || d_max_in > ACPI_STATE_D3_COLD) |
795 | return -EINVAL; |
796 | |
797 | if (d_max_in > ACPI_STATE_D2) { |
798 | enum pm_qos_flags_status stat; |
799 | |
800 | stat = dev_pm_qos_flags(dev, PM_QOS_FLAG_NO_POWER_OFF); |
801 | if (stat == PM_QOS_FLAGS_ALL) |
802 | d_max_in = ACPI_STATE_D2; |
803 | } |
804 | |
805 | adev = ACPI_COMPANION(dev); |
806 | if (!adev) { |
807 | dev_dbg(dev, "ACPI companion missing in %s!\n" , __func__); |
808 | return -ENODEV; |
809 | } |
810 | |
811 | ret = acpi_dev_pm_get_state(dev, adev, target_state: acpi_target_system_state(), |
812 | d_min_p: &d_min, d_max_p: &d_max); |
813 | if (ret) |
814 | return ret; |
815 | |
816 | if (d_max_in < d_min) |
817 | return -EINVAL; |
818 | |
819 | if (d_max > d_max_in) { |
820 | for (d_max = d_max_in; d_max > d_min; d_max--) { |
821 | if (adev->power.states[d_max].flags.valid) |
822 | break; |
823 | } |
824 | } |
825 | |
826 | if (d_min_p) |
827 | *d_min_p = d_min; |
828 | |
829 | return d_max; |
830 | } |
831 | EXPORT_SYMBOL(acpi_pm_device_sleep_state); |
832 | |
833 | /** |
834 | * acpi_pm_notify_work_func - ACPI devices wakeup notification work function. |
835 | * @context: Device wakeup context. |
836 | */ |
837 | static void acpi_pm_notify_work_func(struct acpi_device_wakeup_context *context) |
838 | { |
839 | struct device *dev = context->dev; |
840 | |
841 | if (dev) { |
842 | pm_wakeup_event(dev, msec: 0); |
843 | pm_request_resume(dev); |
844 | } |
845 | } |
846 | |
847 | static DEFINE_MUTEX(acpi_wakeup_lock); |
848 | |
849 | static int __acpi_device_wakeup_enable(struct acpi_device *adev, |
850 | u32 target_state) |
851 | { |
852 | struct acpi_device_wakeup *wakeup = &adev->wakeup; |
853 | acpi_status status; |
854 | int error = 0; |
855 | |
856 | mutex_lock(&acpi_wakeup_lock); |
857 | |
858 | /* |
859 | * If the device wakeup power is already enabled, disable it and enable |
860 | * it again in case it depends on the configuration of subordinate |
861 | * devices and the conditions have changed since it was enabled last |
862 | * time. |
863 | */ |
864 | if (wakeup->enable_count > 0) |
865 | acpi_disable_wakeup_device_power(dev: adev); |
866 | |
867 | error = acpi_enable_wakeup_device_power(dev: adev, state: target_state); |
868 | if (error) { |
869 | if (wakeup->enable_count > 0) { |
870 | acpi_disable_gpe(gpe_device: wakeup->gpe_device, gpe_number: wakeup->gpe_number); |
871 | wakeup->enable_count = 0; |
872 | } |
873 | goto out; |
874 | } |
875 | |
876 | if (wakeup->enable_count > 0) |
877 | goto inc; |
878 | |
879 | status = acpi_enable_gpe(gpe_device: wakeup->gpe_device, gpe_number: wakeup->gpe_number); |
880 | if (ACPI_FAILURE(status)) { |
881 | acpi_disable_wakeup_device_power(dev: adev); |
882 | error = -EIO; |
883 | goto out; |
884 | } |
885 | |
886 | acpi_handle_debug(adev->handle, "GPE%2X enabled for wakeup\n" , |
887 | (unsigned int)wakeup->gpe_number); |
888 | |
889 | inc: |
890 | if (wakeup->enable_count < INT_MAX) |
891 | wakeup->enable_count++; |
892 | else |
893 | acpi_handle_info(adev->handle, "Wakeup enable count out of bounds!\n" ); |
894 | |
895 | out: |
896 | mutex_unlock(lock: &acpi_wakeup_lock); |
897 | return error; |
898 | } |
899 | |
900 | /** |
901 | * acpi_device_wakeup_enable - Enable wakeup functionality for device. |
902 | * @adev: ACPI device to enable wakeup functionality for. |
903 | * @target_state: State the system is transitioning into. |
904 | * |
905 | * Enable the GPE associated with @adev so that it can generate wakeup signals |
906 | * for the device in response to external (remote) events and enable wakeup |
907 | * power for it. |
908 | * |
909 | * Callers must ensure that @adev is a valid ACPI device node before executing |
910 | * this function. |
911 | */ |
912 | static int acpi_device_wakeup_enable(struct acpi_device *adev, u32 target_state) |
913 | { |
914 | return __acpi_device_wakeup_enable(adev, target_state); |
915 | } |
916 | |
917 | /** |
918 | * acpi_device_wakeup_disable - Disable wakeup functionality for device. |
919 | * @adev: ACPI device to disable wakeup functionality for. |
920 | * |
921 | * Disable the GPE associated with @adev and disable wakeup power for it. |
922 | * |
923 | * Callers must ensure that @adev is a valid ACPI device node before executing |
924 | * this function. |
925 | */ |
926 | static void acpi_device_wakeup_disable(struct acpi_device *adev) |
927 | { |
928 | struct acpi_device_wakeup *wakeup = &adev->wakeup; |
929 | |
930 | mutex_lock(&acpi_wakeup_lock); |
931 | |
932 | if (!wakeup->enable_count) |
933 | goto out; |
934 | |
935 | acpi_disable_gpe(gpe_device: wakeup->gpe_device, gpe_number: wakeup->gpe_number); |
936 | acpi_disable_wakeup_device_power(dev: adev); |
937 | |
938 | wakeup->enable_count--; |
939 | |
940 | out: |
941 | mutex_unlock(lock: &acpi_wakeup_lock); |
942 | } |
943 | |
944 | /** |
945 | * acpi_pm_set_device_wakeup - Enable/disable remote wakeup for given device. |
946 | * @dev: Device to enable/disable to generate wakeup events. |
947 | * @enable: Whether to enable or disable the wakeup functionality. |
948 | */ |
949 | int acpi_pm_set_device_wakeup(struct device *dev, bool enable) |
950 | { |
951 | struct acpi_device *adev; |
952 | int error; |
953 | |
954 | adev = ACPI_COMPANION(dev); |
955 | if (!adev) { |
956 | dev_dbg(dev, "ACPI companion missing in %s!\n" , __func__); |
957 | return -ENODEV; |
958 | } |
959 | |
960 | if (!acpi_device_can_wakeup(adev)) |
961 | return -EINVAL; |
962 | |
963 | if (!enable) { |
964 | acpi_device_wakeup_disable(adev); |
965 | dev_dbg(dev, "Wakeup disabled by ACPI\n" ); |
966 | return 0; |
967 | } |
968 | |
969 | error = __acpi_device_wakeup_enable(adev, target_state: acpi_target_system_state()); |
970 | if (!error) |
971 | dev_dbg(dev, "Wakeup enabled by ACPI\n" ); |
972 | |
973 | return error; |
974 | } |
975 | EXPORT_SYMBOL_GPL(acpi_pm_set_device_wakeup); |
976 | |
977 | /** |
978 | * acpi_dev_pm_low_power - Put ACPI device into a low-power state. |
979 | * @dev: Device to put into a low-power state. |
980 | * @adev: ACPI device node corresponding to @dev. |
981 | * @system_state: System state to choose the device state for. |
982 | */ |
983 | static int acpi_dev_pm_low_power(struct device *dev, struct acpi_device *adev, |
984 | u32 system_state) |
985 | { |
986 | int ret, state; |
987 | |
988 | if (!acpi_device_power_manageable(adev)) |
989 | return 0; |
990 | |
991 | ret = acpi_dev_pm_get_state(dev, adev, target_state: system_state, NULL, d_max_p: &state); |
992 | return ret ? ret : acpi_device_set_power(adev, state); |
993 | } |
994 | |
995 | /** |
996 | * acpi_dev_pm_full_power - Put ACPI device into the full-power state. |
997 | * @adev: ACPI device node to put into the full-power state. |
998 | */ |
999 | static int acpi_dev_pm_full_power(struct acpi_device *adev) |
1000 | { |
1001 | return acpi_device_power_manageable(adev) ? |
1002 | acpi_device_set_power(adev, ACPI_STATE_D0) : 0; |
1003 | } |
1004 | |
1005 | /** |
1006 | * acpi_dev_suspend - Put device into a low-power state using ACPI. |
1007 | * @dev: Device to put into a low-power state. |
1008 | * @wakeup: Whether or not to enable wakeup for the device. |
1009 | * |
1010 | * Put the given device into a low-power state using the standard ACPI |
1011 | * mechanism. Set up remote wakeup if desired, choose the state to put the |
1012 | * device into (this checks if remote wakeup is expected to work too), and set |
1013 | * the power state of the device. |
1014 | */ |
1015 | int acpi_dev_suspend(struct device *dev, bool wakeup) |
1016 | { |
1017 | struct acpi_device *adev = ACPI_COMPANION(dev); |
1018 | u32 target_state = acpi_target_system_state(); |
1019 | int error; |
1020 | |
1021 | if (!adev) |
1022 | return 0; |
1023 | |
1024 | if (wakeup && acpi_device_can_wakeup(adev)) { |
1025 | error = acpi_device_wakeup_enable(adev, target_state); |
1026 | if (error) |
1027 | return -EAGAIN; |
1028 | } else { |
1029 | wakeup = false; |
1030 | } |
1031 | |
1032 | error = acpi_dev_pm_low_power(dev, adev, system_state: target_state); |
1033 | if (error && wakeup) |
1034 | acpi_device_wakeup_disable(adev); |
1035 | |
1036 | return error; |
1037 | } |
1038 | EXPORT_SYMBOL_GPL(acpi_dev_suspend); |
1039 | |
1040 | /** |
1041 | * acpi_dev_resume - Put device into the full-power state using ACPI. |
1042 | * @dev: Device to put into the full-power state. |
1043 | * |
1044 | * Put the given device into the full-power state using the standard ACPI |
1045 | * mechanism. Set the power state of the device to ACPI D0 and disable wakeup. |
1046 | */ |
1047 | int acpi_dev_resume(struct device *dev) |
1048 | { |
1049 | struct acpi_device *adev = ACPI_COMPANION(dev); |
1050 | int error; |
1051 | |
1052 | if (!adev) |
1053 | return 0; |
1054 | |
1055 | error = acpi_dev_pm_full_power(adev); |
1056 | acpi_device_wakeup_disable(adev); |
1057 | return error; |
1058 | } |
1059 | EXPORT_SYMBOL_GPL(acpi_dev_resume); |
1060 | |
1061 | /** |
1062 | * acpi_subsys_runtime_suspend - Suspend device using ACPI. |
1063 | * @dev: Device to suspend. |
1064 | * |
1065 | * Carry out the generic runtime suspend procedure for @dev and use ACPI to put |
1066 | * it into a runtime low-power state. |
1067 | */ |
1068 | int acpi_subsys_runtime_suspend(struct device *dev) |
1069 | { |
1070 | int ret = pm_generic_runtime_suspend(dev); |
1071 | |
1072 | return ret ? ret : acpi_dev_suspend(dev, true); |
1073 | } |
1074 | EXPORT_SYMBOL_GPL(acpi_subsys_runtime_suspend); |
1075 | |
1076 | /** |
1077 | * acpi_subsys_runtime_resume - Resume device using ACPI. |
1078 | * @dev: Device to Resume. |
1079 | * |
1080 | * Use ACPI to put the given device into the full-power state and carry out the |
1081 | * generic runtime resume procedure for it. |
1082 | */ |
1083 | int acpi_subsys_runtime_resume(struct device *dev) |
1084 | { |
1085 | int ret = acpi_dev_resume(dev); |
1086 | |
1087 | return ret ? ret : pm_generic_runtime_resume(dev); |
1088 | } |
1089 | EXPORT_SYMBOL_GPL(acpi_subsys_runtime_resume); |
1090 | |
1091 | #ifdef CONFIG_PM_SLEEP |
1092 | static bool acpi_dev_needs_resume(struct device *dev, struct acpi_device *adev) |
1093 | { |
1094 | u32 sys_target = acpi_target_system_state(); |
1095 | int ret, state; |
1096 | |
1097 | if (!pm_runtime_suspended(dev) || !adev || (adev->wakeup.flags.valid && |
1098 | device_may_wakeup(dev) != !!adev->wakeup.prepare_count)) |
1099 | return true; |
1100 | |
1101 | if (sys_target == ACPI_STATE_S0) |
1102 | return false; |
1103 | |
1104 | if (adev->power.flags.dsw_present) |
1105 | return true; |
1106 | |
1107 | ret = acpi_dev_pm_get_state(dev, adev, target_state: sys_target, NULL, d_max_p: &state); |
1108 | if (ret) |
1109 | return true; |
1110 | |
1111 | return state != adev->power.state; |
1112 | } |
1113 | |
1114 | /** |
1115 | * acpi_subsys_prepare - Prepare device for system transition to a sleep state. |
1116 | * @dev: Device to prepare. |
1117 | */ |
1118 | int acpi_subsys_prepare(struct device *dev) |
1119 | { |
1120 | struct acpi_device *adev = ACPI_COMPANION(dev); |
1121 | |
1122 | if (dev->driver && dev->driver->pm && dev->driver->pm->prepare) { |
1123 | int ret = dev->driver->pm->prepare(dev); |
1124 | |
1125 | if (ret < 0) |
1126 | return ret; |
1127 | |
1128 | if (!ret && dev_pm_test_driver_flags(dev, DPM_FLAG_SMART_PREPARE)) |
1129 | return 0; |
1130 | } |
1131 | |
1132 | return !acpi_dev_needs_resume(dev, adev); |
1133 | } |
1134 | EXPORT_SYMBOL_GPL(acpi_subsys_prepare); |
1135 | |
1136 | /** |
1137 | * acpi_subsys_complete - Finalize device's resume during system resume. |
1138 | * @dev: Device to handle. |
1139 | */ |
1140 | void acpi_subsys_complete(struct device *dev) |
1141 | { |
1142 | pm_generic_complete(dev); |
1143 | /* |
1144 | * If the device had been runtime-suspended before the system went into |
1145 | * the sleep state it is going out of and it has never been resumed till |
1146 | * now, resume it in case the firmware powered it up. |
1147 | */ |
1148 | if (pm_runtime_suspended(dev) && pm_resume_via_firmware()) |
1149 | pm_request_resume(dev); |
1150 | } |
1151 | EXPORT_SYMBOL_GPL(acpi_subsys_complete); |
1152 | |
1153 | /** |
1154 | * acpi_subsys_suspend - Run the device driver's suspend callback. |
1155 | * @dev: Device to handle. |
1156 | * |
1157 | * Follow PCI and resume devices from runtime suspend before running their |
1158 | * system suspend callbacks, unless the driver can cope with runtime-suspended |
1159 | * devices during system suspend and there are no ACPI-specific reasons for |
1160 | * resuming them. |
1161 | */ |
1162 | int acpi_subsys_suspend(struct device *dev) |
1163 | { |
1164 | if (!dev_pm_test_driver_flags(dev, DPM_FLAG_SMART_SUSPEND) || |
1165 | acpi_dev_needs_resume(dev, ACPI_COMPANION(dev))) |
1166 | pm_runtime_resume(dev); |
1167 | |
1168 | return pm_generic_suspend(dev); |
1169 | } |
1170 | EXPORT_SYMBOL_GPL(acpi_subsys_suspend); |
1171 | |
1172 | /** |
1173 | * acpi_subsys_suspend_late - Suspend device using ACPI. |
1174 | * @dev: Device to suspend. |
1175 | * |
1176 | * Carry out the generic late suspend procedure for @dev and use ACPI to put |
1177 | * it into a low-power state during system transition into a sleep state. |
1178 | */ |
1179 | int acpi_subsys_suspend_late(struct device *dev) |
1180 | { |
1181 | int ret; |
1182 | |
1183 | if (dev_pm_skip_suspend(dev)) |
1184 | return 0; |
1185 | |
1186 | ret = pm_generic_suspend_late(dev); |
1187 | return ret ? ret : acpi_dev_suspend(dev, device_may_wakeup(dev)); |
1188 | } |
1189 | EXPORT_SYMBOL_GPL(acpi_subsys_suspend_late); |
1190 | |
1191 | /** |
1192 | * acpi_subsys_suspend_noirq - Run the device driver's "noirq" suspend callback. |
1193 | * @dev: Device to suspend. |
1194 | */ |
1195 | int acpi_subsys_suspend_noirq(struct device *dev) |
1196 | { |
1197 | int ret; |
1198 | |
1199 | if (dev_pm_skip_suspend(dev)) |
1200 | return 0; |
1201 | |
1202 | ret = pm_generic_suspend_noirq(dev); |
1203 | if (ret) |
1204 | return ret; |
1205 | |
1206 | /* |
1207 | * If the target system sleep state is suspend-to-idle, it is sufficient |
1208 | * to check whether or not the device's wakeup settings are good for |
1209 | * runtime PM. Otherwise, the pm_resume_via_firmware() check will cause |
1210 | * acpi_subsys_complete() to take care of fixing up the device's state |
1211 | * anyway, if need be. |
1212 | */ |
1213 | if (device_can_wakeup(dev) && !device_may_wakeup(dev)) |
1214 | dev->power.may_skip_resume = false; |
1215 | |
1216 | return 0; |
1217 | } |
1218 | EXPORT_SYMBOL_GPL(acpi_subsys_suspend_noirq); |
1219 | |
1220 | /** |
1221 | * acpi_subsys_resume_noirq - Run the device driver's "noirq" resume callback. |
1222 | * @dev: Device to handle. |
1223 | */ |
1224 | static int acpi_subsys_resume_noirq(struct device *dev) |
1225 | { |
1226 | if (dev_pm_skip_resume(dev)) |
1227 | return 0; |
1228 | |
1229 | return pm_generic_resume_noirq(dev); |
1230 | } |
1231 | |
1232 | /** |
1233 | * acpi_subsys_resume_early - Resume device using ACPI. |
1234 | * @dev: Device to Resume. |
1235 | * |
1236 | * Use ACPI to put the given device into the full-power state and carry out the |
1237 | * generic early resume procedure for it during system transition into the |
1238 | * working state, but only do that if device either defines early resume |
1239 | * handler, or does not define power operations at all. Otherwise powering up |
1240 | * of the device is postponed to the normal resume phase. |
1241 | */ |
1242 | static int acpi_subsys_resume_early(struct device *dev) |
1243 | { |
1244 | const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL; |
1245 | int ret; |
1246 | |
1247 | if (dev_pm_skip_resume(dev)) |
1248 | return 0; |
1249 | |
1250 | if (pm && !pm->resume_early) { |
1251 | dev_dbg(dev, "postponing D0 transition to normal resume stage\n" ); |
1252 | return 0; |
1253 | } |
1254 | |
1255 | ret = acpi_dev_resume(dev); |
1256 | return ret ? ret : pm_generic_resume_early(dev); |
1257 | } |
1258 | |
1259 | /** |
1260 | * acpi_subsys_resume - Resume device using ACPI. |
1261 | * @dev: Device to Resume. |
1262 | * |
1263 | * Use ACPI to put the given device into the full-power state if it has not been |
1264 | * powered up during early resume phase, and carry out the generic resume |
1265 | * procedure for it during system transition into the working state. |
1266 | */ |
1267 | static int acpi_subsys_resume(struct device *dev) |
1268 | { |
1269 | const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL; |
1270 | int ret = 0; |
1271 | |
1272 | if (!dev_pm_skip_resume(dev) && pm && !pm->resume_early) { |
1273 | dev_dbg(dev, "executing postponed D0 transition\n" ); |
1274 | ret = acpi_dev_resume(dev); |
1275 | } |
1276 | |
1277 | return ret ? ret : pm_generic_resume(dev); |
1278 | } |
1279 | |
1280 | /** |
1281 | * acpi_subsys_freeze - Run the device driver's freeze callback. |
1282 | * @dev: Device to handle. |
1283 | */ |
1284 | int acpi_subsys_freeze(struct device *dev) |
1285 | { |
1286 | /* |
1287 | * Resume all runtime-suspended devices before creating a snapshot |
1288 | * image of system memory, because the restore kernel generally cannot |
1289 | * be expected to always handle them consistently and they need to be |
1290 | * put into the runtime-active metastate during system resume anyway, |
1291 | * so it is better to ensure that the state saved in the image will be |
1292 | * always consistent with that. |
1293 | */ |
1294 | pm_runtime_resume(dev); |
1295 | |
1296 | return pm_generic_freeze(dev); |
1297 | } |
1298 | EXPORT_SYMBOL_GPL(acpi_subsys_freeze); |
1299 | |
1300 | /** |
1301 | * acpi_subsys_restore_early - Restore device using ACPI. |
1302 | * @dev: Device to restore. |
1303 | */ |
1304 | int acpi_subsys_restore_early(struct device *dev) |
1305 | { |
1306 | int ret = acpi_dev_resume(dev); |
1307 | |
1308 | return ret ? ret : pm_generic_restore_early(dev); |
1309 | } |
1310 | EXPORT_SYMBOL_GPL(acpi_subsys_restore_early); |
1311 | |
1312 | /** |
1313 | * acpi_subsys_poweroff - Run the device driver's poweroff callback. |
1314 | * @dev: Device to handle. |
1315 | * |
1316 | * Follow PCI and resume devices from runtime suspend before running their |
1317 | * system poweroff callbacks, unless the driver can cope with runtime-suspended |
1318 | * devices during system suspend and there are no ACPI-specific reasons for |
1319 | * resuming them. |
1320 | */ |
1321 | int acpi_subsys_poweroff(struct device *dev) |
1322 | { |
1323 | if (!dev_pm_test_driver_flags(dev, DPM_FLAG_SMART_SUSPEND) || |
1324 | acpi_dev_needs_resume(dev, ACPI_COMPANION(dev))) |
1325 | pm_runtime_resume(dev); |
1326 | |
1327 | return pm_generic_poweroff(dev); |
1328 | } |
1329 | EXPORT_SYMBOL_GPL(acpi_subsys_poweroff); |
1330 | |
1331 | /** |
1332 | * acpi_subsys_poweroff_late - Run the device driver's poweroff callback. |
1333 | * @dev: Device to handle. |
1334 | * |
1335 | * Carry out the generic late poweroff procedure for @dev and use ACPI to put |
1336 | * it into a low-power state during system transition into a sleep state. |
1337 | */ |
1338 | static int acpi_subsys_poweroff_late(struct device *dev) |
1339 | { |
1340 | int ret; |
1341 | |
1342 | if (dev_pm_skip_suspend(dev)) |
1343 | return 0; |
1344 | |
1345 | ret = pm_generic_poweroff_late(dev); |
1346 | if (ret) |
1347 | return ret; |
1348 | |
1349 | return acpi_dev_suspend(dev, device_may_wakeup(dev)); |
1350 | } |
1351 | |
1352 | /** |
1353 | * acpi_subsys_poweroff_noirq - Run the driver's "noirq" poweroff callback. |
1354 | * @dev: Device to suspend. |
1355 | */ |
1356 | static int acpi_subsys_poweroff_noirq(struct device *dev) |
1357 | { |
1358 | if (dev_pm_skip_suspend(dev)) |
1359 | return 0; |
1360 | |
1361 | return pm_generic_poweroff_noirq(dev); |
1362 | } |
1363 | #endif /* CONFIG_PM_SLEEP */ |
1364 | |
1365 | static struct dev_pm_domain acpi_general_pm_domain = { |
1366 | .ops = { |
1367 | .runtime_suspend = acpi_subsys_runtime_suspend, |
1368 | .runtime_resume = acpi_subsys_runtime_resume, |
1369 | #ifdef CONFIG_PM_SLEEP |
1370 | .prepare = acpi_subsys_prepare, |
1371 | .complete = acpi_subsys_complete, |
1372 | .suspend = acpi_subsys_suspend, |
1373 | .resume = acpi_subsys_resume, |
1374 | .suspend_late = acpi_subsys_suspend_late, |
1375 | .suspend_noirq = acpi_subsys_suspend_noirq, |
1376 | .resume_noirq = acpi_subsys_resume_noirq, |
1377 | .resume_early = acpi_subsys_resume_early, |
1378 | .freeze = acpi_subsys_freeze, |
1379 | .poweroff = acpi_subsys_poweroff, |
1380 | .poweroff_late = acpi_subsys_poweroff_late, |
1381 | .poweroff_noirq = acpi_subsys_poweroff_noirq, |
1382 | .restore_early = acpi_subsys_restore_early, |
1383 | #endif |
1384 | }, |
1385 | }; |
1386 | |
1387 | /** |
1388 | * acpi_dev_pm_detach - Remove ACPI power management from the device. |
1389 | * @dev: Device to take care of. |
1390 | * @power_off: Whether or not to try to remove power from the device. |
1391 | * |
1392 | * Remove the device from the general ACPI PM domain and remove its wakeup |
1393 | * notifier. If @power_off is set, additionally remove power from the device if |
1394 | * possible. |
1395 | * |
1396 | * Callers must ensure proper synchronization of this function with power |
1397 | * management callbacks. |
1398 | */ |
1399 | static void acpi_dev_pm_detach(struct device *dev, bool power_off) |
1400 | { |
1401 | struct acpi_device *adev = ACPI_COMPANION(dev); |
1402 | |
1403 | if (adev && dev->pm_domain == &acpi_general_pm_domain) { |
1404 | dev_pm_domain_set(dev, NULL); |
1405 | acpi_remove_pm_notifier(adev); |
1406 | if (power_off) { |
1407 | /* |
1408 | * If the device's PM QoS resume latency limit or flags |
1409 | * have been exposed to user space, they have to be |
1410 | * hidden at this point, so that they don't affect the |
1411 | * choice of the low-power state to put the device into. |
1412 | */ |
1413 | dev_pm_qos_hide_latency_limit(dev); |
1414 | dev_pm_qos_hide_flags(dev); |
1415 | acpi_device_wakeup_disable(adev); |
1416 | acpi_dev_pm_low_power(dev, adev, ACPI_STATE_S0); |
1417 | } |
1418 | } |
1419 | } |
1420 | |
1421 | /** |
1422 | * acpi_dev_pm_attach - Prepare device for ACPI power management. |
1423 | * @dev: Device to prepare. |
1424 | * @power_on: Whether or not to power on the device. |
1425 | * |
1426 | * If @dev has a valid ACPI handle that has a valid struct acpi_device object |
1427 | * attached to it, install a wakeup notification handler for the device and |
1428 | * add it to the general ACPI PM domain. If @power_on is set, the device will |
1429 | * be put into the ACPI D0 state before the function returns. |
1430 | * |
1431 | * This assumes that the @dev's bus type uses generic power management callbacks |
1432 | * (or doesn't use any power management callbacks at all). |
1433 | * |
1434 | * Callers must ensure proper synchronization of this function with power |
1435 | * management callbacks. |
1436 | */ |
1437 | int acpi_dev_pm_attach(struct device *dev, bool power_on) |
1438 | { |
1439 | /* |
1440 | * Skip devices whose ACPI companions match the device IDs below, |
1441 | * because they require special power management handling incompatible |
1442 | * with the generic ACPI PM domain. |
1443 | */ |
1444 | static const struct acpi_device_id special_pm_ids[] = { |
1445 | ACPI_FAN_DEVICE_IDS, |
1446 | {} |
1447 | }; |
1448 | struct acpi_device *adev = ACPI_COMPANION(dev); |
1449 | |
1450 | if (!adev || !acpi_match_device_ids(device: adev, ids: special_pm_ids)) |
1451 | return 0; |
1452 | |
1453 | /* |
1454 | * Only attach the power domain to the first device if the |
1455 | * companion is shared by multiple. This is to prevent doing power |
1456 | * management twice. |
1457 | */ |
1458 | if (!acpi_device_is_first_physical_node(adev, dev)) |
1459 | return 0; |
1460 | |
1461 | acpi_add_pm_notifier(adev, dev, func: acpi_pm_notify_work_func); |
1462 | dev_pm_domain_set(dev, pd: &acpi_general_pm_domain); |
1463 | if (power_on) { |
1464 | acpi_dev_pm_full_power(adev); |
1465 | acpi_device_wakeup_disable(adev); |
1466 | } |
1467 | |
1468 | dev->pm_domain->detach = acpi_dev_pm_detach; |
1469 | return 1; |
1470 | } |
1471 | EXPORT_SYMBOL_GPL(acpi_dev_pm_attach); |
1472 | |
1473 | /** |
1474 | * acpi_storage_d3 - Check if D3 should be used in the suspend path |
1475 | * @dev: Device to check |
1476 | * |
1477 | * Return %true if the platform firmware wants @dev to be programmed |
1478 | * into D3hot or D3cold (if supported) in the suspend path, or %false |
1479 | * when there is no specific preference. On some platforms, if this |
1480 | * hint is ignored, @dev may remain unresponsive after suspending the |
1481 | * platform as a whole. |
1482 | * |
1483 | * Although the property has storage in the name it actually is |
1484 | * applied to the PCIe slot and plugging in a non-storage device the |
1485 | * same platform restrictions will likely apply. |
1486 | */ |
1487 | bool acpi_storage_d3(struct device *dev) |
1488 | { |
1489 | struct acpi_device *adev = ACPI_COMPANION(dev); |
1490 | u8 val; |
1491 | |
1492 | if (force_storage_d3()) |
1493 | return true; |
1494 | |
1495 | if (!adev) |
1496 | return false; |
1497 | if (fwnode_property_read_u8(fwnode: acpi_fwnode_handle(adev), propname: "StorageD3Enable" , |
1498 | val: &val)) |
1499 | return false; |
1500 | return val == 1; |
1501 | } |
1502 | EXPORT_SYMBOL_GPL(acpi_storage_d3); |
1503 | |
1504 | /** |
1505 | * acpi_dev_state_d0 - Tell if the device is in D0 power state |
1506 | * @dev: Physical device the ACPI power state of which to check |
1507 | * |
1508 | * On a system without ACPI, return true. On a system with ACPI, return true if |
1509 | * the current ACPI power state of the device is D0, or false otherwise. |
1510 | * |
1511 | * Note that the power state of a device is not well-defined after it has been |
1512 | * passed to acpi_device_set_power() and before that function returns, so it is |
1513 | * not valid to ask for the ACPI power state of the device in that time frame. |
1514 | * |
1515 | * This function is intended to be used in a driver's probe or remove |
1516 | * function. See Documentation/firmware-guide/acpi/non-d0-probe.rst for |
1517 | * more information. |
1518 | */ |
1519 | bool acpi_dev_state_d0(struct device *dev) |
1520 | { |
1521 | struct acpi_device *adev = ACPI_COMPANION(dev); |
1522 | |
1523 | if (!adev) |
1524 | return true; |
1525 | |
1526 | return adev->power.state == ACPI_STATE_D0; |
1527 | } |
1528 | EXPORT_SYMBOL_GPL(acpi_dev_state_d0); |
1529 | |
1530 | #endif /* CONFIG_PM */ |
1531 | |