sp805_wdt.c

Go to the documentation of this file.

/*
 * drivers/char/watchdog/sp805-wdt.c
 *
 * Watchdog driver for ARM SP805 watchdog module
 *
 * Copyright (C) 2010 ST Microelectronics
 * Viresh Kumar <[email protected]>
 *
 * This file is licensed under the terms of the GNU General Public
 * License version 2 or later. This program is licensed "as is" without any
 * warranty of any kind, whether express or implied.
 */

#include <linux/device.h>
#include <linux/resource.h>
#include <linux/amba/bus.h>
#include <linux/bitops.h>
#include <linux/clk.h>
#include <linux/init.h>
#include <linux/io.h>
#include <linux/ioport.h>
#include <linux/kernel.h>
#include <linux/math64.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/pm.h>
#include <linux/slab.h>
#include <linux/spinlock.h>
#include <linux/types.h>
#include <linux/watchdog.h>

/* default timeout in seconds */
#define DEFAULT_TIMEOUT     60

#define MODULE_NAME     "sp805-wdt"

/* watchdog register offsets and masks */
#define WDTLOAD         0x000
    #define LOAD_MIN    0x00000001
    #define LOAD_MAX    0xFFFFFFFF
#define WDTVALUE        0x004
#define WDTCONTROL      0x008
    /* control register masks */
    #define INT_ENABLE  (1 << 0)
    #define RESET_ENABLE    (1 << 1)
#define WDTINTCLR       0x00C
#define WDTRIS          0x010
#define WDTMIS          0x014
    #define INT_MASK    (1 << 0)
#define WDTLOCK         0xC00
    #define UNLOCK      0x1ACCE551
    #define LOCK        0x00000001

struct sp805_wdt {
    struct watchdog_device      wdd;
    spinlock_t          lock;
    void __iomem            *base;
    struct clk          *clk;
    struct amba_device      *adev;
    unsigned int            load_val;
    unsigned int            timeout;
};

static bool nowayout = WATCHDOG_NOWAYOUT;
module_param(nowayout, bool, 0);
MODULE_PARM_DESC(nowayout,
        "Set to 1 to keep watchdog running after device release");

/* This routine finds load value that will reset system in required timout */
static int wdt_setload(struct watchdog_device *wdd, unsigned int timeout)
{
    struct sp805_wdt *wdt = watchdog_get_drvdata(wdd);
    u64 load, rate;

    rate = clk_get_rate(wdt->clk);

    /*
     * sp805 runs counter with given value twice, after the end of first
     * counter it gives an interrupt and then starts counter again. If
     * interrupt already occurred then it resets the system. This is why
     * load is half of what should be required.
     */
    load = div_u64(rate, 2) * timeout - 1;

    load = (load > LOAD_MAX) ? LOAD_MAX : load;
    load = (load < LOAD_MIN) ? LOAD_MIN : load;

    spin_lock(&wdt->lock);
    wdt->load_val = load;
    /* roundup timeout to closest positive integer value */
    wdt->timeout = div_u64((load + 1) * 2 + (rate / 2), rate);
    spin_unlock(&wdt->lock);

    return 0;
}

/* returns number of seconds left for reset to occur */
static unsigned int wdt_timeleft(struct watchdog_device *wdd)
{
    struct sp805_wdt *wdt = watchdog_get_drvdata(wdd);
    u64 load, rate;

    rate = clk_get_rate(wdt->clk);

    spin_lock(&wdt->lock);
    load = readl_relaxed(wdt->base + WDTVALUE);

    /*If the interrupt is inactive then time left is WDTValue + WDTLoad. */
    if (!(readl_relaxed(wdt->base + WDTRIS) & INT_MASK))
        load += wdt->load_val + 1;
    spin_unlock(&wdt->lock);

    return div_u64(load, rate);
}

static int wdt_config(struct watchdog_device *wdd, bool ping)
{
    struct sp805_wdt *wdt = watchdog_get_drvdata(wdd);
    int ret;

    if (!ping) {
        ret = clk_prepare(wdt->clk);
        if (ret) {
            dev_err(&wdt->adev->dev, "clock prepare fail");
            return ret;
        }

        ret = clk_enable(wdt->clk);
        if (ret) {
            dev_err(&wdt->adev->dev, "clock enable fail");
            clk_unprepare(wdt->clk);
            return ret;
        }
    }

    spin_lock(&wdt->lock);

    writel_relaxed(UNLOCK, wdt->base + WDTLOCK);
    writel_relaxed(wdt->load_val, wdt->base + WDTLOAD);

    if (!ping) {
        writel_relaxed(INT_MASK, wdt->base + WDTINTCLR);
        writel_relaxed(INT_ENABLE | RESET_ENABLE, wdt->base +
                WDTCONTROL);
    }

    writel_relaxed(LOCK, wdt->base + WDTLOCK);

    /* Flush posted writes. */
    readl_relaxed(wdt->base + WDTLOCK);
    spin_unlock(&wdt->lock);

    return 0;
}

static int wdt_ping(struct watchdog_device *wdd)
{
    return wdt_config(wdd, true);
}

/* enables watchdog timers reset */
static int wdt_enable(struct watchdog_device *wdd)
{
    return wdt_config(wdd, false);
}

/* disables watchdog timers reset */
static int wdt_disable(struct watchdog_device *wdd)
{
    struct sp805_wdt *wdt = watchdog_get_drvdata(wdd);

    spin_lock(&wdt->lock);

    writel_relaxed(UNLOCK, wdt->base + WDTLOCK);
    writel_relaxed(0, wdt->base + WDTCONTROL);
    writel_relaxed(LOCK, wdt->base + WDTLOCK);

    /* Flush posted writes. */
    readl_relaxed(wdt->base + WDTLOCK);
    spin_unlock(&wdt->lock);

    clk_disable(wdt->clk);
    clk_unprepare(wdt->clk);

    return 0;
}

static const struct watchdog_info wdt_info = {
    .options = WDIOF_MAGICCLOSE | WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING,
    .identity = MODULE_NAME,
};

static const struct watchdog_ops wdt_ops = {
    .owner      = THIS_MODULE,
    .start      = wdt_enable,
    .stop       = wdt_disable,
    .ping       = wdt_ping,
    .set_timeout    = wdt_setload,
    .get_timeleft   = wdt_timeleft,
};

static int __devinit
sp805_wdt_probe(struct amba_device *adev, const struct amba_id *id)
{
    struct sp805_wdt *wdt;
    int ret = 0;

    if (!devm_request_mem_region(&adev->dev, adev->res.start,
                resource_size(&adev->res), "sp805_wdt")) {
        dev_warn(&adev->dev, "Failed to get memory region resource\n");
        ret = -ENOENT;
        goto err;
    }

    wdt = devm_kzalloc(&adev->dev, sizeof(*wdt), GFP_KERNEL);
    if (!wdt) {
        dev_warn(&adev->dev, "Kzalloc failed\n");
        ret = -ENOMEM;
        goto err;
    }

    wdt->base = devm_ioremap(&adev->dev, adev->res.start,
            resource_size(&adev->res));
    if (!wdt->base) {
        ret = -ENOMEM;
        dev_warn(&adev->dev, "ioremap fail\n");
        goto err;
    }

    wdt->clk = clk_get(&adev->dev, NULL);
    if (IS_ERR(wdt->clk)) {
        dev_warn(&adev->dev, "Clock not found\n");
        ret = PTR_ERR(wdt->clk);
        goto err;
    }

    wdt->adev = adev;
    wdt->wdd.info = &wdt_info;
    wdt->wdd.ops = &wdt_ops;

    spin_lock_init(&wdt->lock);
    watchdog_set_nowayout(&wdt->wdd, nowayout);
    watchdog_set_drvdata(&wdt->wdd, wdt);
    wdt_setload(&wdt->wdd, DEFAULT_TIMEOUT);

    ret = watchdog_register_device(&wdt->wdd);
    if (ret) {
        dev_err(&adev->dev, "watchdog_register_device() failed: %d\n",
                ret);
        goto err_register;
    }
    amba_set_drvdata(adev, wdt);

    dev_info(&adev->dev, "registration successful\n");
    return 0;

err_register:
    clk_put(wdt->clk);
err:
    dev_err(&adev->dev, "Probe Failed!!!\n");
    return ret;
}

static int __devexit sp805_wdt_remove(struct amba_device *adev)
{
    struct sp805_wdt *wdt = amba_get_drvdata(adev);

    watchdog_unregister_device(&wdt->wdd);
    amba_set_drvdata(adev, NULL);
    watchdog_set_drvdata(&wdt->wdd, NULL);
    clk_put(wdt->clk);

    return 0;
}

#ifdef CONFIG_PM
static int sp805_wdt_suspend(struct device *dev)
{
    struct sp805_wdt *wdt = dev_get_drvdata(dev);

    if (watchdog_active(&wdt->wdd))
        return wdt_disable(&wdt->wdd);

    return 0;
}

static int sp805_wdt_resume(struct device *dev)
{
    struct sp805_wdt *wdt = dev_get_drvdata(dev);

    if (watchdog_active(&wdt->wdd))
        return wdt_enable(&wdt->wdd);

    return 0;
}
#endif /* CONFIG_PM */

static SIMPLE_DEV_PM_OPS(sp805_wdt_dev_pm_ops, sp805_wdt_suspend,
        sp805_wdt_resume);

static struct amba_id sp805_wdt_ids[] = {
    {
        .id = 0x00141805,
        .mask   = 0x00ffffff,
    },
    { 0, 0 },
};

MODULE_DEVICE_TABLE(amba, sp805_wdt_ids);

static struct amba_driver sp805_wdt_driver = {
    .drv = {
        .name   = MODULE_NAME,
        .pm = &sp805_wdt_dev_pm_ops,
    },
    .id_table   = sp805_wdt_ids,
    .probe      = sp805_wdt_probe,
    .remove = __devexit_p(sp805_wdt_remove),
};

module_amba_driver(sp805_wdt_driver);

MODULE_AUTHOR("Viresh Kumar <[email protected]>");
MODULE_DESCRIPTION("ARM SP805 Watchdog Driver");
MODULE_LICENSE("GPL");