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