cregit-Linux how code gets into the kernel

Release 4.10 drivers/watchdog/sp805_wdt.c

Directory: drivers/watchdog
/*
 * drivers/char/watchdog/sp805-wdt.c
 *
 * Watchdog driver for ARM SP805 watchdog module
 *
 * Copyright (C) 2010 ST Microelectronics
 * Viresh Kumar <vireshk@kernel.org>
 *
 * 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/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: sp805 wdt device structure
 * @wdd: instance of struct watchdog_device
 * @lock: spin lock protecting dev structure and io access
 * @base: base address of wdt
 * @clk: clock structure of wdt
 * @adev: amba device structure of wdt
 * @status: current status of wdt
 * @load_val: load value to be set for current timeout
 */

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


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 */ wdd->timeout = div_u64((load + 1) * 2 + (rate / 2), rate); spin_unlock(&wdt->lock); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
viresh kumarviresh kumar12599.21%375.00%
lucas de marchilucas de marchi10.79%125.00%
Total126100.00%4100.00%

/* 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); }

Contributors

PersonTokensPropCommitsCommitProp
viresh kumarviresh kumar96100.00%3100.00%
Total96100.00%3100.00%


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_enable(wdt->clk); if (ret) { dev_err(&wdt->adev->dev, "clock enable fail"); return ret; } } spin_lock(&wdt->lock); writel_relaxed(UNLOCK, wdt->base + WDTLOCK); writel_relaxed(wdt->load_val, wdt->base + WDTLOAD); writel_relaxed(INT_MASK, wdt->base + WDTINTCLR); if (!ping) 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; }

Contributors

PersonTokensPropCommitsCommitProp
viresh kumarviresh kumar14290.45%350.00%
nick bowlernick bowler95.73%116.67%
sandeep tripathysandeep tripathy53.18%116.67%
julia lawalljulia lawall10.64%116.67%
Total157100.00%6100.00%


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

Contributors

PersonTokensPropCommitsCommitProp
viresh kumarviresh kumar19100.00%1100.00%
Total19100.00%1100.00%

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

Contributors

PersonTokensPropCommitsCommitProp
viresh kumarviresh kumar19100.00%2100.00%
Total19100.00%2100.00%

/* 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_unprepare(wdt->clk); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
viresh kumarviresh kumar8088.89%466.67%
nick bowlernick bowler910.00%116.67%
julia lawalljulia lawall11.11%116.67%
Total90100.00%6100.00%

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 sp805_wdt_probe(struct amba_device *adev, const struct amba_id *id) { struct sp805_wdt *wdt; int ret = 0; wdt = devm_kzalloc(&adev->dev, sizeof(*wdt), GFP_KERNEL); if (!wdt) { ret = -ENOMEM; goto err; } wdt->base = devm_ioremap_resource(&adev->dev, &adev->res); if (IS_ERR(wdt->base)) return PTR_ERR(wdt->base); wdt->clk = devm_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; wdt->wdd.parent = &adev->dev; 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; } amba_set_drvdata(adev, wdt); dev_info(&adev->dev, "registration successful\n"); return 0; err: dev_err(&adev->dev, "Probe Failed!!!\n"); return ret; }

Contributors

PersonTokensPropCommitsCommitProp
viresh kumarviresh kumar25791.79%342.86%
pratyush anandpratyush anand113.93%114.29%
jingoo hanjingoo han113.93%228.57%
russell kingrussell king10.36%114.29%
Total280100.00%7100.00%


static int sp805_wdt_remove(struct amba_device *adev) { struct sp805_wdt *wdt = amba_get_drvdata(adev); watchdog_unregister_device(&wdt->wdd); watchdog_set_drvdata(&wdt->wdd, NULL); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
viresh kumarviresh kumar42100.00%2100.00%
Total42100.00%2100.00%


static int __maybe_unused 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; }

Contributors

PersonTokensPropCommitsCommitProp
viresh kumarviresh kumar4397.73%266.67%
russell kingrussell king12.27%133.33%
Total44100.00%3100.00%


static int __maybe_unused 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; }

Contributors

PersonTokensPropCommitsCommitProp
viresh kumarviresh kumar4397.73%266.67%
russell kingrussell king12.27%133.33%
Total44100.00%3100.00%

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 = sp805_wdt_remove, }; module_amba_driver(sp805_wdt_driver); MODULE_AUTHOR("Viresh Kumar <vireshk@kernel.org>"); MODULE_DESCRIPTION("ARM SP805 Watchdog Driver"); MODULE_LICENSE("GPL");

Overall Contributors

PersonTokensPropCommitsCommitProp
viresh kumarviresh kumar119395.29%945.00%
nick bowlernick bowler181.44%15.00%
pratyush anandpratyush anand110.88%15.00%
jingoo hanjingoo han110.88%210.00%
dave martindave martin70.56%15.00%
sandeep tripathysandeep tripathy50.40%15.00%
russell kingrussell king30.24%210.00%
julia lawalljulia lawall20.16%15.00%
wim van sebroeckwim van sebroeck10.08%15.00%
lucas de marchilucas de marchi10.08%15.00%
Total1252100.00%20100.00%
Directory: drivers/watchdog
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.