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