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 41 static bool nowayout = WATCHDOG_NOWAYOUT; 42 static int heartbeat = -1; /* module parameter (seconds) */ 43 static unsigned int wdt_max_duration; /* (seconds) */ 44 static struct clk *clk; 45 static unsigned int wdt_tclk; 46 static void __iomem *wdt_reg; 47 static DEFINE_SPINLOCK(wdt_lock); 48 49 static 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 60 static 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 88 static 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 108 static 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 119 static 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 126 static const struct watchdog_info orion_wdt_info = { 127 .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE, 128 .identity = "Orion Watchdog", 129 }; 130 131 static 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 140 static struct watchdog_device orion_wdt = { 141 .info = &orion_wdt_info, 142 .ops = &orion_wdt_ops, 143 }; 144 145 static int 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 if (!res) 160 return -ENODEV; 161 wdt_reg = devm_ioremap(&pdev->dev, res->start, resource_size(res)); 162 if (!wdt_reg) 163 return -ENOMEM; 164 165 wdt_max_duration = WDT_MAX_CYCLE_COUNT / wdt_tclk; 166 167 if ((heartbeat < 1) || (heartbeat > wdt_max_duration)) 168 heartbeat = wdt_max_duration; 169 170 orion_wdt.timeout = heartbeat; 171 orion_wdt.min_timeout = 1; 172 orion_wdt.max_timeout = wdt_max_duration; 173 174 watchdog_set_nowayout(&orion_wdt, nowayout); 175 ret = watchdog_register_device(&orion_wdt); 176 if (ret) { 177 clk_disable_unprepare(clk); 178 return ret; 179 } 180 181 pr_info("Initial timeout %d sec%s\n", 182 heartbeat, nowayout ? ", nowayout" : ""); 183 return 0; 184 } 185 186 static int orion_wdt_remove(struct platform_device *pdev) 187 { 188 watchdog_unregister_device(&orion_wdt); 189 clk_disable_unprepare(clk); 190 return 0; 191 } 192 193 static void orion_wdt_shutdown(struct platform_device *pdev) 194 { 195 orion_wdt_stop(&orion_wdt); 196 } 197 198 static const struct of_device_id orion_wdt_of_match_table[] = { 199 { .compatible = "marvell,orion-wdt", }, 200 {}, 201 }; 202 MODULE_DEVICE_TABLE(of, orion_wdt_of_match_table); 203 204 static struct platform_driver orion_wdt_driver = { 205 .probe = orion_wdt_probe, 206 .remove = orion_wdt_remove, 207 .shutdown = orion_wdt_shutdown, 208 .driver = { 209 .owner = THIS_MODULE, 210 .name = "orion_wdt", 211 .of_match_table = of_match_ptr(orion_wdt_of_match_table), 212 }, 213 }; 214 215 module_platform_driver(orion_wdt_driver); 216 217 MODULE_AUTHOR("Sylver Bruneau <sylver.bruneau@googlemail.com>"); 218 MODULE_DESCRIPTION("Orion Processor Watchdog"); 219 220 module_param(heartbeat, int, 0); 221 MODULE_PARM_DESC(heartbeat, "Initial watchdog heartbeat in seconds"); 222 223 module_param(nowayout, bool, 0); 224 MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=" 225 __MODULE_STRING(WATCHDOG_NOWAYOUT) ")"); 226 227 MODULE_LICENSE("GPL"); 228 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); 229