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