rtc-cadence.c 10 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * Copyright 2019 Cadence
  4. *
  5. * Authors:
  6. * Jan Kotas <jank@cadence.com>
  7. */
  8. #include <linux/module.h>
  9. #include <linux/platform_device.h>
  10. #include <linux/of.h>
  11. #include <linux/io.h>
  12. #include <linux/rtc.h>
  13. #include <linux/clk.h>
  14. #include <linux/bcd.h>
  15. #include <linux/bitfield.h>
  16. #include <linux/interrupt.h>
  17. #include <linux/pm_wakeirq.h>
  18. /* Registers */
  19. #define CDNS_RTC_CTLR 0x00
  20. #define CDNS_RTC_HMR 0x04
  21. #define CDNS_RTC_TIMR 0x08
  22. #define CDNS_RTC_CALR 0x0C
  23. #define CDNS_RTC_TIMAR 0x10
  24. #define CDNS_RTC_CALAR 0x14
  25. #define CDNS_RTC_AENR 0x18
  26. #define CDNS_RTC_EFLR 0x1C
  27. #define CDNS_RTC_IENR 0x20
  28. #define CDNS_RTC_IDISR 0x24
  29. #define CDNS_RTC_IMSKR 0x28
  30. #define CDNS_RTC_STSR 0x2C
  31. #define CDNS_RTC_KRTCR 0x30
  32. /* Control */
  33. #define CDNS_RTC_CTLR_TIME BIT(0)
  34. #define CDNS_RTC_CTLR_CAL BIT(1)
  35. #define CDNS_RTC_CTLR_TIME_CAL (CDNS_RTC_CTLR_TIME | CDNS_RTC_CTLR_CAL)
  36. /* Status */
  37. #define CDNS_RTC_STSR_VT BIT(0)
  38. #define CDNS_RTC_STSR_VC BIT(1)
  39. #define CDNS_RTC_STSR_VTA BIT(2)
  40. #define CDNS_RTC_STSR_VCA BIT(3)
  41. #define CDNS_RTC_STSR_VT_VC (CDNS_RTC_STSR_VT | CDNS_RTC_STSR_VC)
  42. #define CDNS_RTC_STSR_VTA_VCA (CDNS_RTC_STSR_VTA | CDNS_RTC_STSR_VCA)
  43. /* Keep RTC */
  44. #define CDNS_RTC_KRTCR_KRTC BIT(0)
  45. /* Alarm, Event, Interrupt */
  46. #define CDNS_RTC_AEI_HOS BIT(0)
  47. #define CDNS_RTC_AEI_SEC BIT(1)
  48. #define CDNS_RTC_AEI_MIN BIT(2)
  49. #define CDNS_RTC_AEI_HOUR BIT(3)
  50. #define CDNS_RTC_AEI_DATE BIT(4)
  51. #define CDNS_RTC_AEI_MNTH BIT(5)
  52. #define CDNS_RTC_AEI_ALRM BIT(6)
  53. /* Time */
  54. #define CDNS_RTC_TIME_H GENMASK(7, 0)
  55. #define CDNS_RTC_TIME_S GENMASK(14, 8)
  56. #define CDNS_RTC_TIME_M GENMASK(22, 16)
  57. #define CDNS_RTC_TIME_HR GENMASK(29, 24)
  58. #define CDNS_RTC_TIME_PM BIT(30)
  59. #define CDNS_RTC_TIME_CH BIT(31)
  60. /* Calendar */
  61. #define CDNS_RTC_CAL_DAY GENMASK(2, 0)
  62. #define CDNS_RTC_CAL_M GENMASK(7, 3)
  63. #define CDNS_RTC_CAL_D GENMASK(13, 8)
  64. #define CDNS_RTC_CAL_Y GENMASK(23, 16)
  65. #define CDNS_RTC_CAL_C GENMASK(29, 24)
  66. #define CDNS_RTC_CAL_CH BIT(31)
  67. #define CDNS_RTC_MAX_REGS_TRIES 3
  68. struct cdns_rtc {
  69. struct rtc_device *rtc_dev;
  70. struct clk *pclk;
  71. struct clk *ref_clk;
  72. void __iomem *regs;
  73. int irq;
  74. };
  75. static void cdns_rtc_set_enabled(struct cdns_rtc *crtc, bool enabled)
  76. {
  77. u32 reg = enabled ? 0x0 : CDNS_RTC_CTLR_TIME_CAL;
  78. writel(reg, crtc->regs + CDNS_RTC_CTLR);
  79. }
  80. static bool cdns_rtc_get_enabled(struct cdns_rtc *crtc)
  81. {
  82. return !(readl(crtc->regs + CDNS_RTC_CTLR) & CDNS_RTC_CTLR_TIME_CAL);
  83. }
  84. static irqreturn_t cdns_rtc_irq_handler(int irq, void *id)
  85. {
  86. struct device *dev = id;
  87. struct cdns_rtc *crtc = dev_get_drvdata(dev);
  88. /* Reading the register clears it */
  89. if (!(readl(crtc->regs + CDNS_RTC_EFLR) & CDNS_RTC_AEI_ALRM))
  90. return IRQ_NONE;
  91. rtc_update_irq(crtc->rtc_dev, 1, RTC_IRQF | RTC_AF);
  92. return IRQ_HANDLED;
  93. }
  94. static u32 cdns_rtc_time2reg(struct rtc_time *tm)
  95. {
  96. return FIELD_PREP(CDNS_RTC_TIME_S, bin2bcd(tm->tm_sec))
  97. | FIELD_PREP(CDNS_RTC_TIME_M, bin2bcd(tm->tm_min))
  98. | FIELD_PREP(CDNS_RTC_TIME_HR, bin2bcd(tm->tm_hour));
  99. }
  100. static void cdns_rtc_reg2time(u32 reg, struct rtc_time *tm)
  101. {
  102. tm->tm_sec = bcd2bin(FIELD_GET(CDNS_RTC_TIME_S, reg));
  103. tm->tm_min = bcd2bin(FIELD_GET(CDNS_RTC_TIME_M, reg));
  104. tm->tm_hour = bcd2bin(FIELD_GET(CDNS_RTC_TIME_HR, reg));
  105. }
  106. static int cdns_rtc_read_time(struct device *dev, struct rtc_time *tm)
  107. {
  108. struct cdns_rtc *crtc = dev_get_drvdata(dev);
  109. u32 reg;
  110. /* If the RTC is disabled, assume the values are invalid */
  111. if (!cdns_rtc_get_enabled(crtc))
  112. return -EINVAL;
  113. cdns_rtc_set_enabled(crtc, false);
  114. reg = readl(crtc->regs + CDNS_RTC_TIMR);
  115. cdns_rtc_reg2time(reg, tm);
  116. reg = readl(crtc->regs + CDNS_RTC_CALR);
  117. tm->tm_mday = bcd2bin(FIELD_GET(CDNS_RTC_CAL_D, reg));
  118. tm->tm_mon = bcd2bin(FIELD_GET(CDNS_RTC_CAL_M, reg)) - 1;
  119. tm->tm_year = bcd2bin(FIELD_GET(CDNS_RTC_CAL_Y, reg))
  120. + bcd2bin(FIELD_GET(CDNS_RTC_CAL_C, reg)) * 100 - 1900;
  121. tm->tm_wday = bcd2bin(FIELD_GET(CDNS_RTC_CAL_DAY, reg)) - 1;
  122. cdns_rtc_set_enabled(crtc, true);
  123. return 0;
  124. }
  125. static int cdns_rtc_set_time(struct device *dev, struct rtc_time *tm)
  126. {
  127. struct cdns_rtc *crtc = dev_get_drvdata(dev);
  128. u32 timr, calr, stsr;
  129. int ret = -EIO;
  130. int year = tm->tm_year + 1900;
  131. int tries;
  132. cdns_rtc_set_enabled(crtc, false);
  133. timr = cdns_rtc_time2reg(tm);
  134. calr = FIELD_PREP(CDNS_RTC_CAL_D, bin2bcd(tm->tm_mday))
  135. | FIELD_PREP(CDNS_RTC_CAL_M, bin2bcd(tm->tm_mon + 1))
  136. | FIELD_PREP(CDNS_RTC_CAL_Y, bin2bcd(year % 100))
  137. | FIELD_PREP(CDNS_RTC_CAL_C, bin2bcd(year / 100))
  138. | FIELD_PREP(CDNS_RTC_CAL_DAY, tm->tm_wday + 1);
  139. /* Update registers, check valid flags */
  140. for (tries = 0; tries < CDNS_RTC_MAX_REGS_TRIES; tries++) {
  141. writel(timr, crtc->regs + CDNS_RTC_TIMR);
  142. writel(calr, crtc->regs + CDNS_RTC_CALR);
  143. stsr = readl(crtc->regs + CDNS_RTC_STSR);
  144. if ((stsr & CDNS_RTC_STSR_VT_VC) == CDNS_RTC_STSR_VT_VC) {
  145. ret = 0;
  146. break;
  147. }
  148. }
  149. cdns_rtc_set_enabled(crtc, true);
  150. return ret;
  151. }
  152. static int cdns_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
  153. {
  154. struct cdns_rtc *crtc = dev_get_drvdata(dev);
  155. if (enabled) {
  156. writel((CDNS_RTC_AEI_SEC | CDNS_RTC_AEI_MIN | CDNS_RTC_AEI_HOUR
  157. | CDNS_RTC_AEI_DATE | CDNS_RTC_AEI_MNTH),
  158. crtc->regs + CDNS_RTC_AENR);
  159. writel(CDNS_RTC_AEI_ALRM, crtc->regs + CDNS_RTC_IENR);
  160. } else {
  161. writel(0, crtc->regs + CDNS_RTC_AENR);
  162. writel(CDNS_RTC_AEI_ALRM, crtc->regs + CDNS_RTC_IDISR);
  163. }
  164. return 0;
  165. }
  166. static int cdns_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
  167. {
  168. struct cdns_rtc *crtc = dev_get_drvdata(dev);
  169. u32 reg;
  170. reg = readl(crtc->regs + CDNS_RTC_TIMAR);
  171. cdns_rtc_reg2time(reg, &alarm->time);
  172. reg = readl(crtc->regs + CDNS_RTC_CALAR);
  173. alarm->time.tm_mday = bcd2bin(FIELD_GET(CDNS_RTC_CAL_D, reg));
  174. alarm->time.tm_mon = bcd2bin(FIELD_GET(CDNS_RTC_CAL_M, reg)) - 1;
  175. return 0;
  176. }
  177. static int cdns_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
  178. {
  179. struct cdns_rtc *crtc = dev_get_drvdata(dev);
  180. int ret = -EIO;
  181. int tries;
  182. u32 timar, calar, stsr;
  183. cdns_rtc_alarm_irq_enable(dev, 0);
  184. timar = cdns_rtc_time2reg(&alarm->time);
  185. calar = FIELD_PREP(CDNS_RTC_CAL_D, bin2bcd(alarm->time.tm_mday))
  186. | FIELD_PREP(CDNS_RTC_CAL_M, bin2bcd(alarm->time.tm_mon + 1));
  187. /* Update registers, check valid alarm flags */
  188. for (tries = 0; tries < CDNS_RTC_MAX_REGS_TRIES; tries++) {
  189. writel(timar, crtc->regs + CDNS_RTC_TIMAR);
  190. writel(calar, crtc->regs + CDNS_RTC_CALAR);
  191. stsr = readl(crtc->regs + CDNS_RTC_STSR);
  192. if ((stsr & CDNS_RTC_STSR_VTA_VCA) == CDNS_RTC_STSR_VTA_VCA) {
  193. ret = 0;
  194. break;
  195. }
  196. }
  197. if (!ret)
  198. cdns_rtc_alarm_irq_enable(dev, alarm->enabled);
  199. return ret;
  200. }
  201. static const struct rtc_class_ops cdns_rtc_ops = {
  202. .read_time = cdns_rtc_read_time,
  203. .set_time = cdns_rtc_set_time,
  204. .read_alarm = cdns_rtc_read_alarm,
  205. .set_alarm = cdns_rtc_set_alarm,
  206. .alarm_irq_enable = cdns_rtc_alarm_irq_enable,
  207. };
  208. static int cdns_rtc_probe(struct platform_device *pdev)
  209. {
  210. struct cdns_rtc *crtc;
  211. int ret;
  212. unsigned long ref_clk_freq;
  213. crtc = devm_kzalloc(&pdev->dev, sizeof(*crtc), GFP_KERNEL);
  214. if (!crtc)
  215. return -ENOMEM;
  216. crtc->regs = devm_platform_ioremap_resource(pdev, 0);
  217. if (IS_ERR(crtc->regs))
  218. return PTR_ERR(crtc->regs);
  219. crtc->irq = platform_get_irq(pdev, 0);
  220. if (crtc->irq < 0)
  221. return -EINVAL;
  222. crtc->pclk = devm_clk_get(&pdev->dev, "pclk");
  223. if (IS_ERR(crtc->pclk)) {
  224. ret = PTR_ERR(crtc->pclk);
  225. dev_err(&pdev->dev,
  226. "Failed to retrieve the peripheral clock, %d\n", ret);
  227. return ret;
  228. }
  229. crtc->ref_clk = devm_clk_get(&pdev->dev, "ref_clk");
  230. if (IS_ERR(crtc->ref_clk)) {
  231. ret = PTR_ERR(crtc->ref_clk);
  232. dev_err(&pdev->dev,
  233. "Failed to retrieve the reference clock, %d\n", ret);
  234. return ret;
  235. }
  236. crtc->rtc_dev = devm_rtc_allocate_device(&pdev->dev);
  237. if (IS_ERR(crtc->rtc_dev))
  238. return PTR_ERR(crtc->rtc_dev);
  239. platform_set_drvdata(pdev, crtc);
  240. ret = clk_prepare_enable(crtc->pclk);
  241. if (ret) {
  242. dev_err(&pdev->dev,
  243. "Failed to enable the peripheral clock, %d\n", ret);
  244. return ret;
  245. }
  246. ret = clk_prepare_enable(crtc->ref_clk);
  247. if (ret) {
  248. dev_err(&pdev->dev,
  249. "Failed to enable the reference clock, %d\n", ret);
  250. goto err_disable_pclk;
  251. }
  252. ref_clk_freq = clk_get_rate(crtc->ref_clk);
  253. if ((ref_clk_freq != 1) && (ref_clk_freq != 100)) {
  254. dev_err(&pdev->dev,
  255. "Invalid reference clock frequency %lu Hz.\n",
  256. ref_clk_freq);
  257. ret = -EINVAL;
  258. goto err_disable_ref_clk;
  259. }
  260. ret = devm_request_irq(&pdev->dev, crtc->irq,
  261. cdns_rtc_irq_handler, 0,
  262. dev_name(&pdev->dev), &pdev->dev);
  263. if (ret) {
  264. dev_err(&pdev->dev,
  265. "Failed to request interrupt for the device, %d\n",
  266. ret);
  267. goto err_disable_ref_clk;
  268. }
  269. /* The RTC supports 01.01.1900 - 31.12.2999 */
  270. crtc->rtc_dev->range_min = mktime64(1900, 1, 1, 0, 0, 0);
  271. crtc->rtc_dev->range_max = mktime64(2999, 12, 31, 23, 59, 59);
  272. crtc->rtc_dev->ops = &cdns_rtc_ops;
  273. device_init_wakeup(&pdev->dev, true);
  274. /* Always use 24-hour mode and keep the RTC values */
  275. writel(0, crtc->regs + CDNS_RTC_HMR);
  276. writel(CDNS_RTC_KRTCR_KRTC, crtc->regs + CDNS_RTC_KRTCR);
  277. ret = rtc_register_device(crtc->rtc_dev);
  278. if (ret)
  279. goto err_disable_wakeup;
  280. return 0;
  281. err_disable_wakeup:
  282. device_init_wakeup(&pdev->dev, false);
  283. err_disable_ref_clk:
  284. clk_disable_unprepare(crtc->ref_clk);
  285. err_disable_pclk:
  286. clk_disable_unprepare(crtc->pclk);
  287. return ret;
  288. }
  289. static int cdns_rtc_remove(struct platform_device *pdev)
  290. {
  291. struct cdns_rtc *crtc = platform_get_drvdata(pdev);
  292. cdns_rtc_alarm_irq_enable(&pdev->dev, 0);
  293. device_init_wakeup(&pdev->dev, 0);
  294. clk_disable_unprepare(crtc->pclk);
  295. clk_disable_unprepare(crtc->ref_clk);
  296. return 0;
  297. }
  298. #ifdef CONFIG_PM_SLEEP
  299. static int cdns_rtc_suspend(struct device *dev)
  300. {
  301. struct cdns_rtc *crtc = dev_get_drvdata(dev);
  302. if (device_may_wakeup(dev))
  303. enable_irq_wake(crtc->irq);
  304. return 0;
  305. }
  306. static int cdns_rtc_resume(struct device *dev)
  307. {
  308. struct cdns_rtc *crtc = dev_get_drvdata(dev);
  309. if (device_may_wakeup(dev))
  310. disable_irq_wake(crtc->irq);
  311. return 0;
  312. }
  313. #endif
  314. static SIMPLE_DEV_PM_OPS(cdns_rtc_pm_ops, cdns_rtc_suspend, cdns_rtc_resume);
  315. static const struct of_device_id cdns_rtc_of_match[] = {
  316. { .compatible = "cdns,rtc-r109v3" },
  317. { },
  318. };
  319. MODULE_DEVICE_TABLE(of, cdns_rtc_of_match);
  320. static struct platform_driver cdns_rtc_driver = {
  321. .driver = {
  322. .name = "cdns-rtc",
  323. .of_match_table = cdns_rtc_of_match,
  324. .pm = &cdns_rtc_pm_ops,
  325. },
  326. .probe = cdns_rtc_probe,
  327. .remove = cdns_rtc_remove,
  328. };
  329. module_platform_driver(cdns_rtc_driver);
  330. MODULE_AUTHOR("Jan Kotas <jank@cadence.com>");
  331. MODULE_DESCRIPTION("Cadence RTC driver");
  332. MODULE_LICENSE("GPL v2");
  333. MODULE_ALIAS("platform:cdns-rtc");