Skip to contentSkip to conversation

gpio_wdt: Add "always_running" feature to GPIO watchdog

PATCH Superseded Mike Looijmans 3 participants 12 messages Nov 20, 2014 – Feb 3, 2015

Subsystems (2)
lore
Share & tools
lore
#0 lore raw

PATCH 1/1 gpio_wdt: Add "always_running" feature to GPIO watchdog

On some chips, like the TPS386000, the trigger cannot be disabled and the CPU must keep toggling the line at all times. Add a switch "always_running" to keep toggling the GPIO line regardless of the state of the soft part of the watchdog. The "armed" member keeps track of whether a timeout must also cause a reset.

---
 drivers/watchdog/gpio_wdt.c |   20 +++++++++++++++++---
 1 file changed, 17 insertions(+), 3 deletions(-)
drivers/watchdog/gpio_wdt.c +17 -3
index 220a9e0..921ee67 100644
@@ -31,6 +31,8 @@ struct gpio_wdt_priv {
 	int			gpio;
 	bool			active_low;
 	bool			state;
+	bool		always_running;
+	bool		armed;
 	unsigned int		hw_algo;
 	unsigned int		hw_margin;
 	unsigned long		last_jiffies;
@@ -56,6 +58,7 @@ static int gpio_wdt_start(struct watchdog_device *wdd)
 	gpio_direction_output(priv->gpio, priv->state);
 	priv->last_jiffies = jiffies;
 	mod_timer(&priv->timer, priv->last_jiffies + priv->hw_margin);
+	priv->armed = true;
 
 	return 0;
 }
@@ -64,8 +67,11 @@ static int gpio_wdt_stop(struct watchdog_device *wdd)
 {
 	struct gpio_wdt_priv *priv = watchdog_get_drvdata(wdd);
 
-	mod_timer(&priv->timer, 0);
-	gpio_wdt_disable(priv);
+	priv->armed = false;
+	if (!priv->always_running) {
+		mod_timer(&priv->timer, 0);
+		gpio_wdt_disable(priv);
+	}
 
 	return 0;
 }
@@ -91,7 +97,7 @@ static void gpio_wdt_hwping(unsigned long data)
 	struct watchdog_device *wdd = (struct watchdog_device *)data;
 	struct gpio_wdt_priv *priv = watchdog_get_drvdata(wdd);
 
-	if (time_after(jiffies, priv->last_jiffies +
+	if (priv->armed && time_after(jiffies, priv->last_jiffies +
 		       msecs_to_jiffies(wdd->timeout * 1000))) {
 		dev_crit(wdd->dev, "Timer expired. System will reboot soon!\n");
 		return;
@@ -197,6 +203,9 @@ static int gpio_wdt_probe(struct platform_device *pdev)
 	/* Use safe value (1/2 of real timeout) */
 	priv->hw_margin = msecs_to_jiffies(hw_margin / 2);
 
+	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;
@@ -218,6 +227,11 @@ static int gpio_wdt_probe(struct platform_device *pdev)
 	if (ret)
 		watchdog_unregister_device(&priv->wdd);
 
+	if (priv->always_running) {
+		gpio_wdt_start(&priv->wdd);
+		priv->armed = false;
+	}
+
 	return ret;
 }
 
Signature · 1 line
1.7.9.5
maintainer
#1 lore raw
Quoted 56 lines · Mike Looijmans

On some chips, like the TPS386000, the trigger cannot be disabled and the CPU must keep toggling the line at all times. Add a switch "always_running" to keep toggling the GPIO line regardless of the state of the soft part of the watchdog. The "armed" member keeps track of whether a timeout must also cause a reset.

---
 drivers/watchdog/gpio_wdt.c |   20 +++++++++++++++++---
 1 file changed, 17 insertions(+), 3 deletions(-)
drivers/watchdog/gpio_wdt.c +9 -3
index 220a9e0..921ee67 100644
@@ -31,6 +31,8 @@ struct gpio_wdt_priv {
 	int			gpio;
 	bool			active_low;
 	bool			state;
+	bool		always_running;
+	bool		armed;
 	unsigned int		hw_algo;
 	unsigned int		hw_margin;
 	unsigned long		last_jiffies;
@@ -56,6 +58,7 @@ static int gpio_wdt_start(struct watchdog_device *wdd)
 	gpio_direction_output(priv->gpio, priv->state);
 	priv->last_jiffies = jiffies;
 	mod_timer(&priv->timer, priv->last_jiffies + priv->hw_margin);
+	priv->armed = true;
 
 	return 0;
 }
@@ -64,8 +67,11 @@ static int gpio_wdt_stop(struct watchdog_device *wdd)
 {
 	struct gpio_wdt_priv *priv = watchdog_get_drvdata(wdd);
 
-	mod_timer(&priv->timer, 0);
-	gpio_wdt_disable(priv);
+	priv->armed = false;
+	if (!priv->always_running) {
+		mod_timer(&priv->timer, 0);
+		gpio_wdt_disable(priv);
+	}
 
 	return 0;
 }
@@ -91,7 +97,7 @@ static void gpio_wdt_hwping(unsigned long data)
 	struct watchdog_device *wdd = (struct watchdog_device *)data;
 	struct gpio_wdt_priv *priv = watchdog_get_drvdata(wdd);
 
-	if (time_after(jiffies, priv->last_jiffies +
+	if (priv->armed && time_after(jiffies, priv->last_jiffies +
 		       msecs_to_jiffies(wdd->timeout * 1000))) {
 		dev_crit(wdd->dev, "Timer expired. System will reboot soon!\n");
 		return;

drivers/watchdog/gpio_wdt.c static int gpio_wdt_probe(struct platform_device *pdev) · line 207

Quoted 5 lines
drivers/watchdog/gpio_wdt.c +2 -0
@@ -197,6 +203,9 @@ static int gpio_wdt_probe(struct platform_device *pdev)
 	/* Use safe value (1/2 of real timeout) */
 	priv->hw_margin = msecs_to_jiffies(hw_margin / 2);
 
+	priv->always_running = of_property_read_bool(pdev->dev.of_node,
+				"always_running");

That will need to be documented in a devicetree bindings document, and be reviewed by the fdt maintainers. I may be wrong, but I think devicetree properties commonly use '-', not '_'.

Guenter

Quoted 23 lines
drivers/watchdog/gpio_wdt.c +6 -0
+
 	watchdog_set_drvdata(&priv->wdd, priv);
 
 	priv->wdd.info		= &gpio_wdt_ident;
@@ -218,6 +227,11 @@ static int gpio_wdt_probe(struct platform_device *pdev)
 	if (ret)
 		watchdog_unregister_device(&priv->wdd);
 
+	if (priv->always_running) {
+		gpio_wdt_start(&priv->wdd);
+		priv->armed = false;
+	}
+
 	return ret;
 }
 
Signature · 6 lines
1.7.9.5

--
To unsubscribe from this list: send the line "unsubscribe linux-watchdog" in
the body of a message to [email protected]
More majordomo info at  http://vger.kernel.org/majordomo-info.html
#2 lore raw

PATCH v2 1/1 gpio_wdt: Add "always_running" feature to GPIO watchdog

On some chips, like the TPS386000, the trigger cannot be disabled and the CPU must keep toggling the line at all times. Add a switch "always_running" to keep toggling the GPIO line regardless of the state of the soft part of the watchdog. The "armed" member keeps track of whether a timeout must also cause a reset.

---

v2: Rename property "always_running" to "always-running" and add devicetree documentation

 .../devicetree/bindings/watchdog/gpio-wdt.txt      |    5 +++++
 drivers/watchdog/gpio_wdt.c                        |   20 +++++++++++++++++---
 2 files changed, 22 insertions(+), 3 deletions(-)
Documentation/devicetree/bindings/watchdog/gpio-wdt.txt +5 -0
index 37afec1..1987949 100644
@@ -13,6 +13,11 @@ Required Properties:
     by the GPIO flags.
 - hw_margin_ms: Maximum time to reset watchdog circuit (milliseconds).
 
+Optional Properties:
+- always-running: If the watchdog timer cannot be disabled, add this flag to
+  have the driver keep toggling the signal without a client. It will only cease
+  to toggle the signal when the device is open and the timeout elapsed.
+
 Example:
 	watchdog: watchdog {
 		/* ADM706 */
drivers/watchdog/gpio_wdt.c +17 -3
index 220a9e0..3266215 100644
@@ -31,6 +31,8 @@ struct gpio_wdt_priv {
 	int			gpio;
 	bool			active_low;
 	bool			state;
+	bool		always_running;
+	bool		armed;
 	unsigned int		hw_algo;
 	unsigned int		hw_margin;
 	unsigned long		last_jiffies;
@@ -56,6 +58,7 @@ static int gpio_wdt_start(struct watchdog_device *wdd)
 	gpio_direction_output(priv->gpio, priv->state);
 	priv->last_jiffies = jiffies;
 	mod_timer(&priv->timer, priv->last_jiffies + priv->hw_margin);
+	priv->armed = true;
 
 	return 0;
 }
@@ -64,8 +67,11 @@ static int gpio_wdt_stop(struct watchdog_device *wdd)
 {
 	struct gpio_wdt_priv *priv = watchdog_get_drvdata(wdd);
 
-	mod_timer(&priv->timer, 0);
-	gpio_wdt_disable(priv);
+	priv->armed = false;
+	if (!priv->always_running) {
+		mod_timer(&priv->timer, 0);
+		gpio_wdt_disable(priv);
+	}
 
 	return 0;
 }
@@ -91,7 +97,7 @@ static void gpio_wdt_hwping(unsigned long data)
 	struct watchdog_device *wdd = (struct watchdog_device *)data;
 	struct gpio_wdt_priv *priv = watchdog_get_drvdata(wdd);
 
-	if (time_after(jiffies, priv->last_jiffies +
+	if (priv->armed && time_after(jiffies, priv->last_jiffies +
 		       msecs_to_jiffies(wdd->timeout * 1000))) {
 		dev_crit(wdd->dev, "Timer expired. System will reboot soon!\n");
 		return;
@@ -197,6 +203,9 @@ static int gpio_wdt_probe(struct platform_device *pdev)
 	/* Use safe value (1/2 of real timeout) */
 	priv->hw_margin = msecs_to_jiffies(hw_margin / 2);
 
+	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;
@@ -218,6 +227,11 @@ static int gpio_wdt_probe(struct platform_device *pdev)
 	if (ret)
 		watchdog_unregister_device(&priv->wdd);
 
+	if (priv->always_running) {
+		gpio_wdt_start(&priv->wdd);
+		priv->armed = false;
+	}
+
 	return ret;
 }
 
Signature · 1 line
1.7.9.5
maintainer
#3 lore raw
Quoted 37 lines · Mike Looijmans

On some chips, like the TPS386000, the trigger cannot be disabled and the CPU must keep toggling the line at all times. Add a switch "always_running" to keep toggling the GPIO line regardless of the state of the soft part of the watchdog. The "armed" member keeps track of whether a timeout must also cause a reset.

---

v2: Rename property "always_running" to "always-running" and add devicetree documentation

  .../devicetree/bindings/watchdog/gpio-wdt.txt      |    5 +++++
  drivers/watchdog/gpio_wdt.c                        |   20 +++++++++++++++++---
  2 files changed, 22 insertions(+), 3 deletions(-)
Documentation/devicetree/bindings/watchdog/gpio-wdt.txt +5 -0
index 37afec1..1987949 100644
@@ -13,6 +13,11 @@ Required Properties:
      by the GPIO flags.
  - hw_margin_ms: Maximum time to reset watchdog circuit (milliseconds).
 
+Optional Properties:
+- always-running: If the watchdog timer cannot be disabled, add this flag to
+  have the driver keep toggling the signal without a client. It will only cease
+  to toggle the signal when the device is open and the timeout elapsed.
+
  Example:
  	watchdog: watchdog {
  		/* ADM706 */
drivers/watchdog/gpio_wdt.c +0 -0
index 220a9e0..3266215 100644

drivers/watchdog/gpio_wdt.c struct gpio_wdt_priv { · line 35

Quoted 5 lines
drivers/watchdog/gpio_wdt.c +2 -0
@@ -31,6 +31,8 @@ struct gpio_wdt_priv {
  	int			gpio;
  	bool			active_low;
  	bool			state;
+	bool		always_running;
+	bool		armed;

Please align columns with the other variables.

Quoted 26 lines
drivers/watchdog/gpio_wdt.c +6 -2
  	unsigned int		hw_algo;
  	unsigned int		hw_margin;
  	unsigned long		last_jiffies;
@@ -56,6 +58,7 @@ static int gpio_wdt_start(struct watchdog_device *wdd)
  	gpio_direction_output(priv->gpio, priv->state);
  	priv->last_jiffies = jiffies;
  	mod_timer(&priv->timer, priv->last_jiffies + priv->hw_margin);
+	priv->armed = true;
 
  	return 0;
  }
@@ -64,8 +67,11 @@ static int gpio_wdt_stop(struct watchdog_device *wdd)
  {
  	struct gpio_wdt_priv *priv = watchdog_get_drvdata(wdd);
 
-	mod_timer(&priv->timer, 0);
-	gpio_wdt_disable(priv);
+	priv->armed = false;
+	if (!priv->always_running) {
+		mod_timer(&priv->timer, 0);
+		gpio_wdt_disable(priv);
+	}
 
  	return 0;
  }

drivers/watchdog/gpio_wdt.c static void gpio_wdt_hwping(unsigned long data) · line 101

Quoted 6 lines
drivers/watchdog/gpio_wdt.c +1 -1
@@ -91,7 +97,7 @@ static void gpio_wdt_hwping(unsigned long data)
  	struct watchdog_device *wdd = (struct watchdog_device *)data;
  	struct gpio_wdt_priv *priv = watchdog_get_drvdata(wdd);
 
-	if (time_after(jiffies, priv->last_jiffies +
+	if (priv->armed && time_after(jiffies, priv->last_jiffies +
  		       msecs_to_jiffies(wdd->timeout * 1000))) {

Please align continuation lines.

drivers/watchdog/gpio_wdt.c static int gpio_wdt_probe(struct platform_device *pdev) · line 208

Quoted 9 lines
drivers/watchdog/gpio_wdt.c +3 -0
  		dev_crit(wdd->dev, "Timer expired. System will reboot soon!\n");
  		return;
@@ -197,6 +203,9 @@ static int gpio_wdt_probe(struct platform_device *pdev)
  	/* Use safe value (1/2 of real timeout) */
  	priv->hw_margin = msecs_to_jiffies(hw_margin / 2);
 
+	priv->always_running = of_property_read_bool(pdev->dev.of_node,
+				"always-running");
+

Please align continuation line with '('.

drivers/watchdog/gpio_wdt.c static int gpio_wdt_probe(struct platform_device *pdev) · line 234

Quoted 12 lines
drivers/watchdog/gpio_wdt.c +5 -0
  	watchdog_set_drvdata(&priv->wdd, priv);
 
  	priv->wdd.info		= &gpio_wdt_ident;
@@ -218,6 +227,11 @@ static int gpio_wdt_probe(struct platform_device *pdev)
  	if (ret)
  		watchdog_unregister_device(&priv->wdd);
 
+	if (priv->always_running) {
+		gpio_wdt_start(&priv->wdd);
+		priv->armed = false;
+	}
+

This won't work if there is an error. The driver won't load but the timer is started, which will likely cause a crash when the timer fires. You'll have to fix the error handling.

I also dislike that you first set priv->armed in the start function and then reset it, but I don't have a better idea right now.

Guenter

Quoted 4 lines
drivers/watchdog/gpio_wdt.c +0 -0
  	return ret;
  }
 
#4 lore raw
Quoted 78 lines · Guenter Roeck
Quoted 40 lines · Mike Looijmans

On some chips, like the TPS386000, the trigger cannot be disabled and the CPU must keep toggling the line at all times. Add a switch "always_running" to keep toggling the GPIO line regardless of the state of the soft part of the watchdog. The "armed" member keeps track of whether a timeout must also cause a reset.

---

v2: Rename property "always_running" to "always-running" and add devicetree documentation

  .../devicetree/bindings/watchdog/gpio-wdt.txt      |    5 +++++
  drivers/watchdog/gpio_wdt.c                        |   20
+++++++++++++++++---
  2 files changed, 22 insertions(+), 3 deletions(-)
Documentation/devicetree/bindings/watchdog/gpio-wdt.txt +3 -0
index 37afec1..1987949 100644
@@ -13,6 +13,11 @@ Required Properties:
      by the GPIO flags.
  - hw_margin_ms: Maximum time to reset watchdog circuit (milliseconds).
 
+Optional Properties:
+- always-running: If the watchdog timer cannot be disabled, add this flag to
+  have the driver keep toggling the signal without a client. It will only

cease

Documentation/devicetree/bindings/watchdog/gpio-wdt.txt +2 -0
+  to toggle the signal when the device is open and the timeout elapsed.
+
  Example:
      watchdog: watchdog {
          /* ADM706 */
drivers/watchdog/gpio_wdt.c +0 -0
index 220a9e0..3266215 100644

drivers/watchdog/gpio_wdt.c struct gpio_wdt_priv { · line 35

Quoted 5 lines
drivers/watchdog/gpio_wdt.c +2 -0
@@ -31,6 +31,8 @@ struct gpio_wdt_priv {
      int            gpio;
      bool            active_low;
      bool            state;
+    bool        always_running;
+    bool        armed;

Please align columns with the other variables.

Quoted 29 lines
drivers/watchdog/gpio_wdt.c +6 -2
      unsigned int        hw_algo;
      unsigned int        hw_margin;
      unsigned long        last_jiffies;
@@ -56,6 +58,7 @@ static int gpio_wdt_start(struct watchdog_device *wdd)
      gpio_direction_output(priv->gpio, priv->state);
      priv->last_jiffies = jiffies;
      mod_timer(&priv->timer, priv->last_jiffies + priv->hw_margin);
+    priv->armed = true;
 
      return 0;
  }
@@ -64,8 +67,11 @@ static int gpio_wdt_stop(struct watchdog_device *wdd)
  {
      struct gpio_wdt_priv *priv = watchdog_get_drvdata(wdd);
 
-    mod_timer(&priv->timer, 0);
-    gpio_wdt_disable(priv);
+    priv->armed = false;
+    if (!priv->always_running) {
+        mod_timer(&priv->timer, 0);
+        gpio_wdt_disable(priv);
+    }
 
      return 0;
  }
@@ -91,7 +97,7 @@ static void gpio_wdt_hwping(unsigned long data)
      struct watchdog_device *wdd = (struct watchdog_device *)data;
      struct gpio_wdt_priv *priv = watchdog_get_drvdata(wdd);
 
Quoted 5 lines

drivers/watchdog/gpio_wdt.c static void gpio_wdt_hwping(unsigned long data) · line 101

Quoted 3 lines
drivers/watchdog/gpio_wdt.c +1 -1
-    if (time_after(jiffies, priv->last_jiffies +
+    if (priv->armed && time_after(jiffies, priv->last_jiffies +
                 msecs_to_jiffies(wdd->timeout * 1000))) {

Please align continuation lines.

I'm unsure as to how you want them aligned. I thought I adhered to the kernel coding guidelines, but please correct me if I did that wrong.

Quoted 19 lines

drivers/watchdog/gpio_wdt.c static int gpio_wdt_probe(struct platform_device *pdev) · line 208

Quoted 10 lines
drivers/watchdog/gpio_wdt.c +3 -0
          dev_crit(wdd->dev, "Timer expired. System will reboot soon!\n");
          return;
@@ -197,6 +203,9 @@ static int gpio_wdt_probe(struct platform_device *pdev)
      /* Use safe value (1/2 of real timeout) */
      priv->hw_margin = msecs_to_jiffies(hw_margin / 2);
 
+    priv->always_running = of_property_read_bool(pdev->dev.of_node,
+                "always-running");
+

Please align continuation line with '('.

Quoted 7 lines
drivers/watchdog/gpio_wdt.c +0 -0
      watchdog_set_drvdata(&priv->wdd, priv);
 
      priv->wdd.info        = &gpio_wdt_ident;
@@ -218,6 +227,11 @@ static int gpio_wdt_probe(struct platform_device *pdev)
      if (ret)
          watchdog_unregister_device(&priv->wdd);
 
Quoted 9 lines

drivers/watchdog/gpio_wdt.c static int gpio_wdt_probe(struct platform_device *pdev) · line 234

Quoted 5 lines
drivers/watchdog/gpio_wdt.c +5 -0
+    if (priv->always_running) {
+        gpio_wdt_start(&priv->wdd);
+        priv->armed = false;
+    }
+

This won't work if there is an error. The driver won't load but the timer is started, which will likely cause a crash when the timer fires. You'll have to fix the error handling.

If you have an "always-running" gpio watchdog and this fails, the error handling is going to be the least of your problems (the board I use this patch on will power down if you don't toggle the pin every 400ms after POR).

But you're absolutely right, I missed the error handling path here.

An alternative approach would be to make failure to register the notifier a
warning only. It seems harsh to me to let the system commit suicide just because the shutdown notification didn't register. On the other hand, the notification registration should never fail anyway (out-of-memory will result in system failure soon enough).

Quoted 2 lines

I also dislike that you first set priv->armed in the start function and then reset it, but I don't have a better idea right now.

I just relied on the compiler's optimizer to remove the first assignment.

Alternative would be to split the start function into two parts, where the "armed" assignment is omitted from the upper part and call the upper part from probe only.

Quoted 8 lines

Guenter

Quoted 4 lines
drivers/watchdog/gpio_wdt.c +0 -0
      return ret;
  }
 

Met vriendelijke groet / kind regards,

Mike Looijmans
System Expert

TOPIC Embedded Systems
Eindhovenseweg 32-C, NL-5683 KH Best
Postbus 440, NL-5680 AK Best
Telefoon: (+31) (0) 499 33 69 79
Telefax: (+31) (0) 499 33 69 70
E-mail: [email protected]
Website: www.topic.nl

Please consider the environment before printing this e-mail

Visit us at Bits & Chips Smart Systems 20th November, 1931 Congrescentum Brabanthallen 's-Hertogenbosch, stand number 34
http://bc-smartsystems.nl

#5 lore raw

PATCH v3 1/1 gpio_wdt: Add "always_running" feature to GPIO watchdog

In reply to Guenter Roeck

On some chips, like the TPS386000, the trigger cannot be disabled and the CPU must keep toggling the line at all times. Add a switch "always_running" to keep toggling the GPIO line regardless of the state of the soft part of the watchdog. The "armed" member keeps track of whether a timeout must also cause a reset.

---
v3: Indentation adjusted to match
Fix error path in probe when notification registration fails Prevent double assignment of "armed" variable

 .../devicetree/bindings/watchdog/gpio-wdt.txt      |    5 +++
 drivers/watchdog/gpio_wdt.c                        |   39 ++++++++++++++++----
 2 files changed, 36 insertions(+), 8 deletions(-)
Documentation/devicetree/bindings/watchdog/gpio-wdt.txt +5 -0
index 37afec1..1987949 100644
@@ -13,6 +13,11 @@ Required Properties:
     by the GPIO flags.
 - hw_margin_ms: Maximum time to reset watchdog circuit (milliseconds).
 
+Optional Properties:
+- always-running: If the watchdog timer cannot be disabled, add this flag to
+  have the driver keep toggling the signal without a client. It will only cease
+  to toggle the signal when the device is open and the timeout elapsed.
+
 Example:
 	watchdog: watchdog {
 		/* ADM706 */
drivers/watchdog/gpio_wdt.c +31 -8
index 220a9e0..9bfbd73 100644
@@ -31,6 +31,8 @@ struct gpio_wdt_priv {
 	int			gpio;
 	bool			active_low;
 	bool			state;
+	bool			always_running;
+	bool			armed;
 	unsigned int		hw_algo;
 	unsigned int		hw_margin;
 	unsigned long		last_jiffies;
@@ -48,10 +50,8 @@ static void gpio_wdt_disable(struct gpio_wdt_priv *priv)
 		gpio_direction_input(priv->gpio);
 }
 
-static int gpio_wdt_start(struct watchdog_device *wdd)
+static void gpio_wdt_start_impl(struct gpio_wdt_priv *priv)
 {
-	struct gpio_wdt_priv *priv = watchdog_get_drvdata(wdd);
-
 	priv->state = priv->active_low;
 	gpio_direction_output(priv->gpio, priv->state);
 	priv->last_jiffies = jiffies;
@@ -60,12 +60,25 @@ static int gpio_wdt_start(struct watchdog_device *wdd)
 	return 0;
 }
 
+static int gpio_wdt_start(struct watchdog_device *wdd)
+{
+	struct gpio_wdt_priv *priv = watchdog_get_drvdata(wdd);
+
+	gpio_wdt_start_impl(priv);
+	priv->armed = true;
+
+	return 0;
+}
+
 static int gpio_wdt_stop(struct watchdog_device *wdd)
 {
 	struct gpio_wdt_priv *priv = watchdog_get_drvdata(wdd);
 
-	mod_timer(&priv->timer, 0);
-	gpio_wdt_disable(priv);
+	priv->armed = false;
+	if (!priv->always_running) {
+		mod_timer(&priv->timer, 0);
+		gpio_wdt_disable(priv);
+	}
 
 	return 0;
 }
@@ -91,8 +104,8 @@ static void gpio_wdt_hwping(unsigned long data)
 	struct watchdog_device *wdd = (struct watchdog_device *)data;
 	struct gpio_wdt_priv *priv = watchdog_get_drvdata(wdd);
 
-	if (time_after(jiffies, priv->last_jiffies +
-		       msecs_to_jiffies(wdd->timeout * 1000))) {
+	if (priv->armed && time_after(jiffies, priv->last_jiffies +
+				      msecs_to_jiffies(wdd->timeout * 1000))) {
 		dev_crit(wdd->dev, "Timer expired. System will reboot soon!\n");
 		return;
 	}
@@ -197,6 +210,9 @@ static int gpio_wdt_probe(struct platform_device *pdev)
 	/* Use safe value (1/2 of real timeout) */
 	priv->hw_margin = msecs_to_jiffies(hw_margin / 2);
 
+	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;
@@ -216,8 +232,15 @@ static int gpio_wdt_probe(struct platform_device *pdev)
 	priv->notifier.notifier_call = gpio_wdt_notify_sys;
 	ret = register_reboot_notifier(&priv->notifier);
 	if (ret)
-		watchdog_unregister_device(&priv->wdd);
+		goto error_unregister;
 
+	if (priv->always_running)
+		gpio_wdt_start_impl(priv);
+
+	return 0;
+
+error_unregister:
+	watchdog_unregister_device(&priv->wdd);
 	return ret;
 }
 
Signature · 1 line
1.7.9.5
#6 lore raw

Is this v3 patch okay or are you waiting for additional changes?

Kind regards,
Mike.

Quoted 114 lines · Mike Looijmans

On some chips, like the TPS386000, the trigger cannot be disabled and the CPU must keep toggling the line at all times. Add a switch "always_running" to keep toggling the GPIO line regardless of the state of the soft part of the watchdog. The "armed" member keeps track of whether a timeout must also cause a reset.

---
v3: Indentation adjusted to match
Fix error path in probe when notification registration fails Prevent double assignment of "armed" variable

  .../devicetree/bindings/watchdog/gpio-wdt.txt      |    5 +++
  drivers/watchdog/gpio_wdt.c                        |   39 ++++++++++++++++----
  2 files changed, 36 insertions(+), 8 deletions(-)
Documentation/devicetree/bindings/watchdog/gpio-wdt.txt +5 -0
index 37afec1..1987949 100644
@@ -13,6 +13,11 @@ Required Properties:
      by the GPIO flags.
  - hw_margin_ms: Maximum time to reset watchdog circuit (milliseconds).
 
+Optional Properties:
+- always-running: If the watchdog timer cannot be disabled, add this flag to
+  have the driver keep toggling the signal without a client. It will only cease
+  to toggle the signal when the device is open and the timeout elapsed.
+
  Example:
  	watchdog: watchdog {
  		/* ADM706 */
drivers/watchdog/gpio_wdt.c +24 -8
index 220a9e0..9bfbd73 100644
@@ -31,6 +31,8 @@ struct gpio_wdt_priv {
  	int			gpio;
  	bool			active_low;
  	bool			state;
+	bool			always_running;
+	bool			armed;
  	unsigned int		hw_algo;
  	unsigned int		hw_margin;
  	unsigned long		last_jiffies;
@@ -48,10 +50,8 @@ static void gpio_wdt_disable(struct gpio_wdt_priv *priv)
  		gpio_direction_input(priv->gpio);
  }
 
-static int gpio_wdt_start(struct watchdog_device *wdd)
+static void gpio_wdt_start_impl(struct gpio_wdt_priv *priv)
  {
-	struct gpio_wdt_priv *priv = watchdog_get_drvdata(wdd);
-
  	priv->state = priv->active_low;
  	gpio_direction_output(priv->gpio, priv->state);
  	priv->last_jiffies = jiffies;
@@ -60,12 +60,25 @@ static int gpio_wdt_start(struct watchdog_device *wdd)
  	return 0;
  }
 
+static int gpio_wdt_start(struct watchdog_device *wdd)
+{
+	struct gpio_wdt_priv *priv = watchdog_get_drvdata(wdd);
+
+	gpio_wdt_start_impl(priv);
+	priv->armed = true;
+
+	return 0;
+}
+
  static int gpio_wdt_stop(struct watchdog_device *wdd)
  {
  	struct gpio_wdt_priv *priv = watchdog_get_drvdata(wdd);
 
-	mod_timer(&priv->timer, 0);
-	gpio_wdt_disable(priv);
+	priv->armed = false;
+	if (!priv->always_running) {
+		mod_timer(&priv->timer, 0);
+		gpio_wdt_disable(priv);
+	}
 
  	return 0;
  }
@@ -91,8 +104,8 @@ static void gpio_wdt_hwping(unsigned long data)
  	struct watchdog_device *wdd = (struct watchdog_device *)data;
  	struct gpio_wdt_priv *priv = watchdog_get_drvdata(wdd);
 
-	if (time_after(jiffies, priv->last_jiffies +
-		       msecs_to_jiffies(wdd->timeout * 1000))) {
+	if (priv->armed && time_after(jiffies, priv->last_jiffies +
+				      msecs_to_jiffies(wdd->timeout * 1000))) {
  		dev_crit(wdd->dev, "Timer expired. System will reboot soon!\n");
  		return;
  	}
@@ -197,6 +210,9 @@ static int gpio_wdt_probe(struct platform_device *pdev)
  	/* Use safe value (1/2 of real timeout) */
  	priv->hw_margin = msecs_to_jiffies(hw_margin / 2);
 
+	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;
@@ -216,8 +232,15 @@ static int gpio_wdt_probe(struct platform_device *pdev)
  	priv->notifier.notifier_call = gpio_wdt_notify_sys;
  	ret = register_reboot_notifier(&priv->notifier);
  	if (ret)
-		watchdog_unregister_device(&priv->wdd);
+		goto error_unregister;
 

drivers/watchdog/gpio_wdt.c static int gpio_wdt_probe(struct platform_device *pdev) · line 246

Quoted 10 lines
drivers/watchdog/gpio_wdt.c +7 -0
+	if (priv->always_running)
+		gpio_wdt_start_impl(priv);
+
+	return 0;
+
+error_unregister:
+	watchdog_unregister_device(&priv->wdd);
  	return ret;
  }
 

Met vriendelijke groet / kind regards,

Mike Looijmans
System Expert

TOPIC Embedded Systems Eindhovenseweg 32-C, NL-5683 KH Best Postbus 440, NL-5680 AK Best
Telefoon: (+31) (0) 499 33 69 79
Telefax: (+31) (0) 499 33 69 70
E-mail: [email protected]
Website: www.topic.nl

Please consider the environment before printing this e-mail

Topic zoekt gedreven (embedded) software specialisten!
http://topic.nl/vacatures/topic-zoekt-software-engineers/

maintainer Reviewed-by on v3 1/1
#7 lore raw
In reply to Mike Looijmans
Quoted 7 lines · Mike Looijmans

On some chips, like the TPS386000, the trigger cannot be disabled and the CPU must keep toggling the line at all times. Add a switch "always_running" to keep toggling the GPIO line regardless of the state of the soft part of the watchdog. The "armed" member keeps track of whether a timeout must also cause a reset.

maintainer
#8 lore raw
In reply to Mike Looijmans
Quoted 8 lines · Mike Looijmans

On some chips, like the TPS386000, the trigger cannot be disabled and the CPU must keep toggling the line at all times. Add a switch "always_running" to keep toggling the GPIO line regardless of the state of the soft part of the watchdog. The "armed" member keeps track of whether a timeout must also cause a reset.

---

Actially, my reviewed-by: was to early. See below.

Quoted 38 lines

v3: Indentation adjusted to match
Fix error path in probe when notification registration fails Prevent double assignment of "armed" variable

 .../devicetree/bindings/watchdog/gpio-wdt.txt      |    5 +++
 drivers/watchdog/gpio_wdt.c                        |   39 ++++++++++++++++----
 2 files changed, 36 insertions(+), 8 deletions(-)
Documentation/devicetree/bindings/watchdog/gpio-wdt.txt +5 -0
index 37afec1..1987949 100644
@@ -13,6 +13,11 @@ Required Properties:
     by the GPIO flags.
 - hw_margin_ms: Maximum time to reset watchdog circuit (milliseconds).
 
+Optional Properties:
+- always-running: If the watchdog timer cannot be disabled, add this flag to
+  have the driver keep toggling the signal without a client. It will only cease
+  to toggle the signal when the device is open and the timeout elapsed.
+
 Example:
 	watchdog: watchdog {
 		/* ADM706 */
drivers/watchdog/gpio_wdt.c +2 -0
index 220a9e0..9bfbd73 100644
@@ -31,6 +31,8 @@ struct gpio_wdt_priv {
 	int			gpio;
 	bool			active_low;
 	bool			state;
+	bool			always_running;
+	bool			armed;
 	unsigned int		hw_algo;
 	unsigned int		hw_margin;
 	unsigned long		last_jiffies;

drivers/watchdog/gpio_wdt.c static void gpio_wdt_disable(struct gpio_wdt_priv *priv) · line 53

Quoted 5 lines
drivers/watchdog/gpio_wdt.c +1 -1
@@ -48,10 +50,8 @@ static void gpio_wdt_disable(struct gpio_wdt_priv *priv)
 		gpio_direction_input(priv->gpio);
 }
 
-static int gpio_wdt_start(struct watchdog_device *wdd)
+static void gpio_wdt_start_impl(struct gpio_wdt_priv *priv)

This function is now void but still has a return value.

Guenter

#9 lore raw

PATCH v4 1/1 gpio_wdt: Add "always_running" feature to GPIO watchdog

On some chips, like the TPS386000, the trigger cannot be disabled and the CPU must keep toggling the line at all times. Add a switch "always_running" to keep toggling the GPIO line regardless of the state of the soft part of the watchdog. The "armed" member keeps track of whether a timeout must also cause a reset.

---
v4: Fix 'return' with a value, in function returning void

 .../devicetree/bindings/watchdog/gpio-wdt.txt      |    5 +++
 drivers/watchdog/gpio_wdt.c                        |   37 +++++++++++++++-----
 2 files changed, 34 insertions(+), 8 deletions(-)
Documentation/devicetree/bindings/watchdog/gpio-wdt.txt +5 -0
index 37afec1..1987949 100644
@@ -13,6 +13,11 @@ Required Properties:
     by the GPIO flags.
 - hw_margin_ms: Maximum time to reset watchdog circuit (milliseconds).
 
+Optional Properties:
+- always-running: If the watchdog timer cannot be disabled, add this flag to
+  have the driver keep toggling the signal without a client. It will only cease
+  to toggle the signal when the device is open and the timeout elapsed.
+
 Example:
 	watchdog: watchdog {
 		/* ADM706 */
drivers/watchdog/gpio_wdt.c +29 -8
index 220a9e0..51acda6 100644
@@ -31,6 +31,8 @@ struct gpio_wdt_priv {
 	int			gpio;
 	bool			active_low;
 	bool			state;
+	bool			always_running;
+	bool			armed;
 	unsigned int		hw_algo;
 	unsigned int		hw_margin;
 	unsigned long		last_jiffies;
@@ -48,14 +50,20 @@ static void gpio_wdt_disable(struct gpio_wdt_priv *priv)
 		gpio_direction_input(priv->gpio);
 }
 
-static int gpio_wdt_start(struct watchdog_device *wdd)
+static void gpio_wdt_start_impl(struct gpio_wdt_priv *priv)
 {
-	struct gpio_wdt_priv *priv = watchdog_get_drvdata(wdd);
-
 	priv->state = priv->active_low;
 	gpio_direction_output(priv->gpio, priv->state);
 	priv->last_jiffies = jiffies;
 	mod_timer(&priv->timer, priv->last_jiffies + priv->hw_margin);
+}
+
+static int gpio_wdt_start(struct watchdog_device *wdd)
+{
+	struct gpio_wdt_priv *priv = watchdog_get_drvdata(wdd);
+
+	gpio_wdt_start_impl(priv);
+	priv->armed = true;
 
 	return 0;
 }
@@ -64,8 +72,11 @@ static int gpio_wdt_stop(struct watchdog_device *wdd)
 {
 	struct gpio_wdt_priv *priv = watchdog_get_drvdata(wdd);
 
-	mod_timer(&priv->timer, 0);
-	gpio_wdt_disable(priv);
+	priv->armed = false;
+	if (!priv->always_running) {
+		mod_timer(&priv->timer, 0);
+		gpio_wdt_disable(priv);
+	}
 
 	return 0;
 }
@@ -91,8 +102,8 @@ static void gpio_wdt_hwping(unsigned long data)
 	struct watchdog_device *wdd = (struct watchdog_device *)data;
 	struct gpio_wdt_priv *priv = watchdog_get_drvdata(wdd);
 
-	if (time_after(jiffies, priv->last_jiffies +
-		       msecs_to_jiffies(wdd->timeout * 1000))) {
+	if (priv->armed && time_after(jiffies, priv->last_jiffies +
+				      msecs_to_jiffies(wdd->timeout * 1000))) {
 		dev_crit(wdd->dev, "Timer expired. System will reboot soon!\n");
 		return;
 	}
@@ -197,6 +208,9 @@ static int gpio_wdt_probe(struct platform_device *pdev)
 	/* Use safe value (1/2 of real timeout) */
 	priv->hw_margin = msecs_to_jiffies(hw_margin / 2);
 
+	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;
@@ -216,8 +230,15 @@ static int gpio_wdt_probe(struct platform_device *pdev)
 	priv->notifier.notifier_call = gpio_wdt_notify_sys;
 	ret = register_reboot_notifier(&priv->notifier);
 	if (ret)
-		watchdog_unregister_device(&priv->wdd);
+		goto error_unregister;
 
+	if (priv->always_running)
+		gpio_wdt_start_impl(priv);
+
+	return 0;
+
+error_unregister:
+	watchdog_unregister_device(&priv->wdd);
 	return ret;
 }
 
Signature · 1 line
1.7.9.5
maintainer Reviewed-by on v4 1/1
#10 lore raw
Quoted 7 lines · Mike Looijmans

On some chips, like the TPS386000, the trigger cannot be disabled and the CPU must keep toggling the line at all times. Add a switch "always_running" to keep toggling the GPIO line regardless of the state of the soft part of the watchdog. The "armed" member keeps track of whether a timeout must also cause a reset.

#11 lore raw
In reply to Mike Looijmans

Hi Mike,

Quoted 7 lines

On some chips, like the TPS386000, the trigger cannot be disabled and the CPU must keep toggling the line at all times. Add a switch "always_running" to keep toggling the GPIO line regardless of the state of the soft part of the watchdog. The "armed" member keeps track of whether a timeout must also cause a reset.

Patch has been added to linux-watchdog-next.

Kind regards,
Wim.