drivers/watchdog/da9063_wdt.c

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