Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * IndyDog 0.3 A Hardware Watchdog Device for SGI IP22 | |
3 | * | |
4 | * (c) Copyright 2002 Guido Guenther <agx@sigxcpu.org>, All Rights Reserved. | |
5 | * | |
6 | * This program is free software; you can redistribute it and/or | |
7 | * modify it under the terms of the GNU General Public License | |
8 | * as published by the Free Software Foundation; either version | |
9 | * 2 of the License, or (at your option) any later version. | |
10 | * | |
11 | * based on softdog.c by Alan Cox <alan@redhat.com> | |
12 | */ | |
13 | ||
14 | #include <linux/module.h> | |
15 | #include <linux/moduleparam.h> | |
1da177e4 LT |
16 | #include <linux/types.h> |
17 | #include <linux/kernel.h> | |
18 | #include <linux/fs.h> | |
19 | #include <linux/mm.h> | |
20 | #include <linux/miscdevice.h> | |
21 | #include <linux/watchdog.h> | |
22 | #include <linux/notifier.h> | |
23 | #include <linux/reboot.h> | |
24 | #include <linux/init.h> | |
25 | #include <asm/uaccess.h> | |
26 | #include <asm/sgi/mc.h> | |
27 | ||
28 | #define PFX "indydog: " | |
29 | static int indydog_alive; | |
30 | ||
1da177e4 LT |
31 | #define WATCHDOG_TIMEOUT 30 /* 30 sec default timeout */ |
32 | ||
4bfdf378 | 33 | static int nowayout = WATCHDOG_NOWAYOUT; |
1da177e4 | 34 | module_param(nowayout, int, 0); |
bffda5c8 | 35 | MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=" __MODULE_STRING(WATCHDOG_NOWAYOUT) ")"); |
1da177e4 LT |
36 | |
37 | static void indydog_start(void) | |
38 | { | |
39 | u32 mc_ctrl0 = sgimc->cpuctrl0; | |
40 | ||
41 | mc_ctrl0 = sgimc->cpuctrl0 | SGIMC_CCTRL0_WDOG; | |
42 | sgimc->cpuctrl0 = mc_ctrl0; | |
43 | } | |
44 | ||
45 | static void indydog_stop(void) | |
46 | { | |
47 | u32 mc_ctrl0 = sgimc->cpuctrl0; | |
48 | ||
49 | mc_ctrl0 &= ~SGIMC_CCTRL0_WDOG; | |
50 | sgimc->cpuctrl0 = mc_ctrl0; | |
51 | ||
52 | printk(KERN_INFO PFX "Stopped watchdog timer.\n"); | |
53 | } | |
54 | ||
55 | static void indydog_ping(void) | |
56 | { | |
57 | sgimc->watchdogt = 0; | |
58 | } | |
59 | ||
60 | /* | |
61 | * Allow only one person to hold it open | |
62 | */ | |
63 | static int indydog_open(struct inode *inode, struct file *file) | |
64 | { | |
65 | if (indydog_alive) | |
66 | return -EBUSY; | |
67 | ||
68 | if (nowayout) | |
69 | __module_get(THIS_MODULE); | |
70 | ||
71 | /* Activate timer */ | |
72 | indydog_start(); | |
73 | indydog_ping(); | |
74 | ||
75 | indydog_alive = 1; | |
76 | printk(KERN_INFO "Started watchdog timer.\n"); | |
77 | ||
78 | return nonseekable_open(inode, file); | |
79 | } | |
80 | ||
81 | static int indydog_release(struct inode *inode, struct file *file) | |
82 | { | |
83 | /* Shut off the timer. | |
84 | * Lock it in if it's a module and we defined ...NOWAYOUT */ | |
85 | if (!nowayout) | |
86 | indydog_stop(); /* Turn the WDT off */ | |
87 | ||
88 | indydog_alive = 0; | |
89 | ||
90 | return 0; | |
91 | } | |
92 | ||
93 | static ssize_t indydog_write(struct file *file, const char *data, size_t len, loff_t *ppos) | |
94 | { | |
95 | /* Refresh the timer. */ | |
96 | if (len) { | |
97 | indydog_ping(); | |
98 | } | |
99 | return len; | |
100 | } | |
101 | ||
102 | static int indydog_ioctl(struct inode *inode, struct file *file, | |
103 | unsigned int cmd, unsigned long arg) | |
104 | { | |
105 | int options, retval = -EINVAL; | |
106 | static struct watchdog_info ident = { | |
107 | .options = WDIOF_KEEPALIVEPING | | |
108 | WDIOF_MAGICCLOSE, | |
109 | .firmware_version = 0, | |
110 | .identity = "Hardware Watchdog for SGI IP22", | |
111 | }; | |
112 | ||
113 | switch (cmd) { | |
114 | default: | |
795b89d2 | 115 | return -ENOTTY; |
1da177e4 LT |
116 | case WDIOC_GETSUPPORT: |
117 | if (copy_to_user((struct watchdog_info *)arg, | |
118 | &ident, sizeof(ident))) | |
119 | return -EFAULT; | |
120 | return 0; | |
121 | case WDIOC_GETSTATUS: | |
122 | case WDIOC_GETBOOTSTATUS: | |
123 | return put_user(0,(int *)arg); | |
124 | case WDIOC_KEEPALIVE: | |
125 | indydog_ping(); | |
126 | return 0; | |
127 | case WDIOC_GETTIMEOUT: | |
128 | return put_user(WATCHDOG_TIMEOUT,(int *)arg); | |
129 | case WDIOC_SETOPTIONS: | |
130 | { | |
131 | if (get_user(options, (int *)arg)) | |
132 | return -EFAULT; | |
133 | ||
134 | if (options & WDIOS_DISABLECARD) { | |
135 | indydog_stop(); | |
136 | retval = 0; | |
137 | } | |
138 | ||
139 | if (options & WDIOS_ENABLECARD) { | |
140 | indydog_start(); | |
141 | retval = 0; | |
142 | } | |
143 | ||
144 | return retval; | |
145 | } | |
146 | } | |
147 | } | |
148 | ||
149 | static int indydog_notify_sys(struct notifier_block *this, unsigned long code, void *unused) | |
150 | { | |
151 | if (code == SYS_DOWN || code == SYS_HALT) | |
152 | indydog_stop(); /* Turn the WDT off */ | |
153 | ||
154 | return NOTIFY_DONE; | |
155 | } | |
156 | ||
62322d25 | 157 | static const struct file_operations indydog_fops = { |
1da177e4 LT |
158 | .owner = THIS_MODULE, |
159 | .llseek = no_llseek, | |
160 | .write = indydog_write, | |
161 | .ioctl = indydog_ioctl, | |
162 | .open = indydog_open, | |
163 | .release = indydog_release, | |
164 | }; | |
165 | ||
166 | static struct miscdevice indydog_miscdev = { | |
167 | .minor = WATCHDOG_MINOR, | |
168 | .name = "watchdog", | |
169 | .fops = &indydog_fops, | |
170 | }; | |
171 | ||
172 | static struct notifier_block indydog_notifier = { | |
173 | .notifier_call = indydog_notify_sys, | |
174 | }; | |
175 | ||
176 | static char banner[] __initdata = | |
177 | KERN_INFO PFX "Hardware Watchdog Timer for SGI IP22: 0.3\n"; | |
178 | ||
179 | static int __init watchdog_init(void) | |
180 | { | |
181 | int ret; | |
182 | ||
183 | ret = register_reboot_notifier(&indydog_notifier); | |
184 | if (ret) { | |
185 | printk(KERN_ERR PFX "cannot register reboot notifier (err=%d)\n", | |
186 | ret); | |
187 | return ret; | |
188 | } | |
189 | ||
190 | ret = misc_register(&indydog_miscdev); | |
191 | if (ret) { | |
192 | printk(KERN_ERR PFX "cannot register miscdev on minor=%d (err=%d)\n", | |
193 | WATCHDOG_MINOR, ret); | |
194 | unregister_reboot_notifier(&indydog_notifier); | |
195 | return ret; | |
196 | } | |
197 | ||
198 | printk(banner); | |
199 | ||
200 | return 0; | |
201 | } | |
202 | ||
203 | static void __exit watchdog_exit(void) | |
204 | { | |
205 | misc_deregister(&indydog_miscdev); | |
206 | unregister_reboot_notifier(&indydog_notifier); | |
207 | } | |
208 | ||
209 | module_init(watchdog_init); | |
210 | module_exit(watchdog_exit); | |
211 | ||
212 | MODULE_AUTHOR("Guido Guenther <agx@sigxcpu.org>"); | |
213 | MODULE_DESCRIPTION("Hardware Watchdog Device for SGI IP22"); | |
214 | MODULE_LICENSE("GPL"); | |
215 | MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); |