LXR linux/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
  17struct watchdog_ops;
  18struct 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 */
  38struct 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 */
  78struct 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 */
 104static 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 */
 110static 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 */
 117static 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 */
 124static inline void watchdog_set_drvdata(struct watchdog_device *wdd, void *data)
 125{
 126        wdd->driver_data = data;
 127}
 128
 129static inline void *watchdog_get_drvdata(struct watchdog_device *wdd)
 130{
 131        return wdd->driver_data;
 132}
 133
 134/* drivers/watchdog/watchdog_core.c */
 135extern int watchdog_init_timeout(struct watchdog_device *wdd,
 136                                  unsigned int timeout_parm, struct device *dev);
 137extern int watchdog_register_device(struct watchdog_device *);
 138extern void watchdog_unregister_device(struct watchdog_device *);
 139
 140#ifdef CONFIG_HARDLOCKUP_DETECTOR
 141void watchdog_nmi_disable_all(void);
 142void watchdog_nmi_enable_all(void);
 143#else
 144static inline void watchdog_nmi_disable_all(void) {}
 145static inline void watchdog_nmi_enable_all(void) {}
 146#endif
 147
 148#endif  /* ifndef _LINUX_WATCHDOG_H */
 149