From patchwork Wed Dec 16 10:27:59 2015 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jisheng Zhang X-Patchwork-Id: 7860721 Return-Path: X-Original-To: patchwork-linux-arm@patchwork.kernel.org Delivered-To: patchwork-parsemail@patchwork2.web.kernel.org Received: from mail.kernel.org (mail.kernel.org [198.145.29.136]) by patchwork2.web.kernel.org (Postfix) with ESMTP id 05F20BEEE1 for ; Wed, 16 Dec 2015 10:33:48 +0000 (UTC) Received: from mail.kernel.org (localhost [127.0.0.1]) by mail.kernel.org (Postfix) with ESMTP id 93B2720396 for ; Wed, 16 Dec 2015 10:33:46 +0000 (UTC) Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.9]) (using TLSv1.2 with cipher AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 2970F20382 for ; Wed, 16 Dec 2015 10:33:45 +0000 (UTC) Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.80.1 #2 (Red Hat Linux)) id 1a99NT-0008PS-05; Wed, 16 Dec 2015 10:32:11 +0000 Received: from mx0a-0016f401.pphosted.com ([67.231.148.174]) by bombadil.infradead.org with esmtps (Exim 4.80.1 #2 (Red Hat Linux)) id 1a99NO-0008JR-IJ for linux-arm-kernel@lists.infradead.org; Wed, 16 Dec 2015 10:32:08 +0000 Received: from pps.filterd (m0045849.ppops.net [127.0.0.1]) by mx0a-0016f401.pphosted.com (8.15.0.59/8.15.0.59) with SMTP id tBGATsuY020519; Wed, 16 Dec 2015 02:31:41 -0800 Received: from sc-exch02.marvell.com ([199.233.58.182]) by mx0a-0016f401.pphosted.com with ESMTP id 1yu4xy86mm-1 (version=TLSv1/SSLv3 cipher=ECDHE-RSA-AES256-SHA384 bits=256 verify=NOT); Wed, 16 Dec 2015 02:31:41 -0800 Received: from SC-EXCH04.marvell.com (10.93.176.84) by SC-EXCH02.marvell.com (10.93.176.82) with Microsoft SMTP Server (TLS) id 15.0.1104.5; Wed, 16 Dec 2015 02:31:40 -0800 Received: from maili.marvell.com (10.93.176.43) by SC-EXCH04.marvell.com (10.93.176.84) with Microsoft SMTP Server id 15.0.1104.5 via Frontend Transport; Wed, 16 Dec 2015 02:31:40 -0800 Received: from xhacker.marvell.com (unknown [10.37.135.134]) by maili.marvell.com (Postfix) with ESMTP id 13AE33F703F; Wed, 16 Dec 2015 02:31:38 -0800 (PST) From: Jisheng Zhang To: , , Subject: [PATCH] watchdog: dw_wdt: convert to watchdog core api Date: Wed, 16 Dec 2015 18:27:59 +0800 Message-ID: <1450261679-1516-1-git-send-email-jszhang@marvell.com> X-Mailer: git-send-email 2.6.4 MIME-Version: 1.0 X-Proofpoint-Virus-Version: vendor=fsecure engine=2.50.10432:, , definitions=2015-12-16_06:, , signatures=0 X-Proofpoint-Spam-Details: rule=inbound_notspam policy=inbound score=0 spamscore=0 suspectscore=0 malwarescore=0 phishscore=0 adultscore=0 bulkscore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.0.1-1507310007 definitions=main-1512160173 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20151216_023206_639411_EA8D988A X-CRM114-Status: GOOD ( 23.50 ) X-Spam-Score: -2.6 (--) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.20 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Jisheng Zhang , linux-watchdog@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org X-Spam-Status: No, score=-4.2 required=5.0 tests=BAYES_00, RCVD_IN_DNSWL_MED, T_RP_MATCHES_RCVD, UNPARSEABLE_RELAY autolearn=unavailable version=3.3.1 X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on mail.kernel.org X-Virus-Scanned: ClamAV using ClamSMTP Convert the dw_wdt driver to the new watchdog core api. Signed-off-by: Jisheng Zhang --- This patch depends on the signedness bug fix patch: http://lists.infradead.org/pipermail/linux-arm-kernel/2015-December/393872.html drivers/watchdog/Kconfig | 1 + drivers/watchdog/dw_wdt.c | 316 +++++++++++++++++++--------------------------- 2 files changed, 131 insertions(+), 186 deletions(-) diff --git a/drivers/watchdog/Kconfig b/drivers/watchdog/Kconfig index 7a8a6c6..886468a 100644 --- a/drivers/watchdog/Kconfig +++ b/drivers/watchdog/Kconfig @@ -291,6 +291,7 @@ config SA1100_WATCHDOG config DW_WATCHDOG tristate "Synopsys DesignWare watchdog" depends on HAS_IOMEM + select WATCHDOG_CORE help Say Y here if to include support for the Synopsys DesignWare watchdog timer found in many chips. diff --git a/drivers/watchdog/dw_wdt.c b/drivers/watchdog/dw_wdt.c index 8fefa4ad..9e8706a 100644 --- a/drivers/watchdog/dw_wdt.c +++ b/drivers/watchdog/dw_wdt.c @@ -24,10 +24,8 @@ #include #include #include -#include #include #include -#include #include #include #include @@ -36,7 +34,6 @@ #include #include #include -#include #include #define WDOG_CONTROL_REG_OFFSET 0x00 @@ -59,59 +56,60 @@ MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started " #define WDT_TIMEOUT (HZ / 2) -static struct { +struct dw_wdt_device { void __iomem *regs; struct clk *clk; - unsigned long in_use; - unsigned long next_heartbeat; struct timer_list timer; - int expect_close; + struct watchdog_device wdog; struct notifier_block restart_handler; -} dw_wdt; +}; -static inline int dw_wdt_is_enabled(void) +static inline bool dw_wdt_is_enabled(struct dw_wdt_device *wdev) { - return readl(dw_wdt.regs + WDOG_CONTROL_REG_OFFSET) & + return readl(wdev->regs + WDOG_CONTROL_REG_OFFSET) & WDOG_CONTROL_REG_WDT_EN_MASK; } -static inline int dw_wdt_top_in_seconds(unsigned top) +static inline unsigned int dw_wdt_top_in_seconds(struct dw_wdt_device *wdev, + unsigned int top) { /* * There are 16 possible timeout values in 0..15 where the number of * cycles is 2 ^ (16 + i) and the watchdog counts down. */ - return (1U << (16 + top)) / clk_get_rate(dw_wdt.clk); + return (1U << (16 + top)) / clk_get_rate(wdev->clk); } -static int dw_wdt_get_top(void) +static unsigned int dw_wdt_get_timeleft(struct watchdog_device *wdog) { - int top = readl(dw_wdt.regs + WDOG_TIMEOUT_RANGE_REG_OFFSET) & 0xF; + struct dw_wdt_device *wdev = watchdog_get_drvdata(wdog); - return dw_wdt_top_in_seconds(top); + return readl(wdev->regs + WDOG_CURRENT_COUNT_REG_OFFSET) / + clk_get_rate(wdev->clk); } -static inline void dw_wdt_set_next_heartbeat(void) +static int dw_wdt_ping(struct watchdog_device *wdog) { - dw_wdt.next_heartbeat = jiffies + dw_wdt_get_top() * HZ; -} + struct dw_wdt_device *wdev = watchdog_get_drvdata(wdog); -static void dw_wdt_keepalive(void) -{ - writel(WDOG_COUNTER_RESTART_KICK_VALUE, dw_wdt.regs + + writel(WDOG_COUNTER_RESTART_KICK_VALUE, wdev->regs + WDOG_COUNTER_RESTART_REG_OFFSET); + + return 0; } -static int dw_wdt_set_top(unsigned top_s) +static int dw_wdt_set_timeout(struct watchdog_device *wdog, + unsigned int new_timeout) { - int i, top_val = DW_WDT_MAX_TOP; + unsigned int i, top_val = DW_WDT_MAX_TOP; + struct dw_wdt_device *wdev = watchdog_get_drvdata(wdog); /* * Iterate over the timeout values until we find the closest match. We * always look for >=. */ for (i = 0; i <= DW_WDT_MAX_TOP; ++i) - if (dw_wdt_top_in_seconds(i) >= top_s) { + if (dw_wdt_top_in_seconds(wdev, i) >= new_timeout) { top_val = i; break; } @@ -123,33 +121,34 @@ static int dw_wdt_set_top(unsigned top_s) * effectively get a pat of the watchdog right here. */ writel(top_val | top_val << WDOG_TIMEOUT_RANGE_TOPINIT_SHIFT, - dw_wdt.regs + WDOG_TIMEOUT_RANGE_REG_OFFSET); + wdev->regs + WDOG_TIMEOUT_RANGE_REG_OFFSET); /* * Add an explicit pat to handle versions of the watchdog that * don't have TOPINIT. This won't hurt on versions that have * it. */ - dw_wdt_keepalive(); - - dw_wdt_set_next_heartbeat(); + dw_wdt_ping(wdog); - return dw_wdt_top_in_seconds(top_val); + return 0; } static int dw_wdt_restart_handle(struct notifier_block *this, unsigned long mode, void *cmd) { u32 val; + struct dw_wdt_device *wdev = container_of(this, + struct dw_wdt_device, + restart_handler); - writel(0, dw_wdt.regs + WDOG_TIMEOUT_RANGE_REG_OFFSET); - val = readl(dw_wdt.regs + WDOG_CONTROL_REG_OFFSET); + writel(0, wdev->regs + WDOG_TIMEOUT_RANGE_REG_OFFSET); + val = readl(wdev->regs + WDOG_CONTROL_REG_OFFSET); if (val & WDOG_CONTROL_REG_WDT_EN_MASK) - writel(WDOG_COUNTER_RESTART_KICK_VALUE, dw_wdt.regs + + writel(WDOG_COUNTER_RESTART_KICK_VALUE, wdev->regs + WDOG_COUNTER_RESTART_REG_OFFSET); else writel(WDOG_CONTROL_REG_WDT_EN_MASK, - dw_wdt.regs + WDOG_CONTROL_REG_OFFSET); + wdev->regs + WDOG_CONTROL_REG_OFFSET); /* wait for reset to assert... */ mdelay(500); @@ -157,74 +156,52 @@ static int dw_wdt_restart_handle(struct notifier_block *this, return NOTIFY_DONE; } -static void dw_wdt_ping(unsigned long data) +static void dw_wdt_timer_ping(unsigned long arg) { - if (time_before(jiffies, dw_wdt.next_heartbeat) || - (!nowayout && !dw_wdt.in_use)) { - dw_wdt_keepalive(); - mod_timer(&dw_wdt.timer, jiffies + WDT_TIMEOUT); - } else - pr_crit("keepalive missed, machine will reset\n"); + struct watchdog_device *wdog = (struct watchdog_device *)arg; + struct dw_wdt_device *wdev = watchdog_get_drvdata(wdog); + + /* ping it every wdog->timeout / 2 seconds to prevent reboot */ + dw_wdt_ping(wdog); + mod_timer(&wdev->timer, jiffies + wdog->timeout * HZ / 2); } -static int dw_wdt_open(struct inode *inode, struct file *filp) +static int dw_wdt_start(struct watchdog_device *wdog) { - if (test_and_set_bit(0, &dw_wdt.in_use)) - return -EBUSY; - - /* Make sure we don't get unloaded. */ - __module_get(THIS_MODULE); - - if (!dw_wdt_is_enabled()) { - /* - * The watchdog is not currently enabled. Set the timeout to - * something reasonable and then start it. - */ - dw_wdt_set_top(DW_WDT_DEFAULT_SECONDS); + struct dw_wdt_device *wdev = watchdog_get_drvdata(wdog); + + if (!dw_wdt_is_enabled(wdev)) { + dw_wdt_set_timeout(wdog, wdog->timeout); writel(WDOG_CONTROL_REG_WDT_EN_MASK, - dw_wdt.regs + WDOG_CONTROL_REG_OFFSET); + wdev->regs + WDOG_CONTROL_REG_OFFSET); + } else { + /* delete the timer that pings the watchdog after close */ + del_timer_sync(&wdev->timer); + dw_wdt_set_timeout(wdog, wdog->timeout); } - dw_wdt_set_next_heartbeat(); - - return nonseekable_open(inode, filp); + return 0; } -static ssize_t dw_wdt_write(struct file *filp, const char __user *buf, - size_t len, loff_t *offset) +static int dw_wdt_stop(struct watchdog_device *wdog) { - if (!len) - return 0; - - if (!nowayout) { - size_t i; - - dw_wdt.expect_close = 0; - - for (i = 0; i < len; ++i) { - char c; - - if (get_user(c, buf + i)) - return -EFAULT; - - if (c == 'V') { - dw_wdt.expect_close = 1; - break; - } - } - } - - dw_wdt_set_next_heartbeat(); - dw_wdt_keepalive(); - mod_timer(&dw_wdt.timer, jiffies + WDT_TIMEOUT); - - return len; + /* + * We don't need a clk_disable_unprepare, the wdt cannot be disabled + * once started. We use a timer to ping the watchdog while the + * /dev/watchdog is closed + */ + dw_wdt_timer_ping((unsigned long)wdog); + return 0; } -static u32 dw_wdt_time_left(void) +static inline void dw_wdt_ping_if_active(struct watchdog_device *wdog) { - return readl(dw_wdt.regs + WDOG_CURRENT_COUNT_REG_OFFSET) / - clk_get_rate(dw_wdt.clk); + struct dw_wdt_device *wdev = watchdog_get_drvdata(wdog); + + if (dw_wdt_is_enabled(wdev)) { + dw_wdt_set_timeout(wdog, wdog->timeout); + dw_wdt_timer_ping((unsigned long)wdog); + } } static const struct watchdog_info dw_wdt_ident = { @@ -233,78 +210,37 @@ static const struct watchdog_info dw_wdt_ident = { .identity = "Synopsys DesignWare Watchdog", }; -static long dw_wdt_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) -{ - unsigned long val; - int timeout; - - switch (cmd) { - case WDIOC_GETSUPPORT: - return copy_to_user((void __user *)arg, &dw_wdt_ident, - sizeof(dw_wdt_ident)) ? -EFAULT : 0; - - case WDIOC_GETSTATUS: - case WDIOC_GETBOOTSTATUS: - return put_user(0, (int __user *)arg); - - case WDIOC_KEEPALIVE: - dw_wdt_set_next_heartbeat(); - return 0; - - case WDIOC_SETTIMEOUT: - if (get_user(val, (int __user *)arg)) - return -EFAULT; - timeout = dw_wdt_set_top(val); - return put_user(timeout , (int __user *)arg); - - case WDIOC_GETTIMEOUT: - return put_user(dw_wdt_get_top(), (int __user *)arg); - - case WDIOC_GETTIMELEFT: - /* Get the time left until expiry. */ - if (get_user(val, (int __user *)arg)) - return -EFAULT; - return put_user(dw_wdt_time_left(), (int __user *)arg); - - default: - return -ENOTTY; - } -} - -static int dw_wdt_release(struct inode *inode, struct file *filp) -{ - clear_bit(0, &dw_wdt.in_use); - - if (!dw_wdt.expect_close) { - del_timer(&dw_wdt.timer); - - if (!nowayout) - pr_crit("unexpected close, system will reboot soon\n"); - else - pr_crit("watchdog cannot be disabled, system will reboot soon\n"); - } - - dw_wdt.expect_close = 0; - - return 0; -} +static const struct watchdog_ops dw_wdt_ops = { + .owner = THIS_MODULE, + .start = dw_wdt_start, + .stop = dw_wdt_stop, + .ping = dw_wdt_ping, + .set_timeout = dw_wdt_set_timeout, + .get_timeleft = dw_wdt_get_timeleft, +}; #ifdef CONFIG_PM_SLEEP static int dw_wdt_suspend(struct device *dev) { - clk_disable_unprepare(dw_wdt.clk); + struct watchdog_device *wdog = dev_get_drvdata(dev); + struct dw_wdt_device *wdev = watchdog_get_drvdata(wdog); + + clk_disable_unprepare(wdev->clk); return 0; } static int dw_wdt_resume(struct device *dev) { - int err = clk_prepare_enable(dw_wdt.clk); + struct watchdog_device *wdog = dev_get_drvdata(dev); + struct dw_wdt_device *wdev = watchdog_get_drvdata(wdog); + + int err = clk_prepare_enable(wdev->clk); if (err) return err; - dw_wdt_keepalive(); + dw_wdt_ping(wdog); return 0; } @@ -312,67 +248,75 @@ static int dw_wdt_resume(struct device *dev) static SIMPLE_DEV_PM_OPS(dw_wdt_pm_ops, dw_wdt_suspend, dw_wdt_resume); -static const struct file_operations wdt_fops = { - .owner = THIS_MODULE, - .llseek = no_llseek, - .open = dw_wdt_open, - .write = dw_wdt_write, - .unlocked_ioctl = dw_wdt_ioctl, - .release = dw_wdt_release -}; - -static struct miscdevice dw_wdt_miscdev = { - .fops = &wdt_fops, - .name = "watchdog", - .minor = WATCHDOG_MINOR, -}; - static int dw_wdt_drv_probe(struct platform_device *pdev) { int ret; - struct resource *mem = platform_get_resource(pdev, IORESOURCE_MEM, 0); - - dw_wdt.regs = devm_ioremap_resource(&pdev->dev, mem); - if (IS_ERR(dw_wdt.regs)) - return PTR_ERR(dw_wdt.regs); - - dw_wdt.clk = devm_clk_get(&pdev->dev, NULL); - if (IS_ERR(dw_wdt.clk)) - return PTR_ERR(dw_wdt.clk); - - ret = clk_prepare_enable(dw_wdt.clk); + struct dw_wdt_device *wdev; + struct watchdog_device *wdog; + struct resource *mem; + + wdev = devm_kzalloc(&pdev->dev, sizeof(*wdev), GFP_KERNEL); + if (!wdev) + return -ENOMEM; + + mem = platform_get_resource(pdev, IORESOURCE_MEM, 0); + wdev->regs = devm_ioremap_resource(&pdev->dev, mem); + if (IS_ERR(wdev->regs)) + return PTR_ERR(wdev->regs); + + wdev->clk = devm_clk_get(&pdev->dev, NULL); + if (IS_ERR(wdev->clk)) + return PTR_ERR(wdev->clk); + + wdog = &wdev->wdog; + wdog->info = &dw_wdt_ident; + wdog->ops = &dw_wdt_ops; + wdog->min_timeout = dw_wdt_top_in_seconds(wdev, 0); + wdog->max_timeout = dw_wdt_top_in_seconds(wdev, DW_WDT_MAX_TOP); + + ret = clk_prepare_enable(wdev->clk); if (ret) return ret; - ret = misc_register(&dw_wdt_miscdev); - if (ret) - goto out_disable_clk; + platform_set_drvdata(pdev, wdog); + watchdog_set_drvdata(wdog, wdev); + watchdog_set_nowayout(wdog, nowayout); + watchdog_init_timeout(wdog, wdog->max_timeout, &pdev->dev); - dw_wdt.restart_handler.notifier_call = dw_wdt_restart_handle; - dw_wdt.restart_handler.priority = 128; - ret = register_restart_handler(&dw_wdt.restart_handler); + wdev->restart_handler.notifier_call = dw_wdt_restart_handle; + wdev->restart_handler.priority = 128; + ret = register_restart_handler(&wdev->restart_handler); if (ret) - pr_warn("cannot register restart handler\n"); + dev_warn(&pdev->dev, "cannot register restart handler\n"); - dw_wdt_set_next_heartbeat(); - setup_timer(&dw_wdt.timer, dw_wdt_ping, 0); - mod_timer(&dw_wdt.timer, jiffies + WDT_TIMEOUT); + setup_timer(&wdev->timer, dw_wdt_timer_ping, (unsigned long)wdog); + + dw_wdt_ping_if_active(wdog); + + ret = watchdog_register_device(wdog); + if (ret) { + dev_err(&pdev->dev, "cannot register watchdog device\n"); + goto out_disable_clk; + } return 0; out_disable_clk: - clk_disable_unprepare(dw_wdt.clk); + clk_disable_unprepare(wdev->clk); return ret; } static int dw_wdt_drv_remove(struct platform_device *pdev) { - unregister_restart_handler(&dw_wdt.restart_handler); + struct watchdog_device *wdog = platform_get_drvdata(pdev); + struct dw_wdt_device *wdev = watchdog_get_drvdata(wdog); + + unregister_restart_handler(&wdev->restart_handler); - misc_deregister(&dw_wdt_miscdev); + watchdog_unregister_device(wdog); - clk_disable_unprepare(dw_wdt.clk); + clk_disable_unprepare(wdev->clk); return 0; }