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