board: stm32mp1: fixup the usb product id for USB download gadget
[oweals/u-boot.git] / drivers / rtc / s35392a.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * SII Semiconductor Corporation S35392A RTC driver.
4  *
5  * Copyright (c) 2017, General Electric Company
6  *
7  * This program is free software; you can redistribute it and/or modify it
8  * under the terms and conditions of the GNU General Public License,
9  * version 2, as published by the Free Software Foundation.
10  *
11  * This program is distributed in the hope it will be useful, but WITHOUT
12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
14  * more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
18  */
19
20 #include <command.h>
21 #include <common.h>
22 #include <dm.h>
23 #include <i2c.h>
24 #include <linux/bitrev.h>
25 #include <rtc.h>
26
27 #define S35390A_CMD_STATUS1             0x30
28 #define S35390A_CMD_STATUS2             0x31
29 #define S35390A_CMD_TIME1               0x32
30 #define S35390A_CMD_TIME2               0x33
31 #define S35390A_CMD_INT2_REG1   0x35
32
33 #define S35390A_BYTE_YEAR       0
34 #define S35390A_BYTE_MONTH      1
35 #define S35390A_BYTE_DAY        2
36 #define S35390A_BYTE_WDAY       3
37 #define S35390A_BYTE_HOURS      4
38 #define S35390A_BYTE_MINS       5
39 #define S35390A_BYTE_SECS       6
40
41 /* flags for STATUS1 */
42 #define S35390A_FLAG_POC        0x01
43 #define S35390A_FLAG_BLD        0x02
44 #define S35390A_FLAG_INT2       0x04
45 #define S35390A_FLAG_24H        0x40
46 #define S35390A_FLAG_RESET      0x80
47
48 /*
49  * If either BLD or POC is set, then the chip has lost power long enough for
50  * the time value to become invalid.
51  */
52 #define S35390A_LOW_VOLTAGE (S35390A_FLAG_POC | S35390A_FLAG_BLD)
53
54 /*---------------------------------------------------------------------*/
55 #undef DEBUG_RTC
56
57 #ifdef DEBUG_RTC
58 #define DEBUGR(fmt, args...) printf(fmt, ##args)
59 #else
60 #define DEBUGR(fmt, args...)
61 #endif
62 /*---------------------------------------------------------------------*/
63
64 #ifdef CONFIG_DM_RTC
65 #define DEV_TYPE struct udevice
66 #else
67 /* Local udevice */
68 struct ludevice {
69         u8 chip;
70 };
71
72 #define DEV_TYPE struct ludevice
73 struct ludevice dev;
74
75 #endif
76
77 #define msleep(a) udelay(a * 1000)
78
79 int lowvoltage;
80
81 static int s35392a_rtc_reset(DEV_TYPE *dev);
82
83 static int s35392a_rtc_read(DEV_TYPE *dev, u8 reg, u8 *buf, int len)
84 {
85         int ret;
86
87 #ifdef CONFIG_DM_RTC
88         /* TODO: we need to tweak the chip address to reg */
89         ret = dm_i2c_read(dev, 0, buf, len);
90 #else
91         (void)dev;
92         ret = i2c_read(reg, 0, -1, buf, len);
93 #endif
94
95         return ret;
96 }
97
98 static int s35392a_rtc_write(DEV_TYPE *dev, u8 reg, u8 *buf, int len)
99 {
100         int ret;
101
102 #ifdef CONFIG_DM_RTC
103         /* TODO: we need to tweak the chip address to reg */
104         ret = dm_i2c_write(dev, 0, buf, 1);
105 #else
106         (void)dev;
107         ret = i2c_write(reg, 0, 0, buf, len);
108 #endif
109
110         return ret;
111 }
112
113 static int s35392a_rtc_read8(DEV_TYPE *dev, unsigned int reg)
114 {
115         u8 val;
116         int ret;
117
118         ret = s35392a_rtc_read(dev, reg, &val, sizeof(val));
119         return ret < 0 ? ret : val;
120 }
121
122 static int s35392a_rtc_write8(DEV_TYPE *dev, unsigned int reg, int val)
123 {
124         int ret;
125         u8 lval = val;
126
127         ret = s35392a_rtc_write(dev, reg, &lval, sizeof(lval));
128         return ret < 0 ? ret : 0;
129 }
130
131 static int validate_time(const struct rtc_time *tm)
132 {
133         if ((tm->tm_year < 2000) || (tm->tm_year > 2099))
134                 return -EINVAL;
135
136         if ((tm->tm_mon < 1) || (tm->tm_mon > 12))
137                 return -EINVAL;
138
139         if ((tm->tm_mday < 1) || (tm->tm_mday > 31))
140                 return -EINVAL;
141
142         if ((tm->tm_wday < 0) || (tm->tm_wday > 6))
143                 return -EINVAL;
144
145         if ((tm->tm_hour < 0) || (tm->tm_hour > 23))
146                 return -EINVAL;
147
148         if ((tm->tm_min < 0) || (tm->tm_min > 59))
149                 return -EINVAL;
150
151         if ((tm->tm_sec < 0) || (tm->tm_sec > 59))
152                 return -EINVAL;
153
154         return 0;
155 }
156
157 void s35392a_rtc_init(DEV_TYPE *dev)
158 {
159         int status;
160
161         status = s35392a_rtc_read8(dev, S35390A_CMD_STATUS1);
162         if (status < 0)
163                 goto error;
164
165         DEBUGR("init: S35390A_CMD_STATUS1: 0x%x\n", status);
166
167         lowvoltage = status & S35390A_LOW_VOLTAGE ? 1 : 0;
168
169         if (status & S35390A_FLAG_POC)
170                 /*
171                  * Do not communicate for 0.5 seconds since the power-on
172                  * detection circuit is in operation.
173                  */
174                 msleep(500);
175
176         else if (!lowvoltage)
177                 /*
178                  * If both POC and BLD are unset everything is fine.
179                  */
180                 return;
181
182         if (lowvoltage)
183                 printf("RTC low voltage detected\n");
184
185         if (!s35392a_rtc_reset(dev))
186                 return;
187
188 error:
189         printf("Error RTC init.\n");
190 }
191
192 /* Get the current time from the RTC */
193 static int s35392a_rtc_get(DEV_TYPE *dev, struct rtc_time *tm)
194 {
195         u8 date[7];
196         int ret, i;
197
198         if (lowvoltage) {
199                 DEBUGR("RTC low voltage detected\n");
200                 return -EINVAL;
201         }
202
203         ret = s35392a_rtc_read(dev, S35390A_CMD_TIME1, date, sizeof(date));
204         if (ret < 0) {
205                 DEBUGR("Error reading date from RTC\n");
206                 return -EIO;
207         }
208
209         /* This chip returns the bits of each byte in reverse order */
210         for (i = 0; i < 7; ++i)
211                 date[i] = bitrev8(date[i]);
212
213         tm->tm_sec  = bcd2bin(date[S35390A_BYTE_SECS]);
214         tm->tm_min  = bcd2bin(date[S35390A_BYTE_MINS]);
215         tm->tm_hour = bcd2bin(date[S35390A_BYTE_HOURS] & ~S35390A_FLAG_24H);
216         tm->tm_wday = bcd2bin(date[S35390A_BYTE_WDAY]);
217         tm->tm_mday = bcd2bin(date[S35390A_BYTE_DAY]);
218         tm->tm_mon  = bcd2bin(date[S35390A_BYTE_MONTH]);
219         tm->tm_year = bcd2bin(date[S35390A_BYTE_YEAR]) + 2000;
220
221         DEBUGR("Get DATE: %4d-%02d-%02d (wday=%d)  TIME: %2d:%02d:%02d\n",
222                tm->tm_year, tm->tm_mon, tm->tm_mday, tm->tm_wday,
223                tm->tm_hour, tm->tm_min, tm->tm_sec);
224
225         return 0;
226 }
227
228 /* Set the RTC */
229 static int s35392a_rtc_set(DEV_TYPE *dev, const struct rtc_time *tm)
230 {
231         int i, ret;
232         int status;
233         u8 date[7];
234
235         DEBUGR("Set DATE: %4d-%02d-%02d (wday=%d)  TIME: %2d:%02d:%02d\n",
236                tm->tm_year, tm->tm_mon, tm->tm_mday, tm->tm_wday,
237                tm->tm_hour, tm->tm_min, tm->tm_sec);
238
239         ret = validate_time(tm);
240         if (ret < 0)
241                 return -EINVAL;
242
243         /* We support only 24h mode */
244         ret = s35392a_rtc_read8(dev, S35390A_CMD_STATUS1);
245         if (ret < 0)
246                 return -EIO;
247         status = ret;
248
249         ret = s35392a_rtc_write8(dev, S35390A_CMD_STATUS1,
250                                  status | S35390A_FLAG_24H);
251         if (ret < 0)
252                 return -EIO;
253
254         date[S35390A_BYTE_YEAR]  = bin2bcd(tm->tm_year - 2000);
255         date[S35390A_BYTE_MONTH] = bin2bcd(tm->tm_mon);
256         date[S35390A_BYTE_DAY]   = bin2bcd(tm->tm_mday);
257         date[S35390A_BYTE_WDAY]  = bin2bcd(tm->tm_wday);
258         date[S35390A_BYTE_HOURS] = bin2bcd(tm->tm_hour);
259         date[S35390A_BYTE_MINS]  = bin2bcd(tm->tm_min);
260         date[S35390A_BYTE_SECS]  = bin2bcd(tm->tm_sec);
261
262         /* This chip expects the bits of each byte to be in reverse order */
263         for (i = 0; i < 7; ++i)
264                 date[i] = bitrev8(date[i]);
265
266         ret = s35392a_rtc_write(dev, S35390A_CMD_TIME1, date, sizeof(date));
267         if (ret < 0) {
268                 DEBUGR("Error writing date to RTC\n");
269                 return -EIO;
270         }
271
272         /* Now we have time. Reset the low voltage status */
273         lowvoltage = 0;
274
275         return 0;
276 }
277
278 /* Reset the RTC. */
279 static int s35392a_rtc_reset(DEV_TYPE *dev)
280 {
281         int buf;
282         int ret;
283         unsigned int initcount = 0;
284
285         buf = S35390A_FLAG_RESET;
286
287 initialize:
288         ret = s35392a_rtc_write8(dev, S35390A_CMD_STATUS1, buf);
289         if (ret < 0)
290                 return -EIO;
291
292         ret = s35392a_rtc_read8(dev, S35390A_CMD_STATUS1);
293         if (ret < 0)
294                 return -EIO;
295         buf = ret;
296
297         if (!lowvoltage)
298                 lowvoltage = buf & S35390A_LOW_VOLTAGE ? 1 : 0;
299
300         if (buf & S35390A_LOW_VOLTAGE) {
301                 /* Try up to five times to reset the chip */
302                 if (initcount < 5) {
303                         ++initcount;
304                         goto initialize;
305                 } else {
306                         return -EIO;
307                 }
308         }
309
310         return 0;
311 }
312
313 #ifndef CONFIG_DM_RTC
314
315 int rtc_get(struct rtc_time *tm)
316 {
317         return s35392a_rtc_get(&dev, tm);
318 }
319
320 int rtc_set(struct rtc_time *tm)
321 {
322         return s35392a_rtc_set(&dev, tm);
323 }
324
325 void rtc_reset(void)
326 {
327         s35392a_rtc_reset(&dev);
328 }
329
330 void rtc_init(void)
331 {
332         s35392a_rtc_init(&dev);
333 }
334
335 #else
336
337 static int s35392a_probe(struct udevice *dev)
338 {
339         s35392a_rtc_init(dev);
340         return 0;
341 }
342
343 static const struct rtc_ops s35392a_rtc_ops = {
344         .get = s35392a_rtc_get,
345         .set = s35392a_rtc_set,
346         .read8 = s35392a_rtc_read8,
347         .write8 = s35392a_rtc_write8,
348         .reset = s35392a_rtc_reset,
349 };
350
351 static const struct udevice_id s35392a_rtc_ids[] = {
352         { .compatible = "sii,s35392a-rtc" },
353         { }
354 };
355
356 U_BOOT_DRIVER(s35392a_rtc) = {
357         .name     = "s35392a_rtc",
358         .id           = UCLASS_RTC,
359         .probe    = s35392a_probe,
360         .of_match = s35392a_rtc_ids,
361         .ops      = &s35392a_rtc_ops,
362 };
363
364 #endif