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@redhat.com>, All Rights Reserved. 15 * http://www.redhat.com 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@redhat.com> 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 45 #include <asm/io.h> 46 #include <asm/uaccess.h> 47 #include <asm/system.h> 48 49 static struct platform_device *ibwdt_platform_device; 50 static unsigned long ibwdt_is_open; 51 static DEFINE_SPINLOCK(ibwdt_lock); 52 static 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 static int wd_times[] = { 95 30, /* 0x0 */ 96 28, /* 0x1 */ 97 26, /* 0x2 */ 98 24, /* 0x3 */ 99 22, /* 0x4 */ 100 20, /* 0x5 */ 101 18, /* 0x6 */ 102 16, /* 0x7 */ 103 14, /* 0x8 */ 104 12, /* 0x9 */ 105 10, /* 0xA */ 106 8, /* 0xB */ 107 6, /* 0xC */ 108 4, /* 0xD */ 109 2, /* 0xE */ 110 0, /* 0xF */ 111 }; 112 113 #define WDT_STOP 0x441 114 #define WDT_START 0x443 115 116 /* Default timeout */ 117 #define WD_TIMO 0 /* 30 seconds +/- 20%, from table */ 118 119 static int wd_margin = WD_TIMO; 120 121 static int nowayout = WATCHDOG_NOWAYOUT; 122 module_param(nowayout, int, 0); 123 MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=" __MODULE_STRING(WATCHDOG_NOWAYOUT) ")"); 124 125 126 /* 127 * Watchdog Operations 128 */ 129 130 static void 131 ibwdt_ping(void) 132 { 133 spin_lock(&ibwdt_lock); 134 135 /* Write a watchdog value */ 136 outb_p(wd_margin, WDT_START); 137 138 spin_unlock(&ibwdt_lock); 139 } 140 141 static void 142 ibwdt_disable(void) 143 { 144 spin_lock(&ibwdt_lock); 145 outb_p(0, WDT_STOP); 146 spin_unlock(&ibwdt_lock); 147 } 148 149 static int 150 ibwdt_set_heartbeat(int t) 151 { 152 int i; 153 154 if ((t < 0) || (t > 30)) 155 return -EINVAL; 156 157 for (i = 0x0F; i > -1; i--) 158 if (wd_times[i] > t) 159 break; 160 wd_margin = i; 161 return 0; 162 } 163 164 /* 165 * /dev/watchdog handling 166 */ 167 168 static ssize_t 169 ibwdt_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos) 170 { 171 if (count) { 172 if (!nowayout) { 173 size_t i; 174 175 /* In case it was set long ago */ 176 expect_close = 0; 177 178 for (i = 0; i != count; i++) { 179 char c; 180 if (get_user(c, buf + i)) 181 return -EFAULT; 182 if (c == 'V') 183 expect_close = 42; 184 } 185 } 186 ibwdt_ping(); 187 } 188 return count; 189 } 190 191 static int 192 ibwdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd, 193 unsigned long arg) 194 { 195 int new_margin; 196 void __user *argp = (void __user *)arg; 197 int __user *p = argp; 198 199 static struct watchdog_info ident = { 200 .options = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT | WDIOF_MAGICCLOSE, 201 .firmware_version = 1, 202 .identity = "IB700 WDT", 203 }; 204 205 switch (cmd) { 206 case WDIOC_GETSUPPORT: 207 if (copy_to_user(argp, &ident, sizeof(ident))) 208 return -EFAULT; 209 break; 210 211 case WDIOC_GETSTATUS: 212 case WDIOC_GETBOOTSTATUS: 213 return put_user(0, p); 214 215 case WDIOC_KEEPALIVE: 216 ibwdt_ping(); 217 break; 218 219 case WDIOC_SETTIMEOUT: 220 if (get_user(new_margin, p)) 221 return -EFAULT; 222 if (ibwdt_set_heartbeat(new_margin)) 223 return -EINVAL; 224 ibwdt_ping(); 225 /* Fall */ 226 227 case WDIOC_GETTIMEOUT: 228 return put_user(wd_times[wd_margin], p); 229 230 case WDIOC_SETOPTIONS: 231 { 232 int options, retval = -EINVAL; 233 234 if (get_user(options, p)) 235 return -EFAULT; 236 237 if (options & WDIOS_DISABLECARD) { 238 ibwdt_disable(); 239 retval = 0; 240 } 241 242 if (options & WDIOS_ENABLECARD) { 243 ibwdt_ping(); 244 retval = 0; 245 } 246 247 return retval; 248 } 249 250 default: 251 return -ENOTTY; 252 } 253 return 0; 254 } 255 256 static int 257 ibwdt_open(struct inode *inode, struct file *file) 258 { 259 if (test_and_set_bit(0, &ibwdt_is_open)) { 260 return -EBUSY; 261 } 262 if (nowayout) 263 __module_get(THIS_MODULE); 264 265 /* Activate */ 266 ibwdt_ping(); 267 return nonseekable_open(inode, file); 268 } 269 270 static int 271 ibwdt_close(struct inode *inode, struct file *file) 272 { 273 if (expect_close == 42) { 274 ibwdt_disable(); 275 } else { 276 printk(KERN_CRIT PFX "WDT device closed unexpectedly. WDT will not stop!\n"); 277 ibwdt_ping(); 278 } 279 clear_bit(0, &ibwdt_is_open); 280 expect_close = 0; 281 return 0; 282 } 283 284 /* 285 * Kernel Interfaces 286 */ 287 288 static const struct file_operations ibwdt_fops = { 289 .owner = THIS_MODULE, 290 .llseek = no_llseek, 291 .write = ibwdt_write, 292 .ioctl = ibwdt_ioctl, 293 .open = ibwdt_open, 294 .release = ibwdt_close, 295 }; 296 297 static struct miscdevice ibwdt_miscdev = { 298 .minor = WATCHDOG_MINOR, 299 .name = "watchdog", 300 .fops = &ibwdt_fops, 301 }; 302 303 /* 304 * Init & exit routines 305 */ 306 307 static int __devinit ibwdt_probe(struct platform_device *dev) 308 { 309 int res; 310 311 #if WDT_START != WDT_STOP 312 if (!request_region(WDT_STOP, 1, "IB700 WDT")) { 313 printk (KERN_ERR PFX "STOP method I/O %X is not available.\n", WDT_STOP); 314 res = -EIO; 315 goto out_nostopreg; 316 } 317 #endif 318 319 if (!request_region(WDT_START, 1, "IB700 WDT")) { 320 printk (KERN_ERR PFX "START method I/O %X is not available.\n", WDT_START); 321 res = -EIO; 322 goto out_nostartreg; 323 } 324 325 res = misc_register(&ibwdt_miscdev); 326 if (res) { 327 printk (KERN_ERR PFX "failed to register misc device\n"); 328 goto out_nomisc; 329 } 330 return 0; 331 332 out_nomisc: 333 release_region(WDT_START, 1); 334 out_nostartreg: 335 #if WDT_START != WDT_STOP 336 release_region(WDT_STOP, 1); 337 #endif 338 out_nostopreg: 339 return res; 340 } 341 342 static int __devexit ibwdt_remove(struct platform_device *dev) 343 { 344 misc_deregister(&ibwdt_miscdev); 345 release_region(WDT_START,1); 346 #if WDT_START != WDT_STOP 347 release_region(WDT_STOP,1); 348 #endif 349 return 0; 350 } 351 352 static void ibwdt_shutdown(struct platform_device *dev) 353 { 354 /* Turn the WDT off if we have a soft shutdown */ 355 ibwdt_disable(); 356 } 357 358 static struct platform_driver ibwdt_driver = { 359 .probe = ibwdt_probe, 360 .remove = __devexit_p(ibwdt_remove), 361 .shutdown = ibwdt_shutdown, 362 .driver = { 363 .owner = THIS_MODULE, 364 .name = DRV_NAME, 365 }, 366 }; 367 368 static int __init ibwdt_init(void) 369 { 370 int err; 371 372 printk(KERN_INFO PFX "WDT driver for IB700 single board computer initialising.\n"); 373 374 err = platform_driver_register(&ibwdt_driver); 375 if (err) 376 return err; 377 378 ibwdt_platform_device = platform_device_register_simple(DRV_NAME, -1, NULL, 0); 379 if (IS_ERR(ibwdt_platform_device)) { 380 err = PTR_ERR(ibwdt_platform_device); 381 goto unreg_platform_driver; 382 } 383 384 return 0; 385 386 unreg_platform_driver: 387 platform_driver_unregister(&ibwdt_driver); 388 return err; 389 } 390 391 static void __exit ibwdt_exit(void) 392 { 393 platform_device_unregister(ibwdt_platform_device); 394 platform_driver_unregister(&ibwdt_driver); 395 printk(KERN_INFO PFX "Watchdog Module Unloaded.\n"); 396 } 397 398 module_init(ibwdt_init); 399 module_exit(ibwdt_exit); 400 401 MODULE_AUTHOR("Charles Howes <chowes@vsol.net>"); 402 MODULE_DESCRIPTION("IB700 SBC watchdog driver"); 403 MODULE_LICENSE("GPL"); 404 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); 405 406 /* end of ib700wdt.c */ 407