1 /* 2 * Spreadtrum watchdog driver 3 * Copyright (C) 2017 Spreadtrum - http://www.spreadtrum.com 4 * 5 * This program is free software; you can redistribute it and/or 6 * modify it under the terms of the GNU General Public License 7 * version 2 as published by the Free Software Foundation. 8 * 9 * This program is distributed in the hope that it will be useful, but 10 * WITHOUT ANY WARRANTY; without even the implied warranty of 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 12 * General Public License for more details. 13 */ 14 15 #include <linux/bitops.h> 16 #include <linux/clk.h> 17 #include <linux/device.h> 18 #include <linux/err.h> 19 #include <linux/interrupt.h> 20 #include <linux/io.h> 21 #include <linux/kernel.h> 22 #include <linux/module.h> 23 #include <linux/of.h> 24 #include <linux/of_address.h> 25 #include <linux/platform_device.h> 26 #include <linux/watchdog.h> 27 28 #define SPRD_WDT_LOAD_LOW 0x0 29 #define SPRD_WDT_LOAD_HIGH 0x4 30 #define SPRD_WDT_CTRL 0x8 31 #define SPRD_WDT_INT_CLR 0xc 32 #define SPRD_WDT_INT_RAW 0x10 33 #define SPRD_WDT_INT_MSK 0x14 34 #define SPRD_WDT_CNT_LOW 0x18 35 #define SPRD_WDT_CNT_HIGH 0x1c 36 #define SPRD_WDT_LOCK 0x20 37 #define SPRD_WDT_IRQ_LOAD_LOW 0x2c 38 #define SPRD_WDT_IRQ_LOAD_HIGH 0x30 39 40 /* WDT_CTRL */ 41 #define SPRD_WDT_INT_EN_BIT BIT(0) 42 #define SPRD_WDT_CNT_EN_BIT BIT(1) 43 #define SPRD_WDT_NEW_VER_EN BIT(2) 44 #define SPRD_WDT_RST_EN_BIT BIT(3) 45 46 /* WDT_INT_CLR */ 47 #define SPRD_WDT_INT_CLEAR_BIT BIT(0) 48 #define SPRD_WDT_RST_CLEAR_BIT BIT(3) 49 50 /* WDT_INT_RAW */ 51 #define SPRD_WDT_INT_RAW_BIT BIT(0) 52 #define SPRD_WDT_RST_RAW_BIT BIT(3) 53 #define SPRD_WDT_LD_BUSY_BIT BIT(4) 54 55 /* 1s equal to 32768 counter steps */ 56 #define SPRD_WDT_CNT_STEP 32768 57 58 #define SPRD_WDT_UNLOCK_KEY 0xe551 59 #define SPRD_WDT_MIN_TIMEOUT 3 60 #define SPRD_WDT_MAX_TIMEOUT 60 61 62 #define SPRD_WDT_CNT_HIGH_SHIFT 16 63 #define SPRD_WDT_LOW_VALUE_MASK GENMASK(15, 0) 64 #define SPRD_WDT_LOAD_TIMEOUT 1000 65 66 struct sprd_wdt { 67 void __iomem *base; 68 struct watchdog_device wdd; 69 struct clk *enable; 70 struct clk *rtc_enable; 71 int irq; 72 }; 73 74 static inline struct sprd_wdt *to_sprd_wdt(struct watchdog_device *wdd) 75 { 76 return container_of(wdd, struct sprd_wdt, wdd); 77 } 78 79 static inline void sprd_wdt_lock(void __iomem *addr) 80 { 81 writel_relaxed(0x0, addr + SPRD_WDT_LOCK); 82 } 83 84 static inline void sprd_wdt_unlock(void __iomem *addr) 85 { 86 writel_relaxed(SPRD_WDT_UNLOCK_KEY, addr + SPRD_WDT_LOCK); 87 } 88 89 static irqreturn_t sprd_wdt_isr(int irq, void *dev_id) 90 { 91 struct sprd_wdt *wdt = (struct sprd_wdt *)dev_id; 92 93 sprd_wdt_unlock(wdt->base); 94 writel_relaxed(SPRD_WDT_INT_CLEAR_BIT, wdt->base + SPRD_WDT_INT_CLR); 95 sprd_wdt_lock(wdt->base); 96 watchdog_notify_pretimeout(&wdt->wdd); 97 return IRQ_HANDLED; 98 } 99 100 static u32 sprd_wdt_get_cnt_value(struct sprd_wdt *wdt) 101 { 102 u32 val; 103 104 val = readl_relaxed(wdt->base + SPRD_WDT_CNT_HIGH) << 105 SPRD_WDT_CNT_HIGH_SHIFT; 106 val |= readl_relaxed(wdt->base + SPRD_WDT_CNT_LOW) & 107 SPRD_WDT_LOW_VALUE_MASK; 108 109 return val; 110 } 111 112 static int sprd_wdt_load_value(struct sprd_wdt *wdt, u32 timeout, 113 u32 pretimeout) 114 { 115 u32 val, delay_cnt = 0; 116 u32 tmr_step = timeout * SPRD_WDT_CNT_STEP; 117 u32 prtmr_step = pretimeout * SPRD_WDT_CNT_STEP; 118 119 sprd_wdt_unlock(wdt->base); 120 writel_relaxed((tmr_step >> SPRD_WDT_CNT_HIGH_SHIFT) & 121 SPRD_WDT_LOW_VALUE_MASK, wdt->base + SPRD_WDT_LOAD_HIGH); 122 writel_relaxed((tmr_step & SPRD_WDT_LOW_VALUE_MASK), 123 wdt->base + SPRD_WDT_LOAD_LOW); 124 writel_relaxed((prtmr_step >> SPRD_WDT_CNT_HIGH_SHIFT) & 125 SPRD_WDT_LOW_VALUE_MASK, 126 wdt->base + SPRD_WDT_IRQ_LOAD_HIGH); 127 writel_relaxed(prtmr_step & SPRD_WDT_LOW_VALUE_MASK, 128 wdt->base + SPRD_WDT_IRQ_LOAD_LOW); 129 sprd_wdt_lock(wdt->base); 130 131 /* 132 * Waiting the load value operation done, 133 * it needs two or three RTC clock cycles. 134 */ 135 do { 136 val = readl_relaxed(wdt->base + SPRD_WDT_INT_RAW); 137 if (!(val & SPRD_WDT_LD_BUSY_BIT)) 138 break; 139 140 cpu_relax(); 141 } while (delay_cnt++ < SPRD_WDT_LOAD_TIMEOUT); 142 143 if (delay_cnt >= SPRD_WDT_LOAD_TIMEOUT) 144 return -EBUSY; 145 return 0; 146 } 147 148 static int sprd_wdt_enable(struct sprd_wdt *wdt) 149 { 150 u32 val; 151 int ret; 152 153 ret = clk_prepare_enable(wdt->enable); 154 if (ret) 155 return ret; 156 ret = clk_prepare_enable(wdt->rtc_enable); 157 if (ret) { 158 clk_disable_unprepare(wdt->enable); 159 return ret; 160 } 161 162 sprd_wdt_unlock(wdt->base); 163 val = readl_relaxed(wdt->base + SPRD_WDT_CTRL); 164 val |= SPRD_WDT_NEW_VER_EN; 165 writel_relaxed(val, wdt->base + SPRD_WDT_CTRL); 166 sprd_wdt_lock(wdt->base); 167 return 0; 168 } 169 170 static void sprd_wdt_disable(void *_data) 171 { 172 struct sprd_wdt *wdt = _data; 173 174 sprd_wdt_unlock(wdt->base); 175 writel_relaxed(0x0, wdt->base + SPRD_WDT_CTRL); 176 sprd_wdt_lock(wdt->base); 177 178 clk_disable_unprepare(wdt->rtc_enable); 179 clk_disable_unprepare(wdt->enable); 180 } 181 182 static int sprd_wdt_start(struct watchdog_device *wdd) 183 { 184 struct sprd_wdt *wdt = to_sprd_wdt(wdd); 185 u32 val; 186 int ret; 187 188 ret = sprd_wdt_load_value(wdt, wdd->timeout, wdd->pretimeout); 189 if (ret) 190 return ret; 191 192 sprd_wdt_unlock(wdt->base); 193 val = readl_relaxed(wdt->base + SPRD_WDT_CTRL); 194 val |= SPRD_WDT_CNT_EN_BIT | SPRD_WDT_INT_EN_BIT | SPRD_WDT_RST_EN_BIT; 195 writel_relaxed(val, wdt->base + SPRD_WDT_CTRL); 196 sprd_wdt_lock(wdt->base); 197 set_bit(WDOG_HW_RUNNING, &wdd->status); 198 199 return 0; 200 } 201 202 static int sprd_wdt_stop(struct watchdog_device *wdd) 203 { 204 struct sprd_wdt *wdt = to_sprd_wdt(wdd); 205 u32 val; 206 207 sprd_wdt_unlock(wdt->base); 208 val = readl_relaxed(wdt->base + SPRD_WDT_CTRL); 209 val &= ~(SPRD_WDT_CNT_EN_BIT | SPRD_WDT_RST_EN_BIT | 210 SPRD_WDT_INT_EN_BIT); 211 writel_relaxed(val, wdt->base + SPRD_WDT_CTRL); 212 sprd_wdt_lock(wdt->base); 213 return 0; 214 } 215 216 static int sprd_wdt_set_timeout(struct watchdog_device *wdd, 217 u32 timeout) 218 { 219 struct sprd_wdt *wdt = to_sprd_wdt(wdd); 220 221 if (timeout == wdd->timeout) 222 return 0; 223 224 wdd->timeout = timeout; 225 226 return sprd_wdt_load_value(wdt, timeout, wdd->pretimeout); 227 } 228 229 static int sprd_wdt_set_pretimeout(struct watchdog_device *wdd, 230 u32 new_pretimeout) 231 { 232 struct sprd_wdt *wdt = to_sprd_wdt(wdd); 233 234 if (new_pretimeout < wdd->min_timeout) 235 return -EINVAL; 236 237 wdd->pretimeout = new_pretimeout; 238 239 return sprd_wdt_load_value(wdt, wdd->timeout, new_pretimeout); 240 } 241 242 static u32 sprd_wdt_get_timeleft(struct watchdog_device *wdd) 243 { 244 struct sprd_wdt *wdt = to_sprd_wdt(wdd); 245 u32 val; 246 247 val = sprd_wdt_get_cnt_value(wdt); 248 val = val / SPRD_WDT_CNT_STEP; 249 250 return val; 251 } 252 253 static const struct watchdog_ops sprd_wdt_ops = { 254 .owner = THIS_MODULE, 255 .start = sprd_wdt_start, 256 .stop = sprd_wdt_stop, 257 .set_timeout = sprd_wdt_set_timeout, 258 .set_pretimeout = sprd_wdt_set_pretimeout, 259 .get_timeleft = sprd_wdt_get_timeleft, 260 }; 261 262 static const struct watchdog_info sprd_wdt_info = { 263 .options = WDIOF_SETTIMEOUT | 264 WDIOF_PRETIMEOUT | 265 WDIOF_MAGICCLOSE | 266 WDIOF_KEEPALIVEPING, 267 .identity = "Spreadtrum Watchdog Timer", 268 }; 269 270 static int sprd_wdt_probe(struct platform_device *pdev) 271 { 272 struct resource *wdt_res; 273 struct sprd_wdt *wdt; 274 int ret; 275 276 wdt = devm_kzalloc(&pdev->dev, sizeof(*wdt), GFP_KERNEL); 277 if (!wdt) 278 return -ENOMEM; 279 280 wdt_res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 281 wdt->base = devm_ioremap_resource(&pdev->dev, wdt_res); 282 if (IS_ERR(wdt->base)) { 283 dev_err(&pdev->dev, "failed to map memory resource\n"); 284 return PTR_ERR(wdt->base); 285 } 286 287 wdt->enable = devm_clk_get(&pdev->dev, "enable"); 288 if (IS_ERR(wdt->enable)) { 289 dev_err(&pdev->dev, "can't get the enable clock\n"); 290 return PTR_ERR(wdt->enable); 291 } 292 293 wdt->rtc_enable = devm_clk_get(&pdev->dev, "rtc_enable"); 294 if (IS_ERR(wdt->rtc_enable)) { 295 dev_err(&pdev->dev, "can't get the rtc enable clock\n"); 296 return PTR_ERR(wdt->rtc_enable); 297 } 298 299 wdt->irq = platform_get_irq(pdev, 0); 300 if (wdt->irq < 0) { 301 dev_err(&pdev->dev, "failed to get IRQ resource\n"); 302 return wdt->irq; 303 } 304 305 ret = devm_request_irq(&pdev->dev, wdt->irq, sprd_wdt_isr, 306 IRQF_NO_SUSPEND, "sprd-wdt", (void *)wdt); 307 if (ret) { 308 dev_err(&pdev->dev, "failed to register irq\n"); 309 return ret; 310 } 311 312 wdt->wdd.info = &sprd_wdt_info; 313 wdt->wdd.ops = &sprd_wdt_ops; 314 wdt->wdd.parent = &pdev->dev; 315 wdt->wdd.min_timeout = SPRD_WDT_MIN_TIMEOUT; 316 wdt->wdd.max_timeout = SPRD_WDT_MAX_TIMEOUT; 317 wdt->wdd.timeout = SPRD_WDT_MAX_TIMEOUT; 318 319 ret = sprd_wdt_enable(wdt); 320 if (ret) { 321 dev_err(&pdev->dev, "failed to enable wdt\n"); 322 return ret; 323 } 324 ret = devm_add_action(&pdev->dev, sprd_wdt_disable, wdt); 325 if (ret) { 326 sprd_wdt_disable(wdt); 327 dev_err(&pdev->dev, "Failed to add wdt disable action\n"); 328 return ret; 329 } 330 331 watchdog_set_nowayout(&wdt->wdd, WATCHDOG_NOWAYOUT); 332 watchdog_init_timeout(&wdt->wdd, 0, &pdev->dev); 333 334 ret = devm_watchdog_register_device(&pdev->dev, &wdt->wdd); 335 if (ret) { 336 sprd_wdt_disable(wdt); 337 dev_err(&pdev->dev, "failed to register watchdog\n"); 338 return ret; 339 } 340 platform_set_drvdata(pdev, wdt); 341 342 return 0; 343 } 344 345 static int __maybe_unused sprd_wdt_pm_suspend(struct device *dev) 346 { 347 struct watchdog_device *wdd = dev_get_drvdata(dev); 348 struct sprd_wdt *wdt = dev_get_drvdata(dev); 349 350 if (watchdog_active(wdd)) 351 sprd_wdt_stop(&wdt->wdd); 352 sprd_wdt_disable(wdt); 353 354 return 0; 355 } 356 357 static int __maybe_unused sprd_wdt_pm_resume(struct device *dev) 358 { 359 struct watchdog_device *wdd = dev_get_drvdata(dev); 360 struct sprd_wdt *wdt = dev_get_drvdata(dev); 361 int ret; 362 363 ret = sprd_wdt_enable(wdt); 364 if (ret) 365 return ret; 366 367 if (watchdog_active(wdd)) { 368 ret = sprd_wdt_start(&wdt->wdd); 369 if (ret) { 370 sprd_wdt_disable(wdt); 371 return ret; 372 } 373 } 374 375 return 0; 376 } 377 378 static const struct dev_pm_ops sprd_wdt_pm_ops = { 379 SET_SYSTEM_SLEEP_PM_OPS(sprd_wdt_pm_suspend, 380 sprd_wdt_pm_resume) 381 }; 382 383 static const struct of_device_id sprd_wdt_match_table[] = { 384 { .compatible = "sprd,sp9860-wdt", }, 385 {}, 386 }; 387 MODULE_DEVICE_TABLE(of, sprd_wdt_match_table); 388 389 static struct platform_driver sprd_watchdog_driver = { 390 .probe = sprd_wdt_probe, 391 .driver = { 392 .name = "sprd-wdt", 393 .of_match_table = sprd_wdt_match_table, 394 .pm = &sprd_wdt_pm_ops, 395 }, 396 }; 397 module_platform_driver(sprd_watchdog_driver); 398 399 MODULE_AUTHOR("Eric Long <eric.long@spreadtrum.com>"); 400 MODULE_DESCRIPTION("Spreadtrum Watchdog Timer Controller Driver"); 401 MODULE_LICENSE("GPL v2"); 402