rtc-digicolor.c 5.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Real Time Clock driver for Conexant Digicolor
  4. *
  5. * Copyright (C) 2015 Paradox Innovation Ltd.
  6. *
  7. * Author: Baruch Siach <baruch@tkos.co.il>
  8. */
  9. #include <linux/io.h>
  10. #include <linux/iopoll.h>
  11. #include <linux/delay.h>
  12. #include <linux/module.h>
  13. #include <linux/platform_device.h>
  14. #include <linux/rtc.h>
  15. #include <linux/of.h>
  16. #define DC_RTC_CONTROL 0x0
  17. #define DC_RTC_TIME 0x8
  18. #define DC_RTC_REFERENCE 0xc
  19. #define DC_RTC_ALARM 0x10
  20. #define DC_RTC_INTFLAG_CLEAR 0x14
  21. #define DC_RTC_INTENABLE 0x16
  22. #define DC_RTC_CMD_MASK 0xf
  23. #define DC_RTC_GO_BUSY BIT(7)
  24. #define CMD_NOP 0
  25. #define CMD_RESET 1
  26. #define CMD_WRITE 3
  27. #define CMD_READ 4
  28. #define CMD_DELAY_US (10*1000)
  29. #define CMD_TIMEOUT_US (500*CMD_DELAY_US)
  30. struct dc_rtc {
  31. struct rtc_device *rtc_dev;
  32. void __iomem *regs;
  33. };
  34. static int dc_rtc_cmds(struct dc_rtc *rtc, const u8 *cmds, int len)
  35. {
  36. u8 val;
  37. int i, ret;
  38. for (i = 0; i < len; i++) {
  39. writeb_relaxed((cmds[i] & DC_RTC_CMD_MASK) | DC_RTC_GO_BUSY,
  40. rtc->regs + DC_RTC_CONTROL);
  41. ret = readb_relaxed_poll_timeout(
  42. rtc->regs + DC_RTC_CONTROL, val,
  43. !(val & DC_RTC_GO_BUSY), CMD_DELAY_US, CMD_TIMEOUT_US);
  44. if (ret < 0)
  45. return ret;
  46. }
  47. return 0;
  48. }
  49. static int dc_rtc_read(struct dc_rtc *rtc, unsigned long *val)
  50. {
  51. static const u8 read_cmds[] = {CMD_READ, CMD_NOP};
  52. u32 reference, time1, time2;
  53. int ret;
  54. ret = dc_rtc_cmds(rtc, read_cmds, ARRAY_SIZE(read_cmds));
  55. if (ret < 0)
  56. return ret;
  57. reference = readl_relaxed(rtc->regs + DC_RTC_REFERENCE);
  58. time1 = readl_relaxed(rtc->regs + DC_RTC_TIME);
  59. /* Read twice to ensure consistency */
  60. while (1) {
  61. time2 = readl_relaxed(rtc->regs + DC_RTC_TIME);
  62. if (time1 == time2)
  63. break;
  64. time1 = time2;
  65. }
  66. *val = reference + time1;
  67. return 0;
  68. }
  69. static int dc_rtc_write(struct dc_rtc *rtc, u32 val)
  70. {
  71. static const u8 write_cmds[] = {CMD_WRITE, CMD_NOP, CMD_RESET, CMD_NOP};
  72. writel_relaxed(val, rtc->regs + DC_RTC_REFERENCE);
  73. return dc_rtc_cmds(rtc, write_cmds, ARRAY_SIZE(write_cmds));
  74. }
  75. static int dc_rtc_read_time(struct device *dev, struct rtc_time *tm)
  76. {
  77. struct dc_rtc *rtc = dev_get_drvdata(dev);
  78. unsigned long now;
  79. int ret;
  80. ret = dc_rtc_read(rtc, &now);
  81. if (ret < 0)
  82. return ret;
  83. rtc_time64_to_tm(now, tm);
  84. return 0;
  85. }
  86. static int dc_rtc_set_time(struct device *dev, struct rtc_time *tm)
  87. {
  88. struct dc_rtc *rtc = dev_get_drvdata(dev);
  89. return dc_rtc_write(rtc, rtc_tm_to_time64(tm));
  90. }
  91. static int dc_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
  92. {
  93. struct dc_rtc *rtc = dev_get_drvdata(dev);
  94. u32 alarm_reg, reference;
  95. unsigned long now;
  96. int ret;
  97. alarm_reg = readl_relaxed(rtc->regs + DC_RTC_ALARM);
  98. reference = readl_relaxed(rtc->regs + DC_RTC_REFERENCE);
  99. rtc_time64_to_tm(reference + alarm_reg, &alarm->time);
  100. ret = dc_rtc_read(rtc, &now);
  101. if (ret < 0)
  102. return ret;
  103. alarm->pending = alarm_reg + reference > now;
  104. alarm->enabled = readl_relaxed(rtc->regs + DC_RTC_INTENABLE);
  105. return 0;
  106. }
  107. static int dc_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
  108. {
  109. struct dc_rtc *rtc = dev_get_drvdata(dev);
  110. time64_t alarm_time;
  111. u32 reference;
  112. alarm_time = rtc_tm_to_time64(&alarm->time);
  113. reference = readl_relaxed(rtc->regs + DC_RTC_REFERENCE);
  114. writel_relaxed(alarm_time - reference, rtc->regs + DC_RTC_ALARM);
  115. writeb_relaxed(!!alarm->enabled, rtc->regs + DC_RTC_INTENABLE);
  116. return 0;
  117. }
  118. static int dc_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
  119. {
  120. struct dc_rtc *rtc = dev_get_drvdata(dev);
  121. writeb_relaxed(!!enabled, rtc->regs + DC_RTC_INTENABLE);
  122. return 0;
  123. }
  124. static const struct rtc_class_ops dc_rtc_ops = {
  125. .read_time = dc_rtc_read_time,
  126. .set_time = dc_rtc_set_time,
  127. .read_alarm = dc_rtc_read_alarm,
  128. .set_alarm = dc_rtc_set_alarm,
  129. .alarm_irq_enable = dc_rtc_alarm_irq_enable,
  130. };
  131. static irqreturn_t dc_rtc_irq(int irq, void *dev_id)
  132. {
  133. struct dc_rtc *rtc = dev_id;
  134. writeb_relaxed(1, rtc->regs + DC_RTC_INTFLAG_CLEAR);
  135. rtc_update_irq(rtc->rtc_dev, 1, RTC_AF | RTC_IRQF);
  136. return IRQ_HANDLED;
  137. }
  138. static int __init dc_rtc_probe(struct platform_device *pdev)
  139. {
  140. struct dc_rtc *rtc;
  141. int irq, ret;
  142. rtc = devm_kzalloc(&pdev->dev, sizeof(*rtc), GFP_KERNEL);
  143. if (!rtc)
  144. return -ENOMEM;
  145. rtc->regs = devm_platform_ioremap_resource(pdev, 0);
  146. if (IS_ERR(rtc->regs))
  147. return PTR_ERR(rtc->regs);
  148. rtc->rtc_dev = devm_rtc_allocate_device(&pdev->dev);
  149. if (IS_ERR(rtc->rtc_dev))
  150. return PTR_ERR(rtc->rtc_dev);
  151. irq = platform_get_irq(pdev, 0);
  152. if (irq < 0)
  153. return irq;
  154. ret = devm_request_irq(&pdev->dev, irq, dc_rtc_irq, 0, pdev->name, rtc);
  155. if (ret < 0)
  156. return ret;
  157. platform_set_drvdata(pdev, rtc);
  158. rtc->rtc_dev->ops = &dc_rtc_ops;
  159. rtc->rtc_dev->range_max = U32_MAX;
  160. return rtc_register_device(rtc->rtc_dev);
  161. }
  162. static const struct of_device_id dc_dt_ids[] = {
  163. { .compatible = "cnxt,cx92755-rtc" },
  164. { /* sentinel */ }
  165. };
  166. MODULE_DEVICE_TABLE(of, dc_dt_ids);
  167. static struct platform_driver dc_rtc_driver = {
  168. .driver = {
  169. .name = "digicolor_rtc",
  170. .of_match_table = of_match_ptr(dc_dt_ids),
  171. },
  172. };
  173. module_platform_driver_probe(dc_rtc_driver, dc_rtc_probe);
  174. MODULE_AUTHOR("Baruch Siach <baruch@tkos.co.il>");
  175. MODULE_DESCRIPTION("Conexant Digicolor Realtime Clock Driver (RTC)");
  176. MODULE_LICENSE("GPL");