drivers/watchdog/orion_wdt.c

   1 /*
   2  * drivers/watchdog/orion_wdt.c
   3  *
   4  * Watchdog driver for Orion/Kirkwood processors
   5  *
   6  * Author: Sylver Bruneau <sylver.bruneau@googlemail.com>
   7  *
   8  * This file is licensed under  the terms of the GNU General Public
   9  * License version 2. This program is licensed "as is" without any
  10  * warranty of any kind, whether express or implied.
  11  */
  12
  13 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  14
  15 #include <linux/module.h>
  16 #include <linux/moduleparam.h>
  17 #include <linux/types.h>
  18 #include <linux/kernel.h>
  19 #include <linux/fs.h>
  20 #include <linux/miscdevice.h>
  21 #include <linux/platform_device.h>
  22 #include <linux/watchdog.h>
  23 #include <linux/init.h>
  24 #include <linux/uaccess.h>
  25 #include <linux/io.h>
  26 #include <linux/spinlock.h>
  27 #include <linux/clk.h>
  28 #include <mach/bridge-regs.h>
  29
  30 /*
  31  * Watchdog timer block registers.
  32  */
  33 #define TIMER_CTRL              0x0000
  34 #define  WDT_EN                 0x0010
  35 #define WDT_VAL                 0x0024
  36
  37 #define WDT_MAX_CYCLE_COUNT     0xffffffff
  38 #define WDT_IN_USE              0
  39 #define WDT_OK_TO_CLOSE         1
  40
  41 static bool nowayout = WATCHDOG_NOWAYOUT;
  42 static int heartbeat = -1;              /* module parameter (seconds) */
  43 static unsigned int wdt_max_duration;   /* (seconds) */
  44 static struct clk *clk;
  45 static unsigned int wdt_tclk;
  46 static void __iomem *wdt_reg;
  47 static unsigned long wdt_status;
  48 static DEFINE_SPINLOCK(wdt_lock);
  49
  50 static void orion_wdt_ping(void)
  51 {
  52         spin_lock(&wdt_lock);
  53
  54         /* Reload watchdog duration */
  55         writel(wdt_tclk * heartbeat, wdt_reg + WDT_VAL);
  56
  57         spin_unlock(&wdt_lock);
  58 }
  59
  60 static void orion_wdt_enable(void)
  61 {
  62         u32 reg;
  63
  64         spin_lock(&wdt_lock);
  65
  66         /* Set watchdog duration */
  67         writel(wdt_tclk * heartbeat, wdt_reg + WDT_VAL);
  68
  69         /* Clear watchdog timer interrupt */
  70         reg = readl(BRIDGE_CAUSE);
  71         reg &= ~WDT_INT_REQ;
  72         writel(reg, BRIDGE_CAUSE);
  73
  74         /* Enable watchdog timer */
  75         reg = readl(wdt_reg + TIMER_CTRL);
  76         reg |= WDT_EN;
  77         writel(reg, wdt_reg + TIMER_CTRL);
  78
  79         /* Enable reset on watchdog */
  80         reg = readl(RSTOUTn_MASK);
  81         reg |= WDT_RESET_OUT_EN;
  82         writel(reg, RSTOUTn_MASK);
  83
  84         spin_unlock(&wdt_lock);
  85 }
  86
  87 static void orion_wdt_disable(void)
  88 {
  89         u32 reg;
  90
  91         spin_lock(&wdt_lock);
  92
  93         /* Disable reset on watchdog */
  94         reg = readl(RSTOUTn_MASK);
  95         reg &= ~WDT_RESET_OUT_EN;
  96         writel(reg, RSTOUTn_MASK);
  97
  98         /* Disable watchdog timer */
  99         reg = readl(wdt_reg + TIMER_CTRL);
 100         reg &= ~WDT_EN;
 101         writel(reg, wdt_reg + TIMER_CTRL);
 102
 103         spin_unlock(&wdt_lock);
 104 }
 105
 106 static int orion_wdt_get_timeleft(int *time_left)
 107 {
 108         spin_lock(&wdt_lock);
 109         *time_left = readl(wdt_reg + WDT_VAL) / wdt_tclk;
 110         spin_unlock(&wdt_lock);
 111         return 0;
 112 }
 113
 114 static int orion_wdt_open(struct inode *inode, struct file *file)
 115 {
 116         if (test_and_set_bit(WDT_IN_USE, &wdt_status))
 117                 return -EBUSY;
 118         clear_bit(WDT_OK_TO_CLOSE, &wdt_status);
 119         orion_wdt_enable();
 120         return nonseekable_open(inode, file);
 121 }
 122
 123 static ssize_t orion_wdt_write(struct file *file, const char *data,
 124                                         size_t len, loff_t *ppos)
 125 {
 126         if (len) {
 127                 if (!nowayout) {
 128                         size_t i;
 129
 130                         clear_bit(WDT_OK_TO_CLOSE, &wdt_status);
 131                         for (i = 0; i != len; i++) {
 132                                 char c;
 133
 134                                 if (get_user(c, data + i))
 135                                         return -EFAULT;
 136                                 if (c == 'V')
 137                                         set_bit(WDT_OK_TO_CLOSE, &wdt_status);
 138                         }
 139                 }
 140                 orion_wdt_ping();
 141         }
 142         return len;
 143 }
 144
 145 static int orion_wdt_settimeout(int new_time)
 146 {
 147         if ((new_time <= 0) || (new_time > wdt_max_duration))
 148                 return -EINVAL;
 149
 150         /* Set new watchdog time to be used when
 151          * orion_wdt_enable() or orion_wdt_ping() is called. */
 152         heartbeat = new_time;
 153         return 0;
 154 }
 155
 156 static const struct watchdog_info ident = {
 157         .options        = WDIOF_MAGICCLOSE | WDIOF_SETTIMEOUT |
 158                           WDIOF_KEEPALIVEPING,
 159         .identity       = "Orion Watchdog",
 160 };
 161
 162 static long orion_wdt_ioctl(struct file *file, unsigned int cmd,
 163                                 unsigned long arg)
 164 {
 165         int ret = -ENOTTY;
 166         int time;
 167
 168         switch (cmd) {
 169         case WDIOC_GETSUPPORT:
 170                 ret = copy_to_user((struct watchdog_info *)arg, &ident,
 171                                    sizeof(ident)) ? -EFAULT : 0;
 172                 break;
 173
 174         case WDIOC_GETSTATUS:
 175         case WDIOC_GETBOOTSTATUS:
 176                 ret = put_user(0, (int *)arg);
 177                 break;
 178
 179         case WDIOC_KEEPALIVE:
 180                 orion_wdt_ping();
 181                 ret = 0;
 182                 break;
 183
 184         case WDIOC_SETTIMEOUT:
 185                 ret = get_user(time, (int *)arg);
 186                 if (ret)
 187                         break;
 188
 189                 if (orion_wdt_settimeout(time)) {
 190                         ret = -EINVAL;
 191                         break;
 192                 }
 193                 orion_wdt_ping();
 194                 /* Fall through */
 195
 196         case WDIOC_GETTIMEOUT:
 197                 ret = put_user(heartbeat, (int *)arg);
 198                 break;
 199
 200         case WDIOC_GETTIMELEFT:
 201                 if (orion_wdt_get_timeleft(&time)) {
 202                         ret = -EINVAL;
 203                         break;
 204                 }
 205                 ret = put_user(time, (int *)arg);
 206                 break;
 207         }
 208         return ret;
 209 }
 210
 211 static int orion_wdt_release(struct inode *inode, struct file *file)
 212 {
 213         if (test_bit(WDT_OK_TO_CLOSE, &wdt_status))
 214                 orion_wdt_disable();
 215         else
 216                 pr_crit("Device closed unexpectedly - timer will not stop\n");
 217         clear_bit(WDT_IN_USE, &wdt_status);
 218         clear_bit(WDT_OK_TO_CLOSE, &wdt_status);
 219
 220         return 0;
 221 }
 222
 223
 224 static const struct file_operations orion_wdt_fops = {
 225         .owner          = THIS_MODULE,
 226         .llseek         = no_llseek,
 227         .write          = orion_wdt_write,
 228         .unlocked_ioctl = orion_wdt_ioctl,
 229         .open           = orion_wdt_open,
 230         .release        = orion_wdt_release,
 231 };
 232
 233 static struct miscdevice orion_wdt_miscdev = {
 234         .minor          = WATCHDOG_MINOR,
 235         .name           = "watchdog",
 236         .fops           = &orion_wdt_fops,
 237 };
 238
 239 static int __devinit orion_wdt_probe(struct platform_device *pdev)
 240 {
 241         struct resource *res;
 242         int ret;
 243
 244         clk = clk_get(&pdev->dev, NULL);
 245         if (IS_ERR(clk)) {
 246                 printk(KERN_ERR "Orion Watchdog missing clock\n");
 247                 return -ENODEV;
 248         }
 249         clk_prepare_enable(clk);
 250         wdt_tclk = clk_get_rate(clk);
 251
 252         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 253
 254         wdt_reg = ioremap(res->start, resource_size(res));
 255
 256         if (orion_wdt_miscdev.parent)
 257                 return -EBUSY;
 258         orion_wdt_miscdev.parent = &pdev->dev;
 259
 260         wdt_max_duration = WDT_MAX_CYCLE_COUNT / wdt_tclk;
 261         if (orion_wdt_settimeout(heartbeat))
 262                 heartbeat = wdt_max_duration;
 263
 264         ret = misc_register(&orion_wdt_miscdev);
 265         if (ret)
 266                 return ret;
 267
 268         pr_info("Initial timeout %d sec%s\n",
 269                 heartbeat, nowayout ? ", nowayout" : "");
 270         return 0;
 271 }
 272
 273 static int __devexit orion_wdt_remove(struct platform_device *pdev)
 274 {
 275         int ret;
 276
 277         if (test_bit(WDT_IN_USE, &wdt_status)) {
 278                 orion_wdt_disable();
 279                 clear_bit(WDT_IN_USE, &wdt_status);
 280         }
 281
 282         ret = misc_deregister(&orion_wdt_miscdev);
 283         if (!ret)
 284                 orion_wdt_miscdev.parent = NULL;
 285
 286         clk_disable_unprepare(clk);
 287         clk_put(clk);
 288
 289         return ret;
 290 }
 291
 292 static void orion_wdt_shutdown(struct platform_device *pdev)
 293 {
 294         if (test_bit(WDT_IN_USE, &wdt_status))
 295                 orion_wdt_disable();
 296 }
 297
 298 static struct platform_driver orion_wdt_driver = {
 299         .probe          = orion_wdt_probe,
 300         .remove         = __devexit_p(orion_wdt_remove),
 301         .shutdown       = orion_wdt_shutdown,
 302         .driver         = {
 303                 .owner  = THIS_MODULE,
 304                 .name   = "orion_wdt",
 305         },
 306 };
 307
 308 module_platform_driver(orion_wdt_driver);
 309
 310 MODULE_AUTHOR("Sylver Bruneau <sylver.bruneau@googlemail.com>");
 311 MODULE_DESCRIPTION("Orion Processor Watchdog");
 312
 313 module_param(heartbeat, int, 0);
 314 MODULE_PARM_DESC(heartbeat, "Initial watchdog heartbeat in seconds");
 315
 316 module_param(nowayout, bool, 0);
 317 MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default="
 318                                 __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
 319
 320 MODULE_LICENSE("GPL");
 321 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);