[PATCH v2 1/2] ep93xx: implemented watchdog timer driver for TS-72xxSBCs
Mika Westerberg
mika.westerberg at iki.fi
Thu Dec 17 15:22:08 EST 2009
Hi Wim,
Do you have any comments on this driver? Would it be ok for it being accepted
to your watchdog tree?
Thanks,
MW
On Mon, Dec 07, 2009 at 06:36:41PM -0500, H Hartley Sweeten wrote:
> Hello Mika,
>
> Looks good. Cc'ed Wim Van Sebroeck since he is the watchdog
> device driver maintainer.
>
> Acked-by: H Hartley Sweeten <hsweeten at visionengravers.com>
> Cc: Wim Van Sebroeck <wim at iguana.be>
> Cc: Ryan Mallon <ryan at bluewatersys.com>
>
> -----Original Message-----
> From: linux-arm-kernel-bounces at lists.infradead.org [mailto:linux-arm-kernel-bounces at lists.infradead.org] On Behalf Of Mika Westerberg
> Sent: Sunday, December 06, 2009 2:39 AM
> To: linux-arm-kernel at lists.infradead.org
> Subject: [PATCH v2 1/2] ep93xx: implemented watchdog timer driver for TS-72xxSBCs
>
> Technologic Systems TS-72xx SBCs have external glue logic
> CPLD which includes watchdog timer. This driver implements
> kernel support for that.
>
> Signed-off-by: Mika Westerberg <mika.westerberg at iki.fi>
> ---
> drivers/watchdog/Kconfig | 11 +
> drivers/watchdog/Makefile | 1 +
> drivers/watchdog/ts72xx_wdt.c | 516 +++++++++++++++++++++++++++++++++++++++++
> 3 files changed, 528 insertions(+), 0 deletions(-)
> create mode 100644 drivers/watchdog/ts72xx_wdt.c
>
> diff --git a/drivers/watchdog/Kconfig b/drivers/watchdog/Kconfig
> index 3711b88..5204612 100644
> --- a/drivers/watchdog/Kconfig
> +++ b/drivers/watchdog/Kconfig
> @@ -289,6 +289,17 @@ config ADX_WATCHDOG
> Say Y here if you want support for the watchdog timer on Avionic
> Design Xanthos boards.
>
> +config TS72XX_WATCHDOG
> + tristate "TS-72XX SBC Watchdog"
> + depends on MACH_TS72XX
> + help
> + Technologic Systems TS-7200, TS-7250 and TS-7260 boards have
> + watchdog timer implemented in a external CPLD chip. Say Y here
> + if you want to support for the watchdog timer on TS-72XX boards.
> +
> + To compile this driver as a module, choose M here: the
> + module will be called ts72xx_wdt.
> +
> # AVR32 Architecture
>
> config AT32AP700X_WDT
> diff --git a/drivers/watchdog/Makefile b/drivers/watchdog/Makefile
> index 699199b..8e8a9b4 100644
> --- a/drivers/watchdog/Makefile
> +++ b/drivers/watchdog/Makefile
> @@ -46,6 +46,7 @@ obj-$(CONFIG_COH901327_WATCHDOG) += coh901327_wdt.o
> obj-$(CONFIG_STMP3XXX_WATCHDOG) += stmp3xxx_wdt.o
> obj-$(CONFIG_NUC900_WATCHDOG) += nuc900_wdt.o
> obj-$(CONFIG_ADX_WATCHDOG) += adx_wdt.o
> +obj-$(CONFIG_TS72XX_WATCHDOG) += ts72xx_wdt.o
>
> # AVR32 Architecture
> obj-$(CONFIG_AT32AP700X_WDT) += at32ap700x_wdt.o
> diff --git a/drivers/watchdog/ts72xx_wdt.c b/drivers/watchdog/ts72xx_wdt.c
> new file mode 100644
> index 0000000..c4a4d37
> --- /dev/null
> +++ b/drivers/watchdog/ts72xx_wdt.c
> @@ -0,0 +1,516 @@
> +/*
> + * Watchdog driver for Technologic Systems TS-72xx based SBCs
> + * (TS-7200, TS-7250 and TS-7260). These boards have external
> + * glue logic CPLD chip, which includes programmable watchdog
> + * timer.
> + *
> + * Copyright (c) 2009 Mika Westerberg <mika.westerberg at iki.fi>
> + *
> + * This driver is based on ep93xx_wdt and wm831x_wdt drivers.
> + *
> + * This file is licensed under the terms of the GNU General Public
> + * License version 2. This program is licensed "as is" without any
> + * warranty of any kind, whether express or implied.
> + */
> +
> +#include <linux/fs.h>
> +#include <linux/io.h>
> +#include <linux/module.h>
> +#include <linux/moduleparam.h>
> +#include <linux/miscdevice.h>
> +#include <linux/mutex.h>
> +#include <linux/platform_device.h>
> +#include <linux/watchdog.h>
> +#include <linux/uaccess.h>
> +
> +#define TS72XX_WDT_FEED_VAL 0x05
> +#define TS72XX_WDT_DEFAULT_TIMEOUT 8
> +
> +static int timeout = TS72XX_WDT_DEFAULT_TIMEOUT;
> +module_param(timeout, int, 0);
> +MODULE_PARM_DESC(timeout, "Watchdog timeout in seconds. "
> + "(1 <= timeout <= 8, default="
> + __MODULE_STRING(TS72XX_WDT_DEFAULT_TIMEOUT)
> + ")");
> +
> +static int nowayout = WATCHDOG_NOWAYOUT;
> +module_param(nowayout, int, 0);
> +MODULE_PARM_DESC(nowayout, "Disable watchdog shutdown on close");
> +
> +/**
> + * struct ts72xx_wdt - watchdog control structure
> + * @lock: lock that protects this structure
> + * @regval: watchdog timeout value suitable for control register
> + * @flags: flags controlling watchdog device state
> + * @control_reg: watchdog control register
> + * @feed_reg: watchdog feed register
> + * @pdev: back pointer to platform dev
> + */
> +struct ts72xx_wdt {
> + struct mutex lock;
> + int regval;
> +
> +#define TS72XX_WDT_BUSY_FLAG 1
> +#define TS72XX_WDT_EXPECT_CLOSE_FLAG 2
> + int flags;
> +
> + void __iomem *control_reg;
> + void __iomem *feed_reg;
> +
> + struct platform_device *pdev;
> +};
> +
> +struct platform_device *ts72xx_wdt_pdev;
> +
> +/*
> + * TS-72xx Watchdog supports following timeouts (value written
> + * to control register):
> + * value description
> + * -------------------------
> + * 0x00 watchdog disabled
> + * 0x01 250ms
> + * 0x02 500ms
> + * 0x03 1s
> + * 0x04 reserved
> + * 0x05 2s
> + * 0x06 4s
> + * 0x07 8s
> + *
> + * Timeouts below 1s are not very usable so we don't
> + * allow them at all.
> + *
> + * We provide two functions that convert between these:
> + * timeout_to_regval() and regval_to_timeout().
> + */
> +static const struct {
> + int timeout;
> + int regval;
> +} ts72xx_wdt_map[] = {
> + { 1, 3 },
> + { 2, 5 },
> + { 4, 6 },
> + { 8, 7 },
> +};
> +
> +/**
> + * timeout_to_regval() - converts given timeout to control register value
> + * @new_timeout: timeout in seconds to be converted
> + *
> + * Function converts given @new_timeout into valid value that can
> + * be programmed into watchdog control register. When conversion is
> + * not possible, function returns %-EINVAL.
> + */
> +static int timeout_to_regval(int new_timeout)
> +{
> + int i;
> +
> + /* first limit it to 1 - 8 seconds */
> + new_timeout = clamp_val(new_timeout, 1, 8);
> +
> + for (i = 0; i < ARRAY_SIZE(ts72xx_wdt_map); i++) {
> + if (ts72xx_wdt_map[i].timeout >= new_timeout)
> + return ts72xx_wdt_map[i].regval;
> + }
> +
> + return -EINVAL;
> +}
> +
> +/**
> + * regval_to_timeout() - converts control register value to timeout
> + * @regval: control register value to be converted
> + *
> + * Function converts given @regval to timeout in seconds (1, 2, 4 or 8).
> + * If @regval cannot be converted, function returns %-EINVAL.
> + */
> +static int regval_to_timeout(int regval)
> +{
> + int i;
> +
> + for (i = 0; i < ARRAY_SIZE(ts72xx_wdt_map); i++) {
> + if (ts72xx_wdt_map[i].regval == regval)
> + return ts72xx_wdt_map[i].timeout;
> + }
> +
> + return -EINVAL;
> +}
> +
> +/**
> + * ts72xx_wdt_kick() - kick the watchdog
> + * @wdt: watchdog to be kicked
> + *
> + * Called with @wdt->lock held.
> + */
> +static inline void ts72xx_wdt_kick(struct ts72xx_wdt *wdt)
> +{
> + __raw_writeb(TS72XX_WDT_FEED_VAL, wdt->feed_reg);
> +}
> +
> +/**
> + * ts72xx_wdt_start() - starts the watchdog timer
> + * @wdt: watchdog to be started
> + *
> + * This function programs timeout to watchdog timer
> + * and starts it.
> + *
> + * Called with @wdt->lock held.
> + */
> +static void ts72xx_wdt_start(struct ts72xx_wdt *wdt)
> +{
> + /*
> + * To program the wdt, it first must be "fed" and
> + * only after that (within 30 usecs) the configuration
> + * can be changed.
> + */
> + ts72xx_wdt_kick(wdt);
> + __raw_writeb((u8)wdt->regval, wdt->control_reg);
> +}
> +
> +/**
> + * ts72xx_wdt_stop() - stops the watchdog timer
> + * @wdt: watchdog to be stopped
> + *
> + * Called with @wdt->lock held.
> + */
> +static void ts72xx_wdt_stop(struct ts72xx_wdt *wdt)
> +{
> + ts72xx_wdt_kick(wdt);
> + __raw_writeb(0, wdt->control_reg);
> +}
> +
> +static int ts72xx_wdt_open(struct inode *inode, struct file *file)
> +{
> + struct ts72xx_wdt *wdt = platform_get_drvdata(ts72xx_wdt_pdev);
> + int regval;
> +
> + /*
> + * Try to convert default timeout to valid register
> + * value first.
> + */
> + regval = timeout_to_regval(timeout);
> + if (regval < 0) {
> + dev_err(&wdt->pdev->dev,
> + "failed to convert timeout (%d) to register value\n",
> + timeout);
> + return -EINVAL;
> + }
> +
> + if (mutex_lock_interruptible(&wdt->lock))
> + return -ERESTARTSYS;
> +
> + if ((wdt->flags & TS72XX_WDT_BUSY_FLAG) != 0) {
> + mutex_unlock(&wdt->lock);
> + return -EBUSY;
> + }
> +
> + wdt->flags = TS72XX_WDT_BUSY_FLAG;
> + wdt->regval = regval;
> + file->private_data = wdt;
> +
> + ts72xx_wdt_start(wdt);
> +
> + mutex_unlock(&wdt->lock);
> + return nonseekable_open(inode, file);
> +}
> +
> +static int ts72xx_wdt_release(struct inode *inode, struct file *file)
> +{
> + struct ts72xx_wdt *wdt = file->private_data;
> +
> + if (mutex_lock_interruptible(&wdt->lock))
> + return -ERESTARTSYS;
> +
> + if ((wdt->flags & TS72XX_WDT_EXPECT_CLOSE_FLAG) != 0) {
> + ts72xx_wdt_stop(wdt);
> + } else {
> + dev_warn(&wdt->pdev->dev,
> + "TS-72XX WDT device closed unexpectly. "
> + "Watchdog timer will not stop!\n");
> + /*
> + * Kick it one more time, to give userland some time
> + * to recover (for example, respawning the kicker
> + * daemon).
> + */
> + ts72xx_wdt_kick(wdt);
> + }
> +
> + wdt->flags = 0;
> +
> + mutex_unlock(&wdt->lock);
> + return 0;
> +}
> +
> +static ssize_t ts72xx_wdt_write(struct file *file,
> + const char __user *data,
> + size_t len,
> + loff_t *ppos)
> +{
> + struct ts72xx_wdt *wdt = file->private_data;
> +
> + if (!len)
> + return 0;
> +
> + if (mutex_lock_interruptible(&wdt->lock))
> + return -ERESTARTSYS;
> +
> + ts72xx_wdt_kick(wdt);
> +
> + /*
> + * Support for magic character closing. User process
> + * writes 'V' into the device, just before it is closed.
> + * This means that we know that the wdt timer can be
> + * stopped after user closes the device.
> + */
> + if (!nowayout) {
> + int i;
> +
> + for (i = 0; i < len; i++) {
> + char c;
> +
> + /* In case it was set long ago */
> + wdt->flags &= ~TS72XX_WDT_EXPECT_CLOSE_FLAG;
> +
> + if (get_user(c, data + i)) {
> + mutex_unlock(&wdt->lock);
> + return -EFAULT;
> + }
> + if (c == 'V') {
> + wdt->flags |= TS72XX_WDT_EXPECT_CLOSE_FLAG;
> + break;
> + }
> + }
> + }
> +
> + mutex_unlock(&wdt->lock);
> + return len;
> +}
> +
> +static const struct watchdog_info winfo = {
> + .options = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT |
> + WDIOF_MAGICCLOSE,
> + .firmware_version = 1,
> + .identity = "TS-72XX WDT",
> +};
> +
> +static long ts72xx_wdt_ioctl(struct file *file, unsigned int cmd,
> + unsigned long arg)
> +{
> + struct ts72xx_wdt *wdt = file->private_data;
> + void __user *argp = (void __user *)arg;
> + int __user *p = (int __user *)argp;
> + int error = 0;
> +
> + if (mutex_lock_interruptible(&wdt->lock))
> + return -ERESTARTSYS;
> +
> + switch (cmd) {
> + case WDIOC_GETSUPPORT:
> + error = copy_to_user(argp, &winfo, sizeof(winfo));
> + break;
> +
> + case WDIOC_KEEPALIVE:
> + ts72xx_wdt_kick(wdt);
> + break;
> +
> + case WDIOC_SETOPTIONS: {
> + int options;
> +
> + if (get_user(options, p)) {
> + error = -EFAULT;
> + break;
> + }
> +
> + error = -EINVAL;
> +
> + if ((options & WDIOS_DISABLECARD) != 0) {
> + ts72xx_wdt_stop(wdt);
> + error = 0;
> + }
> + if ((options & WDIOS_ENABLECARD) != 0) {
> + ts72xx_wdt_start(wdt);
> + error = 0;
> + }
> +
> + break;
> + }
> +
> + case WDIOC_SETTIMEOUT: {
> + int new_timeout;
> +
> + if (get_user(new_timeout, p)) {
> + error = -EFAULT;
> + } else {
> + int regval;
> +
> + regval = timeout_to_regval(new_timeout);
> + if (regval < 0) {
> + error = -EINVAL;
> + } else {
> + ts72xx_wdt_stop(wdt);
> + wdt->regval = regval;
> + ts72xx_wdt_start(wdt);
> + }
> + }
> + if (error)
> + break;
> +
> + /*FALLTHROUGH*/
> + }
> +
> + case WDIOC_GETTIMEOUT:
> + if (put_user(regval_to_timeout(wdt->regval), p))
> + error = -EFAULT;
> + break;
> +
> + default:
> + error = -ENOTTY;
> + break;
> + }
> +
> + mutex_unlock(&wdt->lock);
> + return error;
> +}
> +
> +static const struct file_operations ts72xx_wdt_fops = {
> + .owner = THIS_MODULE,
> + .llseek = no_llseek,
> + .open = ts72xx_wdt_open,
> + .release = ts72xx_wdt_release,
> + .write = ts72xx_wdt_write,
> + .unlocked_ioctl = ts72xx_wdt_ioctl,
> +};
> +
> +static struct miscdevice ts72xx_wdt_miscdev = {
> + .minor = WATCHDOG_MINOR,
> + .name = "watchdog",
> + .fops = &ts72xx_wdt_fops,
> +};
> +
> +static __devinit int ts72xx_wdt_probe(struct platform_device *pdev)
> +{
> + struct ts72xx_wdt *wdt;
> + struct resource *r1, *r2;
> + int error = 0;
> +
> + wdt = kzalloc(sizeof(struct ts72xx_wdt), GFP_KERNEL);
> + if (!wdt) {
> + dev_err(&pdev->dev, "failed to allocate memory\n");
> + return -ENOMEM;
> + }
> +
> + r1 = platform_get_resource(pdev, IORESOURCE_MEM, 0);
> + if (!r1) {
> + dev_err(&pdev->dev, "failed to get memory resource\n");
> + error = -ENODEV;
> + goto fail;
> + }
> +
> + r1 = request_mem_region(r1->start, resource_size(r1), pdev->name);
> + if (!r1) {
> + dev_err(&pdev->dev, "cannot request memory region\n");
> + error = -EBUSY;
> + goto fail;
> + }
> +
> + wdt->control_reg = ioremap(r1->start, resource_size(r1));
> + if (!wdt->control_reg) {
> + dev_err(&pdev->dev, "failed to map memory\n");
> + error = -ENODEV;
> + goto fail_free_control;
> + }
> +
> + r2 = platform_get_resource(pdev, IORESOURCE_MEM, 1);
> + if (!r2) {
> + dev_err(&pdev->dev, "failed to get memory resource\n");
> + error = -ENODEV;
> + goto fail_unmap_control;
> + }
> +
> + r2 = request_mem_region(r2->start, resource_size(r2), pdev->name);
> + if (!r2) {
> + dev_err(&pdev->dev, "cannot request memory region\n");
> + error = -EBUSY;
> + goto fail_unmap_control;
> + }
> +
> + wdt->feed_reg = ioremap(r2->start, resource_size(r2));
> + if (!wdt->feed_reg) {
> + dev_err(&pdev->dev, "failed to map memory\n");
> + error = -ENODEV;
> + goto fail_free_feed;
> + }
> +
> + platform_set_drvdata(pdev, wdt);
> + ts72xx_wdt_pdev = pdev;
> + wdt->pdev = pdev;
> + mutex_init(&wdt->lock);
> +
> + error = misc_register(&ts72xx_wdt_miscdev);
> + if (error) {
> + dev_err(&pdev->dev, "failed to register miscdev\n");
> + goto fail_unmap_feed;
> + }
> +
> + dev_info(&pdev->dev, "TS-72xx Watchdog driver\n");
> +
> + return 0;
> +
> +fail_unmap_feed:
> + platform_set_drvdata(pdev, NULL);
> + iounmap(wdt->feed_reg);
> +fail_free_feed:
> + release_mem_region(r2->start, resource_size(r2));
> +fail_unmap_control:
> + iounmap(wdt->control_reg);
> +fail_free_control:
> + release_mem_region(r1->start, resource_size(r1));
> +fail:
> + kfree(wdt);
> + return error;
> +}
> +
> +static __devexit int ts72xx_wdt_remove(struct platform_device *pdev)
> +{
> + struct ts72xx_wdt *wdt = platform_get_drvdata(pdev);
> + struct resource *res;
> + int error;
> +
> + error = misc_deregister(&ts72xx_wdt_miscdev);
> + platform_set_drvdata(pdev, NULL);
> +
> + iounmap(wdt->control_reg);
> + res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
> + release_mem_region(res->start, resource_size(res));
> +
> + iounmap(wdt->feed_reg);
> + res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
> + release_mem_region(res->start, resource_size(res));
> +
> + kfree(wdt);
> + return error;
> +}
> +
> +static struct platform_driver ts72xx_wdt_driver = {
> + .probe = ts72xx_wdt_probe,
> + .remove = __devexit_p(ts72xx_wdt_remove),
> + .driver = {
> + .name = "ts72xx-wdt",
> + .owner = THIS_MODULE,
> + },
> +};
> +
> +static __init int ts72xx_wdt_init(void)
> +{
> + return platform_driver_register(&ts72xx_wdt_driver);
> +}
> +module_init(ts72xx_wdt_init);
> +
> +static __exit void ts72xx_wdt_exit(void)
> +{
> + platform_driver_unregister(&ts72xx_wdt_driver);
> +}
> +module_exit(ts72xx_wdt_exit);
> +
> +MODULE_AUTHOR("Mika Westerberg <mika.westerberg at iki.fi>");
> +MODULE_DESCRIPTION("TS-72xx SBC Watchdog");
> +MODULE_LICENSE("GPL");
> +MODULE_ALIAS("platform:ts72xx-wdt");
> --
> 1.5.6.5
>
>
> _______________________________________________
> linux-arm-kernel mailing list
> linux-arm-kernel at lists.infradead.org
> http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
More information about the linux-arm-kernel
mailing list