Line data    Source code

       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             : 
      77             : static inline bool device_can_wakeup(struct device *dev)
      78             : {
      79             :         return dev->power.can_wakeup;
      80             : }
      81             : 
      82             : static inline bool device_may_wakeup(struct device *dev)
      83             : {
      84             :         return dev->power.can_wakeup && !!dev->power.wakeup;
      85             : }
      86             : 
      87             : static inline bool device_wakeup_path(struct device *dev)
      88             : {
      89             :         return dev->power.wakeup_path;
      90             : }
      91             : 
      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_init_wakeup(struct device *dev, bool val);
     113             : extern int device_set_wakeup_enable(struct device *dev, bool enable);
     114             : extern void __pm_stay_awake(struct wakeup_source *ws);
     115             : extern void pm_stay_awake(struct device *dev);
     116             : extern void __pm_relax(struct wakeup_source *ws);
     117             : extern void pm_relax(struct device *dev);
     118             : extern void pm_wakeup_ws_event(struct wakeup_source *ws, unsigned int msec, bool hard);
     119             : extern void pm_wakeup_dev_event(struct device *dev, unsigned int msec, bool hard);
     120             : 
     121             : #else /* !CONFIG_PM_SLEEP */
     122             : 
     123           4 : static inline void device_set_wakeup_capable(struct device *dev, bool capable)
     124             : {
     125           4 :         dev->power.can_wakeup = capable;
     126           4 : }
     127             : 
     128           0 : static inline bool device_can_wakeup(struct device *dev)
     129             : {
     130           0 :         return dev->power.can_wakeup;
     131             : }
     132             : 
     133             : static inline struct wakeup_source *wakeup_source_create(const char *name)
     134             : {
     135             :         return NULL;
     136             : }
     137             : 
     138             : static inline void wakeup_source_destroy(struct wakeup_source *ws) {}
     139             : 
     140             : static inline void wakeup_source_add(struct wakeup_source *ws) {}
     141             : 
     142             : static inline void wakeup_source_remove(struct wakeup_source *ws) {}
     143             : 
     144           0 : static inline struct wakeup_source *wakeup_source_register(struct device *dev,
     145             :                                                            const char *name)
     146             : {
     147           0 :         return NULL;
     148             : }
     149             : 
     150         228 : 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           0 : static inline int device_set_wakeup_enable(struct device *dev, bool enable)
     165             : {
     166           0 :         dev->power.should_wakeup = enable;
     167           0 :         return 0;
     168             : }
     169             : 
     170           0 : static inline int device_init_wakeup(struct device *dev, bool val)
     171             : {
     172           0 :         device_set_wakeup_capable(dev, val);
     173           0 :         device_set_wakeup_enable(dev, val);
     174           0 :         return 0;
     175             : }
     176             : 
     177           0 : static inline bool device_may_wakeup(struct device *dev)
     178             : {
     179           0 :         return dev->power.can_wakeup && dev->power.should_wakeup;
     180             : }
     181             : 
     182             : static inline bool device_wakeup_path(struct device *dev)
     183             : {
     184             :         return false;
     185             : }
     186             : 
     187             : static inline void device_set_wakeup_path(struct device *dev) {}
     188             : 
     189             : static inline void __pm_stay_awake(struct wakeup_source *ws) {}
     190             : 
     191           0 : static inline void pm_stay_awake(struct device *dev) {}
     192             : 
     193        4737 : static inline void __pm_relax(struct wakeup_source *ws) {}
     194             : 
     195           0 : static inline void pm_relax(struct device *dev) {}
     196             : 
     197             : static inline void pm_wakeup_ws_event(struct wakeup_source *ws,
     198             :                                       unsigned int msec, bool hard) {}
     199             : 
     200             : static inline void pm_wakeup_dev_event(struct device *dev, unsigned int msec,
     201             :                                        bool hard) {}
     202             : 
     203             : #endif /* !CONFIG_PM_SLEEP */
     204             : 
     205             : static inline void __pm_wakeup_event(struct wakeup_source *ws, unsigned int msec)
     206             : {
     207             :         return pm_wakeup_ws_event(ws, msec, false);
     208             : }
     209             : 
     210             : static inline void pm_wakeup_event(struct device *dev, unsigned int msec)
     211             : {
     212           0 :         return pm_wakeup_dev_event(dev, msec, false);
     213             : }
     214             : 
     215             : static 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 */