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/platform_device.h> 20 #include <linux/watchdog.h> 21 #include <linux/init.h> 22 #include <linux/io.h> 23 #include <linux/spinlock.h> 24 #include <linux/clk.h> 25 #include <linux/err.h> 26 #include <linux/of.h> 27 #include <mach/bridge-regs.h> 28 29 /* 30 * Watchdog timer block registers. 31 */ 32 #define TIMER_CTRL 0x0000 33 #define WDT_EN 0x0010 34 #define WDT_VAL 0x0024 35 36 #define WDT_MAX_CYCLE_COUNT 0xffffffff 37 #define WDT_IN_USE 0 38 #define WDT_OK_TO_CLOSE 1 39 40 #define WDT_RESET_OUT_EN BIT(1) 41 #define WDT_INT_REQ BIT(3) 42 43 static bool nowayout = WATCHDOG_NOWAYOUT; 44 static int heartbeat = -1; /* module parameter (seconds) */ 45 static unsigned int wdt_max_duration; /* (seconds) */ 46 static struct clk *clk; 47 static unsigned int wdt_tclk; 48 static void __iomem *wdt_reg; 49 static DEFINE_SPINLOCK(wdt_lock); 50 51 static int orion_wdt_ping(struct watchdog_device *wdt_dev) 52 { 53 spin_lock(&wdt_lock); 54 55 /* Reload watchdog duration */ 56 writel(wdt_tclk * wdt_dev->timeout, wdt_reg + WDT_VAL); 57 58 spin_unlock(&wdt_lock); 59 return 0; 60 } 61 62 static int orion_wdt_start(struct watchdog_device *wdt_dev) 63 { 64 u32 reg; 65 66 spin_lock(&wdt_lock); 67 68 /* Set watchdog duration */ 69 writel(wdt_tclk * wdt_dev->timeout, wdt_reg + WDT_VAL); 70 71 /* Clear watchdog timer interrupt */ 72 writel(~WDT_INT_REQ, 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 .min_timeout = 1, 144 }; 145 146 static int orion_wdt_probe(struct platform_device *pdev) 147 { 148 struct resource *res; 149 int ret; 150 151 clk = devm_clk_get(&pdev->dev, NULL); 152 if (IS_ERR(clk)) { 153 dev_err(&pdev->dev, "Orion Watchdog missing clock\n"); 154 return -ENODEV; 155 } 156 clk_prepare_enable(clk); 157 wdt_tclk = clk_get_rate(clk); 158 159 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 160 if (!res) 161 return -ENODEV; 162 wdt_reg = devm_ioremap(&pdev->dev, res->start, resource_size(res)); 163 if (!wdt_reg) 164 return -ENOMEM; 165 166 wdt_max_duration = WDT_MAX_CYCLE_COUNT / wdt_tclk; 167 168 orion_wdt.timeout = wdt_max_duration; 169 orion_wdt.max_timeout = wdt_max_duration; 170 watchdog_init_timeout(&orion_wdt, heartbeat, &pdev->dev); 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 orion_wdt.timeout, 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 = 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("platform:orion_wdt"); 227