drivers/watchdog/gpio_wdt.c

   1 /*
   2  * Driver for watchdog device controlled through GPIO-line
   3  *
   4  * Author: 2013, Alexander Shiyan <shc_work@mail.ru>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  */
  11
  12 #include <linux/err.h>
  13 #include <linux/delay.h>
  14 #include <linux/module.h>
  15 #include <linux/notifier.h>
  16 #include <linux/of_gpio.h>
  17 #include <linux/platform_device.h>
  18 #include <linux/reboot.h>
  19 #include <linux/watchdog.h>
  20
  21 #define SOFT_TIMEOUT_MIN        1
  22 #define SOFT_TIMEOUT_DEF        60
  23 #define SOFT_TIMEOUT_MAX        0xffff
  24
  25 enum {
  26         HW_ALGO_TOGGLE,
  27         HW_ALGO_LEVEL,
  28 };
  29
  30 struct gpio_wdt_priv {
  31         int                     gpio;
  32         bool                    active_low;
  33         bool                    state;
  34         unsigned int            hw_algo;
  35         unsigned int            hw_margin;
  36         unsigned long           last_jiffies;
  37         struct notifier_block   notifier;
  38         struct timer_list       timer;
  39         struct watchdog_device  wdd;
  40 };
  41
  42 static void gpio_wdt_disable(struct gpio_wdt_priv *priv)
  43 {
  44         gpio_set_value_cansleep(priv->gpio, !priv->active_low);
  45
  46         /* Put GPIO back to tristate */
  47         if (priv->hw_algo == HW_ALGO_TOGGLE)
  48                 gpio_direction_input(priv->gpio);
  49 }
  50
  51 static int gpio_wdt_start(struct watchdog_device *wdd)
  52 {
  53         struct gpio_wdt_priv *priv = watchdog_get_drvdata(wdd);
  54
  55         priv->state = priv->active_low;
  56         gpio_direction_output(priv->gpio, priv->state);
  57         priv->last_jiffies = jiffies;
  58         mod_timer(&priv->timer, priv->last_jiffies + priv->hw_margin);
  59
  60         return 0;
  61 }
  62
  63 static int gpio_wdt_stop(struct watchdog_device *wdd)
  64 {
  65         struct gpio_wdt_priv *priv = watchdog_get_drvdata(wdd);
  66
  67         mod_timer(&priv->timer, 0);
  68         gpio_wdt_disable(priv);
  69
  70         return 0;
  71 }
  72
  73 static int gpio_wdt_ping(struct watchdog_device *wdd)
  74 {
  75         struct gpio_wdt_priv *priv = watchdog_get_drvdata(wdd);
  76
  77         priv->last_jiffies = jiffies;
  78
  79         return 0;
  80 }
  81
  82 static int gpio_wdt_set_timeout(struct watchdog_device *wdd, unsigned int t)
  83 {
  84         wdd->timeout = t;
  85
  86         return gpio_wdt_ping(wdd);
  87 }
  88
  89 static void gpio_wdt_hwping(unsigned long data)
  90 {
  91         struct watchdog_device *wdd = (struct watchdog_device *)data;
  92         struct gpio_wdt_priv *priv = watchdog_get_drvdata(wdd);
  93
  94         if (time_after(jiffies, priv->last_jiffies +
  95                        msecs_to_jiffies(wdd->timeout * 1000))) {
  96                 dev_crit(wdd->dev, "Timer expired. System will reboot soon!\n");
  97                 return;
  98         }
  99
 100         /* Restart timer */
 101         mod_timer(&priv->timer, jiffies + priv->hw_margin);
 102
 103         switch (priv->hw_algo) {
 104         case HW_ALGO_TOGGLE:
 105                 /* Toggle output pin */
 106                 priv->state = !priv->state;
 107                 gpio_set_value_cansleep(priv->gpio, priv->state);
 108                 break;
 109         case HW_ALGO_LEVEL:
 110                 /* Pulse */
 111                 gpio_set_value_cansleep(priv->gpio, !priv->active_low);
 112                 udelay(1);
 113                 gpio_set_value_cansleep(priv->gpio, priv->active_low);
 114                 break;
 115         }
 116 }
 117
 118 static int gpio_wdt_notify_sys(struct notifier_block *nb, unsigned long code,
 119                                void *unused)
 120 {
 121         struct gpio_wdt_priv *priv = container_of(nb, struct gpio_wdt_priv,
 122                                                   notifier);
 123
 124         mod_timer(&priv->timer, 0);
 125
 126         switch (code) {
 127         case SYS_HALT:
 128         case SYS_POWER_OFF:
 129                 gpio_wdt_disable(priv);
 130                 break;
 131         default:
 132                 break;
 133         }
 134
 135         return NOTIFY_DONE;
 136 }
 137
 138 static const struct watchdog_info gpio_wdt_ident = {
 139         .options        = WDIOF_MAGICCLOSE | WDIOF_KEEPALIVEPING |
 140                           WDIOF_SETTIMEOUT,
 141         .identity       = "GPIO Watchdog",
 142 };
 143
 144 static const struct watchdog_ops gpio_wdt_ops = {
 145         .owner          = THIS_MODULE,
 146         .start          = gpio_wdt_start,
 147         .stop           = gpio_wdt_stop,
 148         .ping           = gpio_wdt_ping,
 149         .set_timeout    = gpio_wdt_set_timeout,
 150 };
 151
 152 static int gpio_wdt_probe(struct platform_device *pdev)
 153 {
 154         struct gpio_wdt_priv *priv;
 155         enum of_gpio_flags flags;
 156         unsigned int hw_margin;
 157         unsigned long f = 0;
 158         const char *algo;
 159         int ret;
 160
 161         priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
 162         if (!priv)
 163                 return -ENOMEM;
 164
 165         priv->gpio = of_get_gpio_flags(pdev->dev.of_node, 0, &flags);
 166         if (!gpio_is_valid(priv->gpio))
 167                 return priv->gpio;
 168
 169         priv->active_low = flags & OF_GPIO_ACTIVE_LOW;
 170
 171         ret = of_property_read_string(pdev->dev.of_node, "hw_algo", &algo);
 172         if (ret)
 173                 return ret;
 174         if (!strncmp(algo, "toggle", 6)) {
 175                 priv->hw_algo = HW_ALGO_TOGGLE;
 176                 f = GPIOF_IN;
 177         } else if (!strncmp(algo, "level", 5)) {
 178                 priv->hw_algo = HW_ALGO_LEVEL;
 179                 f = priv->active_low ? GPIOF_OUT_INIT_HIGH : GPIOF_OUT_INIT_LOW;
 180         } else {
 181                 return -EINVAL;
 182         }
 183
 184         ret = devm_gpio_request_one(&pdev->dev, priv->gpio, f,
 185                                     dev_name(&pdev->dev));
 186         if (ret)
 187                 return ret;
 188
 189         ret = of_property_read_u32(pdev->dev.of_node,
 190                                    "hw_margin_ms", &hw_margin);
 191         if (ret)
 192                 return ret;
 193         /* Disallow values lower than 2 and higher than 65535 ms */
 194         if (hw_margin < 2 || hw_margin > 65535)
 195                 return -EINVAL;
 196
 197         /* Use safe value (1/2 of real timeout) */
 198         priv->hw_margin = msecs_to_jiffies(hw_margin / 2);
 199
 200         watchdog_set_drvdata(&priv->wdd, priv);
 201
 202         priv->wdd.info          = &gpio_wdt_ident;
 203         priv->wdd.ops           = &gpio_wdt_ops;
 204         priv->wdd.min_timeout   = SOFT_TIMEOUT_MIN;
 205         priv->wdd.max_timeout   = SOFT_TIMEOUT_MAX;
 206
 207         if (watchdog_init_timeout(&priv->wdd, 0, &pdev->dev) < 0)
 208                 priv->wdd.timeout = SOFT_TIMEOUT_DEF;
 209
 210         setup_timer(&priv->timer, gpio_wdt_hwping, (unsigned long)&priv->wdd);
 211
 212         ret = watchdog_register_device(&priv->wdd);
 213         if (ret)
 214                 return ret;
 215
 216         priv->notifier.notifier_call = gpio_wdt_notify_sys;
 217         ret = register_reboot_notifier(&priv->notifier);
 218         if (ret)
 219                 watchdog_unregister_device(&priv->wdd);
 220
 221         return ret;
 222 }
 223
 224 static int gpio_wdt_remove(struct platform_device *pdev)
 225 {
 226         struct gpio_wdt_priv *priv = platform_get_drvdata(pdev);
 227
 228         del_timer_sync(&priv->timer);
 229         unregister_reboot_notifier(&priv->notifier);
 230         watchdog_unregister_device(&priv->wdd);
 231
 232         return 0;
 233 }
 234
 235 static const struct of_device_id gpio_wdt_dt_ids[] = {
 236         { .compatible = "linux,wdt-gpio", },
 237         { }
 238 };
 239 MODULE_DEVICE_TABLE(of, gpio_wdt_dt_ids);
 240
 241 static struct platform_driver gpio_wdt_driver = {
 242         .driver = {
 243                 .name           = "gpio-wdt",
 244                 .owner          = THIS_MODULE,
 245                 .of_match_table = gpio_wdt_dt_ids,
 246         },
 247         .probe  = gpio_wdt_probe,
 248         .remove = gpio_wdt_remove,
 249 };
 250 module_platform_driver(gpio_wdt_driver);
 251
 252 MODULE_AUTHOR("Alexander Shiyan <shc_work@mail.ru>");
 253 MODULE_DESCRIPTION("GPIO Watchdog");
 254 MODULE_LICENSE("GPL");