]> git.sur5r.net Git - u-boot/blob - drivers/rtc/rx8010sj.c
Merge branch 'master' of git://git.denx.de/u-boot-sunxi
[u-boot] / drivers / rtc / rx8010sj.c
1 /*
2  * Epson RX8010 RTC driver.
3  *
4  * Copyright (c) 2017, General Electric Company
5  *
6  * This program is free software; you can redistribute it and/or modify it
7  * under the terms and conditions of the GNU General Public License,
8  * version 2, as published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope it will be useful, but WITHOUT
11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
13  * more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
17  */
18
19 #include <command.h>
20 #include <common.h>
21 #include <dm.h>
22 #include <i2c.h>
23 #include <rtc.h>
24
25 /*---------------------------------------------------------------------*/
26 /* #undef DEBUG_RTC */
27
28 #ifdef DEBUG_RTC
29 #define DEBUGR(fmt, args...) printf(fmt, ##args)
30 #else
31 #define DEBUGR(fmt, args...)
32 #endif
33 /*---------------------------------------------------------------------*/
34
35 #ifndef CONFIG_SYS_I2C_RTC_ADDR
36 # define CONFIG_SYS_I2C_RTC_ADDR        0x32
37 #endif
38
39 /*
40  * RTC register addresses
41  */
42 #define RX8010_SEC     0x10
43 #define RX8010_MIN     0x11
44 #define RX8010_HOUR    0x12
45 #define RX8010_WDAY    0x13
46 #define RX8010_MDAY    0x14
47 #define RX8010_MONTH   0x15
48 #define RX8010_YEAR    0x16
49 #define RX8010_YEAR    0x16
50 #define RX8010_RESV17  0x17
51 #define RX8010_ALMIN   0x18
52 #define RX8010_ALHOUR  0x19
53 #define RX8010_ALWDAY  0x1A
54 #define RX8010_TCOUNT0 0x1B
55 #define RX8010_TCOUNT1 0x1C
56 #define RX8010_EXT     0x1D
57 #define RX8010_FLAG    0x1E
58 #define RX8010_CTRL    0x1F
59 /* 0x20 to 0x2F are user registers */
60 #define RX8010_RESV30  0x30
61 #define RX8010_RESV31  0x32
62 #define RX8010_IRQ     0x32
63
64 #define RX8010_EXT_WADA  BIT(3)
65
66 #define RX8010_FLAG_VLF  BIT(1)
67 #define RX8010_FLAG_AF   BIT(3)
68 #define RX8010_FLAG_TF   BIT(4)
69 #define RX8010_FLAG_UF   BIT(5)
70
71 #define RX8010_CTRL_AIE  BIT(3)
72 #define RX8010_CTRL_UIE  BIT(5)
73 #define RX8010_CTRL_STOP BIT(6)
74 #define RX8010_CTRL_TEST BIT(7)
75
76 #define RX8010_ALARM_AE  BIT(7)
77
78 #ifdef CONFIG_DM_RTC
79
80 #define DEV_TYPE struct udevice
81
82 #else
83
84 /* Local udevice */
85 struct ludevice {
86         u8 chip;
87 };
88
89 #define DEV_TYPE struct ludevice
90
91 #endif
92
93 static int rx8010sj_rtc_read8(DEV_TYPE *dev, unsigned int reg)
94 {
95         u8 val;
96         int ret;
97
98 #ifdef CONFIG_DM_RTC
99         ret = dm_i2c_read(dev, reg, &val, sizeof(val));
100 #else
101         ret = i2c_read(dev->chip, reg, 1, &val, 1);
102 #endif
103
104         return ret < 0 ? ret : val;
105 }
106
107 static int rx8010sj_rtc_write8(DEV_TYPE *dev, unsigned int reg, int val)
108 {
109         int ret;
110         u8 lval = val;
111
112 #ifdef CONFIG_DM_RTC
113         ret = dm_i2c_write(dev, reg, &lval, 1);
114 #else
115         ret = i2c_write(dev->chip, reg, 1, &lval, 1);
116 #endif
117
118         return ret < 0 ? ret : 0;
119 }
120
121 static int validate_time(const struct rtc_time *tm)
122 {
123         if ((tm->tm_year < 2000) || (tm->tm_year > 2099))
124                 return -EINVAL;
125
126         if ((tm->tm_mon < 1) || (tm->tm_mon > 12))
127                 return -EINVAL;
128
129         if ((tm->tm_mday < 1) || (tm->tm_mday > 31))
130                 return -EINVAL;
131
132         if ((tm->tm_wday < 0) || (tm->tm_wday > 6))
133                 return -EINVAL;
134
135         if ((tm->tm_hour < 0) || (tm->tm_hour > 23))
136                 return -EINVAL;
137
138         if ((tm->tm_min < 0) || (tm->tm_min > 59))
139                 return -EINVAL;
140
141         if ((tm->tm_sec < 0) || (tm->tm_sec > 59))
142                 return -EINVAL;
143
144         return 0;
145 }
146
147 void rx8010sj_rtc_init(DEV_TYPE *dev)
148 {
149         u8 ctrl[2];
150         int need_clear = 0, ret = 0;
151
152         /* Initialize reserved registers as specified in datasheet */
153         ret = rx8010sj_rtc_write8(dev, RX8010_RESV17, 0xD8);
154         if (ret < 0)
155                 goto error;
156
157         ret = rx8010sj_rtc_write8(dev, RX8010_RESV30, 0x00);
158         if (ret < 0)
159                 goto error;
160
161         ret = rx8010sj_rtc_write8(dev, RX8010_RESV31, 0x08);
162         if (ret < 0)
163                 goto error;
164
165         ret = rx8010sj_rtc_write8(dev, RX8010_IRQ, 0x00);
166         if (ret < 0)
167                 goto error;
168
169         for (int i = 0; i < 2; i++) {
170                 ret = rx8010sj_rtc_read8(dev, RX8010_FLAG + i);
171                 if (ret < 0)
172                         goto error;
173
174                 ctrl[i] = ret;
175         }
176
177         if (ctrl[0] & RX8010_FLAG_VLF)
178                 printf("RTC low voltage detected\n");
179
180         if (ctrl[0] & RX8010_FLAG_AF) {
181                 printf("Alarm was detected\n");
182                 need_clear = 1;
183         }
184
185         if (ctrl[0] & RX8010_FLAG_TF)
186                 need_clear = 1;
187
188         if (ctrl[0] & RX8010_FLAG_UF)
189                 need_clear = 1;
190
191         if (need_clear) {
192                 ctrl[0] &= ~(RX8010_FLAG_AF | RX8010_FLAG_TF | RX8010_FLAG_UF);
193                 ret = rx8010sj_rtc_write8(dev, RX8010_FLAG, ctrl[0]);
194                 if (ret < 0)
195                         goto error;
196         }
197
198         return;
199
200 error:
201         printf("Error rtc init.\n");
202 }
203
204 /* Get the current time from the RTC */
205 static int rx8010sj_rtc_get(DEV_TYPE *dev, struct rtc_time *tmp)
206 {
207         u8 date[7];
208         int flagreg;
209         int ret;
210
211         flagreg = rx8010sj_rtc_read8(dev, RX8010_FLAG);
212         if (flagreg < 0) {
213                 DEBUGR("Error reading from RTC. err: %d\n", flagreg);
214                 return -EIO;
215         }
216
217         if (flagreg & RX8010_FLAG_VLF) {
218                 DEBUGR("RTC low voltage detected\n");
219                 return -EINVAL;
220         }
221
222         for (int i = 0; i < 7; i++) {
223                 ret = rx8010sj_rtc_read8(dev, RX8010_SEC + i);
224                 if (ret < 0) {
225                         DEBUGR("Error reading from RTC. err: %d\n", ret);
226                         return -EIO;
227                 }
228                 date[i] = ret;
229         }
230
231         tmp->tm_sec = bcd2bin(date[RX8010_SEC - RX8010_SEC] & 0x7f);
232         tmp->tm_min = bcd2bin(date[RX8010_MIN - RX8010_SEC] & 0x7f);
233         tmp->tm_hour = bcd2bin(date[RX8010_HOUR - RX8010_SEC] & 0x3f);
234         tmp->tm_mday = bcd2bin(date[RX8010_MDAY - RX8010_SEC] & 0x3f);
235         tmp->tm_mon = bcd2bin(date[RX8010_MONTH - RX8010_SEC] & 0x1f);
236         tmp->tm_year = bcd2bin(date[RX8010_YEAR - RX8010_SEC]) + 2000;
237         tmp->tm_wday = 0;
238         tmp->tm_yday = 0;
239         tmp->tm_isdst = 0;
240
241         DEBUGR("Get DATE: %4d-%02d-%02d (wday=%d)  TIME: %2d:%02d:%02d\n",
242                tmp->tm_year, tmp->tm_mon, tmp->tm_mday, tmp->tm_wday,
243                tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
244
245         return 0;
246 }
247
248 /* Set the RTC */
249 static int rx8010sj_rtc_set(DEV_TYPE *dev, const struct rtc_time *tm)
250 {
251         u8 date[7];
252         int ctrl, flagreg;
253         int ret;
254
255         ret = validate_time(tm);
256         if (ret < 0)
257                 return -EINVAL;
258
259         /* set STOP bit before changing clock/calendar */
260         ctrl = rx8010sj_rtc_read8(dev, RX8010_CTRL);
261         if (ctrl < 0)
262                 return ctrl;
263         ret = rx8010sj_rtc_write8(dev, RX8010_CTRL, ctrl | RX8010_CTRL_STOP);
264         if (ret < 0)
265                 return ret;
266
267         date[RX8010_SEC - RX8010_SEC] = bin2bcd(tm->tm_sec);
268         date[RX8010_MIN - RX8010_SEC] = bin2bcd(tm->tm_min);
269         date[RX8010_HOUR - RX8010_SEC] = bin2bcd(tm->tm_hour);
270         date[RX8010_MDAY - RX8010_SEC] = bin2bcd(tm->tm_mday);
271         date[RX8010_MONTH - RX8010_SEC] = bin2bcd(tm->tm_mon);
272         date[RX8010_YEAR - RX8010_SEC] = bin2bcd(tm->tm_year - 2000);
273         date[RX8010_WDAY - RX8010_SEC] = bin2bcd(tm->tm_wday);
274
275         for (int i = 0; i < 7; i++) {
276                 ret = rx8010sj_rtc_write8(dev, RX8010_SEC + i, date[i]);
277                 if (ret < 0) {
278                         DEBUGR("Error writing to RTC. err: %d\n", ret);
279                         return -EIO;
280                 }
281         }
282
283         /* clear STOP bit after changing clock/calendar */
284         ctrl = rx8010sj_rtc_read8(dev, RX8010_CTRL);
285         if (ctrl < 0)
286                 return ctrl;
287
288         ret = rx8010sj_rtc_write8(dev, RX8010_CTRL, ctrl & ~RX8010_CTRL_STOP);
289         if (ret < 0)
290                 return ret;
291
292         flagreg = rx8010sj_rtc_read8(dev, RX8010_FLAG);
293         if (flagreg < 0)
294                 return flagreg;
295
296         if (flagreg & RX8010_FLAG_VLF)
297                 ret = rx8010sj_rtc_write8(dev, RX8010_FLAG,
298                                           flagreg & ~RX8010_FLAG_VLF);
299
300         return 0;
301 }
302
303 /* Reset the RTC. */
304 static int rx8010sj_rtc_reset(DEV_TYPE *dev)
305 {
306         /* Not needed */
307         return 0;
308 }
309
310 #ifndef CONFIG_DM_RTC
311
312 int rtc_get(struct rtc_time *tm)
313 {
314         struct ludevice dev = {
315                         .chip = CONFIG_SYS_I2C_RTC_ADDR,
316         };
317
318         return rx8010sj_rtc_get(&dev, tm);
319 }
320
321 int rtc_set(struct rtc_time *tm)
322 {
323         struct ludevice dev = {
324                         .chip = CONFIG_SYS_I2C_RTC_ADDR,
325         };
326
327         return rx8010sj_rtc_set(&dev, tm);
328 }
329
330 void rtc_reset(void)
331 {
332         struct ludevice dev = {
333                         .chip = CONFIG_SYS_I2C_RTC_ADDR,
334         };
335
336         rx8010sj_rtc_reset(&dev);
337 }
338
339 void rtc_init(void)
340 {
341         struct ludevice dev = {
342                         .chip = CONFIG_SYS_I2C_RTC_ADDR,
343         };
344
345         rx8010sj_rtc_init(&dev);
346 }
347
348 #else
349
350 static int rx8010sj_probe(struct udevice *dev)
351 {
352         rx8010sj_rtc_init(&dev);
353
354         return 0;
355 }
356
357 static const struct rtc_ops rx8010sj_rtc_ops = {
358         .get = rx8010sj_rtc_get,
359         .set = rx8010sj_rtc_set,
360         .read8 = rx8010sj_rtc_read8,
361         .write8 = rx8010sj_rtc_write8,
362         .reset = rx8010sj_rtc_reset,
363 };
364
365 static const struct udevice_id rx8010sj_rtc_ids[] = {
366         { .compatible = "epson,rx8010sj-rtc" },
367         { }
368 };
369
370 U_BOOT_DRIVER(rx8010sj_rtc) = {
371         .name     = "rx8010sj_rtc",
372         .id           = UCLASS_RTC,
373         .probe    = rx8010sj_probe,
374         .of_match = rx8010sj_rtc_ids,
375         .ops      = &rx8010sj_rtc_ops,
376 };
377
378 #endif