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