Commit | Line | Data |
---|---|---|
485ae77d SA |
1 | /* |
2 | * SMsC 37B787 Watchdog Timer driver for Linux 2.6.x.x | |
3 | * | |
29fa0586 | 4 | * Based on acquirewdt.c by Alan Cox <alan@lxorguk.ukuu.org.uk> |
143a2e54 | 5 | * and some other existing drivers |
485ae77d SA |
6 | * |
7 | * This program is free software; you can redistribute it and/or | |
8 | * modify it under the terms of the GNU General Public License | |
9 | * as published by the Free Software Foundation; either version | |
10 | * 2 of the License, or (at your option) any later version. | |
8386c8cf | 11 | * |
485ae77d SA |
12 | * The authors do NOT admit liability nor provide warranty for |
13 | * any of this software. This material is provided "AS-IS" in | |
143a2e54 | 14 | * the hope that it may be useful for others. |
485ae77d SA |
15 | * |
16 | * (C) Copyright 2003-2006 Sven Anders <anders@anduras.de> | |
17 | * | |
18 | * History: | |
19 | * 2003 - Created version 1.0 for Linux 2.4.x. | |
20 | * 2006 - Ported to Linux 2.6, added nowayout and MAGICCLOSE | |
59846793 | 21 | * features. Released version 1.1 |
485ae77d SA |
22 | * |
23 | * Theory of operation: | |
24 | * | |
143a2e54 WVS |
25 | * A Watchdog Timer (WDT) is a hardware circuit that can |
26 | * reset the computer system in case of a software fault. | |
27 | * You probably knew that already. | |
485ae77d | 28 | * |
143a2e54 WVS |
29 | * Usually a userspace daemon will notify the kernel WDT driver |
30 | * via the /dev/watchdog special device file that userspace is | |
31 | * still alive, at regular intervals. When such a notification | |
32 | * occurs, the driver will usually tell the hardware watchdog | |
33 | * that everything is in order, and that the watchdog should wait | |
34 | * for yet another little while to reset the system. | |
35 | * If userspace fails (RAM error, kernel bug, whatever), the | |
36 | * notifications cease to occur, and the hardware watchdog will | |
37 | * reset the system (causing a reboot) after the timeout occurs. | |
485ae77d SA |
38 | * |
39 | * Create device with: | |
40 | * mknod /dev/watchdog c 10 130 | |
41 | * | |
42 | * For an example userspace keep-alive daemon, see: | |
395cf969 | 43 | * Documentation/watchdog/wdt.txt |
485ae77d SA |
44 | */ |
45 | ||
27c766aa JP |
46 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
47 | ||
485ae77d SA |
48 | #include <linux/module.h> |
49 | #include <linux/moduleparam.h> | |
50 | #include <linux/types.h> | |
51 | #include <linux/miscdevice.h> | |
52 | #include <linux/watchdog.h> | |
53 | #include <linux/delay.h> | |
54 | #include <linux/fs.h> | |
55 | #include <linux/ioport.h> | |
56 | #include <linux/notifier.h> | |
57 | #include <linux/reboot.h> | |
58 | #include <linux/init.h> | |
aa1fd4d7 | 59 | #include <linux/spinlock.h> |
59846793 AC |
60 | #include <linux/io.h> |
61 | #include <linux/uaccess.h> | |
485ae77d | 62 | |
485ae77d SA |
63 | #include <asm/system.h> |
64 | ||
65 | /* enable support for minutes as units? */ | |
66 | /* (does not always work correctly, so disabled by default!) */ | |
67 | #define SMSC_SUPPORT_MINUTES | |
68 | #undef SMSC_SUPPORT_MINUTES | |
69 | ||
70 | #define MAX_TIMEOUT 255 | |
71 | ||
72 | #define UNIT_SECOND 0 | |
73 | #define UNIT_MINUTE 1 | |
74 | ||
59846793 | 75 | #define VERSION "1.1" |
485ae77d | 76 | |
59846793 | 77 | #define IOPORT 0x3F0 |
485ae77d | 78 | #define IOPORT_SIZE 2 |
59846793 | 79 | #define IODEV_NO 8 |
485ae77d | 80 | |
59846793 AC |
81 | static int unit = UNIT_SECOND; /* timer's unit */ |
82 | static int timeout = 60; /* timeout value: default is 60 "units" */ | |
83 | static unsigned long timer_enabled; /* is the timer enabled? */ | |
485ae77d SA |
84 | |
85 | static char expect_close; /* is the close expected? */ | |
86 | ||
c7dfd0cc | 87 | static DEFINE_SPINLOCK(io_lock);/* to guard the watchdog from io races */ |
aa1fd4d7 | 88 | |
86a1e189 | 89 | static bool nowayout = WATCHDOG_NOWAYOUT; |
485ae77d SA |
90 | |
91 | /* -- Low level function ----------------------------------------*/ | |
92 | ||
93 | /* unlock the IO chip */ | |
94 | ||
95 | static inline void open_io_config(void) | |
96 | { | |
59846793 | 97 | outb(0x55, IOPORT); |
485ae77d | 98 | mdelay(1); |
59846793 | 99 | outb(0x55, IOPORT); |
485ae77d SA |
100 | } |
101 | ||
102 | /* lock the IO chip */ | |
103 | static inline void close_io_config(void) | |
104 | { | |
59846793 | 105 | outb(0xAA, IOPORT); |
485ae77d SA |
106 | } |
107 | ||
108 | /* select the IO device */ | |
109 | static inline void select_io_device(unsigned char devno) | |
110 | { | |
59846793 AC |
111 | outb(0x07, IOPORT); |
112 | outb(devno, IOPORT+1); | |
485ae77d SA |
113 | } |
114 | ||
115 | /* write to the control register */ | |
116 | static inline void write_io_cr(unsigned char reg, unsigned char data) | |
117 | { | |
59846793 AC |
118 | outb(reg, IOPORT); |
119 | outb(data, IOPORT+1); | |
485ae77d SA |
120 | } |
121 | ||
122 | /* read from the control register */ | |
123 | static inline char read_io_cr(unsigned char reg) | |
124 | { | |
59846793 AC |
125 | outb(reg, IOPORT); |
126 | return inb(IOPORT+1); | |
485ae77d SA |
127 | } |
128 | ||
129 | /* -- Medium level functions ------------------------------------*/ | |
130 | ||
131 | static inline void gpio_bit12(unsigned char reg) | |
132 | { | |
59846793 AC |
133 | /* -- General Purpose I/O Bit 1.2 -- |
134 | * Bit 0, In/Out: 0 = Output, 1 = Input | |
135 | * Bit 1, Polarity: 0 = No Invert, 1 = Invert | |
136 | * Bit 2, Group Enable Intr.: 0 = Disable, 1 = Enable | |
137 | * Bit 3/4, Function select: 00 = GPI/O, 01 = WDT, 10 = P17, | |
138 | * 11 = Either Edge Triggered Intr. 2 | |
139 | * Bit 5/6 (Reserved) | |
140 | * Bit 7, Output Type: 0 = Push Pull Bit, 1 = Open Drain | |
141 | */ | |
142 | write_io_cr(0xE2, reg); | |
485ae77d SA |
143 | } |
144 | ||
145 | static inline void gpio_bit13(unsigned char reg) | |
146 | { | |
59846793 AC |
147 | /* -- General Purpose I/O Bit 1.3 -- |
148 | * Bit 0, In/Out: 0 = Output, 1 = Input | |
149 | * Bit 1, Polarity: 0 = No Invert, 1 = Invert | |
150 | * Bit 2, Group Enable Intr.: 0 = Disable, 1 = Enable | |
151 | * Bit 3, Function select: 0 = GPI/O, 1 = LED | |
152 | * Bit 4-6 (Reserved) | |
153 | * Bit 7, Output Type: 0 = Push Pull Bit, 1 = Open Drain | |
154 | */ | |
155 | write_io_cr(0xE3, reg); | |
485ae77d SA |
156 | } |
157 | ||
158 | static inline void wdt_timer_units(unsigned char new_units) | |
159 | { | |
59846793 AC |
160 | /* -- Watchdog timer units -- |
161 | * Bit 0-6 (Reserved) | |
162 | * Bit 7, WDT Time-out Value Units Select | |
163 | * (0 = Minutes, 1 = Seconds) | |
164 | */ | |
165 | write_io_cr(0xF1, new_units); | |
485ae77d SA |
166 | } |
167 | ||
168 | static inline void wdt_timeout_value(unsigned char new_timeout) | |
169 | { | |
59846793 AC |
170 | /* -- Watchdog Timer Time-out Value -- |
171 | * Bit 0-7 Binary coded units (0=Disabled, 1..255) | |
172 | */ | |
173 | write_io_cr(0xF2, new_timeout); | |
485ae77d SA |
174 | } |
175 | ||
176 | static inline void wdt_timer_conf(unsigned char conf) | |
177 | { | |
59846793 AC |
178 | /* -- Watchdog timer configuration -- |
179 | * Bit 0 Joystick enable: 0* = No Reset, 1 = Reset WDT upon | |
180 | * Gameport I/O | |
181 | * Bit 1 Keyboard enable: 0* = No Reset, 1 = Reset WDT upon KBD Intr. | |
182 | * Bit 2 Mouse enable: 0* = No Reset, 1 = Reset WDT upon Mouse Intr | |
183 | * Bit 3 Reset the timer | |
184 | * (Wrong in SMsC documentation? Given as: PowerLED Timout | |
185 | * Enabled) | |
186 | * Bit 4-7 WDT Interrupt Mapping: (0000* = Disabled, | |
187 | * 0001=IRQ1, 0010=(Invalid), 0011=IRQ3 to 1111=IRQ15) | |
188 | */ | |
189 | write_io_cr(0xF3, conf); | |
485ae77d SA |
190 | } |
191 | ||
192 | static inline void wdt_timer_ctrl(unsigned char reg) | |
193 | { | |
59846793 | 194 | /* -- Watchdog timer control -- |
25985edc | 195 | * Bit 0 Status Bit: 0 = Timer counting, 1 = Timeout occurred |
59846793 AC |
196 | * Bit 1 Power LED Toggle: 0 = Disable Toggle, 1 = Toggle at 1 Hz |
197 | * Bit 2 Force Timeout: 1 = Forces WD timeout event (self-cleaning) | |
198 | * Bit 3 P20 Force Timeout enabled: | |
199 | * 0 = P20 activity does not generate the WD timeout event | |
200 | * 1 = P20 Allows rising edge of P20, from the keyboard | |
201 | * controller, to force the WD timeout event. | |
202 | * Bit 4 (Reserved) | |
203 | * -- Soft power management -- | |
204 | * Bit 5 Stop Counter: 1 = Stop software power down counter | |
205 | * set via register 0xB8, (self-cleaning) | |
206 | * (Upon read: 0 = Counter running, 1 = Counter stopped) | |
207 | * Bit 6 Restart Counter: 1 = Restart software power down counter | |
208 | * set via register 0xB8, (self-cleaning) | |
209 | * Bit 7 SPOFF: 1 = Force software power down (self-cleaning) | |
210 | */ | |
211 | write_io_cr(0xF4, reg); | |
485ae77d SA |
212 | } |
213 | ||
214 | /* -- Higher level functions ------------------------------------*/ | |
215 | ||
216 | /* initialize watchdog */ | |
217 | ||
218 | static void wb_smsc_wdt_initialize(void) | |
219 | { | |
59846793 | 220 | unsigned char old; |
485ae77d | 221 | |
aa1fd4d7 | 222 | spin_lock(&io_lock); |
59846793 AC |
223 | open_io_config(); |
224 | select_io_device(IODEV_NO); | |
485ae77d | 225 | |
59846793 AC |
226 | /* enable the watchdog */ |
227 | gpio_bit13(0x08); /* Select pin 80 = LED not GPIO */ | |
228 | gpio_bit12(0x0A); /* Set pin 79 = WDT not | |
229 | GPIO/Output/Polarity=Invert */ | |
230 | /* disable the timeout */ | |
231 | wdt_timeout_value(0); | |
485ae77d | 232 | |
59846793 AC |
233 | /* reset control register */ |
234 | wdt_timer_ctrl(0x00); | |
485ae77d | 235 | |
59846793 | 236 | /* reset configuration register */ |
485ae77d SA |
237 | wdt_timer_conf(0x00); |
238 | ||
59846793 AC |
239 | /* read old (timer units) register */ |
240 | old = read_io_cr(0xF1) & 0x7F; | |
241 | if (unit == UNIT_SECOND) | |
242 | old |= 0x80; /* set to seconds */ | |
485ae77d | 243 | |
59846793 AC |
244 | /* set the watchdog timer units */ |
245 | wdt_timer_units(old); | |
485ae77d | 246 | |
59846793 | 247 | close_io_config(); |
aa1fd4d7 | 248 | spin_unlock(&io_lock); |
485ae77d SA |
249 | } |
250 | ||
251 | /* shutdown the watchdog */ | |
252 | ||
253 | static void wb_smsc_wdt_shutdown(void) | |
254 | { | |
aa1fd4d7 | 255 | spin_lock(&io_lock); |
59846793 AC |
256 | open_io_config(); |
257 | select_io_device(IODEV_NO); | |
485ae77d | 258 | |
59846793 AC |
259 | /* disable the watchdog */ |
260 | gpio_bit13(0x09); | |
261 | gpio_bit12(0x09); | |
485ae77d | 262 | |
59846793 | 263 | /* reset watchdog config register */ |
485ae77d SA |
264 | wdt_timer_conf(0x00); |
265 | ||
59846793 AC |
266 | /* reset watchdog control register */ |
267 | wdt_timer_ctrl(0x00); | |
485ae77d | 268 | |
59846793 AC |
269 | /* disable timeout */ |
270 | wdt_timeout_value(0x00); | |
485ae77d | 271 | |
59846793 | 272 | close_io_config(); |
aa1fd4d7 | 273 | spin_unlock(&io_lock); |
485ae77d SA |
274 | } |
275 | ||
276 | /* set timeout => enable watchdog */ | |
277 | ||
278 | static void wb_smsc_wdt_set_timeout(unsigned char new_timeout) | |
279 | { | |
aa1fd4d7 | 280 | spin_lock(&io_lock); |
59846793 AC |
281 | open_io_config(); |
282 | select_io_device(IODEV_NO); | |
485ae77d | 283 | |
59846793 AC |
284 | /* set Power LED to blink, if we enable the timeout */ |
285 | wdt_timer_ctrl((new_timeout == 0) ? 0x00 : 0x02); | |
485ae77d | 286 | |
59846793 AC |
287 | /* set timeout value */ |
288 | wdt_timeout_value(new_timeout); | |
485ae77d | 289 | |
59846793 | 290 | close_io_config(); |
aa1fd4d7 | 291 | spin_unlock(&io_lock); |
485ae77d SA |
292 | } |
293 | ||
294 | /* get timeout */ | |
295 | ||
296 | static unsigned char wb_smsc_wdt_get_timeout(void) | |
297 | { | |
59846793 | 298 | unsigned char set_timeout; |
485ae77d | 299 | |
aa1fd4d7 | 300 | spin_lock(&io_lock); |
59846793 AC |
301 | open_io_config(); |
302 | select_io_device(IODEV_NO); | |
303 | set_timeout = read_io_cr(0xF2); | |
304 | close_io_config(); | |
aa1fd4d7 | 305 | spin_unlock(&io_lock); |
485ae77d | 306 | |
59846793 | 307 | return set_timeout; |
485ae77d SA |
308 | } |
309 | ||
310 | /* disable watchdog */ | |
311 | ||
312 | static void wb_smsc_wdt_disable(void) | |
313 | { | |
59846793 AC |
314 | /* set the timeout to 0 to disable the watchdog */ |
315 | wb_smsc_wdt_set_timeout(0); | |
485ae77d SA |
316 | } |
317 | ||
318 | /* enable watchdog by setting the current timeout */ | |
319 | ||
320 | static void wb_smsc_wdt_enable(void) | |
321 | { | |
59846793 AC |
322 | /* set the current timeout... */ |
323 | wb_smsc_wdt_set_timeout(timeout); | |
485ae77d SA |
324 | } |
325 | ||
326 | /* reset the timer */ | |
327 | ||
328 | static void wb_smsc_wdt_reset_timer(void) | |
329 | { | |
aa1fd4d7 | 330 | spin_lock(&io_lock); |
59846793 AC |
331 | open_io_config(); |
332 | select_io_device(IODEV_NO); | |
485ae77d | 333 | |
59846793 | 334 | /* reset the timer */ |
485ae77d SA |
335 | wdt_timeout_value(timeout); |
336 | wdt_timer_conf(0x08); | |
337 | ||
59846793 | 338 | close_io_config(); |
aa1fd4d7 | 339 | spin_unlock(&io_lock); |
485ae77d SA |
340 | } |
341 | ||
342 | /* return, if the watchdog is enabled (timeout is set...) */ | |
343 | ||
344 | static int wb_smsc_wdt_status(void) | |
345 | { | |
346 | return (wb_smsc_wdt_get_timeout() == 0) ? 0 : WDIOF_KEEPALIVEPING; | |
347 | } | |
348 | ||
349 | ||
350 | /* -- File operations -------------------------------------------*/ | |
351 | ||
352 | /* open => enable watchdog and set initial timeout */ | |
353 | ||
354 | static int wb_smsc_wdt_open(struct inode *inode, struct file *file) | |
355 | { | |
356 | /* /dev/watchdog can only be opened once */ | |
357 | ||
aa1fd4d7 | 358 | if (test_and_set_bit(0, &timer_enabled)) |
485ae77d SA |
359 | return -EBUSY; |
360 | ||
361 | if (nowayout) | |
362 | __module_get(THIS_MODULE); | |
363 | ||
364 | /* Reload and activate timer */ | |
485ae77d SA |
365 | wb_smsc_wdt_enable(); |
366 | ||
27c766aa | 367 | pr_info("Watchdog enabled. Timeout set to %d %s\n", |
59846793 | 368 | timeout, (unit == UNIT_SECOND) ? "second(s)" : "minute(s)"); |
485ae77d SA |
369 | |
370 | return nonseekable_open(inode, file); | |
371 | } | |
372 | ||
373 | /* close => shut off the timer */ | |
374 | ||
375 | static int wb_smsc_wdt_release(struct inode *inode, struct file *file) | |
376 | { | |
377 | /* Shut off the timer. */ | |
378 | ||
379 | if (expect_close == 42) { | |
59846793 | 380 | wb_smsc_wdt_disable(); |
27c766aa | 381 | pr_info("Watchdog disabled, sleeping again...\n"); |
485ae77d | 382 | } else { |
27c766aa | 383 | pr_crit("Unexpected close, not stopping watchdog!\n"); |
485ae77d SA |
384 | wb_smsc_wdt_reset_timer(); |
385 | } | |
386 | ||
aa1fd4d7 | 387 | clear_bit(0, &timer_enabled); |
485ae77d SA |
388 | expect_close = 0; |
389 | return 0; | |
390 | } | |
391 | ||
392 | /* write => update the timer to keep the machine alive */ | |
393 | ||
394 | static ssize_t wb_smsc_wdt_write(struct file *file, const char __user *data, | |
395 | size_t len, loff_t *ppos) | |
396 | { | |
397 | /* See if we got the magic character 'V' and reload the timer */ | |
398 | if (len) { | |
399 | if (!nowayout) { | |
400 | size_t i; | |
401 | ||
402 | /* reset expect flag */ | |
403 | expect_close = 0; | |
404 | ||
59846793 AC |
405 | /* scan to see whether or not we got the |
406 | magic character */ | |
485ae77d SA |
407 | for (i = 0; i != len; i++) { |
408 | char c; | |
7944d3a5 | 409 | if (get_user(c, data + i)) |
485ae77d SA |
410 | return -EFAULT; |
411 | if (c == 'V') | |
412 | expect_close = 42; | |
413 | } | |
414 | } | |
415 | ||
416 | /* someone wrote to us, we should reload the timer */ | |
417 | wb_smsc_wdt_reset_timer(); | |
418 | } | |
419 | return len; | |
420 | } | |
421 | ||
422 | /* ioctl => control interface */ | |
423 | ||
59846793 AC |
424 | static long wb_smsc_wdt_ioctl(struct file *file, |
425 | unsigned int cmd, unsigned long arg) | |
485ae77d SA |
426 | { |
427 | int new_timeout; | |
428 | ||
429 | union { | |
430 | struct watchdog_info __user *ident; | |
431 | int __user *i; | |
432 | } uarg; | |
433 | ||
59846793 | 434 | static const struct watchdog_info ident = { |
5f3b2756 | 435 | .options = WDIOF_KEEPALIVEPING | |
59846793 | 436 | WDIOF_SETTIMEOUT | |
485ae77d SA |
437 | WDIOF_MAGICCLOSE, |
438 | .firmware_version = 0, | |
5f3b2756 | 439 | .identity = "SMsC 37B787 Watchdog", |
485ae77d SA |
440 | }; |
441 | ||
442 | uarg.i = (int __user *)arg; | |
443 | ||
444 | switch (cmd) { | |
59846793 AC |
445 | case WDIOC_GETSUPPORT: |
446 | return copy_to_user(uarg.ident, &ident, sizeof(ident)) | |
447 | ? -EFAULT : 0; | |
448 | case WDIOC_GETSTATUS: | |
449 | return put_user(wb_smsc_wdt_status(), uarg.i); | |
450 | case WDIOC_GETBOOTSTATUS: | |
451 | return put_user(0, uarg.i); | |
0c06090c WVS |
452 | case WDIOC_SETOPTIONS: |
453 | { | |
454 | int options, retval = -EINVAL; | |
455 | ||
456 | if (get_user(options, uarg.i)) | |
457 | return -EFAULT; | |
458 | ||
459 | if (options & WDIOS_DISABLECARD) { | |
460 | wb_smsc_wdt_disable(); | |
461 | retval = 0; | |
462 | } | |
463 | if (options & WDIOS_ENABLECARD) { | |
464 | wb_smsc_wdt_enable(); | |
465 | retval = 0; | |
466 | } | |
467 | return retval; | |
468 | } | |
59846793 AC |
469 | case WDIOC_KEEPALIVE: |
470 | wb_smsc_wdt_reset_timer(); | |
471 | return 0; | |
472 | case WDIOC_SETTIMEOUT: | |
473 | if (get_user(new_timeout, uarg.i)) | |
474 | return -EFAULT; | |
475 | /* the API states this is given in secs */ | |
476 | if (unit == UNIT_MINUTE) | |
477 | new_timeout /= 60; | |
478 | if (new_timeout < 0 || new_timeout > MAX_TIMEOUT) | |
479 | return -EINVAL; | |
480 | timeout = new_timeout; | |
481 | wb_smsc_wdt_set_timeout(timeout); | |
482 | /* fall through and return the new timeout... */ | |
483 | case WDIOC_GETTIMEOUT: | |
484 | new_timeout = timeout; | |
485 | if (unit == UNIT_MINUTE) | |
143a2e54 | 486 | new_timeout *= 60; |
59846793 | 487 | return put_user(new_timeout, uarg.i); |
59846793 AC |
488 | default: |
489 | return -ENOTTY; | |
485ae77d SA |
490 | } |
491 | } | |
492 | ||
493 | /* -- Notifier funtions -----------------------------------------*/ | |
494 | ||
59846793 AC |
495 | static int wb_smsc_wdt_notify_sys(struct notifier_block *this, |
496 | unsigned long code, void *unused) | |
485ae77d | 497 | { |
59846793 AC |
498 | if (code == SYS_DOWN || code == SYS_HALT) { |
499 | /* set timeout to 0, to avoid possible race-condition */ | |
500 | timeout = 0; | |
485ae77d SA |
501 | wb_smsc_wdt_disable(); |
502 | } | |
503 | return NOTIFY_DONE; | |
504 | } | |
505 | ||
506 | /* -- Module's structures ---------------------------------------*/ | |
507 | ||
59846793 AC |
508 | static const struct file_operations wb_smsc_wdt_fops = { |
509 | .owner = THIS_MODULE, | |
485ae77d SA |
510 | .llseek = no_llseek, |
511 | .write = wb_smsc_wdt_write, | |
59846793 | 512 | .unlocked_ioctl = wb_smsc_wdt_ioctl, |
485ae77d | 513 | .open = wb_smsc_wdt_open, |
aa1fd4d7 | 514 | .release = wb_smsc_wdt_release, |
485ae77d SA |
515 | }; |
516 | ||
59846793 | 517 | static struct notifier_block wb_smsc_wdt_notifier = { |
aa1fd4d7 | 518 | .notifier_call = wb_smsc_wdt_notify_sys, |
485ae77d SA |
519 | }; |
520 | ||
59846793 | 521 | static struct miscdevice wb_smsc_wdt_miscdev = { |
485ae77d SA |
522 | .minor = WATCHDOG_MINOR, |
523 | .name = "watchdog", | |
524 | .fops = &wb_smsc_wdt_fops, | |
525 | }; | |
526 | ||
527 | /* -- Module init functions -------------------------------------*/ | |
528 | ||
529 | /* module's "constructor" */ | |
530 | ||
531 | static int __init wb_smsc_wdt_init(void) | |
532 | { | |
533 | int ret; | |
534 | ||
27c766aa JP |
535 | pr_info("SMsC 37B787 watchdog component driver " |
536 | VERSION " initialising...\n"); | |
485ae77d SA |
537 | |
538 | if (!request_region(IOPORT, IOPORT_SIZE, "SMsC 37B787 watchdog")) { | |
27c766aa | 539 | pr_err("Unable to register IO port %#x\n", IOPORT); |
485ae77d SA |
540 | ret = -EBUSY; |
541 | goto out_pnp; | |
542 | } | |
543 | ||
59846793 AC |
544 | /* set new maximum, if it's too big */ |
545 | if (timeout > MAX_TIMEOUT) | |
546 | timeout = MAX_TIMEOUT; | |
aa1fd4d7 | 547 | |
59846793 AC |
548 | /* init the watchdog timer */ |
549 | wb_smsc_wdt_initialize(); | |
aa1fd4d7 | 550 | |
485ae77d SA |
551 | ret = register_reboot_notifier(&wb_smsc_wdt_notifier); |
552 | if (ret) { | |
27c766aa | 553 | pr_err("Unable to register reboot notifier err = %d\n", ret); |
485ae77d SA |
554 | goto out_io; |
555 | } | |
556 | ||
557 | ret = misc_register(&wb_smsc_wdt_miscdev); | |
558 | if (ret) { | |
27c766aa JP |
559 | pr_err("Unable to register miscdev on minor %d\n", |
560 | WATCHDOG_MINOR); | |
485ae77d SA |
561 | goto out_rbt; |
562 | } | |
563 | ||
59846793 | 564 | /* output info */ |
27c766aa | 565 | pr_info("Timeout set to %d %s\n", |
59846793 | 566 | timeout, (unit == UNIT_SECOND) ? "second(s)" : "minute(s)"); |
27c766aa JP |
567 | pr_info("Watchdog initialized and sleeping (nowayout=%d)...\n", |
568 | nowayout); | |
485ae77d SA |
569 | out_clean: |
570 | return ret; | |
571 | ||
572 | out_rbt: | |
573 | unregister_reboot_notifier(&wb_smsc_wdt_notifier); | |
574 | ||
575 | out_io: | |
576 | release_region(IOPORT, IOPORT_SIZE); | |
577 | ||
578 | out_pnp: | |
579 | goto out_clean; | |
8386c8cf | 580 | } |
485ae77d SA |
581 | |
582 | /* module's "destructor" */ | |
583 | ||
584 | static void __exit wb_smsc_wdt_exit(void) | |
585 | { | |
586 | /* Stop the timer before we leave */ | |
59846793 | 587 | if (!nowayout) { |
485ae77d | 588 | wb_smsc_wdt_shutdown(); |
27c766aa | 589 | pr_info("Watchdog disabled\n"); |
485ae77d SA |
590 | } |
591 | ||
592 | misc_deregister(&wb_smsc_wdt_miscdev); | |
593 | unregister_reboot_notifier(&wb_smsc_wdt_notifier); | |
594 | release_region(IOPORT, IOPORT_SIZE); | |
595 | ||
27c766aa | 596 | pr_info("SMsC 37B787 watchdog component driver removed\n"); |
485ae77d SA |
597 | } |
598 | ||
599 | module_init(wb_smsc_wdt_init); | |
600 | module_exit(wb_smsc_wdt_exit); | |
601 | ||
602 | MODULE_AUTHOR("Sven Anders <anders@anduras.de>"); | |
59846793 AC |
603 | MODULE_DESCRIPTION("Driver for SMsC 37B787 watchdog component (Version " |
604 | VERSION ")"); | |
485ae77d SA |
605 | MODULE_LICENSE("GPL"); |
606 | ||
607 | MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); | |
608 | ||
609 | #ifdef SMSC_SUPPORT_MINUTES | |
610 | module_param(unit, int, 0); | |
59846793 AC |
611 | MODULE_PARM_DESC(unit, |
612 | "set unit to use, 0=seconds or 1=minutes, default is 0"); | |
485ae77d SA |
613 | #endif |
614 | ||
aa1fd4d7 | 615 | module_param(timeout, int, 0); |
485ae77d SA |
616 | MODULE_PARM_DESC(timeout, "range is 1-255 units, default is 60"); |
617 | ||
86a1e189 | 618 | module_param(nowayout, bool, 0); |
59846793 AC |
619 | MODULE_PARM_DESC(nowayout, |
620 | "Watchdog cannot be stopped once started (default=" | |
621 | __MODULE_STRING(WATCHDOG_NOWAYOUT) ")"); |