watchdog: Use pr_<fmt> and pr_<level>
[sfrench/cifs-2.6.git] / drivers / watchdog / pc87413_wdt.c
1 /*
2  *      NS pc87413-wdt Watchdog Timer driver for Linux 2.6.x.x
3  *
4  *      This code is based on wdt.c with original copyright.
5  *
6  *      (C) Copyright 2006 Sven Anders, <anders@anduras.de>
7  *                     and Marcus Junker, <junker@anduras.de>
8  *
9  *      This program is free software; you can redistribute it and/or
10  *      modify it under the terms of the GNU General Public License
11  *      as published by the Free Software Foundation; either version
12  *      2 of the License, or (at your option) any later version.
13  *
14  *      Neither Sven Anders, Marcus Junker nor ANDURAS AG
15  *      admit liability nor provide warranty for any of this software.
16  *      This material is provided "AS-IS" and at no charge.
17  *
18  *      Release 1.1
19  */
20
21 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
22
23 #include <linux/module.h>
24 #include <linux/types.h>
25 #include <linux/miscdevice.h>
26 #include <linux/watchdog.h>
27 #include <linux/ioport.h>
28 #include <linux/delay.h>
29 #include <linux/notifier.h>
30 #include <linux/fs.h>
31 #include <linux/reboot.h>
32 #include <linux/init.h>
33 #include <linux/spinlock.h>
34 #include <linux/moduleparam.h>
35 #include <linux/io.h>
36 #include <linux/uaccess.h>
37
38 #include <asm/system.h>
39
40 /* #define DEBUG 1 */
41
42 #define DEFAULT_TIMEOUT     1           /* 1 minute */
43 #define MAX_TIMEOUT         255
44
45 #define VERSION             "1.1"
46 #define MODNAME             "pc87413 WDT"
47 #define DPFX                MODNAME " - DEBUG: "
48
49 #define WDT_INDEX_IO_PORT   (io+0)      /* I/O port base (index register) */
50 #define WDT_DATA_IO_PORT    (WDT_INDEX_IO_PORT+1)
51 #define SWC_LDN             0x04
52 #define SIOCFG2             0x22        /* Serial IO register */
53 #define WDCTL               0x10        /* Watchdog-Timer-Control-Register */
54 #define WDTO                0x11        /* Watchdog timeout register */
55 #define WDCFG               0x12        /* Watchdog config register */
56
57 #define IO_DEFAULT      0x2E            /* Address used on Portwell Boards */
58
59 static int io = IO_DEFAULT;
60 static int swc_base_addr = -1;
61
62 static int timeout = DEFAULT_TIMEOUT;   /* timeout value */
63 static unsigned long timer_enabled;     /* is the timer enabled? */
64
65 static char expect_close;               /* is the close expected? */
66
67 static DEFINE_SPINLOCK(io_lock);        /* to guard us from io races */
68
69 static int nowayout = WATCHDOG_NOWAYOUT;
70
71 /* -- Low level function ----------------------------------------*/
72
73 /* Select pins for Watchdog output */
74
75 static inline void pc87413_select_wdt_out(void)
76 {
77         unsigned int cr_data = 0;
78
79         /* Step 1: Select multiple pin,pin55,as WDT output */
80
81         outb_p(SIOCFG2, WDT_INDEX_IO_PORT);
82
83         cr_data = inb(WDT_DATA_IO_PORT);
84
85         cr_data |= 0x80; /* Set Bit7 to 1*/
86         outb_p(SIOCFG2, WDT_INDEX_IO_PORT);
87
88         outb_p(cr_data, WDT_DATA_IO_PORT);
89
90 #ifdef DEBUG
91         pr_info(DPFX
92                 "Select multiple pin,pin55,as WDT output: Bit7 to 1: %d\n",
93                                                                 cr_data);
94 #endif
95 }
96
97 /* Enable SWC functions */
98
99 static inline void pc87413_enable_swc(void)
100 {
101         unsigned int cr_data = 0;
102
103         /* Step 2: Enable SWC functions */
104
105         outb_p(0x07, WDT_INDEX_IO_PORT);        /* Point SWC_LDN (LDN=4) */
106         outb_p(SWC_LDN, WDT_DATA_IO_PORT);
107
108         outb_p(0x30, WDT_INDEX_IO_PORT);        /* Read Index 0x30 First */
109         cr_data = inb(WDT_DATA_IO_PORT);
110         cr_data |= 0x01;                        /* Set Bit0 to 1 */
111         outb_p(0x30, WDT_INDEX_IO_PORT);
112         outb_p(cr_data, WDT_DATA_IO_PORT);      /* Index0x30_bit0P1 */
113
114 #ifdef DEBUG
115         pr_info(DPFX "pc87413 - Enable SWC functions\n");
116 #endif
117 }
118
119 /* Read SWC I/O base address */
120
121 static void pc87413_get_swc_base_addr(void)
122 {
123         unsigned char addr_l, addr_h = 0;
124
125         /* Step 3: Read SWC I/O Base Address */
126
127         outb_p(0x60, WDT_INDEX_IO_PORT);        /* Read Index 0x60 */
128         addr_h = inb(WDT_DATA_IO_PORT);
129
130         outb_p(0x61, WDT_INDEX_IO_PORT);        /* Read Index 0x61 */
131
132         addr_l = inb(WDT_DATA_IO_PORT);
133
134         swc_base_addr = (addr_h << 8) + addr_l;
135 #ifdef DEBUG
136         pr_info(DPFX
137                 "Read SWC I/O Base Address: low %d, high %d, res %d\n",
138                                                 addr_l, addr_h, swc_base_addr);
139 #endif
140 }
141
142 /* Select Bank 3 of SWC */
143
144 static inline void pc87413_swc_bank3(void)
145 {
146         /* Step 4: Select Bank3 of SWC */
147         outb_p(inb(swc_base_addr + 0x0f) | 0x03, swc_base_addr + 0x0f);
148 #ifdef DEBUG
149         pr_info(DPFX "Select Bank3 of SWC\n");
150 #endif
151 }
152
153 /* Set watchdog timeout to x minutes */
154
155 static inline void pc87413_programm_wdto(char pc87413_time)
156 {
157         /* Step 5: Programm WDTO, Twd. */
158         outb_p(pc87413_time, swc_base_addr + WDTO);
159 #ifdef DEBUG
160         pr_info(DPFX "Set WDTO to %d minutes\n", pc87413_time);
161 #endif
162 }
163
164 /* Enable WDEN */
165
166 static inline void pc87413_enable_wden(void)
167 {
168         /* Step 6: Enable WDEN */
169         outb_p(inb(swc_base_addr + WDCTL) | 0x01, swc_base_addr + WDCTL);
170 #ifdef DEBUG
171         pr_info(DPFX "Enable WDEN\n");
172 #endif
173 }
174
175 /* Enable SW_WD_TREN */
176 static inline void pc87413_enable_sw_wd_tren(void)
177 {
178         /* Enable SW_WD_TREN */
179         outb_p(inb(swc_base_addr + WDCFG) | 0x80, swc_base_addr + WDCFG);
180 #ifdef DEBUG
181         pr_info(DPFX "Enable SW_WD_TREN\n");
182 #endif
183 }
184
185 /* Disable SW_WD_TREN */
186
187 static inline void pc87413_disable_sw_wd_tren(void)
188 {
189         /* Disable SW_WD_TREN */
190         outb_p(inb(swc_base_addr + WDCFG) & 0x7f, swc_base_addr + WDCFG);
191 #ifdef DEBUG
192         pr_info(DPFX "pc87413 - Disable SW_WD_TREN\n");
193 #endif
194 }
195
196 /* Enable SW_WD_TRG */
197
198 static inline void pc87413_enable_sw_wd_trg(void)
199 {
200         /* Enable SW_WD_TRG */
201         outb_p(inb(swc_base_addr + WDCTL) | 0x80, swc_base_addr + WDCTL);
202 #ifdef DEBUG
203         pr_info(DPFX "pc87413 - Enable SW_WD_TRG\n");
204 #endif
205 }
206
207 /* Disable SW_WD_TRG */
208
209 static inline void pc87413_disable_sw_wd_trg(void)
210 {
211         /* Disable SW_WD_TRG */
212         outb_p(inb(swc_base_addr + WDCTL) & 0x7f, swc_base_addr + WDCTL);
213 #ifdef DEBUG
214         pr_info(DPFX "Disable SW_WD_TRG\n");
215 #endif
216 }
217
218 /* -- Higher level functions ------------------------------------*/
219
220 /* Enable the watchdog */
221
222 static void pc87413_enable(void)
223 {
224         spin_lock(&io_lock);
225
226         pc87413_swc_bank3();
227         pc87413_programm_wdto(timeout);
228         pc87413_enable_wden();
229         pc87413_enable_sw_wd_tren();
230         pc87413_enable_sw_wd_trg();
231
232         spin_unlock(&io_lock);
233 }
234
235 /* Disable the watchdog */
236
237 static void pc87413_disable(void)
238 {
239         spin_lock(&io_lock);
240
241         pc87413_swc_bank3();
242         pc87413_disable_sw_wd_tren();
243         pc87413_disable_sw_wd_trg();
244         pc87413_programm_wdto(0);
245
246         spin_unlock(&io_lock);
247 }
248
249 /* Refresh the watchdog */
250
251 static void pc87413_refresh(void)
252 {
253         spin_lock(&io_lock);
254
255         pc87413_swc_bank3();
256         pc87413_disable_sw_wd_tren();
257         pc87413_disable_sw_wd_trg();
258         pc87413_programm_wdto(timeout);
259         pc87413_enable_wden();
260         pc87413_enable_sw_wd_tren();
261         pc87413_enable_sw_wd_trg();
262
263         spin_unlock(&io_lock);
264 }
265
266 /* -- File operations -------------------------------------------*/
267
268 /**
269  *      pc87413_open:
270  *      @inode: inode of device
271  *      @file: file handle to device
272  *
273  */
274
275 static int pc87413_open(struct inode *inode, struct file *file)
276 {
277         /* /dev/watchdog can only be opened once */
278
279         if (test_and_set_bit(0, &timer_enabled))
280                 return -EBUSY;
281
282         if (nowayout)
283                 __module_get(THIS_MODULE);
284
285         /* Reload and activate timer */
286         pc87413_refresh();
287
288         pr_info("Watchdog enabled. Timeout set to %d minute(s).\n", timeout);
289
290         return nonseekable_open(inode, file);
291 }
292
293 /**
294  *      pc87413_release:
295  *      @inode: inode to board
296  *      @file: file handle to board
297  *
298  *      The watchdog has a configurable API. There is a religious dispute
299  *      between people who want their watchdog to be able to shut down and
300  *      those who want to be sure if the watchdog manager dies the machine
301  *      reboots. In the former case we disable the counters, in the latter
302  *      case you have to open it again very soon.
303  */
304
305 static int pc87413_release(struct inode *inode, struct file *file)
306 {
307         /* Shut off the timer. */
308
309         if (expect_close == 42) {
310                 pc87413_disable();
311                 pr_info("Watchdog disabled, sleeping again...\n");
312         } else {
313                 pr_crit("Unexpected close, not stopping watchdog!\n");
314                 pc87413_refresh();
315         }
316         clear_bit(0, &timer_enabled);
317         expect_close = 0;
318         return 0;
319 }
320
321 /**
322  *      pc87413_status:
323  *
324  *      return, if the watchdog is enabled (timeout is set...)
325  */
326
327
328 static int pc87413_status(void)
329 {
330           return 0; /* currently not supported */
331 }
332
333 /**
334  *      pc87413_write:
335  *      @file: file handle to the watchdog
336  *      @data: data buffer to write
337  *      @len: length in bytes
338  *      @ppos: pointer to the position to write. No seeks allowed
339  *
340  *      A write to a watchdog device is defined as a keepalive signal. Any
341  *      write of data will do, as we we don't define content meaning.
342  */
343
344 static ssize_t pc87413_write(struct file *file, const char __user *data,
345                              size_t len, loff_t *ppos)
346 {
347         /* See if we got the magic character 'V' and reload the timer */
348         if (len) {
349                 if (!nowayout) {
350                         size_t i;
351
352                         /* reset expect flag */
353                         expect_close = 0;
354
355                         /* scan to see whether or not we got the
356                            magic character */
357                         for (i = 0; i != len; i++) {
358                                 char c;
359                                 if (get_user(c, data + i))
360                                         return -EFAULT;
361                                 if (c == 'V')
362                                         expect_close = 42;
363                         }
364                 }
365
366                 /* someone wrote to us, we should reload the timer */
367                 pc87413_refresh();
368         }
369         return len;
370 }
371
372 /**
373  *      pc87413_ioctl:
374  *      @file: file handle to the device
375  *      @cmd: watchdog command
376  *      @arg: argument pointer
377  *
378  *      The watchdog API defines a common set of functions for all watchdogs
379  *      according to their available features. We only actually usefully support
380  *      querying capabilities and current status.
381  */
382
383 static long pc87413_ioctl(struct file *file, unsigned int cmd,
384                                                 unsigned long arg)
385 {
386         int new_timeout;
387
388         union {
389                 struct watchdog_info __user *ident;
390                 int __user *i;
391         } uarg;
392
393         static const struct watchdog_info ident = {
394                 .options          = WDIOF_KEEPALIVEPING |
395                                     WDIOF_SETTIMEOUT |
396                                     WDIOF_MAGICCLOSE,
397                 .firmware_version = 1,
398                 .identity         = "PC87413(HF/F) watchdog",
399         };
400
401         uarg.i = (int __user *)arg;
402
403         switch (cmd) {
404         case WDIOC_GETSUPPORT:
405                 return copy_to_user(uarg.ident, &ident,
406                                         sizeof(ident)) ? -EFAULT : 0;
407         case WDIOC_GETSTATUS:
408                 return put_user(pc87413_status(), uarg.i);
409         case WDIOC_GETBOOTSTATUS:
410                 return put_user(0, uarg.i);
411         case WDIOC_SETOPTIONS:
412         {
413                 int options, retval = -EINVAL;
414                 if (get_user(options, uarg.i))
415                         return -EFAULT;
416                 if (options & WDIOS_DISABLECARD) {
417                         pc87413_disable();
418                         retval = 0;
419                 }
420                 if (options & WDIOS_ENABLECARD) {
421                         pc87413_enable();
422                         retval = 0;
423                 }
424                 return retval;
425         }
426         case WDIOC_KEEPALIVE:
427                 pc87413_refresh();
428 #ifdef DEBUG
429                 pr_info(DPFX "keepalive\n");
430 #endif
431                 return 0;
432         case WDIOC_SETTIMEOUT:
433                 if (get_user(new_timeout, uarg.i))
434                         return -EFAULT;
435                 /* the API states this is given in secs */
436                 new_timeout /= 60;
437                 if (new_timeout < 0 || new_timeout > MAX_TIMEOUT)
438                         return -EINVAL;
439                 timeout = new_timeout;
440                 pc87413_refresh();
441                 /* fall through and return the new timeout... */
442         case WDIOC_GETTIMEOUT:
443                 new_timeout = timeout * 60;
444                 return put_user(new_timeout, uarg.i);
445         default:
446                 return -ENOTTY;
447         }
448 }
449
450 /* -- Notifier funtions -----------------------------------------*/
451
452 /**
453  *      notify_sys:
454  *      @this: our notifier block
455  *      @code: the event being reported
456  *      @unused: unused
457  *
458  *      Our notifier is called on system shutdowns. We want to turn the card
459  *      off at reboot otherwise the machine will reboot again during memory
460  *      test or worse yet during the following fsck. This would suck, in fact
461  *      trust me - if it happens it does suck.
462  */
463
464 static int pc87413_notify_sys(struct notifier_block *this,
465                               unsigned long code,
466                               void *unused)
467 {
468         if (code == SYS_DOWN || code == SYS_HALT)
469                 /* Turn the card off */
470                 pc87413_disable();
471         return NOTIFY_DONE;
472 }
473
474 /* -- Module's structures ---------------------------------------*/
475
476 static const struct file_operations pc87413_fops = {
477         .owner          = THIS_MODULE,
478         .llseek         = no_llseek,
479         .write          = pc87413_write,
480         .unlocked_ioctl = pc87413_ioctl,
481         .open           = pc87413_open,
482         .release        = pc87413_release,
483 };
484
485 static struct notifier_block pc87413_notifier = {
486         .notifier_call  = pc87413_notify_sys,
487 };
488
489 static struct miscdevice pc87413_miscdev = {
490         .minor          = WATCHDOG_MINOR,
491         .name           = "watchdog",
492         .fops           = &pc87413_fops,
493 };
494
495 /* -- Module init functions -------------------------------------*/
496
497 /**
498  *      pc87413_init: module's "constructor"
499  *
500  *      Set up the WDT watchdog board. All we have to do is grab the
501  *      resources we require and bitch if anyone beat us to them.
502  *      The open() function will actually kick the board off.
503  */
504
505 static int __init pc87413_init(void)
506 {
507         int ret;
508
509         pr_info("Version " VERSION " at io 0x%X\n",
510                                                         WDT_INDEX_IO_PORT);
511
512         if (!request_muxed_region(io, 2, MODNAME))
513                 return -EBUSY;
514
515         ret = register_reboot_notifier(&pc87413_notifier);
516         if (ret != 0) {
517                 pr_err("cannot register reboot notifier (err=%d)\n", ret);
518         }
519
520         ret = misc_register(&pc87413_miscdev);
521         if (ret != 0) {
522                 pr_err("cannot register miscdev on minor=%d (err=%d)\n",
523                        WATCHDOG_MINOR, ret);
524                 goto reboot_unreg;
525         }
526         pr_info("initialized. timeout=%d min\n", timeout);
527
528         pc87413_select_wdt_out();
529         pc87413_enable_swc();
530         pc87413_get_swc_base_addr();
531
532         if (!request_region(swc_base_addr, 0x20, MODNAME)) {
533                 pr_err("cannot request SWC region at 0x%x\n", swc_base_addr);
534                 ret = -EBUSY;
535                 goto misc_unreg;
536         }
537
538         pc87413_enable();
539
540         release_region(io, 2);
541         return 0;
542
543 misc_unreg:
544         misc_deregister(&pc87413_miscdev);
545 reboot_unreg:
546         unregister_reboot_notifier(&pc87413_notifier);
547         release_region(io, 2);
548         return ret;
549 }
550
551 /**
552  *      pc87413_exit: module's "destructor"
553  *
554  *      Unload the watchdog. You cannot do this with any file handles open.
555  *      If your watchdog is set to continue ticking on close and you unload
556  *      it, well it keeps ticking. We won't get the interrupt but the board
557  *      will not touch PC memory so all is fine. You just have to load a new
558  *      module in 60 seconds or reboot.
559  */
560
561 static void __exit pc87413_exit(void)
562 {
563         /* Stop the timer before we leave */
564         if (!nowayout) {
565                 pc87413_disable();
566                 pr_info("Watchdog disabled\n");
567         }
568
569         misc_deregister(&pc87413_miscdev);
570         unregister_reboot_notifier(&pc87413_notifier);
571         release_region(swc_base_addr, 0x20);
572
573         pr_info("watchdog component driver removed\n");
574 }
575
576 module_init(pc87413_init);
577 module_exit(pc87413_exit);
578
579 MODULE_AUTHOR("Sven Anders <anders@anduras.de>, "
580                 "Marcus Junker <junker@anduras.de>,");
581 MODULE_DESCRIPTION("PC87413 WDT driver");
582 MODULE_LICENSE("GPL");
583
584 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
585
586 module_param(io, int, 0);
587 MODULE_PARM_DESC(io, MODNAME " I/O port (default: "
588                                         __MODULE_STRING(IO_DEFAULT) ").");
589
590 module_param(timeout, int, 0);
591 MODULE_PARM_DESC(timeout,
592                 "Watchdog timeout in minutes (default="
593                                 __MODULE_STRING(DEFAULT_TIMEOUT) ").");
594
595 module_param(nowayout, int, 0);
596 MODULE_PARM_DESC(nowayout,
597                 "Watchdog cannot be stopped once started (default="
598                                 __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
599