1 /* Watchdog timer for the Geode GX/LX with the CS5535/CS5536 companion chip
2 *
3 * Copyright (C) 2006-2007, Advanced Micro Devices, Inc.
4 *
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License
7 * as published by the Free Software Foundation; either version
8 * 2 of the License, or (at your option) any later version.
9 */
10
11
12 #include <linux/module.h>
13 #include <linux/moduleparam.h>
14 #include <linux/types.h>
15 #include <linux/miscdevice.h>
16 #include <linux/watchdog.h>
17 #include <linux/fs.h>
18 #include <linux/platform_device.h>
19 #include <linux/reboot.h>
20 #include <linux/uaccess.h>
21
22 #include <asm/geode.h>
23
24 #define GEODEWDT_HZ 500
25 #define GEODEWDT_SCALE 6
26 #define GEODEWDT_MAX_SECONDS 131
27
28 #define WDT_FLAGS_OPEN 1
29 #define WDT_FLAGS_ORPHAN 2
30
31 #define DRV_NAME "geodewdt"
32 #define WATCHDOG_NAME "Geode GX/LX WDT"
33 #define WATCHDOG_TIMEOUT 60
34
35 static int timeout = WATCHDOG_TIMEOUT;
36 module_param(timeout, int, 0);
37 MODULE_PARM_DESC(timeout,
38 "Watchdog timeout in seconds. 1<= timeout <=131, default="
39 __MODULE_STRING(WATCHDOG_TIMEOUT) ".");
40
41 static int nowayout = WATCHDOG_NOWAYOUT;
42 module_param(nowayout, int, 0);
43 MODULE_PARM_DESC(nowayout,
44 "Watchdog cannot be stopped once started (default="
45 __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
46
47 static struct platform_device *geodewdt_platform_device;
48 static unsigned long wdt_flags;
49 static int wdt_timer;
50 static int safe_close;
51
52 static void geodewdt_ping(void)
53 {
54 /* Stop the counter */
55 geode_mfgpt_write(wdt_timer, MFGPT_REG_SETUP, 0);
56
57 /* Reset the counter */
58 geode_mfgpt_write(wdt_timer, MFGPT_REG_COUNTER, 0);
59
60 /* Enable the counter */
61 geode_mfgpt_write(wdt_timer, MFGPT_REG_SETUP, MFGPT_SETUP_CNTEN);
62 }
63
64 static void geodewdt_disable(void)
65 {
66 geode_mfgpt_write(wdt_timer, MFGPT_REG_SETUP, 0);
67 geode_mfgpt_write(wdt_timer, MFGPT_REG_COUNTER, 0);
68 }
69
70 static int geodewdt_set_heartbeat(int val)
71 {
72 if (val < 1 || val > GEODEWDT_MAX_SECONDS)
73 return -EINVAL;
74
75 geode_mfgpt_write(wdt_timer, MFGPT_REG_SETUP, 0);
76 geode_mfgpt_write(wdt_timer, MFGPT_REG_CMP2, val * GEODEWDT_HZ);
77 geode_mfgpt_write(wdt_timer, MFGPT_REG_COUNTER, 0);
78 geode_mfgpt_write(wdt_timer, MFGPT_REG_SETUP, MFGPT_SETUP_CNTEN);
79
80 timeout = val;
81 return 0;
82 }
83
84 static int geodewdt_open(struct inode *inode, struct file *file)
85 {
86 if (test_and_set_bit(WDT_FLAGS_OPEN, &wdt_flags))
87 return -EBUSY;
88
89 if (!test_and_clear_bit(WDT_FLAGS_ORPHAN, &wdt_flags))
90 __module_get(THIS_MODULE);
91
92 geodewdt_ping();
93 return nonseekable_open(inode, file);
94 }
95
96 static int geodewdt_release(struct inode *inode, struct file *file)
97 {
98 if (safe_close) {
99 geodewdt_disable();
100 module_put(THIS_MODULE);
101 } else {
102 printk(KERN_CRIT "Unexpected close - watchdog is not stopping.\n");
103 geodewdt_ping();
104
105 set_bit(WDT_FLAGS_ORPHAN, &wdt_flags);
106 }
107
108 clear_bit(WDT_FLAGS_OPEN, &wdt_flags);
109 safe_close = 0;
110 return 0;
111 }
112
113 static ssize_t geodewdt_write(struct file *file, const char __user *data,
114 size_t len, loff_t *ppos)
115 {
116 if (len) {
117 if (!nowayout) {
118 size_t i;
119 safe_close = 0;
120
121 for (i = 0; i != len; i++) {
122 char c;
123
124 if (get_user(c, data + i))
125 return -EFAULT;
126
127 if (c == 'V')
128 safe_close = 1;
129 }
130 }
131
132 geodewdt_ping();
133 }
134 return len;
135 }
136
137 static long geodewdt_ioctl(struct file *file, unsigned int cmd,
138 unsigned long arg)
139 {
140 void __user *argp = (void __user *)arg;
141 int __user *p = argp;
142 int interval;
143
144 static struct watchdog_info ident = {
145 .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING
146 | WDIOF_MAGICCLOSE,
147 .firmware_version = 1,
148 .identity = WATCHDOG_NAME,
149 };
150
151 switch (cmd) {
152 case WDIOC_GETSUPPORT:
153 return copy_to_user(argp, &ident,
154 sizeof(ident)) ? -EFAULT : 0;
155 break;
156
157 case WDIOC_GETSTATUS:
158 case WDIOC_GETBOOTSTATUS:
159 return put_user(0, p);
160
161 case WDIOC_SETOPTIONS:
162 {
163 int options, ret = -EINVAL;
164
165 if (get_user(options, p))
166 return -EFAULT;
167
168 if (options & WDIOS_DISABLECARD) {
169 geodewdt_disable();
170 ret = 0;
171 }
172
173 if (options & WDIOS_ENABLECARD) {
174 geodewdt_ping();
175 ret = 0;
176 }
177
178 return ret;
179 }
180 case WDIOC_KEEPALIVE:
181 geodewdt_ping();
182 return 0;
183
184 case WDIOC_SETTIMEOUT:
185 if (get_user(interval, p))
186 return -EFAULT;
187
188 if (geodewdt_set_heartbeat(interval))
189 return -EINVAL;
190 /* Fall through */
191 case WDIOC_GETTIMEOUT:
192 return put_user(timeout, p);
193
194 default:
195 return -ENOTTY;
196 }
197
198 return 0;
199 }
200
201 static const struct file_operations geodewdt_fops = {
202 .owner = THIS_MODULE,
203 .llseek = no_llseek,
204 .write = geodewdt_write,
205 .unlocked_ioctl = geodewdt_ioctl,
206 .open = geodewdt_open,
207 .release = geodewdt_release,
208 };
209
210 static struct miscdevice geodewdt_miscdev = {
211 .minor = WATCHDOG_MINOR,
212 .name = "watchdog",
213 .fops = &geodewdt_fops,
214 };
215
216 static int __devinit geodewdt_probe(struct platform_device *dev)
217 {
218 int ret, timer;
219
220 timer = geode_mfgpt_alloc_timer(MFGPT_TIMER_ANY, MFGPT_DOMAIN_WORKING);
221
222 if (timer == -1) {
223 printk(KERN_ERR "geodewdt: No timers were available\n");
224 return -ENODEV;
225 }
226
227 wdt_timer = timer;
228
229 /* Set up the timer */
230
231 geode_mfgpt_write(wdt_timer, MFGPT_REG_SETUP,
232 GEODEWDT_SCALE | (3 << 8));
233
234 /* Set up comparator 2 to reset when the event fires */
235 geode_mfgpt_toggle_event(wdt_timer, MFGPT_CMP2, MFGPT_EVENT_RESET, 1);
236
237 /* Set up the initial timeout */
238
239 geode_mfgpt_write(wdt_timer, MFGPT_REG_CMP2,
240 timeout * GEODEWDT_HZ);
241
242 ret = misc_register(&geodewdt_miscdev);
243
244 return ret;
245 }
246
247 static int __devexit geodewdt_remove(struct platform_device *dev)
248 {
249 misc_deregister(&geodewdt_miscdev);
250 return 0;
251 }
252
253 static void geodewdt_shutdown(struct platform_device *dev)
254 {
255 geodewdt_disable();
256 }
257
258 static struct platform_driver geodewdt_driver = {
259 .probe = geodewdt_probe,
260 .remove = __devexit_p(geodewdt_remove),
261 .shutdown = geodewdt_shutdown,
262 .driver = {
263 .owner = THIS_MODULE,
264 .name = DRV_NAME,
265 },
266 };
267
268 static int __init geodewdt_init(void)
269 {
270 int ret;
271
272 ret = platform_driver_register(&geodewdt_driver);
273 if (ret)
274 return ret;
275
276 geodewdt_platform_device = platform_device_register_simple(DRV_NAME,
277 -1, NULL, 0);
278 if (IS_ERR(geodewdt_platform_device)) {
279 ret = PTR_ERR(geodewdt_platform_device);
280 goto err;
281 }
282
283 return 0;
284 err:
285 platform_driver_unregister(&geodewdt_driver);
286 return ret;
287 }
288
289 static void __exit geodewdt_exit(void)
290 {
291 platform_device_unregister(geodewdt_platform_device);
292 platform_driver_unregister(&geodewdt_driver);
293 }
294
295 module_init(geodewdt_init);
296 module_exit(geodewdt_exit);
297
298 MODULE_AUTHOR("Advanced Micro Devices, Inc");
299 MODULE_DESCRIPTION("Geode GX/LX Watchdog Driver");
300 MODULE_LICENSE("GPL");
301 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
302
|
This page was automatically generated by the
LXR engine.
|