drivers/watchdog/da9063_wdt.c

   1 /*
   2  * Watchdog driver for DA9063 PMICs.
   3  *
   4  * Copyright(c) 2012 Dialog Semiconductor Ltd.
   5  *
   6  * Author: Mariusz Wojtasik <mariusz.wojtasik@diasemi.com>
   7  *
   8  * This program is free software; you can redistribute  it and/or modify it
   9  * under  the terms of  the GNU General  Public License as published by the
  10  * Free Software Foundation;  either version 2 of the  License, or (at your
  11  * option) any later version.
  12  */
  13
  14 #include <linux/kernel.h>
  15 #include <linux/module.h>
  16 #include <linux/watchdog.h>
  17 #include <linux/platform_device.h>
  18 #include <linux/uaccess.h>
  19 #include <linux/slab.h>
  20 #include <linux/delay.h>
  21 #include <linux/mfd/da9063/registers.h>
  22 #include <linux/mfd/da9063/core.h>
  23 #include <linux/regmap.h>
  24
  25 /*
  26  * Watchdog selector to timeout in seconds.
  27  *   0: WDT disabled;
  28  *   others: timeout = 2048 ms * 2^(TWDSCALE-1).
  29  */
  30 static const unsigned int wdt_timeout[] = { 0, 2, 4, 8, 16, 32, 65, 131 };
  31 #define DA9063_TWDSCALE_DISABLE         0
  32 #define DA9063_TWDSCALE_MIN             1
  33 #define DA9063_TWDSCALE_MAX             (ARRAY_SIZE(wdt_timeout) - 1)
  34 #define DA9063_WDT_MIN_TIMEOUT          wdt_timeout[DA9063_TWDSCALE_MIN]
  35 #define DA9063_WDT_MAX_TIMEOUT          wdt_timeout[DA9063_TWDSCALE_MAX]
  36 #define DA9063_WDG_TIMEOUT              wdt_timeout[3]
  37 #define DA9063_RESET_PROTECTION_MS      256
  38
  39 static unsigned int da9063_wdt_timeout_to_sel(unsigned int secs)
  40 {
  41         unsigned int i;
  42
  43         for (i = DA9063_TWDSCALE_MIN; i <= DA9063_TWDSCALE_MAX; i++) {
  44                 if (wdt_timeout[i] >= secs)
  45                         return i;
  46         }
  47
  48         return DA9063_TWDSCALE_MAX;
  49 }
  50
  51 static int _da9063_wdt_set_timeout(struct da9063 *da9063, unsigned int regval)
  52 {
  53         return regmap_update_bits(da9063->regmap, DA9063_REG_CONTROL_D,
  54                                   DA9063_TWDSCALE_MASK, regval);
  55 }
  56
  57 static int da9063_wdt_start(struct watchdog_device *wdd)
  58 {
  59         struct da9063 *da9063 = watchdog_get_drvdata(wdd);
  60         unsigned int selector;
  61         int ret;
  62
  63         selector = da9063_wdt_timeout_to_sel(wdd->timeout);
  64         ret = _da9063_wdt_set_timeout(da9063, selector);
  65         if (ret)
  66                 dev_err(da9063->dev, "Watchdog failed to start (err = %d)\n",
  67                         ret);
  68
  69         return ret;
  70 }
  71
  72 static int da9063_wdt_stop(struct watchdog_device *wdd)
  73 {
  74         struct da9063 *da9063 = watchdog_get_drvdata(wdd);
  75         int ret;
  76
  77         ret = regmap_update_bits(da9063->regmap, DA9063_REG_CONTROL_D,
  78                                  DA9063_TWDSCALE_MASK, DA9063_TWDSCALE_DISABLE);
  79         if (ret)
  80                 dev_alert(da9063->dev, "Watchdog failed to stop (err = %d)\n",
  81                           ret);
  82
  83         return ret;
  84 }
  85
  86 static int da9063_wdt_ping(struct watchdog_device *wdd)
  87 {
  88         struct da9063 *da9063 = watchdog_get_drvdata(wdd);
  89         int ret;
  90
  91         ret = regmap_write(da9063->regmap, DA9063_REG_CONTROL_F,
  92                            DA9063_WATCHDOG);
  93         if (ret)
  94                 dev_alert(da9063->dev, "Failed to ping the watchdog (err = %d)\n",
  95                           ret);
  96
  97         return ret;
  98 }
  99
 100 static int da9063_wdt_set_timeout(struct watchdog_device *wdd,
 101                                   unsigned int timeout)
 102 {
 103         struct da9063 *da9063 = watchdog_get_drvdata(wdd);
 104         unsigned int selector;
 105         int ret = 0;
 106
 107         selector = da9063_wdt_timeout_to_sel(timeout);
 108
 109         /*
 110          * There are two cases when a set_timeout() will be called:
 111          * 1. The watchdog is off and someone wants to set the timeout for the
 112          *    further use.
 113          * 2. The watchdog is already running and a new timeout value should be
 114          *    set.
 115          *
 116          * The watchdog can't store a timeout value not equal zero without
 117          * enabling the watchdog, so the timeout must be buffered by the driver.
 118          */
 119         if (watchdog_active(wdd))
 120                 ret = _da9063_wdt_set_timeout(da9063, selector);
 121
 122         if (ret)
 123                 dev_err(da9063->dev, "Failed to set watchdog timeout (err = %d)\n",
 124                         ret);
 125         else
 126                 wdd->timeout = wdt_timeout[selector];
 127
 128         return ret;
 129 }
 130
 131 static int da9063_wdt_restart(struct watchdog_device *wdd, unsigned long action,
 132                               void *data)
 133 {
 134         struct da9063 *da9063 = watchdog_get_drvdata(wdd);
 135         int ret;
 136
 137         ret = regmap_write(da9063->regmap, DA9063_REG_CONTROL_F,
 138                            DA9063_SHUTDOWN);
 139         if (ret)
 140                 dev_alert(da9063->dev, "Failed to shutdown (err = %d)\n",
 141                           ret);
 142
 143         return ret;
 144 }
 145
 146 static const struct watchdog_info da9063_watchdog_info = {
 147         .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING,
 148         .identity = "DA9063 Watchdog",
 149 };
 150
 151 static const struct watchdog_ops da9063_watchdog_ops = {
 152         .owner = THIS_MODULE,
 153         .start = da9063_wdt_start,
 154         .stop = da9063_wdt_stop,
 155         .ping = da9063_wdt_ping,
 156         .set_timeout = da9063_wdt_set_timeout,
 157         .restart = da9063_wdt_restart,
 158 };
 159
 160 static int da9063_wdt_probe(struct platform_device *pdev)
 161 {
 162         struct da9063 *da9063;
 163         struct watchdog_device *wdd;
 164
 165         if (!pdev->dev.parent)
 166                 return -EINVAL;
 167
 168         da9063 = dev_get_drvdata(pdev->dev.parent);
 169         if (!da9063)
 170                 return -EINVAL;
 171
 172         wdd = devm_kzalloc(&pdev->dev, sizeof(*wdd), GFP_KERNEL);
 173         if (!wdd)
 174                 return -ENOMEM;
 175
 176         wdd->info = &da9063_watchdog_info;
 177         wdd->ops = &da9063_watchdog_ops;
 178         wdd->min_timeout = DA9063_WDT_MIN_TIMEOUT;
 179         wdd->max_timeout = DA9063_WDT_MAX_TIMEOUT;
 180         wdd->min_hw_heartbeat_ms = DA9063_RESET_PROTECTION_MS;
 181         wdd->timeout = DA9063_WDG_TIMEOUT;
 182         wdd->parent = &pdev->dev;
 183
 184         wdd->status = WATCHDOG_NOWAYOUT_INIT_STATUS;
 185
 186         watchdog_set_restart_priority(wdd, 128);
 187
 188         watchdog_set_drvdata(wdd, da9063);
 189
 190         return devm_watchdog_register_device(&pdev->dev, wdd);
 191 }
 192
 193 static struct platform_driver da9063_wdt_driver = {
 194         .probe = da9063_wdt_probe,
 195         .driver = {
 196                 .name = DA9063_DRVNAME_WATCHDOG,
 197         },
 198 };
 199 module_platform_driver(da9063_wdt_driver);
 200
 201 MODULE_AUTHOR("Mariusz Wojtasik <mariusz.wojtasik@diasemi.com>");
 202 MODULE_DESCRIPTION("Watchdog driver for Dialog DA9063");
 203 MODULE_LICENSE("GPL");
 204 MODULE_ALIAS("platform:" DA9063_DRVNAME_WATCHDOG);