drivers/watchdog/wm831x_wdt.c

   1 /*
   2  * Watchdog driver for the wm831x PMICs
   3  *
   4  * Copyright (C) 2009 Wolfson Microelectronics
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation
   9  */
  10
  11 #include <linux/module.h>
  12 #include <linux/moduleparam.h>
  13 #include <linux/types.h>
  14 #include <linux/kernel.h>
  15 #include <linux/slab.h>
  16 #include <linux/platform_device.h>
  17 #include <linux/watchdog.h>
  18 #include <linux/uaccess.h>
  19 #include <linux/gpio.h>
  20
  21 #include <linux/mfd/wm831x/core.h>
  22 #include <linux/mfd/wm831x/pdata.h>
  23 #include <linux/mfd/wm831x/watchdog.h>
  24
  25 static int nowayout = WATCHDOG_NOWAYOUT;
  26 module_param(nowayout, int, 0);
  27 MODULE_PARM_DESC(nowayout,
  28                  "Watchdog cannot be stopped once started (default="
  29                  __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
  30
  31 struct wm831x_wdt_drvdata {
  32         struct watchdog_device wdt;
  33         struct wm831x *wm831x;
  34         struct mutex lock;
  35         int update_gpio;
  36         int update_state;
  37 };
  38
  39 /* We can't use the sub-second values here but they're included
  40  * for completeness.  */
  41 static struct {
  42         unsigned int time;  /* Seconds */
  43         u16 val;            /* WDOG_TO value */
  44 } wm831x_wdt_cfgs[] = {
  45         {  1, 2 },
  46         {  2, 3 },
  47         {  4, 4 },
  48         {  8, 5 },
  49         { 16, 6 },
  50         { 32, 7 },
  51         { 33, 7 },  /* Actually 32.768s so include both, others round down */
  52 };
  53
  54 static int wm831x_wdt_start(struct watchdog_device *wdt_dev)
  55 {
  56         struct wm831x_wdt_drvdata *driver_data = watchdog_get_drvdata(wdt_dev);
  57         struct wm831x *wm831x = driver_data->wm831x;
  58         int ret;
  59
  60         mutex_lock(&driver_data->lock);
  61
  62         ret = wm831x_reg_unlock(wm831x);
  63         if (ret == 0) {
  64                 ret = wm831x_set_bits(wm831x, WM831X_WATCHDOG,
  65                                       WM831X_WDOG_ENA, WM831X_WDOG_ENA);
  66                 wm831x_reg_lock(wm831x);
  67         } else {
  68                 dev_err(wm831x->dev, "Failed to unlock security key: %d\n",
  69                         ret);
  70         }
  71
  72         mutex_unlock(&driver_data->lock);
  73
  74         return ret;
  75 }
  76
  77 static int wm831x_wdt_stop(struct watchdog_device *wdt_dev)
  78 {
  79         struct wm831x_wdt_drvdata *driver_data = watchdog_get_drvdata(wdt_dev);
  80         struct wm831x *wm831x = driver_data->wm831x;
  81         int ret;
  82
  83         mutex_lock(&driver_data->lock);
  84
  85         ret = wm831x_reg_unlock(wm831x);
  86         if (ret == 0) {
  87                 ret = wm831x_set_bits(wm831x, WM831X_WATCHDOG,
  88                                       WM831X_WDOG_ENA, 0);
  89                 wm831x_reg_lock(wm831x);
  90         } else {
  91                 dev_err(wm831x->dev, "Failed to unlock security key: %d\n",
  92                         ret);
  93         }
  94
  95         mutex_unlock(&driver_data->lock);
  96
  97         return ret;
  98 }
  99
 100 static int wm831x_wdt_ping(struct watchdog_device *wdt_dev)
 101 {
 102         struct wm831x_wdt_drvdata *driver_data = watchdog_get_drvdata(wdt_dev);
 103         struct wm831x *wm831x = driver_data->wm831x;
 104         int ret;
 105         u16 reg;
 106
 107         mutex_lock(&driver_data->lock);
 108
 109         if (driver_data->update_gpio) {
 110                 gpio_set_value_cansleep(driver_data->update_gpio,
 111                                         driver_data->update_state);
 112                 driver_data->update_state = !driver_data->update_state;
 113                 ret = 0;
 114                 goto out;
 115         }
 116
 117         reg = wm831x_reg_read(wm831x, WM831X_WATCHDOG);
 118
 119         if (!(reg & WM831X_WDOG_RST_SRC)) {
 120                 dev_err(wm831x->dev, "Hardware watchdog update unsupported\n");
 121                 ret = -EINVAL;
 122                 goto out;
 123         }
 124
 125         reg |= WM831X_WDOG_RESET;
 126
 127         ret = wm831x_reg_unlock(wm831x);
 128         if (ret == 0) {
 129                 ret = wm831x_reg_write(wm831x, WM831X_WATCHDOG, reg);
 130                 wm831x_reg_lock(wm831x);
 131         } else {
 132                 dev_err(wm831x->dev, "Failed to unlock security key: %d\n",
 133                         ret);
 134         }
 135
 136 out:
 137         mutex_unlock(&driver_data->lock);
 138
 139         return ret;
 140 }
 141
 142 static int wm831x_wdt_set_timeout(struct watchdog_device *wdt_dev,
 143                                   unsigned int timeout)
 144 {
 145         struct wm831x_wdt_drvdata *driver_data = watchdog_get_drvdata(wdt_dev);
 146         struct wm831x *wm831x = driver_data->wm831x;
 147         int ret, i;
 148
 149         for (i = 0; i < ARRAY_SIZE(wm831x_wdt_cfgs); i++)
 150                 if (wm831x_wdt_cfgs[i].time == timeout)
 151                         break;
 152         if (i == ARRAY_SIZE(wm831x_wdt_cfgs))
 153                 return -EINVAL;
 154
 155         ret = wm831x_reg_unlock(wm831x);
 156         if (ret == 0) {
 157                 ret = wm831x_set_bits(wm831x, WM831X_WATCHDOG,
 158                                       WM831X_WDOG_TO_MASK,
 159                                       wm831x_wdt_cfgs[i].val);
 160                 wm831x_reg_lock(wm831x);
 161         } else {
 162                 dev_err(wm831x->dev, "Failed to unlock security key: %d\n",
 163                         ret);
 164         }
 165
 166         return ret;
 167 }
 168
 169 static const struct watchdog_info wm831x_wdt_info = {
 170         .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE,
 171         .identity = "WM831x Watchdog",
 172 };
 173
 174 static const struct watchdog_ops wm831x_wdt_ops = {
 175         .owner = THIS_MODULE,
 176         .start = wm831x_wdt_start,
 177         .stop = wm831x_wdt_stop,
 178         .ping = wm831x_wdt_ping,
 179         .set_timeout = wm831x_wdt_set_timeout,
 180 };
 181
 182 static int __devinit wm831x_wdt_probe(struct platform_device *pdev)
 183 {
 184         struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
 185         struct wm831x_pdata *chip_pdata;
 186         struct wm831x_watchdog_pdata *pdata;
 187         struct wm831x_wdt_drvdata *driver_data;
 188         struct watchdog_device *wm831x_wdt;
 189         int reg, ret, i;
 190
 191         ret = wm831x_reg_read(wm831x, WM831X_WATCHDOG);
 192         if (ret < 0) {
 193                 dev_err(wm831x->dev, "Failed to read watchdog status: %d\n",
 194                         ret);
 195                 goto err;
 196         }
 197         reg = ret;
 198
 199         if (reg & WM831X_WDOG_DEBUG)
 200                 dev_warn(wm831x->dev, "Watchdog is paused\n");
 201
 202         driver_data = devm_kzalloc(&pdev->dev, sizeof(*driver_data),
 203                                    GFP_KERNEL);
 204         if (!driver_data) {
 205                 dev_err(wm831x->dev, "Unable to alloacate watchdog device\n");
 206                 ret = -ENOMEM;
 207                 goto err;
 208         }
 209
 210         mutex_init(&driver_data->lock);
 211         driver_data->wm831x = wm831x;
 212
 213         wm831x_wdt = &driver_data->wdt;
 214
 215         wm831x_wdt->info = &wm831x_wdt_info;
 216         wm831x_wdt->ops = &wm831x_wdt_ops;
 217         watchdog_set_nowayout(wm831x_wdt, nowayout);
 218         watchdog_set_drvdata(wm831x_wdt, driver_data);
 219
 220         reg = wm831x_reg_read(wm831x, WM831X_WATCHDOG);
 221         reg &= WM831X_WDOG_TO_MASK;
 222         for (i = 0; i < ARRAY_SIZE(wm831x_wdt_cfgs); i++)
 223                 if (wm831x_wdt_cfgs[i].val == reg)
 224                         break;
 225         if (i == ARRAY_SIZE(wm831x_wdt_cfgs))
 226                 dev_warn(wm831x->dev,
 227                          "Unknown watchdog timeout: %x\n", reg);
 228         else
 229                 wm831x_wdt->timeout = wm831x_wdt_cfgs[i].time;
 230
 231         /* Apply any configuration */
 232         if (pdev->dev.parent->platform_data) {
 233                 chip_pdata = pdev->dev.parent->platform_data;
 234                 pdata = chip_pdata->watchdog;
 235         } else {
 236                 pdata = NULL;
 237         }
 238
 239         if (pdata) {
 240                 reg &= ~(WM831X_WDOG_SECACT_MASK | WM831X_WDOG_PRIMACT_MASK |
 241                          WM831X_WDOG_RST_SRC);
 242
 243                 reg |= pdata->primary << WM831X_WDOG_PRIMACT_SHIFT;
 244                 reg |= pdata->secondary << WM831X_WDOG_SECACT_SHIFT;
 245                 reg |= pdata->software << WM831X_WDOG_RST_SRC_SHIFT;
 246
 247                 if (pdata->update_gpio) {
 248                         ret = gpio_request(pdata->update_gpio,
 249                                            "Watchdog update");
 250                         if (ret < 0) {
 251                                 dev_err(wm831x->dev,
 252                                         "Failed to request update GPIO: %d\n",
 253                                         ret);
 254                                 goto err;
 255                         }
 256
 257                         ret = gpio_direction_output(pdata->update_gpio, 0);
 258                         if (ret != 0) {
 259                                 dev_err(wm831x->dev,
 260                                         "gpio_direction_output returned: %d\n",
 261                                         ret);
 262                                 goto err_gpio;
 263                         }
 264
 265                         driver_data->update_gpio = pdata->update_gpio;
 266
 267                         /* Make sure the watchdog takes hardware updates */
 268                         reg |= WM831X_WDOG_RST_SRC;
 269                 }
 270
 271                 ret = wm831x_reg_unlock(wm831x);
 272                 if (ret == 0) {
 273                         ret = wm831x_reg_write(wm831x, WM831X_WATCHDOG, reg);
 274                         wm831x_reg_lock(wm831x);
 275                 } else {
 276                         dev_err(wm831x->dev,
 277                                 "Failed to unlock security key: %d\n", ret);
 278                         goto err_gpio;
 279                 }
 280         }
 281
 282         ret = watchdog_register_device(&driver_data->wdt);
 283         if (ret != 0) {
 284                 dev_err(wm831x->dev, "watchdog_register_device() failed: %d\n",
 285                         ret);
 286                 goto err_gpio;
 287         }
 288
 289         dev_set_drvdata(&pdev->dev, driver_data);
 290
 291         return 0;
 292
 293 err_gpio:
 294         if (driver_data->update_gpio)
 295                 gpio_free(driver_data->update_gpio);
 296 err:
 297         return ret;
 298 }
 299
 300 static int __devexit wm831x_wdt_remove(struct platform_device *pdev)
 301 {
 302         struct wm831x_wdt_drvdata *driver_data = dev_get_drvdata(&pdev->dev);
 303
 304         watchdog_unregister_device(&driver_data->wdt);
 305
 306         if (driver_data->update_gpio)
 307                 gpio_free(driver_data->update_gpio);
 308
 309         return 0;
 310 }
 311
 312 static struct platform_driver wm831x_wdt_driver = {
 313         .probe = wm831x_wdt_probe,
 314         .remove = __devexit_p(wm831x_wdt_remove),
 315         .driver = {
 316                 .name = "wm831x-watchdog",
 317         },
 318 };
 319
 320 module_platform_driver(wm831x_wdt_driver);
 321
 322 MODULE_AUTHOR("Mark Brown");
 323 MODULE_DESCRIPTION("WM831x Watchdog");
 324 MODULE_LICENSE("GPL");
 325 MODULE_ALIAS("platform:wm831x-watchdog");