1 /* SPDX-License-Identifier: GPL-2.0-or-later */
2 /*
3  *  pm_wakeup.h - Power management wakeup interface
4  *
5  *  Copyright (C) 2008 Alan Stern
6  *  Copyright (C) 2010 Rafael J. Wysocki, Novell Inc.
7  */
8 
9 #ifndef _LINUX_PM_WAKEUP_H
10 #define _LINUX_PM_WAKEUP_H
11 
12 #ifndef _DEVICE_H_
13 # error "please don't include this file directly"
14 #endif
15 
16 #include <linux/types.h>
17 
18 struct wake_irq;
19 
20 /**
21  * struct wakeup_source - Representation of wakeup sources
22  *
23  * @name: Name of the wakeup source
24  * @id: Wakeup source id
25  * @entry: Wakeup source list entry
26  * @lock: Wakeup source lock
27  * @wakeirq: Optional device specific wakeirq
28  * @timer: Wakeup timer list
29  * @timer_expires: Wakeup timer expiration
30  * @total_time: Total time this wakeup source has been active.
31  * @max_time: Maximum time this wakeup source has been continuously active.
32  * @last_time: Monotonic clock when the wakeup source's was touched last time.
33  * @prevent_sleep_time: Total time this source has been preventing autosleep.
34  * @event_count: Number of signaled wakeup events.
35  * @active_count: Number of times the wakeup source was activated.
36  * @relax_count: Number of times the wakeup source was deactivated.
37  * @expire_count: Number of times the wakeup source's timeout has expired.
38  * @wakeup_count: Number of times the wakeup source might abort suspend.
39  * @dev: Struct device for sysfs statistics about the wakeup source.
40  * @active: Status of the wakeup source.
41  * @autosleep_enabled: Autosleep is active, so update @prevent_sleep_time.
42  */
43 struct wakeup_source {
44 	const char 		*name;
45 	int			id;
46 	struct list_head	entry;
47 	spinlock_t		lock;
48 	struct wake_irq		*wakeirq;
49 	struct timer_list	timer;
50 	unsigned long		timer_expires;
51 	ktime_t total_time;
52 	ktime_t max_time;
53 	ktime_t last_time;
54 	ktime_t start_prevent_time;
55 	ktime_t prevent_sleep_time;
56 	unsigned long		event_count;
57 	unsigned long		active_count;
58 	unsigned long		relax_count;
59 	unsigned long		expire_count;
60 	unsigned long		wakeup_count;
61 	struct device		*dev;
62 	bool			active:1;
63 	bool			autosleep_enabled:1;
64 };
65 
66 #define for_each_wakeup_source(ws) \
67 	for ((ws) = wakeup_sources_walk_start();	\
68 	     (ws);					\
69 	     (ws) = wakeup_sources_walk_next((ws)))
70 
71 #ifdef CONFIG_PM_SLEEP
72 
73 /*
74  * Changes to device_may_wakeup take effect on the next pm state change.
75  */
76 
device_can_wakeup(struct device * dev)77 static inline bool device_can_wakeup(struct device *dev)
78 {
79 	return dev->power.can_wakeup;
80 }
81 
device_may_wakeup(struct device * dev)82 static inline bool device_may_wakeup(struct device *dev)
83 {
84 	return dev->power.can_wakeup && !!dev->power.wakeup;
85 }
86 
device_wakeup_path(struct device * dev)87 static inline bool device_wakeup_path(struct device *dev)
88 {
89 	return dev->power.wakeup_path;
90 }
91 
device_set_wakeup_path(struct device * dev)92 static inline void device_set_wakeup_path(struct device *dev)
93 {
94 	dev->power.wakeup_path = true;
95 }
96 
97 /* drivers/base/power/wakeup.c */
98 extern struct wakeup_source *wakeup_source_create(const char *name);
99 extern void wakeup_source_destroy(struct wakeup_source *ws);
100 extern void wakeup_source_add(struct wakeup_source *ws);
101 extern void wakeup_source_remove(struct wakeup_source *ws);
102 extern struct wakeup_source *wakeup_source_register(struct device *dev,
103 						    const char *name);
104 extern void wakeup_source_unregister(struct wakeup_source *ws);
105 extern int wakeup_sources_read_lock(void);
106 extern void wakeup_sources_read_unlock(int idx);
107 extern struct wakeup_source *wakeup_sources_walk_start(void);
108 extern struct wakeup_source *wakeup_sources_walk_next(struct wakeup_source *ws);
109 extern int device_wakeup_enable(struct device *dev);
110 extern int device_wakeup_disable(struct device *dev);
111 extern void device_set_wakeup_capable(struct device *dev, bool capable);
112 extern int device_set_wakeup_enable(struct device *dev, bool enable);
113 extern void __pm_stay_awake(struct wakeup_source *ws);
114 extern void pm_stay_awake(struct device *dev);
115 extern void __pm_relax(struct wakeup_source *ws);
116 extern void pm_relax(struct device *dev);
117 extern void pm_wakeup_ws_event(struct wakeup_source *ws, unsigned int msec, bool hard);
118 extern void pm_wakeup_dev_event(struct device *dev, unsigned int msec, bool hard);
119 
120 #else /* !CONFIG_PM_SLEEP */
121 
device_set_wakeup_capable(struct device * dev,bool capable)122 static inline void device_set_wakeup_capable(struct device *dev, bool capable)
123 {
124 	dev->power.can_wakeup = capable;
125 }
126 
device_can_wakeup(struct device * dev)127 static inline bool device_can_wakeup(struct device *dev)
128 {
129 	return dev->power.can_wakeup;
130 }
131 
wakeup_source_create(const char * name)132 static inline struct wakeup_source *wakeup_source_create(const char *name)
133 {
134 	return NULL;
135 }
136 
wakeup_source_destroy(struct wakeup_source * ws)137 static inline void wakeup_source_destroy(struct wakeup_source *ws) {}
138 
wakeup_source_add(struct wakeup_source * ws)139 static inline void wakeup_source_add(struct wakeup_source *ws) {}
140 
wakeup_source_remove(struct wakeup_source * ws)141 static inline void wakeup_source_remove(struct wakeup_source *ws) {}
142 
wakeup_source_register(struct device * dev,const char * name)143 static inline struct wakeup_source *wakeup_source_register(struct device *dev,
144 							   const char *name)
145 {
146 	return NULL;
147 }
148 
wakeup_source_unregister(struct wakeup_source * ws)149 static inline void wakeup_source_unregister(struct wakeup_source *ws) {}
150 
device_wakeup_enable(struct device * dev)151 static inline int device_wakeup_enable(struct device *dev)
152 {
153 	dev->power.should_wakeup = true;
154 	return 0;
155 }
156 
device_wakeup_disable(struct device * dev)157 static inline int device_wakeup_disable(struct device *dev)
158 {
159 	dev->power.should_wakeup = false;
160 	return 0;
161 }
162 
device_set_wakeup_enable(struct device * dev,bool enable)163 static inline int device_set_wakeup_enable(struct device *dev, bool enable)
164 {
165 	dev->power.should_wakeup = enable;
166 	return 0;
167 }
168 
device_may_wakeup(struct device * dev)169 static inline bool device_may_wakeup(struct device *dev)
170 {
171 	return dev->power.can_wakeup && dev->power.should_wakeup;
172 }
173 
device_wakeup_path(struct device * dev)174 static inline bool device_wakeup_path(struct device *dev)
175 {
176 	return false;
177 }
178 
device_set_wakeup_path(struct device * dev)179 static inline void device_set_wakeup_path(struct device *dev) {}
180 
__pm_stay_awake(struct wakeup_source * ws)181 static inline void __pm_stay_awake(struct wakeup_source *ws) {}
182 
pm_stay_awake(struct device * dev)183 static inline void pm_stay_awake(struct device *dev) {}
184 
__pm_relax(struct wakeup_source * ws)185 static inline void __pm_relax(struct wakeup_source *ws) {}
186 
pm_relax(struct device * dev)187 static inline void pm_relax(struct device *dev) {}
188 
pm_wakeup_ws_event(struct wakeup_source * ws,unsigned int msec,bool hard)189 static inline void pm_wakeup_ws_event(struct wakeup_source *ws,
190 				      unsigned int msec, bool hard) {}
191 
pm_wakeup_dev_event(struct device * dev,unsigned int msec,bool hard)192 static inline void pm_wakeup_dev_event(struct device *dev, unsigned int msec,
193 				       bool hard) {}
194 
195 #endif /* !CONFIG_PM_SLEEP */
196 
__pm_wakeup_event(struct wakeup_source * ws,unsigned int msec)197 static inline void __pm_wakeup_event(struct wakeup_source *ws, unsigned int msec)
198 {
199 	return pm_wakeup_ws_event(ws, msec, false);
200 }
201 
pm_wakeup_event(struct device * dev,unsigned int msec)202 static inline void pm_wakeup_event(struct device *dev, unsigned int msec)
203 {
204 	return pm_wakeup_dev_event(dev, msec, false);
205 }
206 
pm_wakeup_hard_event(struct device * dev)207 static inline void pm_wakeup_hard_event(struct device *dev)
208 {
209 	return pm_wakeup_dev_event(dev, 0, true);
210 }
211 
212 /**
213  * device_init_wakeup - Device wakeup initialization.
214  * @dev: Device to handle.
215  * @enable: Whether or not to enable @dev as a wakeup device.
216  *
217  * By default, most devices should leave wakeup disabled.  The exceptions are
218  * devices that everyone expects to be wakeup sources: keyboards, power buttons,
219  * possibly network interfaces, etc.  Also, devices that don't generate their
220  * own wakeup requests but merely forward requests from one bus to another
221  * (like PCI bridges) should have wakeup enabled by default.
222  */
device_init_wakeup(struct device * dev,bool enable)223 static inline int device_init_wakeup(struct device *dev, bool enable)
224 {
225 	if (enable) {
226 		device_set_wakeup_capable(dev, true);
227 		return device_wakeup_enable(dev);
228 	} else {
229 		device_wakeup_disable(dev);
230 		device_set_wakeup_capable(dev, false);
231 		return 0;
232 	}
233 }
234 
235 #endif /* _LINUX_PM_WAKEUP_H */
236