drivers/watchdog/mv64x60_wdt.c

   1 /*
   2  * mv64x60_wdt.c - MV64X60 (Marvell Discovery) watchdog userspace interface
   3  *
   4  * Author: James Chapman <jchapman@katalix.com>
   5  *
   6  * Platform-specific setup code should configure the dog to generate
   7  * interrupt or reset as required.  This code only enables/disables
   8  * and services the watchdog.
   9  *
  10  * Derived from mpc8xx_wdt.c, with the following copyright.
  11  *
  12  * 2002 (c) Florian Schirmer <jolt@tuxbox.org> This file is licensed under
  13  * the terms of the GNU General Public License version 2. This program
  14  * is licensed "as is" without any warranty of any kind, whether express
  15  * or implied.
  16  */
  17
  18 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  19
  20 #include <linux/fs.h>
  21 #include <linux/init.h>
  22 #include <linux/kernel.h>
  23 #include <linux/miscdevice.h>
  24 #include <linux/module.h>
  25 #include <linux/watchdog.h>
  26 #include <linux/platform_device.h>
  27 #include <linux/mv643xx.h>
  28 #include <linux/uaccess.h>
  29 #include <linux/io.h>
  30
  31 #define MV64x60_WDT_WDC_OFFSET  0
  32
  33 /*
  34  * The watchdog configuration register contains a pair of 2-bit fields,
  35  *   1.  a reload field, bits 27-26, which triggers a reload of
  36  *       the countdown register, and
  37  *   2.  an enable field, bits 25-24, which toggles between
  38  *       enabling and disabling the watchdog timer.
  39  * Bit 31 is a read-only field which indicates whether the
  40  * watchdog timer is currently enabled.
  41  *
  42  * The low 24 bits contain the timer reload value.
  43  */
  44 #define MV64x60_WDC_ENABLE_SHIFT        24
  45 #define MV64x60_WDC_SERVICE_SHIFT       26
  46 #define MV64x60_WDC_ENABLED_SHIFT       31
  47
  48 #define MV64x60_WDC_ENABLED_TRUE        1
  49 #define MV64x60_WDC_ENABLED_FALSE       0
  50
  51 /* Flags bits */
  52 #define MV64x60_WDOG_FLAG_OPENED        0
  53
  54 static unsigned long wdt_flags;
  55 static int wdt_status;
  56 static void __iomem *mv64x60_wdt_regs;
  57 static int mv64x60_wdt_timeout;
  58 static int mv64x60_wdt_count;
  59 static unsigned int bus_clk;
  60 static char expect_close;
  61 static DEFINE_SPINLOCK(mv64x60_wdt_spinlock);
  62
  63 static bool nowayout = WATCHDOG_NOWAYOUT;
  64 module_param(nowayout, bool, 0);
  65 MODULE_PARM_DESC(nowayout,
  66                 "Watchdog cannot be stopped once started (default="
  67                                 __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
  68
  69 static int mv64x60_wdt_toggle_wdc(int enabled_predicate, int field_shift)
  70 {
  71         u32 data;
  72         u32 enabled;
  73         int ret = 0;
  74
  75         spin_lock(&mv64x60_wdt_spinlock);
  76         data = readl(mv64x60_wdt_regs + MV64x60_WDT_WDC_OFFSET);
  77         enabled = (data >> MV64x60_WDC_ENABLED_SHIFT) & 1;
  78
  79         /* only toggle the requested field if enabled state matches predicate */
  80         if ((enabled ^ enabled_predicate) == 0) {
  81                 /* We write a 1, then a 2 -- to the appropriate field */
  82                 data = (1 << field_shift) | mv64x60_wdt_count;
  83                 writel(data, mv64x60_wdt_regs + MV64x60_WDT_WDC_OFFSET);
  84
  85                 data = (2 << field_shift) | mv64x60_wdt_count;
  86                 writel(data, mv64x60_wdt_regs + MV64x60_WDT_WDC_OFFSET);
  87                 ret = 1;
  88         }
  89         spin_unlock(&mv64x60_wdt_spinlock);
  90
  91         return ret;
  92 }
  93
  94 static void mv64x60_wdt_service(void)
  95 {
  96         mv64x60_wdt_toggle_wdc(MV64x60_WDC_ENABLED_TRUE,
  97                                MV64x60_WDC_SERVICE_SHIFT);
  98 }
  99
 100 static void mv64x60_wdt_handler_enable(void)
 101 {
 102         if (mv64x60_wdt_toggle_wdc(MV64x60_WDC_ENABLED_FALSE,
 103                                    MV64x60_WDC_ENABLE_SHIFT)) {
 104                 mv64x60_wdt_service();
 105                 pr_notice("watchdog activated\n");
 106         }
 107 }
 108
 109 static void mv64x60_wdt_handler_disable(void)
 110 {
 111         if (mv64x60_wdt_toggle_wdc(MV64x60_WDC_ENABLED_TRUE,
 112                                    MV64x60_WDC_ENABLE_SHIFT))
 113                 pr_notice("watchdog deactivated\n");
 114 }
 115
 116 static void mv64x60_wdt_set_timeout(unsigned int timeout)
 117 {
 118         /* maximum bus cycle count is 0xFFFFFFFF */
 119         if (timeout > 0xFFFFFFFF / bus_clk)
 120                 timeout = 0xFFFFFFFF / bus_clk;
 121
 122         mv64x60_wdt_count = timeout * bus_clk >> 8;
 123         mv64x60_wdt_timeout = timeout;
 124 }
 125
 126 static int mv64x60_wdt_open(struct inode *inode, struct file *file)
 127 {
 128         if (test_and_set_bit(MV64x60_WDOG_FLAG_OPENED, &wdt_flags))
 129                 return -EBUSY;
 130
 131         if (nowayout)
 132                 __module_get(THIS_MODULE);
 133
 134         mv64x60_wdt_handler_enable();
 135
 136         return nonseekable_open(inode, file);
 137 }
 138
 139 static int mv64x60_wdt_release(struct inode *inode, struct file *file)
 140 {
 141         if (expect_close == 42)
 142                 mv64x60_wdt_handler_disable();
 143         else {
 144                 pr_crit("unexpected close, not stopping timer!\n");
 145                 mv64x60_wdt_service();
 146         }
 147         expect_close = 0;
 148
 149         clear_bit(MV64x60_WDOG_FLAG_OPENED, &wdt_flags);
 150
 151         return 0;
 152 }
 153
 154 static ssize_t mv64x60_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_close = 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_close = 42;
 169                         }
 170                 }
 171                 mv64x60_wdt_service();
 172         }
 173
 174         return len;
 175 }
 176
 177 static long mv64x60_wdt_ioctl(struct file *file,
 178                                         unsigned int cmd, unsigned long arg)
 179 {
 180         int timeout;
 181         int options;
 182         void __user *argp = (void __user *)arg;
 183         static const struct watchdog_info info = {
 184                 .options =      WDIOF_SETTIMEOUT        |
 185                                 WDIOF_MAGICCLOSE        |
 186                                 WDIOF_KEEPALIVEPING,
 187                 .firmware_version = 0,
 188                 .identity = "MV64x60 watchdog",
 189         };
 190
 191         switch (cmd) {
 192         case WDIOC_GETSUPPORT:
 193                 if (copy_to_user(argp, &info, sizeof(info)))
 194                         return -EFAULT;
 195                 break;
 196
 197         case WDIOC_GETSTATUS:
 198         case WDIOC_GETBOOTSTATUS:
 199                 if (put_user(wdt_status, (int __user *)argp))
 200                         return -EFAULT;
 201                 wdt_status &= ~WDIOF_KEEPALIVEPING;
 202                 break;
 203
 204         case WDIOC_GETTEMP:
 205                 return -EOPNOTSUPP;
 206
 207         case WDIOC_SETOPTIONS:
 208                 if (get_user(options, (int __user *)argp))
 209                         return -EFAULT;
 210
 211                 if (options & WDIOS_DISABLECARD)
 212                         mv64x60_wdt_handler_disable();
 213
 214                 if (options & WDIOS_ENABLECARD)
 215                         mv64x60_wdt_handler_enable();
 216                 break;
 217
 218         case WDIOC_KEEPALIVE:
 219                 mv64x60_wdt_service();
 220                 wdt_status |= WDIOF_KEEPALIVEPING;
 221                 break;
 222
 223         case WDIOC_SETTIMEOUT:
 224                 if (get_user(timeout, (int __user *)argp))
 225                         return -EFAULT;
 226                 mv64x60_wdt_set_timeout(timeout);
 227                 /* Fall through */
 228
 229         case WDIOC_GETTIMEOUT:
 230                 if (put_user(mv64x60_wdt_timeout, (int __user *)argp))
 231                         return -EFAULT;
 232                 break;
 233
 234         default:
 235                 return -ENOTTY;
 236         }
 237
 238         return 0;
 239 }
 240
 241 static const struct file_operations mv64x60_wdt_fops = {
 242         .owner = THIS_MODULE,
 243         .llseek = no_llseek,
 244         .write = mv64x60_wdt_write,
 245         .unlocked_ioctl = mv64x60_wdt_ioctl,
 246         .open = mv64x60_wdt_open,
 247         .release = mv64x60_wdt_release,
 248 };
 249
 250 static struct miscdevice mv64x60_wdt_miscdev = {
 251         .minor = WATCHDOG_MINOR,
 252         .name = "watchdog",
 253         .fops = &mv64x60_wdt_fops,
 254 };
 255
 256 static int __devinit mv64x60_wdt_probe(struct platform_device *dev)
 257 {
 258         struct mv64x60_wdt_pdata *pdata = dev->dev.platform_data;
 259         struct resource *r;
 260         int timeout = 10;
 261
 262         bus_clk = 133;                  /* in MHz */
 263         if (pdata) {
 264                 timeout = pdata->timeout;
 265                 bus_clk = pdata->bus_clk;
 266         }
 267
 268         /* Since bus_clk is truncated MHz, actual frequency could be
 269          * up to 1MHz higher.  Round up, since it's better to time out
 270          * too late than too soon.
 271          */
 272         bus_clk++;
 273         bus_clk *= 1000000;             /* convert to Hz */
 274
 275         r = platform_get_resource(dev, IORESOURCE_MEM, 0);
 276         if (!r)
 277                 return -ENODEV;
 278
 279         mv64x60_wdt_regs = ioremap(r->start, resource_size(r));
 280         if (mv64x60_wdt_regs == NULL)
 281                 return -ENOMEM;
 282
 283         mv64x60_wdt_set_timeout(timeout);
 284
 285         mv64x60_wdt_handler_disable();  /* in case timer was already running */
 286
 287         return misc_register(&mv64x60_wdt_miscdev);
 288 }
 289
 290 static int __devexit mv64x60_wdt_remove(struct platform_device *dev)
 291 {
 292         misc_deregister(&mv64x60_wdt_miscdev);
 293
 294         mv64x60_wdt_handler_disable();
 295
 296         iounmap(mv64x60_wdt_regs);
 297
 298         return 0;
 299 }
 300
 301 static struct platform_driver mv64x60_wdt_driver = {
 302         .probe = mv64x60_wdt_probe,
 303         .remove = __devexit_p(mv64x60_wdt_remove),
 304         .driver = {
 305                 .owner = THIS_MODULE,
 306                 .name = MV64x60_WDT_NAME,
 307         },
 308 };
 309
 310 static int __init mv64x60_wdt_init(void)
 311 {
 312         pr_info("MV64x60 watchdog driver\n");
 313
 314         return platform_driver_register(&mv64x60_wdt_driver);
 315 }
 316
 317 static void __exit mv64x60_wdt_exit(void)
 318 {
 319         platform_driver_unregister(&mv64x60_wdt_driver);
 320 }
 321
 322 module_init(mv64x60_wdt_init);
 323 module_exit(mv64x60_wdt_exit);
 324
 325 MODULE_AUTHOR("James Chapman <jchapman@katalix.com>");
 326 MODULE_DESCRIPTION("MV64x60 watchdog driver");
 327 MODULE_LICENSE("GPL");
 328 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
 329 MODULE_ALIAS("platform:" MV64x60_WDT_NAME);