Commit | Line | Data |
---|---|---|
2874c5fd | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
fef931ff AJ |
2 | /* |
3 | * Real time clock driver for DA9052 | |
4 | * | |
5 | * Copyright(c) 2012 Dialog Semiconductor Ltd. | |
6 | * | |
7 | * Author: Dajun Dajun Chen <dajun.chen@diasemi.com> | |
fef931ff AJ |
8 | */ |
9 | ||
10 | #include <linux/module.h> | |
11 | #include <linux/platform_device.h> | |
12 | #include <linux/rtc.h> | |
11f54d05 | 13 | #include <linux/err.h> |
03cc1625 | 14 | #include <linux/delay.h> |
fef931ff AJ |
15 | |
16 | #include <linux/mfd/da9052/da9052.h> | |
17 | #include <linux/mfd/da9052/reg.h> | |
18 | ||
7c994c08 AO |
19 | #define rtc_err(rtc, fmt, ...) \ |
20 | dev_err(rtc->da9052->dev, "%s: " fmt, __func__, ##__VA_ARGS__) | |
fef931ff | 21 | |
03cc1625 AW |
22 | #define DA9052_GET_TIME_RETRIES 5 |
23 | ||
fef931ff AJ |
24 | struct da9052_rtc { |
25 | struct rtc_device *rtc; | |
26 | struct da9052 *da9052; | |
fef931ff AJ |
27 | }; |
28 | ||
7c994c08 | 29 | static int da9052_rtc_enable_alarm(struct da9052_rtc *rtc, bool enable) |
fef931ff AJ |
30 | { |
31 | int ret; | |
32 | if (enable) { | |
7c994c08 AO |
33 | ret = da9052_reg_update(rtc->da9052, DA9052_ALARM_Y_REG, |
34 | DA9052_ALARM_Y_ALARM_ON|DA9052_ALARM_Y_TICK_ON, | |
35 | DA9052_ALARM_Y_ALARM_ON); | |
fef931ff | 36 | if (ret != 0) |
7c994c08 | 37 | rtc_err(rtc, "Failed to enable ALM: %d\n", ret); |
fef931ff | 38 | } else { |
7c994c08 AO |
39 | ret = da9052_reg_update(rtc->da9052, DA9052_ALARM_Y_REG, |
40 | DA9052_ALARM_Y_ALARM_ON|DA9052_ALARM_Y_TICK_ON, 0); | |
fef931ff | 41 | if (ret != 0) |
7c994c08 | 42 | rtc_err(rtc, "Write error: %d\n", ret); |
fef931ff AJ |
43 | } |
44 | return ret; | |
45 | } | |
46 | ||
47 | static irqreturn_t da9052_rtc_irq(int irq, void *data) | |
48 | { | |
49 | struct da9052_rtc *rtc = data; | |
fef931ff | 50 | |
7c994c08 | 51 | rtc_update_irq(rtc->rtc, 1, RTC_IRQF | RTC_AF); |
fef931ff AJ |
52 | |
53 | return IRQ_HANDLED; | |
54 | } | |
55 | ||
7c994c08 | 56 | static int da9052_read_alarm(struct da9052_rtc *rtc, struct rtc_time *rtc_tm) |
fef931ff AJ |
57 | { |
58 | int ret; | |
03cc1625 AW |
59 | uint8_t v[2][5]; |
60 | int idx = 1; | |
61 | int timeout = DA9052_GET_TIME_RETRIES; | |
fef931ff | 62 | |
03cc1625 AW |
63 | ret = da9052_group_read(rtc->da9052, DA9052_ALARM_MI_REG, 5, &v[0][0]); |
64 | if (ret) { | |
7c994c08 | 65 | rtc_err(rtc, "Failed to group read ALM: %d\n", ret); |
fef931ff AJ |
66 | return ret; |
67 | } | |
68 | ||
03cc1625 AW |
69 | do { |
70 | ret = da9052_group_read(rtc->da9052, | |
71 | DA9052_ALARM_MI_REG, 5, &v[idx][0]); | |
72 | if (ret) { | |
73 | rtc_err(rtc, "Failed to group read ALM: %d\n", ret); | |
74 | return ret; | |
75 | } | |
fef931ff | 76 | |
03cc1625 AW |
77 | if (memcmp(&v[0][0], &v[1][0], 5) == 0) { |
78 | rtc_tm->tm_year = (v[0][4] & DA9052_RTC_YEAR) + 100; | |
79 | rtc_tm->tm_mon = (v[0][3] & DA9052_RTC_MONTH) - 1; | |
80 | rtc_tm->tm_mday = v[0][2] & DA9052_RTC_DAY; | |
81 | rtc_tm->tm_hour = v[0][1] & DA9052_RTC_HOUR; | |
82 | rtc_tm->tm_min = v[0][0] & DA9052_RTC_MIN; | |
d2c92705 | 83 | rtc_tm->tm_sec = 0; |
03cc1625 AW |
84 | |
85 | ret = rtc_valid_tm(rtc_tm); | |
86 | return ret; | |
87 | } | |
88 | ||
89 | idx = (1-idx); | |
90 | msleep(20); | |
91 | ||
92 | } while (timeout--); | |
93 | ||
94 | rtc_err(rtc, "Timed out reading alarm time\n"); | |
95 | ||
96 | return -EIO; | |
fef931ff AJ |
97 | } |
98 | ||
7c994c08 | 99 | static int da9052_set_alarm(struct da9052_rtc *rtc, struct rtc_time *rtc_tm) |
fef931ff | 100 | { |
7c994c08 AO |
101 | struct da9052 *da9052 = rtc->da9052; |
102 | unsigned long alm_time; | |
fef931ff AJ |
103 | int ret; |
104 | uint8_t v[3]; | |
105 | ||
7c994c08 AO |
106 | ret = rtc_tm_to_time(rtc_tm, &alm_time); |
107 | if (ret != 0) | |
108 | return ret; | |
109 | ||
110 | if (rtc_tm->tm_sec > 0) { | |
111 | alm_time += 60 - rtc_tm->tm_sec; | |
112 | rtc_time_to_tm(alm_time, rtc_tm); | |
113 | } | |
114 | BUG_ON(rtc_tm->tm_sec); /* it will cause repeated irqs if not zero */ | |
115 | ||
fef931ff AJ |
116 | rtc_tm->tm_year -= 100; |
117 | rtc_tm->tm_mon += 1; | |
118 | ||
119 | ret = da9052_reg_update(da9052, DA9052_ALARM_MI_REG, | |
120 | DA9052_RTC_MIN, rtc_tm->tm_min); | |
121 | if (ret != 0) { | |
7c994c08 | 122 | rtc_err(rtc, "Failed to write ALRM MIN: %d\n", ret); |
fef931ff AJ |
123 | return ret; |
124 | } | |
125 | ||
126 | v[0] = rtc_tm->tm_hour; | |
127 | v[1] = rtc_tm->tm_mday; | |
128 | v[2] = rtc_tm->tm_mon; | |
129 | ||
130 | ret = da9052_group_write(da9052, DA9052_ALARM_H_REG, 3, v); | |
131 | if (ret < 0) | |
132 | return ret; | |
133 | ||
134 | ret = da9052_reg_update(da9052, DA9052_ALARM_Y_REG, | |
135 | DA9052_RTC_YEAR, rtc_tm->tm_year); | |
136 | if (ret != 0) | |
7c994c08 | 137 | rtc_err(rtc, "Failed to write ALRM YEAR: %d\n", ret); |
fef931ff AJ |
138 | |
139 | return ret; | |
140 | } | |
141 | ||
7c994c08 | 142 | static int da9052_rtc_get_alarm_status(struct da9052_rtc *rtc) |
fef931ff AJ |
143 | { |
144 | int ret; | |
145 | ||
7c994c08 | 146 | ret = da9052_reg_read(rtc->da9052, DA9052_ALARM_Y_REG); |
fef931ff | 147 | if (ret < 0) { |
7c994c08 | 148 | rtc_err(rtc, "Failed to read ALM: %d\n", ret); |
fef931ff AJ |
149 | return ret; |
150 | } | |
7c994c08 AO |
151 | |
152 | return !!(ret&DA9052_ALARM_Y_ALARM_ON); | |
fef931ff AJ |
153 | } |
154 | ||
155 | static int da9052_rtc_read_time(struct device *dev, struct rtc_time *rtc_tm) | |
156 | { | |
157 | struct da9052_rtc *rtc = dev_get_drvdata(dev); | |
fef931ff | 158 | int ret; |
03cc1625 AW |
159 | uint8_t v[2][6]; |
160 | int idx = 1; | |
161 | int timeout = DA9052_GET_TIME_RETRIES; | |
fef931ff | 162 | |
03cc1625 AW |
163 | ret = da9052_group_read(rtc->da9052, DA9052_COUNT_S_REG, 6, &v[0][0]); |
164 | if (ret) { | |
7c994c08 | 165 | rtc_err(rtc, "Failed to read RTC time : %d\n", ret); |
fef931ff AJ |
166 | return ret; |
167 | } | |
168 | ||
03cc1625 AW |
169 | do { |
170 | ret = da9052_group_read(rtc->da9052, | |
171 | DA9052_COUNT_S_REG, 6, &v[idx][0]); | |
172 | if (ret) { | |
173 | rtc_err(rtc, "Failed to read RTC time : %d\n", ret); | |
174 | return ret; | |
175 | } | |
fef931ff | 176 | |
03cc1625 AW |
177 | if (memcmp(&v[0][0], &v[1][0], 6) == 0) { |
178 | rtc_tm->tm_year = (v[0][5] & DA9052_RTC_YEAR) + 100; | |
179 | rtc_tm->tm_mon = (v[0][4] & DA9052_RTC_MONTH) - 1; | |
180 | rtc_tm->tm_mday = v[0][3] & DA9052_RTC_DAY; | |
181 | rtc_tm->tm_hour = v[0][2] & DA9052_RTC_HOUR; | |
182 | rtc_tm->tm_min = v[0][1] & DA9052_RTC_MIN; | |
183 | rtc_tm->tm_sec = v[0][0] & DA9052_RTC_SEC; | |
184 | ||
bb54be13 | 185 | return 0; |
03cc1625 AW |
186 | } |
187 | ||
188 | idx = (1-idx); | |
189 | msleep(20); | |
190 | ||
191 | } while (timeout--); | |
192 | ||
193 | rtc_err(rtc, "Timed out reading time\n"); | |
194 | ||
195 | return -EIO; | |
fef931ff AJ |
196 | } |
197 | ||
198 | static int da9052_rtc_set_time(struct device *dev, struct rtc_time *tm) | |
199 | { | |
200 | struct da9052_rtc *rtc; | |
201 | uint8_t v[6]; | |
7c994c08 | 202 | int ret; |
fef931ff | 203 | |
ae824c48 AW |
204 | /* DA9052 only has 6 bits for year - to represent 2000-2063 */ |
205 | if ((tm->tm_year < 100) || (tm->tm_year > 163)) | |
206 | return -EINVAL; | |
207 | ||
fef931ff AJ |
208 | rtc = dev_get_drvdata(dev); |
209 | ||
210 | v[0] = tm->tm_sec; | |
211 | v[1] = tm->tm_min; | |
212 | v[2] = tm->tm_hour; | |
213 | v[3] = tm->tm_mday; | |
214 | v[4] = tm->tm_mon + 1; | |
215 | v[5] = tm->tm_year - 100; | |
216 | ||
7c994c08 AO |
217 | ret = da9052_group_write(rtc->da9052, DA9052_COUNT_S_REG, 6, v); |
218 | if (ret < 0) | |
219 | rtc_err(rtc, "failed to set RTC time: %d\n", ret); | |
220 | return ret; | |
fef931ff AJ |
221 | } |
222 | ||
223 | static int da9052_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm) | |
224 | { | |
225 | int ret; | |
226 | struct rtc_time *tm = &alrm->time; | |
227 | struct da9052_rtc *rtc = dev_get_drvdata(dev); | |
228 | ||
7c994c08 AO |
229 | ret = da9052_read_alarm(rtc, tm); |
230 | if (ret < 0) { | |
231 | rtc_err(rtc, "failed to read RTC alarm: %d\n", ret); | |
fef931ff | 232 | return ret; |
7c994c08 | 233 | } |
fef931ff | 234 | |
7c994c08 | 235 | alrm->enabled = da9052_rtc_get_alarm_status(rtc); |
fef931ff AJ |
236 | return 0; |
237 | } | |
238 | ||
239 | static int da9052_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm) | |
240 | { | |
241 | int ret; | |
242 | struct rtc_time *tm = &alrm->time; | |
243 | struct da9052_rtc *rtc = dev_get_drvdata(dev); | |
244 | ||
ae824c48 AW |
245 | /* DA9052 only has 6 bits for year - to represent 2000-2063 */ |
246 | if ((tm->tm_year < 100) || (tm->tm_year > 163)) | |
247 | return -EINVAL; | |
248 | ||
7c994c08 | 249 | ret = da9052_rtc_enable_alarm(rtc, 0); |
fef931ff AJ |
250 | if (ret < 0) |
251 | return ret; | |
252 | ||
7c994c08 AO |
253 | ret = da9052_set_alarm(rtc, tm); |
254 | if (ret < 0) | |
fef931ff AJ |
255 | return ret; |
256 | ||
7c994c08 | 257 | ret = da9052_rtc_enable_alarm(rtc, 1); |
fef931ff AJ |
258 | return ret; |
259 | } | |
260 | ||
261 | static int da9052_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled) | |
262 | { | |
263 | struct da9052_rtc *rtc = dev_get_drvdata(dev); | |
264 | ||
7c994c08 | 265 | return da9052_rtc_enable_alarm(rtc, enabled); |
fef931ff AJ |
266 | } |
267 | ||
268 | static const struct rtc_class_ops da9052_rtc_ops = { | |
269 | .read_time = da9052_rtc_read_time, | |
270 | .set_time = da9052_rtc_set_time, | |
271 | .read_alarm = da9052_rtc_read_alarm, | |
272 | .set_alarm = da9052_rtc_set_alarm, | |
273 | .alarm_irq_enable = da9052_rtc_alarm_irq_enable, | |
274 | }; | |
275 | ||
5a167f45 | 276 | static int da9052_rtc_probe(struct platform_device *pdev) |
fef931ff AJ |
277 | { |
278 | struct da9052_rtc *rtc; | |
279 | int ret; | |
280 | ||
281 | rtc = devm_kzalloc(&pdev->dev, sizeof(struct da9052_rtc), GFP_KERNEL); | |
282 | if (!rtc) | |
283 | return -ENOMEM; | |
284 | ||
285 | rtc->da9052 = dev_get_drvdata(pdev->dev.parent); | |
286 | platform_set_drvdata(pdev, rtc); | |
7c994c08 AO |
287 | |
288 | ret = da9052_reg_write(rtc->da9052, DA9052_BBAT_CONT_REG, 0xFE); | |
289 | if (ret < 0) { | |
290 | rtc_err(rtc, | |
291 | "Failed to setup RTC battery charging: %d\n", ret); | |
292 | return ret; | |
293 | } | |
294 | ||
295 | ret = da9052_reg_update(rtc->da9052, DA9052_ALARM_Y_REG, | |
296 | DA9052_ALARM_Y_TICK_ON, 0); | |
297 | if (ret != 0) | |
298 | rtc_err(rtc, "Failed to disable TICKS: %d\n", ret); | |
299 | ||
6406d96e ST |
300 | device_init_wakeup(&pdev->dev, true); |
301 | rtc->rtc = devm_rtc_device_register(&pdev->dev, pdev->name, | |
302 | &da9052_rtc_ops, THIS_MODULE); | |
303 | ||
304 | if (IS_ERR(rtc->rtc)) | |
305 | return PTR_ERR(rtc->rtc); | |
306 | ||
c2c0eed7 | 307 | ret = da9052_request_irq(rtc->da9052, DA9052_IRQ_ALARM, "ALM", |
925e8ea6 | 308 | da9052_rtc_irq, rtc); |
fef931ff | 309 | if (ret != 0) { |
7c994c08 | 310 | rtc_err(rtc, "irq registration failed: %d\n", ret); |
007def04 | 311 | return ret; |
fef931ff AJ |
312 | } |
313 | ||
6406d96e | 314 | return 0; |
fef931ff AJ |
315 | } |
316 | ||
fef931ff AJ |
317 | static struct platform_driver da9052_rtc_driver = { |
318 | .probe = da9052_rtc_probe, | |
fef931ff AJ |
319 | .driver = { |
320 | .name = "da9052-rtc", | |
fef931ff AJ |
321 | }, |
322 | }; | |
323 | ||
324 | module_platform_driver(da9052_rtc_driver); | |
325 | ||
7c994c08 | 326 | MODULE_AUTHOR("Anthony Olech <Anthony.Olech@diasemi.com>"); |
fef931ff AJ |
327 | MODULE_DESCRIPTION("RTC driver for Dialog DA9052 PMIC"); |
328 | MODULE_LICENSE("GPL"); | |
329 | MODULE_ALIAS("platform:da9052-rtc"); |