Release 4.14 drivers/watchdog/gpio_wdt.c
/*
* Driver for watchdog device controlled through GPIO-line
*
* Author: 2013, Alexander Shiyan <shc_work@mail.ru>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*/
#include <linux/err.h>
#include <linux/delay.h>
#include <linux/module.h>
#include <linux/of_gpio.h>
#include <linux/platform_device.h>
#include <linux/watchdog.h>
#define SOFT_TIMEOUT_MIN 1
#define SOFT_TIMEOUT_DEF 60
enum {
HW_ALGO_TOGGLE,
HW_ALGO_LEVEL,
};
struct gpio_wdt_priv {
int gpio;
bool active_low;
bool state;
bool always_running;
unsigned int hw_algo;
struct watchdog_device wdd;
};
static void gpio_wdt_disable(struct gpio_wdt_priv *priv)
{
gpio_set_value_cansleep(priv->gpio, !priv->active_low);
/* Put GPIO back to tristate */
if (priv->hw_algo == HW_ALGO_TOGGLE)
gpio_direction_input(priv->gpio);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Alexander Shiyan | 39 | 100.00% | 1 | 100.00% |
| Total | 39 | 100.00% | 1 | 100.00% |
static int gpio_wdt_ping(struct watchdog_device *wdd)
{
struct gpio_wdt_priv *priv = watchdog_get_drvdata(wdd);
switch (priv->hw_algo) {
case HW_ALGO_TOGGLE:
/* Toggle output pin */
priv->state = !priv->state;
gpio_set_value_cansleep(priv->gpio, priv->state);
break;
case HW_ALGO_LEVEL:
/* Pulse */
gpio_set_value_cansleep(priv->gpio, !priv->active_low);
udelay(1);
gpio_set_value_cansleep(priv->gpio, priv->active_low);
break;
}
return 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Uwe Kleine-König | 83 | 92.22% | 1 | 50.00% |
| Guenter Roeck | 7 | 7.78% | 1 | 50.00% |
| Total | 90 | 100.00% | 2 | 100.00% |
static int gpio_wdt_start(struct watchdog_device *wdd)
{
struct gpio_wdt_priv *priv = watchdog_get_drvdata(wdd);
priv->state = priv->active_low;
gpio_direction_output(priv->gpio, priv->state);
set_bit(WDOG_HW_RUNNING, &wdd->status);
return gpio_wdt_ping(wdd);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Alexander Shiyan | 29 | 51.79% | 1 | 25.00% |
| Guenter Roeck | 21 | 37.50% | 1 | 25.00% |
| Mike Looijmans | 5 | 8.93% | 1 | 25.00% |
| Uwe Kleine-König | 1 | 1.79% | 1 | 25.00% |
| Total | 56 | 100.00% | 4 | 100.00% |
static int gpio_wdt_stop(struct watchdog_device *wdd)
{
struct gpio_wdt_priv *priv = watchdog_get_drvdata(wdd);
if (!priv->always_running) {
gpio_wdt_disable(priv);
clear_bit(WDOG_HW_RUNNING, &wdd->status);
}
return 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Alexander Shiyan | 33 | 68.75% | 1 | 33.33% |
| Mike Looijmans | 8 | 16.67% | 1 | 33.33% |
| Guenter Roeck | 7 | 14.58% | 1 | 33.33% |
| Total | 48 | 100.00% | 3 | 100.00% |
static const struct watchdog_info gpio_wdt_ident = {
.options = WDIOF_MAGICCLOSE | WDIOF_KEEPALIVEPING |
WDIOF_SETTIMEOUT,
.identity = "GPIO Watchdog",
};
static const struct watchdog_ops gpio_wdt_ops = {
.owner = THIS_MODULE,
.start = gpio_wdt_start,
.stop = gpio_wdt_stop,
.ping = gpio_wdt_ping,
};
static int gpio_wdt_probe(struct platform_device *pdev)
{
struct gpio_wdt_priv *priv;
enum of_gpio_flags flags;
unsigned int hw_margin;
unsigned long f = 0;
const char *algo;
int ret;
priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
if (!priv)
return -ENOMEM;
platform_set_drvdata(pdev, priv);
priv->gpio = of_get_gpio_flags(pdev->dev.of_node, 0, &flags);
if (!gpio_is_valid(priv->gpio))
return priv->gpio;
priv->active_low = flags & OF_GPIO_ACTIVE_LOW;
ret = of_property_read_string(pdev->dev.of_node, "hw_algo", &algo);
if (ret)
return ret;
if (!strcmp(algo, "toggle")) {
priv->hw_algo = HW_ALGO_TOGGLE;
f = GPIOF_IN;
} else if (!strcmp(algo, "level")) {
priv->hw_algo = HW_ALGO_LEVEL;
f = priv->active_low ? GPIOF_OUT_INIT_HIGH : GPIOF_OUT_INIT_LOW;
} else {
return -EINVAL;
}
ret = devm_gpio_request_one(&pdev->dev, priv->gpio, f,
dev_name(&pdev->dev));
if (ret)
return ret;
ret = of_property_read_u32(pdev->dev.of_node,
"hw_margin_ms", &hw_margin);
if (ret)
return ret;
/* Disallow values lower than 2 and higher than 65535 ms */
if (hw_margin < 2 || hw_margin > 65535)
return -EINVAL;
priv->always_running = of_property_read_bool(pdev->dev.of_node,
"always-running");
watchdog_set_drvdata(&priv->wdd, priv);
priv->wdd.info = &gpio_wdt_ident;
priv->wdd.ops = &gpio_wdt_ops;
priv->wdd.min_timeout = SOFT_TIMEOUT_MIN;
priv->wdd.max_hw_heartbeat_ms = hw_margin;
priv->wdd.parent = &pdev->dev;
if (watchdog_init_timeout(&priv->wdd, 0, &pdev->dev) < 0)
priv->wdd.timeout = SOFT_TIMEOUT_DEF;
watchdog_stop_on_reboot(&priv->wdd);
if (priv->always_running)
gpio_wdt_start(&priv->wdd);
ret = watchdog_register_device(&priv->wdd);
return ret;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Alexander Shiyan | 345 | 87.34% | 1 | 14.29% |
| Mike Looijmans | 15 | 3.80% | 1 | 14.29% |
| Pratyush Anand | 11 | 2.78% | 1 | 14.29% |
| Guenter Roeck | 10 | 2.53% | 1 | 14.29% |
| Wei Yongjun | 7 | 1.77% | 1 | 14.29% |
| Damien Riegel | 5 | 1.27% | 1 | 14.29% |
| Uwe Kleine-König | 2 | 0.51% | 1 | 14.29% |
| Total | 395 | 100.00% | 7 | 100.00% |
static int gpio_wdt_remove(struct platform_device *pdev)
{
struct gpio_wdt_priv *priv = platform_get_drvdata(pdev);
watchdog_unregister_device(&priv->wdd);
return 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Alexander Shiyan | 32 | 100.00% | 1 | 100.00% |
| Total | 32 | 100.00% | 1 | 100.00% |
static const struct of_device_id gpio_wdt_dt_ids[] = {
{ .compatible = "linux,wdt-gpio", },
{ }
};
MODULE_DEVICE_TABLE(of, gpio_wdt_dt_ids);
static struct platform_driver gpio_wdt_driver = {
.driver = {
.name = "gpio-wdt",
.of_match_table = gpio_wdt_dt_ids,
},
.probe = gpio_wdt_probe,
.remove = gpio_wdt_remove,
};
#ifdef CONFIG_GPIO_WATCHDOG_ARCH_INITCALL
static int __init gpio_wdt_init(void)
{
return platform_driver_register(&gpio_wdt_driver);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Jean-Baptiste Theou | 16 | 100.00% | 1 | 100.00% |
| Total | 16 | 100.00% | 1 | 100.00% |
arch_initcall(gpio_wdt_init);
#else
module_platform_driver(gpio_wdt_driver);
#endif
MODULE_AUTHOR("Alexander Shiyan <shc_work@mail.ru>");
MODULE_DESCRIPTION("GPIO Watchdog");
MODULE_LICENSE("GPL");
Overall Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Alexander Shiyan | 661 | 75.63% | 1 | 11.11% |
| Uwe Kleine-König | 86 | 9.84% | 2 | 22.22% |
| Guenter Roeck | 45 | 5.15% | 1 | 11.11% |
| Mike Looijmans | 31 | 3.55% | 1 | 11.11% |
| Jean-Baptiste Theou | 28 | 3.20% | 1 | 11.11% |
| Pratyush Anand | 11 | 1.26% | 1 | 11.11% |
| Wei Yongjun | 7 | 0.80% | 1 | 11.11% |
| Damien Riegel | 5 | 0.57% | 1 | 11.11% |
| Total | 874 | 100.00% | 9 | 100.00% |
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.