rtc-da9063.c 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Real time clock device driver for DA9063
  4. * Copyright (C) 2013-2015 Dialog Semiconductor Ltd.
  5. */
  6. #include <linux/delay.h>
  7. #include <linux/init.h>
  8. #include <linux/interrupt.h>
  9. #include <linux/kernel.h>
  10. #include <linux/module.h>
  11. #include <linux/of.h>
  12. #include <linux/platform_device.h>
  13. #include <linux/regmap.h>
  14. #include <linux/rtc.h>
  15. #include <linux/slab.h>
  16. #include <linux/mfd/da9062/registers.h>
  17. #include <linux/mfd/da9063/registers.h>
  18. #include <linux/mfd/da9063/core.h>
  19. #define YEARS_TO_DA9063(year) ((year) - 100)
  20. #define MONTHS_TO_DA9063(month) ((month) + 1)
  21. #define YEARS_FROM_DA9063(year) ((year) + 100)
  22. #define MONTHS_FROM_DA9063(month) ((month) - 1)
  23. enum {
  24. RTC_SEC = 0,
  25. RTC_MIN = 1,
  26. RTC_HOUR = 2,
  27. RTC_DAY = 3,
  28. RTC_MONTH = 4,
  29. RTC_YEAR = 5,
  30. RTC_DATA_LEN
  31. };
  32. struct da9063_compatible_rtc_regmap {
  33. /* REGS */
  34. int rtc_enable_reg;
  35. int rtc_enable_32k_crystal_reg;
  36. int rtc_alarm_secs_reg;
  37. int rtc_alarm_year_reg;
  38. int rtc_count_secs_reg;
  39. int rtc_count_year_reg;
  40. int rtc_event_reg;
  41. /* MASKS */
  42. int rtc_enable_mask;
  43. int rtc_crystal_mask;
  44. int rtc_event_alarm_mask;
  45. int rtc_alarm_on_mask;
  46. int rtc_alarm_status_mask;
  47. int rtc_tick_on_mask;
  48. int rtc_ready_to_read_mask;
  49. int rtc_count_sec_mask;
  50. int rtc_count_min_mask;
  51. int rtc_count_hour_mask;
  52. int rtc_count_day_mask;
  53. int rtc_count_month_mask;
  54. int rtc_count_year_mask;
  55. /* ALARM CONFIG */
  56. int rtc_data_start;
  57. int rtc_alarm_len;
  58. };
  59. struct da9063_compatible_rtc {
  60. struct rtc_device *rtc_dev;
  61. struct rtc_time alarm_time;
  62. struct regmap *regmap;
  63. const struct da9063_compatible_rtc_regmap *config;
  64. bool rtc_sync;
  65. };
  66. static const struct da9063_compatible_rtc_regmap da9063_ad_regs = {
  67. /* REGS */
  68. .rtc_enable_reg = DA9063_REG_CONTROL_E,
  69. .rtc_alarm_secs_reg = DA9063_AD_REG_ALARM_MI,
  70. .rtc_alarm_year_reg = DA9063_AD_REG_ALARM_Y,
  71. .rtc_count_secs_reg = DA9063_REG_COUNT_S,
  72. .rtc_count_year_reg = DA9063_REG_COUNT_Y,
  73. .rtc_event_reg = DA9063_REG_EVENT_A,
  74. /* MASKS */
  75. .rtc_enable_mask = DA9063_RTC_EN,
  76. .rtc_crystal_mask = DA9063_CRYSTAL,
  77. .rtc_enable_32k_crystal_reg = DA9063_REG_EN_32K,
  78. .rtc_event_alarm_mask = DA9063_E_ALARM,
  79. .rtc_alarm_on_mask = DA9063_ALARM_ON,
  80. .rtc_alarm_status_mask = DA9063_ALARM_STATUS_ALARM |
  81. DA9063_ALARM_STATUS_TICK,
  82. .rtc_tick_on_mask = DA9063_TICK_ON,
  83. .rtc_ready_to_read_mask = DA9063_RTC_READ,
  84. .rtc_count_sec_mask = DA9063_COUNT_SEC_MASK,
  85. .rtc_count_min_mask = DA9063_COUNT_MIN_MASK,
  86. .rtc_count_hour_mask = DA9063_COUNT_HOUR_MASK,
  87. .rtc_count_day_mask = DA9063_COUNT_DAY_MASK,
  88. .rtc_count_month_mask = DA9063_COUNT_MONTH_MASK,
  89. .rtc_count_year_mask = DA9063_COUNT_YEAR_MASK,
  90. /* ALARM CONFIG */
  91. .rtc_data_start = RTC_MIN,
  92. .rtc_alarm_len = RTC_DATA_LEN - 1,
  93. };
  94. static const struct da9063_compatible_rtc_regmap da9063_bb_regs = {
  95. /* REGS */
  96. .rtc_enable_reg = DA9063_REG_CONTROL_E,
  97. .rtc_alarm_secs_reg = DA9063_BB_REG_ALARM_S,
  98. .rtc_alarm_year_reg = DA9063_BB_REG_ALARM_Y,
  99. .rtc_count_secs_reg = DA9063_REG_COUNT_S,
  100. .rtc_count_year_reg = DA9063_REG_COUNT_Y,
  101. .rtc_event_reg = DA9063_REG_EVENT_A,
  102. /* MASKS */
  103. .rtc_enable_mask = DA9063_RTC_EN,
  104. .rtc_crystal_mask = DA9063_CRYSTAL,
  105. .rtc_enable_32k_crystal_reg = DA9063_REG_EN_32K,
  106. .rtc_event_alarm_mask = DA9063_E_ALARM,
  107. .rtc_alarm_on_mask = DA9063_ALARM_ON,
  108. .rtc_alarm_status_mask = DA9063_ALARM_STATUS_ALARM |
  109. DA9063_ALARM_STATUS_TICK,
  110. .rtc_tick_on_mask = DA9063_TICK_ON,
  111. .rtc_ready_to_read_mask = DA9063_RTC_READ,
  112. .rtc_count_sec_mask = DA9063_COUNT_SEC_MASK,
  113. .rtc_count_min_mask = DA9063_COUNT_MIN_MASK,
  114. .rtc_count_hour_mask = DA9063_COUNT_HOUR_MASK,
  115. .rtc_count_day_mask = DA9063_COUNT_DAY_MASK,
  116. .rtc_count_month_mask = DA9063_COUNT_MONTH_MASK,
  117. .rtc_count_year_mask = DA9063_COUNT_YEAR_MASK,
  118. /* ALARM CONFIG */
  119. .rtc_data_start = RTC_SEC,
  120. .rtc_alarm_len = RTC_DATA_LEN,
  121. };
  122. static const struct da9063_compatible_rtc_regmap da9062_aa_regs = {
  123. /* REGS */
  124. .rtc_enable_reg = DA9062AA_CONTROL_E,
  125. .rtc_alarm_secs_reg = DA9062AA_ALARM_S,
  126. .rtc_alarm_year_reg = DA9062AA_ALARM_Y,
  127. .rtc_count_secs_reg = DA9062AA_COUNT_S,
  128. .rtc_count_year_reg = DA9062AA_COUNT_Y,
  129. .rtc_event_reg = DA9062AA_EVENT_A,
  130. /* MASKS */
  131. .rtc_enable_mask = DA9062AA_RTC_EN_MASK,
  132. .rtc_crystal_mask = DA9062AA_CRYSTAL_MASK,
  133. .rtc_enable_32k_crystal_reg = DA9062AA_EN_32K,
  134. .rtc_event_alarm_mask = DA9062AA_M_ALARM_MASK,
  135. .rtc_alarm_on_mask = DA9062AA_ALARM_ON_MASK,
  136. .rtc_alarm_status_mask = (0x02 << 6),
  137. .rtc_tick_on_mask = DA9062AA_TICK_ON_MASK,
  138. .rtc_ready_to_read_mask = DA9062AA_RTC_READ_MASK,
  139. .rtc_count_sec_mask = DA9062AA_COUNT_SEC_MASK,
  140. .rtc_count_min_mask = DA9062AA_COUNT_MIN_MASK,
  141. .rtc_count_hour_mask = DA9062AA_COUNT_HOUR_MASK,
  142. .rtc_count_day_mask = DA9062AA_COUNT_DAY_MASK,
  143. .rtc_count_month_mask = DA9062AA_COUNT_MONTH_MASK,
  144. .rtc_count_year_mask = DA9062AA_COUNT_YEAR_MASK,
  145. /* ALARM CONFIG */
  146. .rtc_data_start = RTC_SEC,
  147. .rtc_alarm_len = RTC_DATA_LEN,
  148. };
  149. static const struct of_device_id da9063_compatible_reg_id_table[] = {
  150. { .compatible = "dlg,da9063-rtc", .data = &da9063_bb_regs },
  151. { .compatible = "dlg,da9062-rtc", .data = &da9062_aa_regs },
  152. { },
  153. };
  154. MODULE_DEVICE_TABLE(of, da9063_compatible_reg_id_table);
  155. static void da9063_data_to_tm(u8 *data, struct rtc_time *tm,
  156. struct da9063_compatible_rtc *rtc)
  157. {
  158. const struct da9063_compatible_rtc_regmap *config = rtc->config;
  159. tm->tm_sec = data[RTC_SEC] & config->rtc_count_sec_mask;
  160. tm->tm_min = data[RTC_MIN] & config->rtc_count_min_mask;
  161. tm->tm_hour = data[RTC_HOUR] & config->rtc_count_hour_mask;
  162. tm->tm_mday = data[RTC_DAY] & config->rtc_count_day_mask;
  163. tm->tm_mon = MONTHS_FROM_DA9063(data[RTC_MONTH] &
  164. config->rtc_count_month_mask);
  165. tm->tm_year = YEARS_FROM_DA9063(data[RTC_YEAR] &
  166. config->rtc_count_year_mask);
  167. }
  168. static void da9063_tm_to_data(struct rtc_time *tm, u8 *data,
  169. struct da9063_compatible_rtc *rtc)
  170. {
  171. const struct da9063_compatible_rtc_regmap *config = rtc->config;
  172. data[RTC_SEC] = tm->tm_sec & config->rtc_count_sec_mask;
  173. data[RTC_MIN] = tm->tm_min & config->rtc_count_min_mask;
  174. data[RTC_HOUR] = tm->tm_hour & config->rtc_count_hour_mask;
  175. data[RTC_DAY] = tm->tm_mday & config->rtc_count_day_mask;
  176. data[RTC_MONTH] = MONTHS_TO_DA9063(tm->tm_mon) &
  177. config->rtc_count_month_mask;
  178. data[RTC_YEAR] = YEARS_TO_DA9063(tm->tm_year) &
  179. config->rtc_count_year_mask;
  180. }
  181. static int da9063_rtc_stop_alarm(struct device *dev)
  182. {
  183. struct da9063_compatible_rtc *rtc = dev_get_drvdata(dev);
  184. const struct da9063_compatible_rtc_regmap *config = rtc->config;
  185. return regmap_update_bits(rtc->regmap,
  186. config->rtc_alarm_year_reg,
  187. config->rtc_alarm_on_mask,
  188. 0);
  189. }
  190. static int da9063_rtc_start_alarm(struct device *dev)
  191. {
  192. struct da9063_compatible_rtc *rtc = dev_get_drvdata(dev);
  193. const struct da9063_compatible_rtc_regmap *config = rtc->config;
  194. return regmap_update_bits(rtc->regmap,
  195. config->rtc_alarm_year_reg,
  196. config->rtc_alarm_on_mask,
  197. config->rtc_alarm_on_mask);
  198. }
  199. static int da9063_rtc_read_time(struct device *dev, struct rtc_time *tm)
  200. {
  201. struct da9063_compatible_rtc *rtc = dev_get_drvdata(dev);
  202. const struct da9063_compatible_rtc_regmap *config = rtc->config;
  203. unsigned long tm_secs;
  204. unsigned long al_secs;
  205. u8 data[RTC_DATA_LEN];
  206. int ret;
  207. ret = regmap_bulk_read(rtc->regmap,
  208. config->rtc_count_secs_reg,
  209. data, RTC_DATA_LEN);
  210. if (ret < 0) {
  211. dev_err(dev, "Failed to read RTC time data: %d\n", ret);
  212. return ret;
  213. }
  214. if (!(data[RTC_SEC] & config->rtc_ready_to_read_mask)) {
  215. dev_dbg(dev, "RTC not yet ready to be read by the host\n");
  216. return -EINVAL;
  217. }
  218. da9063_data_to_tm(data, tm, rtc);
  219. tm_secs = rtc_tm_to_time64(tm);
  220. al_secs = rtc_tm_to_time64(&rtc->alarm_time);
  221. /* handle the rtc synchronisation delay */
  222. if (rtc->rtc_sync == true && al_secs - tm_secs == 1)
  223. memcpy(tm, &rtc->alarm_time, sizeof(struct rtc_time));
  224. else
  225. rtc->rtc_sync = false;
  226. return 0;
  227. }
  228. static int da9063_rtc_set_time(struct device *dev, struct rtc_time *tm)
  229. {
  230. struct da9063_compatible_rtc *rtc = dev_get_drvdata(dev);
  231. const struct da9063_compatible_rtc_regmap *config = rtc->config;
  232. u8 data[RTC_DATA_LEN];
  233. int ret;
  234. da9063_tm_to_data(tm, data, rtc);
  235. ret = regmap_bulk_write(rtc->regmap,
  236. config->rtc_count_secs_reg,
  237. data, RTC_DATA_LEN);
  238. if (ret < 0)
  239. dev_err(dev, "Failed to set RTC time data: %d\n", ret);
  240. return ret;
  241. }
  242. static int da9063_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
  243. {
  244. struct da9063_compatible_rtc *rtc = dev_get_drvdata(dev);
  245. const struct da9063_compatible_rtc_regmap *config = rtc->config;
  246. u8 data[RTC_DATA_LEN];
  247. int ret;
  248. unsigned int val;
  249. data[RTC_SEC] = 0;
  250. ret = regmap_bulk_read(rtc->regmap,
  251. config->rtc_alarm_secs_reg,
  252. &data[config->rtc_data_start],
  253. config->rtc_alarm_len);
  254. if (ret < 0)
  255. return ret;
  256. da9063_data_to_tm(data, &alrm->time, rtc);
  257. alrm->enabled = !!(data[RTC_YEAR] & config->rtc_alarm_on_mask);
  258. ret = regmap_read(rtc->regmap,
  259. config->rtc_event_reg,
  260. &val);
  261. if (ret < 0)
  262. return ret;
  263. if (val & config->rtc_event_alarm_mask)
  264. alrm->pending = 1;
  265. else
  266. alrm->pending = 0;
  267. return 0;
  268. }
  269. static int da9063_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
  270. {
  271. struct da9063_compatible_rtc *rtc = dev_get_drvdata(dev);
  272. const struct da9063_compatible_rtc_regmap *config = rtc->config;
  273. u8 data[RTC_DATA_LEN];
  274. int ret;
  275. da9063_tm_to_data(&alrm->time, data, rtc);
  276. ret = da9063_rtc_stop_alarm(dev);
  277. if (ret < 0) {
  278. dev_err(dev, "Failed to stop alarm: %d\n", ret);
  279. return ret;
  280. }
  281. ret = regmap_bulk_write(rtc->regmap,
  282. config->rtc_alarm_secs_reg,
  283. &data[config->rtc_data_start],
  284. config->rtc_alarm_len);
  285. if (ret < 0) {
  286. dev_err(dev, "Failed to write alarm: %d\n", ret);
  287. return ret;
  288. }
  289. da9063_data_to_tm(data, &rtc->alarm_time, rtc);
  290. if (alrm->enabled) {
  291. ret = da9063_rtc_start_alarm(dev);
  292. if (ret < 0) {
  293. dev_err(dev, "Failed to start alarm: %d\n", ret);
  294. return ret;
  295. }
  296. }
  297. return ret;
  298. }
  299. static int da9063_rtc_alarm_irq_enable(struct device *dev,
  300. unsigned int enabled)
  301. {
  302. if (enabled)
  303. return da9063_rtc_start_alarm(dev);
  304. else
  305. return da9063_rtc_stop_alarm(dev);
  306. }
  307. static irqreturn_t da9063_alarm_event(int irq, void *data)
  308. {
  309. struct da9063_compatible_rtc *rtc = data;
  310. const struct da9063_compatible_rtc_regmap *config = rtc->config;
  311. regmap_update_bits(rtc->regmap,
  312. config->rtc_alarm_year_reg,
  313. config->rtc_alarm_on_mask,
  314. 0);
  315. rtc->rtc_sync = true;
  316. rtc_update_irq(rtc->rtc_dev, 1, RTC_IRQF | RTC_AF);
  317. return IRQ_HANDLED;
  318. }
  319. static const struct rtc_class_ops da9063_rtc_ops = {
  320. .read_time = da9063_rtc_read_time,
  321. .set_time = da9063_rtc_set_time,
  322. .read_alarm = da9063_rtc_read_alarm,
  323. .set_alarm = da9063_rtc_set_alarm,
  324. .alarm_irq_enable = da9063_rtc_alarm_irq_enable,
  325. };
  326. static int da9063_rtc_probe(struct platform_device *pdev)
  327. {
  328. struct da9063_compatible_rtc *rtc;
  329. const struct da9063_compatible_rtc_regmap *config;
  330. const struct of_device_id *match;
  331. int irq_alarm;
  332. u8 data[RTC_DATA_LEN];
  333. int ret;
  334. if (!pdev->dev.of_node)
  335. return -ENXIO;
  336. match = of_match_node(da9063_compatible_reg_id_table,
  337. pdev->dev.of_node);
  338. rtc = devm_kzalloc(&pdev->dev, sizeof(*rtc), GFP_KERNEL);
  339. if (!rtc)
  340. return -ENOMEM;
  341. rtc->config = match->data;
  342. if (of_device_is_compatible(pdev->dev.of_node, "dlg,da9063-rtc")) {
  343. struct da9063 *chip = dev_get_drvdata(pdev->dev.parent);
  344. if (chip->variant_code == PMIC_DA9063_AD)
  345. rtc->config = &da9063_ad_regs;
  346. }
  347. rtc->regmap = dev_get_regmap(pdev->dev.parent, NULL);
  348. if (!rtc->regmap) {
  349. dev_warn(&pdev->dev, "Parent regmap unavailable.\n");
  350. return -ENXIO;
  351. }
  352. config = rtc->config;
  353. ret = regmap_update_bits(rtc->regmap,
  354. config->rtc_enable_reg,
  355. config->rtc_enable_mask,
  356. config->rtc_enable_mask);
  357. if (ret < 0) {
  358. dev_err(&pdev->dev, "Failed to enable RTC\n");
  359. return ret;
  360. }
  361. ret = regmap_update_bits(rtc->regmap,
  362. config->rtc_enable_32k_crystal_reg,
  363. config->rtc_crystal_mask,
  364. config->rtc_crystal_mask);
  365. if (ret < 0) {
  366. dev_err(&pdev->dev, "Failed to run 32kHz oscillator\n");
  367. return ret;
  368. }
  369. ret = regmap_update_bits(rtc->regmap,
  370. config->rtc_alarm_secs_reg,
  371. config->rtc_alarm_status_mask,
  372. 0);
  373. if (ret < 0) {
  374. dev_err(&pdev->dev, "Failed to access RTC alarm register\n");
  375. return ret;
  376. }
  377. ret = regmap_update_bits(rtc->regmap,
  378. config->rtc_alarm_secs_reg,
  379. DA9063_ALARM_STATUS_ALARM,
  380. DA9063_ALARM_STATUS_ALARM);
  381. if (ret < 0) {
  382. dev_err(&pdev->dev, "Failed to access RTC alarm register\n");
  383. return ret;
  384. }
  385. ret = regmap_update_bits(rtc->regmap,
  386. config->rtc_alarm_year_reg,
  387. config->rtc_tick_on_mask,
  388. 0);
  389. if (ret < 0) {
  390. dev_err(&pdev->dev, "Failed to disable TICKs\n");
  391. return ret;
  392. }
  393. data[RTC_SEC] = 0;
  394. ret = regmap_bulk_read(rtc->regmap,
  395. config->rtc_alarm_secs_reg,
  396. &data[config->rtc_data_start],
  397. config->rtc_alarm_len);
  398. if (ret < 0) {
  399. dev_err(&pdev->dev, "Failed to read initial alarm data: %d\n",
  400. ret);
  401. return ret;
  402. }
  403. platform_set_drvdata(pdev, rtc);
  404. rtc->rtc_dev = devm_rtc_allocate_device(&pdev->dev);
  405. if (IS_ERR(rtc->rtc_dev))
  406. return PTR_ERR(rtc->rtc_dev);
  407. rtc->rtc_dev->ops = &da9063_rtc_ops;
  408. rtc->rtc_dev->range_min = RTC_TIMESTAMP_BEGIN_2000;
  409. rtc->rtc_dev->range_max = RTC_TIMESTAMP_END_2063;
  410. da9063_data_to_tm(data, &rtc->alarm_time, rtc);
  411. rtc->rtc_sync = false;
  412. /*
  413. * TODO: some models have alarms on a minute boundary but still support
  414. * real hardware interrupts. Add this once the core supports it.
  415. */
  416. if (config->rtc_data_start != RTC_SEC)
  417. rtc->rtc_dev->uie_unsupported = 1;
  418. irq_alarm = platform_get_irq_byname(pdev, "ALARM");
  419. if (irq_alarm < 0)
  420. return irq_alarm;
  421. ret = devm_request_threaded_irq(&pdev->dev, irq_alarm, NULL,
  422. da9063_alarm_event,
  423. IRQF_TRIGGER_LOW | IRQF_ONESHOT,
  424. "ALARM", rtc);
  425. if (ret)
  426. dev_err(&pdev->dev, "Failed to request ALARM IRQ %d: %d\n",
  427. irq_alarm, ret);
  428. return rtc_register_device(rtc->rtc_dev);
  429. }
  430. static struct platform_driver da9063_rtc_driver = {
  431. .probe = da9063_rtc_probe,
  432. .driver = {
  433. .name = DA9063_DRVNAME_RTC,
  434. .of_match_table = da9063_compatible_reg_id_table,
  435. },
  436. };
  437. module_platform_driver(da9063_rtc_driver);
  438. MODULE_AUTHOR("S Twiss <stwiss.opensource@diasemi.com>");
  439. MODULE_DESCRIPTION("Real time clock device driver for Dialog DA9063");
  440. MODULE_LICENSE("GPL");
  441. MODULE_ALIAS("platform:" DA9063_DRVNAME_RTC);