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 #define WATCHDOG_NOWAYOUT IS_BUILTIN(CONFIG_WATCHDOG_NOWAYOUT) 101 #define WATCHDOG_NOWAYOUT_INIT_STATUS (WATCHDOG_NOWAYOUT << WDOG_NO_WAY_OUT) 102 103 /* Use the following function to check whether or not the watchdog is active */ 104 static inline bool watchdog_active(struct watchdog_device *wdd) 105 { 106 return test_bit(WDOG_ACTIVE, &wdd->status); 107 } 108 109 /* Use the following function to set the nowayout feature */ 110 static inline void watchdog_set_nowayout(struct watchdog_device *wdd, bool nowayout) 111 { 112 if (nowayout) 113 set_bit(WDOG_NO_WAY_OUT, &wdd->status); 114 } 115 116 /* Use the following function to check if a timeout value is invalid */ 117 static inline bool watchdog_timeout_invalid(struct watchdog_device *wdd, unsigned int t) 118 { 119 return ((wdd->max_timeout != 0) && 120 (t < wdd->min_timeout || t > wdd->max_timeout)); 121 } 122 123 /* Use the following functions to manipulate watchdog driver specific data */ 124 static inline void watchdog_set_drvdata(struct watchdog_device *wdd, void *data) 125 { 126 wdd->driver_data = data; 127 } 128 129 static inline void *watchdog_get_drvdata(struct watchdog_device *wdd) 130 { 131 return wdd->driver_data; 132 } 133 134 /* drivers/watchdog/watchdog_core.c */ 135 extern int watchdog_init_timeout(struct watchdog_device *wdd, 136 unsigned int timeout_parm, struct device *dev); 137 extern int watchdog_register_device(struct watchdog_device *); 138 extern void watchdog_unregister_device(struct watchdog_device *); 139 140 #endif /* ifndef _LINUX_WATCHDOG_H */ 141