Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
Paul Mundt | b1fa888 | 2010-05-24 10:55:59 +0900 | [diff] [blame] | 2 | * drivers/watchdog/shwdt.c |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3 | * |
| 4 | * Watchdog driver for integrated watchdog in the SuperH processors. |
| 5 | * |
Paul Mundt | 4096812 | 2012-05-10 14:21:15 +0900 | [diff] [blame] | 6 | * Copyright (C) 2001 - 2012 Paul Mundt <lethal@linux-sh.org> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 7 | * |
| 8 | * This program is free software; you can redistribute it and/or modify it |
| 9 | * under the terms of the GNU General Public License as published by the |
| 10 | * Free Software Foundation; either version 2 of the License, or (at your |
| 11 | * option) any later version. |
| 12 | * |
| 13 | * 14-Dec-2001 Matt Domsch <Matt_Domsch@dell.com> |
| 14 | * Added nowayout module option to override CONFIG_WATCHDOG_NOWAYOUT |
| 15 | * |
| 16 | * 19-Apr-2002 Rob Radez <rob@osinvestor.com> |
| 17 | * Added expect close support, made emulated timeout runtime changeable |
| 18 | * general cleanups, add some ioctls |
| 19 | */ |
Joe Perches | 27c766a | 2012-02-15 15:06:19 -0800 | [diff] [blame] | 20 | |
| 21 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
| 22 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 23 | #include <linux/module.h> |
| 24 | #include <linux/moduleparam.h> |
Paul Mundt | 8f5585e | 2010-05-25 18:31:12 +0900 | [diff] [blame] | 25 | #include <linux/platform_device.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 26 | #include <linux/init.h> |
| 27 | #include <linux/types.h> |
Paul Mundt | f9fb360 | 2012-05-10 15:15:08 +0900 | [diff] [blame] | 28 | #include <linux/spinlock.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 29 | #include <linux/watchdog.h> |
Paul Mundt | 8c013d96 | 2012-05-10 16:08:35 +0900 | [diff] [blame] | 30 | #include <linux/pm_runtime.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 31 | #include <linux/fs.h> |
Paul Mundt | f118420 | 2006-09-27 17:53:59 +0900 | [diff] [blame] | 32 | #include <linux/mm.h> |
Paul Mundt | 8f5585e | 2010-05-25 18:31:12 +0900 | [diff] [blame] | 33 | #include <linux/slab.h> |
Alan Cox | 70b814e | 2008-05-19 14:08:55 +0100 | [diff] [blame] | 34 | #include <linux/io.h> |
Paul Mundt | 9ea6404 | 2012-05-10 15:46:48 +0900 | [diff] [blame] | 35 | #include <linux/clk.h> |
Sachin Kamat | 6330c70 | 2013-03-04 10:36:41 +0530 | [diff] [blame] | 36 | #include <linux/err.h> |
Adrian Bunk | 58cf419 | 2008-08-08 18:39:11 +0300 | [diff] [blame] | 37 | #include <asm/watchdog.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 38 | |
Paul Mundt | 8f5585e | 2010-05-25 18:31:12 +0900 | [diff] [blame] | 39 | #define DRV_NAME "sh-wdt" |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 40 | |
| 41 | /* |
| 42 | * Default clock division ratio is 5.25 msecs. For an additional table of |
| 43 | * values, consult the asm-sh/watchdog.h. Overload this at module load |
| 44 | * time. |
| 45 | * |
| 46 | * In order for this to work reliably we need to have HZ set to 1000 or |
| 47 | * something quite higher than 100 (or we need a proper high-res timer |
| 48 | * implementation that will deal with this properly), otherwise the 10ms |
| 49 | * resolution of a jiffy is enough to trigger the overflow. For things like |
| 50 | * the SH-4 and SH-5, this isn't necessarily that big of a problem, though |
| 51 | * for the SH-2 and SH-3, this isn't recommended unless the WDT is absolutely |
| 52 | * necssary. |
| 53 | * |
| 54 | * As a result of this timing problem, the only modes that are particularly |
Lucas De Marchi | 25985ed | 2011-03-30 22:57:33 -0300 | [diff] [blame] | 55 | * feasible are the 4096 and the 2048 divisors, which yield 5.25 and 2.62ms |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 56 | * overflow periods respectively. |
| 57 | * |
| 58 | * Also, since we can't really expect userspace to be responsive enough |
Joe Perches | ee0fc09 | 2008-02-03 17:32:52 +0200 | [diff] [blame] | 59 | * before the overflow happens, we maintain two separate timers .. One in |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 60 | * the kernel for clearing out WOVF every 2ms or so (again, this depends on |
| 61 | * HZ == 1000), and another for monitoring userspace writes to the WDT device. |
| 62 | * |
| 63 | * As such, we currently use a configurable heartbeat interval which defaults |
| 64 | * to 30s. In this case, the userspace daemon is only responsible for periodic |
| 65 | * writes to the device before the next heartbeat is scheduled. If the daemon |
| 66 | * misses its deadline, the kernel timer will allow the WDT to overflow. |
| 67 | */ |
| 68 | static int clock_division_ratio = WTCSR_CKS_4096; |
David Engraf | bea1906 | 2011-07-20 15:03:39 +0200 | [diff] [blame] | 69 | #define next_ping_period(cks) (jiffies + msecs_to_jiffies(cks - 4)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 70 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 71 | #define WATCHDOG_HEARTBEAT 30 /* 30 sec default heartbeat */ |
| 72 | static int heartbeat = WATCHDOG_HEARTBEAT; /* in seconds */ |
Wim Van Sebroeck | 86a1e18 | 2012-03-05 16:51:11 +0100 | [diff] [blame] | 73 | static bool nowayout = WATCHDOG_NOWAYOUT; |
Paul Mundt | 8f5585e | 2010-05-25 18:31:12 +0900 | [diff] [blame] | 74 | static unsigned long next_heartbeat; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 75 | |
Paul Mundt | 8f5585e | 2010-05-25 18:31:12 +0900 | [diff] [blame] | 76 | struct sh_wdt { |
| 77 | void __iomem *base; |
| 78 | struct device *dev; |
Paul Mundt | 9ea6404 | 2012-05-10 15:46:48 +0900 | [diff] [blame] | 79 | struct clk *clk; |
Paul Mundt | f9fb360 | 2012-05-10 15:15:08 +0900 | [diff] [blame] | 80 | spinlock_t lock; |
Paul Mundt | 8f5585e | 2010-05-25 18:31:12 +0900 | [diff] [blame] | 81 | |
| 82 | struct timer_list timer; |
Paul Mundt | 8f5585e | 2010-05-25 18:31:12 +0900 | [diff] [blame] | 83 | }; |
| 84 | |
Paul Mundt | 1950f49 | 2012-05-10 15:07:53 +0900 | [diff] [blame] | 85 | static int sh_wdt_start(struct watchdog_device *wdt_dev) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 86 | { |
Paul Mundt | 1950f49 | 2012-05-10 15:07:53 +0900 | [diff] [blame] | 87 | struct sh_wdt *wdt = watchdog_get_drvdata(wdt_dev); |
Alan Cox | 70b814e | 2008-05-19 14:08:55 +0100 | [diff] [blame] | 88 | unsigned long flags; |
Paul Mundt | 8f5585e | 2010-05-25 18:31:12 +0900 | [diff] [blame] | 89 | u8 csr; |
Alan Cox | 70b814e | 2008-05-19 14:08:55 +0100 | [diff] [blame] | 90 | |
Paul Mundt | 8c013d96 | 2012-05-10 16:08:35 +0900 | [diff] [blame] | 91 | pm_runtime_get_sync(wdt->dev); |
Paul Mundt | d42c974 | 2012-05-10 16:14:40 +0900 | [diff] [blame] | 92 | clk_enable(wdt->clk); |
Paul Mundt | 8c013d96 | 2012-05-10 16:08:35 +0900 | [diff] [blame] | 93 | |
Paul Mundt | f9fb360 | 2012-05-10 15:15:08 +0900 | [diff] [blame] | 94 | spin_lock_irqsave(&wdt->lock, flags); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 95 | |
| 96 | next_heartbeat = jiffies + (heartbeat * HZ); |
Paul Mundt | 8f5585e | 2010-05-25 18:31:12 +0900 | [diff] [blame] | 97 | mod_timer(&wdt->timer, next_ping_period(clock_division_ratio)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 98 | |
| 99 | csr = sh_wdt_read_csr(); |
| 100 | csr |= WTCSR_WT | clock_division_ratio; |
| 101 | sh_wdt_write_csr(csr); |
| 102 | |
| 103 | sh_wdt_write_cnt(0); |
| 104 | |
| 105 | /* |
| 106 | * These processors have a bit of an inconsistent initialization |
| 107 | * process.. starting with SH-3, RSTS was moved to WTCSR, and the |
| 108 | * RSTCSR register was removed. |
| 109 | * |
| 110 | * On the SH-2 however, in addition with bits being in different |
| 111 | * locations, we must deal with RSTCSR outright.. |
| 112 | */ |
| 113 | csr = sh_wdt_read_csr(); |
| 114 | csr |= WTCSR_TME; |
| 115 | csr &= ~WTCSR_RSTS; |
| 116 | sh_wdt_write_csr(csr); |
| 117 | |
| 118 | #ifdef CONFIG_CPU_SH2 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 119 | csr = sh_wdt_read_rstcsr(); |
| 120 | csr &= ~RSTCSR_RSTS; |
| 121 | sh_wdt_write_rstcsr(csr); |
| 122 | #endif |
Paul Mundt | f9fb360 | 2012-05-10 15:15:08 +0900 | [diff] [blame] | 123 | spin_unlock_irqrestore(&wdt->lock, flags); |
Paul Mundt | 1950f49 | 2012-05-10 15:07:53 +0900 | [diff] [blame] | 124 | |
| 125 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 126 | } |
| 127 | |
Paul Mundt | 1950f49 | 2012-05-10 15:07:53 +0900 | [diff] [blame] | 128 | static int sh_wdt_stop(struct watchdog_device *wdt_dev) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 129 | { |
Paul Mundt | 1950f49 | 2012-05-10 15:07:53 +0900 | [diff] [blame] | 130 | struct sh_wdt *wdt = watchdog_get_drvdata(wdt_dev); |
Alan Cox | 70b814e | 2008-05-19 14:08:55 +0100 | [diff] [blame] | 131 | unsigned long flags; |
Paul Mundt | 8f5585e | 2010-05-25 18:31:12 +0900 | [diff] [blame] | 132 | u8 csr; |
Alan Cox | 70b814e | 2008-05-19 14:08:55 +0100 | [diff] [blame] | 133 | |
Paul Mundt | f9fb360 | 2012-05-10 15:15:08 +0900 | [diff] [blame] | 134 | spin_lock_irqsave(&wdt->lock, flags); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 135 | |
Paul Mundt | 8f5585e | 2010-05-25 18:31:12 +0900 | [diff] [blame] | 136 | del_timer(&wdt->timer); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 137 | |
| 138 | csr = sh_wdt_read_csr(); |
| 139 | csr &= ~WTCSR_TME; |
| 140 | sh_wdt_write_csr(csr); |
Paul Mundt | 8f5585e | 2010-05-25 18:31:12 +0900 | [diff] [blame] | 141 | |
Paul Mundt | f9fb360 | 2012-05-10 15:15:08 +0900 | [diff] [blame] | 142 | spin_unlock_irqrestore(&wdt->lock, flags); |
Paul Mundt | 1950f49 | 2012-05-10 15:07:53 +0900 | [diff] [blame] | 143 | |
Paul Mundt | d42c974 | 2012-05-10 16:14:40 +0900 | [diff] [blame] | 144 | clk_disable(wdt->clk); |
Paul Mundt | 8c013d96 | 2012-05-10 16:08:35 +0900 | [diff] [blame] | 145 | pm_runtime_put_sync(wdt->dev); |
| 146 | |
Paul Mundt | 1950f49 | 2012-05-10 15:07:53 +0900 | [diff] [blame] | 147 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 148 | } |
| 149 | |
Paul Mundt | 1950f49 | 2012-05-10 15:07:53 +0900 | [diff] [blame] | 150 | static int sh_wdt_keepalive(struct watchdog_device *wdt_dev) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 151 | { |
Paul Mundt | f9fb360 | 2012-05-10 15:15:08 +0900 | [diff] [blame] | 152 | struct sh_wdt *wdt = watchdog_get_drvdata(wdt_dev); |
Alan Cox | 70b814e | 2008-05-19 14:08:55 +0100 | [diff] [blame] | 153 | unsigned long flags; |
| 154 | |
Paul Mundt | f9fb360 | 2012-05-10 15:15:08 +0900 | [diff] [blame] | 155 | spin_lock_irqsave(&wdt->lock, flags); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 156 | next_heartbeat = jiffies + (heartbeat * HZ); |
Paul Mundt | f9fb360 | 2012-05-10 15:15:08 +0900 | [diff] [blame] | 157 | spin_unlock_irqrestore(&wdt->lock, flags); |
Paul Mundt | 1950f49 | 2012-05-10 15:07:53 +0900 | [diff] [blame] | 158 | |
| 159 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 160 | } |
| 161 | |
Paul Mundt | 1950f49 | 2012-05-10 15:07:53 +0900 | [diff] [blame] | 162 | static int sh_wdt_set_heartbeat(struct watchdog_device *wdt_dev, unsigned t) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 163 | { |
Paul Mundt | f9fb360 | 2012-05-10 15:15:08 +0900 | [diff] [blame] | 164 | struct sh_wdt *wdt = watchdog_get_drvdata(wdt_dev); |
Alan Cox | 70b814e | 2008-05-19 14:08:55 +0100 | [diff] [blame] | 165 | unsigned long flags; |
| 166 | |
| 167 | if (unlikely(t < 1 || t > 3600)) /* arbitrary upper limit */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 168 | return -EINVAL; |
| 169 | |
Paul Mundt | f9fb360 | 2012-05-10 15:15:08 +0900 | [diff] [blame] | 170 | spin_lock_irqsave(&wdt->lock, flags); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 171 | heartbeat = t; |
Paul Mundt | 1950f49 | 2012-05-10 15:07:53 +0900 | [diff] [blame] | 172 | wdt_dev->timeout = t; |
Paul Mundt | f9fb360 | 2012-05-10 15:15:08 +0900 | [diff] [blame] | 173 | spin_unlock_irqrestore(&wdt->lock, flags); |
Paul Mundt | 1950f49 | 2012-05-10 15:07:53 +0900 | [diff] [blame] | 174 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 175 | return 0; |
| 176 | } |
| 177 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 178 | static void sh_wdt_ping(unsigned long data) |
| 179 | { |
Paul Mundt | 8f5585e | 2010-05-25 18:31:12 +0900 | [diff] [blame] | 180 | struct sh_wdt *wdt = (struct sh_wdt *)data; |
Alan Cox | 70b814e | 2008-05-19 14:08:55 +0100 | [diff] [blame] | 181 | unsigned long flags; |
| 182 | |
Paul Mundt | f9fb360 | 2012-05-10 15:15:08 +0900 | [diff] [blame] | 183 | spin_lock_irqsave(&wdt->lock, flags); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 184 | if (time_before(jiffies, next_heartbeat)) { |
Paul Mundt | 8f5585e | 2010-05-25 18:31:12 +0900 | [diff] [blame] | 185 | u8 csr; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 186 | |
| 187 | csr = sh_wdt_read_csr(); |
| 188 | csr &= ~WTCSR_IOVF; |
| 189 | sh_wdt_write_csr(csr); |
| 190 | |
| 191 | sh_wdt_write_cnt(0); |
| 192 | |
Paul Mundt | 8f5585e | 2010-05-25 18:31:12 +0900 | [diff] [blame] | 193 | mod_timer(&wdt->timer, next_ping_period(clock_division_ratio)); |
Paul Mundt | e4c2cfe | 2006-09-27 12:31:01 +0900 | [diff] [blame] | 194 | } else |
Paul Mundt | 8f5585e | 2010-05-25 18:31:12 +0900 | [diff] [blame] | 195 | dev_warn(wdt->dev, "Heartbeat lost! Will not ping " |
| 196 | "the watchdog\n"); |
Paul Mundt | f9fb360 | 2012-05-10 15:15:08 +0900 | [diff] [blame] | 197 | spin_unlock_irqrestore(&wdt->lock, flags); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 198 | } |
| 199 | |
Alan Cox | 70b814e | 2008-05-19 14:08:55 +0100 | [diff] [blame] | 200 | static const struct watchdog_info sh_wdt_info = { |
Paul Mundt | e4c2cfe | 2006-09-27 12:31:01 +0900 | [diff] [blame] | 201 | .options = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT | |
| 202 | WDIOF_MAGICCLOSE, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 203 | .firmware_version = 1, |
| 204 | .identity = "SH WDT", |
| 205 | }; |
| 206 | |
Paul Mundt | 1950f49 | 2012-05-10 15:07:53 +0900 | [diff] [blame] | 207 | static const struct watchdog_ops sh_wdt_ops = { |
| 208 | .owner = THIS_MODULE, |
| 209 | .start = sh_wdt_start, |
| 210 | .stop = sh_wdt_stop, |
| 211 | .ping = sh_wdt_keepalive, |
| 212 | .set_timeout = sh_wdt_set_heartbeat, |
| 213 | }; |
| 214 | |
| 215 | static struct watchdog_device sh_wdt_dev = { |
| 216 | .info = &sh_wdt_info, |
| 217 | .ops = &sh_wdt_ops, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 218 | }; |
| 219 | |
Bill Pemberton | 2d991a1 | 2012-11-19 13:21:41 -0500 | [diff] [blame] | 220 | static int sh_wdt_probe(struct platform_device *pdev) |
Paul Mundt | 8f5585e | 2010-05-25 18:31:12 +0900 | [diff] [blame] | 221 | { |
| 222 | struct sh_wdt *wdt; |
| 223 | struct resource *res; |
| 224 | int rc; |
| 225 | |
| 226 | /* |
| 227 | * As this driver only covers the global watchdog case, reject |
| 228 | * any attempts to register per-CPU watchdogs. |
| 229 | */ |
| 230 | if (pdev->id != -1) |
| 231 | return -EINVAL; |
| 232 | |
| 233 | res = platform_get_resource(pdev, IORESOURCE_MEM, 0); |
| 234 | if (unlikely(!res)) |
| 235 | return -EINVAL; |
| 236 | |
Paul Mundt | 8f5585e | 2010-05-25 18:31:12 +0900 | [diff] [blame] | 237 | wdt = devm_kzalloc(&pdev->dev, sizeof(struct sh_wdt), GFP_KERNEL); |
Paul Mundt | 9ea6404 | 2012-05-10 15:46:48 +0900 | [diff] [blame] | 238 | if (unlikely(!wdt)) |
| 239 | return -ENOMEM; |
Paul Mundt | 8f5585e | 2010-05-25 18:31:12 +0900 | [diff] [blame] | 240 | |
| 241 | wdt->dev = &pdev->dev; |
| 242 | |
Jingoo Han | 2f7b9b4 | 2013-04-29 18:16:33 +0900 | [diff] [blame] | 243 | wdt->clk = devm_clk_get(&pdev->dev, NULL); |
Paul Mundt | 9ea6404 | 2012-05-10 15:46:48 +0900 | [diff] [blame] | 244 | if (IS_ERR(wdt->clk)) { |
| 245 | /* |
| 246 | * Clock framework support is optional, continue on |
| 247 | * anyways if we don't find a matching clock. |
| 248 | */ |
| 249 | wdt->clk = NULL; |
| 250 | } |
| 251 | |
Sachin Kamat | 6330c70 | 2013-03-04 10:36:41 +0530 | [diff] [blame] | 252 | wdt->base = devm_ioremap_resource(wdt->dev, res); |
Jingoo Han | 2f7b9b4 | 2013-04-29 18:16:33 +0900 | [diff] [blame] | 253 | if (IS_ERR(wdt->base)) |
| 254 | return PTR_ERR(wdt->base); |
Paul Mundt | 9ea6404 | 2012-05-10 15:46:48 +0900 | [diff] [blame] | 255 | |
Paul Mundt | f9fb360 | 2012-05-10 15:15:08 +0900 | [diff] [blame] | 256 | watchdog_set_nowayout(&sh_wdt_dev, nowayout); |
| 257 | watchdog_set_drvdata(&sh_wdt_dev, wdt); |
| 258 | |
Paul Mundt | f9fb360 | 2012-05-10 15:15:08 +0900 | [diff] [blame] | 259 | spin_lock_init(&wdt->lock); |
| 260 | |
Paul Mundt | 1950f49 | 2012-05-10 15:07:53 +0900 | [diff] [blame] | 261 | rc = sh_wdt_set_heartbeat(&sh_wdt_dev, heartbeat); |
Paul Mundt | 8f5585e | 2010-05-25 18:31:12 +0900 | [diff] [blame] | 262 | if (unlikely(rc)) { |
Paul Mundt | 1950f49 | 2012-05-10 15:07:53 +0900 | [diff] [blame] | 263 | /* Default timeout if invalid */ |
| 264 | sh_wdt_set_heartbeat(&sh_wdt_dev, WATCHDOG_HEARTBEAT); |
| 265 | |
| 266 | dev_warn(&pdev->dev, |
| 267 | "heartbeat value must be 1<=x<=3600, using %d\n", |
| 268 | sh_wdt_dev.timeout); |
| 269 | } |
| 270 | |
| 271 | dev_info(&pdev->dev, "configured with heartbeat=%d sec (nowayout=%d)\n", |
| 272 | sh_wdt_dev.timeout, nowayout); |
| 273 | |
Paul Mundt | 1950f49 | 2012-05-10 15:07:53 +0900 | [diff] [blame] | 274 | rc = watchdog_register_device(&sh_wdt_dev); |
| 275 | if (unlikely(rc)) { |
| 276 | dev_err(&pdev->dev, "Can't register watchdog (err=%d)\n", rc); |
Jingoo Han | 2f7b9b4 | 2013-04-29 18:16:33 +0900 | [diff] [blame] | 277 | return rc; |
Paul Mundt | 8f5585e | 2010-05-25 18:31:12 +0900 | [diff] [blame] | 278 | } |
| 279 | |
| 280 | init_timer(&wdt->timer); |
| 281 | wdt->timer.function = sh_wdt_ping; |
| 282 | wdt->timer.data = (unsigned long)wdt; |
| 283 | wdt->timer.expires = next_ping_period(clock_division_ratio); |
| 284 | |
Paul Mundt | 8f5585e | 2010-05-25 18:31:12 +0900 | [diff] [blame] | 285 | dev_info(&pdev->dev, "initialized.\n"); |
| 286 | |
Paul Mundt | 8c013d96 | 2012-05-10 16:08:35 +0900 | [diff] [blame] | 287 | pm_runtime_enable(&pdev->dev); |
| 288 | |
Paul Mundt | 8f5585e | 2010-05-25 18:31:12 +0900 | [diff] [blame] | 289 | return 0; |
Paul Mundt | 8f5585e | 2010-05-25 18:31:12 +0900 | [diff] [blame] | 290 | } |
| 291 | |
Bill Pemberton | 4b12b89 | 2012-11-19 13:26:24 -0500 | [diff] [blame] | 292 | static int sh_wdt_remove(struct platform_device *pdev) |
Paul Mundt | 8f5585e | 2010-05-25 18:31:12 +0900 | [diff] [blame] | 293 | { |
Paul Mundt | 1950f49 | 2012-05-10 15:07:53 +0900 | [diff] [blame] | 294 | watchdog_unregister_device(&sh_wdt_dev); |
Paul Mundt | 8f5585e | 2010-05-25 18:31:12 +0900 | [diff] [blame] | 295 | |
Paul Mundt | 8c013d96 | 2012-05-10 16:08:35 +0900 | [diff] [blame] | 296 | pm_runtime_disable(&pdev->dev); |
Paul Mundt | 8f5585e | 2010-05-25 18:31:12 +0900 | [diff] [blame] | 297 | |
| 298 | return 0; |
| 299 | } |
| 300 | |
Paul Mundt | 4096812 | 2012-05-10 14:21:15 +0900 | [diff] [blame] | 301 | static void sh_wdt_shutdown(struct platform_device *pdev) |
| 302 | { |
Paul Mundt | 1950f49 | 2012-05-10 15:07:53 +0900 | [diff] [blame] | 303 | sh_wdt_stop(&sh_wdt_dev); |
Paul Mundt | 4096812 | 2012-05-10 14:21:15 +0900 | [diff] [blame] | 304 | } |
| 305 | |
Paul Mundt | 8f5585e | 2010-05-25 18:31:12 +0900 | [diff] [blame] | 306 | static struct platform_driver sh_wdt_driver = { |
| 307 | .driver = { |
| 308 | .name = DRV_NAME, |
| 309 | .owner = THIS_MODULE, |
| 310 | }, |
| 311 | |
Paul Mundt | 4096812 | 2012-05-10 14:21:15 +0900 | [diff] [blame] | 312 | .probe = sh_wdt_probe, |
Bill Pemberton | 8226871 | 2012-11-19 13:21:12 -0500 | [diff] [blame] | 313 | .remove = sh_wdt_remove, |
Paul Mundt | 4096812 | 2012-05-10 14:21:15 +0900 | [diff] [blame] | 314 | .shutdown = sh_wdt_shutdown, |
Paul Mundt | 8f5585e | 2010-05-25 18:31:12 +0900 | [diff] [blame] | 315 | }; |
| 316 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 317 | static int __init sh_wdt_init(void) |
| 318 | { |
Paul Mundt | 8f5585e | 2010-05-25 18:31:12 +0900 | [diff] [blame] | 319 | if (unlikely(clock_division_ratio < 0x5 || |
| 320 | clock_division_ratio > 0x7)) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 321 | clock_division_ratio = WTCSR_CKS_4096; |
Paul Mundt | 8f5585e | 2010-05-25 18:31:12 +0900 | [diff] [blame] | 322 | |
Joe Perches | 27c766a | 2012-02-15 15:06:19 -0800 | [diff] [blame] | 323 | pr_info("divisor must be 0x5<=x<=0x7, using %d\n", |
| 324 | clock_division_ratio); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 325 | } |
| 326 | |
Paul Mundt | 8f5585e | 2010-05-25 18:31:12 +0900 | [diff] [blame] | 327 | return platform_driver_register(&sh_wdt_driver); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 328 | } |
| 329 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 330 | static void __exit sh_wdt_exit(void) |
| 331 | { |
Paul Mundt | 8f5585e | 2010-05-25 18:31:12 +0900 | [diff] [blame] | 332 | platform_driver_unregister(&sh_wdt_driver); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 333 | } |
Paul Mundt | 8f5585e | 2010-05-25 18:31:12 +0900 | [diff] [blame] | 334 | module_init(sh_wdt_init); |
| 335 | module_exit(sh_wdt_exit); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 336 | |
| 337 | MODULE_AUTHOR("Paul Mundt <lethal@linux-sh.org>"); |
| 338 | MODULE_DESCRIPTION("SuperH watchdog driver"); |
| 339 | MODULE_LICENSE("GPL"); |
Paul Mundt | 8f5585e | 2010-05-25 18:31:12 +0900 | [diff] [blame] | 340 | MODULE_ALIAS("platform:" DRV_NAME); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 341 | |
| 342 | module_param(clock_division_ratio, int, 0); |
Wim Van Sebroeck | a77dba7 | 2009-04-14 20:20:07 +0000 | [diff] [blame] | 343 | MODULE_PARM_DESC(clock_division_ratio, |
| 344 | "Clock division ratio. Valid ranges are from 0x5 (1.31ms) " |
Randy Dunlap | 76550d3 | 2010-05-01 09:46:15 -0700 | [diff] [blame] | 345 | "to 0x7 (5.25ms). (default=" __MODULE_STRING(WTCSR_CKS_4096) ")"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 346 | |
| 347 | module_param(heartbeat, int, 0); |
Alan Cox | 70b814e | 2008-05-19 14:08:55 +0100 | [diff] [blame] | 348 | MODULE_PARM_DESC(heartbeat, |
| 349 | "Watchdog heartbeat in seconds. (1 <= heartbeat <= 3600, default=" |
| 350 | __MODULE_STRING(WATCHDOG_HEARTBEAT) ")"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 351 | |
Wim Van Sebroeck | 86a1e18 | 2012-03-05 16:51:11 +0100 | [diff] [blame] | 352 | module_param(nowayout, bool, 0); |
Alan Cox | 70b814e | 2008-05-19 14:08:55 +0100 | [diff] [blame] | 353 | MODULE_PARM_DESC(nowayout, |
| 354 | "Watchdog cannot be stopped once started (default=" |
| 355 | __MODULE_STRING(WATCHDOG_NOWAYOUT) ")"); |