include/linux/watchdog.h

   1 /*
   2  *      Generic watchdog defines. Derived from..
   3  *
   4  * Berkshire PC Watchdog Defines
   5  * by Ken Hollis <khollis@bitgate.com>
   6  *
   7  */
   8 #ifndef _LINUX_WATCHDOG_H
   9 #define _LINUX_WATCHDOG_H
  10
  11
  12 #include <linux/bitops.h>
  13 #include <linux/device.h>
  14 #include <linux/cdev.h>
  15 #include <uapi/linux/watchdog.h>
  16
  17 struct watchdog_ops;
  18 struct watchdog_device;
  19
  20 /** struct watchdog_ops - The watchdog-devices operations
  21  *
  22  * @owner:      The module owner.
  23  * @start:      The routine for starting the watchdog device.
  24  * @stop:       The routine for stopping the watchdog device.
  25  * @ping:       The routine that sends a keepalive ping to the watchdog device.
  26  * @status:     The routine that shows the status of the watchdog device.
  27  * @set_timeout:The routine for setting the watchdog devices timeout value (in seconds).
  28  * @get_timeleft:The routine that gets the time left before a reset (in seconds).
  29  * @ref:        The ref operation for dyn. allocated watchdog_device structs
  30  * @unref:      The unref operation for dyn. allocated watchdog_device structs
  31  * @ioctl:      The routines that handles extra ioctl calls.
  32  *
  33  * The watchdog_ops structure contains a list of low-level operations
  34  * that control a watchdog device. It also contains the module that owns
  35  * these operations. The start and stop function are mandatory, all other
  36  * functions are optional.
  37  */
  38 struct watchdog_ops {
  39         struct module *owner;
  40         /* mandatory operations */
  41         int (*start)(struct watchdog_device *);
  42         int (*stop)(struct watchdog_device *);
  43         /* optional operations */
  44         int (*ping)(struct watchdog_device *);
  45         unsigned int (*status)(struct watchdog_device *);
  46         int (*set_timeout)(struct watchdog_device *, unsigned int);
  47         unsigned int (*get_timeleft)(struct watchdog_device *);
  48         void (*ref)(struct watchdog_device *);
  49         void (*unref)(struct watchdog_device *);
  50         long (*ioctl)(struct watchdog_device *, unsigned int, unsigned long);
  51 };
  52
  53 /** struct watchdog_device - The structure that defines a watchdog device
  54  *
  55  * @id:         The watchdog's ID. (Allocated by watchdog_register_device)
  56  * @cdev:       The watchdog's Character device.
  57  * @dev:        The device for our watchdog
  58  * @parent:     The parent bus device
  59  * @info:       Pointer to a watchdog_info structure.
  60  * @ops:        Pointer to the list of watchdog operations.
  61  * @bootstatus: Status of the watchdog device at boot.
  62  * @timeout:    The watchdog devices timeout value (in seconds).
  63  * @min_timeout:The watchdog devices minimum timeout value (in seconds).
  64  * @max_timeout:The watchdog devices maximum timeout value (in seconds).
  65  * @driver-data:Pointer to the drivers private data.
  66  * @lock:       Lock for watchdog core internal use only.
  67  * @status:     Field that contains the devices internal status bits.
  68  * @deferred: entry in wtd_deferred_reg_list which is used to
  69  *                         register early initialized watchdogs.
  70  *
  71  * The watchdog_device structure contains all information about a
  72  * watchdog timer device.
  73  *
  74  * The driver-data field may not be accessed directly. It must be accessed
  75  * via the watchdog_set_drvdata and watchdog_get_drvdata helpers.
  76  *
  77  * The lock field is for watchdog core internal use only and should not be
  78  * touched.
  79  */
  80 struct watchdog_device {
  81         int id;
  82         struct cdev cdev;
  83         struct device *dev;
  84         struct device *parent;
  85         const struct watchdog_info *info;
  86         const struct watchdog_ops *ops;
  87         unsigned int bootstatus;
  88         unsigned int timeout;
  89         unsigned int min_timeout;
  90         unsigned int max_timeout;
  91         void *driver_data;
  92         struct mutex lock;
  93         unsigned long status;
  94 /* Bit numbers for status flags */
  95 #define WDOG_ACTIVE             0       /* Is the watchdog running/active */
  96 #define WDOG_DEV_OPEN           1       /* Opened via /dev/watchdog ? */
  97 #define WDOG_ALLOW_RELEASE      2       /* Did we receive the magic char ? */
  98 #define WDOG_NO_WAY_OUT         3       /* Is 'nowayout' feature set ? */
  99 #define WDOG_UNREGISTERED       4       /* Has the device been unregistered */
 100         struct list_head deferred;
 101 };
 102
 103 #define WATCHDOG_NOWAYOUT               IS_BUILTIN(CONFIG_WATCHDOG_NOWAYOUT)
 104 #define WATCHDOG_NOWAYOUT_INIT_STATUS   (WATCHDOG_NOWAYOUT << WDOG_NO_WAY_OUT)
 105
 106 /* Use the following function to check whether or not the watchdog is active */
 107 static inline bool watchdog_active(struct watchdog_device *wdd)
 108 {
 109         return test_bit(WDOG_ACTIVE, &wdd->status);
 110 }
 111
 112 /* Use the following function to set the nowayout feature */
 113 static inline void watchdog_set_nowayout(struct watchdog_device *wdd, bool nowayout)
 114 {
 115         if (nowayout)
 116                 set_bit(WDOG_NO_WAY_OUT, &wdd->status);
 117 }
 118
 119 /* Use the following function to check if a timeout value is invalid */
 120 static inline bool watchdog_timeout_invalid(struct watchdog_device *wdd, unsigned int t)
 121 {
 122         /*
 123          * The timeout is invalid if
 124          * - the requested value is smaller than the configured minimum timeout,
 125          * or
 126          * - a maximum timeout is configured, and the requested value is larger
 127          *   than the maximum timeout.
 128          */
 129         return t < wdd->min_timeout ||
 130                 (wdd->max_timeout && t > wdd->max_timeout);
 131 }
 132
 133 /* Use the following functions to manipulate watchdog driver specific data */
 134 static inline void watchdog_set_drvdata(struct watchdog_device *wdd, void *data)
 135 {
 136         wdd->driver_data = data;
 137 }
 138
 139 static inline void *watchdog_get_drvdata(struct watchdog_device *wdd)
 140 {
 141         return wdd->driver_data;
 142 }
 143
 144 /* drivers/watchdog/watchdog_core.c */
 145 extern int watchdog_init_timeout(struct watchdog_device *wdd,
 146                                   unsigned int timeout_parm, struct device *dev);
 147 extern int watchdog_register_device(struct watchdog_device *);
 148 extern void watchdog_unregister_device(struct watchdog_device *);
 149
 150 #endif  /* ifndef _LINUX_WATCHDOG_H */