xref: /openbmc/linux/drivers/acpi/power.c (revision 9659281c)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * drivers/acpi/power.c - ACPI Power Resources management.
4  *
5  * Copyright (C) 2001 - 2015 Intel Corp.
6  * Author: Andy Grover <andrew.grover@intel.com>
7  * Author: Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
8  * Author: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
9  */
10 
11 /*
12  * ACPI power-managed devices may be controlled in two ways:
13  * 1. via "Device Specific (D-State) Control"
14  * 2. via "Power Resource Control".
15  * The code below deals with ACPI Power Resources control.
16  *
17  * An ACPI "power resource object" represents a software controllable power
18  * plane, clock plane, or other resource depended on by a device.
19  *
20  * A device may rely on multiple power resources, and a power resource
21  * may be shared by multiple devices.
22  */
23 
24 #define pr_fmt(fmt) "ACPI: PM: " fmt
25 
26 #include <linux/kernel.h>
27 #include <linux/module.h>
28 #include <linux/init.h>
29 #include <linux/types.h>
30 #include <linux/slab.h>
31 #include <linux/pm_runtime.h>
32 #include <linux/sysfs.h>
33 #include <linux/acpi.h>
34 #include "sleep.h"
35 #include "internal.h"
36 
37 #define ACPI_POWER_CLASS		"power_resource"
38 #define ACPI_POWER_DEVICE_NAME		"Power Resource"
39 #define ACPI_POWER_RESOURCE_STATE_OFF	0x00
40 #define ACPI_POWER_RESOURCE_STATE_ON	0x01
41 #define ACPI_POWER_RESOURCE_STATE_UNKNOWN 0xFF
42 
43 struct acpi_power_dependent_device {
44 	struct device *dev;
45 	struct list_head node;
46 };
47 
48 struct acpi_power_resource {
49 	struct acpi_device device;
50 	struct list_head list_node;
51 	char *name;
52 	u32 system_level;
53 	u32 order;
54 	unsigned int ref_count;
55 	u8 state;
56 	bool wakeup_enabled;
57 	struct mutex resource_lock;
58 	struct list_head dependents;
59 };
60 
61 struct acpi_power_resource_entry {
62 	struct list_head node;
63 	struct acpi_power_resource *resource;
64 };
65 
66 static LIST_HEAD(acpi_power_resource_list);
67 static DEFINE_MUTEX(power_resource_list_lock);
68 
69 /* --------------------------------------------------------------------------
70                              Power Resource Management
71    -------------------------------------------------------------------------- */
72 
73 static inline
74 struct acpi_power_resource *to_power_resource(struct acpi_device *device)
75 {
76 	return container_of(device, struct acpi_power_resource, device);
77 }
78 
79 static struct acpi_power_resource *acpi_power_get_context(acpi_handle handle)
80 {
81 	struct acpi_device *device;
82 
83 	if (acpi_bus_get_device(handle, &device))
84 		return NULL;
85 
86 	return to_power_resource(device);
87 }
88 
89 static int acpi_power_resources_list_add(acpi_handle handle,
90 					 struct list_head *list)
91 {
92 	struct acpi_power_resource *resource = acpi_power_get_context(handle);
93 	struct acpi_power_resource_entry *entry;
94 
95 	if (!resource || !list)
96 		return -EINVAL;
97 
98 	entry = kzalloc(sizeof(*entry), GFP_KERNEL);
99 	if (!entry)
100 		return -ENOMEM;
101 
102 	entry->resource = resource;
103 	if (!list_empty(list)) {
104 		struct acpi_power_resource_entry *e;
105 
106 		list_for_each_entry(e, list, node)
107 			if (e->resource->order > resource->order) {
108 				list_add_tail(&entry->node, &e->node);
109 				return 0;
110 			}
111 	}
112 	list_add_tail(&entry->node, list);
113 	return 0;
114 }
115 
116 void acpi_power_resources_list_free(struct list_head *list)
117 {
118 	struct acpi_power_resource_entry *entry, *e;
119 
120 	list_for_each_entry_safe(entry, e, list, node) {
121 		list_del(&entry->node);
122 		kfree(entry);
123 	}
124 }
125 
126 static bool acpi_power_resource_is_dup(union acpi_object *package,
127 				       unsigned int start, unsigned int i)
128 {
129 	acpi_handle rhandle, dup;
130 	unsigned int j;
131 
132 	/* The caller is expected to check the package element types */
133 	rhandle = package->package.elements[i].reference.handle;
134 	for (j = start; j < i; j++) {
135 		dup = package->package.elements[j].reference.handle;
136 		if (dup == rhandle)
137 			return true;
138 	}
139 
140 	return false;
141 }
142 
143 int acpi_extract_power_resources(union acpi_object *package, unsigned int start,
144 				 struct list_head *list)
145 {
146 	unsigned int i;
147 	int err = 0;
148 
149 	for (i = start; i < package->package.count; i++) {
150 		union acpi_object *element = &package->package.elements[i];
151 		struct acpi_device *rdev;
152 		acpi_handle rhandle;
153 
154 		if (element->type != ACPI_TYPE_LOCAL_REFERENCE) {
155 			err = -ENODATA;
156 			break;
157 		}
158 		rhandle = element->reference.handle;
159 		if (!rhandle) {
160 			err = -ENODEV;
161 			break;
162 		}
163 
164 		/* Some ACPI tables contain duplicate power resource references */
165 		if (acpi_power_resource_is_dup(package, start, i))
166 			continue;
167 
168 		rdev = acpi_add_power_resource(rhandle);
169 		if (!rdev) {
170 			err = -ENODEV;
171 			break;
172 		}
173 		err = acpi_power_resources_list_add(rhandle, list);
174 		if (err)
175 			break;
176 	}
177 	if (err)
178 		acpi_power_resources_list_free(list);
179 
180 	return err;
181 }
182 
183 static int __get_state(acpi_handle handle, u8 *state)
184 {
185 	acpi_status status = AE_OK;
186 	unsigned long long sta = 0;
187 	u8 cur_state;
188 
189 	status = acpi_evaluate_integer(handle, "_STA", NULL, &sta);
190 	if (ACPI_FAILURE(status))
191 		return -ENODEV;
192 
193 	cur_state = sta & ACPI_POWER_RESOURCE_STATE_ON;
194 
195 	acpi_handle_debug(handle, "Power resource is %s\n",
196 			  cur_state ? "on" : "off");
197 
198 	*state = cur_state;
199 	return 0;
200 }
201 
202 static int acpi_power_get_state(struct acpi_power_resource *resource, u8 *state)
203 {
204 	if (resource->state == ACPI_POWER_RESOURCE_STATE_UNKNOWN) {
205 		int ret;
206 
207 		ret = __get_state(resource->device.handle, &resource->state);
208 		if (ret)
209 			return ret;
210 	}
211 
212 	*state = resource->state;
213 	return 0;
214 }
215 
216 static int acpi_power_get_list_state(struct list_head *list, u8 *state)
217 {
218 	struct acpi_power_resource_entry *entry;
219 	u8 cur_state = ACPI_POWER_RESOURCE_STATE_OFF;
220 
221 	if (!list || !state)
222 		return -EINVAL;
223 
224 	/* The state of the list is 'on' IFF all resources are 'on'. */
225 	list_for_each_entry(entry, list, node) {
226 		struct acpi_power_resource *resource = entry->resource;
227 		int result;
228 
229 		mutex_lock(&resource->resource_lock);
230 		result = acpi_power_get_state(resource, &cur_state);
231 		mutex_unlock(&resource->resource_lock);
232 		if (result)
233 			return result;
234 
235 		if (cur_state != ACPI_POWER_RESOURCE_STATE_ON)
236 			break;
237 	}
238 
239 	pr_debug("Power resource list is %s\n", cur_state ? "on" : "off");
240 
241 	*state = cur_state;
242 	return 0;
243 }
244 
245 static int
246 acpi_power_resource_add_dependent(struct acpi_power_resource *resource,
247 				  struct device *dev)
248 {
249 	struct acpi_power_dependent_device *dep;
250 	int ret = 0;
251 
252 	mutex_lock(&resource->resource_lock);
253 	list_for_each_entry(dep, &resource->dependents, node) {
254 		/* Only add it once */
255 		if (dep->dev == dev)
256 			goto unlock;
257 	}
258 
259 	dep = kzalloc(sizeof(*dep), GFP_KERNEL);
260 	if (!dep) {
261 		ret = -ENOMEM;
262 		goto unlock;
263 	}
264 
265 	dep->dev = dev;
266 	list_add_tail(&dep->node, &resource->dependents);
267 	dev_dbg(dev, "added power dependency to [%s]\n", resource->name);
268 
269 unlock:
270 	mutex_unlock(&resource->resource_lock);
271 	return ret;
272 }
273 
274 static void
275 acpi_power_resource_remove_dependent(struct acpi_power_resource *resource,
276 				     struct device *dev)
277 {
278 	struct acpi_power_dependent_device *dep;
279 
280 	mutex_lock(&resource->resource_lock);
281 	list_for_each_entry(dep, &resource->dependents, node) {
282 		if (dep->dev == dev) {
283 			list_del(&dep->node);
284 			kfree(dep);
285 			dev_dbg(dev, "removed power dependency to [%s]\n",
286 				resource->name);
287 			break;
288 		}
289 	}
290 	mutex_unlock(&resource->resource_lock);
291 }
292 
293 /**
294  * acpi_device_power_add_dependent - Add dependent device of this ACPI device
295  * @adev: ACPI device pointer
296  * @dev: Dependent device
297  *
298  * If @adev has non-empty _PR0 the @dev is added as dependent device to all
299  * power resources returned by it. This means that whenever these power
300  * resources are turned _ON the dependent devices get runtime resumed. This
301  * is needed for devices such as PCI to allow its driver to re-initialize
302  * it after it went to D0uninitialized.
303  *
304  * If @adev does not have _PR0 this does nothing.
305  *
306  * Returns %0 in case of success and negative errno otherwise.
307  */
308 int acpi_device_power_add_dependent(struct acpi_device *adev,
309 				    struct device *dev)
310 {
311 	struct acpi_power_resource_entry *entry;
312 	struct list_head *resources;
313 	int ret;
314 
315 	if (!adev->flags.power_manageable)
316 		return 0;
317 
318 	resources = &adev->power.states[ACPI_STATE_D0].resources;
319 	list_for_each_entry(entry, resources, node) {
320 		ret = acpi_power_resource_add_dependent(entry->resource, dev);
321 		if (ret)
322 			goto err;
323 	}
324 
325 	return 0;
326 
327 err:
328 	list_for_each_entry(entry, resources, node)
329 		acpi_power_resource_remove_dependent(entry->resource, dev);
330 
331 	return ret;
332 }
333 
334 /**
335  * acpi_device_power_remove_dependent - Remove dependent device
336  * @adev: ACPI device pointer
337  * @dev: Dependent device
338  *
339  * Does the opposite of acpi_device_power_add_dependent() and removes the
340  * dependent device if it is found. Can be called to @adev that does not
341  * have _PR0 as well.
342  */
343 void acpi_device_power_remove_dependent(struct acpi_device *adev,
344 					struct device *dev)
345 {
346 	struct acpi_power_resource_entry *entry;
347 	struct list_head *resources;
348 
349 	if (!adev->flags.power_manageable)
350 		return;
351 
352 	resources = &adev->power.states[ACPI_STATE_D0].resources;
353 	list_for_each_entry_reverse(entry, resources, node)
354 		acpi_power_resource_remove_dependent(entry->resource, dev);
355 }
356 
357 static int __acpi_power_on(struct acpi_power_resource *resource)
358 {
359 	struct acpi_power_dependent_device *dep;
360 	acpi_status status = AE_OK;
361 
362 	status = acpi_evaluate_object(resource->device.handle, "_ON", NULL, NULL);
363 	if (ACPI_FAILURE(status)) {
364 		resource->state = ACPI_POWER_RESOURCE_STATE_UNKNOWN;
365 		return -ENODEV;
366 	}
367 
368 	resource->state = ACPI_POWER_RESOURCE_STATE_ON;
369 
370 	pr_debug("Power resource [%s] turned on\n", resource->name);
371 
372 	/*
373 	 * If there are other dependents on this power resource we need to
374 	 * resume them now so that their drivers can re-initialize the
375 	 * hardware properly after it went back to D0.
376 	 */
377 	if (list_empty(&resource->dependents) ||
378 	    list_is_singular(&resource->dependents))
379 		return 0;
380 
381 	list_for_each_entry(dep, &resource->dependents, node) {
382 		dev_dbg(dep->dev, "runtime resuming because [%s] turned on\n",
383 			resource->name);
384 		pm_request_resume(dep->dev);
385 	}
386 
387 	return 0;
388 }
389 
390 static int acpi_power_on_unlocked(struct acpi_power_resource *resource)
391 {
392 	int result = 0;
393 
394 	if (resource->ref_count++) {
395 		pr_debug("Power resource [%s] already on\n", resource->name);
396 	} else {
397 		result = __acpi_power_on(resource);
398 		if (result)
399 			resource->ref_count--;
400 	}
401 	return result;
402 }
403 
404 static int acpi_power_on(struct acpi_power_resource *resource)
405 {
406 	int result;
407 
408 	mutex_lock(&resource->resource_lock);
409 	result = acpi_power_on_unlocked(resource);
410 	mutex_unlock(&resource->resource_lock);
411 	return result;
412 }
413 
414 static int __acpi_power_off(struct acpi_power_resource *resource)
415 {
416 	acpi_status status;
417 
418 	status = acpi_evaluate_object(resource->device.handle, "_OFF",
419 				      NULL, NULL);
420 	if (ACPI_FAILURE(status)) {
421 		resource->state = ACPI_POWER_RESOURCE_STATE_UNKNOWN;
422 		return -ENODEV;
423 	}
424 
425 	resource->state = ACPI_POWER_RESOURCE_STATE_OFF;
426 
427 	pr_debug("Power resource [%s] turned off\n", resource->name);
428 
429 	return 0;
430 }
431 
432 static int acpi_power_off_unlocked(struct acpi_power_resource *resource)
433 {
434 	int result = 0;
435 
436 	if (!resource->ref_count) {
437 		pr_debug("Power resource [%s] already off\n", resource->name);
438 		return 0;
439 	}
440 
441 	if (--resource->ref_count) {
442 		pr_debug("Power resource [%s] still in use\n", resource->name);
443 	} else {
444 		result = __acpi_power_off(resource);
445 		if (result)
446 			resource->ref_count++;
447 	}
448 	return result;
449 }
450 
451 static int acpi_power_off(struct acpi_power_resource *resource)
452 {
453 	int result;
454 
455 	mutex_lock(&resource->resource_lock);
456 	result = acpi_power_off_unlocked(resource);
457 	mutex_unlock(&resource->resource_lock);
458 	return result;
459 }
460 
461 static int acpi_power_off_list(struct list_head *list)
462 {
463 	struct acpi_power_resource_entry *entry;
464 	int result = 0;
465 
466 	list_for_each_entry_reverse(entry, list, node) {
467 		result = acpi_power_off(entry->resource);
468 		if (result)
469 			goto err;
470 	}
471 	return 0;
472 
473  err:
474 	list_for_each_entry_continue(entry, list, node)
475 		acpi_power_on(entry->resource);
476 
477 	return result;
478 }
479 
480 static int acpi_power_on_list(struct list_head *list)
481 {
482 	struct acpi_power_resource_entry *entry;
483 	int result = 0;
484 
485 	list_for_each_entry(entry, list, node) {
486 		result = acpi_power_on(entry->resource);
487 		if (result)
488 			goto err;
489 	}
490 	return 0;
491 
492  err:
493 	list_for_each_entry_continue_reverse(entry, list, node)
494 		acpi_power_off(entry->resource);
495 
496 	return result;
497 }
498 
499 static struct attribute *attrs[] = {
500 	NULL,
501 };
502 
503 static const struct attribute_group attr_groups[] = {
504 	[ACPI_STATE_D0] = {
505 		.name = "power_resources_D0",
506 		.attrs = attrs,
507 	},
508 	[ACPI_STATE_D1] = {
509 		.name = "power_resources_D1",
510 		.attrs = attrs,
511 	},
512 	[ACPI_STATE_D2] = {
513 		.name = "power_resources_D2",
514 		.attrs = attrs,
515 	},
516 	[ACPI_STATE_D3_HOT] = {
517 		.name = "power_resources_D3hot",
518 		.attrs = attrs,
519 	},
520 };
521 
522 static const struct attribute_group wakeup_attr_group = {
523 	.name = "power_resources_wakeup",
524 	.attrs = attrs,
525 };
526 
527 static void acpi_power_hide_list(struct acpi_device *adev,
528 				 struct list_head *resources,
529 				 const struct attribute_group *attr_group)
530 {
531 	struct acpi_power_resource_entry *entry;
532 
533 	if (list_empty(resources))
534 		return;
535 
536 	list_for_each_entry_reverse(entry, resources, node) {
537 		struct acpi_device *res_dev = &entry->resource->device;
538 
539 		sysfs_remove_link_from_group(&adev->dev.kobj,
540 					     attr_group->name,
541 					     dev_name(&res_dev->dev));
542 	}
543 	sysfs_remove_group(&adev->dev.kobj, attr_group);
544 }
545 
546 static void acpi_power_expose_list(struct acpi_device *adev,
547 				   struct list_head *resources,
548 				   const struct attribute_group *attr_group)
549 {
550 	struct acpi_power_resource_entry *entry;
551 	int ret;
552 
553 	if (list_empty(resources))
554 		return;
555 
556 	ret = sysfs_create_group(&adev->dev.kobj, attr_group);
557 	if (ret)
558 		return;
559 
560 	list_for_each_entry(entry, resources, node) {
561 		struct acpi_device *res_dev = &entry->resource->device;
562 
563 		ret = sysfs_add_link_to_group(&adev->dev.kobj,
564 					      attr_group->name,
565 					      &res_dev->dev.kobj,
566 					      dev_name(&res_dev->dev));
567 		if (ret) {
568 			acpi_power_hide_list(adev, resources, attr_group);
569 			break;
570 		}
571 	}
572 }
573 
574 static void acpi_power_expose_hide(struct acpi_device *adev,
575 				   struct list_head *resources,
576 				   const struct attribute_group *attr_group,
577 				   bool expose)
578 {
579 	if (expose)
580 		acpi_power_expose_list(adev, resources, attr_group);
581 	else
582 		acpi_power_hide_list(adev, resources, attr_group);
583 }
584 
585 void acpi_power_add_remove_device(struct acpi_device *adev, bool add)
586 {
587 	int state;
588 
589 	if (adev->wakeup.flags.valid)
590 		acpi_power_expose_hide(adev, &adev->wakeup.resources,
591 				       &wakeup_attr_group, add);
592 
593 	if (!adev->power.flags.power_resources)
594 		return;
595 
596 	for (state = ACPI_STATE_D0; state <= ACPI_STATE_D3_HOT; state++)
597 		acpi_power_expose_hide(adev,
598 				       &adev->power.states[state].resources,
599 				       &attr_groups[state], add);
600 }
601 
602 int acpi_power_wakeup_list_init(struct list_head *list, int *system_level_p)
603 {
604 	struct acpi_power_resource_entry *entry;
605 	int system_level = 5;
606 
607 	list_for_each_entry(entry, list, node) {
608 		struct acpi_power_resource *resource = entry->resource;
609 		int result;
610 		u8 state;
611 
612 		mutex_lock(&resource->resource_lock);
613 
614 		result = acpi_power_get_state(resource, &state);
615 		if (result) {
616 			mutex_unlock(&resource->resource_lock);
617 			return result;
618 		}
619 		if (state == ACPI_POWER_RESOURCE_STATE_ON) {
620 			resource->ref_count++;
621 			resource->wakeup_enabled = true;
622 		}
623 		if (system_level > resource->system_level)
624 			system_level = resource->system_level;
625 
626 		mutex_unlock(&resource->resource_lock);
627 	}
628 	*system_level_p = system_level;
629 	return 0;
630 }
631 
632 /* --------------------------------------------------------------------------
633                              Device Power Management
634    -------------------------------------------------------------------------- */
635 
636 /**
637  * acpi_device_sleep_wake - execute _DSW (Device Sleep Wake) or (deprecated in
638  *                          ACPI 3.0) _PSW (Power State Wake)
639  * @dev: Device to handle.
640  * @enable: 0 - disable, 1 - enable the wake capabilities of the device.
641  * @sleep_state: Target sleep state of the system.
642  * @dev_state: Target power state of the device.
643  *
644  * Execute _DSW (Device Sleep Wake) or (deprecated in ACPI 3.0) _PSW (Power
645  * State Wake) for the device, if present.  On failure reset the device's
646  * wakeup.flags.valid flag.
647  *
648  * RETURN VALUE:
649  * 0 if either _DSW or _PSW has been successfully executed
650  * 0 if neither _DSW nor _PSW has been found
651  * -ENODEV if the execution of either _DSW or _PSW has failed
652  */
653 int acpi_device_sleep_wake(struct acpi_device *dev,
654 			   int enable, int sleep_state, int dev_state)
655 {
656 	union acpi_object in_arg[3];
657 	struct acpi_object_list arg_list = { 3, in_arg };
658 	acpi_status status = AE_OK;
659 
660 	/*
661 	 * Try to execute _DSW first.
662 	 *
663 	 * Three arguments are needed for the _DSW object:
664 	 * Argument 0: enable/disable the wake capabilities
665 	 * Argument 1: target system state
666 	 * Argument 2: target device state
667 	 * When _DSW object is called to disable the wake capabilities, maybe
668 	 * the first argument is filled. The values of the other two arguments
669 	 * are meaningless.
670 	 */
671 	in_arg[0].type = ACPI_TYPE_INTEGER;
672 	in_arg[0].integer.value = enable;
673 	in_arg[1].type = ACPI_TYPE_INTEGER;
674 	in_arg[1].integer.value = sleep_state;
675 	in_arg[2].type = ACPI_TYPE_INTEGER;
676 	in_arg[2].integer.value = dev_state;
677 	status = acpi_evaluate_object(dev->handle, "_DSW", &arg_list, NULL);
678 	if (ACPI_SUCCESS(status)) {
679 		return 0;
680 	} else if (status != AE_NOT_FOUND) {
681 		acpi_handle_info(dev->handle, "_DSW execution failed\n");
682 		dev->wakeup.flags.valid = 0;
683 		return -ENODEV;
684 	}
685 
686 	/* Execute _PSW */
687 	status = acpi_execute_simple_method(dev->handle, "_PSW", enable);
688 	if (ACPI_FAILURE(status) && (status != AE_NOT_FOUND)) {
689 		acpi_handle_info(dev->handle, "_PSW execution failed\n");
690 		dev->wakeup.flags.valid = 0;
691 		return -ENODEV;
692 	}
693 
694 	return 0;
695 }
696 
697 /*
698  * Prepare a wakeup device, two steps (Ref ACPI 2.0:P229):
699  * 1. Power on the power resources required for the wakeup device
700  * 2. Execute _DSW (Device Sleep Wake) or (deprecated in ACPI 3.0) _PSW (Power
701  *    State Wake) for the device, if present
702  */
703 int acpi_enable_wakeup_device_power(struct acpi_device *dev, int sleep_state)
704 {
705 	struct acpi_power_resource_entry *entry;
706 	int err = 0;
707 
708 	if (!dev || !dev->wakeup.flags.valid)
709 		return -EINVAL;
710 
711 	mutex_lock(&acpi_device_lock);
712 
713 	if (dev->wakeup.prepare_count++)
714 		goto out;
715 
716 	list_for_each_entry(entry, &dev->wakeup.resources, node) {
717 		struct acpi_power_resource *resource = entry->resource;
718 
719 		mutex_lock(&resource->resource_lock);
720 
721 		if (!resource->wakeup_enabled) {
722 			err = acpi_power_on_unlocked(resource);
723 			if (!err)
724 				resource->wakeup_enabled = true;
725 		}
726 
727 		mutex_unlock(&resource->resource_lock);
728 
729 		if (err) {
730 			dev_err(&dev->dev,
731 				"Cannot turn wakeup power resources on\n");
732 			dev->wakeup.flags.valid = 0;
733 			goto out;
734 		}
735 	}
736 	/*
737 	 * Passing 3 as the third argument below means the device may be
738 	 * put into arbitrary power state afterward.
739 	 */
740 	err = acpi_device_sleep_wake(dev, 1, sleep_state, 3);
741 	if (err)
742 		dev->wakeup.prepare_count = 0;
743 
744  out:
745 	mutex_unlock(&acpi_device_lock);
746 	return err;
747 }
748 
749 /*
750  * Shutdown a wakeup device, counterpart of above method
751  * 1. Execute _DSW (Device Sleep Wake) or (deprecated in ACPI 3.0) _PSW (Power
752  *    State Wake) for the device, if present
753  * 2. Shutdown down the power resources
754  */
755 int acpi_disable_wakeup_device_power(struct acpi_device *dev)
756 {
757 	struct acpi_power_resource_entry *entry;
758 	int err = 0;
759 
760 	if (!dev || !dev->wakeup.flags.valid)
761 		return -EINVAL;
762 
763 	mutex_lock(&acpi_device_lock);
764 
765 	if (--dev->wakeup.prepare_count > 0)
766 		goto out;
767 
768 	/*
769 	 * Executing the code below even if prepare_count is already zero when
770 	 * the function is called may be useful, for example for initialisation.
771 	 */
772 	if (dev->wakeup.prepare_count < 0)
773 		dev->wakeup.prepare_count = 0;
774 
775 	err = acpi_device_sleep_wake(dev, 0, 0, 0);
776 	if (err)
777 		goto out;
778 
779 	list_for_each_entry(entry, &dev->wakeup.resources, node) {
780 		struct acpi_power_resource *resource = entry->resource;
781 
782 		mutex_lock(&resource->resource_lock);
783 
784 		if (resource->wakeup_enabled) {
785 			err = acpi_power_off_unlocked(resource);
786 			if (!err)
787 				resource->wakeup_enabled = false;
788 		}
789 
790 		mutex_unlock(&resource->resource_lock);
791 
792 		if (err) {
793 			dev_err(&dev->dev,
794 				"Cannot turn wakeup power resources off\n");
795 			dev->wakeup.flags.valid = 0;
796 			break;
797 		}
798 	}
799 
800  out:
801 	mutex_unlock(&acpi_device_lock);
802 	return err;
803 }
804 
805 int acpi_power_get_inferred_state(struct acpi_device *device, int *state)
806 {
807 	u8 list_state = ACPI_POWER_RESOURCE_STATE_OFF;
808 	int result = 0;
809 	int i = 0;
810 
811 	if (!device || !state)
812 		return -EINVAL;
813 
814 	/*
815 	 * We know a device's inferred power state when all the resources
816 	 * required for a given D-state are 'on'.
817 	 */
818 	for (i = ACPI_STATE_D0; i <= ACPI_STATE_D3_HOT; i++) {
819 		struct list_head *list = &device->power.states[i].resources;
820 
821 		if (list_empty(list))
822 			continue;
823 
824 		result = acpi_power_get_list_state(list, &list_state);
825 		if (result)
826 			return result;
827 
828 		if (list_state == ACPI_POWER_RESOURCE_STATE_ON) {
829 			*state = i;
830 			return 0;
831 		}
832 	}
833 
834 	*state = device->power.states[ACPI_STATE_D3_COLD].flags.valid ?
835 		ACPI_STATE_D3_COLD : ACPI_STATE_D3_HOT;
836 	return 0;
837 }
838 
839 int acpi_power_on_resources(struct acpi_device *device, int state)
840 {
841 	if (!device || state < ACPI_STATE_D0 || state > ACPI_STATE_D3_HOT)
842 		return -EINVAL;
843 
844 	return acpi_power_on_list(&device->power.states[state].resources);
845 }
846 
847 int acpi_power_transition(struct acpi_device *device, int state)
848 {
849 	int result = 0;
850 
851 	if (!device || (state < ACPI_STATE_D0) || (state > ACPI_STATE_D3_COLD))
852 		return -EINVAL;
853 
854 	if (device->power.state == state || !device->flags.power_manageable)
855 		return 0;
856 
857 	if ((device->power.state < ACPI_STATE_D0)
858 	    || (device->power.state > ACPI_STATE_D3_COLD))
859 		return -ENODEV;
860 
861 	/*
862 	 * First we reference all power resources required in the target list
863 	 * (e.g. so the device doesn't lose power while transitioning).  Then,
864 	 * we dereference all power resources used in the current list.
865 	 */
866 	if (state < ACPI_STATE_D3_COLD)
867 		result = acpi_power_on_list(
868 			&device->power.states[state].resources);
869 
870 	if (!result && device->power.state < ACPI_STATE_D3_COLD)
871 		acpi_power_off_list(
872 			&device->power.states[device->power.state].resources);
873 
874 	/* We shouldn't change the state unless the above operations succeed. */
875 	device->power.state = result ? ACPI_STATE_UNKNOWN : state;
876 
877 	return result;
878 }
879 
880 static void acpi_release_power_resource(struct device *dev)
881 {
882 	struct acpi_device *device = to_acpi_device(dev);
883 	struct acpi_power_resource *resource;
884 
885 	resource = container_of(device, struct acpi_power_resource, device);
886 
887 	mutex_lock(&power_resource_list_lock);
888 	list_del(&resource->list_node);
889 	mutex_unlock(&power_resource_list_lock);
890 
891 	acpi_free_pnp_ids(&device->pnp);
892 	kfree(resource);
893 }
894 
895 static ssize_t resource_in_use_show(struct device *dev,
896 				    struct device_attribute *attr,
897 				    char *buf)
898 {
899 	struct acpi_power_resource *resource;
900 
901 	resource = to_power_resource(to_acpi_device(dev));
902 	return sprintf(buf, "%u\n", !!resource->ref_count);
903 }
904 static DEVICE_ATTR_RO(resource_in_use);
905 
906 static void acpi_power_sysfs_remove(struct acpi_device *device)
907 {
908 	device_remove_file(&device->dev, &dev_attr_resource_in_use);
909 }
910 
911 static void acpi_power_add_resource_to_list(struct acpi_power_resource *resource)
912 {
913 	mutex_lock(&power_resource_list_lock);
914 
915 	if (!list_empty(&acpi_power_resource_list)) {
916 		struct acpi_power_resource *r;
917 
918 		list_for_each_entry(r, &acpi_power_resource_list, list_node)
919 			if (r->order > resource->order) {
920 				list_add_tail(&resource->list_node, &r->list_node);
921 				goto out;
922 			}
923 	}
924 	list_add_tail(&resource->list_node, &acpi_power_resource_list);
925 
926  out:
927 	mutex_unlock(&power_resource_list_lock);
928 }
929 
930 struct acpi_device *acpi_add_power_resource(acpi_handle handle)
931 {
932 	struct acpi_power_resource *resource;
933 	struct acpi_device *device = NULL;
934 	union acpi_object acpi_object;
935 	struct acpi_buffer buffer = { sizeof(acpi_object), &acpi_object };
936 	acpi_status status;
937 	int result;
938 
939 	acpi_bus_get_device(handle, &device);
940 	if (device)
941 		return device;
942 
943 	resource = kzalloc(sizeof(*resource), GFP_KERNEL);
944 	if (!resource)
945 		return NULL;
946 
947 	device = &resource->device;
948 	acpi_init_device_object(device, handle, ACPI_BUS_TYPE_POWER);
949 	mutex_init(&resource->resource_lock);
950 	INIT_LIST_HEAD(&resource->list_node);
951 	INIT_LIST_HEAD(&resource->dependents);
952 	resource->name = device->pnp.bus_id;
953 	strcpy(acpi_device_name(device), ACPI_POWER_DEVICE_NAME);
954 	strcpy(acpi_device_class(device), ACPI_POWER_CLASS);
955 	device->power.state = ACPI_STATE_UNKNOWN;
956 
957 	/* Evaluate the object to get the system level and resource order. */
958 	status = acpi_evaluate_object(handle, NULL, NULL, &buffer);
959 	if (ACPI_FAILURE(status))
960 		goto err;
961 
962 	resource->system_level = acpi_object.power_resource.system_level;
963 	resource->order = acpi_object.power_resource.resource_order;
964 	resource->state = ACPI_POWER_RESOURCE_STATE_UNKNOWN;
965 
966 	pr_info("%s [%s]\n", acpi_device_name(device), acpi_device_bid(device));
967 
968 	device->flags.match_driver = true;
969 	result = acpi_device_add(device, acpi_release_power_resource);
970 	if (result)
971 		goto err;
972 
973 	if (!device_create_file(&device->dev, &dev_attr_resource_in_use))
974 		device->remove = acpi_power_sysfs_remove;
975 
976 	acpi_power_add_resource_to_list(resource);
977 	acpi_device_add_finalize(device);
978 	return device;
979 
980  err:
981 	acpi_release_power_resource(&device->dev);
982 	return NULL;
983 }
984 
985 #ifdef CONFIG_ACPI_SLEEP
986 void acpi_resume_power_resources(void)
987 {
988 	struct acpi_power_resource *resource;
989 
990 	mutex_lock(&power_resource_list_lock);
991 
992 	list_for_each_entry(resource, &acpi_power_resource_list, list_node) {
993 		int result;
994 		u8 state;
995 
996 		mutex_lock(&resource->resource_lock);
997 
998 		resource->state = ACPI_POWER_RESOURCE_STATE_UNKNOWN;
999 		result = acpi_power_get_state(resource, &state);
1000 		if (result) {
1001 			mutex_unlock(&resource->resource_lock);
1002 			continue;
1003 		}
1004 
1005 		if (state == ACPI_POWER_RESOURCE_STATE_OFF
1006 		    && resource->ref_count) {
1007 			dev_dbg(&resource->device.dev, "Turning ON\n");
1008 			__acpi_power_on(resource);
1009 		}
1010 
1011 		mutex_unlock(&resource->resource_lock);
1012 	}
1013 
1014 	mutex_unlock(&power_resource_list_lock);
1015 }
1016 #endif
1017 
1018 /**
1019  * acpi_turn_off_unused_power_resources - Turn off power resources not in use.
1020  */
1021 void acpi_turn_off_unused_power_resources(void)
1022 {
1023 	struct acpi_power_resource *resource;
1024 
1025 	mutex_lock(&power_resource_list_lock);
1026 
1027 	list_for_each_entry_reverse(resource, &acpi_power_resource_list, list_node) {
1028 		mutex_lock(&resource->resource_lock);
1029 
1030 		/*
1031 		 * Turn off power resources in an unknown state too, because the
1032 		 * platform firmware on some system expects the OS to turn off
1033 		 * power resources without any users unconditionally.
1034 		 */
1035 		if (!resource->ref_count &&
1036 		    resource->state != ACPI_POWER_RESOURCE_STATE_OFF) {
1037 			dev_dbg(&resource->device.dev, "Turning OFF\n");
1038 			__acpi_power_off(resource);
1039 		}
1040 
1041 		mutex_unlock(&resource->resource_lock);
1042 	}
1043 
1044 	mutex_unlock(&power_resource_list_lock);
1045 }
1046