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