1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * PIKA FPGA based Watchdog Timer 4 * 5 * Copyright (c) 2008 PIKA Technologies 6 * Sean MacLennan <smaclennan@pikatech.com> 7 */ 8 9 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 10 11 #include <linux/init.h> 12 #include <linux/errno.h> 13 #include <linux/module.h> 14 #include <linux/moduleparam.h> 15 #include <linux/types.h> 16 #include <linux/kernel.h> 17 #include <linux/fs.h> 18 #include <linux/miscdevice.h> 19 #include <linux/watchdog.h> 20 #include <linux/reboot.h> 21 #include <linux/jiffies.h> 22 #include <linux/timer.h> 23 #include <linux/bitops.h> 24 #include <linux/uaccess.h> 25 #include <linux/io.h> 26 #include <linux/of_address.h> 27 #include <linux/of_platform.h> 28 29 #define DRV_NAME "PIKA-WDT" 30 31 /* Hardware timeout in seconds */ 32 #define WDT_HW_TIMEOUT 2 33 34 /* Timer heartbeat (500ms) */ 35 #define WDT_TIMEOUT (HZ/2) 36 37 /* User land timeout */ 38 #define WDT_HEARTBEAT 15 39 static int heartbeat = WDT_HEARTBEAT; 40 module_param(heartbeat, int, 0); 41 MODULE_PARM_DESC(heartbeat, "Watchdog heartbeats in seconds. " 42 "(default = " __MODULE_STRING(WDT_HEARTBEAT) ")"); 43 44 static bool nowayout = WATCHDOG_NOWAYOUT; 45 module_param(nowayout, bool, 0); 46 MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started " 47 "(default=" __MODULE_STRING(WATCHDOG_NOWAYOUT) ")"); 48 49 static struct { 50 void __iomem *fpga; 51 unsigned long next_heartbeat; /* the next_heartbeat for the timer */ 52 unsigned long open; 53 char expect_close; 54 int bootstatus; 55 struct timer_list timer; /* The timer that pings the watchdog */ 56 } pikawdt_private; 57 58 static struct watchdog_info ident __ro_after_init = { 59 .identity = DRV_NAME, 60 .options = WDIOF_CARDRESET | 61 WDIOF_SETTIMEOUT | 62 WDIOF_KEEPALIVEPING | 63 WDIOF_MAGICCLOSE, 64 }; 65 66 /* 67 * Reload the watchdog timer. (ie, pat the watchdog) 68 */ 69 static inline void pikawdt_reset(void) 70 { 71 /* -- FPGA: Reset Control Register (32bit R/W) (Offset: 0x14) -- 72 * Bit 7, WTCHDG_EN: When set to 1, the watchdog timer is enabled. 73 * Once enabled, it cannot be disabled. The watchdog can be 74 * kicked by performing any write access to the reset 75 * control register (this register). 76 * Bit 8-11, WTCHDG_TIMEOUT_SEC: Sets the watchdog timeout value in 77 * seconds. Valid ranges are 1 to 15 seconds. The value can 78 * be modified dynamically. 79 */ 80 unsigned reset = in_be32(pikawdt_private.fpga + 0x14); 81 /* enable with max timeout - 15 seconds */ 82 reset |= (1 << 7) + (WDT_HW_TIMEOUT << 8); 83 out_be32(pikawdt_private.fpga + 0x14, reset); 84 } 85 86 /* 87 * Timer tick 88 */ 89 static void pikawdt_ping(struct timer_list *unused) 90 { 91 if (time_before(jiffies, pikawdt_private.next_heartbeat) || 92 (!nowayout && !pikawdt_private.open)) { 93 pikawdt_reset(); 94 mod_timer(&pikawdt_private.timer, jiffies + WDT_TIMEOUT); 95 } else 96 pr_crit("I will reset your machine !\n"); 97 } 98 99 100 static void pikawdt_keepalive(void) 101 { 102 pikawdt_private.next_heartbeat = jiffies + heartbeat * HZ; 103 } 104 105 static void pikawdt_start(void) 106 { 107 pikawdt_keepalive(); 108 mod_timer(&pikawdt_private.timer, jiffies + WDT_TIMEOUT); 109 } 110 111 /* 112 * Watchdog device is opened, and watchdog starts running. 113 */ 114 static int pikawdt_open(struct inode *inode, struct file *file) 115 { 116 /* /dev/watchdog can only be opened once */ 117 if (test_and_set_bit(0, &pikawdt_private.open)) 118 return -EBUSY; 119 120 pikawdt_start(); 121 122 return stream_open(inode, file); 123 } 124 125 /* 126 * Close the watchdog device. 127 */ 128 static int pikawdt_release(struct inode *inode, struct file *file) 129 { 130 /* stop internal ping */ 131 if (!pikawdt_private.expect_close) 132 del_timer(&pikawdt_private.timer); 133 134 clear_bit(0, &pikawdt_private.open); 135 pikawdt_private.expect_close = 0; 136 return 0; 137 } 138 139 /* 140 * Pat the watchdog whenever device is written to. 141 */ 142 static ssize_t pikawdt_write(struct file *file, const char __user *data, 143 size_t len, loff_t *ppos) 144 { 145 if (!len) 146 return 0; 147 148 /* Scan for magic character */ 149 if (!nowayout) { 150 size_t i; 151 152 pikawdt_private.expect_close = 0; 153 154 for (i = 0; i < len; i++) { 155 char c; 156 if (get_user(c, data + i)) 157 return -EFAULT; 158 if (c == 'V') { 159 pikawdt_private.expect_close = 42; 160 break; 161 } 162 } 163 } 164 165 pikawdt_keepalive(); 166 167 return len; 168 } 169 170 /* 171 * Handle commands from user-space. 172 */ 173 static long pikawdt_ioctl(struct file *file, 174 unsigned int cmd, unsigned long arg) 175 { 176 void __user *argp = (void __user *)arg; 177 int __user *p = argp; 178 int new_value; 179 180 switch (cmd) { 181 case WDIOC_GETSUPPORT: 182 return copy_to_user(argp, &ident, sizeof(ident)) ? -EFAULT : 0; 183 184 case WDIOC_GETSTATUS: 185 return put_user(0, p); 186 187 case WDIOC_GETBOOTSTATUS: 188 return put_user(pikawdt_private.bootstatus, p); 189 190 case WDIOC_KEEPALIVE: 191 pikawdt_keepalive(); 192 return 0; 193 194 case WDIOC_SETTIMEOUT: 195 if (get_user(new_value, p)) 196 return -EFAULT; 197 198 heartbeat = new_value; 199 pikawdt_keepalive(); 200 201 return put_user(new_value, p); /* return current value */ 202 203 case WDIOC_GETTIMEOUT: 204 return put_user(heartbeat, p); 205 } 206 return -ENOTTY; 207 } 208 209 210 static const struct file_operations pikawdt_fops = { 211 .owner = THIS_MODULE, 212 .llseek = no_llseek, 213 .open = pikawdt_open, 214 .release = pikawdt_release, 215 .write = pikawdt_write, 216 .unlocked_ioctl = pikawdt_ioctl, 217 }; 218 219 static struct miscdevice pikawdt_miscdev = { 220 .minor = WATCHDOG_MINOR, 221 .name = "watchdog", 222 .fops = &pikawdt_fops, 223 }; 224 225 static int __init pikawdt_init(void) 226 { 227 struct device_node *np; 228 void __iomem *fpga; 229 u32 post1; 230 int ret; 231 232 np = of_find_compatible_node(NULL, NULL, "pika,fpga"); 233 if (np == NULL) { 234 pr_err("Unable to find fpga\n"); 235 return -ENOENT; 236 } 237 238 pikawdt_private.fpga = of_iomap(np, 0); 239 of_node_put(np); 240 if (pikawdt_private.fpga == NULL) { 241 pr_err("Unable to map fpga\n"); 242 return -ENOMEM; 243 } 244 245 ident.firmware_version = in_be32(pikawdt_private.fpga + 0x1c) & 0xffff; 246 247 /* POST information is in the sd area. */ 248 np = of_find_compatible_node(NULL, NULL, "pika,fpga-sd"); 249 if (np == NULL) { 250 pr_err("Unable to find fpga-sd\n"); 251 ret = -ENOENT; 252 goto out; 253 } 254 255 fpga = of_iomap(np, 0); 256 of_node_put(np); 257 if (fpga == NULL) { 258 pr_err("Unable to map fpga-sd\n"); 259 ret = -ENOMEM; 260 goto out; 261 } 262 263 /* -- FPGA: POST Test Results Register 1 (32bit R/W) (Offset: 0x4040) -- 264 * Bit 31, WDOG: Set to 1 when the last reset was caused by a watchdog 265 * timeout. 266 */ 267 post1 = in_be32(fpga + 0x40); 268 if (post1 & 0x80000000) 269 pikawdt_private.bootstatus = WDIOF_CARDRESET; 270 271 iounmap(fpga); 272 273 timer_setup(&pikawdt_private.timer, pikawdt_ping, 0); 274 275 ret = misc_register(&pikawdt_miscdev); 276 if (ret) { 277 pr_err("Unable to register miscdev\n"); 278 goto out; 279 } 280 281 pr_info("initialized. heartbeat=%d sec (nowayout=%d)\n", 282 heartbeat, nowayout); 283 return 0; 284 285 out: 286 iounmap(pikawdt_private.fpga); 287 return ret; 288 } 289 290 static void __exit pikawdt_exit(void) 291 { 292 misc_deregister(&pikawdt_miscdev); 293 294 iounmap(pikawdt_private.fpga); 295 } 296 297 module_init(pikawdt_init); 298 module_exit(pikawdt_exit); 299 300 MODULE_AUTHOR("Sean MacLennan <smaclennan@pikatech.com>"); 301 MODULE_DESCRIPTION("PIKA FPGA based Watchdog Timer"); 302 MODULE_LICENSE("GPL"); 303