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