da9062_wdt.c 6.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Watchdog device driver for DA9062 and DA9061 PMICs
  4. * Copyright (C) 2015 Dialog Semiconductor Ltd.
  5. *
  6. */
  7. #include <linux/kernel.h>
  8. #include <linux/module.h>
  9. #include <linux/watchdog.h>
  10. #include <linux/platform_device.h>
  11. #include <linux/uaccess.h>
  12. #include <linux/slab.h>
  13. #include <linux/i2c.h>
  14. #include <linux/delay.h>
  15. #include <linux/jiffies.h>
  16. #include <linux/mfd/da9062/registers.h>
  17. #include <linux/mfd/da9062/core.h>
  18. #include <linux/property.h>
  19. #include <linux/regmap.h>
  20. #include <linux/of.h>
  21. static const unsigned int wdt_timeout[] = { 0, 2, 4, 8, 16, 32, 65, 131 };
  22. #define DA9062_TWDSCALE_DISABLE 0
  23. #define DA9062_TWDSCALE_MIN 1
  24. #define DA9062_TWDSCALE_MAX (ARRAY_SIZE(wdt_timeout) - 1)
  25. #define DA9062_WDT_MIN_TIMEOUT wdt_timeout[DA9062_TWDSCALE_MIN]
  26. #define DA9062_WDT_MAX_TIMEOUT wdt_timeout[DA9062_TWDSCALE_MAX]
  27. #define DA9062_WDG_DEFAULT_TIMEOUT wdt_timeout[DA9062_TWDSCALE_MAX-1]
  28. #define DA9062_RESET_PROTECTION_MS 300
  29. struct da9062_watchdog {
  30. struct da9062 *hw;
  31. struct watchdog_device wdtdev;
  32. bool use_sw_pm;
  33. };
  34. static unsigned int da9062_wdt_read_timeout(struct da9062_watchdog *wdt)
  35. {
  36. unsigned int val;
  37. regmap_read(wdt->hw->regmap, DA9062AA_CONTROL_D, &val);
  38. return wdt_timeout[val & DA9062AA_TWDSCALE_MASK];
  39. }
  40. static unsigned int da9062_wdt_timeout_to_sel(unsigned int secs)
  41. {
  42. unsigned int i;
  43. for (i = DA9062_TWDSCALE_MIN; i <= DA9062_TWDSCALE_MAX; i++) {
  44. if (wdt_timeout[i] >= secs)
  45. return i;
  46. }
  47. return DA9062_TWDSCALE_MAX;
  48. }
  49. static int da9062_reset_watchdog_timer(struct da9062_watchdog *wdt)
  50. {
  51. return regmap_update_bits(wdt->hw->regmap, DA9062AA_CONTROL_F,
  52. DA9062AA_WATCHDOG_MASK,
  53. DA9062AA_WATCHDOG_MASK);
  54. }
  55. static int da9062_wdt_update_timeout_register(struct da9062_watchdog *wdt,
  56. unsigned int regval)
  57. {
  58. struct da9062 *chip = wdt->hw;
  59. regmap_update_bits(chip->regmap,
  60. DA9062AA_CONTROL_D,
  61. DA9062AA_TWDSCALE_MASK,
  62. DA9062_TWDSCALE_DISABLE);
  63. usleep_range(150, 300);
  64. return regmap_update_bits(chip->regmap,
  65. DA9062AA_CONTROL_D,
  66. DA9062AA_TWDSCALE_MASK,
  67. regval);
  68. }
  69. static int da9062_wdt_start(struct watchdog_device *wdd)
  70. {
  71. struct da9062_watchdog *wdt = watchdog_get_drvdata(wdd);
  72. unsigned int selector;
  73. int ret;
  74. selector = da9062_wdt_timeout_to_sel(wdt->wdtdev.timeout);
  75. ret = da9062_wdt_update_timeout_register(wdt, selector);
  76. if (ret)
  77. dev_err(wdt->hw->dev, "Watchdog failed to start (err = %d)\n",
  78. ret);
  79. return ret;
  80. }
  81. static int da9062_wdt_stop(struct watchdog_device *wdd)
  82. {
  83. struct da9062_watchdog *wdt = watchdog_get_drvdata(wdd);
  84. int ret;
  85. ret = regmap_update_bits(wdt->hw->regmap,
  86. DA9062AA_CONTROL_D,
  87. DA9062AA_TWDSCALE_MASK,
  88. DA9062_TWDSCALE_DISABLE);
  89. if (ret)
  90. dev_err(wdt->hw->dev, "Watchdog failed to stop (err = %d)\n",
  91. ret);
  92. return ret;
  93. }
  94. static int da9062_wdt_ping(struct watchdog_device *wdd)
  95. {
  96. struct da9062_watchdog *wdt = watchdog_get_drvdata(wdd);
  97. int ret;
  98. ret = da9062_reset_watchdog_timer(wdt);
  99. if (ret)
  100. dev_err(wdt->hw->dev, "Failed to ping the watchdog (err = %d)\n",
  101. ret);
  102. return ret;
  103. }
  104. static int da9062_wdt_set_timeout(struct watchdog_device *wdd,
  105. unsigned int timeout)
  106. {
  107. struct da9062_watchdog *wdt = watchdog_get_drvdata(wdd);
  108. unsigned int selector;
  109. int ret;
  110. selector = da9062_wdt_timeout_to_sel(timeout);
  111. ret = da9062_wdt_update_timeout_register(wdt, selector);
  112. if (ret)
  113. dev_err(wdt->hw->dev, "Failed to set watchdog timeout (err = %d)\n",
  114. ret);
  115. else
  116. wdd->timeout = wdt_timeout[selector];
  117. return ret;
  118. }
  119. static int da9062_wdt_restart(struct watchdog_device *wdd, unsigned long action,
  120. void *data)
  121. {
  122. struct da9062_watchdog *wdt = watchdog_get_drvdata(wdd);
  123. struct i2c_client *client = to_i2c_client(wdt->hw->dev);
  124. int ret;
  125. /* Don't use regmap because it is not atomic safe */
  126. ret = i2c_smbus_write_byte_data(client, DA9062AA_CONTROL_F,
  127. DA9062AA_SHUTDOWN_MASK);
  128. if (ret < 0)
  129. dev_alert(wdt->hw->dev, "Failed to shutdown (err = %d)\n",
  130. ret);
  131. /* wait for reset to assert... */
  132. mdelay(500);
  133. return ret;
  134. }
  135. static const struct watchdog_info da9062_watchdog_info = {
  136. .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING,
  137. .identity = "DA9062 WDT",
  138. };
  139. static const struct watchdog_ops da9062_watchdog_ops = {
  140. .owner = THIS_MODULE,
  141. .start = da9062_wdt_start,
  142. .stop = da9062_wdt_stop,
  143. .ping = da9062_wdt_ping,
  144. .set_timeout = da9062_wdt_set_timeout,
  145. .restart = da9062_wdt_restart,
  146. };
  147. static const struct of_device_id da9062_compatible_id_table[] = {
  148. { .compatible = "dlg,da9062-watchdog", },
  149. { },
  150. };
  151. MODULE_DEVICE_TABLE(of, da9062_compatible_id_table);
  152. static int da9062_wdt_probe(struct platform_device *pdev)
  153. {
  154. struct device *dev = &pdev->dev;
  155. unsigned int timeout;
  156. struct da9062 *chip;
  157. struct da9062_watchdog *wdt;
  158. chip = dev_get_drvdata(dev->parent);
  159. if (!chip)
  160. return -EINVAL;
  161. wdt = devm_kzalloc(dev, sizeof(*wdt), GFP_KERNEL);
  162. if (!wdt)
  163. return -ENOMEM;
  164. wdt->use_sw_pm = device_property_present(dev, "dlg,use-sw-pm");
  165. wdt->hw = chip;
  166. wdt->wdtdev.info = &da9062_watchdog_info;
  167. wdt->wdtdev.ops = &da9062_watchdog_ops;
  168. wdt->wdtdev.min_timeout = DA9062_WDT_MIN_TIMEOUT;
  169. wdt->wdtdev.max_timeout = DA9062_WDT_MAX_TIMEOUT;
  170. wdt->wdtdev.min_hw_heartbeat_ms = DA9062_RESET_PROTECTION_MS;
  171. wdt->wdtdev.timeout = DA9062_WDG_DEFAULT_TIMEOUT;
  172. wdt->wdtdev.status = WATCHDOG_NOWAYOUT_INIT_STATUS;
  173. wdt->wdtdev.parent = dev;
  174. watchdog_set_restart_priority(&wdt->wdtdev, 128);
  175. watchdog_set_drvdata(&wdt->wdtdev, wdt);
  176. dev_set_drvdata(dev, &wdt->wdtdev);
  177. timeout = da9062_wdt_read_timeout(wdt);
  178. if (timeout)
  179. wdt->wdtdev.timeout = timeout;
  180. /* Set timeout from DT value if available */
  181. watchdog_init_timeout(&wdt->wdtdev, 0, dev);
  182. if (timeout) {
  183. da9062_wdt_set_timeout(&wdt->wdtdev, wdt->wdtdev.timeout);
  184. set_bit(WDOG_HW_RUNNING, &wdt->wdtdev.status);
  185. }
  186. return devm_watchdog_register_device(dev, &wdt->wdtdev);
  187. }
  188. static int __maybe_unused da9062_wdt_suspend(struct device *dev)
  189. {
  190. struct watchdog_device *wdd = dev_get_drvdata(dev);
  191. struct da9062_watchdog *wdt = watchdog_get_drvdata(wdd);
  192. if (!wdt->use_sw_pm)
  193. return 0;
  194. if (watchdog_active(wdd))
  195. return da9062_wdt_stop(wdd);
  196. return 0;
  197. }
  198. static int __maybe_unused da9062_wdt_resume(struct device *dev)
  199. {
  200. struct watchdog_device *wdd = dev_get_drvdata(dev);
  201. struct da9062_watchdog *wdt = watchdog_get_drvdata(wdd);
  202. if (!wdt->use_sw_pm)
  203. return 0;
  204. if (watchdog_active(wdd))
  205. return da9062_wdt_start(wdd);
  206. return 0;
  207. }
  208. static SIMPLE_DEV_PM_OPS(da9062_wdt_pm_ops,
  209. da9062_wdt_suspend, da9062_wdt_resume);
  210. static struct platform_driver da9062_wdt_driver = {
  211. .probe = da9062_wdt_probe,
  212. .driver = {
  213. .name = "da9062-watchdog",
  214. .pm = &da9062_wdt_pm_ops,
  215. .of_match_table = da9062_compatible_id_table,
  216. },
  217. };
  218. module_platform_driver(da9062_wdt_driver);
  219. MODULE_AUTHOR("S Twiss <stwiss.opensource@diasemi.com>");
  220. MODULE_DESCRIPTION("WDT device driver for Dialog DA9062 and DA9061");
  221. MODULE_LICENSE("GPL");
  222. MODULE_ALIAS("platform:da9062-watchdog");