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