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