1/* 2 * GE watchdog userspace interface 3 * 4 * Author: Martyn Welch <martyn.welch@ge.com> 5 * 6 * Copyright 2008 GE Intelligent Platforms Embedded Systems, Inc. 7 * 8 * This program is free software; you can redistribute it and/or modify it 9 * under the terms of the GNU General Public License as published by the 10 * Free Software Foundation; either version 2 of the License, or (at your 11 * option) any later version. 12 * 13 * Based on: mv64x60_wdt.c (MV64X60 watchdog userspace interface) 14 * Author: James Chapman <jchapman@katalix.com> 15 */ 16 17/* TODO: 18 * This driver does not provide support for the hardwares capability of sending 19 * an interrupt at a programmable threshold. 20 * 21 * This driver currently can only support 1 watchdog - there are 2 in the 22 * hardware that this driver supports. Thus one could be configured as a 23 * process-based watchdog (via /dev/watchdog), the second (using the interrupt 24 * capabilities) a kernel-based watchdog. 25 */ 26 27#include <linux/kernel.h> 28#include <linux/compiler.h> 29#include <linux/init.h> 30#include <linux/module.h> 31#include <linux/miscdevice.h> 32#include <linux/watchdog.h> 33#include <linux/of.h> 34#include <linux/of_platform.h> 35#include <linux/io.h> 36#include <linux/uaccess.h> 37 38#include <sysdev/fsl_soc.h> 39 40/* 41 * The watchdog configuration register contains a pair of 2-bit fields, 42 * 1. a reload field, bits 27-26, which triggers a reload of 43 * the countdown register, and 44 * 2. an enable field, bits 25-24, which toggles between 45 * enabling and disabling the watchdog timer. 46 * Bit 31 is a read-only field which indicates whether the 47 * watchdog timer is currently enabled. 48 * 49 * The low 24 bits contain the timer reload value. 50 */ 51#define GEF_WDC_ENABLE_SHIFT 24 52#define GEF_WDC_SERVICE_SHIFT 26 53#define GEF_WDC_ENABLED_SHIFT 31 54 55#define GEF_WDC_ENABLED_TRUE 1 56#define GEF_WDC_ENABLED_FALSE 0 57 58/* Flags bits */ 59#define GEF_WDOG_FLAG_OPENED 0 60 61static unsigned long wdt_flags; 62static int wdt_status; 63static void __iomem *gef_wdt_regs; 64static int gef_wdt_timeout; 65static int gef_wdt_count; 66static unsigned int bus_clk; 67static char expect_close; 68static DEFINE_SPINLOCK(gef_wdt_spinlock); 69 70static int nowayout = WATCHDOG_NOWAYOUT; 71module_param(nowayout, int, 0); 72MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=" 73 __MODULE_STRING(WATCHDOG_NOWAYOUT) ")"); 74 75 76static int gef_wdt_toggle_wdc(int enabled_predicate, int field_shift) 77{ 78 u32 data; 79 u32 enabled; 80 int ret = 0; 81 82 spin_lock(&gef_wdt_spinlock); 83 data = ioread32be(gef_wdt_regs); 84 enabled = (data >> GEF_WDC_ENABLED_SHIFT) & 1; 85 86 /* only toggle the requested field if enabled state matches predicate */ 87 if ((enabled ^ enabled_predicate) == 0) { 88 /* We write a 1, then a 2 -- to the appropriate field */ 89 data = (1 << field_shift) | gef_wdt_count; 90 iowrite32be(data, gef_wdt_regs); 91 92 data = (2 << field_shift) | gef_wdt_count; 93 iowrite32be(data, gef_wdt_regs); 94 ret = 1; 95 } 96 spin_unlock(&gef_wdt_spinlock); 97 98 return ret; 99} 100 101static void gef_wdt_service(void) 102{ 103 gef_wdt_toggle_wdc(GEF_WDC_ENABLED_TRUE, 104 GEF_WDC_SERVICE_SHIFT); 105} 106 107static void gef_wdt_handler_enable(void) 108{ 109 if (gef_wdt_toggle_wdc(GEF_WDC_ENABLED_FALSE, 110 GEF_WDC_ENABLE_SHIFT)) { 111 gef_wdt_service(); 112 printk(KERN_NOTICE "gef_wdt: watchdog activated\n"); 113 } 114} 115 116static void gef_wdt_handler_disable(void) 117{ 118 if (gef_wdt_toggle_wdc(GEF_WDC_ENABLED_TRUE, 119 GEF_WDC_ENABLE_SHIFT)) 120 printk(KERN_NOTICE "gef_wdt: watchdog deactivated\n"); 121} 122 123static void gef_wdt_set_timeout(unsigned int timeout) 124{ 125 /* maximum bus cycle count is 0xFFFFFFFF */ 126 if (timeout > 0xFFFFFFFF / bus_clk) 127 timeout = 0xFFFFFFFF / bus_clk; 128 129 /* Register only holds upper 24 bits, bit shifted into lower 24 */ 130 gef_wdt_count = (timeout * bus_clk) >> 8; 131 gef_wdt_timeout = timeout; 132} 133 134 135static ssize_t gef_wdt_write(struct file *file, const char __user *data, 136 size_t len, loff_t *ppos) 137{ 138 if (len) { 139 if (!nowayout) { 140 size_t i; 141 142 expect_close = 0; 143 144 for (i = 0; i != len; i++) { 145 char c; 146 if (get_user(c, data + i)) 147 return -EFAULT; 148 if (c == 'V') 149 expect_close = 42; 150 } 151 } 152 gef_wdt_service(); 153 } 154 155 return len; 156} 157 158static long gef_wdt_ioctl(struct file *file, unsigned int cmd, 159 unsigned long arg) 160{ 161 int timeout; 162 int options; 163 void __user *argp = (void __user *)arg; 164 static const struct watchdog_info info = { 165 .options = WDIOF_SETTIMEOUT | WDIOF_MAGICCLOSE | 166 WDIOF_KEEPALIVEPING, 167 .firmware_version = 0, 168 .identity = "GE watchdog", 169 }; 170 171 switch (cmd) { 172 case WDIOC_GETSUPPORT: 173 if (copy_to_user(argp, &info, sizeof(info))) 174 return -EFAULT; 175 break; 176 177 case WDIOC_GETSTATUS: 178 case WDIOC_GETBOOTSTATUS: 179 if (put_user(wdt_status, (int __user *)argp)) 180 return -EFAULT; 181 wdt_status &= ~WDIOF_KEEPALIVEPING; 182 break; 183 184 case WDIOC_SETOPTIONS: 185 if (get_user(options, (int __user *)argp)) 186 return -EFAULT; 187 188 if (options & WDIOS_DISABLECARD) 189 gef_wdt_handler_disable(); 190 191 if (options & WDIOS_ENABLECARD) 192 gef_wdt_handler_enable(); 193 break; 194 195 case WDIOC_KEEPALIVE: 196 gef_wdt_service(); 197 wdt_status |= WDIOF_KEEPALIVEPING; 198 break; 199 200 case WDIOC_SETTIMEOUT: 201 if (get_user(timeout, (int __user *)argp)) 202 return -EFAULT; 203 gef_wdt_set_timeout(timeout); 204 /* Fall through */ 205 206 case WDIOC_GETTIMEOUT: 207 if (put_user(gef_wdt_timeout, (int __user *)argp)) 208 return -EFAULT; 209 break; 210 211 default: 212 return -ENOTTY; 213 } 214 215 return 0; 216} 217 218static int gef_wdt_open(struct inode *inode, struct file *file) 219{ 220 if (test_and_set_bit(GEF_WDOG_FLAG_OPENED, &wdt_flags)) 221 return -EBUSY; 222 223 if (nowayout) 224 __module_get(THIS_MODULE); 225 226 gef_wdt_handler_enable(); 227 228 return nonseekable_open(inode, file); 229} 230 231static int gef_wdt_release(struct inode *inode, struct file *file) 232{ 233 if (expect_close == 42) 234 gef_wdt_handler_disable(); 235 else { 236 printk(KERN_CRIT 237 "gef_wdt: unexpected close, not stopping timer!\n"); 238 gef_wdt_service(); 239 } 240 expect_close = 0; 241 242 clear_bit(GEF_WDOG_FLAG_OPENED, &wdt_flags); 243 244 return 0; 245} 246 247static const struct file_operations gef_wdt_fops = { 248 .owner = THIS_MODULE, 249 .llseek = no_llseek, 250 .write = gef_wdt_write, 251 .unlocked_ioctl = gef_wdt_ioctl, 252 .open = gef_wdt_open, 253 .release = gef_wdt_release, 254}; 255 256static struct miscdevice gef_wdt_miscdev = { 257 .minor = WATCHDOG_MINOR, 258 .name = "watchdog", 259 .fops = &gef_wdt_fops, 260}; 261 262 263static int __devinit gef_wdt_probe(struct platform_device *dev, 264 const struct of_device_id *match) 265{ 266 int timeout = 10; 267 u32 freq; 268 269 bus_clk = 133; /* in MHz */ 270 271 freq = fsl_get_sys_freq(); 272 if (freq != -1) 273 bus_clk = freq; 274 275 /* Map devices registers into memory */ 276 gef_wdt_regs = of_iomap(dev->dev.of_node, 0); 277 if (gef_wdt_regs == NULL) 278 return -ENOMEM; 279 280 gef_wdt_set_timeout(timeout); 281 282 gef_wdt_handler_disable(); /* in case timer was already running */ 283 284 return misc_register(&gef_wdt_miscdev); 285} 286 287static int __devexit gef_wdt_remove(struct platform_device *dev) 288{ 289 misc_deregister(&gef_wdt_miscdev); 290 291 gef_wdt_handler_disable(); 292 293 iounmap(gef_wdt_regs); 294 295 return 0; 296} 297 298static const struct of_device_id gef_wdt_ids[] = { 299 { 300 .compatible = "gef,fpga-wdt", 301 }, 302 {}, 303}; 304 305static struct of_platform_driver gef_wdt_driver = { 306 .driver = { 307 .name = "gef_wdt", 308 .owner = THIS_MODULE, 309 .of_match_table = gef_wdt_ids, 310 }, 311 .probe = gef_wdt_probe, 312}; 313 314static int __init gef_wdt_init(void) 315{ 316 printk(KERN_INFO "GE watchdog driver\n"); 317 return of_register_platform_driver(&gef_wdt_driver); 318} 319 320static void __exit gef_wdt_exit(void) 321{ 322 of_unregister_platform_driver(&gef_wdt_driver); 323} 324 325module_init(gef_wdt_init); 326module_exit(gef_wdt_exit); 327 328MODULE_AUTHOR("Martyn Welch <martyn.welch@ge.com>"); 329MODULE_DESCRIPTION("GE watchdog driver"); 330MODULE_LICENSE("GPL"); 331MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); 332MODULE_ALIAS("platform: gef_wdt"); 333