From: wim@iguana.be (Wim Van Sebroeck) Date: Fri, 18 Dec 2009 10:32:05 +0100 Subject: [PATCH v2 1/2] ep93xx: implemented watchdog timer driver for TS-72xxSBCs In-Reply-To: <20091217202208.GJ25613@gw.healthdatacare.com> References: <9a6b3d18f799bd632e0d0f688f998336f073a7ef.1260089508.git.mika.westerberg@iki.fi> <20091217202208.GJ25613@gw.healthdatacare.com> Message-ID: <20091218093205.GA4291@infomag.iguana.be> To: linux-arm-kernel@lists.infradead.org List-Id: linux-arm-kernel.lists.infradead.org Hi Mike, the reviewing is still on my todo-list. I will keep you posted. Kind regards, Wim. > 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 > > Cc: Wim Van Sebroeck > > Cc: Ryan Mallon > > > > -----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 > > --- > > 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 > > + * > > + * 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 > > +#include > > +#include > > +#include > > +#include > > +#include > > +#include > > +#include > > +#include > > + > > +#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 "); > > +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