Commit | Line | Data |
---|---|---|
cc90ef0f | 1 | /* |
abda5c8b | 2 | * i6300esb: Watchdog timer driver for Intel 6300ESB chipset |
cc90ef0f DH |
3 | * |
4 | * (c) Copyright 2004 Google Inc. | |
96de0e25 | 5 | * (c) Copyright 2005 David Härdeman <david@2gen.com> |
cc90ef0f DH |
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. | |
11 | * | |
7944d3a5 | 12 | * based on i810-tco.c which is in turn based on softdog.c |
cc90ef0f | 13 | * |
7944d3a5 WVS |
14 | * The timer is implemented in the following I/O controller hubs: |
15 | * (See the intel documentation on http://developer.intel.com.) | |
16 | * 6300ESB chip : document number 300641-003 | |
cc90ef0f DH |
17 | * |
18 | * 2004YYZZ Ross Biro | |
19 | * Initial version 0.01 | |
20 | * 2004YYZZ Ross Biro | |
7944d3a5 | 21 | * Version 0.02 |
96de0e25 | 22 | * 20050210 David Härdeman <david@2gen.com> |
7944d3a5 | 23 | * Ported driver to kernel 2.6 |
cc90ef0f DH |
24 | */ |
25 | ||
26 | /* | |
27 | * Includes, defines, variables, module parameters, ... | |
28 | */ | |
29 | ||
30 | #include <linux/module.h> | |
31 | #include <linux/types.h> | |
32 | #include <linux/kernel.h> | |
33 | #include <linux/fs.h> | |
34 | #include <linux/mm.h> | |
35 | #include <linux/miscdevice.h> | |
36 | #include <linux/watchdog.h> | |
37 | #include <linux/reboot.h> | |
38 | #include <linux/init.h> | |
39 | #include <linux/pci.h> | |
40 | #include <linux/ioport.h> | |
0829291e AC |
41 | #include <linux/uaccess.h> |
42 | #include <linux/io.h> | |
cc90ef0f | 43 | |
cc90ef0f DH |
44 | /* Module and version information */ |
45 | #define ESB_VERSION "0.03" | |
46 | #define ESB_MODULE_NAME "i6300ESB timer" | |
47 | #define ESB_DRIVER_NAME ESB_MODULE_NAME ", v" ESB_VERSION | |
48 | #define PFX ESB_MODULE_NAME ": " | |
49 | ||
abda5c8b DH |
50 | /* PCI configuration registers */ |
51 | #define ESB_CONFIG_REG 0x60 /* Config register */ | |
52 | #define ESB_LOCK_REG 0x68 /* WDT lock register */ | |
53 | ||
54 | /* Memory mapped registers */ | |
55 | #define ESB_TIMER1_REG BASEADDR + 0x00 /* Timer1 value after each reset */ | |
56 | #define ESB_TIMER2_REG BASEADDR + 0x04 /* Timer2 value after each reset */ | |
57 | #define ESB_GINTSR_REG BASEADDR + 0x08 /* General Interrupt Status Register */ | |
58 | #define ESB_RELOAD_REG BASEADDR + 0x0c /* Reload register */ | |
59 | ||
60 | /* Lock register bits */ | |
0829291e AC |
61 | #define ESB_WDT_FUNC (0x01 << 2) /* Watchdog functionality */ |
62 | #define ESB_WDT_ENABLE (0x01 << 1) /* Enable WDT */ | |
63 | #define ESB_WDT_LOCK (0x01 << 0) /* Lock (nowayout) */ | |
abda5c8b DH |
64 | |
65 | /* Config register bits */ | |
0829291e AC |
66 | #define ESB_WDT_REBOOT (0x01 << 5) /* Enable reboot on timeout */ |
67 | #define ESB_WDT_FREQ (0x01 << 2) /* Decrement frequency */ | |
68 | #define ESB_WDT_INTTYPE (0x11 << 0) /* Interrupt type on timer1 timeout */ | |
abda5c8b DH |
69 | |
70 | /* Reload register bits */ | |
0829291e | 71 | #define ESB_WDT_RELOAD (0x01 << 8) /* prevent timeout */ |
abda5c8b DH |
72 | |
73 | /* Magic constants */ | |
74 | #define ESB_UNLOCK1 0x80 /* Step 1 to unlock reset registers */ | |
75 | #define ESB_UNLOCK2 0x86 /* Step 2 to unlock reset registers */ | |
76 | ||
cc90ef0f DH |
77 | /* internal variables */ |
78 | static void __iomem *BASEADDR; | |
c7dfd0cc | 79 | static DEFINE_SPINLOCK(esb_lock); /* Guards the hardware */ |
cc90ef0f DH |
80 | static unsigned long timer_alive; |
81 | static struct pci_dev *esb_pci; | |
82 | static unsigned short triggered; /* The status of the watchdog upon boot */ | |
83 | static char esb_expect_close; | |
84 | ||
85 | /* module parameters */ | |
0829291e AC |
86 | /* 30 sec default heartbeat (1 < heartbeat < 2*1023) */ |
87 | #define WATCHDOG_HEARTBEAT 30 | |
cc90ef0f | 88 | static int heartbeat = WATCHDOG_HEARTBEAT; /* in seconds */ |
0829291e | 89 | |
cc90ef0f | 90 | module_param(heartbeat, int, 0); |
0829291e AC |
91 | MODULE_PARM_DESC(heartbeat, |
92 | "Watchdog heartbeat in seconds. (1<heartbeat<2046, default=" | |
93 | __MODULE_STRING(WATCHDOG_HEARTBEAT) ")"); | |
cc90ef0f | 94 | |
811f9991 | 95 | static int nowayout = WATCHDOG_NOWAYOUT; |
cc90ef0f | 96 | module_param(nowayout, int, 0); |
0829291e AC |
97 | MODULE_PARM_DESC(nowayout, |
98 | "Watchdog cannot be stopped once started (default=" | |
99 | __MODULE_STRING(WATCHDOG_NOWAYOUT) ")"); | |
cc90ef0f DH |
100 | |
101 | /* | |
102 | * Some i6300ESB specific functions | |
103 | */ | |
104 | ||
105 | /* | |
106 | * Prepare for reloading the timer by unlocking the proper registers. | |
107 | * This is performed by first writing 0x80 followed by 0x86 to the | |
108 | * reload register. After this the appropriate registers can be written | |
109 | * to once before they need to be unlocked again. | |
110 | */ | |
7944d3a5 WVS |
111 | static inline void esb_unlock_registers(void) |
112 | { | |
0829291e AC |
113 | writeb(ESB_UNLOCK1, ESB_RELOAD_REG); |
114 | writeb(ESB_UNLOCK2, ESB_RELOAD_REG); | |
cc90ef0f DH |
115 | } |
116 | ||
117 | static void esb_timer_start(void) | |
118 | { | |
119 | u8 val; | |
120 | ||
121 | /* Enable or Enable + Lock? */ | |
28562af3 | 122 | val = 0x02 | (nowayout ? 0x01 : 0x00); |
0829291e | 123 | pci_write_config_byte(esb_pci, ESB_LOCK_REG, val); |
cc90ef0f DH |
124 | } |
125 | ||
126 | static int esb_timer_stop(void) | |
127 | { | |
128 | u8 val; | |
129 | ||
130 | spin_lock(&esb_lock); | |
131 | /* First, reset timers as suggested by the docs */ | |
132 | esb_unlock_registers(); | |
ce2f50b4 | 133 | writew(ESB_WDT_RELOAD, ESB_RELOAD_REG); |
cc90ef0f DH |
134 | /* Then disable the WDT */ |
135 | pci_write_config_byte(esb_pci, ESB_LOCK_REG, 0x0); | |
136 | pci_read_config_byte(esb_pci, ESB_LOCK_REG, &val); | |
137 | spin_unlock(&esb_lock); | |
138 | ||
139 | /* Returns 0 if the timer was disabled, non-zero otherwise */ | |
140 | return (val & 0x01); | |
141 | } | |
142 | ||
143 | static void esb_timer_keepalive(void) | |
144 | { | |
145 | spin_lock(&esb_lock); | |
146 | esb_unlock_registers(); | |
ce2f50b4 | 147 | writew(ESB_WDT_RELOAD, ESB_RELOAD_REG); |
0829291e | 148 | /* FIXME: Do we need to flush anything here? */ |
cc90ef0f DH |
149 | spin_unlock(&esb_lock); |
150 | } | |
151 | ||
152 | static int esb_timer_set_heartbeat(int time) | |
153 | { | |
154 | u32 val; | |
155 | ||
156 | if (time < 0x1 || time > (2 * 0x03ff)) | |
157 | return -EINVAL; | |
158 | ||
159 | spin_lock(&esb_lock); | |
160 | ||
161 | /* We shift by 9, so if we are passed a value of 1 sec, | |
162 | * val will be 1 << 9 = 512, then write that to two | |
163 | * timers => 2 * 512 = 1024 (which is decremented at 1KHz) | |
164 | */ | |
165 | val = time << 9; | |
166 | ||
167 | /* Write timer 1 */ | |
168 | esb_unlock_registers(); | |
169 | writel(val, ESB_TIMER1_REG); | |
170 | ||
171 | /* Write timer 2 */ | |
172 | esb_unlock_registers(); | |
7944d3a5 | 173 | writel(val, ESB_TIMER2_REG); |
cc90ef0f | 174 | |
0829291e | 175 | /* Reload */ |
cc90ef0f | 176 | esb_unlock_registers(); |
ce2f50b4 | 177 | writew(ESB_WDT_RELOAD, ESB_RELOAD_REG); |
cc90ef0f DH |
178 | |
179 | /* FIXME: Do we need to flush everything out? */ | |
180 | ||
181 | /* Done */ | |
182 | heartbeat = time; | |
183 | spin_unlock(&esb_lock); | |
184 | return 0; | |
185 | } | |
186 | ||
0829291e | 187 | static int esb_timer_read(void) |
cc90ef0f | 188 | { |
0829291e | 189 | u32 count; |
cc90ef0f DH |
190 | |
191 | /* This isn't documented, and doesn't take into | |
0829291e AC |
192 | * acount which stage is running, but it looks |
193 | * like a 20 bit count down, so we might as well report it. | |
194 | */ | |
195 | pci_read_config_dword(esb_pci, 0x64, &count); | |
196 | return (int)count; | |
cc90ef0f DH |
197 | } |
198 | ||
199 | /* | |
7944d3a5 | 200 | * /dev/watchdog handling |
cc90ef0f DH |
201 | */ |
202 | ||
0829291e | 203 | static int esb_open(struct inode *inode, struct file *file) |
cc90ef0f | 204 | { |
0829291e AC |
205 | /* /dev/watchdog can only be opened once */ |
206 | if (test_and_set_bit(0, &timer_alive)) | |
207 | return -EBUSY; | |
cc90ef0f | 208 | |
0829291e AC |
209 | /* Reload and activate timer */ |
210 | esb_timer_keepalive(); | |
211 | esb_timer_start(); | |
cc90ef0f DH |
212 | |
213 | return nonseekable_open(inode, file); | |
214 | } | |
215 | ||
0829291e | 216 | static int esb_release(struct inode *inode, struct file *file) |
cc90ef0f | 217 | { |
0829291e AC |
218 | /* Shut off the timer. */ |
219 | if (esb_expect_close == 42) | |
220 | esb_timer_stop(); | |
221 | else { | |
222 | printk(KERN_CRIT PFX | |
223 | "Unexpected close, not stopping watchdog!\n"); | |
224 | esb_timer_keepalive(); | |
225 | } | |
226 | clear_bit(0, &timer_alive); | |
227 | esb_expect_close = 0; | |
228 | return 0; | |
cc90ef0f DH |
229 | } |
230 | ||
0829291e AC |
231 | static ssize_t esb_write(struct file *file, const char __user *data, |
232 | size_t len, loff_t *ppos) | |
cc90ef0f DH |
233 | { |
234 | /* See if we got the magic character 'V' and reload the timer */ | |
0829291e | 235 | if (len) { |
cc90ef0f DH |
236 | if (!nowayout) { |
237 | size_t i; | |
238 | ||
239 | /* note: just in case someone wrote the magic character | |
240 | * five months ago... */ | |
241 | esb_expect_close = 0; | |
242 | ||
143a2e54 WVS |
243 | /* scan to see whether or not we got the |
244 | * magic character */ | |
cc90ef0f DH |
245 | for (i = 0; i != len; i++) { |
246 | char c; | |
7944d3a5 | 247 | if (get_user(c, data + i)) |
cc90ef0f DH |
248 | return -EFAULT; |
249 | if (c == 'V') | |
250 | esb_expect_close = 42; | |
251 | } | |
252 | } | |
253 | ||
254 | /* someone wrote to us, we should reload the timer */ | |
0829291e | 255 | esb_timer_keepalive(); |
cc90ef0f DH |
256 | } |
257 | return len; | |
258 | } | |
259 | ||
0829291e | 260 | static long esb_ioctl(struct file *file, unsigned int cmd, unsigned long arg) |
cc90ef0f DH |
261 | { |
262 | int new_options, retval = -EINVAL; | |
263 | int new_heartbeat; | |
264 | void __user *argp = (void __user *)arg; | |
265 | int __user *p = argp; | |
266 | static struct watchdog_info ident = { | |
7944d3a5 | 267 | .options = WDIOF_SETTIMEOUT | |
cc90ef0f DH |
268 | WDIOF_KEEPALIVEPING | |
269 | WDIOF_MAGICCLOSE, | |
7944d3a5 WVS |
270 | .firmware_version = 0, |
271 | .identity = ESB_MODULE_NAME, | |
cc90ef0f DH |
272 | }; |
273 | ||
274 | switch (cmd) { | |
0829291e AC |
275 | case WDIOC_GETSUPPORT: |
276 | return copy_to_user(argp, &ident, | |
277 | sizeof(ident)) ? -EFAULT : 0; | |
cc90ef0f | 278 | |
0829291e AC |
279 | case WDIOC_GETSTATUS: |
280 | return put_user(esb_timer_read(), p); | |
cc90ef0f | 281 | |
0829291e AC |
282 | case WDIOC_GETBOOTSTATUS: |
283 | return put_user(triggered, p); | |
cc90ef0f | 284 | |
0829291e AC |
285 | case WDIOC_SETOPTIONS: |
286 | { | |
287 | if (get_user(new_options, p)) | |
288 | return -EFAULT; | |
cc90ef0f | 289 | |
0829291e AC |
290 | if (new_options & WDIOS_DISABLECARD) { |
291 | esb_timer_stop(); | |
292 | retval = 0; | |
293 | } | |
cc90ef0f | 294 | |
0829291e AC |
295 | if (new_options & WDIOS_ENABLECARD) { |
296 | esb_timer_keepalive(); | |
297 | esb_timer_start(); | |
298 | retval = 0; | |
299 | } | |
300 | return retval; | |
301 | } | |
0c06090c WVS |
302 | case WDIOC_KEEPALIVE: |
303 | esb_timer_keepalive(); | |
304 | return 0; | |
305 | ||
0829291e AC |
306 | case WDIOC_SETTIMEOUT: |
307 | { | |
308 | if (get_user(new_heartbeat, p)) | |
309 | return -EFAULT; | |
310 | if (esb_timer_set_heartbeat(new_heartbeat)) | |
311 | return -EINVAL; | |
312 | esb_timer_keepalive(); | |
313 | /* Fall */ | |
314 | } | |
315 | case WDIOC_GETTIMEOUT: | |
316 | return put_user(heartbeat, p); | |
317 | default: | |
318 | return -ENOTTY; | |
319 | } | |
cc90ef0f DH |
320 | } |
321 | ||
322 | /* | |
323 | * Notify system | |
324 | */ | |
325 | ||
0829291e AC |
326 | static int esb_notify_sys(struct notifier_block *this, |
327 | unsigned long code, void *unused) | |
cc90ef0f | 328 | { |
7944d3a5 WVS |
329 | if (code == SYS_DOWN || code == SYS_HALT) |
330 | esb_timer_stop(); /* Turn the WDT off */ | |
331 | ||
0829291e | 332 | return NOTIFY_DONE; |
cc90ef0f DH |
333 | } |
334 | ||
335 | /* | |
336 | * Kernel Interfaces | |
337 | */ | |
338 | ||
62322d25 | 339 | static const struct file_operations esb_fops = { |
0829291e AC |
340 | .owner = THIS_MODULE, |
341 | .llseek = no_llseek, | |
342 | .write = esb_write, | |
343 | .unlocked_ioctl = esb_ioctl, | |
344 | .open = esb_open, | |
345 | .release = esb_release, | |
cc90ef0f DH |
346 | }; |
347 | ||
348 | static struct miscdevice esb_miscdev = { | |
0829291e AC |
349 | .minor = WATCHDOG_MINOR, |
350 | .name = "watchdog", | |
351 | .fops = &esb_fops, | |
cc90ef0f DH |
352 | }; |
353 | ||
354 | static struct notifier_block esb_notifier = { | |
0829291e | 355 | .notifier_call = esb_notify_sys, |
cc90ef0f DH |
356 | }; |
357 | ||
358 | /* | |
359 | * Data for PCI driver interface | |
360 | * | |
361 | * This data only exists for exporting the supported | |
362 | * PCI ids via MODULE_DEVICE_TABLE. We do not actually | |
363 | * register a pci_driver, because someone else might one day | |
364 | * want to register another driver on the same PCI id. | |
365 | */ | |
366 | static struct pci_device_id esb_pci_tbl[] = { | |
0829291e AC |
367 | { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ESB_9), }, |
368 | { 0, }, /* End of list */ | |
cc90ef0f | 369 | }; |
0829291e | 370 | MODULE_DEVICE_TABLE(pci, esb_pci_tbl); |
cc90ef0f DH |
371 | |
372 | /* | |
373 | * Init & exit routines | |
374 | */ | |
375 | ||
0829291e | 376 | static unsigned char __init esb_getdevice(void) |
cc90ef0f DH |
377 | { |
378 | u8 val1; | |
379 | unsigned short val2; | |
0829291e AC |
380 | /* |
381 | * Find the PCI device | |
382 | */ | |
cc90ef0f | 383 | |
0829291e AC |
384 | esb_pci = pci_get_device(PCI_VENDOR_ID_INTEL, |
385 | PCI_DEVICE_ID_INTEL_ESB_9, NULL); | |
cc90ef0f | 386 | |
0829291e AC |
387 | if (esb_pci) { |
388 | if (pci_enable_device(esb_pci)) { | |
389 | printk(KERN_ERR PFX "failed to enable device\n"); | |
811f9991 | 390 | goto err_devput; |
cc90ef0f DH |
391 | } |
392 | ||
393 | if (pci_request_region(esb_pci, 0, ESB_MODULE_NAME)) { | |
0829291e | 394 | printk(KERN_ERR PFX "failed to request region\n"); |
cc90ef0f DH |
395 | goto err_disable; |
396 | } | |
397 | ||
af4c293f | 398 | BASEADDR = pci_ioremap_bar(esb_pci, 0); |
cc90ef0f | 399 | if (BASEADDR == NULL) { |
0829291e AC |
400 | /* Something's wrong here, BASEADDR has to be set */ |
401 | printk(KERN_ERR PFX "failed to get BASEADDR\n"); | |
402 | goto err_release; | |
403 | } | |
cc90ef0f DH |
404 | |
405 | /* | |
406 | * The watchdog has two timers, it can be setup so that the | |
407 | * expiry of timer1 results in an interrupt and the expiry of | |
408 | * timer2 results in a reboot. We set it to not generate | |
409 | * any interrupts as there is not much we can do with it | |
410 | * right now. | |
411 | * | |
412 | * We also enable reboots and set the timer frequency to | |
413 | * the PCI clock divided by 2^15 (approx 1KHz). | |
414 | */ | |
415 | pci_write_config_word(esb_pci, ESB_CONFIG_REG, 0x0003); | |
416 | ||
417 | /* Check that the WDT isn't already locked */ | |
418 | pci_read_config_byte(esb_pci, ESB_LOCK_REG, &val1); | |
419 | if (val1 & ESB_WDT_LOCK) | |
0829291e | 420 | printk(KERN_WARNING PFX "nowayout already set\n"); |
cc90ef0f DH |
421 | |
422 | /* Set the timer to watchdog mode and disable it for now */ | |
423 | pci_write_config_byte(esb_pci, ESB_LOCK_REG, 0x00); | |
424 | ||
425 | /* Check if the watchdog was previously triggered */ | |
426 | esb_unlock_registers(); | |
427 | val2 = readw(ESB_RELOAD_REG); | |
428 | triggered = (val2 & (0x01 << 9) >> 9); | |
429 | ||
430 | /* Reset trigger flag and timers */ | |
431 | esb_unlock_registers(); | |
432 | writew((0x11 << 8), ESB_RELOAD_REG); | |
433 | ||
434 | /* Done */ | |
435 | return 1; | |
436 | ||
437 | err_release: | |
438 | pci_release_region(esb_pci, 0); | |
439 | err_disable: | |
440 | pci_disable_device(esb_pci); | |
811f9991 | 441 | err_devput: |
c69af038 | 442 | pci_dev_put(esb_pci); |
cc90ef0f | 443 | } |
cc90ef0f DH |
444 | return 0; |
445 | } | |
446 | ||
0829291e | 447 | static int __init watchdog_init(void) |
cc90ef0f | 448 | { |
0829291e AC |
449 | int ret; |
450 | ||
451 | /* Check whether or not the hardware watchdog is there */ | |
452 | if (!esb_getdevice() || esb_pci == NULL) | |
453 | return -ENODEV; | |
454 | ||
455 | /* Check that the heartbeat value is within it's range; | |
456 | if not reset to the default */ | |
457 | if (esb_timer_set_heartbeat(heartbeat)) { | |
458 | esb_timer_set_heartbeat(WATCHDOG_HEARTBEAT); | |
459 | printk(KERN_INFO PFX | |
460 | "heartbeat value must be 1<heartbeat<2046, using %d\n", | |
461 | heartbeat); | |
462 | } | |
463 | ret = register_reboot_notifier(&esb_notifier); | |
464 | if (ret != 0) { | |
465 | printk(KERN_ERR PFX | |
466 | "cannot register reboot notifier (err=%d)\n", ret); | |
467 | goto err_unmap; | |
468 | } | |
cc90ef0f | 469 | |
0829291e AC |
470 | ret = misc_register(&esb_miscdev); |
471 | if (ret != 0) { | |
472 | printk(KERN_ERR PFX | |
473 | "cannot register miscdev on minor=%d (err=%d)\n", | |
474 | WATCHDOG_MINOR, ret); | |
475 | goto err_notifier; | |
476 | } | |
477 | esb_timer_stop(); | |
478 | printk(KERN_INFO PFX | |
479 | "initialized (0x%p). heartbeat=%d sec (nowayout=%d)\n", | |
480 | BASEADDR, heartbeat, nowayout); | |
481 | return 0; | |
cc90ef0f DH |
482 | |
483 | err_notifier: | |
0829291e | 484 | unregister_reboot_notifier(&esb_notifier); |
cc90ef0f DH |
485 | err_unmap: |
486 | iounmap(BASEADDR); | |
487 | /* err_release: */ | |
488 | pci_release_region(esb_pci, 0); | |
489 | /* err_disable: */ | |
490 | pci_disable_device(esb_pci); | |
811f9991 | 491 | /* err_devput: */ |
c69af038 | 492 | pci_dev_put(esb_pci); |
0829291e | 493 | return ret; |
cc90ef0f DH |
494 | } |
495 | ||
0829291e | 496 | static void __exit watchdog_cleanup(void) |
cc90ef0f DH |
497 | { |
498 | /* Stop the timer before we leave */ | |
499 | if (!nowayout) | |
0829291e | 500 | esb_timer_stop(); |
cc90ef0f DH |
501 | |
502 | /* Deregister */ | |
503 | misc_deregister(&esb_miscdev); | |
0829291e | 504 | unregister_reboot_notifier(&esb_notifier); |
cc90ef0f DH |
505 | iounmap(BASEADDR); |
506 | pci_release_region(esb_pci, 0); | |
507 | pci_disable_device(esb_pci); | |
c69af038 | 508 | pci_dev_put(esb_pci); |
cc90ef0f DH |
509 | } |
510 | ||
511 | module_init(watchdog_init); | |
512 | module_exit(watchdog_cleanup); | |
513 | ||
96de0e25 | 514 | MODULE_AUTHOR("Ross Biro and David Härdeman"); |
cc90ef0f DH |
515 | MODULE_DESCRIPTION("Watchdog driver for Intel 6300ESB chipsets"); |
516 | MODULE_LICENSE("GPL"); | |
517 | MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); |