1
2
3
4
5
6
7
8
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
35static int timeout = WATCHDOG_TIMEOUT;
36module_param(timeout, int, 0);
37MODULE_PARM_DESC(timeout,
38 "Watchdog timeout in seconds. 1<= timeout <=131, default="
39 __MODULE_STRING(WATCHDOG_TIMEOUT) ".");
40
41static int nowayout = WATCHDOG_NOWAYOUT;
42module_param(nowayout, int, 0);
43MODULE_PARM_DESC(nowayout,
44 "Watchdog cannot be stopped once started (default="
45 __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
46
47static struct platform_device *geodewdt_platform_device;
48static unsigned long wdt_flags;
49static int wdt_timer;
50static int safe_close;
51
52static void geodewdt_ping(void)
53{
54
55 geode_mfgpt_write(wdt_timer, MFGPT_REG_SETUP, 0);
56
57
58 geode_mfgpt_write(wdt_timer, MFGPT_REG_COUNTER, 0);
59
60
61 geode_mfgpt_write(wdt_timer, MFGPT_REG_SETUP, MFGPT_SETUP_CNTEN);
62}
63
64static 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
70static 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
84static 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
96static 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
113static 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
137static 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
191 case WDIOC_GETTIMEOUT:
192 return put_user(timeout, p);
193
194 default:
195 return -ENOTTY;
196 }
197
198 return 0;
199}
200
201static 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
210static struct miscdevice geodewdt_miscdev = {
211 .minor = WATCHDOG_MINOR,
212 .name = "watchdog",
213 .fops = &geodewdt_fops,
214};
215
216static 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
230
231 geode_mfgpt_write(wdt_timer, MFGPT_REG_SETUP,
232 GEODEWDT_SCALE | (3 << 8));
233
234
235 geode_mfgpt_toggle_event(wdt_timer, MFGPT_CMP2, MFGPT_EVENT_RESET, 1);
236
237
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
247static int __devexit geodewdt_remove(struct platform_device *dev)
248{
249 misc_deregister(&geodewdt_miscdev);
250 return 0;
251}
252
253static void geodewdt_shutdown(struct platform_device *dev)
254{
255 geodewdt_disable();
256}
257
258static 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
268static 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;
284err:
285 platform_driver_unregister(&geodewdt_driver);
286 return ret;
287}
288
289static void __exit geodewdt_exit(void)
290{
291 platform_device_unregister(geodewdt_platform_device);
292 platform_driver_unregister(&geodewdt_driver);
293}
294
295module_init(geodewdt_init);
296module_exit(geodewdt_exit);
297
298MODULE_AUTHOR("Advanced Micro Devices, Inc");
299MODULE_DESCRIPTION("Geode GX/LX Watchdog Driver");
300MODULE_LICENSE("GPL");
301MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
302
