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