bcm_kona_wdt.c 8.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * Copyright (C) 2013 Broadcom Corporation
  4. *
  5. */
  6. #include <linux/debugfs.h>
  7. #include <linux/delay.h>
  8. #include <linux/err.h>
  9. #include <linux/io.h>
  10. #include <linux/module.h>
  11. #include <linux/of_address.h>
  12. #include <linux/platform_device.h>
  13. #include <linux/watchdog.h>
  14. #define SECWDOG_CTRL_REG 0x00000000
  15. #define SECWDOG_COUNT_REG 0x00000004
  16. #define SECWDOG_RESERVED_MASK 0x1dffffff
  17. #define SECWDOG_WD_LOAD_FLAG 0x10000000
  18. #define SECWDOG_EN_MASK 0x08000000
  19. #define SECWDOG_SRSTEN_MASK 0x04000000
  20. #define SECWDOG_RES_MASK 0x00f00000
  21. #define SECWDOG_COUNT_MASK 0x000fffff
  22. #define SECWDOG_MAX_COUNT SECWDOG_COUNT_MASK
  23. #define SECWDOG_CLKS_SHIFT 20
  24. #define SECWDOG_MAX_RES 15
  25. #define SECWDOG_DEFAULT_RESOLUTION 4
  26. #define SECWDOG_MAX_TRY 1000
  27. #define SECS_TO_TICKS(x, w) ((x) << (w)->resolution)
  28. #define TICKS_TO_SECS(x, w) ((x) >> (w)->resolution)
  29. #define BCM_KONA_WDT_NAME "bcm_kona_wdt"
  30. struct bcm_kona_wdt {
  31. void __iomem *base;
  32. /*
  33. * One watchdog tick is 1/(2^resolution) seconds. Resolution can take
  34. * the values 0-15, meaning one tick can be 1s to 30.52us. Our default
  35. * resolution of 4 means one tick is 62.5ms.
  36. *
  37. * The watchdog counter is 20 bits. Depending on resolution, the maximum
  38. * counter value of 0xfffff expires after about 12 days (resolution 0)
  39. * down to only 32s (resolution 15). The default resolution of 4 gives
  40. * us a maximum of about 18 hours and 12 minutes before the watchdog
  41. * times out.
  42. */
  43. int resolution;
  44. spinlock_t lock;
  45. #ifdef CONFIG_BCM_KONA_WDT_DEBUG
  46. unsigned long busy_count;
  47. struct dentry *debugfs;
  48. #endif
  49. };
  50. static int secure_register_read(struct bcm_kona_wdt *wdt, uint32_t offset)
  51. {
  52. uint32_t val;
  53. unsigned count = 0;
  54. /*
  55. * If the WD_LOAD_FLAG is set, the watchdog counter field is being
  56. * updated in hardware. Once the WD timer is updated in hardware, it
  57. * gets cleared.
  58. */
  59. do {
  60. if (unlikely(count > 1))
  61. udelay(5);
  62. val = readl_relaxed(wdt->base + offset);
  63. count++;
  64. } while ((val & SECWDOG_WD_LOAD_FLAG) && count < SECWDOG_MAX_TRY);
  65. #ifdef CONFIG_BCM_KONA_WDT_DEBUG
  66. /* Remember the maximum number iterations due to WD_LOAD_FLAG */
  67. if (count > wdt->busy_count)
  68. wdt->busy_count = count;
  69. #endif
  70. /* This is the only place we return a negative value. */
  71. if (val & SECWDOG_WD_LOAD_FLAG)
  72. return -ETIMEDOUT;
  73. /* We always mask out reserved bits. */
  74. val &= SECWDOG_RESERVED_MASK;
  75. return val;
  76. }
  77. #ifdef CONFIG_BCM_KONA_WDT_DEBUG
  78. static int bcm_kona_show(struct seq_file *s, void *data)
  79. {
  80. int ctl_val, cur_val;
  81. unsigned long flags;
  82. struct bcm_kona_wdt *wdt = s->private;
  83. if (!wdt) {
  84. seq_puts(s, "No device pointer\n");
  85. return 0;
  86. }
  87. spin_lock_irqsave(&wdt->lock, flags);
  88. ctl_val = secure_register_read(wdt, SECWDOG_CTRL_REG);
  89. cur_val = secure_register_read(wdt, SECWDOG_COUNT_REG);
  90. spin_unlock_irqrestore(&wdt->lock, flags);
  91. if (ctl_val < 0 || cur_val < 0) {
  92. seq_puts(s, "Error accessing hardware\n");
  93. } else {
  94. int ctl, cur, ctl_sec, cur_sec, res;
  95. ctl = ctl_val & SECWDOG_COUNT_MASK;
  96. res = (ctl_val & SECWDOG_RES_MASK) >> SECWDOG_CLKS_SHIFT;
  97. cur = cur_val & SECWDOG_COUNT_MASK;
  98. ctl_sec = TICKS_TO_SECS(ctl, wdt);
  99. cur_sec = TICKS_TO_SECS(cur, wdt);
  100. seq_printf(s,
  101. "Resolution: %d / %d\n"
  102. "Control: %d s / %d (%#x) ticks\n"
  103. "Current: %d s / %d (%#x) ticks\n"
  104. "Busy count: %lu\n",
  105. res, wdt->resolution,
  106. ctl_sec, ctl, ctl,
  107. cur_sec, cur, cur,
  108. wdt->busy_count);
  109. }
  110. return 0;
  111. }
  112. DEFINE_SHOW_ATTRIBUTE(bcm_kona);
  113. static void bcm_kona_wdt_debug_init(struct platform_device *pdev)
  114. {
  115. struct dentry *dir;
  116. struct bcm_kona_wdt *wdt = platform_get_drvdata(pdev);
  117. if (!wdt)
  118. return;
  119. wdt->debugfs = NULL;
  120. dir = debugfs_create_dir(BCM_KONA_WDT_NAME, NULL);
  121. debugfs_create_file("info", S_IFREG | S_IRUGO, dir, wdt,
  122. &bcm_kona_fops);
  123. wdt->debugfs = dir;
  124. }
  125. static void bcm_kona_wdt_debug_exit(struct platform_device *pdev)
  126. {
  127. struct bcm_kona_wdt *wdt = platform_get_drvdata(pdev);
  128. if (wdt)
  129. debugfs_remove_recursive(wdt->debugfs);
  130. }
  131. #else
  132. static void bcm_kona_wdt_debug_init(struct platform_device *pdev) {}
  133. static void bcm_kona_wdt_debug_exit(struct platform_device *pdev) {}
  134. #endif /* CONFIG_BCM_KONA_WDT_DEBUG */
  135. static int bcm_kona_wdt_ctrl_reg_modify(struct bcm_kona_wdt *wdt,
  136. unsigned mask, unsigned newval)
  137. {
  138. int val;
  139. unsigned long flags;
  140. int ret = 0;
  141. spin_lock_irqsave(&wdt->lock, flags);
  142. val = secure_register_read(wdt, SECWDOG_CTRL_REG);
  143. if (val < 0) {
  144. ret = val;
  145. } else {
  146. val &= ~mask;
  147. val |= newval;
  148. writel_relaxed(val, wdt->base + SECWDOG_CTRL_REG);
  149. }
  150. spin_unlock_irqrestore(&wdt->lock, flags);
  151. return ret;
  152. }
  153. static int bcm_kona_wdt_set_resolution_reg(struct bcm_kona_wdt *wdt)
  154. {
  155. if (wdt->resolution > SECWDOG_MAX_RES)
  156. return -EINVAL;
  157. return bcm_kona_wdt_ctrl_reg_modify(wdt, SECWDOG_RES_MASK,
  158. wdt->resolution << SECWDOG_CLKS_SHIFT);
  159. }
  160. static int bcm_kona_wdt_set_timeout_reg(struct watchdog_device *wdog,
  161. unsigned watchdog_flags)
  162. {
  163. struct bcm_kona_wdt *wdt = watchdog_get_drvdata(wdog);
  164. return bcm_kona_wdt_ctrl_reg_modify(wdt, SECWDOG_COUNT_MASK,
  165. SECS_TO_TICKS(wdog->timeout, wdt) |
  166. watchdog_flags);
  167. }
  168. static int bcm_kona_wdt_set_timeout(struct watchdog_device *wdog,
  169. unsigned int t)
  170. {
  171. wdog->timeout = t;
  172. return 0;
  173. }
  174. static unsigned int bcm_kona_wdt_get_timeleft(struct watchdog_device *wdog)
  175. {
  176. struct bcm_kona_wdt *wdt = watchdog_get_drvdata(wdog);
  177. int val;
  178. unsigned long flags;
  179. spin_lock_irqsave(&wdt->lock, flags);
  180. val = secure_register_read(wdt, SECWDOG_COUNT_REG);
  181. spin_unlock_irqrestore(&wdt->lock, flags);
  182. if (val < 0)
  183. return val;
  184. return TICKS_TO_SECS(val & SECWDOG_COUNT_MASK, wdt);
  185. }
  186. static int bcm_kona_wdt_start(struct watchdog_device *wdog)
  187. {
  188. return bcm_kona_wdt_set_timeout_reg(wdog,
  189. SECWDOG_EN_MASK | SECWDOG_SRSTEN_MASK);
  190. }
  191. static int bcm_kona_wdt_stop(struct watchdog_device *wdog)
  192. {
  193. struct bcm_kona_wdt *wdt = watchdog_get_drvdata(wdog);
  194. return bcm_kona_wdt_ctrl_reg_modify(wdt, SECWDOG_EN_MASK |
  195. SECWDOG_SRSTEN_MASK, 0);
  196. }
  197. static const struct watchdog_ops bcm_kona_wdt_ops = {
  198. .owner = THIS_MODULE,
  199. .start = bcm_kona_wdt_start,
  200. .stop = bcm_kona_wdt_stop,
  201. .set_timeout = bcm_kona_wdt_set_timeout,
  202. .get_timeleft = bcm_kona_wdt_get_timeleft,
  203. };
  204. static const struct watchdog_info bcm_kona_wdt_info = {
  205. .options = WDIOF_SETTIMEOUT | WDIOF_MAGICCLOSE |
  206. WDIOF_KEEPALIVEPING,
  207. .identity = "Broadcom Kona Watchdog Timer",
  208. };
  209. static struct watchdog_device bcm_kona_wdt_wdd = {
  210. .info = &bcm_kona_wdt_info,
  211. .ops = &bcm_kona_wdt_ops,
  212. .min_timeout = 1,
  213. .max_timeout = SECWDOG_MAX_COUNT >> SECWDOG_DEFAULT_RESOLUTION,
  214. .timeout = SECWDOG_MAX_COUNT >> SECWDOG_DEFAULT_RESOLUTION,
  215. };
  216. static int bcm_kona_wdt_probe(struct platform_device *pdev)
  217. {
  218. struct device *dev = &pdev->dev;
  219. struct bcm_kona_wdt *wdt;
  220. int ret;
  221. wdt = devm_kzalloc(dev, sizeof(*wdt), GFP_KERNEL);
  222. if (!wdt)
  223. return -ENOMEM;
  224. spin_lock_init(&wdt->lock);
  225. wdt->base = devm_platform_ioremap_resource(pdev, 0);
  226. if (IS_ERR(wdt->base))
  227. return PTR_ERR(wdt->base);
  228. wdt->resolution = SECWDOG_DEFAULT_RESOLUTION;
  229. ret = bcm_kona_wdt_set_resolution_reg(wdt);
  230. if (ret) {
  231. dev_err(dev, "Failed to set resolution (error: %d)", ret);
  232. return ret;
  233. }
  234. platform_set_drvdata(pdev, wdt);
  235. watchdog_set_drvdata(&bcm_kona_wdt_wdd, wdt);
  236. bcm_kona_wdt_wdd.parent = dev;
  237. ret = bcm_kona_wdt_set_timeout_reg(&bcm_kona_wdt_wdd, 0);
  238. if (ret) {
  239. dev_err(dev, "Failed set watchdog timeout");
  240. return ret;
  241. }
  242. watchdog_stop_on_reboot(&bcm_kona_wdt_wdd);
  243. watchdog_stop_on_unregister(&bcm_kona_wdt_wdd);
  244. ret = devm_watchdog_register_device(dev, &bcm_kona_wdt_wdd);
  245. if (ret)
  246. return ret;
  247. bcm_kona_wdt_debug_init(pdev);
  248. dev_dbg(dev, "Broadcom Kona Watchdog Timer");
  249. return 0;
  250. }
  251. static int bcm_kona_wdt_remove(struct platform_device *pdev)
  252. {
  253. bcm_kona_wdt_debug_exit(pdev);
  254. dev_dbg(&pdev->dev, "Watchdog driver disabled");
  255. return 0;
  256. }
  257. static const struct of_device_id bcm_kona_wdt_of_match[] = {
  258. { .compatible = "brcm,kona-wdt", },
  259. {},
  260. };
  261. MODULE_DEVICE_TABLE(of, bcm_kona_wdt_of_match);
  262. static struct platform_driver bcm_kona_wdt_driver = {
  263. .driver = {
  264. .name = BCM_KONA_WDT_NAME,
  265. .of_match_table = bcm_kona_wdt_of_match,
  266. },
  267. .probe = bcm_kona_wdt_probe,
  268. .remove = bcm_kona_wdt_remove,
  269. };
  270. module_platform_driver(bcm_kona_wdt_driver);
  271. MODULE_ALIAS("platform:" BCM_KONA_WDT_NAME);
  272. MODULE_AUTHOR("Markus Mayer <mmayer@broadcom.com>");
  273. MODULE_DESCRIPTION("Broadcom Kona Watchdog Driver");
  274. MODULE_LICENSE("GPL v2");