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                 ret = -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 = kzalloc(sizeof(*driver_data), GFP_KERNEL);
 203         if (!driver_data) {
 204                 dev_err(wm831x->dev, "Unable to alloacate watchdog device\n");
 205                 ret = -ENOMEM;
 206                 goto err;
 207         }
 208
 209         mutex_init(&driver_data->lock);
 210         driver_data->wm831x = wm831x;
 211
 212         wm831x_wdt = &driver_data->wdt;
 213
 214         wm831x_wdt->info = &wm831x_wdt_info;
 215         wm831x_wdt->ops = &wm831x_wdt_ops;
 216         watchdog_set_drvdata(wm831x_wdt, driver_data);
 217
 218         if (nowayout)
 219                 wm831x_wdt->status |= WDOG_NO_WAY_OUT;
 220
 221         reg = wm831x_reg_read(wm831x, WM831X_WATCHDOG);
 222         reg &= WM831X_WDOG_TO_MASK;
 223         for (i = 0; i < ARRAY_SIZE(wm831x_wdt_cfgs); i++)
 224                 if (wm831x_wdt_cfgs[i].val == reg)
 225                         break;
 226         if (i == ARRAY_SIZE(wm831x_wdt_cfgs))
 227                 dev_warn(wm831x->dev,
 228                          "Unknown watchdog timeout: %x\n", reg);
 229         else
 230                 wm831x_wdt->timeout = wm831x_wdt_cfgs[i].time;
 231
 232         /* Apply any configuration */
 233         if (pdev->dev.parent->platform_data) {
 234                 chip_pdata = pdev->dev.parent->platform_data;
 235                 pdata = chip_pdata->watchdog;
 236         } else {
 237                 pdata = NULL;
 238         }
 239
 240         if (pdata) {
 241                 reg &= ~(WM831X_WDOG_SECACT_MASK | WM831X_WDOG_PRIMACT_MASK |
 242                          WM831X_WDOG_RST_SRC);
 243
 244                 reg |= pdata->primary << WM831X_WDOG_PRIMACT_SHIFT;
 245                 reg |= pdata->secondary << WM831X_WDOG_SECACT_SHIFT;
 246                 reg |= pdata->software << WM831X_WDOG_RST_SRC_SHIFT;
 247
 248                 if (pdata->update_gpio) {
 249                         ret = gpio_request(pdata->update_gpio,
 250                                            "Watchdog update");
 251                         if (ret < 0) {
 252                                 dev_err(wm831x->dev,
 253                                         "Failed to request update GPIO: %d\n",
 254                                         ret);
 255                                 goto err_alloc;
 256                         }
 257
 258                         ret = gpio_direction_output(pdata->update_gpio, 0);
 259                         if (ret != 0) {
 260                                 dev_err(wm831x->dev,
 261                                         "gpio_direction_output returned: %d\n",
 262                                         ret);
 263                                 goto err_gpio;
 264                         }
 265
 266                         driver_data->update_gpio = pdata->update_gpio;
 267
 268                         /* Make sure the watchdog takes hardware updates */
 269                         reg |= WM831X_WDOG_RST_SRC;
 270                 }
 271
 272                 ret = wm831x_reg_unlock(wm831x);
 273                 if (ret == 0) {
 274                         ret = wm831x_reg_write(wm831x, WM831X_WATCHDOG, reg);
 275                         wm831x_reg_lock(wm831x);
 276                 } else {
 277                         dev_err(wm831x->dev,
 278                                 "Failed to unlock security key: %d\n", ret);
 279                         goto err_gpio;
 280                 }
 281         }
 282
 283         ret = watchdog_register_device(&driver_data->wdt);
 284         if (ret != 0) {
 285                 dev_err(wm831x->dev, "watchdog_register_device() failed: %d\n",
 286                         ret);
 287                 goto err_gpio;
 288         }
 289
 290         dev_set_drvdata(&pdev->dev, driver_data);
 291
 292         return 0;
 293
 294 err_gpio:
 295         if (driver_data->update_gpio)
 296                 gpio_free(driver_data->update_gpio);
 297 err_alloc:
 298         kfree(driver_data);
 299 err:
 300         return ret;
 301 }
 302
 303 static int __devexit wm831x_wdt_remove(struct platform_device *pdev)
 304 {
 305         struct wm831x_wdt_drvdata *driver_data = dev_get_drvdata(&pdev->dev);
 306
 307         watchdog_unregister_device(&driver_data->wdt);
 308
 309         if (driver_data->update_gpio)
 310                 gpio_free(driver_data->update_gpio);
 311
 312         return 0;
 313 }
 314
 315 static struct platform_driver wm831x_wdt_driver = {
 316         .probe = wm831x_wdt_probe,
 317         .remove = __devexit_p(wm831x_wdt_remove),
 318         .driver = {
 319                 .name = "wm831x-watchdog",
 320         },
 321 };
 322
 323 static int __init wm831x_wdt_init(void)
 324 {
 325         return platform_driver_register(&wm831x_wdt_driver);
 326 }
 327 module_init(wm831x_wdt_init);
 328
 329 static void __exit wm831x_wdt_exit(void)
 330 {
 331         platform_driver_unregister(&wm831x_wdt_driver);
 332 }
 333 module_exit(wm831x_wdt_exit);
 334
 335 MODULE_AUTHOR("Mark Brown");
 336 MODULE_DESCRIPTION("WM831x Watchdog");
 337 MODULE_LICENSE("GPL");
 338 MODULE_ALIAS("platform:wm831x-watchdog");