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