Version:  2.0.40 2.2.26 2.4.37 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18

Linux/drivers/watchdog/geodewdt.c

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us