rtc-vt8500.c 7.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * drivers/rtc/rtc-vt8500.c
  4. *
  5. * Copyright (C) 2010 Alexey Charkov <alchark@gmail.com>
  6. *
  7. * Based on rtc-pxa.c
  8. */
  9. #include <linux/module.h>
  10. #include <linux/rtc.h>
  11. #include <linux/init.h>
  12. #include <linux/interrupt.h>
  13. #include <linux/io.h>
  14. #include <linux/bcd.h>
  15. #include <linux/platform_device.h>
  16. #include <linux/slab.h>
  17. #include <linux/of.h>
  18. /*
  19. * Register definitions
  20. */
  21. #define VT8500_RTC_TS 0x00 /* Time set */
  22. #define VT8500_RTC_DS 0x04 /* Date set */
  23. #define VT8500_RTC_AS 0x08 /* Alarm set */
  24. #define VT8500_RTC_CR 0x0c /* Control */
  25. #define VT8500_RTC_TR 0x10 /* Time read */
  26. #define VT8500_RTC_DR 0x14 /* Date read */
  27. #define VT8500_RTC_WS 0x18 /* Write status */
  28. #define VT8500_RTC_CL 0x20 /* Calibration */
  29. #define VT8500_RTC_IS 0x24 /* Interrupt status */
  30. #define VT8500_RTC_ST 0x28 /* Status */
  31. #define INVALID_TIME_BIT (1 << 31)
  32. #define DATE_CENTURY_S 19
  33. #define DATE_YEAR_S 11
  34. #define DATE_YEAR_MASK (0xff << DATE_YEAR_S)
  35. #define DATE_MONTH_S 6
  36. #define DATE_MONTH_MASK (0x1f << DATE_MONTH_S)
  37. #define DATE_DAY_MASK 0x3f
  38. #define TIME_DOW_S 20
  39. #define TIME_DOW_MASK (0x07 << TIME_DOW_S)
  40. #define TIME_HOUR_S 14
  41. #define TIME_HOUR_MASK (0x3f << TIME_HOUR_S)
  42. #define TIME_MIN_S 7
  43. #define TIME_MIN_MASK (0x7f << TIME_MIN_S)
  44. #define TIME_SEC_MASK 0x7f
  45. #define ALARM_DAY_S 20
  46. #define ALARM_DAY_MASK (0x3f << ALARM_DAY_S)
  47. #define ALARM_DAY_BIT (1 << 29)
  48. #define ALARM_HOUR_BIT (1 << 28)
  49. #define ALARM_MIN_BIT (1 << 27)
  50. #define ALARM_SEC_BIT (1 << 26)
  51. #define ALARM_ENABLE_MASK (ALARM_DAY_BIT \
  52. | ALARM_HOUR_BIT \
  53. | ALARM_MIN_BIT \
  54. | ALARM_SEC_BIT)
  55. #define VT8500_RTC_CR_ENABLE (1 << 0) /* Enable RTC */
  56. #define VT8500_RTC_CR_12H (1 << 1) /* 12h time format */
  57. #define VT8500_RTC_CR_SM_ENABLE (1 << 2) /* Enable periodic irqs */
  58. #define VT8500_RTC_CR_SM_SEC (1 << 3) /* 0: 1Hz/60, 1: 1Hz */
  59. #define VT8500_RTC_CR_CALIB (1 << 4) /* Enable calibration */
  60. #define VT8500_RTC_IS_ALARM (1 << 0) /* Alarm interrupt status */
  61. struct vt8500_rtc {
  62. void __iomem *regbase;
  63. int irq_alarm;
  64. struct rtc_device *rtc;
  65. spinlock_t lock; /* Protects this structure */
  66. };
  67. static irqreturn_t vt8500_rtc_irq(int irq, void *dev_id)
  68. {
  69. struct vt8500_rtc *vt8500_rtc = dev_id;
  70. u32 isr;
  71. unsigned long events = 0;
  72. spin_lock(&vt8500_rtc->lock);
  73. /* clear interrupt sources */
  74. isr = readl(vt8500_rtc->regbase + VT8500_RTC_IS);
  75. writel(isr, vt8500_rtc->regbase + VT8500_RTC_IS);
  76. spin_unlock(&vt8500_rtc->lock);
  77. if (isr & VT8500_RTC_IS_ALARM)
  78. events |= RTC_AF | RTC_IRQF;
  79. rtc_update_irq(vt8500_rtc->rtc, 1, events);
  80. return IRQ_HANDLED;
  81. }
  82. static int vt8500_rtc_read_time(struct device *dev, struct rtc_time *tm)
  83. {
  84. struct vt8500_rtc *vt8500_rtc = dev_get_drvdata(dev);
  85. u32 date, time;
  86. date = readl(vt8500_rtc->regbase + VT8500_RTC_DR);
  87. time = readl(vt8500_rtc->regbase + VT8500_RTC_TR);
  88. tm->tm_sec = bcd2bin(time & TIME_SEC_MASK);
  89. tm->tm_min = bcd2bin((time & TIME_MIN_MASK) >> TIME_MIN_S);
  90. tm->tm_hour = bcd2bin((time & TIME_HOUR_MASK) >> TIME_HOUR_S);
  91. tm->tm_mday = bcd2bin(date & DATE_DAY_MASK);
  92. tm->tm_mon = bcd2bin((date & DATE_MONTH_MASK) >> DATE_MONTH_S) - 1;
  93. tm->tm_year = bcd2bin((date & DATE_YEAR_MASK) >> DATE_YEAR_S)
  94. + ((date >> DATE_CENTURY_S) & 1 ? 200 : 100);
  95. tm->tm_wday = (time & TIME_DOW_MASK) >> TIME_DOW_S;
  96. return 0;
  97. }
  98. static int vt8500_rtc_set_time(struct device *dev, struct rtc_time *tm)
  99. {
  100. struct vt8500_rtc *vt8500_rtc = dev_get_drvdata(dev);
  101. writel((bin2bcd(tm->tm_year % 100) << DATE_YEAR_S)
  102. | (bin2bcd(tm->tm_mon + 1) << DATE_MONTH_S)
  103. | (bin2bcd(tm->tm_mday))
  104. | ((tm->tm_year >= 200) << DATE_CENTURY_S),
  105. vt8500_rtc->regbase + VT8500_RTC_DS);
  106. writel((bin2bcd(tm->tm_wday) << TIME_DOW_S)
  107. | (bin2bcd(tm->tm_hour) << TIME_HOUR_S)
  108. | (bin2bcd(tm->tm_min) << TIME_MIN_S)
  109. | (bin2bcd(tm->tm_sec)),
  110. vt8500_rtc->regbase + VT8500_RTC_TS);
  111. return 0;
  112. }
  113. static int vt8500_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
  114. {
  115. struct vt8500_rtc *vt8500_rtc = dev_get_drvdata(dev);
  116. u32 isr, alarm;
  117. alarm = readl(vt8500_rtc->regbase + VT8500_RTC_AS);
  118. isr = readl(vt8500_rtc->regbase + VT8500_RTC_IS);
  119. alrm->time.tm_mday = bcd2bin((alarm & ALARM_DAY_MASK) >> ALARM_DAY_S);
  120. alrm->time.tm_hour = bcd2bin((alarm & TIME_HOUR_MASK) >> TIME_HOUR_S);
  121. alrm->time.tm_min = bcd2bin((alarm & TIME_MIN_MASK) >> TIME_MIN_S);
  122. alrm->time.tm_sec = bcd2bin((alarm & TIME_SEC_MASK));
  123. alrm->enabled = (alarm & ALARM_ENABLE_MASK) ? 1 : 0;
  124. alrm->pending = (isr & VT8500_RTC_IS_ALARM) ? 1 : 0;
  125. return rtc_valid_tm(&alrm->time);
  126. }
  127. static int vt8500_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
  128. {
  129. struct vt8500_rtc *vt8500_rtc = dev_get_drvdata(dev);
  130. writel((alrm->enabled ? ALARM_ENABLE_MASK : 0)
  131. | (bin2bcd(alrm->time.tm_mday) << ALARM_DAY_S)
  132. | (bin2bcd(alrm->time.tm_hour) << TIME_HOUR_S)
  133. | (bin2bcd(alrm->time.tm_min) << TIME_MIN_S)
  134. | (bin2bcd(alrm->time.tm_sec)),
  135. vt8500_rtc->regbase + VT8500_RTC_AS);
  136. return 0;
  137. }
  138. static int vt8500_alarm_irq_enable(struct device *dev, unsigned int enabled)
  139. {
  140. struct vt8500_rtc *vt8500_rtc = dev_get_drvdata(dev);
  141. unsigned long tmp = readl(vt8500_rtc->regbase + VT8500_RTC_AS);
  142. if (enabled)
  143. tmp |= ALARM_ENABLE_MASK;
  144. else
  145. tmp &= ~ALARM_ENABLE_MASK;
  146. writel(tmp, vt8500_rtc->regbase + VT8500_RTC_AS);
  147. return 0;
  148. }
  149. static const struct rtc_class_ops vt8500_rtc_ops = {
  150. .read_time = vt8500_rtc_read_time,
  151. .set_time = vt8500_rtc_set_time,
  152. .read_alarm = vt8500_rtc_read_alarm,
  153. .set_alarm = vt8500_rtc_set_alarm,
  154. .alarm_irq_enable = vt8500_alarm_irq_enable,
  155. };
  156. static int vt8500_rtc_probe(struct platform_device *pdev)
  157. {
  158. struct vt8500_rtc *vt8500_rtc;
  159. int ret;
  160. vt8500_rtc = devm_kzalloc(&pdev->dev,
  161. sizeof(struct vt8500_rtc), GFP_KERNEL);
  162. if (!vt8500_rtc)
  163. return -ENOMEM;
  164. spin_lock_init(&vt8500_rtc->lock);
  165. platform_set_drvdata(pdev, vt8500_rtc);
  166. vt8500_rtc->irq_alarm = platform_get_irq(pdev, 0);
  167. if (vt8500_rtc->irq_alarm < 0)
  168. return vt8500_rtc->irq_alarm;
  169. vt8500_rtc->regbase = devm_platform_ioremap_resource(pdev, 0);
  170. if (IS_ERR(vt8500_rtc->regbase))
  171. return PTR_ERR(vt8500_rtc->regbase);
  172. /* Enable RTC and set it to 24-hour mode */
  173. writel(VT8500_RTC_CR_ENABLE,
  174. vt8500_rtc->regbase + VT8500_RTC_CR);
  175. vt8500_rtc->rtc = devm_rtc_allocate_device(&pdev->dev);
  176. if (IS_ERR(vt8500_rtc->rtc))
  177. return PTR_ERR(vt8500_rtc->rtc);
  178. vt8500_rtc->rtc->ops = &vt8500_rtc_ops;
  179. vt8500_rtc->rtc->range_min = RTC_TIMESTAMP_BEGIN_2000;
  180. vt8500_rtc->rtc->range_max = RTC_TIMESTAMP_END_2199;
  181. ret = devm_request_irq(&pdev->dev, vt8500_rtc->irq_alarm,
  182. vt8500_rtc_irq, 0, "rtc alarm", vt8500_rtc);
  183. if (ret < 0) {
  184. dev_err(&pdev->dev, "can't get irq %i, err %d\n",
  185. vt8500_rtc->irq_alarm, ret);
  186. return ret;
  187. }
  188. return rtc_register_device(vt8500_rtc->rtc);
  189. }
  190. static int vt8500_rtc_remove(struct platform_device *pdev)
  191. {
  192. struct vt8500_rtc *vt8500_rtc = platform_get_drvdata(pdev);
  193. /* Disable alarm matching */
  194. writel(0, vt8500_rtc->regbase + VT8500_RTC_IS);
  195. return 0;
  196. }
  197. static const struct of_device_id wmt_dt_ids[] = {
  198. { .compatible = "via,vt8500-rtc", },
  199. {}
  200. };
  201. MODULE_DEVICE_TABLE(of, wmt_dt_ids);
  202. static struct platform_driver vt8500_rtc_driver = {
  203. .probe = vt8500_rtc_probe,
  204. .remove = vt8500_rtc_remove,
  205. .driver = {
  206. .name = "vt8500-rtc",
  207. .of_match_table = wmt_dt_ids,
  208. },
  209. };
  210. module_platform_driver(vt8500_rtc_driver);
  211. MODULE_AUTHOR("Alexey Charkov <alchark@gmail.com>");
  212. MODULE_DESCRIPTION("VIA VT8500 SoC Realtime Clock Driver (RTC)");
  213. MODULE_LICENSE("GPL v2");
  214. MODULE_ALIAS("platform:vt8500-rtc");