Automerge with /usr/src/ntfs-2.6.git.
[linux-2.6] / drivers / char / watchdog / wdrtas.c
1 /*
2  * FIXME: add wdrtas_get_status and wdrtas_get_boot_status as soon as
3  * RTAS calls are available
4  */
5
6 /*
7  * RTAS watchdog driver
8  *
9  * (C) Copyright IBM Corp. 2005
10  * device driver to exploit watchdog RTAS functions
11  *
12  * Authors : Utz Bacher <utz.bacher@de.ibm.com>
13  *
14  * This program is free software; you can redistribute it and/or modify
15  * it under the terms of the GNU General Public License as published by
16  * the Free Software Foundation; either version 2, or (at your option)
17  * any later version.
18  *
19  * This program is distributed in the hope that it will be useful,
20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
22  * GNU General Public License for more details.
23  *
24  * You should have received a copy of the GNU General Public License
25  * along with this program; if not, write to the Free Software
26  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
27  */
28
29 #include <linux/config.h>
30 #include <linux/fs.h>
31 #include <linux/init.h>
32 #include <linux/kernel.h>
33 #include <linux/miscdevice.h>
34 #include <linux/module.h>
35 #include <linux/notifier.h>
36 #include <linux/reboot.h>
37 #include <linux/types.h>
38 #include <linux/watchdog.h>
39
40 #include <asm/rtas.h>
41 #include <asm/uaccess.h>
42
43 #define WDRTAS_MAGIC_CHAR               42
44 #define WDRTAS_SUPPORTED_MASK           (WDIOF_SETTIMEOUT | \
45                                          WDIOF_MAGICCLOSE)
46
47 MODULE_AUTHOR("Utz Bacher <utz.bacher@de.ibm.com>");
48 MODULE_DESCRIPTION("RTAS watchdog driver");
49 MODULE_LICENSE("GPL");
50 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
51 MODULE_ALIAS_MISCDEV(TEMP_MINOR);
52
53 #ifdef CONFIG_WATCHDOG_NOWAYOUT
54 static int wdrtas_nowayout = 1;
55 #else
56 static int wdrtas_nowayout = 0;
57 #endif
58
59 static atomic_t wdrtas_miscdev_open = ATOMIC_INIT(0);
60 static char wdrtas_expect_close = 0;
61
62 static int wdrtas_interval;
63
64 #define WDRTAS_THERMAL_SENSOR           3
65 static int wdrtas_token_get_sensor_state;
66 #define WDRTAS_SURVEILLANCE_IND         9000
67 static int wdrtas_token_set_indicator;
68 #define WDRTAS_SP_SPI                   28
69 static int wdrtas_token_get_sp;
70 static int wdrtas_token_event_scan;
71
72 #define WDRTAS_DEFAULT_INTERVAL         300
73
74 #define WDRTAS_LOGBUFFER_LEN            128
75 static char wdrtas_logbuffer[WDRTAS_LOGBUFFER_LEN];
76
77
78 /*** watchdog access functions */
79
80 /**
81  * wdrtas_set_interval - sets the watchdog interval
82  * @interval: new interval
83  *
84  * returns 0 on success, <0 on failures
85  *
86  * wdrtas_set_interval sets the watchdog keepalive interval by calling the
87  * RTAS function set-indicator (surveillance). The unit of interval is
88  * seconds.
89  */
90 static int
91 wdrtas_set_interval(int interval)
92 {
93         long result;
94         static int print_msg = 10;
95
96         /* rtas uses minutes */
97         interval = (interval + 59) / 60;
98
99         result = rtas_call(wdrtas_token_set_indicator, 3, 1, NULL,
100                            WDRTAS_SURVEILLANCE_IND, 0, interval);
101         if ( (result < 0) && (print_msg) ) {
102                 printk(KERN_ERR "wdrtas: setting the watchdog to %i "
103                        "timeout failed: %li\n", interval, result);
104                 print_msg--;
105         }
106
107         return result;
108 }
109
110 /**
111  * wdrtas_get_interval - returns the current watchdog interval
112  * @fallback_value: value (in seconds) to use, if the RTAS call fails
113  *
114  * returns the interval
115  *
116  * wdrtas_get_interval returns the current watchdog keepalive interval
117  * as reported by the RTAS function ibm,get-system-parameter. The unit
118  * of the return value is seconds.
119  */
120 static int
121 wdrtas_get_interval(int fallback_value)
122 {
123         long result;
124         char value[4];
125
126         result = rtas_call(wdrtas_token_get_sp, 3, 1, NULL,
127                            WDRTAS_SP_SPI, (void *)__pa(&value), 4);
128         if ( (value[0] != 0) || (value[1] != 2) || (value[3] != 0) ||
129              (result < 0) ) {
130                 printk(KERN_WARNING "wdrtas: could not get sp_spi watchdog "
131                        "timeout (%li). Continuing\n", result);
132                 return fallback_value;
133         }
134
135         /* rtas uses minutes */
136         return ((int)value[2]) * 60;
137 }
138
139 /**
140  * wdrtas_timer_start - starts watchdog
141  *
142  * wdrtas_timer_start starts the watchdog by calling the RTAS function
143  * set-interval (surveillance)
144  */
145 static void
146 wdrtas_timer_start(void)
147 {
148         wdrtas_set_interval(wdrtas_interval);
149 }
150
151 /**
152  * wdrtas_timer_stop - stops watchdog
153  *
154  * wdrtas_timer_stop stops the watchdog timer by calling the RTAS function
155  * set-interval (surveillance)
156  */
157 static void
158 wdrtas_timer_stop(void)
159 {
160         wdrtas_set_interval(0);
161 }
162
163 /**
164  * wdrtas_log_scanned_event - logs an event we received during keepalive
165  *
166  * wdrtas_log_scanned_event prints a message to the log buffer dumping
167  * the results of the last event-scan call
168  */
169 static void
170 wdrtas_log_scanned_event(void)
171 {
172         int i;
173
174         for (i = 0; i < WDRTAS_LOGBUFFER_LEN; i += 16)
175                 printk(KERN_INFO "wdrtas: dumping event (line %i/%i), data = "
176                        "%02x %02x %02x %02x  %02x %02x %02x %02x   "
177                        "%02x %02x %02x %02x  %02x %02x %02x %02x\n",
178                        (i / 16) + 1, (WDRTAS_LOGBUFFER_LEN / 16),
179                        wdrtas_logbuffer[i + 0], wdrtas_logbuffer[i + 1], 
180                        wdrtas_logbuffer[i + 2], wdrtas_logbuffer[i + 3], 
181                        wdrtas_logbuffer[i + 4], wdrtas_logbuffer[i + 5], 
182                        wdrtas_logbuffer[i + 6], wdrtas_logbuffer[i + 7], 
183                        wdrtas_logbuffer[i + 8], wdrtas_logbuffer[i + 9], 
184                        wdrtas_logbuffer[i + 10], wdrtas_logbuffer[i + 11], 
185                        wdrtas_logbuffer[i + 12], wdrtas_logbuffer[i + 13], 
186                        wdrtas_logbuffer[i + 14], wdrtas_logbuffer[i + 15]);
187 }
188
189 /**
190  * wdrtas_timer_keepalive - resets watchdog timer to keep system alive
191  *
192  * wdrtas_timer_keepalive restarts the watchdog timer by calling the
193  * RTAS function event-scan and repeats these calls as long as there are
194  * events available. All events will be dumped.
195  */
196 static void
197 wdrtas_timer_keepalive(void)
198 {
199         long result;
200
201         do {
202                 result = rtas_call(wdrtas_token_event_scan, 4, 1, NULL,
203                                    RTAS_EVENT_SCAN_ALL_EVENTS, 0,
204                                    (void *)__pa(wdrtas_logbuffer),
205                                    WDRTAS_LOGBUFFER_LEN);
206                 if (result < 0)
207                         printk(KERN_ERR "wdrtas: event-scan failed: %li\n",
208                                result);
209                 if (result == 0)
210                         wdrtas_log_scanned_event();
211         } while (result == 0);
212 }
213
214 /**
215  * wdrtas_get_temperature - returns current temperature
216  *
217  * returns temperature or <0 on failures
218  *
219  * wdrtas_get_temperature returns the current temperature in Fahrenheit. It
220  * uses the RTAS call get-sensor-state, token 3 to do so
221  */
222 static int
223 wdrtas_get_temperature(void)
224 {
225         long result;
226         int temperature = 0;
227
228         result = rtas_call(wdrtas_token_get_sensor_state, 2, 2,
229                            (void *)__pa(&temperature),
230                            WDRTAS_THERMAL_SENSOR, 0);
231
232         if (result < 0)
233                 printk(KERN_WARNING "wdrtas: reading the thermal sensor "
234                        "faild: %li\n", result);
235         else
236                 temperature = ((temperature * 9) / 5) + 32; /* fahrenheit */
237
238         return temperature;
239 }
240
241 /**
242  * wdrtas_get_status - returns the status of the watchdog
243  *
244  * returns a bitmask of defines WDIOF_... as defined in
245  * include/linux/watchdog.h
246  */
247 static int
248 wdrtas_get_status(void)
249 {
250         return 0; /* TODO */
251 }
252
253 /**
254  * wdrtas_get_boot_status - returns the reason for the last boot
255  *
256  * returns a bitmask of defines WDIOF_... as defined in
257  * include/linux/watchdog.h, indicating why the watchdog rebooted the system
258  */
259 static int
260 wdrtas_get_boot_status(void)
261 {
262         return 0; /* TODO */
263 }
264
265 /*** watchdog API and operations stuff */
266
267 /* wdrtas_write - called when watchdog device is written to
268  * @file: file structure
269  * @buf: user buffer with data
270  * @len: amount to data written
271  * @ppos: position in file
272  *
273  * returns the number of successfully processed characters, which is always
274  * the number of bytes passed to this function
275  *
276  * wdrtas_write processes all the data given to it and looks for the magic
277  * character 'V'. This character allows the watchdog device to be closed
278  * properly.
279  */
280 static ssize_t
281 wdrtas_write(struct file *file, const char __user *buf,
282              size_t len, loff_t *ppos)
283 {
284         int i;
285         char c;
286
287         if (!len)
288                 goto out;
289
290         if (!wdrtas_nowayout) {
291                 wdrtas_expect_close = 0;
292                 /* look for 'V' */
293                 for (i = 0; i < len; i++) {
294                         if (get_user(c, buf + i))
295                                 return -EFAULT;
296                         /* allow to close device */
297                         if (c == 'V')
298                                 wdrtas_expect_close = WDRTAS_MAGIC_CHAR;
299                 }
300         }
301
302         wdrtas_timer_keepalive();
303
304 out:
305         return len;
306 }
307
308 /**
309  * wdrtas_ioctl - ioctl function for the watchdog device
310  * @inode: inode structure
311  * @file: file structure
312  * @cmd: command for ioctl
313  * @arg: argument pointer
314  *
315  * returns 0 on success, <0 on failure
316  *
317  * wdrtas_ioctl implements the watchdog API ioctls
318  */
319 static int
320 wdrtas_ioctl(struct inode *inode, struct file *file,
321              unsigned int cmd, unsigned long arg)
322 {
323         int __user *argp = (void *)arg;
324         int i;
325         static struct watchdog_info wdinfo = {
326                 .options = WDRTAS_SUPPORTED_MASK,
327                 .firmware_version = 0,
328                 .identity = "wdrtas"
329         };
330
331         switch (cmd) {
332         case WDIOC_GETSUPPORT:
333                 if (copy_to_user(argp, &wdinfo, sizeof(wdinfo)))
334                         return -EFAULT;
335                 return 0;
336
337         case WDIOC_GETSTATUS:
338                 i = wdrtas_get_status();
339                 return put_user(i, argp);
340
341         case WDIOC_GETBOOTSTATUS:
342                 i = wdrtas_get_boot_status();
343                 return put_user(i, argp);
344
345         case WDIOC_GETTEMP:
346                 if (wdrtas_token_get_sensor_state == RTAS_UNKNOWN_SERVICE)
347                         return -EOPNOTSUPP;
348
349                 i = wdrtas_get_temperature();
350                 return put_user(i, argp);
351
352         case WDIOC_SETOPTIONS:
353                 if (get_user(i, argp))
354                         return -EFAULT;
355                 if (i & WDIOS_DISABLECARD)
356                         wdrtas_timer_stop();
357                 if (i & WDIOS_ENABLECARD) {
358                         wdrtas_timer_keepalive();
359                         wdrtas_timer_start();
360                 }
361                 if (i & WDIOS_TEMPPANIC) {
362                         /* not implemented. Done by H8 */
363                 }
364                 return 0;
365
366         case WDIOC_KEEPALIVE:
367                 wdrtas_timer_keepalive();
368                 return 0;
369
370         case WDIOC_SETTIMEOUT:
371                 if (get_user(i, argp))
372                         return -EFAULT;
373
374                 if (wdrtas_set_interval(i))
375                         return -EINVAL;
376
377                 wdrtas_timer_keepalive();
378
379                 if (wdrtas_token_get_sp == RTAS_UNKNOWN_SERVICE)
380                         wdrtas_interval = i;
381                 else
382                         wdrtas_interval = wdrtas_get_interval(i);
383                 /* fallthrough */
384
385         case WDIOC_GETTIMEOUT:
386                 return put_user(wdrtas_interval, argp);
387
388         default:
389                 return -ENOIOCTLCMD;
390         }
391 }
392
393 /**
394  * wdrtas_open - open function of watchdog device
395  * @inode: inode structure
396  * @file: file structure
397  *
398  * returns 0 on success, -EBUSY if the file has been opened already, <0 on
399  * other failures
400  *
401  * function called when watchdog device is opened
402  */
403 static int
404 wdrtas_open(struct inode *inode, struct file *file)
405 {
406         /* only open once */
407         if (atomic_inc_return(&wdrtas_miscdev_open) > 1) {
408                 atomic_dec(&wdrtas_miscdev_open);
409                 return -EBUSY;
410         }
411
412         wdrtas_timer_start();
413         wdrtas_timer_keepalive();
414
415         return nonseekable_open(inode, file);
416 }
417
418 /**
419  * wdrtas_close - close function of watchdog device
420  * @inode: inode structure
421  * @file: file structure
422  *
423  * returns 0 on success
424  *
425  * close function. Always succeeds
426  */
427 static int
428 wdrtas_close(struct inode *inode, struct file *file)
429 {
430         /* only stop watchdog, if this was announced using 'V' before */
431         if (wdrtas_expect_close == WDRTAS_MAGIC_CHAR)
432                 wdrtas_timer_stop();
433         else {
434                 printk(KERN_WARNING "wdrtas: got unexpected close. Watchdog "
435                        "not stopped.\n");
436                 wdrtas_timer_keepalive();
437         }
438
439         wdrtas_expect_close = 0;
440         atomic_dec(&wdrtas_miscdev_open);
441         return 0;
442 }
443
444 /**
445  * wdrtas_temp_read - gives back the temperature in fahrenheit
446  * @file: file structure
447  * @buf: user buffer
448  * @count: number of bytes to be read
449  * @ppos: position in file
450  *
451  * returns always 1 or -EFAULT in case of user space copy failures, <0 on
452  * other failures
453  *
454  * wdrtas_temp_read gives the temperature to the users by copying this
455  * value as one byte into the user space buffer. The unit is Fahrenheit...
456  */
457 static ssize_t
458 wdrtas_temp_read(struct file *file, char __user *buf,
459                  size_t count, loff_t *ppos)
460 {
461         int temperature = 0;
462
463         temperature = wdrtas_get_temperature();
464         if (temperature < 0)
465                 return temperature;
466
467         if (copy_to_user(buf, &temperature, 1))
468                 return -EFAULT;
469
470         return 1;
471 }
472
473 /**
474  * wdrtas_temp_open - open function of temperature device
475  * @inode: inode structure
476  * @file: file structure
477  *
478  * returns 0 on success, <0 on failure
479  *
480  * function called when temperature device is opened
481  */
482 static int
483 wdrtas_temp_open(struct inode *inode, struct file *file)
484 {
485         return nonseekable_open(inode, file);
486 }
487
488 /**
489  * wdrtas_temp_close - close function of temperature device
490  * @inode: inode structure
491  * @file: file structure
492  *
493  * returns 0 on success
494  *
495  * close function. Always succeeds
496  */
497 static int
498 wdrtas_temp_close(struct inode *inode, struct file *file)
499 {
500         return 0;
501 }
502
503 /**
504  * wdrtas_reboot - reboot notifier function
505  * @nb: notifier block structure
506  * @code: reboot code
507  * @ptr: unused
508  *
509  * returns NOTIFY_DONE
510  *
511  * wdrtas_reboot stops the watchdog in case of a reboot
512  */
513 static int
514 wdrtas_reboot(struct notifier_block *this, unsigned long code, void *ptr)
515 {
516         if ( (code==SYS_DOWN) || (code==SYS_HALT) )
517                 wdrtas_timer_stop();
518
519         return NOTIFY_DONE;
520 }
521
522 /*** initialization stuff */
523
524 static struct file_operations wdrtas_fops = {
525         .owner          = THIS_MODULE,
526         .llseek         = no_llseek,
527         .write          = wdrtas_write,
528         .ioctl          = wdrtas_ioctl,
529         .open           = wdrtas_open,
530         .release        = wdrtas_close,
531 };
532
533 static struct miscdevice wdrtas_miscdev = {
534         .minor =        WATCHDOG_MINOR,
535         .name =         "watchdog",
536         .fops =         &wdrtas_fops,
537 };
538
539 static struct file_operations wdrtas_temp_fops = {
540         .owner          = THIS_MODULE,
541         .llseek         = no_llseek,
542         .read           = wdrtas_temp_read,
543         .open           = wdrtas_temp_open,
544         .release        = wdrtas_temp_close,
545 };
546
547 static struct miscdevice wdrtas_tempdev = {
548         .minor =        TEMP_MINOR,
549         .name =         "temperature",
550         .fops =         &wdrtas_temp_fops,
551 };
552
553 static struct notifier_block wdrtas_notifier = {
554         .notifier_call =        wdrtas_reboot,
555 };
556
557 /**
558  * wdrtas_get_tokens - reads in RTAS tokens
559  *
560  * returns 0 on succes, <0 on failure
561  *
562  * wdrtas_get_tokens reads in the tokens for the RTAS calls used in
563  * this watchdog driver. It tolerates, if "get-sensor-state" and
564  * "ibm,get-system-parameter" are not available.
565  */
566 static int
567 wdrtas_get_tokens(void)
568 {
569         wdrtas_token_get_sensor_state = rtas_token("get-sensor-state");
570         if (wdrtas_token_get_sensor_state == RTAS_UNKNOWN_SERVICE) {
571                 printk(KERN_WARNING "wdrtas: couldn't get token for "
572                        "get-sensor-state. Trying to continue without "
573                        "temperature support.\n");
574         }
575
576         wdrtas_token_get_sp = rtas_token("ibm,get-system-parameter");
577         if (wdrtas_token_get_sp == RTAS_UNKNOWN_SERVICE) {
578                 printk(KERN_WARNING "wdrtas: couldn't get token for "
579                        "ibm,get-system-parameter. Trying to continue with "
580                        "a default timeout value of %i seconds.\n",
581                        WDRTAS_DEFAULT_INTERVAL);
582         }
583
584         wdrtas_token_set_indicator = rtas_token("set-indicator");
585         if (wdrtas_token_set_indicator == RTAS_UNKNOWN_SERVICE) {
586                 printk(KERN_ERR "wdrtas: couldn't get token for "
587                        "set-indicator. Terminating watchdog code.\n");
588                 return -EIO;
589         }
590
591         wdrtas_token_event_scan = rtas_token("event-scan");
592         if (wdrtas_token_event_scan == RTAS_UNKNOWN_SERVICE) {
593                 printk(KERN_ERR "wdrtas: couldn't get token for event-scan. "
594                        "Terminating watchdog code.\n");
595                 return -EIO;
596         }
597
598         return 0;
599 }
600
601 /**
602  * wdrtas_unregister_devs - unregisters the misc dev handlers
603  *
604  * wdrtas_register_devs unregisters the watchdog and temperature watchdog
605  * misc devs
606  */
607 static void
608 wdrtas_unregister_devs(void)
609 {
610         misc_deregister(&wdrtas_miscdev);
611         if (wdrtas_token_get_sensor_state != RTAS_UNKNOWN_SERVICE)
612                 misc_deregister(&wdrtas_tempdev);
613 }
614
615 /**
616  * wdrtas_register_devs - registers the misc dev handlers
617  *
618  * returns 0 on succes, <0 on failure
619  *
620  * wdrtas_register_devs registers the watchdog and temperature watchdog
621  * misc devs
622  */
623 static int
624 wdrtas_register_devs(void)
625 {
626         int result;
627
628         result = misc_register(&wdrtas_miscdev);
629         if (result) {
630                 printk(KERN_ERR "wdrtas: couldn't register watchdog misc "
631                        "device. Terminating watchdog code.\n");
632                 return result;
633         }
634
635         if (wdrtas_token_get_sensor_state != RTAS_UNKNOWN_SERVICE) {
636                 result = misc_register(&wdrtas_tempdev);
637                 if (result) {
638                         printk(KERN_WARNING "wdrtas: couldn't register "
639                                "watchdog temperature misc device. Continuing "
640                                "without temperature support.\n");
641                         wdrtas_token_get_sensor_state = RTAS_UNKNOWN_SERVICE;
642                 }
643         }
644
645         return 0;
646 }
647
648 /**
649  * wdrtas_init - init function of the watchdog driver
650  *
651  * returns 0 on succes, <0 on failure
652  *
653  * registers the file handlers and the reboot notifier
654  */
655 static int __init
656 wdrtas_init(void)
657 {
658         if (wdrtas_get_tokens())
659                 return -ENODEV;
660
661         if (wdrtas_register_devs())
662                 return -ENODEV;
663
664         if (register_reboot_notifier(&wdrtas_notifier)) {
665                 printk(KERN_ERR "wdrtas: could not register reboot notifier. "
666                        "Terminating watchdog code.\n");
667                 wdrtas_unregister_devs();
668                 return -ENODEV;
669         }
670
671         if (wdrtas_token_get_sp == RTAS_UNKNOWN_SERVICE)
672                 wdrtas_interval = WDRTAS_DEFAULT_INTERVAL;
673         else
674                 wdrtas_interval = wdrtas_get_interval(WDRTAS_DEFAULT_INTERVAL);
675
676         return 0;
677 }
678
679 /**
680  * wdrtas_exit - exit function of the watchdog driver
681  *
682  * unregisters the file handlers and the reboot notifier
683  */
684 static void __exit
685 wdrtas_exit(void)
686 {
687         if (!wdrtas_nowayout)
688                 wdrtas_timer_stop();
689
690         wdrtas_unregister_devs();
691
692         unregister_reboot_notifier(&wdrtas_notifier);
693 }
694
695 module_init(wdrtas_init);
696 module_exit(wdrtas_exit);