1/* 2 * Watchdog driver for Atmel AT91SAM9x processors. 3 * 4 * Copyright (C) 2008 Renaud CERRATO r.cerrato@til-technologies.fr 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/* 13 * The Watchdog Timer Mode Register can be only written to once. If the 14 * timeout need to be set from Linux, be sure that the bootstrap or the 15 * bootloader doesn't write to this register. 16 */ 17 18#include <linux/errno.h> 19#include <linux/fs.h> 20#include <linux/init.h> 21#include <linux/io.h> 22#include <linux/kernel.h> 23#include <linux/miscdevice.h> 24#include <linux/module.h> 25#include <linux/moduleparam.h> 26#include <linux/platform_device.h> 27#include <linux/types.h> 28#include <linux/watchdog.h> 29#include <linux/jiffies.h> 30#include <linux/timer.h> 31#include <linux/bitops.h> 32#include <linux/uaccess.h> 33 34#include <mach/at91_wdt.h> 35 36#define DRV_NAME "AT91SAM9 Watchdog" 37 38/* AT91SAM9 watchdog runs a 12bit counter @ 256Hz, 39 * use this to convert a watchdog 40 * value from/to milliseconds. 41 */ 42#define ms_to_ticks(t) (((t << 8) / 1000) - 1) 43#define ticks_to_ms(t) (((t + 1) * 1000) >> 8) 44 45/* Hardware timeout in seconds */ 46#define WDT_HW_TIMEOUT 2 47 48/* Timer heartbeat (500ms) */ 49#define WDT_TIMEOUT (HZ/2) 50 51/* User land timeout */ 52#define WDT_HEARTBEAT 15 53static int heartbeat = WDT_HEARTBEAT; 54module_param(heartbeat, int, 0); 55MODULE_PARM_DESC(heartbeat, "Watchdog heartbeats in seconds. " 56 "(default = " __MODULE_STRING(WDT_HEARTBEAT) ")"); 57 58static int nowayout = WATCHDOG_NOWAYOUT; 59module_param(nowayout, int, 0); 60MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started " 61 "(default=" __MODULE_STRING(WATCHDOG_NOWAYOUT) ")"); 62 63static void at91_ping(unsigned long data); 64 65static struct { 66 unsigned long next_heartbeat; /* the next_heartbeat for the timer */ 67 unsigned long open; 68 char expect_close; 69 struct timer_list timer; /* The timer that pings the watchdog */ 70} at91wdt_private; 71 72/* ......................................................................... */ 73 74 75/* 76 * Reload the watchdog timer. (ie, pat the watchdog) 77 */ 78static inline void at91_wdt_reset(void) 79{ 80 at91_sys_write(AT91_WDT_CR, AT91_WDT_KEY | AT91_WDT_WDRSTT); 81} 82 83/* 84 * Timer tick 85 */ 86static void at91_ping(unsigned long data) 87{ 88 if (time_before(jiffies, at91wdt_private.next_heartbeat) || 89 (!nowayout && !at91wdt_private.open)) { 90 at91_wdt_reset(); 91 mod_timer(&at91wdt_private.timer, jiffies + WDT_TIMEOUT); 92 } else 93 printk(KERN_CRIT DRV_NAME": I will reset your machine !\n"); 94} 95 96/* 97 * Watchdog device is opened, and watchdog starts running. 98 */ 99static int at91_wdt_open(struct inode *inode, struct file *file) 100{ 101 if (test_and_set_bit(0, &at91wdt_private.open)) 102 return -EBUSY; 103 104 at91wdt_private.next_heartbeat = jiffies + heartbeat * HZ; 105 mod_timer(&at91wdt_private.timer, jiffies + WDT_TIMEOUT); 106 107 return nonseekable_open(inode, file); 108} 109 110/* 111 * Close the watchdog device. 112 */ 113static int at91_wdt_close(struct inode *inode, struct file *file) 114{ 115 clear_bit(0, &at91wdt_private.open); 116 117 /* stop internal ping */ 118 if (!at91wdt_private.expect_close) 119 del_timer(&at91wdt_private.timer); 120 121 at91wdt_private.expect_close = 0; 122 return 0; 123} 124 125/* 126 * Set the watchdog time interval in 1/256Hz (write-once) 127 * Counter is 12 bit. 128 */ 129static int at91_wdt_settimeout(unsigned int timeout) 130{ 131 unsigned int reg; 132 unsigned int mr; 133 134 /* Check if disabled */ 135 mr = at91_sys_read(AT91_WDT_MR); 136 if (mr & AT91_WDT_WDDIS) { 137 printk(KERN_ERR DRV_NAME": sorry, watchdog is disabled\n"); 138 return -EIO; 139 } 140 141 /* 142 * All counting occurs at SLOW_CLOCK / 128 = 256 Hz 143 * 144 * Since WDV is a 12-bit counter, the maximum period is 145 * 4096 / 256 = 16 seconds. 146 */ 147 reg = AT91_WDT_WDRSTEN /* causes watchdog reset */ 148 /* | AT91_WDT_WDRPROC causes processor reset only */ 149 | AT91_WDT_WDDBGHLT /* disabled in debug mode */ 150 | AT91_WDT_WDD /* restart at any time */ 151 | (timeout & AT91_WDT_WDV); /* timer value */ 152 at91_sys_write(AT91_WDT_MR, reg); 153 154 return 0; 155} 156 157static const struct watchdog_info at91_wdt_info = { 158 .identity = DRV_NAME, 159 .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING | 160 WDIOF_MAGICCLOSE, 161}; 162 163/* 164 * Handle commands from user-space. 165 */ 166static long at91_wdt_ioctl(struct file *file, 167 unsigned int cmd, unsigned long arg) 168{ 169 void __user *argp = (void __user *)arg; 170 int __user *p = argp; 171 int new_value; 172 173 switch (cmd) { 174 case WDIOC_GETSUPPORT: 175 return copy_to_user(argp, &at91_wdt_info, 176 sizeof(at91_wdt_info)) ? -EFAULT : 0; 177 178 case WDIOC_GETSTATUS: 179 case WDIOC_GETBOOTSTATUS: 180 return put_user(0, p); 181 182 case WDIOC_KEEPALIVE: 183 at91wdt_private.next_heartbeat = jiffies + heartbeat * HZ; 184 return 0; 185 186 case WDIOC_SETTIMEOUT: 187 if (get_user(new_value, p)) 188 return -EFAULT; 189 190 heartbeat = new_value; 191 at91wdt_private.next_heartbeat = jiffies + heartbeat * HZ; 192 193 return put_user(new_value, p); /* return current value */ 194 195 case WDIOC_GETTIMEOUT: 196 return put_user(heartbeat, p); 197 } 198 return -ENOTTY; 199} 200 201/* 202 * Pat the watchdog whenever device is written to. 203 */ 204static ssize_t at91_wdt_write(struct file *file, const char *data, size_t len, 205 loff_t *ppos) 206{ 207 if (!len) 208 return 0; 209 210 /* Scan for magic character */ 211 if (!nowayout) { 212 size_t i; 213 214 at91wdt_private.expect_close = 0; 215 216 for (i = 0; i < len; i++) { 217 char c; 218 if (get_user(c, data + i)) 219 return -EFAULT; 220 if (c == 'V') { 221 at91wdt_private.expect_close = 42; 222 break; 223 } 224 } 225 } 226 227 at91wdt_private.next_heartbeat = jiffies + heartbeat * HZ; 228 229 return len; 230} 231 232/* ......................................................................... */ 233 234static const struct file_operations at91wdt_fops = { 235 .owner = THIS_MODULE, 236 .llseek = no_llseek, 237 .unlocked_ioctl = at91_wdt_ioctl, 238 .open = at91_wdt_open, 239 .release = at91_wdt_close, 240 .write = at91_wdt_write, 241}; 242 243static struct miscdevice at91wdt_miscdev = { 244 .minor = WATCHDOG_MINOR, 245 .name = "watchdog", 246 .fops = &at91wdt_fops, 247}; 248 249static int __init at91wdt_probe(struct platform_device *pdev) 250{ 251 int res; 252 253 if (at91wdt_miscdev.parent) 254 return -EBUSY; 255 at91wdt_miscdev.parent = &pdev->dev; 256 257 /* Set watchdog */ 258 res = at91_wdt_settimeout(ms_to_ticks(WDT_HW_TIMEOUT * 1000)); 259 if (res) 260 return res; 261 262 res = misc_register(&at91wdt_miscdev); 263 if (res) 264 return res; 265 266 at91wdt_private.next_heartbeat = jiffies + heartbeat * HZ; 267 setup_timer(&at91wdt_private.timer, at91_ping, 0); 268 mod_timer(&at91wdt_private.timer, jiffies + WDT_TIMEOUT); 269 270 printk(KERN_INFO DRV_NAME " enabled (heartbeat=%d sec, nowayout=%d)\n", 271 heartbeat, nowayout); 272 273 return 0; 274} 275 276static int __exit at91wdt_remove(struct platform_device *pdev) 277{ 278 int res; 279 280 res = misc_deregister(&at91wdt_miscdev); 281 if (!res) 282 at91wdt_miscdev.parent = NULL; 283 284 return res; 285} 286 287#ifdef CONFIG_PM 288 289static int at91wdt_suspend(struct platform_device *pdev, pm_message_t message) 290{ 291 return 0; 292} 293 294static int at91wdt_resume(struct platform_device *pdev) 295{ 296 return 0; 297} 298 299#else 300#define at91wdt_suspend NULL 301#define at91wdt_resume NULL 302#endif 303 304static struct platform_driver at91wdt_driver = { 305 .remove = __exit_p(at91wdt_remove), 306 .suspend = at91wdt_suspend, 307 .resume = at91wdt_resume, 308 .driver = { 309 .name = "at91_wdt", 310 .owner = THIS_MODULE, 311 }, 312}; 313 314static int __init at91sam_wdt_init(void) 315{ 316 return platform_driver_probe(&at91wdt_driver, at91wdt_probe); 317} 318 319static void __exit at91sam_wdt_exit(void) 320{ 321 platform_driver_unregister(&at91wdt_driver); 322} 323 324module_init(at91sam_wdt_init); 325module_exit(at91sam_wdt_exit); 326 327MODULE_AUTHOR("Renaud CERRATO <r.cerrato@til-technologies.fr>"); 328MODULE_DESCRIPTION("Watchdog driver for Atmel AT91SAM9x processors"); 329MODULE_LICENSE("GPL"); 330MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); 331