drivers/char/watchdog/at91rm9200_wdt.c

   1 /*
   2  * Watchdog driver for Atmel AT91RM9200 (Thunder)
   3  *
   4  *  Copyright (C) 2003 SAN People (Pty) Ltd
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version
   9  * 2 of the License, or (at your option) any later version.
  10  */
  11
  12 #include <linux/errno.h>
  13 #include <linux/fs.h>
  14 #include <linux/init.h>
  15 #include <linux/kernel.h>
  16 #include <linux/miscdevice.h>
  17 #include <linux/module.h>
  18 #include <linux/moduleparam.h>
  19 #include <linux/platform_device.h>
  20 #include <linux/types.h>
  21 #include <linux/watchdog.h>
  22 #include <asm/bitops.h>
  23 #include <asm/uaccess.h>
  24
  25
  26 #define WDT_DEFAULT_TIME        5       /* seconds */
  27 #define WDT_MAX_TIME            256     /* seconds */
  28
  29 static int wdt_time = WDT_DEFAULT_TIME;
  30 static int nowayout = WATCHDOG_NOWAYOUT;
  31
  32 module_param(wdt_time, int, 0);
  33 MODULE_PARM_DESC(wdt_time, "Watchdog time in seconds. (default="__MODULE_STRING(WDT_DEFAULT_TIME) ")");
  34
  35 #ifdef CONFIG_WATCHDOG_NOWAYOUT
  36 module_param(nowayout, int, 0);
  37 MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=" __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
  38 #endif
  39
  40
  41 static unsigned long at91wdt_busy;
  42
  43 /* ......................................................................... */
  44
  45 /*
  46  * Disable the watchdog.
  47  */
  48 static void inline at91_wdt_stop(void)
  49 {
  50         at91_sys_write(AT91_ST_WDMR, AT91_ST_EXTEN);
  51 }
  52
  53 /*
  54  * Enable and reset the watchdog.
  55  */
  56 static void inline at91_wdt_start(void)
  57 {
  58         at91_sys_write(AT91_ST_WDMR, AT91_ST_EXTEN | AT91_ST_RSTEN | (((65536 * wdt_time) >> 8) & AT91_ST_WDV));
  59         at91_sys_write(AT91_ST_CR, AT91_ST_WDRST);
  60 }
  61
  62 /*
  63  * Reload the watchdog timer.  (ie, pat the watchdog)
  64  */
  65 static void inline at91_wdt_reload(void)
  66 {
  67         at91_sys_write(AT91_ST_CR, AT91_ST_WDRST);
  68 }
  69
  70 /* ......................................................................... */
  71
  72 /*
  73  * Watchdog device is opened, and watchdog starts running.
  74  */
  75 static int at91_wdt_open(struct inode *inode, struct file *file)
  76 {
  77         if (test_and_set_bit(0, &at91wdt_busy))
  78                 return -EBUSY;
  79
  80         at91_wdt_start();
  81         return nonseekable_open(inode, file);
  82 }
  83
  84 /*
  85  * Close the watchdog device.
  86  * If CONFIG_WATCHDOG_NOWAYOUT is NOT defined then the watchdog is also
  87  *  disabled.
  88  */
  89 static int at91_wdt_close(struct inode *inode, struct file *file)
  90 {
  91         if (!nowayout)
  92                 at91_wdt_stop();        /* Disable the watchdog when file is closed */
  93
  94         clear_bit(0, &at91wdt_busy);
  95         return 0;
  96 }
  97
  98 /*
  99  * Change the watchdog time interval.
 100  */
 101 static int at91_wdt_settimeout(int new_time)
 102 {
 103         /*
 104          * All counting occurs at SLOW_CLOCK / 128 = 0.256 Hz
 105          *
 106          * Since WDV is a 16-bit counter, the maximum period is
 107          * 65536 / 0.256 = 256 seconds.
 108          */
 109         if ((new_time <= 0) || (new_time > WDT_MAX_TIME))
 110                 return -EINVAL;
 111
 112         /* Set new watchdog time. It will be used when at91_wdt_start() is called. */
 113         wdt_time = new_time;
 114         return 0;
 115 }
 116
 117 static struct watchdog_info at91_wdt_info = {
 118         .identity       = "at91 watchdog",
 119         .options        = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING,
 120 };
 121
 122 /*
 123  * Handle commands from user-space.
 124  */
 125 static int at91_wdt_ioctl(struct inode *inode, struct file *file,
 126                 unsigned int cmd, unsigned long arg)
 127 {
 128         void __user *argp = (void __user *)arg;
 129         int __user *p = argp;
 130         int new_value;
 131
 132         switch(cmd) {
 133                 case WDIOC_KEEPALIVE:
 134                         at91_wdt_reload();      /* pat the watchdog */
 135                         return 0;
 136
 137                 case WDIOC_GETSUPPORT:
 138                         return copy_to_user(argp, &at91_wdt_info, sizeof(at91_wdt_info)) ? -EFAULT : 0;
 139
 140                 case WDIOC_SETTIMEOUT:
 141                         if (get_user(new_value, p))
 142                                 return -EFAULT;
 143
 144                         if (at91_wdt_settimeout(new_value))
 145                                 return -EINVAL;
 146
 147                         /* Enable new time value */
 148                         at91_wdt_start();
 149
 150                         /* Return current value */
 151                         return put_user(wdt_time, p);
 152
 153                 case WDIOC_GETTIMEOUT:
 154                         return put_user(wdt_time, p);
 155
 156                 case WDIOC_GETSTATUS:
 157                 case WDIOC_GETBOOTSTATUS:
 158                         return put_user(0, p);
 159
 160                 case WDIOC_SETOPTIONS:
 161                         if (get_user(new_value, p))
 162                                 return -EFAULT;
 163
 164                         if (new_value & WDIOS_DISABLECARD)
 165                                 at91_wdt_stop();
 166                         if (new_value & WDIOS_ENABLECARD)
 167                                 at91_wdt_start();
 168                         return 0;
 169
 170                 default:
 171                         return -ENOTTY;
 172         }
 173 }
 174
 175 /*
 176  * Pat the watchdog whenever device is written to.
 177  */
 178 static ssize_t at91_wdt_write(struct file *file, const char *data, size_t len, loff_t *ppos)
 179 {
 180         at91_wdt_reload();              /* pat the watchdog */
 181         return len;
 182 }
 183
 184 /* ......................................................................... */
 185
 186 static const struct file_operations at91wdt_fops = {
 187         .owner          = THIS_MODULE,
 188         .llseek         = no_llseek,
 189         .ioctl          = at91_wdt_ioctl,
 190         .open           = at91_wdt_open,
 191         .release        = at91_wdt_close,
 192         .write          = at91_wdt_write,
 193 };
 194
 195 static struct miscdevice at91wdt_miscdev = {
 196         .minor          = WATCHDOG_MINOR,
 197         .name           = "watchdog",
 198         .fops           = &at91wdt_fops,
 199 };
 200
 201 static int __init at91wdt_probe(struct platform_device *pdev)
 202 {
 203         int res;
 204
 205         if (at91wdt_miscdev.dev)
 206                 return -EBUSY;
 207         at91wdt_miscdev.dev = &pdev->dev;
 208
 209         res = misc_register(&at91wdt_miscdev);
 210         if (res)
 211                 return res;
 212
 213         printk("AT91 Watchdog Timer enabled (%d seconds%s)\n", wdt_time, nowayout ? ", nowayout" : "");
 214         return 0;
 215 }
 216
 217 static int __exit at91wdt_remove(struct platform_device *pdev)
 218 {
 219         int res;
 220
 221         res = misc_deregister(&at91wdt_miscdev);
 222         if (!res)
 223                 at91wdt_miscdev.dev = NULL;
 224
 225         return res;
 226 }
 227
 228 static void at91wdt_shutdown(struct platform_device *pdev)
 229 {
 230         at91_wdt_stop();
 231 }
 232
 233 #ifdef CONFIG_PM
 234
 235 static int at91wdt_suspend(struct platform_device *pdev, pm_message_t message)
 236 {
 237         at91_wdt_stop();
 238         return 0;
 239 }
 240
 241 static int at91wdt_resume(struct platform_device *pdev)
 242 {
 243         if (at91wdt_busy)
 244                 at91_wdt_start();
 245                 return 0;
 246 }
 247
 248 #else
 249 #define at91wdt_suspend NULL
 250 #define at91wdt_resume  NULL
 251 #endif
 252
 253 static struct platform_driver at91wdt_driver = {
 254         .probe          = at91wdt_probe,
 255         .remove         = __exit_p(at91wdt_remove),
 256         .shutdown       = at91wdt_shutdown,
 257         .suspend        = at91wdt_suspend,
 258         .resume         = at91wdt_resume,
 259         .driver         = {
 260                 .name   = "at91_wdt",
 261                 .owner  = THIS_MODULE,
 262         },
 263 };
 264
 265 static int __init at91_wdt_init(void)
 266 {
 267         /* Check that the heartbeat value is within range; if not reset to the default */
 268         if (at91_wdt_settimeout(wdt_time)) {
 269                 at91_wdt_settimeout(WDT_DEFAULT_TIME);
 270                 pr_info("at91_wdt: wdt_time value must be 1 <= wdt_time <= 256, using %d\n", wdt_time);
 271         }
 272
 273         return platform_driver_register(&at91wdt_driver);
 274 }
 275
 276 static void __exit at91_wdt_exit(void)
 277 {
 278         platform_driver_unregister(&at91wdt_driver);
 279 }
 280
 281 module_init(at91_wdt_init);
 282 module_exit(at91_wdt_exit);
 283
 284 MODULE_AUTHOR("Andrew Victor");
 285 MODULE_DESCRIPTION("Watchdog driver for Atmel AT91RM9200");
 286 MODULE_LICENSE("GPL");
 287 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);