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         540 :         return dev->power.can_wakeup;
      80             : }
      81             : 
      82             : static inline bool device_may_wakeup(struct device *dev)
      83             : {
      84           0 :         return dev->power.can_wakeup && !!dev->power.wakeup;
      85             : }
      86             : 
      87             : static inline bool device_wakeup_path(struct device *dev)
      88             : {
      89           0 :         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_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             : 
     122             : static inline void device_set_wakeup_capable(struct device *dev, bool capable)
     123             : {
     124             :         dev->power.can_wakeup = capable;
     125             : }
     126             : 
     127             : static inline bool device_can_wakeup(struct device *dev)
     128             : {
     129             :         return dev->power.can_wakeup;
     130             : }
     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_destroy(struct wakeup_source *ws) {}
     138             : 
     139             : static inline void wakeup_source_add(struct wakeup_source *ws) {}
     140             : 
     141             : static inline void wakeup_source_remove(struct wakeup_source *ws) {}
     142             : 
     143             : static inline struct wakeup_source *wakeup_source_register(struct device *dev,
     144             :                                                            const char *name)
     145             : {
     146             :         return NULL;
     147             : }
     148             : 
     149             : static inline void wakeup_source_unregister(struct wakeup_source *ws) {}
     150             : 
     151             : static inline int device_wakeup_enable(struct device *dev)
     152             : {
     153             :         dev->power.should_wakeup = true;
     154             :         return 0;
     155             : }
     156             : 
     157             : static inline int device_wakeup_disable(struct device *dev)
     158             : {
     159             :         dev->power.should_wakeup = false;
     160             :         return 0;
     161             : }
     162             : 
     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             : 
     169             : static inline bool device_may_wakeup(struct device *dev)
     170             : {
     171             :         return dev->power.can_wakeup && dev->power.should_wakeup;
     172             : }
     173             : 
     174             : static inline bool device_wakeup_path(struct device *dev)
     175             : {
     176             :         return false;
     177             : }
     178             : 
     179             : static inline void device_set_wakeup_path(struct device *dev) {}
     180             : 
     181             : static inline void __pm_stay_awake(struct wakeup_source *ws) {}
     182             : 
     183             : static inline void pm_stay_awake(struct device *dev) {}
     184             : 
     185             : static inline void __pm_relax(struct wakeup_source *ws) {}
     186             : 
     187             : static inline void pm_relax(struct device *dev) {}
     188             : 
     189             : static inline void pm_wakeup_ws_event(struct wakeup_source *ws,
     190             :                                       unsigned int msec, bool hard) {}
     191             : 
     192             : static inline void pm_wakeup_dev_event(struct device *dev, unsigned int msec,
     193             :                                        bool hard) {}
     194             : 
     195             : #endif /* !CONFIG_PM_SLEEP */
     196             : 
     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             : 
     202             : static inline void pm_wakeup_event(struct device *dev, unsigned int msec)
     203             : {
     204           0 :         return pm_wakeup_dev_event(dev, msec, false);
     205             : }
     206             : 
     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             :  */
     223           0 : static inline int device_init_wakeup(struct device *dev, bool enable)
     224             : {
     225           0 :         if (enable) {
     226           0 :                 device_set_wakeup_capable(dev, true);
     227           0 :                 return device_wakeup_enable(dev);
     228             :         } else {
     229           0 :                 device_wakeup_disable(dev);
     230           0 :                 device_set_wakeup_capable(dev, false);
     231           0 :                 return 0;
     232             :         }
     233             : }
     234             : 
     235             : #endif /* _LINUX_PM_WAKEUP_H */