drivers/watchdog/imx2_wdt.c

   1 /*
   2  * Watchdog driver for IMX2 and later processors
   3  *
   4  *  Copyright (C) 2010 Wolfram Sang, Pengutronix e.K. <w.sang@pengutronix.de>
   5  *
   6  * some parts adapted by similar drivers from Darius Augulis and Vladimir
   7  * Zapolskiy, additional improvements by Wim Van Sebroeck.
   8  *
   9  * This program is free software; you can redistribute it and/or modify it
  10  * under the terms of the GNU General Public License version 2 as published by
  11  * the Free Software Foundation.
  12  *
  13  * NOTE: MX1 has a slightly different Watchdog than MX2 and later:
  14  *
  15  *                      MX1:            MX2+:
  16  *                      ----            -----
  17  * Registers:           32-bit          16-bit
  18  * Stopable timer:      Yes             No
  19  * Need to enable clk:  No              Yes
  20  * Halt on suspend:     Manual          Can be automatic
  21  */
  22
  23 #include <linux/init.h>
  24 #include <linux/kernel.h>
  25 #include <linux/miscdevice.h>
  26 #include <linux/module.h>
  27 #include <linux/moduleparam.h>
  28 #include <linux/platform_device.h>
  29 #include <linux/watchdog.h>
  30 #include <linux/clk.h>
  31 #include <linux/fs.h>
  32 #include <linux/io.h>
  33 #include <linux/uaccess.h>
  34 #include <linux/timer.h>
  35 #include <linux/jiffies.h>
  36 #include <mach/hardware.h>
  37
  38 #define DRIVER_NAME "imx2-wdt"
  39
  40 #define IMX2_WDT_WCR            0x00            /* Control Register */
  41 #define IMX2_WDT_WCR_WT         (0xFF << 8)     /* -> Watchdog Timeout Field */
  42 #define IMX2_WDT_WCR_WRE        (1 << 3)        /* -> WDOG Reset Enable */
  43 #define IMX2_WDT_WCR_WDE        (1 << 2)        /* -> Watchdog Enable */
  44
  45 #define IMX2_WDT_WSR            0x02            /* Service Register */
  46 #define IMX2_WDT_SEQ1           0x5555          /* -> service sequence 1 */
  47 #define IMX2_WDT_SEQ2           0xAAAA          /* -> service sequence 2 */
  48
  49 #define IMX2_WDT_WRSR           0x04            /* Reset Status Register */
  50 #define IMX2_WDT_WRSR_TOUT      (1 << 1)        /* -> Reset due to Timeout */
  51
  52 #define IMX2_WDT_MAX_TIME       128
  53 #define IMX2_WDT_DEFAULT_TIME   60              /* in seconds */
  54
  55 #define WDOG_SEC_TO_COUNT(s)    ((s * 2 - 1) << 8)
  56
  57 #define IMX2_WDT_STATUS_OPEN    0
  58 #define IMX2_WDT_STATUS_STARTED 1
  59 #define IMX2_WDT_EXPECT_CLOSE   2
  60
  61 static struct {
  62         struct clk *clk;
  63         void __iomem *base;
  64         unsigned timeout;
  65         unsigned long status;
  66         struct timer_list timer;        /* Pings the watchdog when closed */
  67 } imx2_wdt;
  68
  69 static struct miscdevice imx2_wdt_miscdev;
  70
  71 static bool nowayout = WATCHDOG_NOWAYOUT;
  72 module_param(nowayout, bool, 0);
  73 MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default="
  74                                 __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
  75
  76
  77 static unsigned timeout = IMX2_WDT_DEFAULT_TIME;
  78 module_param(timeout, uint, 0);
  79 MODULE_PARM_DESC(timeout, "Watchdog timeout in seconds (default="
  80                                 __MODULE_STRING(IMX2_WDT_DEFAULT_TIME) ")");
  81
  82 static const struct watchdog_info imx2_wdt_info = {
  83         .identity = "imx2+ watchdog",
  84         .options = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT | WDIOF_MAGICCLOSE,
  85 };
  86
  87 static inline void imx2_wdt_setup(void)
  88 {
  89         u16 val = __raw_readw(imx2_wdt.base + IMX2_WDT_WCR);
  90
  91         /* Strip the old watchdog Time-Out value */
  92         val &= ~IMX2_WDT_WCR_WT;
  93         /* Generate reset if WDOG times out */
  94         val &= ~IMX2_WDT_WCR_WRE;
  95         /* Keep Watchdog Disabled */
  96         val &= ~IMX2_WDT_WCR_WDE;
  97         /* Set the watchdog's Time-Out value */
  98         val |= WDOG_SEC_TO_COUNT(imx2_wdt.timeout);
  99
 100         __raw_writew(val, imx2_wdt.base + IMX2_WDT_WCR);
 101
 102         /* enable the watchdog */
 103         val |= IMX2_WDT_WCR_WDE;
 104         __raw_writew(val, imx2_wdt.base + IMX2_WDT_WCR);
 105 }
 106
 107 static inline void imx2_wdt_ping(void)
 108 {
 109         __raw_writew(IMX2_WDT_SEQ1, imx2_wdt.base + IMX2_WDT_WSR);
 110         __raw_writew(IMX2_WDT_SEQ2, imx2_wdt.base + IMX2_WDT_WSR);
 111 }
 112
 113 static void imx2_wdt_timer_ping(unsigned long arg)
 114 {
 115         /* ping it every imx2_wdt.timeout / 2 seconds to prevent reboot */
 116         imx2_wdt_ping();
 117         mod_timer(&imx2_wdt.timer, jiffies + imx2_wdt.timeout * HZ / 2);
 118 }
 119
 120 static void imx2_wdt_start(void)
 121 {
 122         if (!test_and_set_bit(IMX2_WDT_STATUS_STARTED, &imx2_wdt.status)) {
 123                 /* at our first start we enable clock and do initialisations */
 124                 clk_enable(imx2_wdt.clk);
 125
 126                 imx2_wdt_setup();
 127         } else  /* delete the timer that pings the watchdog after close */
 128                 del_timer_sync(&imx2_wdt.timer);
 129
 130         /* Watchdog is enabled - time to reload the timeout value */
 131         imx2_wdt_ping();
 132 }
 133
 134 static void imx2_wdt_stop(void)
 135 {
 136         /* we don't need a clk_disable, it cannot be disabled once started.
 137          * We use a timer to ping the watchdog while /dev/watchdog is closed */
 138         imx2_wdt_timer_ping(0);
 139 }
 140
 141 static void imx2_wdt_set_timeout(int new_timeout)
 142 {
 143         u16 val = __raw_readw(imx2_wdt.base + IMX2_WDT_WCR);
 144
 145         /* set the new timeout value in the WSR */
 146         val &= ~IMX2_WDT_WCR_WT;
 147         val |= WDOG_SEC_TO_COUNT(new_timeout);
 148         __raw_writew(val, imx2_wdt.base + IMX2_WDT_WCR);
 149 }
 150
 151 static int imx2_wdt_open(struct inode *inode, struct file *file)
 152 {
 153         if (test_and_set_bit(IMX2_WDT_STATUS_OPEN, &imx2_wdt.status))
 154                 return -EBUSY;
 155
 156         imx2_wdt_start();
 157         return nonseekable_open(inode, file);
 158 }
 159
 160 static int imx2_wdt_close(struct inode *inode, struct file *file)
 161 {
 162         if (test_bit(IMX2_WDT_EXPECT_CLOSE, &imx2_wdt.status) && !nowayout)
 163                 imx2_wdt_stop();
 164         else {
 165                 dev_crit(imx2_wdt_miscdev.parent,
 166                         "Unexpected close: Expect reboot!\n");
 167                 imx2_wdt_ping();
 168         }
 169
 170         clear_bit(IMX2_WDT_EXPECT_CLOSE, &imx2_wdt.status);
 171         clear_bit(IMX2_WDT_STATUS_OPEN, &imx2_wdt.status);
 172         return 0;
 173 }
 174
 175 static long imx2_wdt_ioctl(struct file *file, unsigned int cmd,
 176                                                         unsigned long arg)
 177 {
 178         void __user *argp = (void __user *)arg;
 179         int __user *p = argp;
 180         int new_value;
 181         u16 val;
 182
 183         switch (cmd) {
 184         case WDIOC_GETSUPPORT:
 185                 return copy_to_user(argp, &imx2_wdt_info,
 186                         sizeof(struct watchdog_info)) ? -EFAULT : 0;
 187
 188         case WDIOC_GETSTATUS:
 189                 return put_user(0, p);
 190
 191         case WDIOC_GETBOOTSTATUS:
 192                 val = __raw_readw(imx2_wdt.base + IMX2_WDT_WRSR);
 193                 new_value = val & IMX2_WDT_WRSR_TOUT ? WDIOF_CARDRESET : 0;
 194                 return put_user(new_value, p);
 195
 196         case WDIOC_KEEPALIVE:
 197                 imx2_wdt_ping();
 198                 return 0;
 199
 200         case WDIOC_SETTIMEOUT:
 201                 if (get_user(new_value, p))
 202                         return -EFAULT;
 203                 if ((new_value < 1) || (new_value > IMX2_WDT_MAX_TIME))
 204                         return -EINVAL;
 205                 imx2_wdt_set_timeout(new_value);
 206                 imx2_wdt.timeout = new_value;
 207                 imx2_wdt_ping();
 208
 209                 /* Fallthrough to return current value */
 210         case WDIOC_GETTIMEOUT:
 211                 return put_user(imx2_wdt.timeout, p);
 212
 213         default:
 214                 return -ENOTTY;
 215         }
 216 }
 217
 218 static ssize_t imx2_wdt_write(struct file *file, const char __user *data,
 219                                                 size_t len, loff_t *ppos)
 220 {
 221         size_t i;
 222         char c;
 223
 224         if (len == 0)   /* Can we see this even ? */
 225                 return 0;
 226
 227         clear_bit(IMX2_WDT_EXPECT_CLOSE, &imx2_wdt.status);
 228         /* scan to see whether or not we got the magic character */
 229         for (i = 0; i != len; i++) {
 230                 if (get_user(c, data + i))
 231                         return -EFAULT;
 232                 if (c == 'V')
 233                         set_bit(IMX2_WDT_EXPECT_CLOSE, &imx2_wdt.status);
 234         }
 235
 236         imx2_wdt_ping();
 237         return len;
 238 }
 239
 240 static const struct file_operations imx2_wdt_fops = {
 241         .owner = THIS_MODULE,
 242         .llseek = no_llseek,
 243         .unlocked_ioctl = imx2_wdt_ioctl,
 244         .open = imx2_wdt_open,
 245         .release = imx2_wdt_close,
 246         .write = imx2_wdt_write,
 247 };
 248
 249 static struct miscdevice imx2_wdt_miscdev = {
 250         .minor = WATCHDOG_MINOR,
 251         .name = "watchdog",
 252         .fops = &imx2_wdt_fops,
 253 };
 254
 255 static int __init imx2_wdt_probe(struct platform_device *pdev)
 256 {
 257         int ret;
 258         struct resource *res;
 259
 260         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 261         if (!res) {
 262                 dev_err(&pdev->dev, "can't get device resources\n");
 263                 return -ENODEV;
 264         }
 265
 266         imx2_wdt.base = devm_request_and_ioremap(&pdev->dev, res);
 267         if (!imx2_wdt.base) {
 268                 dev_err(&pdev->dev, "ioremap failed\n");
 269                 return -ENOMEM;
 270         }
 271
 272         imx2_wdt.clk = clk_get(&pdev->dev, NULL);
 273         if (IS_ERR(imx2_wdt.clk)) {
 274                 dev_err(&pdev->dev, "can't get Watchdog clock\n");
 275                 return PTR_ERR(imx2_wdt.clk);
 276         }
 277
 278         imx2_wdt.timeout = clamp_t(unsigned, timeout, 1, IMX2_WDT_MAX_TIME);
 279         if (imx2_wdt.timeout != timeout)
 280                 dev_warn(&pdev->dev, "Initial timeout out of range! "
 281                         "Clamped from %u to %u\n", timeout, imx2_wdt.timeout);
 282
 283         setup_timer(&imx2_wdt.timer, imx2_wdt_timer_ping, 0);
 284
 285         imx2_wdt_miscdev.parent = &pdev->dev;
 286         ret = misc_register(&imx2_wdt_miscdev);
 287         if (ret)
 288                 goto fail;
 289
 290         dev_info(&pdev->dev,
 291                 "IMX2+ Watchdog Timer enabled. timeout=%ds (nowayout=%d)\n",
 292                                                 imx2_wdt.timeout, nowayout);
 293         return 0;
 294
 295 fail:
 296         imx2_wdt_miscdev.parent = NULL;
 297         clk_put(imx2_wdt.clk);
 298         return ret;
 299 }
 300
 301 static int __exit imx2_wdt_remove(struct platform_device *pdev)
 302 {
 303         misc_deregister(&imx2_wdt_miscdev);
 304
 305         if (test_bit(IMX2_WDT_STATUS_STARTED, &imx2_wdt.status)) {
 306                 del_timer_sync(&imx2_wdt.timer);
 307
 308                 dev_crit(imx2_wdt_miscdev.parent,
 309                         "Device removed: Expect reboot!\n");
 310         } else
 311                 clk_put(imx2_wdt.clk);
 312
 313         imx2_wdt_miscdev.parent = NULL;
 314         return 0;
 315 }
 316
 317 static void imx2_wdt_shutdown(struct platform_device *pdev)
 318 {
 319         if (test_bit(IMX2_WDT_STATUS_STARTED, &imx2_wdt.status)) {
 320                 /* we are running, we need to delete the timer but will give
 321                  * max timeout before reboot will take place */
 322                 del_timer_sync(&imx2_wdt.timer);
 323                 imx2_wdt_set_timeout(IMX2_WDT_MAX_TIME);
 324                 imx2_wdt_ping();
 325
 326                 dev_crit(imx2_wdt_miscdev.parent,
 327                         "Device shutdown: Expect reboot!\n");
 328         }
 329 }
 330
 331 static const struct of_device_id imx2_wdt_dt_ids[] = {
 332         { .compatible = "fsl,imx21-wdt", },
 333         { /* sentinel */ }
 334 };
 335
 336 static struct platform_driver imx2_wdt_driver = {
 337         .remove         = __exit_p(imx2_wdt_remove),
 338         .shutdown       = imx2_wdt_shutdown,
 339         .driver         = {
 340                 .name   = DRIVER_NAME,
 341                 .owner  = THIS_MODULE,
 342                 .of_match_table = imx2_wdt_dt_ids,
 343         },
 344 };
 345
 346 static int __init imx2_wdt_init(void)
 347 {
 348         return platform_driver_probe(&imx2_wdt_driver, imx2_wdt_probe);
 349 }
 350 module_init(imx2_wdt_init);
 351
 352 static void __exit imx2_wdt_exit(void)
 353 {
 354         platform_driver_unregister(&imx2_wdt_driver);
 355 }
 356 module_exit(imx2_wdt_exit);
 357
 358 MODULE_AUTHOR("Wolfram Sang");
 359 MODULE_DESCRIPTION("Watchdog driver for IMX2 and later");
 360 MODULE_LICENSE("GPL v2");
 361 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
 362 MODULE_ALIAS("platform:" DRIVER_NAME);