rtc-st-lpc.c 7.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * rtc-st-lpc.c - ST's LPC RTC, powered by the Low Power Timer
  4. *
  5. * Copyright (C) 2014 STMicroelectronics Limited
  6. *
  7. * Author: David Paris <david.paris@st.com> for STMicroelectronics
  8. * Lee Jones <lee.jones@linaro.org> for STMicroelectronics
  9. *
  10. * Based on the original driver written by Stuart Menefy.
  11. */
  12. #include <linux/clk.h>
  13. #include <linux/delay.h>
  14. #include <linux/init.h>
  15. #include <linux/io.h>
  16. #include <linux/irq.h>
  17. #include <linux/kernel.h>
  18. #include <linux/module.h>
  19. #include <linux/of.h>
  20. #include <linux/of_irq.h>
  21. #include <linux/platform_device.h>
  22. #include <linux/rtc.h>
  23. #include <dt-bindings/mfd/st-lpc.h>
  24. /* Low Power Timer */
  25. #define LPC_LPT_LSB_OFF 0x400
  26. #define LPC_LPT_MSB_OFF 0x404
  27. #define LPC_LPT_START_OFF 0x408
  28. /* Low Power Alarm */
  29. #define LPC_LPA_LSB_OFF 0x410
  30. #define LPC_LPA_MSB_OFF 0x414
  31. #define LPC_LPA_START_OFF 0x418
  32. /* LPC as WDT */
  33. #define LPC_WDT_OFF 0x510
  34. #define LPC_WDT_FLAG_OFF 0x514
  35. struct st_rtc {
  36. struct rtc_device *rtc_dev;
  37. struct rtc_wkalrm alarm;
  38. struct clk *clk;
  39. unsigned long clkrate;
  40. void __iomem *ioaddr;
  41. bool irq_enabled:1;
  42. spinlock_t lock;
  43. short irq;
  44. };
  45. static void st_rtc_set_hw_alarm(struct st_rtc *rtc,
  46. unsigned long msb, unsigned long lsb)
  47. {
  48. unsigned long flags;
  49. spin_lock_irqsave(&rtc->lock, flags);
  50. writel_relaxed(1, rtc->ioaddr + LPC_WDT_OFF);
  51. writel_relaxed(msb, rtc->ioaddr + LPC_LPA_MSB_OFF);
  52. writel_relaxed(lsb, rtc->ioaddr + LPC_LPA_LSB_OFF);
  53. writel_relaxed(1, rtc->ioaddr + LPC_LPA_START_OFF);
  54. writel_relaxed(0, rtc->ioaddr + LPC_WDT_OFF);
  55. spin_unlock_irqrestore(&rtc->lock, flags);
  56. }
  57. static irqreturn_t st_rtc_handler(int this_irq, void *data)
  58. {
  59. struct st_rtc *rtc = (struct st_rtc *)data;
  60. rtc_update_irq(rtc->rtc_dev, 1, RTC_AF);
  61. return IRQ_HANDLED;
  62. }
  63. static int st_rtc_read_time(struct device *dev, struct rtc_time *tm)
  64. {
  65. struct st_rtc *rtc = dev_get_drvdata(dev);
  66. unsigned long lpt_lsb, lpt_msb;
  67. unsigned long long lpt;
  68. unsigned long flags;
  69. spin_lock_irqsave(&rtc->lock, flags);
  70. do {
  71. lpt_msb = readl_relaxed(rtc->ioaddr + LPC_LPT_MSB_OFF);
  72. lpt_lsb = readl_relaxed(rtc->ioaddr + LPC_LPT_LSB_OFF);
  73. } while (readl_relaxed(rtc->ioaddr + LPC_LPT_MSB_OFF) != lpt_msb);
  74. spin_unlock_irqrestore(&rtc->lock, flags);
  75. lpt = ((unsigned long long)lpt_msb << 32) | lpt_lsb;
  76. do_div(lpt, rtc->clkrate);
  77. rtc_time64_to_tm(lpt, tm);
  78. return 0;
  79. }
  80. static int st_rtc_set_time(struct device *dev, struct rtc_time *tm)
  81. {
  82. struct st_rtc *rtc = dev_get_drvdata(dev);
  83. unsigned long long lpt, secs;
  84. unsigned long flags;
  85. secs = rtc_tm_to_time64(tm);
  86. lpt = (unsigned long long)secs * rtc->clkrate;
  87. spin_lock_irqsave(&rtc->lock, flags);
  88. writel_relaxed(lpt >> 32, rtc->ioaddr + LPC_LPT_MSB_OFF);
  89. writel_relaxed(lpt, rtc->ioaddr + LPC_LPT_LSB_OFF);
  90. writel_relaxed(1, rtc->ioaddr + LPC_LPT_START_OFF);
  91. spin_unlock_irqrestore(&rtc->lock, flags);
  92. return 0;
  93. }
  94. static int st_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *wkalrm)
  95. {
  96. struct st_rtc *rtc = dev_get_drvdata(dev);
  97. unsigned long flags;
  98. spin_lock_irqsave(&rtc->lock, flags);
  99. memcpy(wkalrm, &rtc->alarm, sizeof(struct rtc_wkalrm));
  100. spin_unlock_irqrestore(&rtc->lock, flags);
  101. return 0;
  102. }
  103. static int st_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
  104. {
  105. struct st_rtc *rtc = dev_get_drvdata(dev);
  106. if (enabled && !rtc->irq_enabled) {
  107. enable_irq(rtc->irq);
  108. rtc->irq_enabled = true;
  109. } else if (!enabled && rtc->irq_enabled) {
  110. disable_irq(rtc->irq);
  111. rtc->irq_enabled = false;
  112. }
  113. return 0;
  114. }
  115. static int st_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *t)
  116. {
  117. struct st_rtc *rtc = dev_get_drvdata(dev);
  118. struct rtc_time now;
  119. unsigned long long now_secs;
  120. unsigned long long alarm_secs;
  121. unsigned long long lpa;
  122. st_rtc_read_time(dev, &now);
  123. now_secs = rtc_tm_to_time64(&now);
  124. alarm_secs = rtc_tm_to_time64(&t->time);
  125. memcpy(&rtc->alarm, t, sizeof(struct rtc_wkalrm));
  126. /* Now many secs to fire */
  127. alarm_secs -= now_secs;
  128. lpa = (unsigned long long)alarm_secs * rtc->clkrate;
  129. st_rtc_set_hw_alarm(rtc, lpa >> 32, lpa);
  130. st_rtc_alarm_irq_enable(dev, t->enabled);
  131. return 0;
  132. }
  133. static const struct rtc_class_ops st_rtc_ops = {
  134. .read_time = st_rtc_read_time,
  135. .set_time = st_rtc_set_time,
  136. .read_alarm = st_rtc_read_alarm,
  137. .set_alarm = st_rtc_set_alarm,
  138. .alarm_irq_enable = st_rtc_alarm_irq_enable,
  139. };
  140. static int st_rtc_probe(struct platform_device *pdev)
  141. {
  142. struct device_node *np = pdev->dev.of_node;
  143. struct st_rtc *rtc;
  144. uint32_t mode;
  145. int ret = 0;
  146. ret = of_property_read_u32(np, "st,lpc-mode", &mode);
  147. if (ret) {
  148. dev_err(&pdev->dev, "An LPC mode must be provided\n");
  149. return -EINVAL;
  150. }
  151. /* LPC can either run as a Clocksource or in RTC or WDT mode */
  152. if (mode != ST_LPC_MODE_RTC)
  153. return -ENODEV;
  154. rtc = devm_kzalloc(&pdev->dev, sizeof(struct st_rtc), GFP_KERNEL);
  155. if (!rtc)
  156. return -ENOMEM;
  157. rtc->rtc_dev = devm_rtc_allocate_device(&pdev->dev);
  158. if (IS_ERR(rtc->rtc_dev))
  159. return PTR_ERR(rtc->rtc_dev);
  160. spin_lock_init(&rtc->lock);
  161. rtc->ioaddr = devm_platform_ioremap_resource(pdev, 0);
  162. if (IS_ERR(rtc->ioaddr))
  163. return PTR_ERR(rtc->ioaddr);
  164. rtc->irq = irq_of_parse_and_map(np, 0);
  165. if (!rtc->irq) {
  166. dev_err(&pdev->dev, "IRQ missing or invalid\n");
  167. return -EINVAL;
  168. }
  169. ret = devm_request_irq(&pdev->dev, rtc->irq, st_rtc_handler, 0,
  170. pdev->name, rtc);
  171. if (ret) {
  172. dev_err(&pdev->dev, "Failed to request irq %i\n", rtc->irq);
  173. return ret;
  174. }
  175. enable_irq_wake(rtc->irq);
  176. disable_irq(rtc->irq);
  177. rtc->clk = clk_get(&pdev->dev, NULL);
  178. if (IS_ERR(rtc->clk)) {
  179. dev_err(&pdev->dev, "Unable to request clock\n");
  180. return PTR_ERR(rtc->clk);
  181. }
  182. clk_prepare_enable(rtc->clk);
  183. rtc->clkrate = clk_get_rate(rtc->clk);
  184. if (!rtc->clkrate) {
  185. dev_err(&pdev->dev, "Unable to fetch clock rate\n");
  186. return -EINVAL;
  187. }
  188. device_set_wakeup_capable(&pdev->dev, 1);
  189. platform_set_drvdata(pdev, rtc);
  190. rtc->rtc_dev->ops = &st_rtc_ops;
  191. rtc->rtc_dev->range_max = U64_MAX;
  192. do_div(rtc->rtc_dev->range_max, rtc->clkrate);
  193. ret = rtc_register_device(rtc->rtc_dev);
  194. if (ret) {
  195. clk_disable_unprepare(rtc->clk);
  196. return ret;
  197. }
  198. return 0;
  199. }
  200. #ifdef CONFIG_PM_SLEEP
  201. static int st_rtc_suspend(struct device *dev)
  202. {
  203. struct st_rtc *rtc = dev_get_drvdata(dev);
  204. if (device_may_wakeup(dev))
  205. return 0;
  206. writel_relaxed(1, rtc->ioaddr + LPC_WDT_OFF);
  207. writel_relaxed(0, rtc->ioaddr + LPC_LPA_START_OFF);
  208. writel_relaxed(0, rtc->ioaddr + LPC_WDT_OFF);
  209. return 0;
  210. }
  211. static int st_rtc_resume(struct device *dev)
  212. {
  213. struct st_rtc *rtc = dev_get_drvdata(dev);
  214. rtc_alarm_irq_enable(rtc->rtc_dev, 0);
  215. /*
  216. * clean 'rtc->alarm' to allow a new
  217. * .set_alarm to the upper RTC layer
  218. */
  219. memset(&rtc->alarm, 0, sizeof(struct rtc_wkalrm));
  220. writel_relaxed(0, rtc->ioaddr + LPC_LPA_MSB_OFF);
  221. writel_relaxed(0, rtc->ioaddr + LPC_LPA_LSB_OFF);
  222. writel_relaxed(1, rtc->ioaddr + LPC_WDT_OFF);
  223. writel_relaxed(1, rtc->ioaddr + LPC_LPA_START_OFF);
  224. writel_relaxed(0, rtc->ioaddr + LPC_WDT_OFF);
  225. return 0;
  226. }
  227. #endif
  228. static SIMPLE_DEV_PM_OPS(st_rtc_pm_ops, st_rtc_suspend, st_rtc_resume);
  229. static const struct of_device_id st_rtc_match[] = {
  230. { .compatible = "st,stih407-lpc" },
  231. {}
  232. };
  233. MODULE_DEVICE_TABLE(of, st_rtc_match);
  234. static struct platform_driver st_rtc_platform_driver = {
  235. .driver = {
  236. .name = "st-lpc-rtc",
  237. .pm = &st_rtc_pm_ops,
  238. .of_match_table = st_rtc_match,
  239. },
  240. .probe = st_rtc_probe,
  241. };
  242. module_platform_driver(st_rtc_platform_driver);
  243. MODULE_DESCRIPTION("STMicroelectronics LPC RTC driver");
  244. MODULE_AUTHOR("David Paris <david.paris@st.com>");
  245. MODULE_LICENSE("GPL");