rtc-max8907.c 5.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * RTC driver for Maxim MAX8907
  4. *
  5. * Copyright (c) 2011-2012, NVIDIA Corporation.
  6. *
  7. * Based on drivers/rtc/rtc-max8925.c,
  8. * Copyright (C) 2009-2010 Marvell International Ltd.
  9. */
  10. #include <linux/bcd.h>
  11. #include <linux/i2c.h>
  12. #include <linux/mfd/max8907.h>
  13. #include <linux/module.h>
  14. #include <linux/platform_device.h>
  15. #include <linux/regmap.h>
  16. #include <linux/rtc.h>
  17. #include <linux/slab.h>
  18. enum {
  19. RTC_SEC = 0,
  20. RTC_MIN,
  21. RTC_HOUR,
  22. RTC_WEEKDAY,
  23. RTC_DATE,
  24. RTC_MONTH,
  25. RTC_YEAR1,
  26. RTC_YEAR2,
  27. };
  28. #define TIME_NUM 8
  29. #define ALARM_1SEC (1 << 7)
  30. #define HOUR_12 (1 << 7)
  31. #define HOUR_AM_PM (1 << 5)
  32. #define ALARM0_IRQ (1 << 3)
  33. #define ALARM1_IRQ (1 << 2)
  34. #define ALARM0_STATUS (1 << 2)
  35. #define ALARM1_STATUS (1 << 1)
  36. struct max8907_rtc {
  37. struct max8907 *max8907;
  38. struct regmap *regmap;
  39. struct rtc_device *rtc_dev;
  40. int irq;
  41. };
  42. static irqreturn_t max8907_irq_handler(int irq, void *data)
  43. {
  44. struct max8907_rtc *rtc = data;
  45. regmap_write(rtc->regmap, MAX8907_REG_ALARM0_CNTL, 0);
  46. rtc_update_irq(rtc->rtc_dev, 1, RTC_IRQF | RTC_AF);
  47. return IRQ_HANDLED;
  48. }
  49. static void regs_to_tm(u8 *regs, struct rtc_time *tm)
  50. {
  51. tm->tm_year = bcd2bin(regs[RTC_YEAR2]) * 100 +
  52. bcd2bin(regs[RTC_YEAR1]) - 1900;
  53. tm->tm_mon = bcd2bin(regs[RTC_MONTH] & 0x1f) - 1;
  54. tm->tm_mday = bcd2bin(regs[RTC_DATE] & 0x3f);
  55. tm->tm_wday = (regs[RTC_WEEKDAY] & 0x07);
  56. if (regs[RTC_HOUR] & HOUR_12) {
  57. tm->tm_hour = bcd2bin(regs[RTC_HOUR] & 0x01f);
  58. if (tm->tm_hour == 12)
  59. tm->tm_hour = 0;
  60. if (regs[RTC_HOUR] & HOUR_AM_PM)
  61. tm->tm_hour += 12;
  62. } else {
  63. tm->tm_hour = bcd2bin(regs[RTC_HOUR] & 0x03f);
  64. }
  65. tm->tm_min = bcd2bin(regs[RTC_MIN] & 0x7f);
  66. tm->tm_sec = bcd2bin(regs[RTC_SEC] & 0x7f);
  67. }
  68. static void tm_to_regs(struct rtc_time *tm, u8 *regs)
  69. {
  70. u8 high, low;
  71. high = (tm->tm_year + 1900) / 100;
  72. low = tm->tm_year % 100;
  73. regs[RTC_YEAR2] = bin2bcd(high);
  74. regs[RTC_YEAR1] = bin2bcd(low);
  75. regs[RTC_MONTH] = bin2bcd(tm->tm_mon + 1);
  76. regs[RTC_DATE] = bin2bcd(tm->tm_mday);
  77. regs[RTC_WEEKDAY] = tm->tm_wday;
  78. regs[RTC_HOUR] = bin2bcd(tm->tm_hour);
  79. regs[RTC_MIN] = bin2bcd(tm->tm_min);
  80. regs[RTC_SEC] = bin2bcd(tm->tm_sec);
  81. }
  82. static int max8907_rtc_read_time(struct device *dev, struct rtc_time *tm)
  83. {
  84. struct max8907_rtc *rtc = dev_get_drvdata(dev);
  85. u8 regs[TIME_NUM];
  86. int ret;
  87. ret = regmap_bulk_read(rtc->regmap, MAX8907_REG_RTC_SEC, regs,
  88. TIME_NUM);
  89. if (ret < 0)
  90. return ret;
  91. regs_to_tm(regs, tm);
  92. return 0;
  93. }
  94. static int max8907_rtc_set_time(struct device *dev, struct rtc_time *tm)
  95. {
  96. struct max8907_rtc *rtc = dev_get_drvdata(dev);
  97. u8 regs[TIME_NUM];
  98. tm_to_regs(tm, regs);
  99. return regmap_bulk_write(rtc->regmap, MAX8907_REG_RTC_SEC, regs,
  100. TIME_NUM);
  101. }
  102. static int max8907_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
  103. {
  104. struct max8907_rtc *rtc = dev_get_drvdata(dev);
  105. u8 regs[TIME_NUM];
  106. unsigned int val;
  107. int ret;
  108. ret = regmap_bulk_read(rtc->regmap, MAX8907_REG_ALARM0_SEC, regs,
  109. TIME_NUM);
  110. if (ret < 0)
  111. return ret;
  112. regs_to_tm(regs, &alrm->time);
  113. ret = regmap_read(rtc->regmap, MAX8907_REG_ALARM0_CNTL, &val);
  114. if (ret < 0)
  115. return ret;
  116. alrm->enabled = !!(val & 0x7f);
  117. return 0;
  118. }
  119. static int max8907_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
  120. {
  121. struct max8907_rtc *rtc = dev_get_drvdata(dev);
  122. u8 regs[TIME_NUM];
  123. int ret;
  124. tm_to_regs(&alrm->time, regs);
  125. /* Disable alarm while we update the target time */
  126. ret = regmap_write(rtc->regmap, MAX8907_REG_ALARM0_CNTL, 0);
  127. if (ret < 0)
  128. return ret;
  129. ret = regmap_bulk_write(rtc->regmap, MAX8907_REG_ALARM0_SEC, regs,
  130. TIME_NUM);
  131. if (ret < 0)
  132. return ret;
  133. if (alrm->enabled)
  134. ret = regmap_write(rtc->regmap, MAX8907_REG_ALARM0_CNTL, 0x77);
  135. return ret;
  136. }
  137. static const struct rtc_class_ops max8907_rtc_ops = {
  138. .read_time = max8907_rtc_read_time,
  139. .set_time = max8907_rtc_set_time,
  140. .read_alarm = max8907_rtc_read_alarm,
  141. .set_alarm = max8907_rtc_set_alarm,
  142. };
  143. static int max8907_rtc_probe(struct platform_device *pdev)
  144. {
  145. struct max8907 *max8907 = dev_get_drvdata(pdev->dev.parent);
  146. struct max8907_rtc *rtc;
  147. int ret;
  148. rtc = devm_kzalloc(&pdev->dev, sizeof(*rtc), GFP_KERNEL);
  149. if (!rtc)
  150. return -ENOMEM;
  151. platform_set_drvdata(pdev, rtc);
  152. rtc->max8907 = max8907;
  153. rtc->regmap = max8907->regmap_rtc;
  154. rtc->rtc_dev = devm_rtc_device_register(&pdev->dev, "max8907-rtc",
  155. &max8907_rtc_ops, THIS_MODULE);
  156. if (IS_ERR(rtc->rtc_dev)) {
  157. ret = PTR_ERR(rtc->rtc_dev);
  158. dev_err(&pdev->dev, "Failed to register RTC device: %d\n", ret);
  159. return ret;
  160. }
  161. rtc->irq = regmap_irq_get_virq(max8907->irqc_rtc,
  162. MAX8907_IRQ_RTC_ALARM0);
  163. if (rtc->irq < 0)
  164. return rtc->irq;
  165. ret = devm_request_threaded_irq(&pdev->dev, rtc->irq, NULL,
  166. max8907_irq_handler,
  167. IRQF_ONESHOT, "max8907-alarm0", rtc);
  168. if (ret < 0)
  169. dev_err(&pdev->dev, "Failed to request IRQ%d: %d\n",
  170. rtc->irq, ret);
  171. return ret;
  172. }
  173. static struct platform_driver max8907_rtc_driver = {
  174. .driver = {
  175. .name = "max8907-rtc",
  176. },
  177. .probe = max8907_rtc_probe,
  178. };
  179. module_platform_driver(max8907_rtc_driver);
  180. MODULE_DESCRIPTION("Maxim MAX8907 RTC driver");
  181. MODULE_LICENSE("GPL v2");