1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* drivers/char/watchdog/scx200_wdt.c 3 4 National Semiconductor SCx200 Watchdog support 5 6 Copyright (c) 2001,2002 Christer Weinigel <wingel@nano-system.com> 7 8 Some code taken from: 9 National Semiconductor PC87307/PC97307 (ala SC1200) WDT driver 10 (c) Copyright 2002 Zwane Mwaikambo <zwane@commfireservices.com> 11 12 13 The author(s) of this software shall not be held liable for damages 14 of any nature resulting due to the use of this software. This 15 software is provided AS-IS with no warranties. */ 16 17 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 18 19 #include <linux/module.h> 20 #include <linux/moduleparam.h> 21 #include <linux/init.h> 22 #include <linux/miscdevice.h> 23 #include <linux/watchdog.h> 24 #include <linux/notifier.h> 25 #include <linux/reboot.h> 26 #include <linux/fs.h> 27 #include <linux/ioport.h> 28 #include <linux/scx200.h> 29 #include <linux/uaccess.h> 30 #include <linux/io.h> 31 32 #define DEBUG 33 34 MODULE_AUTHOR("Christer Weinigel <wingel@nano-system.com>"); 35 MODULE_DESCRIPTION("NatSemi SCx200 Watchdog Driver"); 36 MODULE_LICENSE("GPL"); 37 38 static int margin = 60; /* in seconds */ 39 module_param(margin, int, 0); 40 MODULE_PARM_DESC(margin, "Watchdog margin in seconds"); 41 42 static bool nowayout = WATCHDOG_NOWAYOUT; 43 module_param(nowayout, bool, 0); 44 MODULE_PARM_DESC(nowayout, "Disable watchdog shutdown on close"); 45 46 static u16 wdto_restart; 47 static char expect_close; 48 static unsigned long open_lock; 49 static DEFINE_SPINLOCK(scx_lock); 50 51 /* Bits of the WDCNFG register */ 52 #define W_ENABLE 0x00fa /* Enable watchdog */ 53 #define W_DISABLE 0x0000 /* Disable watchdog */ 54 55 /* The scaling factor for the timer, this depends on the value of W_ENABLE */ 56 #define W_SCALE (32768/1024) 57 58 static void scx200_wdt_ping(void) 59 { 60 spin_lock(&scx_lock); 61 outw(wdto_restart, scx200_cb_base + SCx200_WDT_WDTO); 62 spin_unlock(&scx_lock); 63 } 64 65 static void scx200_wdt_update_margin(void) 66 { 67 pr_info("timer margin %d seconds\n", margin); 68 wdto_restart = margin * W_SCALE; 69 } 70 71 static void scx200_wdt_enable(void) 72 { 73 pr_debug("enabling watchdog timer, wdto_restart = %d\n", wdto_restart); 74 75 spin_lock(&scx_lock); 76 outw(0, scx200_cb_base + SCx200_WDT_WDTO); 77 outb(SCx200_WDT_WDSTS_WDOVF, scx200_cb_base + SCx200_WDT_WDSTS); 78 outw(W_ENABLE, scx200_cb_base + SCx200_WDT_WDCNFG); 79 spin_unlock(&scx_lock); 80 81 scx200_wdt_ping(); 82 } 83 84 static void scx200_wdt_disable(void) 85 { 86 pr_debug("disabling watchdog timer\n"); 87 88 spin_lock(&scx_lock); 89 outw(0, scx200_cb_base + SCx200_WDT_WDTO); 90 outb(SCx200_WDT_WDSTS_WDOVF, scx200_cb_base + SCx200_WDT_WDSTS); 91 outw(W_DISABLE, scx200_cb_base + SCx200_WDT_WDCNFG); 92 spin_unlock(&scx_lock); 93 } 94 95 static int scx200_wdt_open(struct inode *inode, struct file *file) 96 { 97 /* only allow one at a time */ 98 if (test_and_set_bit(0, &open_lock)) 99 return -EBUSY; 100 scx200_wdt_enable(); 101 102 return stream_open(inode, file); 103 } 104 105 static int scx200_wdt_release(struct inode *inode, struct file *file) 106 { 107 if (expect_close != 42) 108 pr_warn("watchdog device closed unexpectedly, will not disable the watchdog timer\n"); 109 else if (!nowayout) 110 scx200_wdt_disable(); 111 expect_close = 0; 112 clear_bit(0, &open_lock); 113 114 return 0; 115 } 116 117 static int scx200_wdt_notify_sys(struct notifier_block *this, 118 unsigned long code, void *unused) 119 { 120 if (code == SYS_HALT || code == SYS_POWER_OFF) 121 if (!nowayout) 122 scx200_wdt_disable(); 123 124 return NOTIFY_DONE; 125 } 126 127 static struct notifier_block scx200_wdt_notifier = { 128 .notifier_call = scx200_wdt_notify_sys, 129 }; 130 131 static ssize_t scx200_wdt_write(struct file *file, const char __user *data, 132 size_t len, loff_t *ppos) 133 { 134 /* check for a magic close character */ 135 if (len) { 136 size_t i; 137 138 scx200_wdt_ping(); 139 140 expect_close = 0; 141 for (i = 0; i < len; ++i) { 142 char c; 143 if (get_user(c, data + i)) 144 return -EFAULT; 145 if (c == 'V') 146 expect_close = 42; 147 } 148 149 return len; 150 } 151 152 return 0; 153 } 154 155 static long scx200_wdt_ioctl(struct file *file, unsigned int cmd, 156 unsigned long arg) 157 { 158 void __user *argp = (void __user *)arg; 159 int __user *p = argp; 160 static const struct watchdog_info ident = { 161 .identity = "NatSemi SCx200 Watchdog", 162 .firmware_version = 1, 163 .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING | 164 WDIOF_MAGICCLOSE, 165 }; 166 int new_margin; 167 168 switch (cmd) { 169 case WDIOC_GETSUPPORT: 170 if (copy_to_user(argp, &ident, sizeof(ident))) 171 return -EFAULT; 172 return 0; 173 case WDIOC_GETSTATUS: 174 case WDIOC_GETBOOTSTATUS: 175 if (put_user(0, p)) 176 return -EFAULT; 177 return 0; 178 case WDIOC_KEEPALIVE: 179 scx200_wdt_ping(); 180 return 0; 181 case WDIOC_SETTIMEOUT: 182 if (get_user(new_margin, p)) 183 return -EFAULT; 184 if (new_margin < 1) 185 return -EINVAL; 186 margin = new_margin; 187 scx200_wdt_update_margin(); 188 scx200_wdt_ping(); 189 /* Fall through */ 190 case WDIOC_GETTIMEOUT: 191 if (put_user(margin, p)) 192 return -EFAULT; 193 return 0; 194 default: 195 return -ENOTTY; 196 } 197 } 198 199 static const struct file_operations scx200_wdt_fops = { 200 .owner = THIS_MODULE, 201 .llseek = no_llseek, 202 .write = scx200_wdt_write, 203 .unlocked_ioctl = scx200_wdt_ioctl, 204 .open = scx200_wdt_open, 205 .release = scx200_wdt_release, 206 }; 207 208 static struct miscdevice scx200_wdt_miscdev = { 209 .minor = WATCHDOG_MINOR, 210 .name = "watchdog", 211 .fops = &scx200_wdt_fops, 212 }; 213 214 static int __init scx200_wdt_init(void) 215 { 216 int r; 217 218 pr_debug("NatSemi SCx200 Watchdog Driver\n"); 219 220 /* check that we have found the configuration block */ 221 if (!scx200_cb_present()) 222 return -ENODEV; 223 224 if (!request_region(scx200_cb_base + SCx200_WDT_OFFSET, 225 SCx200_WDT_SIZE, 226 "NatSemi SCx200 Watchdog")) { 227 pr_warn("watchdog I/O region busy\n"); 228 return -EBUSY; 229 } 230 231 scx200_wdt_update_margin(); 232 scx200_wdt_disable(); 233 234 r = register_reboot_notifier(&scx200_wdt_notifier); 235 if (r) { 236 pr_err("unable to register reboot notifier\n"); 237 release_region(scx200_cb_base + SCx200_WDT_OFFSET, 238 SCx200_WDT_SIZE); 239 return r; 240 } 241 242 r = misc_register(&scx200_wdt_miscdev); 243 if (r) { 244 unregister_reboot_notifier(&scx200_wdt_notifier); 245 release_region(scx200_cb_base + SCx200_WDT_OFFSET, 246 SCx200_WDT_SIZE); 247 return r; 248 } 249 250 return 0; 251 } 252 253 static void __exit scx200_wdt_cleanup(void) 254 { 255 misc_deregister(&scx200_wdt_miscdev); 256 unregister_reboot_notifier(&scx200_wdt_notifier); 257 release_region(scx200_cb_base + SCx200_WDT_OFFSET, 258 SCx200_WDT_SIZE); 259 } 260 261 module_init(scx200_wdt_init); 262 module_exit(scx200_wdt_cleanup); 263