Blame view
drivers/watchdog/st_lpc_wdt.c
6.87 KB
2e62c4988 watchdog: add SPD... |
1 |
// SPDX-License-Identifier: GPL-2.0+ |
f27925a6c watchdog: st_wdt:... |
2 3 4 5 6 7 8 |
/* * ST's LPC Watchdog * * Copyright (C) 2014 STMicroelectronics -- All Rights Reserved * * Author: David Paris <david.paris@st.com> for STMicroelectronics * Lee Jones <lee.jones@linaro.org> for STMicroelectronics |
f27925a6c watchdog: st_wdt:... |
9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 |
*/ #include <linux/clk.h> #include <linux/init.h> #include <linux/io.h> #include <linux/kernel.h> #include <linux/mfd/syscon.h> #include <linux/module.h> #include <linux/of.h> #include <linux/of_platform.h> #include <linux/platform_device.h> #include <linux/regmap.h> #include <linux/watchdog.h> #include <dt-bindings/mfd/st-lpc.h> /* Low Power Alarm */ #define LPC_LPA_LSB_OFF 0x410 #define LPC_LPA_START_OFF 0x418 /* LPC as WDT */ #define LPC_WDT_OFF 0x510 static struct watchdog_device st_wdog_dev; struct st_wdog_syscfg { unsigned int reset_type_reg; unsigned int reset_type_mask; unsigned int enable_reg; unsigned int enable_mask; }; struct st_wdog { void __iomem *base; struct device *dev; struct regmap *regmap; struct st_wdog_syscfg *syscfg; struct clk *clk; unsigned long clkrate; bool warm_reset; }; |
f27925a6c watchdog: st_wdt:... |
50 51 52 53 54 55 56 57 58 59 |
static struct st_wdog_syscfg stih407_syscfg = { .enable_reg = 0x204, .enable_mask = BIT(19), }; static const struct of_device_id st_wdog_match[] = { { .compatible = "st,stih407-lpc", .data = &stih407_syscfg, }, |
f27925a6c watchdog: st_wdt:... |
60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 |
{}, }; MODULE_DEVICE_TABLE(of, st_wdog_match); static void st_wdog_setup(struct st_wdog *st_wdog, bool enable) { /* Type of watchdog reset - 0: Cold 1: Warm */ if (st_wdog->syscfg->reset_type_reg) regmap_update_bits(st_wdog->regmap, st_wdog->syscfg->reset_type_reg, st_wdog->syscfg->reset_type_mask, st_wdog->warm_reset); /* Mask/unmask watchdog reset */ regmap_update_bits(st_wdog->regmap, st_wdog->syscfg->enable_reg, st_wdog->syscfg->enable_mask, enable ? 0 : st_wdog->syscfg->enable_mask); } static void st_wdog_load_timer(struct st_wdog *st_wdog, unsigned int timeout) { unsigned long clkrate = st_wdog->clkrate; writel_relaxed(timeout * clkrate, st_wdog->base + LPC_LPA_LSB_OFF); writel_relaxed(1, st_wdog->base + LPC_LPA_START_OFF); } static int st_wdog_start(struct watchdog_device *wdd) { struct st_wdog *st_wdog = watchdog_get_drvdata(wdd); writel_relaxed(1, st_wdog->base + LPC_WDT_OFF); return 0; } static int st_wdog_stop(struct watchdog_device *wdd) { struct st_wdog *st_wdog = watchdog_get_drvdata(wdd); writel_relaxed(0, st_wdog->base + LPC_WDT_OFF); return 0; } static int st_wdog_set_timeout(struct watchdog_device *wdd, unsigned int timeout) { struct st_wdog *st_wdog = watchdog_get_drvdata(wdd); wdd->timeout = timeout; st_wdog_load_timer(st_wdog, timeout); return 0; } static int st_wdog_keepalive(struct watchdog_device *wdd) { struct st_wdog *st_wdog = watchdog_get_drvdata(wdd); st_wdog_load_timer(st_wdog, wdd->timeout); return 0; } static const struct watchdog_info st_wdog_info = { .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE, .identity = "ST LPC WDT", }; static const struct watchdog_ops st_wdog_ops = { .owner = THIS_MODULE, .start = st_wdog_start, .stop = st_wdog_stop, .ping = st_wdog_keepalive, .set_timeout = st_wdog_set_timeout, }; static struct watchdog_device st_wdog_dev = { .info = &st_wdog_info, .ops = &st_wdog_ops, }; |
cfe9ee3ab watchdog: st_lpc_... |
143 144 145 146 |
static void st_clk_disable_unprepare(void *data) { clk_disable_unprepare(data); } |
f27925a6c watchdog: st_wdt:... |
147 148 |
static int st_wdog_probe(struct platform_device *pdev) { |
cfe9ee3ab watchdog: st_lpc_... |
149 |
struct device *dev = &pdev->dev; |
f27925a6c watchdog: st_wdt:... |
150 |
const struct of_device_id *match; |
cfe9ee3ab watchdog: st_lpc_... |
151 |
struct device_node *np = dev->of_node; |
f27925a6c watchdog: st_wdt:... |
152 153 |
struct st_wdog *st_wdog; struct regmap *regmap; |
f27925a6c watchdog: st_wdt:... |
154 155 156 157 158 159 160 |
struct clk *clk; void __iomem *base; uint32_t mode; int ret; ret = of_property_read_u32(np, "st,lpc-mode", &mode); if (ret) { |
cfe9ee3ab watchdog: st_lpc_... |
161 162 |
dev_err(dev, "An LPC mode must be provided "); |
f27925a6c watchdog: st_wdt:... |
163 164 |
return -EINVAL; } |
79cb09767 watchdog: st_wdt:... |
165 |
/* LPC can either run as a Clocksource or in RTC or WDT mode */ |
f27925a6c watchdog: st_wdt:... |
166 167 |
if (mode != ST_LPC_MODE_WDT) return -ENODEV; |
cfe9ee3ab watchdog: st_lpc_... |
168 |
st_wdog = devm_kzalloc(dev, sizeof(*st_wdog), GFP_KERNEL); |
f27925a6c watchdog: st_wdt:... |
169 170 |
if (!st_wdog) return -ENOMEM; |
cfe9ee3ab watchdog: st_lpc_... |
171 |
match = of_match_device(st_wdog_match, dev); |
f27925a6c watchdog: st_wdt:... |
172 |
if (!match) { |
cfe9ee3ab watchdog: st_lpc_... |
173 174 |
dev_err(dev, "Couldn't match device "); |
f27925a6c watchdog: st_wdt:... |
175 176 177 |
return -ENODEV; } st_wdog->syscfg = (struct st_wdog_syscfg *)match->data; |
0f0a6a285 watchdog: Convert... |
178 |
base = devm_platform_ioremap_resource(pdev, 0); |
f27925a6c watchdog: st_wdt:... |
179 180 181 182 183 |
if (IS_ERR(base)) return PTR_ERR(base); regmap = syscon_regmap_lookup_by_phandle(np, "st,syscfg"); if (IS_ERR(regmap)) { |
cfe9ee3ab watchdog: st_lpc_... |
184 185 |
dev_err(dev, "No syscfg phandle specified "); |
f27925a6c watchdog: st_wdt:... |
186 187 |
return PTR_ERR(regmap); } |
cfe9ee3ab watchdog: st_lpc_... |
188 |
clk = devm_clk_get(dev, NULL); |
f27925a6c watchdog: st_wdt:... |
189 |
if (IS_ERR(clk)) { |
cfe9ee3ab watchdog: st_lpc_... |
190 191 |
dev_err(dev, "Unable to request clock "); |
f27925a6c watchdog: st_wdt:... |
192 193 |
return PTR_ERR(clk); } |
cfe9ee3ab watchdog: st_lpc_... |
194 |
st_wdog->dev = dev; |
f27925a6c watchdog: st_wdt:... |
195 196 197 198 199 200 201 |
st_wdog->base = base; st_wdog->clk = clk; st_wdog->regmap = regmap; st_wdog->warm_reset = of_property_read_bool(np, "st,warm_reset"); st_wdog->clkrate = clk_get_rate(st_wdog->clk); if (!st_wdog->clkrate) { |
cfe9ee3ab watchdog: st_lpc_... |
202 203 |
dev_err(dev, "Unable to fetch clock rate "); |
f27925a6c watchdog: st_wdt:... |
204 205 206 |
return -EINVAL; } st_wdog_dev.max_timeout = 0xFFFFFFFF / st_wdog->clkrate; |
cfe9ee3ab watchdog: st_lpc_... |
207 |
st_wdog_dev.parent = dev; |
f27925a6c watchdog: st_wdt:... |
208 209 210 |
ret = clk_prepare_enable(clk); if (ret) { |
cfe9ee3ab watchdog: st_lpc_... |
211 212 |
dev_err(dev, "Unable to enable clock "); |
f27925a6c watchdog: st_wdt:... |
213 214 |
return ret; } |
cfe9ee3ab watchdog: st_lpc_... |
215 216 217 |
ret = devm_add_action_or_reset(dev, st_clk_disable_unprepare, clk); if (ret) return ret; |
f27925a6c watchdog: st_wdt:... |
218 219 220 221 222 |
watchdog_set_drvdata(&st_wdog_dev, st_wdog); watchdog_set_nowayout(&st_wdog_dev, WATCHDOG_NOWAYOUT); /* Init Watchdog timeout with value in DT */ |
cfe9ee3ab watchdog: st_lpc_... |
223 |
ret = watchdog_init_timeout(&st_wdog_dev, 0, dev); |
b4214185b watchdog: st_lpc_... |
224 |
if (ret) |
f27925a6c watchdog: st_wdt:... |
225 |
return ret; |
f27925a6c watchdog: st_wdt:... |
226 |
|
cfe9ee3ab watchdog: st_lpc_... |
227 |
ret = devm_watchdog_register_device(dev, &st_wdog_dev); |
7283b217a watchdog: st_lpc_... |
228 |
if (ret) |
f27925a6c watchdog: st_wdt:... |
229 |
return ret; |
f27925a6c watchdog: st_wdt:... |
230 231 |
st_wdog_setup(st_wdog, true); |
cfe9ee3ab watchdog: st_lpc_... |
232 |
dev_info(dev, "LPC Watchdog driver registered, reset type is %s", |
f27925a6c watchdog: st_wdt:... |
233 234 235 236 237 238 239 240 241 242 |
st_wdog->warm_reset ? "warm" : "cold"); return ret; } static int st_wdog_remove(struct platform_device *pdev) { struct st_wdog *st_wdog = watchdog_get_drvdata(&st_wdog_dev); st_wdog_setup(st_wdog, false); |
f27925a6c watchdog: st_wdt:... |
243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 |
return 0; } #ifdef CONFIG_PM_SLEEP static int st_wdog_suspend(struct device *dev) { struct st_wdog *st_wdog = watchdog_get_drvdata(&st_wdog_dev); if (watchdog_active(&st_wdog_dev)) st_wdog_stop(&st_wdog_dev); st_wdog_setup(st_wdog, false); clk_disable(st_wdog->clk); return 0; } static int st_wdog_resume(struct device *dev) { struct st_wdog *st_wdog = watchdog_get_drvdata(&st_wdog_dev); int ret; ret = clk_enable(st_wdog->clk); if (ret) { dev_err(dev, "Unable to re-enable clock "); watchdog_unregister_device(&st_wdog_dev); clk_unprepare(st_wdog->clk); return ret; } st_wdog_setup(st_wdog, true); if (watchdog_active(&st_wdog_dev)) { st_wdog_load_timer(st_wdog, st_wdog_dev.timeout); st_wdog_start(&st_wdog_dev); } return 0; } #endif static SIMPLE_DEV_PM_OPS(st_wdog_pm_ops, st_wdog_suspend, st_wdog_resume); static struct platform_driver st_wdog_driver = { .driver = { .name = "st-lpc-wdt", .pm = &st_wdog_pm_ops, .of_match_table = st_wdog_match, }, .probe = st_wdog_probe, .remove = st_wdog_remove, }; module_platform_driver(st_wdog_driver); MODULE_AUTHOR("David Paris <david.paris@st.com>"); MODULE_DESCRIPTION("ST LPC Watchdog Driver"); MODULE_LICENSE("GPL"); |