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.
  28  * @get_timeleft:The routine that get's the time that's left before a reset.
  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 optonal.
  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.
  63  * @min_timeout:The watchdog devices minimum timeout value.
  64  * @max_timeout:The watchdog devices maximum timeout value.
  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  *
  69  * The watchdog_device structure contains all information about a
  70  * watchdog timer device.
  71  *
  72  * The driver-data field may not be accessed directly. It must be accessed
  73  * via the watchdog_set_drvdata and watchdog_get_drvdata helpers.
  74  *
  75  * The lock field is for watchdog core internal use only and should not be
  76  * touched.
  77  */
  78 struct watchdog_device {
  79         int id;
  80         struct cdev cdev;
  81         struct device *dev;
  82         struct device *parent;
  83         const struct watchdog_info *info;
  84         const struct watchdog_ops *ops;
  85         unsigned int bootstatus;
  86         unsigned int timeout;
  87         unsigned int min_timeout;
  88         unsigned int max_timeout;
  89         void *driver_data;
  90         struct mutex lock;
  91         unsigned long status;
  92 /* Bit numbers for status flags */
  93 #define WDOG_ACTIVE             0       /* Is the watchdog running/active */
  94 #define WDOG_DEV_OPEN           1       /* Opened via /dev/watchdog ? */
  95 #define WDOG_ALLOW_RELEASE      2       /* Did we receive the magic char ? */
  96 #define WDOG_NO_WAY_OUT         3       /* Is 'nowayout' feature set ? */
  97 #define WDOG_UNREGISTERED       4       /* Has the device been unregistered */
  98 };
  99
 100 #ifdef CONFIG_WATCHDOG_NOWAYOUT
 101 #define WATCHDOG_NOWAYOUT               1
 102 #define WATCHDOG_NOWAYOUT_INIT_STATUS   (1 << WDOG_NO_WAY_OUT)
 103 #else
 104 #define WATCHDOG_NOWAYOUT               0
 105 #define WATCHDOG_NOWAYOUT_INIT_STATUS   0
 106 #endif
 107
 108 /* Use the following function to check whether or not the watchdog is active */
 109 static inline bool watchdog_active(struct watchdog_device *wdd)
 110 {
 111         return test_bit(WDOG_ACTIVE, &wdd->status);
 112 }
 113
 114 /* Use the following function to set the nowayout feature */
 115 static inline void watchdog_set_nowayout(struct watchdog_device *wdd, bool nowayout)
 116 {
 117         if (nowayout)
 118                 set_bit(WDOG_NO_WAY_OUT, &wdd->status);
 119 }
 120
 121 /* Use the following function to check if a timeout value is invalid */
 122 static inline bool watchdog_timeout_invalid(struct watchdog_device *wdd, unsigned int t)
 123 {
 124         return ((wdd->max_timeout != 0) &&
 125                 (t < wdd->min_timeout || t > wdd->max_timeout));
 126 }
 127
 128 /* Use the following functions to manipulate watchdog driver specific data */
 129 static inline void watchdog_set_drvdata(struct watchdog_device *wdd, void *data)
 130 {
 131         wdd->driver_data = data;
 132 }
 133
 134 static inline void *watchdog_get_drvdata(struct watchdog_device *wdd)
 135 {
 136         return wdd->driver_data;
 137 }
 138
 139 /* drivers/watchdog/watchdog_core.c */
 140 extern int watchdog_init_timeout(struct watchdog_device *wdd,
 141                                   unsigned int timeout_parm, struct device *dev);
 142 extern int watchdog_register_device(struct watchdog_device *);
 143 extern void watchdog_unregister_device(struct watchdog_device *);
 144
 145 #endif  /* ifndef _LINUX_WATCHDOG_H */