Version:  2.0.40 2.2.26 2.4.37 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15

Linux/drivers/watchdog/advantechwdt.c

  1 /*
  2  *      Advantech Single Board Computer WDT driver
  3  *
  4  *      (c) Copyright 2000-2001 Marek Michalkiewicz <marekm@linux.org.pl>
  5  *
  6  *      Based on acquirewdt.c which is based on wdt.c.
  7  *      Original copyright messages:
  8  *
  9  *      (c) Copyright 1996 Alan Cox <alan@lxorguk.ukuu.org.uk>,
 10  *                                              All Rights Reserved.
 11  *
 12  *      This program is free software; you can redistribute it and/or
 13  *      modify it under the terms of the GNU General Public License
 14  *      as published by the Free Software Foundation; either version
 15  *      2 of the License, or (at your option) any later version.
 16  *
 17  *      Neither Alan Cox nor CymruNet Ltd. admit liability nor provide
 18  *      warranty for any of this software. This material is provided
 19  *      "AS-IS" and at no charge.
 20  *
 21  *      (c) Copyright 1995    Alan Cox <alan@lxorguk.ukuu.org.uk>
 22  *
 23  *      14-Dec-2001 Matt Domsch <Matt_Domsch@dell.com>
 24  *          Added nowayout module option to override CONFIG_WATCHDOG_NOWAYOUT
 25  *
 26  *      16-Oct-2002 Rob Radez <rob@osinvestor.com>
 27  *          Clean up ioctls, clean up init + exit, add expect close support,
 28  *          add wdt_start and wdt_stop as parameters.
 29  */
 30 
 31 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 32 
 33 #include <linux/module.h>
 34 #include <linux/moduleparam.h>
 35 #include <linux/types.h>
 36 #include <linux/miscdevice.h>
 37 #include <linux/watchdog.h>
 38 #include <linux/fs.h>
 39 #include <linux/ioport.h>
 40 #include <linux/platform_device.h>
 41 #include <linux/init.h>
 42 #include <linux/io.h>
 43 #include <linux/uaccess.h>
 44 
 45 
 46 #define DRV_NAME "advantechwdt"
 47 #define WATCHDOG_NAME "Advantech WDT"
 48 #define WATCHDOG_TIMEOUT 60             /* 60 sec default timeout */
 49 
 50 /* the watchdog platform device */
 51 static struct platform_device *advwdt_platform_device;
 52 static unsigned long advwdt_is_open;
 53 static char adv_expect_close;
 54 
 55 /*
 56  *      You must set these - there is no sane way to probe for this board.
 57  *
 58  *      To enable or restart, write the timeout value in seconds (1 to 63)
 59  *      to I/O port wdt_start.  To disable, read I/O port wdt_stop.
 60  *      Both are 0x443 for most boards (tested on a PCA-6276VE-00B1), but
 61  *      check your manual (at least the PCA-6159 seems to be different -
 62  *      the manual says wdt_stop is 0x43, not 0x443).
 63  *      (0x43 is also a write-only control register for the 8254 timer!)
 64  */
 65 
 66 static int wdt_stop = 0x443;
 67 module_param(wdt_stop, int, 0);
 68 MODULE_PARM_DESC(wdt_stop, "Advantech WDT 'stop' io port (default 0x443)");
 69 
 70 static int wdt_start = 0x443;
 71 module_param(wdt_start, int, 0);
 72 MODULE_PARM_DESC(wdt_start, "Advantech WDT 'start' io port (default 0x443)");
 73 
 74 static int timeout = WATCHDOG_TIMEOUT;  /* in seconds */
 75 module_param(timeout, int, 0);
 76 MODULE_PARM_DESC(timeout,
 77         "Watchdog timeout in seconds. 1<= timeout <=63, default="
 78                 __MODULE_STRING(WATCHDOG_TIMEOUT) ".");
 79 
 80 static bool nowayout = WATCHDOG_NOWAYOUT;
 81 module_param(nowayout, bool, 0);
 82 MODULE_PARM_DESC(nowayout,
 83         "Watchdog cannot be stopped once started (default="
 84                 __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
 85 
 86 /*
 87  *      Watchdog Operations
 88  */
 89 
 90 static void advwdt_ping(void)
 91 {
 92         /* Write a watchdog value */
 93         outb_p(timeout, wdt_start);
 94 }
 95 
 96 static void advwdt_disable(void)
 97 {
 98         inb_p(wdt_stop);
 99 }
100 
101 static int advwdt_set_heartbeat(int t)
102 {
103         if (t < 1 || t > 63)
104                 return -EINVAL;
105         timeout = t;
106         return 0;
107 }
108 
109 /*
110  *      /dev/watchdog handling
111  */
112 
113 static ssize_t advwdt_write(struct file *file, const char __user *buf,
114                                                 size_t count, loff_t *ppos)
115 {
116         if (count) {
117                 if (!nowayout) {
118                         size_t i;
119 
120                         adv_expect_close = 0;
121 
122                         for (i = 0; i != count; i++) {
123                                 char c;
124                                 if (get_user(c, buf + i))
125                                         return -EFAULT;
126                                 if (c == 'V')
127                                         adv_expect_close = 42;
128                         }
129                 }
130                 advwdt_ping();
131         }
132         return count;
133 }
134 
135 static long advwdt_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
136 {
137         int new_timeout;
138         void __user *argp = (void __user *)arg;
139         int __user *p = argp;
140         static const struct watchdog_info ident = {
141                 .options = WDIOF_KEEPALIVEPING |
142                            WDIOF_SETTIMEOUT |
143                            WDIOF_MAGICCLOSE,
144                 .firmware_version = 1,
145                 .identity = WATCHDOG_NAME,
146         };
147 
148         switch (cmd) {
149         case WDIOC_GETSUPPORT:
150                 if (copy_to_user(argp, &ident, sizeof(ident)))
151                         return -EFAULT;
152                 break;
153 
154         case WDIOC_GETSTATUS:
155         case WDIOC_GETBOOTSTATUS:
156                 return put_user(0, p);
157 
158         case WDIOC_SETOPTIONS:
159         {
160                 int options, retval = -EINVAL;
161 
162                 if (get_user(options, p))
163                         return -EFAULT;
164                 if (options & WDIOS_DISABLECARD) {
165                         advwdt_disable();
166                         retval = 0;
167                 }
168                 if (options & WDIOS_ENABLECARD) {
169                         advwdt_ping();
170                         retval = 0;
171                 }
172                 return retval;
173         }
174         case WDIOC_KEEPALIVE:
175                 advwdt_ping();
176                 break;
177 
178         case WDIOC_SETTIMEOUT:
179                 if (get_user(new_timeout, p))
180                         return -EFAULT;
181                 if (advwdt_set_heartbeat(new_timeout))
182                         return -EINVAL;
183                 advwdt_ping();
184                 /* Fall */
185         case WDIOC_GETTIMEOUT:
186                 return put_user(timeout, p);
187         default:
188                 return -ENOTTY;
189         }
190         return 0;
191 }
192 
193 static int advwdt_open(struct inode *inode, struct file *file)
194 {
195         if (test_and_set_bit(0, &advwdt_is_open))
196                 return -EBUSY;
197         /*
198          *      Activate
199          */
200 
201         advwdt_ping();
202         return nonseekable_open(inode, file);
203 }
204 
205 static int advwdt_close(struct inode *inode, struct file *file)
206 {
207         if (adv_expect_close == 42) {
208                 advwdt_disable();
209         } else {
210                 pr_crit("Unexpected close, not stopping watchdog!\n");
211                 advwdt_ping();
212         }
213         clear_bit(0, &advwdt_is_open);
214         adv_expect_close = 0;
215         return 0;
216 }
217 
218 /*
219  *      Kernel Interfaces
220  */
221 
222 static const struct file_operations advwdt_fops = {
223         .owner          = THIS_MODULE,
224         .llseek         = no_llseek,
225         .write          = advwdt_write,
226         .unlocked_ioctl = advwdt_ioctl,
227         .open           = advwdt_open,
228         .release        = advwdt_close,
229 };
230 
231 static struct miscdevice advwdt_miscdev = {
232         .minor  = WATCHDOG_MINOR,
233         .name   = "watchdog",
234         .fops   = &advwdt_fops,
235 };
236 
237 /*
238  *      Init & exit routines
239  */
240 
241 static int __init advwdt_probe(struct platform_device *dev)
242 {
243         int ret;
244 
245         if (wdt_stop != wdt_start) {
246                 if (!request_region(wdt_stop, 1, WATCHDOG_NAME)) {
247                         pr_err("I/O address 0x%04x already in use\n",
248                                wdt_stop);
249                         ret = -EIO;
250                         goto out;
251                 }
252         }
253 
254         if (!request_region(wdt_start, 1, WATCHDOG_NAME)) {
255                 pr_err("I/O address 0x%04x already in use\n", wdt_start);
256                 ret = -EIO;
257                 goto unreg_stop;
258         }
259 
260         /* Check that the heartbeat value is within it's range ;
261          * if not reset to the default */
262         if (advwdt_set_heartbeat(timeout)) {
263                 advwdt_set_heartbeat(WATCHDOG_TIMEOUT);
264                 pr_info("timeout value must be 1<=x<=63, using %d\n", timeout);
265         }
266 
267         ret = misc_register(&advwdt_miscdev);
268         if (ret != 0) {
269                 pr_err("cannot register miscdev on minor=%d (err=%d)\n",
270                        WATCHDOG_MINOR, ret);
271                 goto unreg_regions;
272         }
273         pr_info("initialized. timeout=%d sec (nowayout=%d)\n",
274                 timeout, nowayout);
275 out:
276         return ret;
277 unreg_regions:
278         release_region(wdt_start, 1);
279 unreg_stop:
280         if (wdt_stop != wdt_start)
281                 release_region(wdt_stop, 1);
282         goto out;
283 }
284 
285 static int advwdt_remove(struct platform_device *dev)
286 {
287         misc_deregister(&advwdt_miscdev);
288         release_region(wdt_start, 1);
289         if (wdt_stop != wdt_start)
290                 release_region(wdt_stop, 1);
291 
292         return 0;
293 }
294 
295 static void advwdt_shutdown(struct platform_device *dev)
296 {
297         /* Turn the WDT off if we have a soft shutdown */
298         advwdt_disable();
299 }
300 
301 static struct platform_driver advwdt_driver = {
302         .remove         = advwdt_remove,
303         .shutdown       = advwdt_shutdown,
304         .driver         = {
305                 .owner  = THIS_MODULE,
306                 .name   = DRV_NAME,
307         },
308 };
309 
310 static int __init advwdt_init(void)
311 {
312         int err;
313 
314         pr_info("WDT driver for Advantech single board computer initialising\n");
315 
316         advwdt_platform_device = platform_device_register_simple(DRV_NAME,
317                                                                 -1, NULL, 0);
318         if (IS_ERR(advwdt_platform_device))
319                 return PTR_ERR(advwdt_platform_device);
320 
321         err = platform_driver_probe(&advwdt_driver, advwdt_probe);
322         if (err)
323                 goto unreg_platform_device;
324 
325         return 0;
326 
327 unreg_platform_device:
328         platform_device_unregister(advwdt_platform_device);
329         return err;
330 }
331 
332 static void __exit advwdt_exit(void)
333 {
334         platform_device_unregister(advwdt_platform_device);
335         platform_driver_unregister(&advwdt_driver);
336         pr_info("Watchdog Module Unloaded\n");
337 }
338 
339 module_init(advwdt_init);
340 module_exit(advwdt_exit);
341 
342 MODULE_LICENSE("GPL");
343 MODULE_AUTHOR("Marek Michalkiewicz <marekm@linux.org.pl>");
344 MODULE_DESCRIPTION("Advantech Single Board Computer WDT driver");
345 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us