linux/include/linux/watchdog.h
<<
>>
Prefs
   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
  17struct 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
  62struct watchdog_ops;
  63struct 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 * @ref:        The ref operation for dyn. allocated watchdog_device structs
  75 * @unref:      The unref operation for dyn. allocated watchdog_device structs
  76 * @ioctl:      The routines that handles extra ioctl calls.
  77 *
  78 * The watchdog_ops structure contains a list of low-level operations
  79 * that control a watchdog device. It also contains the module that owns
  80 * these operations. The start and stop function are mandatory, all other
  81 * functions are optonal.
  82 */
  83struct watchdog_ops {
  84        struct module *owner;
  85        /* mandatory operations */
  86        int (*start)(struct watchdog_device *);
  87        int (*stop)(struct watchdog_device *);
  88        /* optional operations */
  89        int (*ping)(struct watchdog_device *);
  90        unsigned int (*status)(struct watchdog_device *);
  91        int (*set_timeout)(struct watchdog_device *, unsigned int);
  92        unsigned int (*get_timeleft)(struct watchdog_device *);
  93        void (*ref)(struct watchdog_device *);
  94        void (*unref)(struct watchdog_device *);
  95        long (*ioctl)(struct watchdog_device *, unsigned int, unsigned long);
  96};
  97
  98/** struct watchdog_device - The structure that defines a watchdog device
  99 *
 100 * @id:         The watchdog's ID. (Allocated by watchdog_register_device)
 101 * @cdev:       The watchdog's Character device.
 102 * @dev:        The device for our watchdog
 103 * @parent:     The parent bus device
 104 * @info:       Pointer to a watchdog_info structure.
 105 * @ops:        Pointer to the list of watchdog operations.
 106 * @bootstatus: Status of the watchdog device at boot.
 107 * @timeout:    The watchdog devices timeout value.
 108 * @min_timeout:The watchdog devices minimum timeout value.
 109 * @max_timeout:The watchdog devices maximum timeout value.
 110 * @driver-data:Pointer to the drivers private data.
 111 * @lock:       Lock for watchdog core internal use only.
 112 * @status:     Field that contains the devices internal status bits.
 113 *
 114 * The watchdog_device structure contains all information about a
 115 * watchdog timer device.
 116 *
 117 * The driver-data field may not be accessed directly. It must be accessed
 118 * via the watchdog_set_drvdata and watchdog_get_drvdata helpers.
 119 *
 120 * The lock field is for watchdog core internal use only and should not be
 121 * touched.
 122 */
 123struct watchdog_device {
 124        int id;
 125        struct cdev cdev;
 126        struct device *dev;
 127        struct device *parent;
 128        const struct watchdog_info *info;
 129        const struct watchdog_ops *ops;
 130        unsigned int bootstatus;
 131        unsigned int timeout;
 132        unsigned int min_timeout;
 133        unsigned int max_timeout;
 134        void *driver_data;
 135        struct mutex lock;
 136        unsigned long status;
 137/* Bit numbers for status flags */
 138#define WDOG_ACTIVE             0       /* Is the watchdog running/active */
 139#define WDOG_DEV_OPEN           1       /* Opened via /dev/watchdog ? */
 140#define WDOG_ALLOW_RELEASE      2       /* Did we receive the magic char ? */
 141#define WDOG_NO_WAY_OUT         3       /* Is 'nowayout' feature set ? */
 142#define WDOG_UNREGISTERED       4       /* Has the device been unregistered */
 143};
 144
 145#ifdef CONFIG_WATCHDOG_NOWAYOUT
 146#define WATCHDOG_NOWAYOUT               1
 147#define WATCHDOG_NOWAYOUT_INIT_STATUS   (1 << WDOG_NO_WAY_OUT)
 148#else
 149#define WATCHDOG_NOWAYOUT               0
 150#define WATCHDOG_NOWAYOUT_INIT_STATUS   0
 151#endif
 152
 153/* Use the following function to check wether or not the watchdog is active */
 154static inline bool watchdog_active(struct watchdog_device *wdd)
 155{
 156        return test_bit(WDOG_ACTIVE, &wdd->status);
 157}
 158
 159/* Use the following function to set the nowayout feature */
 160static inline void watchdog_set_nowayout(struct watchdog_device *wdd, bool nowayout)
 161{
 162        if (nowayout)
 163                set_bit(WDOG_NO_WAY_OUT, &wdd->status);
 164}
 165
 166/* Use the following functions to manipulate watchdog driver specific data */
 167static inline void watchdog_set_drvdata(struct watchdog_device *wdd, void *data)
 168{
 169        wdd->driver_data = data;
 170}
 171
 172static inline void *watchdog_get_drvdata(struct watchdog_device *wdd)
 173{
 174        return wdd->driver_data;
 175}
 176
 177/* drivers/watchdog/core/watchdog_core.c */
 178extern int watchdog_register_device(struct watchdog_device *);
 179extern void watchdog_unregister_device(struct watchdog_device *);
 180
 181#endif  /* __KERNEL__ */
 182
 183#endif  /* ifndef _LINUX_WATCHDOG_H */
 184
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.