rtc-sc27xx.c 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662
  1. /*
  2. * Copyright (C) 2017 Spreadtrum Communications Inc.
  3. *
  4. * SPDX-License-Identifier: GPL-2.0
  5. */
  6. #include <linux/bitops.h>
  7. #include <linux/delay.h>
  8. #include <linux/err.h>
  9. #include <linux/module.h>
  10. #include <linux/of.h>
  11. #include <linux/platform_device.h>
  12. #include <linux/regmap.h>
  13. #include <linux/rtc.h>
  14. #define SPRD_RTC_SEC_CNT_VALUE 0x0
  15. #define SPRD_RTC_MIN_CNT_VALUE 0x4
  16. #define SPRD_RTC_HOUR_CNT_VALUE 0x8
  17. #define SPRD_RTC_DAY_CNT_VALUE 0xc
  18. #define SPRD_RTC_SEC_CNT_UPD 0x10
  19. #define SPRD_RTC_MIN_CNT_UPD 0x14
  20. #define SPRD_RTC_HOUR_CNT_UPD 0x18
  21. #define SPRD_RTC_DAY_CNT_UPD 0x1c
  22. #define SPRD_RTC_SEC_ALM_UPD 0x20
  23. #define SPRD_RTC_MIN_ALM_UPD 0x24
  24. #define SPRD_RTC_HOUR_ALM_UPD 0x28
  25. #define SPRD_RTC_DAY_ALM_UPD 0x2c
  26. #define SPRD_RTC_INT_EN 0x30
  27. #define SPRD_RTC_INT_RAW_STS 0x34
  28. #define SPRD_RTC_INT_CLR 0x38
  29. #define SPRD_RTC_INT_MASK_STS 0x3C
  30. #define SPRD_RTC_SEC_ALM_VALUE 0x40
  31. #define SPRD_RTC_MIN_ALM_VALUE 0x44
  32. #define SPRD_RTC_HOUR_ALM_VALUE 0x48
  33. #define SPRD_RTC_DAY_ALM_VALUE 0x4c
  34. #define SPRD_RTC_SPG_VALUE 0x50
  35. #define SPRD_RTC_SPG_UPD 0x54
  36. #define SPRD_RTC_SEC_AUXALM_UPD 0x60
  37. #define SPRD_RTC_MIN_AUXALM_UPD 0x64
  38. #define SPRD_RTC_HOUR_AUXALM_UPD 0x68
  39. #define SPRD_RTC_DAY_AUXALM_UPD 0x6c
  40. /* BIT & MASK definition for SPRD_RTC_INT_* registers */
  41. #define SPRD_RTC_SEC_EN BIT(0)
  42. #define SPRD_RTC_MIN_EN BIT(1)
  43. #define SPRD_RTC_HOUR_EN BIT(2)
  44. #define SPRD_RTC_DAY_EN BIT(3)
  45. #define SPRD_RTC_ALARM_EN BIT(4)
  46. #define SPRD_RTC_HRS_FORMAT_EN BIT(5)
  47. #define SPRD_RTC_AUXALM_EN BIT(6)
  48. #define SPRD_RTC_SPG_UPD_EN BIT(7)
  49. #define SPRD_RTC_SEC_UPD_EN BIT(8)
  50. #define SPRD_RTC_MIN_UPD_EN BIT(9)
  51. #define SPRD_RTC_HOUR_UPD_EN BIT(10)
  52. #define SPRD_RTC_DAY_UPD_EN BIT(11)
  53. #define SPRD_RTC_ALMSEC_UPD_EN BIT(12)
  54. #define SPRD_RTC_ALMMIN_UPD_EN BIT(13)
  55. #define SPRD_RTC_ALMHOUR_UPD_EN BIT(14)
  56. #define SPRD_RTC_ALMDAY_UPD_EN BIT(15)
  57. #define SPRD_RTC_INT_MASK GENMASK(15, 0)
  58. #define SPRD_RTC_TIME_INT_MASK \
  59. (SPRD_RTC_SEC_UPD_EN | SPRD_RTC_MIN_UPD_EN | \
  60. SPRD_RTC_HOUR_UPD_EN | SPRD_RTC_DAY_UPD_EN)
  61. #define SPRD_RTC_ALMTIME_INT_MASK \
  62. (SPRD_RTC_ALMSEC_UPD_EN | SPRD_RTC_ALMMIN_UPD_EN | \
  63. SPRD_RTC_ALMHOUR_UPD_EN | SPRD_RTC_ALMDAY_UPD_EN)
  64. #define SPRD_RTC_ALM_INT_MASK \
  65. (SPRD_RTC_SEC_EN | SPRD_RTC_MIN_EN | \
  66. SPRD_RTC_HOUR_EN | SPRD_RTC_DAY_EN | \
  67. SPRD_RTC_ALARM_EN | SPRD_RTC_AUXALM_EN)
  68. /* second/minute/hour/day values mask definition */
  69. #define SPRD_RTC_SEC_MASK GENMASK(5, 0)
  70. #define SPRD_RTC_MIN_MASK GENMASK(5, 0)
  71. #define SPRD_RTC_HOUR_MASK GENMASK(4, 0)
  72. #define SPRD_RTC_DAY_MASK GENMASK(15, 0)
  73. /* alarm lock definition for SPRD_RTC_SPG_UPD register */
  74. #define SPRD_RTC_ALMLOCK_MASK GENMASK(7, 0)
  75. #define SPRD_RTC_ALM_UNLOCK 0xa5
  76. #define SPRD_RTC_ALM_LOCK (~SPRD_RTC_ALM_UNLOCK & \
  77. SPRD_RTC_ALMLOCK_MASK)
  78. /* SPG values definition for SPRD_RTC_SPG_UPD register */
  79. #define SPRD_RTC_POWEROFF_ALM_FLAG BIT(8)
  80. #define SPRD_RTC_POWER_RESET_FLAG BIT(9)
  81. /* timeout of synchronizing time and alarm registers (us) */
  82. #define SPRD_RTC_POLL_TIMEOUT 200000
  83. #define SPRD_RTC_POLL_DELAY_US 20000
  84. struct sprd_rtc {
  85. struct rtc_device *rtc;
  86. struct regmap *regmap;
  87. struct device *dev;
  88. u32 base;
  89. int irq;
  90. bool valid;
  91. };
  92. /*
  93. * The Spreadtrum RTC controller has 3 groups registers, including time, normal
  94. * alarm and auxiliary alarm. The time group registers are used to set RTC time,
  95. * the normal alarm registers are used to set normal alarm, and the auxiliary
  96. * alarm registers are used to set auxiliary alarm. Both alarm event and
  97. * auxiliary alarm event can wake up system from deep sleep, but only alarm
  98. * event can power up system from power down status.
  99. */
  100. enum sprd_rtc_reg_types {
  101. SPRD_RTC_TIME,
  102. SPRD_RTC_ALARM,
  103. SPRD_RTC_AUX_ALARM,
  104. };
  105. static int sprd_rtc_clear_alarm_ints(struct sprd_rtc *rtc)
  106. {
  107. return regmap_write(rtc->regmap, rtc->base + SPRD_RTC_INT_CLR,
  108. SPRD_RTC_ALM_INT_MASK);
  109. }
  110. static int sprd_rtc_disable_ints(struct sprd_rtc *rtc)
  111. {
  112. int ret;
  113. ret = regmap_update_bits(rtc->regmap, rtc->base + SPRD_RTC_INT_EN,
  114. SPRD_RTC_INT_MASK, 0);
  115. if (ret)
  116. return ret;
  117. return regmap_write(rtc->regmap, rtc->base + SPRD_RTC_INT_CLR,
  118. SPRD_RTC_INT_MASK);
  119. }
  120. static int sprd_rtc_lock_alarm(struct sprd_rtc *rtc, bool lock)
  121. {
  122. int ret;
  123. u32 val;
  124. ret = regmap_read(rtc->regmap, rtc->base + SPRD_RTC_SPG_VALUE, &val);
  125. if (ret)
  126. return ret;
  127. val &= ~(SPRD_RTC_ALMLOCK_MASK | SPRD_RTC_POWEROFF_ALM_FLAG);
  128. if (lock)
  129. val |= SPRD_RTC_ALM_LOCK;
  130. else
  131. val |= SPRD_RTC_ALM_UNLOCK | SPRD_RTC_POWEROFF_ALM_FLAG;
  132. ret = regmap_write(rtc->regmap, rtc->base + SPRD_RTC_SPG_UPD, val);
  133. if (ret)
  134. return ret;
  135. /* wait until the SPG value is updated successfully */
  136. ret = regmap_read_poll_timeout(rtc->regmap,
  137. rtc->base + SPRD_RTC_INT_RAW_STS, val,
  138. (val & SPRD_RTC_SPG_UPD_EN),
  139. SPRD_RTC_POLL_DELAY_US,
  140. SPRD_RTC_POLL_TIMEOUT);
  141. if (ret) {
  142. dev_err(rtc->dev, "failed to update SPG value:%d\n", ret);
  143. return ret;
  144. }
  145. return 0;
  146. }
  147. static int sprd_rtc_get_secs(struct sprd_rtc *rtc, enum sprd_rtc_reg_types type,
  148. time64_t *secs)
  149. {
  150. u32 sec_reg, min_reg, hour_reg, day_reg;
  151. u32 val, sec, min, hour, day;
  152. int ret;
  153. switch (type) {
  154. case SPRD_RTC_TIME:
  155. sec_reg = SPRD_RTC_SEC_CNT_VALUE;
  156. min_reg = SPRD_RTC_MIN_CNT_VALUE;
  157. hour_reg = SPRD_RTC_HOUR_CNT_VALUE;
  158. day_reg = SPRD_RTC_DAY_CNT_VALUE;
  159. break;
  160. case SPRD_RTC_ALARM:
  161. sec_reg = SPRD_RTC_SEC_ALM_VALUE;
  162. min_reg = SPRD_RTC_MIN_ALM_VALUE;
  163. hour_reg = SPRD_RTC_HOUR_ALM_VALUE;
  164. day_reg = SPRD_RTC_DAY_ALM_VALUE;
  165. break;
  166. case SPRD_RTC_AUX_ALARM:
  167. sec_reg = SPRD_RTC_SEC_AUXALM_UPD;
  168. min_reg = SPRD_RTC_MIN_AUXALM_UPD;
  169. hour_reg = SPRD_RTC_HOUR_AUXALM_UPD;
  170. day_reg = SPRD_RTC_DAY_AUXALM_UPD;
  171. break;
  172. default:
  173. return -EINVAL;
  174. }
  175. ret = regmap_read(rtc->regmap, rtc->base + sec_reg, &val);
  176. if (ret)
  177. return ret;
  178. sec = val & SPRD_RTC_SEC_MASK;
  179. ret = regmap_read(rtc->regmap, rtc->base + min_reg, &val);
  180. if (ret)
  181. return ret;
  182. min = val & SPRD_RTC_MIN_MASK;
  183. ret = regmap_read(rtc->regmap, rtc->base + hour_reg, &val);
  184. if (ret)
  185. return ret;
  186. hour = val & SPRD_RTC_HOUR_MASK;
  187. ret = regmap_read(rtc->regmap, rtc->base + day_reg, &val);
  188. if (ret)
  189. return ret;
  190. day = val & SPRD_RTC_DAY_MASK;
  191. *secs = (((time64_t)(day * 24) + hour) * 60 + min) * 60 + sec;
  192. return 0;
  193. }
  194. static int sprd_rtc_set_secs(struct sprd_rtc *rtc, enum sprd_rtc_reg_types type,
  195. time64_t secs)
  196. {
  197. u32 sec_reg, min_reg, hour_reg, day_reg, sts_mask;
  198. u32 sec, min, hour, day, val;
  199. int ret, rem;
  200. /* convert seconds to RTC time format */
  201. day = div_s64_rem(secs, 86400, &rem);
  202. hour = rem / 3600;
  203. rem -= hour * 3600;
  204. min = rem / 60;
  205. sec = rem - min * 60;
  206. switch (type) {
  207. case SPRD_RTC_TIME:
  208. sec_reg = SPRD_RTC_SEC_CNT_UPD;
  209. min_reg = SPRD_RTC_MIN_CNT_UPD;
  210. hour_reg = SPRD_RTC_HOUR_CNT_UPD;
  211. day_reg = SPRD_RTC_DAY_CNT_UPD;
  212. sts_mask = SPRD_RTC_TIME_INT_MASK;
  213. break;
  214. case SPRD_RTC_ALARM:
  215. sec_reg = SPRD_RTC_SEC_ALM_UPD;
  216. min_reg = SPRD_RTC_MIN_ALM_UPD;
  217. hour_reg = SPRD_RTC_HOUR_ALM_UPD;
  218. day_reg = SPRD_RTC_DAY_ALM_UPD;
  219. sts_mask = SPRD_RTC_ALMTIME_INT_MASK;
  220. break;
  221. case SPRD_RTC_AUX_ALARM:
  222. sec_reg = SPRD_RTC_SEC_AUXALM_UPD;
  223. min_reg = SPRD_RTC_MIN_AUXALM_UPD;
  224. hour_reg = SPRD_RTC_HOUR_AUXALM_UPD;
  225. day_reg = SPRD_RTC_DAY_AUXALM_UPD;
  226. sts_mask = 0;
  227. break;
  228. default:
  229. return -EINVAL;
  230. }
  231. ret = regmap_write(rtc->regmap, rtc->base + sec_reg, sec);
  232. if (ret)
  233. return ret;
  234. ret = regmap_write(rtc->regmap, rtc->base + min_reg, min);
  235. if (ret)
  236. return ret;
  237. ret = regmap_write(rtc->regmap, rtc->base + hour_reg, hour);
  238. if (ret)
  239. return ret;
  240. ret = regmap_write(rtc->regmap, rtc->base + day_reg, day);
  241. if (ret)
  242. return ret;
  243. if (type == SPRD_RTC_AUX_ALARM)
  244. return 0;
  245. /*
  246. * Since the time and normal alarm registers are put in always-power-on
  247. * region supplied by VDDRTC, then these registers changing time will
  248. * be very long, about 125ms. Thus here we should wait until all
  249. * values are updated successfully.
  250. */
  251. ret = regmap_read_poll_timeout(rtc->regmap,
  252. rtc->base + SPRD_RTC_INT_RAW_STS, val,
  253. ((val & sts_mask) == sts_mask),
  254. SPRD_RTC_POLL_DELAY_US,
  255. SPRD_RTC_POLL_TIMEOUT);
  256. if (ret < 0) {
  257. dev_err(rtc->dev, "set time/alarm values timeout\n");
  258. return ret;
  259. }
  260. return regmap_write(rtc->regmap, rtc->base + SPRD_RTC_INT_CLR,
  261. sts_mask);
  262. }
  263. static int sprd_rtc_read_aux_alarm(struct device *dev, struct rtc_wkalrm *alrm)
  264. {
  265. struct sprd_rtc *rtc = dev_get_drvdata(dev);
  266. time64_t secs;
  267. u32 val;
  268. int ret;
  269. ret = sprd_rtc_get_secs(rtc, SPRD_RTC_AUX_ALARM, &secs);
  270. if (ret)
  271. return ret;
  272. rtc_time64_to_tm(secs, &alrm->time);
  273. ret = regmap_read(rtc->regmap, rtc->base + SPRD_RTC_INT_EN, &val);
  274. if (ret)
  275. return ret;
  276. alrm->enabled = !!(val & SPRD_RTC_AUXALM_EN);
  277. ret = regmap_read(rtc->regmap, rtc->base + SPRD_RTC_INT_RAW_STS, &val);
  278. if (ret)
  279. return ret;
  280. alrm->pending = !!(val & SPRD_RTC_AUXALM_EN);
  281. return 0;
  282. }
  283. static int sprd_rtc_set_aux_alarm(struct device *dev, struct rtc_wkalrm *alrm)
  284. {
  285. struct sprd_rtc *rtc = dev_get_drvdata(dev);
  286. time64_t secs = rtc_tm_to_time64(&alrm->time);
  287. int ret;
  288. /* clear the auxiliary alarm interrupt status */
  289. ret = regmap_write(rtc->regmap, rtc->base + SPRD_RTC_INT_CLR,
  290. SPRD_RTC_AUXALM_EN);
  291. if (ret)
  292. return ret;
  293. ret = sprd_rtc_set_secs(rtc, SPRD_RTC_AUX_ALARM, secs);
  294. if (ret)
  295. return ret;
  296. if (alrm->enabled) {
  297. ret = regmap_update_bits(rtc->regmap,
  298. rtc->base + SPRD_RTC_INT_EN,
  299. SPRD_RTC_AUXALM_EN,
  300. SPRD_RTC_AUXALM_EN);
  301. } else {
  302. ret = regmap_update_bits(rtc->regmap,
  303. rtc->base + SPRD_RTC_INT_EN,
  304. SPRD_RTC_AUXALM_EN, 0);
  305. }
  306. return ret;
  307. }
  308. static int sprd_rtc_read_time(struct device *dev, struct rtc_time *tm)
  309. {
  310. struct sprd_rtc *rtc = dev_get_drvdata(dev);
  311. time64_t secs;
  312. int ret;
  313. if (!rtc->valid) {
  314. dev_warn(dev, "RTC values are invalid\n");
  315. return -EINVAL;
  316. }
  317. ret = sprd_rtc_get_secs(rtc, SPRD_RTC_TIME, &secs);
  318. if (ret)
  319. return ret;
  320. rtc_time64_to_tm(secs, tm);
  321. return 0;
  322. }
  323. static int sprd_rtc_set_time(struct device *dev, struct rtc_time *tm)
  324. {
  325. struct sprd_rtc *rtc = dev_get_drvdata(dev);
  326. time64_t secs = rtc_tm_to_time64(tm);
  327. u32 val;
  328. int ret;
  329. ret = sprd_rtc_set_secs(rtc, SPRD_RTC_TIME, secs);
  330. if (ret)
  331. return ret;
  332. if (!rtc->valid) {
  333. /*
  334. * Set SPRD_RTC_POWER_RESET_FLAG to indicate now RTC has valid
  335. * time values.
  336. */
  337. ret = regmap_update_bits(rtc->regmap,
  338. rtc->base + SPRD_RTC_SPG_UPD,
  339. SPRD_RTC_POWER_RESET_FLAG,
  340. SPRD_RTC_POWER_RESET_FLAG);
  341. if (ret)
  342. return ret;
  343. ret = regmap_read_poll_timeout(rtc->regmap,
  344. rtc->base + SPRD_RTC_INT_RAW_STS,
  345. val, (val & SPRD_RTC_SPG_UPD_EN),
  346. SPRD_RTC_POLL_DELAY_US,
  347. SPRD_RTC_POLL_TIMEOUT);
  348. if (ret) {
  349. dev_err(rtc->dev, "failed to update SPG value:%d\n",
  350. ret);
  351. return ret;
  352. }
  353. rtc->valid = true;
  354. }
  355. return 0;
  356. }
  357. static int sprd_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
  358. {
  359. struct sprd_rtc *rtc = dev_get_drvdata(dev);
  360. time64_t secs;
  361. int ret;
  362. u32 val;
  363. /*
  364. * If aie_timer is enabled, we should get the normal alarm time.
  365. * Otherwise we should get auxiliary alarm time.
  366. */
  367. if (rtc->rtc && rtc->rtc->aie_timer.enabled == 0)
  368. return sprd_rtc_read_aux_alarm(dev, alrm);
  369. ret = sprd_rtc_get_secs(rtc, SPRD_RTC_ALARM, &secs);
  370. if (ret)
  371. return ret;
  372. rtc_time64_to_tm(secs, &alrm->time);
  373. ret = regmap_read(rtc->regmap, rtc->base + SPRD_RTC_INT_EN, &val);
  374. if (ret)
  375. return ret;
  376. alrm->enabled = !!(val & SPRD_RTC_ALARM_EN);
  377. ret = regmap_read(rtc->regmap, rtc->base + SPRD_RTC_INT_RAW_STS, &val);
  378. if (ret)
  379. return ret;
  380. alrm->pending = !!(val & SPRD_RTC_ALARM_EN);
  381. return 0;
  382. }
  383. static int sprd_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
  384. {
  385. struct sprd_rtc *rtc = dev_get_drvdata(dev);
  386. time64_t secs = rtc_tm_to_time64(&alrm->time);
  387. struct rtc_time aie_time =
  388. rtc_ktime_to_tm(rtc->rtc->aie_timer.node.expires);
  389. int ret;
  390. /*
  391. * We have 2 groups alarms: normal alarm and auxiliary alarm. Since
  392. * both normal alarm event and auxiliary alarm event can wake up system
  393. * from deep sleep, but only alarm event can power up system from power
  394. * down status. Moreover we do not need to poll about 125ms when
  395. * updating auxiliary alarm registers. Thus we usually set auxiliary
  396. * alarm when wake up system from deep sleep, and for other scenarios,
  397. * we should set normal alarm with polling status.
  398. *
  399. * So here we check if the alarm time is set by aie_timer, if yes, we
  400. * should set normal alarm, if not, we should set auxiliary alarm which
  401. * means it is just a wake event.
  402. */
  403. if (!rtc->rtc->aie_timer.enabled || rtc_tm_sub(&aie_time, &alrm->time))
  404. return sprd_rtc_set_aux_alarm(dev, alrm);
  405. /* clear the alarm interrupt status firstly */
  406. ret = regmap_write(rtc->regmap, rtc->base + SPRD_RTC_INT_CLR,
  407. SPRD_RTC_ALARM_EN);
  408. if (ret)
  409. return ret;
  410. ret = sprd_rtc_set_secs(rtc, SPRD_RTC_ALARM, secs);
  411. if (ret)
  412. return ret;
  413. if (alrm->enabled) {
  414. ret = regmap_update_bits(rtc->regmap,
  415. rtc->base + SPRD_RTC_INT_EN,
  416. SPRD_RTC_ALARM_EN,
  417. SPRD_RTC_ALARM_EN);
  418. if (ret)
  419. return ret;
  420. /* unlock the alarm to enable the alarm function. */
  421. ret = sprd_rtc_lock_alarm(rtc, false);
  422. } else {
  423. regmap_update_bits(rtc->regmap,
  424. rtc->base + SPRD_RTC_INT_EN,
  425. SPRD_RTC_ALARM_EN, 0);
  426. /*
  427. * Lock the alarm function in case fake alarm event will power
  428. * up systems.
  429. */
  430. ret = sprd_rtc_lock_alarm(rtc, true);
  431. }
  432. return ret;
  433. }
  434. static int sprd_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
  435. {
  436. struct sprd_rtc *rtc = dev_get_drvdata(dev);
  437. int ret;
  438. if (enabled) {
  439. ret = regmap_update_bits(rtc->regmap,
  440. rtc->base + SPRD_RTC_INT_EN,
  441. SPRD_RTC_ALARM_EN | SPRD_RTC_AUXALM_EN,
  442. SPRD_RTC_ALARM_EN | SPRD_RTC_AUXALM_EN);
  443. if (ret)
  444. return ret;
  445. ret = sprd_rtc_lock_alarm(rtc, false);
  446. } else {
  447. regmap_update_bits(rtc->regmap, rtc->base + SPRD_RTC_INT_EN,
  448. SPRD_RTC_ALARM_EN | SPRD_RTC_AUXALM_EN, 0);
  449. ret = sprd_rtc_lock_alarm(rtc, true);
  450. }
  451. return ret;
  452. }
  453. static const struct rtc_class_ops sprd_rtc_ops = {
  454. .read_time = sprd_rtc_read_time,
  455. .set_time = sprd_rtc_set_time,
  456. .read_alarm = sprd_rtc_read_alarm,
  457. .set_alarm = sprd_rtc_set_alarm,
  458. .alarm_irq_enable = sprd_rtc_alarm_irq_enable,
  459. };
  460. static irqreturn_t sprd_rtc_handler(int irq, void *dev_id)
  461. {
  462. struct sprd_rtc *rtc = dev_id;
  463. int ret;
  464. ret = sprd_rtc_clear_alarm_ints(rtc);
  465. if (ret)
  466. return IRQ_RETVAL(ret);
  467. rtc_update_irq(rtc->rtc, 1, RTC_AF | RTC_IRQF);
  468. return IRQ_HANDLED;
  469. }
  470. static int sprd_rtc_check_power_down(struct sprd_rtc *rtc)
  471. {
  472. u32 val;
  473. int ret;
  474. ret = regmap_read(rtc->regmap, rtc->base + SPRD_RTC_SPG_VALUE, &val);
  475. if (ret)
  476. return ret;
  477. /*
  478. * If the SPRD_RTC_POWER_RESET_FLAG was not set, which means the RTC has
  479. * been powered down, so the RTC time values are invalid.
  480. */
  481. rtc->valid = (val & SPRD_RTC_POWER_RESET_FLAG) ? true : false;
  482. return 0;
  483. }
  484. static int sprd_rtc_probe(struct platform_device *pdev)
  485. {
  486. struct device_node *node = pdev->dev.of_node;
  487. struct sprd_rtc *rtc;
  488. int ret;
  489. rtc = devm_kzalloc(&pdev->dev, sizeof(*rtc), GFP_KERNEL);
  490. if (!rtc)
  491. return -ENOMEM;
  492. rtc->regmap = dev_get_regmap(pdev->dev.parent, NULL);
  493. if (!rtc->regmap)
  494. return -ENODEV;
  495. ret = of_property_read_u32(node, "reg", &rtc->base);
  496. if (ret) {
  497. dev_err(&pdev->dev, "failed to get RTC base address\n");
  498. return ret;
  499. }
  500. rtc->irq = platform_get_irq(pdev, 0);
  501. if (rtc->irq < 0) {
  502. dev_err(&pdev->dev, "failed to get RTC irq number\n");
  503. return rtc->irq;
  504. }
  505. rtc->dev = &pdev->dev;
  506. platform_set_drvdata(pdev, rtc);
  507. /* clear all RTC interrupts and disable all RTC interrupts */
  508. ret = sprd_rtc_disable_ints(rtc);
  509. if (ret) {
  510. dev_err(&pdev->dev, "failed to disable RTC interrupts\n");
  511. return ret;
  512. }
  513. /* check if RTC time values are valid */
  514. ret = sprd_rtc_check_power_down(rtc);
  515. if (ret) {
  516. dev_err(&pdev->dev, "failed to check RTC time values\n");
  517. return ret;
  518. }
  519. ret = devm_request_threaded_irq(&pdev->dev, rtc->irq, NULL,
  520. sprd_rtc_handler,
  521. IRQF_ONESHOT | IRQF_EARLY_RESUME,
  522. pdev->name, rtc);
  523. if (ret < 0) {
  524. dev_err(&pdev->dev, "failed to request RTC irq\n");
  525. return ret;
  526. }
  527. rtc->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
  528. &sprd_rtc_ops, THIS_MODULE);
  529. if (IS_ERR(rtc->rtc))
  530. return PTR_ERR(rtc->rtc);
  531. device_init_wakeup(&pdev->dev, 1);
  532. return 0;
  533. }
  534. static int sprd_rtc_remove(struct platform_device *pdev)
  535. {
  536. device_init_wakeup(&pdev->dev, 0);
  537. return 0;
  538. }
  539. static const struct of_device_id sprd_rtc_of_match[] = {
  540. { .compatible = "sprd,sc2731-rtc", },
  541. { },
  542. };
  543. MODULE_DEVICE_TABLE(of, sprd_rtc_of_match);
  544. static struct platform_driver sprd_rtc_driver = {
  545. .driver = {
  546. .name = "sprd-rtc",
  547. .of_match_table = sprd_rtc_of_match,
  548. },
  549. .probe = sprd_rtc_probe,
  550. .remove = sprd_rtc_remove,
  551. };
  552. module_platform_driver(sprd_rtc_driver);
  553. MODULE_LICENSE("GPL v2");
  554. MODULE_DESCRIPTION("Spreadtrum RTC Device Driver");
  555. MODULE_AUTHOR("Baolin Wang <baolin.wang@spreadtrum.com>");