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