1/* 2 * IB700 Single Board Computer WDT driver 3 * 4 * (c) Copyright 2001 Charles Howes <chowes@vsol.net> 5 * 6 * Based on advantechwdt.c which is based on acquirewdt.c which 7 * is based on wdt.c. 8 * 9 * (c) Copyright 2000-2001 Marek Michalkiewicz <marekm@linux.org.pl> 10 * 11 * Based on acquirewdt.c which is based on wdt.c. 12 * Original copyright messages: 13 * 14 * (c) Copyright 1996 Alan Cox <alan@lxorguk.ukuu.org.uk>, 15 * All Rights Reserved. 16 * 17 * This program is free software; you can redistribute it and/or 18 * modify it under the terms of the GNU General Public License 19 * as published by the Free Software Foundation; either version 20 * 2 of the License, or (at your option) any later version. 21 * 22 * Neither Alan Cox nor CymruNet Ltd. admit liability nor provide 23 * warranty for any of this software. This material is provided 24 * "AS-IS" and at no charge. 25 * 26 * (c) Copyright 1995 Alan Cox <alan@lxorguk.ukuu.org.uk> 27 * 28 * 14-Dec-2001 Matt Domsch <Matt_Domsch@dell.com> 29 * Added nowayout module option to override CONFIG_WATCHDOG_NOWAYOUT 30 * Added timeout module option to override default 31 * 32 */ 33 34#include <linux/module.h> 35#include <linux/types.h> 36#include <linux/miscdevice.h> 37#include <linux/watchdog.h> 38#include <linux/ioport.h> 39#include <linux/fs.h> 40#include <linux/init.h> 41#include <linux/spinlock.h> 42#include <linux/moduleparam.h> 43#include <linux/platform_device.h> 44#include <linux/io.h> 45#include <linux/uaccess.h> 46 47#include <asm/system.h> 48 49static struct platform_device *ibwdt_platform_device; 50static unsigned long ibwdt_is_open; 51static DEFINE_SPINLOCK(ibwdt_lock); 52static char expect_close; 53 54/* Module information */ 55#define DRV_NAME "ib700wdt" 56#define PFX DRV_NAME ": " 57 58/* 59 * 60 * Watchdog Timer Configuration 61 * 62 * The function of the watchdog timer is to reset the system 63 * automatically and is defined at I/O port 0443H. To enable the 64 * watchdog timer and allow the system to reset, write I/O port 0443H. 65 * To disable the timer, write I/O port 0441H for the system to stop the 66 * watchdog function. The timer has a tolerance of 20% for its 67 * intervals. 68 * 69 * The following describes how the timer should be programmed. 70 * 71 * Enabling Watchdog: 72 * MOV AX,000FH (Choose the values from 0 to F) 73 * MOV DX,0443H 74 * OUT DX,AX 75 * 76 * Disabling Watchdog: 77 * MOV AX,000FH (Any value is fine.) 78 * MOV DX,0441H 79 * OUT DX,AX 80 * 81 * Watchdog timer control table: 82 * Level Value Time/sec | Level Value Time/sec 83 * 1 F 0 | 9 7 16 84 * 2 E 2 | 10 6 18 85 * 3 D 4 | 11 5 20 86 * 4 C 6 | 12 4 22 87 * 5 B 8 | 13 3 24 88 * 6 A 10 | 14 2 26 89 * 7 9 12 | 15 1 28 90 * 8 8 14 | 16 0 30 91 * 92 */ 93 94#define WDT_STOP 0x441 95#define WDT_START 0x443 96 97/* Default timeout */ 98#define WATCHDOG_TIMEOUT 30 /* 30 seconds +/- 20% */ 99static int timeout = WATCHDOG_TIMEOUT; /* in seconds */ 100module_param(timeout, int, 0); 101MODULE_PARM_DESC(timeout, 102 "Watchdog timeout in seconds. 0<= timeout <=30, default=" 103 __MODULE_STRING(WATCHDOG_TIMEOUT) "."); 104 105static int nowayout = WATCHDOG_NOWAYOUT; 106module_param(nowayout, int, 0); 107MODULE_PARM_DESC(nowayout, 108 "Watchdog cannot be stopped once started (default=" 109 __MODULE_STRING(WATCHDOG_NOWAYOUT) ")"); 110 111 112/* 113 * Watchdog Operations 114 */ 115 116static void ibwdt_ping(void) 117{ 118 int wd_margin = 15 - ((timeout + 1) / 2); 119 120 spin_lock(&ibwdt_lock); 121 122 /* Write a watchdog value */ 123 outb_p(wd_margin, WDT_START); 124 125 spin_unlock(&ibwdt_lock); 126} 127 128static void ibwdt_disable(void) 129{ 130 spin_lock(&ibwdt_lock); 131 outb_p(0, WDT_STOP); 132 spin_unlock(&ibwdt_lock); 133} 134 135static int ibwdt_set_heartbeat(int t) 136{ 137 if (t < 0 || t > 30) 138 return -EINVAL; 139 140 timeout = t; 141 return 0; 142} 143 144/* 145 * /dev/watchdog handling 146 */ 147 148static ssize_t ibwdt_write(struct file *file, const char __user *buf, 149 size_t count, loff_t *ppos) 150{ 151 if (count) { 152 if (!nowayout) { 153 size_t i; 154 155 /* In case it was set long ago */ 156 expect_close = 0; 157 158 for (i = 0; i != count; i++) { 159 char c; 160 if (get_user(c, buf + i)) 161 return -EFAULT; 162 if (c == 'V') 163 expect_close = 42; 164 } 165 } 166 ibwdt_ping(); 167 } 168 return count; 169} 170 171static long ibwdt_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 172{ 173 int new_margin; 174 void __user *argp = (void __user *)arg; 175 int __user *p = argp; 176 177 static const struct watchdog_info ident = { 178 .options = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT 179 | WDIOF_MAGICCLOSE, 180 .firmware_version = 1, 181 .identity = "IB700 WDT", 182 }; 183 184 switch (cmd) { 185 case WDIOC_GETSUPPORT: 186 if (copy_to_user(argp, &ident, sizeof(ident))) 187 return -EFAULT; 188 break; 189 190 case WDIOC_GETSTATUS: 191 case WDIOC_GETBOOTSTATUS: 192 return put_user(0, p); 193 194 case WDIOC_SETOPTIONS: 195 { 196 int options, retval = -EINVAL; 197 198 if (get_user(options, p)) 199 return -EFAULT; 200 201 if (options & WDIOS_DISABLECARD) { 202 ibwdt_disable(); 203 retval = 0; 204 } 205 if (options & WDIOS_ENABLECARD) { 206 ibwdt_ping(); 207 retval = 0; 208 } 209 return retval; 210 } 211 case WDIOC_KEEPALIVE: 212 ibwdt_ping(); 213 break; 214 215 case WDIOC_SETTIMEOUT: 216 if (get_user(new_margin, p)) 217 return -EFAULT; 218 if (ibwdt_set_heartbeat(new_margin)) 219 return -EINVAL; 220 ibwdt_ping(); 221 /* Fall */ 222 223 case WDIOC_GETTIMEOUT: 224 return put_user(timeout, p); 225 226 default: 227 return -ENOTTY; 228 } 229 return 0; 230} 231 232static int ibwdt_open(struct inode *inode, struct file *file) 233{ 234 if (test_and_set_bit(0, &ibwdt_is_open)) 235 return -EBUSY; 236 if (nowayout) 237 __module_get(THIS_MODULE); 238 239 /* Activate */ 240 ibwdt_ping(); 241 return nonseekable_open(inode, file); 242} 243 244static int ibwdt_close(struct inode *inode, struct file *file) 245{ 246 if (expect_close == 42) { 247 ibwdt_disable(); 248 } else { 249 printk(KERN_CRIT PFX 250 "WDT device closed unexpectedly. WDT will not stop!\n"); 251 ibwdt_ping(); 252 } 253 clear_bit(0, &ibwdt_is_open); 254 expect_close = 0; 255 return 0; 256} 257 258/* 259 * Kernel Interfaces 260 */ 261 262static const struct file_operations ibwdt_fops = { 263 .owner = THIS_MODULE, 264 .llseek = no_llseek, 265 .write = ibwdt_write, 266 .unlocked_ioctl = ibwdt_ioctl, 267 .open = ibwdt_open, 268 .release = ibwdt_close, 269}; 270 271static struct miscdevice ibwdt_miscdev = { 272 .minor = WATCHDOG_MINOR, 273 .name = "watchdog", 274 .fops = &ibwdt_fops, 275}; 276 277/* 278 * Init & exit routines 279 */ 280 281static int __devinit ibwdt_probe(struct platform_device *dev) 282{ 283 int res; 284 285#if WDT_START != WDT_STOP 286 if (!request_region(WDT_STOP, 1, "IB700 WDT")) { 287 printk(KERN_ERR PFX "STOP method I/O %X is not available.\n", 288 WDT_STOP); 289 res = -EIO; 290 goto out_nostopreg; 291 } 292#endif 293 294 if (!request_region(WDT_START, 1, "IB700 WDT")) { 295 printk(KERN_ERR PFX "START method I/O %X is not available.\n", 296 WDT_START); 297 res = -EIO; 298 goto out_nostartreg; 299 } 300 301 /* Check that the heartbeat value is within it's range ; 302 * if not reset to the default */ 303 if (ibwdt_set_heartbeat(timeout)) { 304 ibwdt_set_heartbeat(WATCHDOG_TIMEOUT); 305 printk(KERN_INFO PFX 306 "timeout value must be 0<=x<=30, using %d\n", timeout); 307 } 308 309 res = misc_register(&ibwdt_miscdev); 310 if (res) { 311 printk(KERN_ERR PFX "failed to register misc device\n"); 312 goto out_nomisc; 313 } 314 return 0; 315 316out_nomisc: 317 release_region(WDT_START, 1); 318out_nostartreg: 319#if WDT_START != WDT_STOP 320 release_region(WDT_STOP, 1); 321#endif 322out_nostopreg: 323 return res; 324} 325 326static int __devexit ibwdt_remove(struct platform_device *dev) 327{ 328 misc_deregister(&ibwdt_miscdev); 329 release_region(WDT_START, 1); 330#if WDT_START != WDT_STOP 331 release_region(WDT_STOP, 1); 332#endif 333 return 0; 334} 335 336static void ibwdt_shutdown(struct platform_device *dev) 337{ 338 /* Turn the WDT off if we have a soft shutdown */ 339 ibwdt_disable(); 340} 341 342static struct platform_driver ibwdt_driver = { 343 .probe = ibwdt_probe, 344 .remove = __devexit_p(ibwdt_remove), 345 .shutdown = ibwdt_shutdown, 346 .driver = { 347 .owner = THIS_MODULE, 348 .name = DRV_NAME, 349 }, 350}; 351 352static int __init ibwdt_init(void) 353{ 354 int err; 355 356 printk(KERN_INFO PFX 357 "WDT driver for IB700 single board computer initialising.\n"); 358 359 err = platform_driver_register(&ibwdt_driver); 360 if (err) 361 return err; 362 363 ibwdt_platform_device = platform_device_register_simple(DRV_NAME, 364 -1, NULL, 0); 365 if (IS_ERR(ibwdt_platform_device)) { 366 err = PTR_ERR(ibwdt_platform_device); 367 goto unreg_platform_driver; 368 } 369 370 return 0; 371 372unreg_platform_driver: 373 platform_driver_unregister(&ibwdt_driver); 374 return err; 375} 376 377static void __exit ibwdt_exit(void) 378{ 379 platform_device_unregister(ibwdt_platform_device); 380 platform_driver_unregister(&ibwdt_driver); 381 printk(KERN_INFO PFX "Watchdog Module Unloaded.\n"); 382} 383 384module_init(ibwdt_init); 385module_exit(ibwdt_exit); 386 387MODULE_AUTHOR("Charles Howes <chowes@vsol.net>"); 388MODULE_DESCRIPTION("IB700 SBC watchdog driver"); 389MODULE_LICENSE("GPL"); 390MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); 391 392/* end of ib700wdt.c */ 393