drivers/watchdog/ts4800_wdt.c

   1 /*
   2  * Watchdog driver for TS-4800 based boards
   3  *
   4  * Copyright (c) 2015 - Savoir-faire Linux
   5  *
   6  * This file is licensed under the terms of the GNU General Public
   7  * License version 2. This program is licensed "as is" without any
   8  * warranty of any kind, whether express or implied.
   9  */
  10
  11 #include <linux/kernel.h>
  12 #include <linux/mfd/syscon.h>
  13 #include <linux/module.h>
  14 #include <linux/of.h>
  15 #include <linux/platform_device.h>
  16 #include <linux/regmap.h>
  17 #include <linux/watchdog.h>
  18
  19 static bool nowayout = WATCHDOG_NOWAYOUT;
  20 module_param(nowayout, bool, 0);
  21 MODULE_PARM_DESC(nowayout,
  22         "Watchdog cannot be stopped once started (default="
  23         __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
  24
  25 /* possible feed values */
  26 #define TS4800_WDT_FEED_2S       0x1
  27 #define TS4800_WDT_FEED_10S      0x2
  28 #define TS4800_WDT_DISABLE       0x3
  29
  30 struct ts4800_wdt {
  31         struct watchdog_device  wdd;
  32         struct regmap           *regmap;
  33         u32                     feed_offset;
  34         u32                     feed_val;
  35 };
  36
  37 /*
  38  * TS-4800 supports the following timeout values:
  39  *
  40  *   value desc
  41  *   ---------------------
  42  *     0    feed for 338ms
  43  *     1    feed for 2.706s
  44  *     2    feed for 10.824s
  45  *     3    disable watchdog
  46  *
  47  * Keep the regmap/timeout map ordered by timeout
  48  */
  49 static const struct {
  50         const int timeout;
  51         const int regval;
  52 } ts4800_wdt_map[] = {
  53         { 2,  TS4800_WDT_FEED_2S },
  54         { 10, TS4800_WDT_FEED_10S },
  55 };
  56
  57 #define MAX_TIMEOUT_INDEX       (ARRAY_SIZE(ts4800_wdt_map) - 1)
  58
  59 static void ts4800_write_feed(struct ts4800_wdt *wdt, u32 val)
  60 {
  61         regmap_write(wdt->regmap, wdt->feed_offset, val);
  62 }
  63
  64 static int ts4800_wdt_start(struct watchdog_device *wdd)
  65 {
  66         struct ts4800_wdt *wdt = watchdog_get_drvdata(wdd);
  67
  68         ts4800_write_feed(wdt, wdt->feed_val);
  69         return 0;
  70 }
  71
  72 static int ts4800_wdt_stop(struct watchdog_device *wdd)
  73 {
  74         struct ts4800_wdt *wdt = watchdog_get_drvdata(wdd);
  75
  76         ts4800_write_feed(wdt, TS4800_WDT_DISABLE);
  77         return 0;
  78 }
  79
  80 static int ts4800_wdt_set_timeout(struct watchdog_device *wdd,
  81                                   unsigned int timeout)
  82 {
  83         struct ts4800_wdt *wdt = watchdog_get_drvdata(wdd);
  84         int i;
  85
  86         for (i = 0; i < MAX_TIMEOUT_INDEX; i++) {
  87                 if (ts4800_wdt_map[i].timeout >= timeout)
  88                         break;
  89         }
  90
  91         wdd->timeout = ts4800_wdt_map[i].timeout;
  92         wdt->feed_val = ts4800_wdt_map[i].regval;
  93
  94         return 0;
  95 }
  96
  97 static const struct watchdog_ops ts4800_wdt_ops = {
  98         .owner = THIS_MODULE,
  99         .start = ts4800_wdt_start,
 100         .stop = ts4800_wdt_stop,
 101         .set_timeout = ts4800_wdt_set_timeout,
 102 };
 103
 104 static const struct watchdog_info ts4800_wdt_info = {
 105         .options = WDIOF_SETTIMEOUT | WDIOF_MAGICCLOSE | WDIOF_KEEPALIVEPING,
 106         .identity = "TS-4800 Watchdog",
 107 };
 108
 109 static int ts4800_wdt_probe(struct platform_device *pdev)
 110 {
 111         struct device_node *np = pdev->dev.of_node;
 112         struct device_node *syscon_np;
 113         struct watchdog_device *wdd;
 114         struct ts4800_wdt *wdt;
 115         u32 reg;
 116         int ret;
 117
 118         syscon_np = of_parse_phandle(np, "syscon", 0);
 119         if (!syscon_np) {
 120                 dev_err(&pdev->dev, "no syscon property\n");
 121                 return -ENODEV;
 122         }
 123
 124         ret = of_property_read_u32_index(np, "syscon", 1, &reg);
 125         if (ret < 0) {
 126                 dev_err(&pdev->dev, "no offset in syscon\n");
 127                 return ret;
 128         }
 129
 130         /* allocate memory for watchdog struct */
 131         wdt = devm_kzalloc(&pdev->dev, sizeof(*wdt), GFP_KERNEL);
 132         if (!wdt)
 133                 return -ENOMEM;
 134
 135         /* set regmap and offset to know where to write */
 136         wdt->feed_offset = reg;
 137         wdt->regmap = syscon_node_to_regmap(syscon_np);
 138         if (IS_ERR(wdt->regmap)) {
 139                 dev_err(&pdev->dev, "cannot get parent's regmap\n");
 140                 return PTR_ERR(wdt->regmap);
 141         }
 142
 143         /* Initialize struct watchdog_device */
 144         wdd = &wdt->wdd;
 145         wdd->parent = &pdev->dev;
 146         wdd->info = &ts4800_wdt_info;
 147         wdd->ops = &ts4800_wdt_ops;
 148         wdd->min_timeout = ts4800_wdt_map[0].timeout;
 149         wdd->max_timeout = ts4800_wdt_map[MAX_TIMEOUT_INDEX].timeout;
 150
 151         watchdog_set_drvdata(wdd, wdt);
 152         watchdog_set_nowayout(wdd, nowayout);
 153         watchdog_init_timeout(wdd, 0, &pdev->dev);
 154
 155         /*
 156          * As this watchdog supports only a few values, ts4800_wdt_set_timeout
 157          * must be called to initialize timeout and feed_val with valid values.
 158          * Default to maximum timeout if none, or an invalid one, is provided in
 159          * device tree.
 160          */
 161         if (!wdd->timeout)
 162                 wdd->timeout = wdd->max_timeout;
 163         ts4800_wdt_set_timeout(wdd, wdd->timeout);
 164
 165         /*
 166          * The feed register is write-only, so it is not possible to determine
 167          * watchdog's state. Disable it to be in a known state.
 168          */
 169         ts4800_wdt_stop(wdd);
 170
 171         ret = watchdog_register_device(wdd);
 172         if (ret) {
 173                 dev_err(&pdev->dev,
 174                         "failed to register watchdog device\n");
 175                 return ret;
 176         }
 177
 178         platform_set_drvdata(pdev, wdt);
 179
 180         dev_info(&pdev->dev,
 181                  "initialized (timeout = %d sec, nowayout = %d)\n",
 182                  wdd->timeout, nowayout);
 183
 184         return 0;
 185 }
 186
 187 static int ts4800_wdt_remove(struct platform_device *pdev)
 188 {
 189         struct ts4800_wdt *wdt = platform_get_drvdata(pdev);
 190
 191         watchdog_unregister_device(&wdt->wdd);
 192
 193         return 0;
 194 }
 195
 196 static const struct of_device_id ts4800_wdt_of_match[] = {
 197         { .compatible = "technologic,ts4800-wdt", },
 198         { },
 199 };
 200 MODULE_DEVICE_TABLE(of, ts4800_wdt_of_match);
 201
 202 static struct platform_driver ts4800_wdt_driver = {
 203         .probe          = ts4800_wdt_probe,
 204         .remove         = ts4800_wdt_remove,
 205         .driver         = {
 206                 .name   = "ts4800_wdt",
 207                 .of_match_table = ts4800_wdt_of_match,
 208         },
 209 };
 210
 211 module_platform_driver(ts4800_wdt_driver);
 212
 213 MODULE_AUTHOR("Damien Riegel <damien.riegel@savoirfairelinux.com>");
 214 MODULE_LICENSE("GPL v2");
 215 MODULE_ALIAS("platform:ts4800_wdt");