Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]

Groups > linux.kernel > #1200555 > unrolled thread

[PATCH v3 1/2] drivers: watchdog: add a driver to support SAMA5D4 watchdog timer

Back to article view | Back to linux.kernel

This discussion starts older than the indexed window; earlier articles aren't shown. The article labeled Started by below is the oldest one visible, not the original post.

Contents

  [PATCH v3 1/2] drivers: watchdog: add a driver to support SAMA5D4 watchdog timer Wenyou Yang <wenyou.yang@atmel.com> - 2015-08-05 11:10 +0200
    Re: [PATCH v3 1/2] drivers: watchdog: add a driver to support  SAMA5D4 watchdog timer Lothar Waßmann <LW@KARO-electronics.de> - 2015-08-05 13:00 +0200
      RE: [PATCH v3 1/2] drivers: watchdog: add a driver to support  SAMA5D4 watchdog timer "Yang, Wenyou" <Wenyou.Yang@atmel.com> - 2015-08-06 04:10 +0200
    Re: [PATCH v3 1/2] drivers: watchdog: add a driver to support SAMA5D4  watchdog timer Guenter Roeck <linux@roeck-us.net> - 2015-08-05 17:10 +0200
      RE: [PATCH v3 1/2] drivers: watchdog: add a driver to support  SAMA5D4 watchdog timer "Yang, Wenyou" <Wenyou.Yang@atmel.com> - 2015-08-06 04:20 +0200

#1200555 — [PATCH v3 1/2] drivers: watchdog: add a driver to support SAMA5D4 watchdog timer

From SAMA5D4, the watchdog timer is upgrated with a new feature,
which is describled as in the datasheet, "WDT_MR can be written
until a LOCKMR command is issued in WDT_CR".
That is to say, as long as the bootstrap and u-boot don't issue
a LOCKMR command, WDT_MR can be written more than once in the driver.

So the SAMA5D4 watchdog driver's implementation is different from
the at91sam9260 watchdog driver implemented in file at91sam9_wdt.c.
The user application open the device file to enable the watchdog timer
hardware, and close to disable it, and set the watchdog timer timeout
by seting WDV and WDD fields of WDT_MR register, and ping the watchdog
by issuing WDRSTT command to WDT_CR register with hard-coded key.

Signed-off-by: Wenyou Yang <wenyou.yang@atmel.com>
---
 drivers/watchdog/Kconfig            |    9 ++
 drivers/watchdog/Makefile           |    1 +
 drivers/watchdog/at91_sama5d4_wdt.c |  279 +++++++++++++++++++++++++++++++++++
 drivers/watchdog/at91sam9_wdt.h     |    2 +
 4 files changed, 291 insertions(+)
 create mode 100644 drivers/watchdog/at91_sama5d4_wdt.c

diff --git a/drivers/watchdog/Kconfig b/drivers/watchdog/Kconfig
index e5e7c55..4ce8346 100644
--- a/drivers/watchdog/Kconfig
+++ b/drivers/watchdog/Kconfig
@@ -152,6 +152,15 @@ config ARM_SP805_WATCHDOG
 	  ARM Primecell SP805 Watchdog timer. This will reboot your system when
 	  the timeout is reached.
 
+config AT91_SAMA5D4_WATCHDOG
+	tristate "Atmel SAMA5D4 Watchdog Timer"
+	depends on ARCH_AT91
+	select WATCHDOG_CORE
+	help
+	  Atmel SAMA5D4 watchdog timer is embedded into SAMA5D4 chips.
+	  Its Watchdog Timer Mode Register can be written more than once.
+	  This will reboot your system when the timeout is reached.
+
 config AT91RM9200_WATCHDOG
 	tristate "AT91RM9200 watchdog"
 	depends on SOC_AT91RM9200 && MFD_SYSCON
diff --git a/drivers/watchdog/Makefile b/drivers/watchdog/Makefile
index 5c19294..c57569c 100644
--- a/drivers/watchdog/Makefile
+++ b/drivers/watchdog/Makefile
@@ -30,6 +30,7 @@ obj-$(CONFIG_USBPCWATCHDOG) += pcwd_usb.o
 
 # ARM Architecture
 obj-$(CONFIG_ARM_SP805_WATCHDOG) += sp805_wdt.o
+obj-$(CONFIG_AT91_SAMA5D4_WATCHDOG) += at91_sama5d4_wdt.o
 obj-$(CONFIG_AT91RM9200_WATCHDOG) += at91rm9200_wdt.o
 obj-$(CONFIG_AT91SAM9X_WATCHDOG) += at91sam9_wdt.o
 obj-$(CONFIG_CADENCE_WATCHDOG) += cadence_wdt.o
diff --git a/drivers/watchdog/at91_sama5d4_wdt.c b/drivers/watchdog/at91_sama5d4_wdt.c
new file mode 100644
index 0000000..f2e1995
--- /dev/null
+++ b/drivers/watchdog/at91_sama5d4_wdt.c
@@ -0,0 +1,279 @@
+/*
+ * Driver for Atmel SAMA5D4 Watchdog Timer
+ *
+ * Copyright (C) 2015 Atmel Corporation
+ *
+ * Licensed under GPLv2.
+ */
+
+#include <linux/interrupt.h>
+#include <linux/io.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/of_irq.h>
+#include <linux/platform_device.h>
+#include <linux/reboot.h>
+#include <linux/watchdog.h>
+
+#include "at91sam9_wdt.h"
+
+/* minimum and maximum watchdog timeout, in seconds */
+#define MIN_WDT_TIMEOUT		1
+#define MAX_WDT_TIMEOUT		16
+#define WDT_DEFAULT_TIMEOUT	MAX_WDT_TIMEOUT
+
+#define WDT_SEC2TICKS(s)	((s) ? (((s) << 8) - 1) : 0)
+
+struct atmel_wdt {
+	struct watchdog_device	wdd;
+	void __iomem		*reg_base;
+	u32	config;
+};
+
+static int wdt_timeout = WDT_DEFAULT_TIMEOUT;
+static bool nowayout = WATCHDOG_NOWAYOUT;
+
+module_param(wdt_timeout, int, 0);
+MODULE_PARM_DESC(wdt_timeout,
+	"Watchdog wdt_timeout in seconds. (default = "
+	__MODULE_STRING(WDT_DEFAULT_TIMEOUT) ")");
+
+module_param(nowayout, bool, 0);
+MODULE_PARM_DESC(nowayout,
+	"Watchdog cannot be stopped once started (default="
+	__MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
+
+#define wdt_read(wdt, field) \
+	readl_relaxed((wdt)->reg_base + (field))
+
+#define wdt_write(wtd, field, val) \
+	writel_relaxed((val), (wdt)->reg_base + (field))
+
+static int atmel_wdt_start(struct watchdog_device *wdd)
+{
+	struct atmel_wdt *wdt = watchdog_get_drvdata(wdd);
+	u32 reg;
+
+	reg = wdt_read(wdt, AT91_WDT_MR);
+	reg &= ~AT91_WDT_WDDIS;
+	wdt_write(wdt, AT91_WDT_MR, reg);
+
+	return 0;
+}
+
+static int atmel_wdt_stop(struct watchdog_device *wdd)
+{
+	struct atmel_wdt *wdt = watchdog_get_drvdata(wdd);
+	u32 reg;
+
+	reg = wdt_read(wdt, AT91_WDT_MR);
+	reg |= AT91_WDT_WDDIS;
+	wdt_write(wdt, AT91_WDT_MR, reg);
+
+	return 0;
+}
+
+static int atmel_wdt_ping(struct watchdog_device *wdd)
+{
+	struct atmel_wdt *wdt = watchdog_get_drvdata(wdd);
+
+	wdt_write(wdt, AT91_WDT_CR, AT91_WDT_KEY | AT91_WDT_WDRSTT);
+
+	return 0;
+}
+
+static int atmel_wdt_set_timeout(struct watchdog_device *wdd,
+				 unsigned int timeout)
+{
+	struct atmel_wdt *wdt = watchdog_get_drvdata(wdd);
+	u32 value = WDT_SEC2TICKS(timeout);
+	u32 reg;
+
+	reg = wdt_read(wdt, AT91_WDT_MR);
+	reg &= ~AT91_WDT_WDV;
+	reg &= ~AT91_WDT_WDD;
+	reg |= AT91_WDT_SET_WDV(value);
+	reg |= AT91_WDT_SET_WDD(value);
+	wdt_write(wdt, AT91_WDT_MR, reg);
+
+	wdd->timeout = timeout;
+
+	return 0;
+}
+
+static const struct watchdog_info atmel_wdt_info = {
+	.options = WDIOF_SETTIMEOUT | WDIOF_MAGICCLOSE | WDIOF_KEEPALIVEPING,
+	.firmware_version = 0,
+	.identity = "Atmel SAMA5D4 Watchdog",
+};
+
+static struct watchdog_ops atmel_wdt_ops = {
+	.owner = THIS_MODULE,
+	.start = atmel_wdt_start,
+	.stop = atmel_wdt_stop,
+	.ping = atmel_wdt_ping,
+	.set_timeout = atmel_wdt_set_timeout,
+};
+
+static irqreturn_t atmel_wdt_irq_handler(int irq, void *dev_id)
+{
+	struct atmel_wdt *wdt = platform_get_drvdata(dev_id);
+
+	if (wdt_read(wdt, AT91_WDT_SR)) {
+		pr_crit("Atmel Watchdog Software Reset\n");
+		emergency_restart();
+		pr_crit("Reboot didn't ?????\n");
+	}
+
+	return IRQ_HANDLED;
+}
+
+static int of_atmel_wdt_init(struct device_node *np, struct atmel_wdt *wdt)
+{
+	const char *tmp;
+
+	wdt->config = AT91_WDT_WDDIS;
+
+	if (!of_property_read_string(np, "atmel,watchdog-type", &tmp) &&
+	    !strcmp(tmp, "software"))
+		wdt->config |= AT91_WDT_WDFIEN;
+	else
+		wdt->config |= AT91_WDT_WDRSTEN;
+
+	if (of_property_read_bool(np, "atmel,idle-halt"))
+		wdt->config |= AT91_WDT_WDIDLEHLT;
+
+	if (of_property_read_bool(np, "atmel,dbg-halt"))
+		wdt->config |= AT91_WDT_WDDBGHLT;
+
+	return 0;
+}
+
+static int atmel_wdt_init(struct atmel_wdt *wdt)
+{
+	struct watchdog_device *wdd = &wdt->wdd;
+	u32 value = WDT_SEC2TICKS(wdd->timeout);
+	u32 reg;
+
+	/*
+	 * Because the fields WDV and WDD must not be modified when the WDDIS
+	 * bit is set, so clear the WDDIS bit before writing the WDT_MR.
+	 */
+	reg = wdt_read(wdt, AT91_WDT_MR);
+	reg &= ~AT91_WDT_WDDIS;
+	wdt_write(wdt, AT91_WDT_MR, reg);
+
+	reg = wdt->config;
+	reg |= AT91_WDT_SET_WDD(value);
+	reg |= AT91_WDT_SET_WDV(value);
+
+	wdt_write(wdt, AT91_WDT_MR, reg);
+
+	return 0;
+}
+
+static int atmel_wdt_probe(struct platform_device *pdev)
+{
+	struct watchdog_device *wdd;
+	struct atmel_wdt *wdt;
+	struct resource *res;
+	void __iomem *regs;
+	int ret, irq = -1;
+
+	wdt = devm_kzalloc(&pdev->dev, sizeof(*wdt), GFP_KERNEL);
+	if (!wdt)
+		return -ENOMEM;
+
+	wdd = &wdt->wdd;
+	wdd->timeout = wdt_timeout;
+	wdd->info = &atmel_wdt_info;
+	wdd->ops = &atmel_wdt_ops;
+	wdd->min_timeout = MIN_WDT_TIMEOUT;
+	wdd->max_timeout = MAX_WDT_TIMEOUT;
+
+	watchdog_set_drvdata(wdd, wdt);
+
+	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+	regs = devm_ioremap_resource(&pdev->dev, res);
+	if (IS_ERR(regs))
+		return PTR_ERR(regs);
+
+	wdt->reg_base = regs;
+
+	if (pdev->dev.of_node) {
+		irq = irq_of_parse_and_map(pdev->dev.of_node, 0);
+		if (!irq)
+			dev_warn(&pdev->dev, "failed to get IRQ from DT\n");
+
+		ret = of_atmel_wdt_init(pdev->dev.of_node, wdt);
+		if (ret)
+			return ret;
+	}
+
+	if ((wdt->config & AT91_WDT_WDFIEN) && irq > 0) {
+		ret = devm_request_irq(&pdev->dev, irq, atmel_wdt_irq_handler,
+				       0, pdev->name, pdev);
+		if (ret) {
+			dev_err(&pdev->dev,
+				"cannot register interrupt handler\n");
+			return ret;
+		}
+	}
+
+	ret = watchdog_init_timeout(wdd, wdt_timeout, &pdev->dev);
+	if (ret) {
+		dev_err(&pdev->dev, "unable to set timeout value\n");
+		return ret;
+	}
+
+	ret = atmel_wdt_init(wdt);
+	if (ret)
+		return ret;
+
+	watchdog_set_nowayout(wdd, nowayout);
+
+	ret = watchdog_register_device(wdd);
+	if (ret) {
+		dev_err(&pdev->dev, "failed to register watchdog device\n");
+		return ret;
+	}
+
+	platform_set_drvdata(pdev, wdt);
+
+	dev_info(&pdev->dev, "initialized (timeout = %d sec, nowayout = %d)\n",
+		 wdt_timeout, nowayout);
+
+	return 0;
+}
+
+static int atmel_wdt_remove(struct platform_device *pdev)
+{
+	struct atmel_wdt *wdt = platform_get_drvdata(pdev);
+
+	atmel_wdt_stop(&wdt->wdd);
+
+	watchdog_unregister_device(&wdt->wdd);
+
+	return 0;
+}
+
+static const struct of_device_id atmel_wdt_of_match[] = {
+	{ .compatible = "atmel,sama5d4-wdt", },
+	{ },
+};
+MODULE_DEVICE_TABLE(of, atmel_wdt_of_match);
+
+static struct platform_driver atmel_wdt_driver = {
+	.probe		= atmel_wdt_probe,
+	.remove		= atmel_wdt_remove,
+	.driver		= {
+		.name	= "sama5d4 wdt",
+		.of_match_table = atmel_wdt_of_match,
+	},
+};
+module_platform_driver(atmel_wdt_driver);
+
+MODULE_AUTHOR("Atmel Corporation");
+MODULE_DESCRIPTION("Atmel SAMA5D4 Watchdog Timer driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/watchdog/at91sam9_wdt.h b/drivers/watchdog/at91sam9_wdt.h
index c6fbb2e6..b79a83b 100644
--- a/drivers/watchdog/at91sam9_wdt.h
+++ b/drivers/watchdog/at91sam9_wdt.h
@@ -22,11 +22,13 @@
 
 #define AT91_WDT_MR		0x04			/* Watchdog Mode Register */
 #define		AT91_WDT_WDV		(0xfff << 0)		/* Counter Value */
+#define			AT91_WDT_SET_WDV(x)	((x) & AT91_WDT_WDV)
 #define		AT91_WDT_WDFIEN		(1     << 12)		/* Fault Interrupt Enable */
 #define		AT91_WDT_WDRSTEN	(1     << 13)		/* Reset Processor */
 #define		AT91_WDT_WDRPROC	(1     << 14)		/* Timer Restart */
 #define		AT91_WDT_WDDIS		(1     << 15)		/* Watchdog Disable */
 #define		AT91_WDT_WDD		(0xfff << 16)		/* Delta Value */
+#define			AT91_WDT_SET_WDD(x)	(((x) << 16) & AT91_WDT_WDD)
 #define		AT91_WDT_WDDBGHLT	(1     << 28)		/* Debug Halt */
 #define		AT91_WDT_WDIDLEHLT	(1     << 29)		/* Idle Halt */
 
-- 
1.7.9.5

--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[toc] | [next] | [standalone]

#1200651 — Re: [PATCH v3 1/2] drivers: watchdog: add a driver to support SAMA5D4 watchdog timer

Hi,

> From SAMA5D4, the watchdog timer is upgrated with a new feature,
> which is describled as in the datasheet, "WDT_MR can be written
> until a LOCKMR command is issued in WDT_CR".
> That is to say, as long as the bootstrap and u-boot don't issue
> a LOCKMR command, WDT_MR can be written more than once in the driver.
> 
> So the SAMA5D4 watchdog driver's implementation is different from
> the at91sam9260 watchdog driver implemented in file at91sam9_wdt.c.
> The user application open the device file to enable the watchdog timer
> hardware, and close to disable it, and set the watchdog timer timeout
> by seting WDV and WDD fields of WDT_MR register, and ping the watchdog
> by issuing WDRSTT command to WDT_CR register with hard-coded key.
> 
> Signed-off-by: Wenyou Yang <wenyou.yang@atmel.com>
> ---
>  drivers/watchdog/Kconfig            |    9 ++
>  drivers/watchdog/Makefile           |    1 +
>  drivers/watchdog/at91_sama5d4_wdt.c |  279 +++++++++++++++++++++++++++++++++++
>  drivers/watchdog/at91sam9_wdt.h     |    2 +
>  4 files changed, 291 insertions(+)
>  create mode 100644 drivers/watchdog/at91_sama5d4_wdt.c
> 
> diff --git a/drivers/watchdog/Kconfig b/drivers/watchdog/Kconfig
> index e5e7c55..4ce8346 100644
> --- a/drivers/watchdog/Kconfig
> +++ b/drivers/watchdog/Kconfig
> @@ -152,6 +152,15 @@ config ARM_SP805_WATCHDOG
>  	  ARM Primecell SP805 Watchdog timer. This will reboot your system when
>  	  the timeout is reached.
>  
> +config AT91_SAMA5D4_WATCHDOG
> +	tristate "Atmel SAMA5D4 Watchdog Timer"
> +	depends on ARCH_AT91
> +	select WATCHDOG_CORE
> +	help
> +	  Atmel SAMA5D4 watchdog timer is embedded into SAMA5D4 chips.
> +	  Its Watchdog Timer Mode Register can be written more than once.
> +	  This will reboot your system when the timeout is reached.
> +
>  config AT91RM9200_WATCHDOG
>  	tristate "AT91RM9200 watchdog"
>  	depends on SOC_AT91RM9200 && MFD_SYSCON
> diff --git a/drivers/watchdog/Makefile b/drivers/watchdog/Makefile
> index 5c19294..c57569c 100644
> --- a/drivers/watchdog/Makefile
> +++ b/drivers/watchdog/Makefile
> @@ -30,6 +30,7 @@ obj-$(CONFIG_USBPCWATCHDOG) += pcwd_usb.o
>  
>  # ARM Architecture
>  obj-$(CONFIG_ARM_SP805_WATCHDOG) += sp805_wdt.o
> +obj-$(CONFIG_AT91_SAMA5D4_WATCHDOG) += at91_sama5d4_wdt.o
consistency? Other AT91 entries don't have an '_' between 'AT91' and
the remainder of the Kconfig name.

>  obj-$(CONFIG_AT91RM9200_WATCHDOG) += at91rm9200_wdt.o
>  obj-$(CONFIG_AT91SAM9X_WATCHDOG) += at91sam9_wdt.o
[...]
> +static irqreturn_t atmel_wdt_irq_handler(int irq, void *dev_id)
> +{
> +	struct atmel_wdt *wdt = platform_get_drvdata(dev_id);
> +
> +	if (wdt_read(wdt, AT91_WDT_SR)) {
> +		pr_crit("Atmel Watchdog Software Reset\n");
> +		emergency_restart();
> +		pr_crit("Reboot didn't ?????\n");
>
Reboot didn't what? 'succeed' perhaps?

> +static const struct of_device_id atmel_wdt_of_match[] = {
> +	{ .compatible = "atmel,sama5d4-wdt", },
> +	{ },
The empty initializer must always be the last element of the array, so
there is no point in having a trailing ',' (whose purpose is to
facilitate adding more entries after the last one).
Without the comma there will be a compile error if (e.g. due to a
badly resolved merge conflict) an additional entry would be added after
the stop marker. With the comma after the stop marker any trailing
entries would silently be ignored.


Lothar Waßmann
-- 
___________________________________________________________

Ka-Ro electronics GmbH | Pascalstraße 22 | D - 52076 Aachen
Phone: +49 2408 1402-0 | Fax: +49 2408 1402-10
Geschäftsführer: Matthias Kaussen
Handelsregistereintrag: Amtsgericht Aachen, HRB 4996

www.karo-electronics.de | info@karo-electronics.de
___________________________________________________________
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[toc] | [prev] | [next] | [standalone]

#1201388 — RE: [PATCH v3 1/2] drivers: watchdog: add a driver to support SAMA5D4 watchdog timer
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--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[toc] | [prev] | [next] | [standalone]

#1200846 — Re: [PATCH v3 1/2] drivers: watchdog: add a driver to support SAMA5D4 watchdog timer

On 08/05/2015 01:57 AM, Wenyou Yang wrote:
>>From SAMA5D4, the watchdog timer is upgrated with a new feature,
> which is describled as in the datasheet, "WDT_MR can be written
> until a LOCKMR command is issued in WDT_CR".
> That is to say, as long as the bootstrap and u-boot don't issue
> a LOCKMR command, WDT_MR can be written more than once in the driver.
>
> So the SAMA5D4 watchdog driver's implementation is different from
> the at91sam9260 watchdog driver implemented in file at91sam9_wdt.c.
> The user application open the device file to enable the watchdog timer
> hardware, and close to disable it, and set the watchdog timer timeout
> by seting WDV and WDD fields of WDT_MR register, and ping the watchdog
> by issuing WDRSTT command to WDT_CR register with hard-coded key.
>
> Signed-off-by: Wenyou Yang <wenyou.yang@atmel.com>
> ---
>   drivers/watchdog/Kconfig            |    9 ++
>   drivers/watchdog/Makefile           |    1 +
>   drivers/watchdog/at91_sama5d4_wdt.c |  279 +++++++++++++++++++++++++++++++++++
>   drivers/watchdog/at91sam9_wdt.h     |    2 +
>   4 files changed, 291 insertions(+)
>   create mode 100644 drivers/watchdog/at91_sama5d4_wdt.c
>
> diff --git a/drivers/watchdog/Kconfig b/drivers/watchdog/Kconfig
> index e5e7c55..4ce8346 100644
> --- a/drivers/watchdog/Kconfig
> +++ b/drivers/watchdog/Kconfig
> @@ -152,6 +152,15 @@ config ARM_SP805_WATCHDOG
>   	  ARM Primecell SP805 Watchdog timer. This will reboot your system when
>   	  the timeout is reached.
>
> +config AT91_SAMA5D4_WATCHDOG

Looking into the chip ordering documentation. The chip goes by ATSAMA5D4,
while the other chips go by AT91SAM9xxx.

So I think ATSAMA5D4 would be better (same for the driver name).

Couple of additional nitpicks below.

Thanks,
Guenter

> +	tristate "Atmel SAMA5D4 Watchdog Timer"
> +	depends on ARCH_AT91
> +	select WATCHDOG_CORE
> +	help
> +	  Atmel SAMA5D4 watchdog timer is embedded into SAMA5D4 chips.
> +	  Its Watchdog Timer Mode Register can be written more than once.
> +	  This will reboot your system when the timeout is reached.
> +
>   config AT91RM9200_WATCHDOG
>   	tristate "AT91RM9200 watchdog"
>   	depends on SOC_AT91RM9200 && MFD_SYSCON
> diff --git a/drivers/watchdog/Makefile b/drivers/watchdog/Makefile
> index 5c19294..c57569c 100644
> --- a/drivers/watchdog/Makefile
> +++ b/drivers/watchdog/Makefile
> @@ -30,6 +30,7 @@ obj-$(CONFIG_USBPCWATCHDOG) += pcwd_usb.o
>
>   # ARM Architecture
>   obj-$(CONFIG_ARM_SP805_WATCHDOG) += sp805_wdt.o
> +obj-$(CONFIG_AT91_SAMA5D4_WATCHDOG) += at91_sama5d4_wdt.o
>   obj-$(CONFIG_AT91RM9200_WATCHDOG) += at91rm9200_wdt.o
>   obj-$(CONFIG_AT91SAM9X_WATCHDOG) += at91sam9_wdt.o
>   obj-$(CONFIG_CADENCE_WATCHDOG) += cadence_wdt.o
> diff --git a/drivers/watchdog/at91_sama5d4_wdt.c b/drivers/watchdog/at91_sama5d4_wdt.c
> new file mode 100644
> index 0000000..f2e1995
> --- /dev/null
> +++ b/drivers/watchdog/at91_sama5d4_wdt.c
> @@ -0,0 +1,279 @@
> +/*
> + * Driver for Atmel SAMA5D4 Watchdog Timer
> + *
> + * Copyright (C) 2015 Atmel Corporation
> + *
> + * Licensed under GPLv2.
> + */
> +
> +#include <linux/interrupt.h>
> +#include <linux/io.h>
> +#include <linux/kernel.h>
> +#include <linux/module.h>
> +#include <linux/of.h>
> +#include <linux/of_irq.h>
> +#include <linux/platform_device.h>
> +#include <linux/reboot.h>
> +#include <linux/watchdog.h>
> +
> +#include "at91sam9_wdt.h"
> +
> +/* minimum and maximum watchdog timeout, in seconds */
> +#define MIN_WDT_TIMEOUT		1
> +#define MAX_WDT_TIMEOUT		16
> +#define WDT_DEFAULT_TIMEOUT	MAX_WDT_TIMEOUT
> +
> +#define WDT_SEC2TICKS(s)	((s) ? (((s) << 8) - 1) : 0)
> +
> +struct atmel_wdt {

If you don't mind, please use "sama5d4" as prefix here and for function names.

> +	struct watchdog_device	wdd;
> +	void __iomem		*reg_base;
> +	u32	config;
> +};
> +
> +static int wdt_timeout = WDT_DEFAULT_TIMEOUT;
> +static bool nowayout = WATCHDOG_NOWAYOUT;
> +
> +module_param(wdt_timeout, int, 0);
> +MODULE_PARM_DESC(wdt_timeout,
> +	"Watchdog wdt_timeout in seconds. (default = "
> +	__MODULE_STRING(WDT_DEFAULT_TIMEOUT) ")");
> +
> +module_param(nowayout, bool, 0);
> +MODULE_PARM_DESC(nowayout,
> +	"Watchdog cannot be stopped once started (default="
> +	__MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
> +
> +#define wdt_read(wdt, field) \
> +	readl_relaxed((wdt)->reg_base + (field))
> +
> +#define wdt_write(wtd, field, val) \
> +	writel_relaxed((val), (wdt)->reg_base + (field))
> +
> +static int atmel_wdt_start(struct watchdog_device *wdd)
> +{
> +	struct atmel_wdt *wdt = watchdog_get_drvdata(wdd);
> +	u32 reg;
> +
> +	reg = wdt_read(wdt, AT91_WDT_MR);
> +	reg &= ~AT91_WDT_WDDIS;
> +	wdt_write(wdt, AT91_WDT_MR, reg);
> +
> +	return 0;
> +}
> +
> +static int atmel_wdt_stop(struct watchdog_device *wdd)
> +{
> +	struct atmel_wdt *wdt = watchdog_get_drvdata(wdd);
> +	u32 reg;
> +
> +	reg = wdt_read(wdt, AT91_WDT_MR);
> +	reg |= AT91_WDT_WDDIS;
> +	wdt_write(wdt, AT91_WDT_MR, reg);
> +
> +	return 0;
> +}
> +
> +static int atmel_wdt_ping(struct watchdog_device *wdd)
> +{
> +	struct atmel_wdt *wdt = watchdog_get_drvdata(wdd);
> +
> +	wdt_write(wdt, AT91_WDT_CR, AT91_WDT_KEY | AT91_WDT_WDRSTT);
> +
> +	return 0;
> +}
> +
> +static int atmel_wdt_set_timeout(struct watchdog_device *wdd,
> +				 unsigned int timeout)
> +{
> +	struct atmel_wdt *wdt = watchdog_get_drvdata(wdd);
> +	u32 value = WDT_SEC2TICKS(timeout);
> +	u32 reg;
> +
> +	reg = wdt_read(wdt, AT91_WDT_MR);
> +	reg &= ~AT91_WDT_WDV;
> +	reg &= ~AT91_WDT_WDD;
> +	reg |= AT91_WDT_SET_WDV(value);
> +	reg |= AT91_WDT_SET_WDD(value);
> +	wdt_write(wdt, AT91_WDT_MR, reg);
> +
> +	wdd->timeout = timeout;
> +
> +	return 0;
> +}
> +
> +static const struct watchdog_info atmel_wdt_info = {
> +	.options = WDIOF_SETTIMEOUT | WDIOF_MAGICCLOSE | WDIOF_KEEPALIVEPING,
> +	.firmware_version = 0,

Unnecessary initialization.

> +	.identity = "Atmel SAMA5D4 Watchdog",
> +};
> +
> +static struct watchdog_ops atmel_wdt_ops = {
> +	.owner = THIS_MODULE,
> +	.start = atmel_wdt_start,
> +	.stop = atmel_wdt_stop,
> +	.ping = atmel_wdt_ping,
> +	.set_timeout = atmel_wdt_set_timeout,
> +};
> +
> +static irqreturn_t atmel_wdt_irq_handler(int irq, void *dev_id)
> +{
> +	struct atmel_wdt *wdt = platform_get_drvdata(dev_id);
> +
> +	if (wdt_read(wdt, AT91_WDT_SR)) {
> +		pr_crit("Atmel Watchdog Software Reset\n");
> +		emergency_restart();
> +		pr_crit("Reboot didn't ?????\n");
> +	}
> +
> +	return IRQ_HANDLED;
> +}
> +
> +static int of_atmel_wdt_init(struct device_node *np, struct atmel_wdt *wdt)
> +{
> +	const char *tmp;
> +
> +	wdt->config = AT91_WDT_WDDIS;
> +
> +	if (!of_property_read_string(np, "atmel,watchdog-type", &tmp) &&
> +	    !strcmp(tmp, "software"))
> +		wdt->config |= AT91_WDT_WDFIEN;
> +	else
> +		wdt->config |= AT91_WDT_WDRSTEN;
> +
> +	if (of_property_read_bool(np, "atmel,idle-halt"))
> +		wdt->config |= AT91_WDT_WDIDLEHLT;
> +
> +	if (of_property_read_bool(np, "atmel,dbg-halt"))
> +		wdt->config |= AT91_WDT_WDDBGHLT;
> +
> +	return 0;
> +}
> +
> +static int atmel_wdt_init(struct atmel_wdt *wdt)
> +{
> +	struct watchdog_device *wdd = &wdt->wdd;
> +	u32 value = WDT_SEC2TICKS(wdd->timeout);
> +	u32 reg;
> +
> +	/*
> +	 * Because the fields WDV and WDD must not be modified when the WDDIS
> +	 * bit is set, so clear the WDDIS bit before writing the WDT_MR.
> +	 */
> +	reg = wdt_read(wdt, AT91_WDT_MR);
> +	reg &= ~AT91_WDT_WDDIS;
> +	wdt_write(wdt, AT91_WDT_MR, reg);
> +
> +	reg = wdt->config;
> +	reg |= AT91_WDT_SET_WDD(value);
> +	reg |= AT91_WDT_SET_WDV(value);
> +
> +	wdt_write(wdt, AT91_WDT_MR, reg);
> +
> +	return 0;
> +}
> +
> +static int atmel_wdt_probe(struct platform_device *pdev)
> +{
> +	struct watchdog_device *wdd;
> +	struct atmel_wdt *wdt;
> +	struct resource *res;
> +	void __iomem *regs;
> +	int ret, irq = -1;

Might as well use irq = 0 here for consistency.

> +
> +	wdt = devm_kzalloc(&pdev->dev, sizeof(*wdt), GFP_KERNEL);
> +	if (!wdt)
> +		return -ENOMEM;
> +
> +	wdd = &wdt->wdd;
> +	wdd->timeout = wdt_timeout;
> +	wdd->info = &atmel_wdt_info;
> +	wdd->ops = &atmel_wdt_ops;
> +	wdd->min_timeout = MIN_WDT_TIMEOUT;
> +	wdd->max_timeout = MAX_WDT_TIMEOUT;
> +
> +	watchdog_set_drvdata(wdd, wdt);
> +
> +	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
> +	regs = devm_ioremap_resource(&pdev->dev, res);
> +	if (IS_ERR(regs))
> +		return PTR_ERR(regs);
> +
> +	wdt->reg_base = regs;
> +
> +	if (pdev->dev.of_node) {
> +		irq = irq_of_parse_and_map(pdev->dev.of_node, 0);
> +		if (!irq)
> +			dev_warn(&pdev->dev, "failed to get IRQ from DT\n");
> +
> +		ret = of_atmel_wdt_init(pdev->dev.of_node, wdt);
> +		if (ret)
> +			return ret;
> +	}
> +
> +	if ((wdt->config & AT91_WDT_WDFIEN) && irq > 0) {

... then you can check " ... && irq" here.

> +		ret = devm_request_irq(&pdev->dev, irq, atmel_wdt_irq_handler,
> +				       0, pdev->name, pdev);
> +		if (ret) {
> +			dev_err(&pdev->dev,
> +				"cannot register interrupt handler\n");
> +			return ret;
> +		}
> +	}
> +
> +	ret = watchdog_init_timeout(wdd, wdt_timeout, &pdev->dev);
> +	if (ret) {
> +		dev_err(&pdev->dev, "unable to set timeout value\n");
> +		return ret;
> +	}
> +
> +	ret = atmel_wdt_init(wdt);
> +	if (ret)
> +		return ret;
> +
> +	watchdog_set_nowayout(wdd, nowayout);
> +
> +	ret = watchdog_register_device(wdd);
> +	if (ret) {
> +		dev_err(&pdev->dev, "failed to register watchdog device\n");
> +		return ret;
> +	}
> +
> +	platform_set_drvdata(pdev, wdt);
> +
> +	dev_info(&pdev->dev, "initialized (timeout = %d sec, nowayout = %d)\n",
> +		 wdt_timeout, nowayout);
> +
> +	return 0;
> +}
> +
> +static int atmel_wdt_remove(struct platform_device *pdev)
> +{
> +	struct atmel_wdt *wdt = platform_get_drvdata(pdev);
> +
> +	atmel_wdt_stop(&wdt->wdd);
> +
> +	watchdog_unregister_device(&wdt->wdd);
> +
> +	return 0;
> +}
> +
> +static const struct of_device_id atmel_wdt_of_match[] = {
> +	{ .compatible = "atmel,sama5d4-wdt", },
> +	{ },
> +};
> +MODULE_DEVICE_TABLE(of, atmel_wdt_of_match);
> +
> +static struct platform_driver atmel_wdt_driver = {
> +	.probe		= atmel_wdt_probe,
> +	.remove		= atmel_wdt_remove,
> +	.driver		= {
> +		.name	= "sama5d4 wdt",
> +		.of_match_table = atmel_wdt_of_match,
> +	},
> +};
> +module_platform_driver(atmel_wdt_driver);
> +
> +MODULE_AUTHOR("Atmel Corporation");
> +MODULE_DESCRIPTION("Atmel SAMA5D4 Watchdog Timer driver");
> +MODULE_LICENSE("GPL v2");
> diff --git a/drivers/watchdog/at91sam9_wdt.h b/drivers/watchdog/at91sam9_wdt.h
> index c6fbb2e6..b79a83b 100644
> --- a/drivers/watchdog/at91sam9_wdt.h
> +++ b/drivers/watchdog/at91sam9_wdt.h
> @@ -22,11 +22,13 @@
>
>   #define AT91_WDT_MR		0x04			/* Watchdog Mode Register */
>   #define		AT91_WDT_WDV		(0xfff << 0)		/* Counter Value */
> +#define			AT91_WDT_SET_WDV(x)	((x) & AT91_WDT_WDV)
>   #define		AT91_WDT_WDFIEN		(1     << 12)		/* Fault Interrupt Enable */
>   #define		AT91_WDT_WDRSTEN	(1     << 13)		/* Reset Processor */
>   #define		AT91_WDT_WDRPROC	(1     << 14)		/* Timer Restart */
>   #define		AT91_WDT_WDDIS		(1     << 15)		/* Watchdog Disable */
>   #define		AT91_WDT_WDD		(0xfff << 16)		/* Delta Value */
> +#define			AT91_WDT_SET_WDD(x)	(((x) << 16) & AT91_WDT_WDD)
>   #define		AT91_WDT_WDDBGHLT	(1     << 28)		/* Debug Halt */
>   #define		AT91_WDT_WDIDLEHLT	(1     << 29)		/* Idle Halt */
>
>

--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[toc] | [prev] | [next] | [standalone]

#1201391 — RE: [PATCH v3 1/2] drivers: watchdog: add a driver to support SAMA5D4 watchdog timer
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--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[toc] | [prev] | [standalone]

Back to top | Article view | linux.kernel

csiph-web