476 lines · c
1// SPDX-License-Identifier: GPL-2.0+2/*3 * Eurotech CPU-1220/1410/1420 on board WDT driver4 *5 * (c) Copyright 2001 Ascensit <support@ascensit.com>6 * (c) Copyright 2001 Rodolfo Giometti <giometti@ascensit.com>7 * (c) Copyright 2002 Rob Radez <rob@osinvestor.com>8 *9 * Based on wdt.c.10 * Original copyright messages:11 *12 * (c) Copyright 1996-1997 Alan Cox <alan@lxorguk.ukuu.org.uk>,13 * All Rights Reserved.14 *15 * Neither Alan Cox nor CymruNet Ltd. admit liability nor provide16 * warranty for any of this software. This material is provided17 * "AS-IS" and at no charge.18 *19 * (c) Copyright 1995 Alan Cox <alan@lxorguk.ukuu.org.uk>*20 */21 22/* Changelog:23 *24 * 2001 - Rodolfo Giometti25 * Initial release26 *27 * 2002/04/25 - Rob Radez28 * clean up #includes29 * clean up locking30 * make __setup param unique31 * proper options in watchdog_info32 * add WDIOC_GETSTATUS and WDIOC_SETOPTIONS ioctls33 * add expect_close support34 *35 * 2002.05.30 - Joel Becker <joel.becker@oracle.com>36 * Added Matt Domsch's nowayout module option.37 */38 39/*40 * The eurotech CPU-1220/1410/1420's watchdog is a part41 * of the on-board SUPER I/O device SMSC FDC 37B782.42 */43 44#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt45 46#include <linux/interrupt.h>47#include <linux/module.h>48#include <linux/moduleparam.h>49#include <linux/types.h>50#include <linux/miscdevice.h>51#include <linux/watchdog.h>52#include <linux/fs.h>53#include <linux/ioport.h>54#include <linux/notifier.h>55#include <linux/reboot.h>56#include <linux/init.h>57#include <linux/io.h>58#include <linux/uaccess.h>59 60 61static unsigned long eurwdt_is_open;62static int eurwdt_timeout;63static char eur_expect_close;64static DEFINE_SPINLOCK(eurwdt_lock);65 66/*67 * You must set these - there is no sane way to probe for this board.68 */69 70static int io = 0x3f0;71static int irq = 10;72static char *ev = "int";73 74#define WDT_TIMEOUT 60 /* 1 minute */75 76static bool nowayout = WATCHDOG_NOWAYOUT;77module_param(nowayout, bool, 0);78MODULE_PARM_DESC(nowayout,79 "Watchdog cannot be stopped once started (default="80 __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");81 82/*83 * Some symbolic names84 */85 86#define WDT_CTRL_REG 0x3087#define WDT_OUTPIN_CFG 0xe288#define WDT_EVENT_INT 0x0089#define WDT_EVENT_REBOOT 0x0890#define WDT_UNIT_SEL 0xf191#define WDT_UNIT_SECS 0x8092#define WDT_TIMEOUT_VAL 0xf293#define WDT_TIMER_CFG 0xf394 95 96module_param_hw(io, int, ioport, 0);97MODULE_PARM_DESC(io, "Eurotech WDT io port (default=0x3f0)");98module_param_hw(irq, int, irq, 0);99MODULE_PARM_DESC(irq, "Eurotech WDT irq (default=10)");100module_param(ev, charp, 0);101MODULE_PARM_DESC(ev, "Eurotech WDT event type (default is `int')");102 103 104/*105 * Programming support106 */107 108static inline void eurwdt_write_reg(u8 index, u8 data)109{110 outb(index, io);111 outb(data, io+1);112}113 114static inline void eurwdt_lock_chip(void)115{116 outb(0xaa, io);117}118 119static inline void eurwdt_unlock_chip(void)120{121 outb(0x55, io);122 eurwdt_write_reg(0x07, 0x08); /* set the logical device */123}124 125static inline void eurwdt_set_timeout(int timeout)126{127 eurwdt_write_reg(WDT_TIMEOUT_VAL, (u8) timeout);128}129 130static inline void eurwdt_disable_timer(void)131{132 eurwdt_set_timeout(0);133}134 135static void eurwdt_activate_timer(void)136{137 eurwdt_disable_timer();138 eurwdt_write_reg(WDT_CTRL_REG, 0x01); /* activate the WDT */139 eurwdt_write_reg(WDT_OUTPIN_CFG,140 !strcmp("int", ev) ? WDT_EVENT_INT : WDT_EVENT_REBOOT);141 142 /* Setting interrupt line */143 if (irq == 2 || irq > 15 || irq < 0) {144 pr_err("invalid irq number\n");145 irq = 0; /* if invalid we disable interrupt */146 }147 if (irq == 0)148 pr_info("interrupt disabled\n");149 150 eurwdt_write_reg(WDT_TIMER_CFG, irq << 4);151 152 eurwdt_write_reg(WDT_UNIT_SEL, WDT_UNIT_SECS); /* we use seconds */153 eurwdt_set_timeout(0); /* the default timeout */154}155 156 157/*158 * Kernel methods.159 */160 161static irqreturn_t eurwdt_interrupt(int irq, void *dev_id)162{163 pr_crit("timeout WDT timeout\n");164 165#ifdef ONLY_TESTING166 pr_crit("Would Reboot\n");167#else168 pr_crit("Initiating system reboot\n");169 emergency_restart();170#endif171 return IRQ_HANDLED;172}173 174 175/**176 * eurwdt_ping:177 *178 * Reload counter one with the watchdog timeout.179 */180 181static void eurwdt_ping(void)182{183 /* Write the watchdog default value */184 eurwdt_set_timeout(eurwdt_timeout);185}186 187/**188 * eurwdt_write:189 * @file: file handle to the watchdog190 * @buf: buffer to write (unused as data does not matter here191 * @count: count of bytes192 * @ppos: pointer to the position to write. No seeks allowed193 *194 * A write to a watchdog device is defined as a keepalive signal. Any195 * write of data will do, as we don't define content meaning.196 */197 198static ssize_t eurwdt_write(struct file *file, const char __user *buf,199size_t count, loff_t *ppos)200{201 if (count) {202 if (!nowayout) {203 size_t i;204 205 eur_expect_close = 0;206 207 for (i = 0; i != count; i++) {208 char c;209 if (get_user(c, buf + i))210 return -EFAULT;211 if (c == 'V')212 eur_expect_close = 42;213 }214 }215 spin_lock(&eurwdt_lock);216 eurwdt_ping(); /* the default timeout */217 spin_unlock(&eurwdt_lock);218 }219 return count;220}221 222/**223 * eurwdt_ioctl:224 * @file: file handle to the device225 * @cmd: watchdog command226 * @arg: argument pointer227 *228 * The watchdog API defines a common set of functions for all watchdogs229 * according to their available features.230 */231 232static long eurwdt_ioctl(struct file *file,233 unsigned int cmd, unsigned long arg)234{235 void __user *argp = (void __user *)arg;236 int __user *p = argp;237 static const struct watchdog_info ident = {238 .options = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT239 | WDIOF_MAGICCLOSE,240 .firmware_version = 1,241 .identity = "WDT Eurotech CPU-1220/1410",242 };243 244 int time;245 int options, retval = -EINVAL;246 247 switch (cmd) {248 case WDIOC_GETSUPPORT:249 return copy_to_user(argp, &ident, sizeof(ident)) ? -EFAULT : 0;250 251 case WDIOC_GETSTATUS:252 case WDIOC_GETBOOTSTATUS:253 return put_user(0, p);254 255 case WDIOC_SETOPTIONS:256 if (get_user(options, p))257 return -EFAULT;258 spin_lock(&eurwdt_lock);259 if (options & WDIOS_DISABLECARD) {260 eurwdt_disable_timer();261 retval = 0;262 }263 if (options & WDIOS_ENABLECARD) {264 eurwdt_activate_timer();265 eurwdt_ping();266 retval = 0;267 }268 spin_unlock(&eurwdt_lock);269 return retval;270 271 case WDIOC_KEEPALIVE:272 spin_lock(&eurwdt_lock);273 eurwdt_ping();274 spin_unlock(&eurwdt_lock);275 return 0;276 277 case WDIOC_SETTIMEOUT:278 if (copy_from_user(&time, p, sizeof(int)))279 return -EFAULT;280 281 /* Sanity check */282 if (time < 0 || time > 255)283 return -EINVAL;284 285 spin_lock(&eurwdt_lock);286 eurwdt_timeout = time;287 eurwdt_set_timeout(time);288 spin_unlock(&eurwdt_lock);289 fallthrough;290 291 case WDIOC_GETTIMEOUT:292 return put_user(eurwdt_timeout, p);293 294 default:295 return -ENOTTY;296 }297}298 299/**300 * eurwdt_open:301 * @inode: inode of device302 * @file: file handle to device303 *304 * The misc device has been opened. The watchdog device is single305 * open and on opening we load the counter.306 */307 308static int eurwdt_open(struct inode *inode, struct file *file)309{310 if (test_and_set_bit(0, &eurwdt_is_open))311 return -EBUSY;312 eurwdt_timeout = WDT_TIMEOUT; /* initial timeout */313 /* Activate the WDT */314 eurwdt_activate_timer();315 return stream_open(inode, file);316}317 318/**319 * eurwdt_release:320 * @inode: inode to board321 * @file: file handle to board322 *323 * The watchdog has a configurable API. There is a religious dispute324 * between people who want their watchdog to be able to shut down and325 * those who want to be sure if the watchdog manager dies the machine326 * reboots. In the former case we disable the counters, in the latter327 * case you have to open it again very soon.328 */329 330static int eurwdt_release(struct inode *inode, struct file *file)331{332 if (eur_expect_close == 42)333 eurwdt_disable_timer();334 else {335 pr_crit("Unexpected close, not stopping watchdog!\n");336 eurwdt_ping();337 }338 clear_bit(0, &eurwdt_is_open);339 eur_expect_close = 0;340 return 0;341}342 343/**344 * eurwdt_notify_sys:345 * @this: our notifier block346 * @code: the event being reported347 * @unused: unused348 *349 * Our notifier is called on system shutdowns. We want to turn the card350 * off at reboot otherwise the machine will reboot again during memory351 * test or worse yet during the following fsck. This would suck, in fact352 * trust me - if it happens it does suck.353 */354 355static int eurwdt_notify_sys(struct notifier_block *this, unsigned long code,356 void *unused)357{358 if (code == SYS_DOWN || code == SYS_HALT)359 eurwdt_disable_timer(); /* Turn the card off */360 361 return NOTIFY_DONE;362}363 364/*365 * Kernel Interfaces366 */367 368 369static const struct file_operations eurwdt_fops = {370 .owner = THIS_MODULE,371 .write = eurwdt_write,372 .unlocked_ioctl = eurwdt_ioctl,373 .compat_ioctl = compat_ptr_ioctl,374 .open = eurwdt_open,375 .release = eurwdt_release,376};377 378static struct miscdevice eurwdt_miscdev = {379 .minor = WATCHDOG_MINOR,380 .name = "watchdog",381 .fops = &eurwdt_fops,382};383 384/*385 * The WDT card needs to learn about soft shutdowns in order to386 * turn the timebomb registers off.387 */388 389static struct notifier_block eurwdt_notifier = {390 .notifier_call = eurwdt_notify_sys,391};392 393/**394 * eurwdt_exit:395 *396 * Unload the watchdog. You cannot do this with any file handles open.397 * If your watchdog is set to continue ticking on close and you unload398 * it, well it keeps ticking. We won't get the interrupt but the board399 * will not touch PC memory so all is fine. You just have to load a new400 * module in 60 seconds or reboot.401 */402 403static void __exit eurwdt_exit(void)404{405 eurwdt_lock_chip();406 407 misc_deregister(&eurwdt_miscdev);408 409 unregister_reboot_notifier(&eurwdt_notifier);410 release_region(io, 2);411 free_irq(irq, NULL);412}413 414/**415 * eurwdt_init:416 *417 * Set up the WDT watchdog board. After grabbing the resources418 * we require we need also to unlock the device.419 * The open() function will actually kick the board off.420 */421 422static int __init eurwdt_init(void)423{424 int ret;425 426 ret = request_irq(irq, eurwdt_interrupt, 0, "eurwdt", NULL);427 if (ret) {428 pr_err("IRQ %d is not free\n", irq);429 goto out;430 }431 432 if (!request_region(io, 2, "eurwdt")) {433 pr_err("IO %X is not free\n", io);434 ret = -EBUSY;435 goto outirq;436 }437 438 ret = register_reboot_notifier(&eurwdt_notifier);439 if (ret) {440 pr_err("can't register reboot notifier (err=%d)\n", ret);441 goto outreg;442 }443 444 ret = misc_register(&eurwdt_miscdev);445 if (ret) {446 pr_err("can't misc_register on minor=%d\n", WATCHDOG_MINOR);447 goto outreboot;448 }449 450 eurwdt_unlock_chip();451 452 ret = 0;453 pr_info("Eurotech WDT driver 0.01 at %X (Interrupt %d) - timeout event: %s\n",454 io, irq, (!strcmp("int", ev) ? "int" : "reboot"));455 456out:457 return ret;458 459outreboot:460 unregister_reboot_notifier(&eurwdt_notifier);461 462outreg:463 release_region(io, 2);464 465outirq:466 free_irq(irq, NULL);467 goto out;468}469 470module_init(eurwdt_init);471module_exit(eurwdt_exit);472 473MODULE_AUTHOR("Rodolfo Giometti");474MODULE_DESCRIPTION("Driver for Eurotech CPU-1220/1410 on board watchdog");475MODULE_LICENSE("GPL");476