rtc-mc13xxx.c 7.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * Real Time Clock driver for Freescale MC13XXX PMIC
  4. *
  5. * (C) 2009 Sascha Hauer, Pengutronix
  6. * (C) 2009 Uwe Kleine-Koenig, Pengutronix
  7. */
  8. #include <linux/mfd/mc13xxx.h>
  9. #include <linux/platform_device.h>
  10. #include <linux/kernel.h>
  11. #include <linux/module.h>
  12. #include <linux/mod_devicetable.h>
  13. #include <linux/slab.h>
  14. #include <linux/rtc.h>
  15. #define DRIVER_NAME "mc13xxx-rtc"
  16. #define MC13XXX_RTCTOD 20
  17. #define MC13XXX_RTCTODA 21
  18. #define MC13XXX_RTCDAY 22
  19. #define MC13XXX_RTCDAYA 23
  20. #define SEC_PER_DAY (24 * 60 * 60)
  21. struct mc13xxx_rtc {
  22. struct rtc_device *rtc;
  23. struct mc13xxx *mc13xxx;
  24. int valid;
  25. };
  26. static int mc13xxx_rtc_irq_enable_unlocked(struct device *dev,
  27. unsigned int enabled, int irq)
  28. {
  29. struct mc13xxx_rtc *priv = dev_get_drvdata(dev);
  30. int (*func)(struct mc13xxx *mc13xxx, int irq);
  31. if (!priv->valid)
  32. return -ENODATA;
  33. func = enabled ? mc13xxx_irq_unmask : mc13xxx_irq_mask;
  34. return func(priv->mc13xxx, irq);
  35. }
  36. static int mc13xxx_rtc_alarm_irq_enable(struct device *dev,
  37. unsigned int enabled)
  38. {
  39. struct mc13xxx_rtc *priv = dev_get_drvdata(dev);
  40. int ret;
  41. mc13xxx_lock(priv->mc13xxx);
  42. ret = mc13xxx_rtc_irq_enable_unlocked(dev, enabled, MC13XXX_IRQ_TODA);
  43. mc13xxx_unlock(priv->mc13xxx);
  44. return ret;
  45. }
  46. static int mc13xxx_rtc_read_time(struct device *dev, struct rtc_time *tm)
  47. {
  48. struct mc13xxx_rtc *priv = dev_get_drvdata(dev);
  49. unsigned int seconds, days1, days2;
  50. if (!priv->valid)
  51. return -ENODATA;
  52. do {
  53. int ret;
  54. ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCDAY, &days1);
  55. if (ret)
  56. return ret;
  57. ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCTOD, &seconds);
  58. if (ret)
  59. return ret;
  60. ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCDAY, &days2);
  61. if (ret)
  62. return ret;
  63. } while (days1 != days2);
  64. rtc_time64_to_tm((time64_t)days1 * SEC_PER_DAY + seconds, tm);
  65. return 0;
  66. }
  67. static int mc13xxx_rtc_set_time(struct device *dev, struct rtc_time *tm)
  68. {
  69. struct mc13xxx_rtc *priv = dev_get_drvdata(dev);
  70. unsigned int seconds, days;
  71. unsigned int alarmseconds;
  72. int ret;
  73. days = div_s64_rem(rtc_tm_to_time64(tm), SEC_PER_DAY, &seconds);
  74. mc13xxx_lock(priv->mc13xxx);
  75. /*
  76. * temporarily invalidate alarm to prevent triggering it when the day is
  77. * already updated while the time isn't yet.
  78. */
  79. ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCTODA, &alarmseconds);
  80. if (unlikely(ret))
  81. goto out;
  82. if (alarmseconds < SEC_PER_DAY) {
  83. ret = mc13xxx_reg_write(priv->mc13xxx,
  84. MC13XXX_RTCTODA, 0x1ffff);
  85. if (unlikely(ret))
  86. goto out;
  87. }
  88. /*
  89. * write seconds=0 to prevent a day switch between writing days
  90. * and seconds below
  91. */
  92. ret = mc13xxx_reg_write(priv->mc13xxx, MC13XXX_RTCTOD, 0);
  93. if (unlikely(ret))
  94. goto out;
  95. ret = mc13xxx_reg_write(priv->mc13xxx, MC13XXX_RTCDAY, days);
  96. if (unlikely(ret))
  97. goto out;
  98. ret = mc13xxx_reg_write(priv->mc13xxx, MC13XXX_RTCTOD, seconds);
  99. if (unlikely(ret))
  100. goto out;
  101. /* restore alarm */
  102. if (alarmseconds < SEC_PER_DAY) {
  103. ret = mc13xxx_reg_write(priv->mc13xxx,
  104. MC13XXX_RTCTODA, alarmseconds);
  105. if (unlikely(ret))
  106. goto out;
  107. }
  108. if (!priv->valid) {
  109. ret = mc13xxx_irq_ack(priv->mc13xxx, MC13XXX_IRQ_RTCRST);
  110. if (unlikely(ret))
  111. goto out;
  112. ret = mc13xxx_irq_unmask(priv->mc13xxx, MC13XXX_IRQ_RTCRST);
  113. }
  114. out:
  115. priv->valid = !ret;
  116. mc13xxx_unlock(priv->mc13xxx);
  117. return ret;
  118. }
  119. static int mc13xxx_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
  120. {
  121. struct mc13xxx_rtc *priv = dev_get_drvdata(dev);
  122. unsigned int seconds, days;
  123. time64_t s1970;
  124. int enabled, pending;
  125. int ret;
  126. mc13xxx_lock(priv->mc13xxx);
  127. ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCTODA, &seconds);
  128. if (unlikely(ret))
  129. goto out;
  130. if (seconds >= SEC_PER_DAY) {
  131. ret = -ENODATA;
  132. goto out;
  133. }
  134. ret = mc13xxx_reg_read(priv->mc13xxx, MC13XXX_RTCDAY, &days);
  135. if (unlikely(ret))
  136. goto out;
  137. ret = mc13xxx_irq_status(priv->mc13xxx, MC13XXX_IRQ_TODA,
  138. &enabled, &pending);
  139. out:
  140. mc13xxx_unlock(priv->mc13xxx);
  141. if (ret)
  142. return ret;
  143. alarm->enabled = enabled;
  144. alarm->pending = pending;
  145. s1970 = (time64_t)days * SEC_PER_DAY + seconds;
  146. rtc_time64_to_tm(s1970, &alarm->time);
  147. dev_dbg(dev, "%s: %lld\n", __func__, (long long)s1970);
  148. return 0;
  149. }
  150. static int mc13xxx_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
  151. {
  152. struct mc13xxx_rtc *priv = dev_get_drvdata(dev);
  153. time64_t s1970;
  154. u32 seconds, days;
  155. int ret;
  156. mc13xxx_lock(priv->mc13xxx);
  157. /* disable alarm to prevent false triggering */
  158. ret = mc13xxx_reg_write(priv->mc13xxx, MC13XXX_RTCTODA, 0x1ffff);
  159. if (unlikely(ret))
  160. goto out;
  161. ret = mc13xxx_irq_ack(priv->mc13xxx, MC13XXX_IRQ_TODA);
  162. if (unlikely(ret))
  163. goto out;
  164. s1970 = rtc_tm_to_time64(&alarm->time);
  165. dev_dbg(dev, "%s: %s %lld\n", __func__, alarm->enabled ? "on" : "off",
  166. (long long)s1970);
  167. ret = mc13xxx_rtc_irq_enable_unlocked(dev, alarm->enabled,
  168. MC13XXX_IRQ_TODA);
  169. if (unlikely(ret))
  170. goto out;
  171. days = div_s64_rem(s1970, SEC_PER_DAY, &seconds);
  172. ret = mc13xxx_reg_write(priv->mc13xxx, MC13XXX_RTCDAYA, days);
  173. if (unlikely(ret))
  174. goto out;
  175. ret = mc13xxx_reg_write(priv->mc13xxx, MC13XXX_RTCTODA, seconds);
  176. out:
  177. mc13xxx_unlock(priv->mc13xxx);
  178. return ret;
  179. }
  180. static irqreturn_t mc13xxx_rtc_alarm_handler(int irq, void *dev)
  181. {
  182. struct mc13xxx_rtc *priv = dev;
  183. struct mc13xxx *mc13xxx = priv->mc13xxx;
  184. rtc_update_irq(priv->rtc, 1, RTC_IRQF | RTC_AF);
  185. mc13xxx_irq_ack(mc13xxx, irq);
  186. return IRQ_HANDLED;
  187. }
  188. static const struct rtc_class_ops mc13xxx_rtc_ops = {
  189. .read_time = mc13xxx_rtc_read_time,
  190. .set_time = mc13xxx_rtc_set_time,
  191. .read_alarm = mc13xxx_rtc_read_alarm,
  192. .set_alarm = mc13xxx_rtc_set_alarm,
  193. .alarm_irq_enable = mc13xxx_rtc_alarm_irq_enable,
  194. };
  195. static irqreturn_t mc13xxx_rtc_reset_handler(int irq, void *dev)
  196. {
  197. struct mc13xxx_rtc *priv = dev;
  198. struct mc13xxx *mc13xxx = priv->mc13xxx;
  199. priv->valid = 0;
  200. mc13xxx_irq_mask(mc13xxx, irq);
  201. return IRQ_HANDLED;
  202. }
  203. static int __init mc13xxx_rtc_probe(struct platform_device *pdev)
  204. {
  205. int ret;
  206. struct mc13xxx_rtc *priv;
  207. struct mc13xxx *mc13xxx;
  208. priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
  209. if (!priv)
  210. return -ENOMEM;
  211. mc13xxx = dev_get_drvdata(pdev->dev.parent);
  212. priv->mc13xxx = mc13xxx;
  213. priv->valid = 1;
  214. priv->rtc = devm_rtc_allocate_device(&pdev->dev);
  215. if (IS_ERR(priv->rtc))
  216. return PTR_ERR(priv->rtc);
  217. platform_set_drvdata(pdev, priv);
  218. priv->rtc->ops = &mc13xxx_rtc_ops;
  219. /* 15bit days + hours, minutes, seconds */
  220. priv->rtc->range_max = (timeu64_t)(1 << 15) * SEC_PER_DAY - 1;
  221. mc13xxx_lock(mc13xxx);
  222. mc13xxx_irq_ack(mc13xxx, MC13XXX_IRQ_RTCRST);
  223. ret = mc13xxx_irq_request(mc13xxx, MC13XXX_IRQ_RTCRST,
  224. mc13xxx_rtc_reset_handler, DRIVER_NAME, priv);
  225. if (ret)
  226. goto err_irq_request;
  227. ret = mc13xxx_irq_request_nounmask(mc13xxx, MC13XXX_IRQ_TODA,
  228. mc13xxx_rtc_alarm_handler, DRIVER_NAME, priv);
  229. if (ret)
  230. goto err_irq_request;
  231. mc13xxx_unlock(mc13xxx);
  232. ret = rtc_register_device(priv->rtc);
  233. if (ret) {
  234. mc13xxx_lock(mc13xxx);
  235. goto err_irq_request;
  236. }
  237. return 0;
  238. err_irq_request:
  239. mc13xxx_irq_free(mc13xxx, MC13XXX_IRQ_TODA, priv);
  240. mc13xxx_irq_free(mc13xxx, MC13XXX_IRQ_RTCRST, priv);
  241. mc13xxx_unlock(mc13xxx);
  242. return ret;
  243. }
  244. static int mc13xxx_rtc_remove(struct platform_device *pdev)
  245. {
  246. struct mc13xxx_rtc *priv = platform_get_drvdata(pdev);
  247. mc13xxx_lock(priv->mc13xxx);
  248. mc13xxx_irq_free(priv->mc13xxx, MC13XXX_IRQ_TODA, priv);
  249. mc13xxx_irq_free(priv->mc13xxx, MC13XXX_IRQ_RTCRST, priv);
  250. mc13xxx_unlock(priv->mc13xxx);
  251. return 0;
  252. }
  253. static const struct platform_device_id mc13xxx_rtc_idtable[] = {
  254. {
  255. .name = "mc13783-rtc",
  256. }, {
  257. .name = "mc13892-rtc",
  258. }, {
  259. .name = "mc34708-rtc",
  260. },
  261. { /* sentinel */ }
  262. };
  263. MODULE_DEVICE_TABLE(platform, mc13xxx_rtc_idtable);
  264. static struct platform_driver mc13xxx_rtc_driver = {
  265. .id_table = mc13xxx_rtc_idtable,
  266. .remove = mc13xxx_rtc_remove,
  267. .driver = {
  268. .name = DRIVER_NAME,
  269. },
  270. };
  271. module_platform_driver_probe(mc13xxx_rtc_driver, &mc13xxx_rtc_probe);
  272. MODULE_AUTHOR("Sascha Hauer <s.hauer@pengutronix.de>");
  273. MODULE_DESCRIPTION("RTC driver for Freescale MC13XXX PMIC");
  274. MODULE_LICENSE("GPL v2");