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