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 */
watchdog_active(struct watchdog_device * wdd)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 */
watchdog_set_nowayout(struct watchdog_device * wdd,bool nowayout)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 */
watchdog_timeout_invalid(struct watchdog_device * wdd,unsigned int t)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 */
watchdog_set_drvdata(struct watchdog_device * wdd,void * data)134 static inline void watchdog_set_drvdata(struct watchdog_device *wdd, void *data)
135 {
136 wdd->driver_data = data;
137 }
138
watchdog_get_drvdata(struct watchdog_device * wdd)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 */
151