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