1 /* 2 * Watchdog driver for Broadcom BCM47XX 3 * 4 * Copyright (C) 2008 Aleksandar Radovanovic <biblbroks@sezampro.rs> 5 * Copyright (C) 2009 Matthieu CASTET <castet.matthieu@free.fr> 6 * 7 * This program is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU General Public License 9 * as published by the Free Software Foundation; either version 10 * 2 of the License, or (at your option) any later version. 11 */ 12 13 #include <linux/bitops.h> 14 #include <linux/errno.h> 15 #include <linux/fs.h> 16 #include <linux/init.h> 17 #include <linux/kernel.h> 18 #include <linux/miscdevice.h> 19 #include <linux/module.h> 20 #include <linux/moduleparam.h> 21 #include <linux/reboot.h> 22 #include <linux/types.h> 23 #include <linux/uaccess.h> 24 #include <linux/watchdog.h> 25 #include <linux/timer.h> 26 #include <linux/jiffies.h> 27 #include <linux/ssb/ssb_embedded.h> 28 #include <asm/mach-bcm47xx/bcm47xx.h> 29 30 #define DRV_NAME "bcm47xx_wdt" 31 32 #define WDT_DEFAULT_TIME 30 /* seconds */ 33 #define WDT_MAX_TIME 255 /* seconds */ 34 35 static int wdt_time = WDT_DEFAULT_TIME; 36 static int nowayout = WATCHDOG_NOWAYOUT; 37 38 module_param(wdt_time, int, 0); 39 MODULE_PARM_DESC(wdt_time, "Watchdog time in seconds. (default=" 40 __MODULE_STRING(WDT_DEFAULT_TIME) ")"); 41 42 #ifdef CONFIG_WATCHDOG_NOWAYOUT 43 module_param(nowayout, int, 0); 44 MODULE_PARM_DESC(nowayout, 45 "Watchdog cannot be stopped once started (default=" 46 __MODULE_STRING(WATCHDOG_NOWAYOUT) ")"); 47 #endif 48 49 static unsigned long bcm47xx_wdt_busy; 50 static char expect_release; 51 static struct timer_list wdt_timer; 52 static atomic_t ticks; 53 54 static inline void bcm47xx_wdt_hw_start(void) 55 { 56 /* this is 2,5s on 100Mhz clock and 2s on 133 Mhz */ 57 ssb_watchdog_timer_set(&ssb_bcm47xx, 0xfffffff); 58 } 59 60 static inline int bcm47xx_wdt_hw_stop(void) 61 { 62 return ssb_watchdog_timer_set(&ssb_bcm47xx, 0); 63 } 64 65 static void bcm47xx_timer_tick(unsigned long unused) 66 { 67 if (!atomic_dec_and_test(&ticks)) { 68 bcm47xx_wdt_hw_start(); 69 mod_timer(&wdt_timer, jiffies + HZ); 70 } else { 71 printk(KERN_CRIT DRV_NAME "Watchdog will fire soon!!!\n"); 72 } 73 } 74 75 static inline void bcm47xx_wdt_pet(void) 76 { 77 atomic_set(&ticks, wdt_time); 78 } 79 80 static void bcm47xx_wdt_start(void) 81 { 82 bcm47xx_wdt_pet(); 83 bcm47xx_timer_tick(0); 84 } 85 86 static void bcm47xx_wdt_pause(void) 87 { 88 del_timer_sync(&wdt_timer); 89 bcm47xx_wdt_hw_stop(); 90 } 91 92 static void bcm47xx_wdt_stop(void) 93 { 94 bcm47xx_wdt_pause(); 95 } 96 97 static int bcm47xx_wdt_settimeout(int new_time) 98 { 99 if ((new_time <= 0) || (new_time > WDT_MAX_TIME)) 100 return -EINVAL; 101 102 wdt_time = new_time; 103 return 0; 104 } 105 106 static int bcm47xx_wdt_open(struct inode *inode, struct file *file) 107 { 108 if (test_and_set_bit(0, &bcm47xx_wdt_busy)) 109 return -EBUSY; 110 111 bcm47xx_wdt_start(); 112 return nonseekable_open(inode, file); 113 } 114 115 static int bcm47xx_wdt_release(struct inode *inode, struct file *file) 116 { 117 if (expect_release == 42) { 118 bcm47xx_wdt_stop(); 119 } else { 120 printk(KERN_CRIT DRV_NAME 121 ": Unexpected close, not stopping watchdog!\n"); 122 bcm47xx_wdt_start(); 123 } 124 125 clear_bit(0, &bcm47xx_wdt_busy); 126 expect_release = 0; 127 return 0; 128 } 129 130 static ssize_t bcm47xx_wdt_write(struct file *file, const char __user *data, 131 size_t len, loff_t *ppos) 132 { 133 if (len) { 134 if (!nowayout) { 135 size_t i; 136 137 expect_release = 0; 138 139 for (i = 0; i != len; i++) { 140 char c; 141 if (get_user(c, data + i)) 142 return -EFAULT; 143 if (c == 'V') 144 expect_release = 42; 145 } 146 } 147 bcm47xx_wdt_pet(); 148 } 149 return len; 150 } 151 152 static const struct watchdog_info bcm47xx_wdt_info = { 153 .identity = DRV_NAME, 154 .options = WDIOF_SETTIMEOUT | 155 WDIOF_KEEPALIVEPING | 156 WDIOF_MAGICCLOSE, 157 }; 158 159 static long bcm47xx_wdt_ioctl(struct file *file, 160 unsigned int cmd, unsigned long arg) 161 { 162 void __user *argp = (void __user *)arg; 163 int __user *p = argp; 164 int new_value, retval = -EINVAL; 165 166 switch (cmd) { 167 case WDIOC_GETSUPPORT: 168 return copy_to_user(argp, &bcm47xx_wdt_info, 169 sizeof(bcm47xx_wdt_info)) ? -EFAULT : 0; 170 171 case WDIOC_GETSTATUS: 172 case WDIOC_GETBOOTSTATUS: 173 return put_user(0, p); 174 175 case WDIOC_SETOPTIONS: 176 if (get_user(new_value, p)) 177 return -EFAULT; 178 179 if (new_value & WDIOS_DISABLECARD) { 180 bcm47xx_wdt_stop(); 181 retval = 0; 182 } 183 184 if (new_value & WDIOS_ENABLECARD) { 185 bcm47xx_wdt_start(); 186 retval = 0; 187 } 188 189 return retval; 190 191 case WDIOC_KEEPALIVE: 192 bcm47xx_wdt_pet(); 193 return 0; 194 195 case WDIOC_SETTIMEOUT: 196 if (get_user(new_value, p)) 197 return -EFAULT; 198 199 if (bcm47xx_wdt_settimeout(new_value)) 200 return -EINVAL; 201 202 bcm47xx_wdt_pet(); 203 204 case WDIOC_GETTIMEOUT: 205 return put_user(wdt_time, p); 206 207 default: 208 return -ENOTTY; 209 } 210 } 211 212 static int bcm47xx_wdt_notify_sys(struct notifier_block *this, 213 unsigned long code, void *unused) 214 { 215 if (code == SYS_DOWN || code == SYS_HALT) 216 bcm47xx_wdt_stop(); 217 return NOTIFY_DONE; 218 } 219 220 static const struct file_operations bcm47xx_wdt_fops = { 221 .owner = THIS_MODULE, 222 .llseek = no_llseek, 223 .unlocked_ioctl = bcm47xx_wdt_ioctl, 224 .open = bcm47xx_wdt_open, 225 .release = bcm47xx_wdt_release, 226 .write = bcm47xx_wdt_write, 227 }; 228 229 static struct miscdevice bcm47xx_wdt_miscdev = { 230 .minor = WATCHDOG_MINOR, 231 .name = "watchdog", 232 .fops = &bcm47xx_wdt_fops, 233 }; 234 235 static struct notifier_block bcm47xx_wdt_notifier = { 236 .notifier_call = bcm47xx_wdt_notify_sys, 237 }; 238 239 static int __init bcm47xx_wdt_init(void) 240 { 241 int ret; 242 243 if (bcm47xx_wdt_hw_stop() < 0) 244 return -ENODEV; 245 246 setup_timer(&wdt_timer, bcm47xx_timer_tick, 0L); 247 248 if (bcm47xx_wdt_settimeout(wdt_time)) { 249 bcm47xx_wdt_settimeout(WDT_DEFAULT_TIME); 250 printk(KERN_INFO DRV_NAME ": " 251 "wdt_time value must be 0 < wdt_time < %d, using %d\n", 252 (WDT_MAX_TIME + 1), wdt_time); 253 } 254 255 ret = register_reboot_notifier(&bcm47xx_wdt_notifier); 256 if (ret) 257 return ret; 258 259 ret = misc_register(&bcm47xx_wdt_miscdev); 260 if (ret) { 261 unregister_reboot_notifier(&bcm47xx_wdt_notifier); 262 return ret; 263 } 264 265 printk(KERN_INFO "BCM47xx Watchdog Timer enabled (%d seconds%s)\n", 266 wdt_time, nowayout ? ", nowayout" : ""); 267 return 0; 268 } 269 270 static void __exit bcm47xx_wdt_exit(void) 271 { 272 if (!nowayout) 273 bcm47xx_wdt_stop(); 274 275 misc_deregister(&bcm47xx_wdt_miscdev); 276 277 unregister_reboot_notifier(&bcm47xx_wdt_notifier); 278 } 279 280 module_init(bcm47xx_wdt_init); 281 module_exit(bcm47xx_wdt_exit); 282 283 MODULE_AUTHOR("Aleksandar Radovanovic"); 284 MODULE_DESCRIPTION("Watchdog driver for Broadcom BCM47xx"); 285 MODULE_LICENSE("GPL"); 286 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); 287