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