linux/drivers/watchdog/orion_wdt.c
<<
>>
Prefs
   1/*
   2 * drivers/watchdog/orion_wdt.c
   3 *
   4 * Watchdog driver for Orion/Kirkwood processors
   5 *
   6 * Author: Sylver Bruneau <sylver.bruneau@googlemail.com>
   7 *
   8 * This file is licensed under  the terms of the GNU General Public
   9 * License version 2. This program is licensed "as is" without any
  10 * warranty of any kind, whether express or implied.
  11 */
  12
  13#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  14
  15#include <linux/module.h>
  16#include <linux/moduleparam.h>
  17#include <linux/types.h>
  18#include <linux/kernel.h>
  19#include <linux/miscdevice.h>
  20#include <linux/platform_device.h>
  21#include <linux/watchdog.h>
  22#include <linux/init.h>
  23#include <linux/io.h>
  24#include <linux/spinlock.h>
  25#include <linux/clk.h>
  26#include <linux/err.h>
  27#include <linux/of.h>
  28#include <mach/bridge-regs.h>
  29
  30/*
  31 * Watchdog timer block registers.
  32 */
  33#define TIMER_CTRL              0x0000
  34#define WDT_EN                  0x0010
  35#define WDT_VAL                 0x0024
  36
  37#define WDT_MAX_CYCLE_COUNT     0xffffffff
  38#define WDT_IN_USE              0
  39#define WDT_OK_TO_CLOSE         1
  40
  41static bool nowayout = WATCHDOG_NOWAYOUT;
  42static int heartbeat = -1;              /* module parameter (seconds) */
  43static unsigned int wdt_max_duration;   /* (seconds) */
  44static struct clk *clk;
  45static unsigned int wdt_tclk;
  46static void __iomem *wdt_reg;
  47static DEFINE_SPINLOCK(wdt_lock);
  48
  49static int orion_wdt_ping(struct watchdog_device *wdt_dev)
  50{
  51        spin_lock(&wdt_lock);
  52
  53        /* Reload watchdog duration */
  54        writel(wdt_tclk * wdt_dev->timeout, wdt_reg + WDT_VAL);
  55
  56        spin_unlock(&wdt_lock);
  57        return 0;
  58}
  59
  60static int orion_wdt_start(struct watchdog_device *wdt_dev)
  61{
  62        u32 reg;
  63
  64        spin_lock(&wdt_lock);
  65
  66        /* Set watchdog duration */
  67        writel(wdt_tclk * wdt_dev->timeout, wdt_reg + WDT_VAL);
  68
  69        /* Clear watchdog timer interrupt */
  70        reg = readl(BRIDGE_CAUSE);
  71        reg &= ~WDT_INT_REQ;
  72        writel(reg, BRIDGE_CAUSE);
  73
  74        /* Enable watchdog timer */
  75        reg = readl(wdt_reg + TIMER_CTRL);
  76        reg |= WDT_EN;
  77        writel(reg, wdt_reg + TIMER_CTRL);
  78
  79        /* Enable reset on watchdog */
  80        reg = readl(RSTOUTn_MASK);
  81        reg |= WDT_RESET_OUT_EN;
  82        writel(reg, RSTOUTn_MASK);
  83
  84        spin_unlock(&wdt_lock);
  85        return 0;
  86}
  87
  88static int orion_wdt_stop(struct watchdog_device *wdt_dev)
  89{
  90        u32 reg;
  91
  92        spin_lock(&wdt_lock);
  93
  94        /* Disable reset on watchdog */
  95        reg = readl(RSTOUTn_MASK);
  96        reg &= ~WDT_RESET_OUT_EN;
  97        writel(reg, RSTOUTn_MASK);
  98
  99        /* Disable watchdog timer */
 100        reg = readl(wdt_reg + TIMER_CTRL);
 101        reg &= ~WDT_EN;
 102        writel(reg, wdt_reg + TIMER_CTRL);
 103
 104        spin_unlock(&wdt_lock);
 105        return 0;
 106}
 107
 108static unsigned int orion_wdt_get_timeleft(struct watchdog_device *wdt_dev)
 109{
 110        unsigned int time_left;
 111
 112        spin_lock(&wdt_lock);
 113        time_left = readl(wdt_reg + WDT_VAL) / wdt_tclk;
 114        spin_unlock(&wdt_lock);
 115
 116        return time_left;
 117}
 118
 119static int orion_wdt_set_timeout(struct watchdog_device *wdt_dev,
 120                                 unsigned int timeout)
 121{
 122        wdt_dev->timeout = timeout;
 123        return 0;
 124}
 125
 126static const struct watchdog_info orion_wdt_info = {
 127        .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE,
 128        .identity = "Orion Watchdog",
 129};
 130
 131static const struct watchdog_ops orion_wdt_ops = {
 132        .owner = THIS_MODULE,
 133        .start = orion_wdt_start,
 134        .stop = orion_wdt_stop,
 135        .ping = orion_wdt_ping,
 136        .set_timeout = orion_wdt_set_timeout,
 137        .get_timeleft = orion_wdt_get_timeleft,
 138};
 139
 140static struct watchdog_device orion_wdt = {
 141        .info = &orion_wdt_info,
 142        .ops = &orion_wdt_ops,
 143};
 144
 145static int __devinit orion_wdt_probe(struct platform_device *pdev)
 146{
 147        struct resource *res;
 148        int ret;
 149
 150        clk = devm_clk_get(&pdev->dev, NULL);
 151        if (IS_ERR(clk)) {
 152                dev_err(&pdev->dev, "Orion Watchdog missing clock\n");
 153                return -ENODEV;
 154        }
 155        clk_prepare_enable(clk);
 156        wdt_tclk = clk_get_rate(clk);
 157
 158        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 159        wdt_reg = devm_ioremap(&pdev->dev, res->start, resource_size(res));
 160        if (!wdt_reg)
 161                return -ENOMEM;
 162
 163        wdt_max_duration = WDT_MAX_CYCLE_COUNT / wdt_tclk;
 164
 165        if ((heartbeat < 1) || (heartbeat > wdt_max_duration))
 166                heartbeat = wdt_max_duration;
 167
 168        orion_wdt.timeout = heartbeat;
 169        orion_wdt.min_timeout = 1;
 170        orion_wdt.max_timeout = wdt_max_duration;
 171
 172        watchdog_set_nowayout(&orion_wdt, nowayout);
 173        ret = watchdog_register_device(&orion_wdt);
 174        if (ret) {
 175                clk_disable_unprepare(clk);
 176                return ret;
 177        }
 178
 179        pr_info("Initial timeout %d sec%s\n",
 180                heartbeat, nowayout ? ", nowayout" : "");
 181        return 0;
 182}
 183
 184static int __devexit orion_wdt_remove(struct platform_device *pdev)
 185{
 186        watchdog_unregister_device(&orion_wdt);
 187        clk_disable_unprepare(clk);
 188        return 0;
 189}
 190
 191static void orion_wdt_shutdown(struct platform_device *pdev)
 192{
 193        orion_wdt_stop(&orion_wdt);
 194}
 195
 196static const struct of_device_id orion_wdt_of_match_table[] __devinitdata = {
 197        { .compatible = "marvell,orion-wdt", },
 198        {},
 199};
 200MODULE_DEVICE_TABLE(of, orion_wdt_of_match_table);
 201
 202static struct platform_driver orion_wdt_driver = {
 203        .probe          = orion_wdt_probe,
 204        .remove         = __devexit_p(orion_wdt_remove),
 205        .shutdown       = orion_wdt_shutdown,
 206        .driver         = {
 207                .owner  = THIS_MODULE,
 208                .name   = "orion_wdt",
 209                .of_match_table = of_match_ptr(orion_wdt_of_match_table),
 210        },
 211};
 212
 213module_platform_driver(orion_wdt_driver);
 214
 215MODULE_AUTHOR("Sylver Bruneau <sylver.bruneau@googlemail.com>");
 216MODULE_DESCRIPTION("Orion Processor Watchdog");
 217
 218module_param(heartbeat, int, 0);
 219MODULE_PARM_DESC(heartbeat, "Initial watchdog heartbeat in seconds");
 220
 221module_param(nowayout, bool, 0);
 222MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default="
 223                                __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
 224
 225MODULE_LICENSE("GPL");
 226MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
 227
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.