xref: /openbmc/linux/drivers/acpi/wakeup.c (revision c6237b21)
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * wakeup.c - support wakeup devices
4  * Copyright (C) 2004 Li Shaohua <shaohua.li@intel.com>
5  */
6 
7 #include <linux/init.h>
8 #include <linux/acpi.h>
9 #include <linux/kernel.h>
10 #include <linux/types.h>
11 
12 #include "internal.h"
13 #include "sleep.h"
14 
15 struct acpi_wakeup_handler {
16 	struct list_head list_node;
17 	bool (*wakeup)(void *context);
18 	void *context;
19 };
20 
21 static LIST_HEAD(acpi_wakeup_handler_head);
22 static DEFINE_MUTEX(acpi_wakeup_handler_mutex);
23 
24 /*
25  * We didn't lock acpi_device_lock in the file, because it invokes oops in
26  * suspend/resume and isn't really required as this is called in S-state. At
27  * that time, there is no device hotplug
28  **/
29 
30 /**
31  * acpi_enable_wakeup_devices - Enable wake-up device GPEs.
32  * @sleep_state: ACPI system sleep state.
33  *
34  * Enable wakeup device power of devices with the state.enable flag set and set
35  * the wakeup enable mask bits in the GPE registers that correspond to wakeup
36  * devices.
37  */
acpi_enable_wakeup_devices(u8 sleep_state)38 void acpi_enable_wakeup_devices(u8 sleep_state)
39 {
40 	struct acpi_device *dev, *tmp;
41 
42 	list_for_each_entry_safe(dev, tmp, &acpi_wakeup_device_list,
43 				 wakeup_list) {
44 		if (!dev->wakeup.flags.valid
45 		    || sleep_state > (u32) dev->wakeup.sleep_state
46 		    || !(device_may_wakeup(&dev->dev)
47 			 || dev->wakeup.prepare_count))
48 			continue;
49 
50 		if (device_may_wakeup(&dev->dev))
51 			acpi_enable_wakeup_device_power(dev, sleep_state);
52 
53 		/* The wake-up power should have been enabled already. */
54 		acpi_set_gpe_wake_mask(dev->wakeup.gpe_device, dev->wakeup.gpe_number,
55 				ACPI_GPE_ENABLE);
56 	}
57 }
58 
59 /**
60  * acpi_disable_wakeup_devices - Disable devices' wakeup capability.
61  * @sleep_state: ACPI system sleep state.
62  */
acpi_disable_wakeup_devices(u8 sleep_state)63 void acpi_disable_wakeup_devices(u8 sleep_state)
64 {
65 	struct acpi_device *dev, *tmp;
66 
67 	list_for_each_entry_safe(dev, tmp, &acpi_wakeup_device_list,
68 				 wakeup_list) {
69 		if (!dev->wakeup.flags.valid
70 		    || sleep_state > (u32) dev->wakeup.sleep_state
71 		    || !(device_may_wakeup(&dev->dev)
72 			 || dev->wakeup.prepare_count))
73 			continue;
74 
75 		acpi_set_gpe_wake_mask(dev->wakeup.gpe_device, dev->wakeup.gpe_number,
76 				ACPI_GPE_DISABLE);
77 
78 		if (device_may_wakeup(&dev->dev))
79 			acpi_disable_wakeup_device_power(dev);
80 	}
81 }
82 
acpi_wakeup_device_init(void)83 int __init acpi_wakeup_device_init(void)
84 {
85 	struct acpi_device *dev, *tmp;
86 
87 	mutex_lock(&acpi_device_lock);
88 	list_for_each_entry_safe(dev, tmp, &acpi_wakeup_device_list,
89 				 wakeup_list) {
90 		if (device_can_wakeup(&dev->dev)) {
91 			/* Button GPEs are supposed to be always enabled. */
92 			acpi_enable_gpe(dev->wakeup.gpe_device,
93 					dev->wakeup.gpe_number);
94 			device_set_wakeup_enable(&dev->dev, true);
95 		}
96 	}
97 	mutex_unlock(&acpi_device_lock);
98 	return 0;
99 }
100 
101 /**
102  * acpi_register_wakeup_handler - Register wakeup handler
103  * @wake_irq: The IRQ through which the device may receive wakeups
104  * @wakeup:   Wakeup-handler to call when the SCI has triggered a wakeup
105  * @context:  Context to pass to the handler when calling it
106  *
107  * Drivers which may share an IRQ with the SCI can use this to register
108  * a handler which returns true when the device they are managing wants
109  * to trigger a wakeup.
110  */
acpi_register_wakeup_handler(int wake_irq,bool (* wakeup)(void * context),void * context)111 int acpi_register_wakeup_handler(int wake_irq, bool (*wakeup)(void *context),
112 				 void *context)
113 {
114 	struct acpi_wakeup_handler *handler;
115 
116 	/*
117 	 * If the device is not sharing its IRQ with the SCI, there is no
118 	 * need to register the handler.
119 	 */
120 	if (!acpi_sci_irq_valid() || wake_irq != acpi_sci_irq)
121 		return 0;
122 
123 	handler = kmalloc(sizeof(*handler), GFP_KERNEL);
124 	if (!handler)
125 		return -ENOMEM;
126 
127 	handler->wakeup = wakeup;
128 	handler->context = context;
129 
130 	mutex_lock(&acpi_wakeup_handler_mutex);
131 	list_add(&handler->list_node, &acpi_wakeup_handler_head);
132 	mutex_unlock(&acpi_wakeup_handler_mutex);
133 
134 	return 0;
135 }
136 EXPORT_SYMBOL_GPL(acpi_register_wakeup_handler);
137 
138 /**
139  * acpi_unregister_wakeup_handler - Unregister wakeup handler
140  * @wakeup:   Wakeup-handler passed to acpi_register_wakeup_handler()
141  * @context:  Context passed to acpi_register_wakeup_handler()
142  */
acpi_unregister_wakeup_handler(bool (* wakeup)(void * context),void * context)143 void acpi_unregister_wakeup_handler(bool (*wakeup)(void *context),
144 				    void *context)
145 {
146 	struct acpi_wakeup_handler *handler;
147 
148 	mutex_lock(&acpi_wakeup_handler_mutex);
149 	list_for_each_entry(handler, &acpi_wakeup_handler_head, list_node) {
150 		if (handler->wakeup == wakeup && handler->context == context) {
151 			list_del(&handler->list_node);
152 			kfree(handler);
153 			break;
154 		}
155 	}
156 	mutex_unlock(&acpi_wakeup_handler_mutex);
157 }
158 EXPORT_SYMBOL_GPL(acpi_unregister_wakeup_handler);
159 
acpi_check_wakeup_handlers(void)160 bool acpi_check_wakeup_handlers(void)
161 {
162 	struct acpi_wakeup_handler *handler;
163 
164 	/* No need to lock, nothing else is running when we're called. */
165 	list_for_each_entry(handler, &acpi_wakeup_handler_head, list_node) {
166 		if (handler->wakeup(handler->context))
167 			return true;
168 	}
169 
170 	return false;
171 }
172