LXR linux/drivers/watchdog/ep93xx

   1/*
   2 * Watchdog driver for Cirrus Logic EP93xx family of devices.
   3 *
   4 * Copyright (c) 2004 Ray Lehtiniemi
   5 * Copyright (c) 2006 Tower Technologies
   6 * Based on ep93xx driver, bits from alim7101_wdt.c
   7 *
   8 * Authors: Ray Lehtiniemi <rayl@mail.com>,
   9 *      Alessandro Zummo <a.zummo@towertech.it>
  10 *
  11 * Copyright (c) 2012 H Hartley Sweeten <hsweeten@visionengravers.com>
  12 *      Convert to a platform device and use the watchdog framework API
  13 *
  14 * This file is licensed under the terms of the GNU General Public
  15 * License version 2. This program is licensed "as is" without any
  16 * warranty of any kind, whether express or implied.
  17 *
  18 * This watchdog fires after 250msec, which is a too short interval
  19 * for us to rely on the user space daemon alone. So we ping the
  20 * wdt each ~200msec and eventually stop doing it if the user space
  21 * daemon dies.
  22 */
  23
  24#include <linux/platform_device.h>
  25#include <linux/module.h>
  26#include <linux/watchdog.h>
  27#include <linux/io.h>
  28
  29/* default timeout (secs) */
  30#define WDT_TIMEOUT 30
  31
  32static bool nowayout = WATCHDOG_NOWAYOUT;
  33module_param(nowayout, bool, 0);
  34MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started");
  35
  36static unsigned int timeout;
  37module_param(timeout, uint, 0);
  38MODULE_PARM_DESC(timeout, "Watchdog timeout in seconds.");
  39
  40#define EP93XX_WATCHDOG         0x00
  41#define EP93XX_WDSTATUS         0x04
  42
  43struct ep93xx_wdt_priv {
  44        void __iomem *mmio;
  45        struct watchdog_device wdd;
  46};
  47
  48static int ep93xx_wdt_start(struct watchdog_device *wdd)
  49{
  50        struct ep93xx_wdt_priv *priv = watchdog_get_drvdata(wdd);
  51
  52        writel(0xaaaa, priv->mmio + EP93XX_WATCHDOG);
  53
  54        return 0;
  55}
  56
  57static int ep93xx_wdt_stop(struct watchdog_device *wdd)
  58{
  59        struct ep93xx_wdt_priv *priv = watchdog_get_drvdata(wdd);
  60
  61        writel(0xaa55, priv->mmio + EP93XX_WATCHDOG);
  62
  63        return 0;
  64}
  65
  66static int ep93xx_wdt_ping(struct watchdog_device *wdd)
  67{
  68        struct ep93xx_wdt_priv *priv = watchdog_get_drvdata(wdd);
  69
  70        writel(0x5555, priv->mmio + EP93XX_WATCHDOG);
  71
  72        return 0;
  73}
  74
  75static const struct watchdog_info ep93xx_wdt_ident = {
  76        .options        = WDIOF_CARDRESET |
  77                          WDIOF_SETTIMEOUT |
  78                          WDIOF_MAGICCLOSE |
  79                          WDIOF_KEEPALIVEPING,
  80        .identity       = "EP93xx Watchdog",
  81};
  82
  83static const struct watchdog_ops ep93xx_wdt_ops = {
  84        .owner          = THIS_MODULE,
  85        .start          = ep93xx_wdt_start,
  86        .stop           = ep93xx_wdt_stop,
  87        .ping           = ep93xx_wdt_ping,
  88};
  89
  90static int ep93xx_wdt_probe(struct platform_device *pdev)
  91{
  92        struct ep93xx_wdt_priv *priv;
  93        struct watchdog_device *wdd;
  94        struct resource *res;
  95        unsigned long val;
  96        int ret;
  97
  98        priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
  99        if (!priv)
 100                return -ENOMEM;
 101
 102        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 103        priv->mmio = devm_ioremap_resource(&pdev->dev, res);
 104        if (IS_ERR(priv->mmio))
 105                return PTR_ERR(priv->mmio);
 106
 107        val = readl(priv->mmio + EP93XX_WATCHDOG);
 108
 109        wdd = &priv->wdd;
 110        wdd->bootstatus = (val & 0x01) ? WDIOF_CARDRESET : 0;
 111        wdd->info = &ep93xx_wdt_ident;
 112        wdd->ops = &ep93xx_wdt_ops;
 113        wdd->min_timeout = 1;
 114        wdd->max_hw_heartbeat_ms = 200;
 115        wdd->parent = &pdev->dev;
 116
 117        watchdog_set_nowayout(wdd, nowayout);
 118
 119        wdd->timeout = WDT_TIMEOUT;
 120        watchdog_init_timeout(wdd, timeout, &pdev->dev);
 121
 122        watchdog_set_drvdata(wdd, priv);
 123
 124        ret = devm_watchdog_register_device(&pdev->dev, wdd);
 125        if (ret)
 126                return ret;
 127
 128        dev_info(&pdev->dev, "EP93XX watchdog driver %s\n",
 129                (val & 0x08) ? " (nCS1 disable detected)" : "");
 130
 131        return 0;
 132}
 133
 134static struct platform_driver ep93xx_wdt_driver = {
 135        .driver         = {
 136                .name   = "ep93xx-wdt",
 137        },
 138        .probe          = ep93xx_wdt_probe,
 139};
 140
 141module_platform_driver(ep93xx_wdt_driver);
 142
 143MODULE_AUTHOR("Ray Lehtiniemi <rayl@mail.com>");
 144MODULE_AUTHOR("Alessandro Zummo <a.zummo@towertech.it>");
 145MODULE_AUTHOR("H Hartley Sweeten <hsweeten@visionengravers.com>");
 146MODULE_DESCRIPTION("EP93xx Watchdog");
 147MODULE_LICENSE("GPL");
 148