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
   9 #ifndef _LINUX_WATCHDOG_H
  10 #define _LINUX_WATCHDOG_H
  11
  12 #include <linux/ioctl.h>
  13 #include <linux/types.h>
  14
  15 #define WATCHDOG_IOCTL_BASE     'W'
  16
  17 struct watchdog_info {
  18         __u32 options;          /* Options the card/driver supports */
  19         __u32 firmware_version; /* Firmware version of the card */
  20         __u8  identity[32];     /* Identity of the board */
  21 };
  22
  23 #define WDIOC_GETSUPPORT        _IOR(WATCHDOG_IOCTL_BASE, 0, struct watchdog_info)
  24 #define WDIOC_GETSTATUS         _IOR(WATCHDOG_IOCTL_BASE, 1, int)
  25 #define WDIOC_GETBOOTSTATUS     _IOR(WATCHDOG_IOCTL_BASE, 2, int)
  26 #define WDIOC_GETTEMP           _IOR(WATCHDOG_IOCTL_BASE, 3, int)
  27 #define WDIOC_SETOPTIONS        _IOR(WATCHDOG_IOCTL_BASE, 4, int)
  28 #define WDIOC_KEEPALIVE         _IOR(WATCHDOG_IOCTL_BASE, 5, int)
  29 #define WDIOC_SETTIMEOUT        _IOWR(WATCHDOG_IOCTL_BASE, 6, int)
  30 #define WDIOC_GETTIMEOUT        _IOR(WATCHDOG_IOCTL_BASE, 7, int)
  31 #define WDIOC_SETPRETIMEOUT     _IOWR(WATCHDOG_IOCTL_BASE, 8, int)
  32 #define WDIOC_GETPRETIMEOUT     _IOR(WATCHDOG_IOCTL_BASE, 9, int)
  33 #define WDIOC_GETTIMELEFT       _IOR(WATCHDOG_IOCTL_BASE, 10, int)
  34
  35 #define WDIOF_UNKNOWN           -1      /* Unknown flag error */
  36 #define WDIOS_UNKNOWN           -1      /* Unknown status error */
  37
  38 #define WDIOF_OVERHEAT          0x0001  /* Reset due to CPU overheat */
  39 #define WDIOF_FANFAULT          0x0002  /* Fan failed */
  40 #define WDIOF_EXTERN1           0x0004  /* External relay 1 */
  41 #define WDIOF_EXTERN2           0x0008  /* External relay 2 */
  42 #define WDIOF_POWERUNDER        0x0010  /* Power bad/power fault */
  43 #define WDIOF_CARDRESET         0x0020  /* Card previously reset the CPU */
  44 #define WDIOF_POWEROVER         0x0040  /* Power over voltage */
  45 #define WDIOF_SETTIMEOUT        0x0080  /* Set timeout (in seconds) */
  46 #define WDIOF_MAGICCLOSE        0x0100  /* Supports magic close char */
  47 #define WDIOF_PRETIMEOUT        0x0200  /* Pretimeout (in seconds), get/set */
  48 #define WDIOF_ALARMONLY         0x0400  /* Watchdog triggers a management or
  49                                            other external alarm not a reboot */
  50 #define WDIOF_KEEPALIVEPING     0x8000  /* Keep alive ping reply */
  51
  52 #define WDIOS_DISABLECARD       0x0001  /* Turn off the watchdog timer */
  53 #define WDIOS_ENABLECARD        0x0002  /* Turn on the watchdog timer */
  54 #define WDIOS_TEMPPANIC         0x0004  /* Kernel panic on temperature trip */
  55
  56 #ifdef __KERNEL__
  57
  58 #include <linux/bitops.h>
  59 #include <linux/device.h>
  60 #include <linux/cdev.h>
  61
  62 struct watchdog_ops;
  63 struct watchdog_device;
  64
  65 /** struct watchdog_ops - The watchdog-devices operations
  66  *
  67  * @owner:      The module owner.
  68  * @start:      The routine for starting the watchdog device.
  69  * @stop:       The routine for stopping the watchdog device.
  70  * @ping:       The routine that sends a keepalive ping to the watchdog device.
  71  * @status:     The routine that shows the status of the watchdog device.
  72  * @set_timeout:The routine for setting the watchdog devices timeout value.
  73  * @get_timeleft:The routine that get's the time that's left before a reset.
  74  * @ioctl:      The routines that handles extra ioctl calls.
  75  *
  76  * The watchdog_ops structure contains a list of low-level operations
  77  * that control a watchdog device. It also contains the module that owns
  78  * these operations. The start and stop function are mandatory, all other
  79  * functions are optonal.
  80  */
  81 struct watchdog_ops {
  82         struct module *owner;
  83         /* mandatory operations */
  84         int (*start)(struct watchdog_device *);
  85         int (*stop)(struct watchdog_device *);
  86         /* optional operations */
  87         int (*ping)(struct watchdog_device *);
  88         unsigned int (*status)(struct watchdog_device *);
  89         int (*set_timeout)(struct watchdog_device *, unsigned int);
  90         unsigned int (*get_timeleft)(struct watchdog_device *);
  91         long (*ioctl)(struct watchdog_device *, unsigned int, unsigned long);
  92 };
  93
  94 /** struct watchdog_device - The structure that defines a watchdog device
  95  *
  96  * @id:         The watchdog's ID. (Allocated by watchdog_register_device)
  97  * @cdev:       The watchdog's Character device.
  98  * @dev:        The device for our watchdog
  99  * @parent:     The parent bus device
 100  * @info:       Pointer to a watchdog_info structure.
 101  * @ops:        Pointer to the list of watchdog operations.
 102  * @bootstatus: Status of the watchdog device at boot.
 103  * @timeout:    The watchdog devices timeout value.
 104  * @min_timeout:The watchdog devices minimum timeout value.
 105  * @max_timeout:The watchdog devices maximum timeout value.
 106  * @driver-data:Pointer to the drivers private data.
 107  * @status:     Field that contains the devices internal status bits.
 108  *
 109  * The watchdog_device structure contains all information about a
 110  * watchdog timer device.
 111  *
 112  * The driver-data field may not be accessed directly. It must be accessed
 113  * via the watchdog_set_drvdata and watchdog_get_drvdata helpers.
 114  */
 115 struct watchdog_device {
 116         int id;
 117         struct cdev cdev;
 118         struct device *dev;
 119         struct device *parent;
 120         const struct watchdog_info *info;
 121         const struct watchdog_ops *ops;
 122         unsigned int bootstatus;
 123         unsigned int timeout;
 124         unsigned int min_timeout;
 125         unsigned int max_timeout;
 126         void *driver_data;
 127         unsigned long status;
 128 /* Bit numbers for status flags */
 129 #define WDOG_ACTIVE             0       /* Is the watchdog running/active */
 130 #define WDOG_DEV_OPEN           1       /* Opened via /dev/watchdog ? */
 131 #define WDOG_ALLOW_RELEASE      2       /* Did we receive the magic char ? */
 132 #define WDOG_NO_WAY_OUT         3       /* Is 'nowayout' feature set ? */
 133 };
 134
 135 #ifdef CONFIG_WATCHDOG_NOWAYOUT
 136 #define WATCHDOG_NOWAYOUT               1
 137 #define WATCHDOG_NOWAYOUT_INIT_STATUS   (1 << WDOG_NO_WAY_OUT)
 138 #else
 139 #define WATCHDOG_NOWAYOUT               0
 140 #define WATCHDOG_NOWAYOUT_INIT_STATUS   0
 141 #endif
 142
 143 /* Use the following function to check wether or not the watchdog is active */
 144 static inline bool watchdog_active(struct watchdog_device *wdd)
 145 {
 146         return test_bit(WDOG_ACTIVE, &wdd->status);
 147 }
 148
 149 /* Use the following function to set the nowayout feature */
 150 static inline void watchdog_set_nowayout(struct watchdog_device *wdd, bool nowayout)
 151 {
 152         if (nowayout)
 153                 set_bit(WDOG_NO_WAY_OUT, &wdd->status);
 154 }
 155
 156 /* Use the following functions to manipulate watchdog driver specific data */
 157 static inline void watchdog_set_drvdata(struct watchdog_device *wdd, void *data)
 158 {
 159         wdd->driver_data = data;
 160 }
 161
 162 static inline void *watchdog_get_drvdata(struct watchdog_device *wdd)
 163 {
 164         return wdd->driver_data;
 165 }
 166
 167 /* drivers/watchdog/core/watchdog_core.c */
 168 extern int watchdog_register_device(struct watchdog_device *);
 169 extern void watchdog_unregister_device(struct watchdog_device *);
 170
 171 #endif  /* __KERNEL__ */
 172
 173 #endif  /* ifndef _LINUX_WATCHDOG_H */