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
 18struct 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 */
 43struct 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
 77static inline bool device_can_wakeup(struct device *dev)
 78{
 79	return dev->power.can_wakeup;
 80}
 81
 82static inline bool device_may_wakeup(struct device *dev)
 83{
 84	return dev->power.can_wakeup && !!dev->power.wakeup;
 85}
 86
 87static inline bool device_wakeup_path(struct device *dev)
 88{
 89	return dev->power.wakeup_path;
 90}
 91
 92static inline void device_set_wakeup_path(struct device *dev)
 93{
 94	dev->power.wakeup_path = true;
 95}
 96
 97/* drivers/base/power/wakeup.c */
 
 98extern struct wakeup_source *wakeup_source_create(const char *name);
 
 99extern void wakeup_source_destroy(struct wakeup_source *ws);
100extern void wakeup_source_add(struct wakeup_source *ws);
101extern void wakeup_source_remove(struct wakeup_source *ws);
102extern struct wakeup_source *wakeup_source_register(struct device *dev,
103						    const char *name);
104extern void wakeup_source_unregister(struct wakeup_source *ws);
105extern int wakeup_sources_read_lock(void);
106extern void wakeup_sources_read_unlock(int idx);
107extern struct wakeup_source *wakeup_sources_walk_start(void);
108extern struct wakeup_source *wakeup_sources_walk_next(struct wakeup_source *ws);
109extern int device_wakeup_enable(struct device *dev);
110extern int device_wakeup_disable(struct device *dev);
111extern void device_set_wakeup_capable(struct device *dev, bool capable);
112extern int device_init_wakeup(struct device *dev, bool val);
113extern int device_set_wakeup_enable(struct device *dev, bool enable);
114extern void __pm_stay_awake(struct wakeup_source *ws);
115extern void pm_stay_awake(struct device *dev);
116extern void __pm_relax(struct wakeup_source *ws);
117extern void pm_relax(struct device *dev);
118extern void pm_wakeup_ws_event(struct wakeup_source *ws, unsigned int msec, bool hard);
119extern void pm_wakeup_dev_event(struct device *dev, unsigned int msec, bool hard);
120
121#else /* !CONFIG_PM_SLEEP */
122
123static inline void device_set_wakeup_capable(struct device *dev, bool capable)
124{
125	dev->power.can_wakeup = capable;
126}
127
128static inline bool device_can_wakeup(struct device *dev)
129{
130	return dev->power.can_wakeup;
131}
132
 
 
 
133static inline struct wakeup_source *wakeup_source_create(const char *name)
134{
135	return NULL;
136}
137
 
 
138static inline void wakeup_source_destroy(struct wakeup_source *ws) {}
139
140static inline void wakeup_source_add(struct wakeup_source *ws) {}
141
142static inline void wakeup_source_remove(struct wakeup_source *ws) {}
143
144static inline struct wakeup_source *wakeup_source_register(struct device *dev,
145							   const char *name)
146{
147	return NULL;
148}
149
150static inline void wakeup_source_unregister(struct wakeup_source *ws) {}
151
152static inline int device_wakeup_enable(struct device *dev)
153{
154	dev->power.should_wakeup = true;
155	return 0;
156}
157
158static inline int device_wakeup_disable(struct device *dev)
159{
160	dev->power.should_wakeup = false;
161	return 0;
162}
163
164static inline int device_set_wakeup_enable(struct device *dev, bool enable)
165{
166	dev->power.should_wakeup = enable;
167	return 0;
168}
169
170static inline int device_init_wakeup(struct device *dev, bool val)
171{
172	device_set_wakeup_capable(dev, val);
173	device_set_wakeup_enable(dev, val);
174	return 0;
175}
176
177static inline bool device_may_wakeup(struct device *dev)
178{
179	return dev->power.can_wakeup && dev->power.should_wakeup;
180}
181
182static inline bool device_wakeup_path(struct device *dev)
183{
184	return false;
185}
186
187static inline void device_set_wakeup_path(struct device *dev) {}
188
189static inline void __pm_stay_awake(struct wakeup_source *ws) {}
190
191static inline void pm_stay_awake(struct device *dev) {}
192
193static inline void __pm_relax(struct wakeup_source *ws) {}
194
195static inline void pm_relax(struct device *dev) {}
196
197static inline void pm_wakeup_ws_event(struct wakeup_source *ws,
198				      unsigned int msec, bool hard) {}
199
200static inline void pm_wakeup_dev_event(struct device *dev, unsigned int msec,
201				       bool hard) {}
202
203#endif /* !CONFIG_PM_SLEEP */
204
205static inline void __pm_wakeup_event(struct wakeup_source *ws, unsigned int msec)
206{
207	return pm_wakeup_ws_event(ws, msec, false);
208}
209
210static inline void pm_wakeup_event(struct device *dev, unsigned int msec)
211{
212	return pm_wakeup_dev_event(dev, msec, false);
 
213}
214
215static inline void pm_wakeup_hard_event(struct device *dev)
216{
217	return pm_wakeup_dev_event(dev, 0, true);
 
218}
219
220#endif /* _LINUX_PM_WAKEUP_H */

 
  1/*
  2 *  pm_wakeup.h - Power management wakeup interface
  3 *
  4 *  Copyright (C) 2008 Alan Stern
  5 *  Copyright (C) 2010 Rafael J. Wysocki, Novell Inc.
  6 *
  7 *  This program is free software; you can redistribute it and/or modify
  8 *  it under the terms of the GNU General Public License as published by
  9 *  the Free Software Foundation; either version 2 of the License, or
 10 *  (at your option) any later version.
 11 *
 12 *  This program is distributed in the hope that it will be useful,
 13 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 14 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 15 *  GNU General Public License for more details.
 16 *
 17 *  You should have received a copy of the GNU General Public License
 18 *  along with this program; if not, write to the Free Software
 19 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 20 */
 21
 22#ifndef _LINUX_PM_WAKEUP_H
 23#define _LINUX_PM_WAKEUP_H
 24
 25#ifndef _DEVICE_H_
 26# error "please don't include this file directly"
 27#endif
 28
 29#include <linux/types.h>
 30
 31struct wake_irq;
 32
 33/**
 34 * struct wakeup_source - Representation of wakeup sources
 35 *
 36 * @name: Name of the wakeup source
 
 37 * @entry: Wakeup source list entry
 38 * @lock: Wakeup source lock
 39 * @wakeirq: Optional device specific wakeirq
 40 * @timer: Wakeup timer list
 41 * @timer_expires: Wakeup timer expiration
 42 * @total_time: Total time this wakeup source has been active.
 43 * @max_time: Maximum time this wakeup source has been continuously active.
 44 * @last_time: Monotonic clock when the wakeup source's was touched last time.
 45 * @prevent_sleep_time: Total time this source has been preventing autosleep.
 46 * @event_count: Number of signaled wakeup events.
 47 * @active_count: Number of times the wakeup source was activated.
 48 * @relax_count: Number of times the wakeup source was deactivated.
 49 * @expire_count: Number of times the wakeup source's timeout has expired.
 50 * @wakeup_count: Number of times the wakeup source might abort suspend.
 
 51 * @active: Status of the wakeup source.
 52 * @has_timeout: The wakeup source has been activated with a timeout.
 53 */
 54struct wakeup_source {
 55	const char 		*name;
 
 56	struct list_head	entry;
 57	spinlock_t		lock;
 58	struct wake_irq		*wakeirq;
 59	struct timer_list	timer;
 60	unsigned long		timer_expires;
 61	ktime_t total_time;
 62	ktime_t max_time;
 63	ktime_t last_time;
 64	ktime_t start_prevent_time;
 65	ktime_t prevent_sleep_time;
 66	unsigned long		event_count;
 67	unsigned long		active_count;
 68	unsigned long		relax_count;
 69	unsigned long		expire_count;
 70	unsigned long		wakeup_count;
 
 71	bool			active:1;
 72	bool			autosleep_enabled:1;
 73};
 74
 
 
 
 
 
 75#ifdef CONFIG_PM_SLEEP
 76
 77/*
 78 * Changes to device_may_wakeup take effect on the next pm state change.
 79 */
 80
 81static inline bool device_can_wakeup(struct device *dev)
 82{
 83	return dev->power.can_wakeup;
 84}
 85
 86static inline bool device_may_wakeup(struct device *dev)
 87{
 88	return dev->power.can_wakeup && !!dev->power.wakeup;
 89}
 90
 
 
 
 
 
 
 
 
 
 
 91/* drivers/base/power/wakeup.c */
 92extern void wakeup_source_prepare(struct wakeup_source *ws, const char *name);
 93extern struct wakeup_source *wakeup_source_create(const char *name);
 94extern void wakeup_source_drop(struct wakeup_source *ws);
 95extern void wakeup_source_destroy(struct wakeup_source *ws);
 96extern void wakeup_source_add(struct wakeup_source *ws);
 97extern void wakeup_source_remove(struct wakeup_source *ws);
 98extern struct wakeup_source *wakeup_source_register(const char *name);
 
 99extern void wakeup_source_unregister(struct wakeup_source *ws);
 
 
 
 
100extern int device_wakeup_enable(struct device *dev);
101extern int device_wakeup_disable(struct device *dev);
102extern void device_set_wakeup_capable(struct device *dev, bool capable);
103extern int device_init_wakeup(struct device *dev, bool val);
104extern int device_set_wakeup_enable(struct device *dev, bool enable);
105extern void __pm_stay_awake(struct wakeup_source *ws);
106extern void pm_stay_awake(struct device *dev);
107extern void __pm_relax(struct wakeup_source *ws);
108extern void pm_relax(struct device *dev);
109extern void __pm_wakeup_event(struct wakeup_source *ws, unsigned int msec);
110extern void pm_wakeup_event(struct device *dev, unsigned int msec);
111
112#else /* !CONFIG_PM_SLEEP */
113
114static inline void device_set_wakeup_capable(struct device *dev, bool capable)
115{
116	dev->power.can_wakeup = capable;
117}
118
119static inline bool device_can_wakeup(struct device *dev)
120{
121	return dev->power.can_wakeup;
122}
123
124static inline void wakeup_source_prepare(struct wakeup_source *ws,
125					 const char *name) {}
126
127static inline struct wakeup_source *wakeup_source_create(const char *name)
128{
129	return NULL;
130}
131
132static inline void wakeup_source_drop(struct wakeup_source *ws) {}
133
134static inline void wakeup_source_destroy(struct wakeup_source *ws) {}
135
136static inline void wakeup_source_add(struct wakeup_source *ws) {}
137
138static inline void wakeup_source_remove(struct wakeup_source *ws) {}
139
140static inline struct wakeup_source *wakeup_source_register(const char *name)
 
141{
142	return NULL;
143}
144
145static inline void wakeup_source_unregister(struct wakeup_source *ws) {}
146
147static inline int device_wakeup_enable(struct device *dev)
148{
149	dev->power.should_wakeup = true;
150	return 0;
151}
152
153static inline int device_wakeup_disable(struct device *dev)
154{
155	dev->power.should_wakeup = false;
156	return 0;
157}
158
159static inline int device_set_wakeup_enable(struct device *dev, bool enable)
160{
161	dev->power.should_wakeup = enable;
162	return 0;
163}
164
165static inline int device_init_wakeup(struct device *dev, bool val)
166{
167	device_set_wakeup_capable(dev, val);
168	device_set_wakeup_enable(dev, val);
169	return 0;
170}
171
172static inline bool device_may_wakeup(struct device *dev)
173{
174	return dev->power.can_wakeup && dev->power.should_wakeup;
175}
176
 
 
 
 
 
 
 
177static inline void __pm_stay_awake(struct wakeup_source *ws) {}
178
179static inline void pm_stay_awake(struct device *dev) {}
180
181static inline void __pm_relax(struct wakeup_source *ws) {}
182
183static inline void pm_relax(struct device *dev) {}
184
185static inline void __pm_wakeup_event(struct wakeup_source *ws, unsigned int msec) {}
 
186
187static inline void pm_wakeup_event(struct device *dev, unsigned int msec) {}
 
188
189#endif /* !CONFIG_PM_SLEEP */
190
191static inline void wakeup_source_init(struct wakeup_source *ws,
192				      const char *name)
 
 
 
 
193{
194	wakeup_source_prepare(ws, name);
195	wakeup_source_add(ws);
196}
197
198static inline void wakeup_source_trash(struct wakeup_source *ws)
199{
200	wakeup_source_remove(ws);
201	wakeup_source_drop(ws);
202}
203
204#endif /* _LINUX_PM_WAKEUP_H */