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