drivers/watchdog/bcm47xx_wdt.c

   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         switch (bcm47xx_bus_type) {
  58 #ifdef CONFIG_BCM47XX_SSB
  59         case BCM47XX_BUS_TYPE_SSB:
  60                 ssb_watchdog_timer_set(&bcm47xx_bus.ssb, 0xfffffff);
  61                 break;
  62 #endif
  63         }
  64 }
  65
  66 static inline int bcm47xx_wdt_hw_stop(void)
  67 {
  68         switch (bcm47xx_bus_type) {
  69 #ifdef CONFIG_BCM47XX_SSB
  70         case BCM47XX_BUS_TYPE_SSB:
  71                 return ssb_watchdog_timer_set(&bcm47xx_bus.ssb, 0);
  72 #endif
  73         }
  74         return -EINVAL;
  75 }
  76
  77 static void bcm47xx_timer_tick(unsigned long unused)
  78 {
  79         if (!atomic_dec_and_test(&ticks)) {
  80                 bcm47xx_wdt_hw_start();
  81                 mod_timer(&wdt_timer, jiffies + HZ);
  82         } else {
  83                 printk(KERN_CRIT DRV_NAME "Watchdog will fire soon!!!\n");
  84         }
  85 }
  86
  87 static inline void bcm47xx_wdt_pet(void)
  88 {
  89         atomic_set(&ticks, wdt_time);
  90 }
  91
  92 static void bcm47xx_wdt_start(void)
  93 {
  94         bcm47xx_wdt_pet();
  95         bcm47xx_timer_tick(0);
  96 }
  97
  98 static void bcm47xx_wdt_pause(void)
  99 {
 100         del_timer_sync(&wdt_timer);
 101         bcm47xx_wdt_hw_stop();
 102 }
 103
 104 static void bcm47xx_wdt_stop(void)
 105 {
 106         bcm47xx_wdt_pause();
 107 }
 108
 109 static int bcm47xx_wdt_settimeout(int new_time)
 110 {
 111         if ((new_time <= 0) || (new_time > WDT_MAX_TIME))
 112                 return -EINVAL;
 113
 114         wdt_time = new_time;
 115         return 0;
 116 }
 117
 118 static int bcm47xx_wdt_open(struct inode *inode, struct file *file)
 119 {
 120         if (test_and_set_bit(0, &bcm47xx_wdt_busy))
 121                 return -EBUSY;
 122
 123         bcm47xx_wdt_start();
 124         return nonseekable_open(inode, file);
 125 }
 126
 127 static int bcm47xx_wdt_release(struct inode *inode, struct file *file)
 128 {
 129         if (expect_release == 42) {
 130                 bcm47xx_wdt_stop();
 131         } else {
 132                 printk(KERN_CRIT DRV_NAME
 133                         ": Unexpected close, not stopping watchdog!\n");
 134                 bcm47xx_wdt_start();
 135         }
 136
 137         clear_bit(0, &bcm47xx_wdt_busy);
 138         expect_release = 0;
 139         return 0;
 140 }
 141
 142 static ssize_t bcm47xx_wdt_write(struct file *file, const char __user *data,
 143                                 size_t len, loff_t *ppos)
 144 {
 145         if (len) {
 146                 if (!nowayout) {
 147                         size_t i;
 148
 149                         expect_release = 0;
 150
 151                         for (i = 0; i != len; i++) {
 152                                 char c;
 153                                 if (get_user(c, data + i))
 154                                         return -EFAULT;
 155                                 if (c == 'V')
 156                                         expect_release = 42;
 157                         }
 158                 }
 159                 bcm47xx_wdt_pet();
 160         }
 161         return len;
 162 }
 163
 164 static const struct watchdog_info bcm47xx_wdt_info = {
 165         .identity       = DRV_NAME,
 166         .options        = WDIOF_SETTIMEOUT |
 167                                 WDIOF_KEEPALIVEPING |
 168                                 WDIOF_MAGICCLOSE,
 169 };
 170
 171 static long bcm47xx_wdt_ioctl(struct file *file,
 172                                         unsigned int cmd, unsigned long arg)
 173 {
 174         void __user *argp = (void __user *)arg;
 175         int __user *p = argp;
 176         int new_value, retval = -EINVAL;
 177
 178         switch (cmd) {
 179         case WDIOC_GETSUPPORT:
 180                 return copy_to_user(argp, &bcm47xx_wdt_info,
 181                                 sizeof(bcm47xx_wdt_info)) ? -EFAULT : 0;
 182
 183         case WDIOC_GETSTATUS:
 184         case WDIOC_GETBOOTSTATUS:
 185                 return put_user(0, p);
 186
 187         case WDIOC_SETOPTIONS:
 188                 if (get_user(new_value, p))
 189                         return -EFAULT;
 190
 191                 if (new_value & WDIOS_DISABLECARD) {
 192                         bcm47xx_wdt_stop();
 193                         retval = 0;
 194                 }
 195
 196                 if (new_value & WDIOS_ENABLECARD) {
 197                         bcm47xx_wdt_start();
 198                         retval = 0;
 199                 }
 200
 201                 return retval;
 202
 203         case WDIOC_KEEPALIVE:
 204                 bcm47xx_wdt_pet();
 205                 return 0;
 206
 207         case WDIOC_SETTIMEOUT:
 208                 if (get_user(new_value, p))
 209                         return -EFAULT;
 210
 211                 if (bcm47xx_wdt_settimeout(new_value))
 212                         return -EINVAL;
 213
 214                 bcm47xx_wdt_pet();
 215
 216         case WDIOC_GETTIMEOUT:
 217                 return put_user(wdt_time, p);
 218
 219         default:
 220                 return -ENOTTY;
 221         }
 222 }
 223
 224 static int bcm47xx_wdt_notify_sys(struct notifier_block *this,
 225         unsigned long code, void *unused)
 226 {
 227         if (code == SYS_DOWN || code == SYS_HALT)
 228                 bcm47xx_wdt_stop();
 229         return NOTIFY_DONE;
 230 }
 231
 232 static const struct file_operations bcm47xx_wdt_fops = {
 233         .owner          = THIS_MODULE,
 234         .llseek         = no_llseek,
 235         .unlocked_ioctl = bcm47xx_wdt_ioctl,
 236         .open           = bcm47xx_wdt_open,
 237         .release        = bcm47xx_wdt_release,
 238         .write          = bcm47xx_wdt_write,
 239 };
 240
 241 static struct miscdevice bcm47xx_wdt_miscdev = {
 242         .minor          = WATCHDOG_MINOR,
 243         .name           = "watchdog",
 244         .fops           = &bcm47xx_wdt_fops,
 245 };
 246
 247 static struct notifier_block bcm47xx_wdt_notifier = {
 248         .notifier_call = bcm47xx_wdt_notify_sys,
 249 };
 250
 251 static int __init bcm47xx_wdt_init(void)
 252 {
 253         int ret;
 254
 255         if (bcm47xx_wdt_hw_stop() < 0)
 256                 return -ENODEV;
 257
 258         setup_timer(&wdt_timer, bcm47xx_timer_tick, 0L);
 259
 260         if (bcm47xx_wdt_settimeout(wdt_time)) {
 261                 bcm47xx_wdt_settimeout(WDT_DEFAULT_TIME);
 262                 printk(KERN_INFO DRV_NAME ": "
 263                         "wdt_time value must be 0 < wdt_time < %d, using %d\n",
 264                         (WDT_MAX_TIME + 1), wdt_time);
 265         }
 266
 267         ret = register_reboot_notifier(&bcm47xx_wdt_notifier);
 268         if (ret)
 269                 return ret;
 270
 271         ret = misc_register(&bcm47xx_wdt_miscdev);
 272         if (ret) {
 273                 unregister_reboot_notifier(&bcm47xx_wdt_notifier);
 274                 return ret;
 275         }
 276
 277         printk(KERN_INFO "BCM47xx Watchdog Timer enabled (%d seconds%s)\n",
 278                                 wdt_time, nowayout ? ", nowayout" : "");
 279         return 0;
 280 }
 281
 282 static void __exit bcm47xx_wdt_exit(void)
 283 {
 284         if (!nowayout)
 285                 bcm47xx_wdt_stop();
 286
 287         misc_deregister(&bcm47xx_wdt_miscdev);
 288
 289         unregister_reboot_notifier(&bcm47xx_wdt_notifier);
 290 }
 291
 292 module_init(bcm47xx_wdt_init);
 293 module_exit(bcm47xx_wdt_exit);
 294
 295 MODULE_AUTHOR("Aleksandar Radovanovic");
 296 MODULE_DESCRIPTION("Watchdog driver for Broadcom BCM47xx");
 297 MODULE_LICENSE("GPL");
 298 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);