]>
Commit | Line | Data |
---|---|---|
2874c5fd | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
c46288b0 BB |
2 | /* |
3 | * Seiko Instruments S-35390A RTC Driver | |
4 | * | |
5 | * Copyright (c) 2007 Byron Bradley | |
c46288b0 BB |
6 | */ |
7 | ||
8 | #include <linux/module.h> | |
9 | #include <linux/rtc.h> | |
10 | #include <linux/i2c.h> | |
11 | #include <linux/bitrev.h> | |
12 | #include <linux/bcd.h> | |
13 | #include <linux/slab.h> | |
8e6583f1 | 14 | #include <linux/delay.h> |
c46288b0 BB |
15 | |
16 | #define S35390A_CMD_STATUS1 0 | |
17 | #define S35390A_CMD_STATUS2 1 | |
18 | #define S35390A_CMD_TIME1 2 | |
542dd33a ML |
19 | #define S35390A_CMD_TIME2 3 |
20 | #define S35390A_CMD_INT2_REG1 5 | |
c46288b0 BB |
21 | |
22 | #define S35390A_BYTE_YEAR 0 | |
23 | #define S35390A_BYTE_MONTH 1 | |
24 | #define S35390A_BYTE_DAY 2 | |
25 | #define S35390A_BYTE_WDAY 3 | |
26 | #define S35390A_BYTE_HOURS 4 | |
27 | #define S35390A_BYTE_MINS 5 | |
28 | #define S35390A_BYTE_SECS 6 | |
29 | ||
542dd33a ML |
30 | #define S35390A_ALRM_BYTE_WDAY 0 |
31 | #define S35390A_ALRM_BYTE_HOURS 1 | |
32 | #define S35390A_ALRM_BYTE_MINS 2 | |
33 | ||
3bd32722 | 34 | /* flags for STATUS1 */ |
097aa24b RL |
35 | #define S35390A_FLAG_POC BIT(0) |
36 | #define S35390A_FLAG_BLD BIT(1) | |
37 | #define S35390A_FLAG_INT2 BIT(2) | |
38 | #define S35390A_FLAG_24H BIT(6) | |
39 | #define S35390A_FLAG_RESET BIT(7) | |
3bd32722 UKK |
40 | |
41 | /* flag for STATUS2 */ | |
097aa24b | 42 | #define S35390A_FLAG_TEST BIT(0) |
542dd33a | 43 | |
a86bd904 RL |
44 | /* INT2 pin output mode */ |
45 | #define S35390A_INT2_MODE_MASK 0x0E | |
542dd33a | 46 | #define S35390A_INT2_MODE_NOINTR 0x00 |
a86bd904 RL |
47 | #define S35390A_INT2_MODE_ALARM BIT(1) /* INT2AE */ |
48 | #define S35390A_INT2_MODE_PMIN_EDG BIT(2) /* INT2ME */ | |
49 | #define S35390A_INT2_MODE_FREQ BIT(3) /* INT2FE */ | |
50 | #define S35390A_INT2_MODE_PMIN (BIT(3) | BIT(2)) /* INT2FE | INT2ME */ | |
542dd33a | 51 | |
3760f736 JD |
52 | static const struct i2c_device_id s35390a_id[] = { |
53 | { "s35390a", 0 }, | |
54 | { } | |
55 | }; | |
56 | MODULE_DEVICE_TABLE(i2c, s35390a_id); | |
57 | ||
21f27432 JMC |
58 | static const struct of_device_id s35390a_of_match[] = { |
59 | { .compatible = "s35390a" }, | |
60 | { .compatible = "sii,s35390a" }, | |
61 | { } | |
62 | }; | |
63 | MODULE_DEVICE_TABLE(of, s35390a_of_match); | |
64 | ||
c46288b0 BB |
65 | struct s35390a { |
66 | struct i2c_client *client[8]; | |
67 | struct rtc_device *rtc; | |
68 | int twentyfourhour; | |
69 | }; | |
70 | ||
71 | static int s35390a_set_reg(struct s35390a *s35390a, int reg, char *buf, int len) | |
72 | { | |
73 | struct i2c_client *client = s35390a->client[reg]; | |
74 | struct i2c_msg msg[] = { | |
65659f63 S |
75 | { |
76 | .addr = client->addr, | |
77 | .len = len, | |
78 | .buf = buf | |
79 | }, | |
c46288b0 BB |
80 | }; |
81 | ||
82 | if ((i2c_transfer(client->adapter, msg, 1)) != 1) | |
83 | return -EIO; | |
84 | ||
85 | return 0; | |
86 | } | |
87 | ||
88 | static int s35390a_get_reg(struct s35390a *s35390a, int reg, char *buf, int len) | |
89 | { | |
90 | struct i2c_client *client = s35390a->client[reg]; | |
91 | struct i2c_msg msg[] = { | |
65659f63 S |
92 | { |
93 | .addr = client->addr, | |
94 | .flags = I2C_M_RD, | |
95 | .len = len, | |
96 | .buf = buf | |
97 | }, | |
c46288b0 BB |
98 | }; |
99 | ||
100 | if ((i2c_transfer(client->adapter, msg, 1)) != 1) | |
101 | return -EIO; | |
102 | ||
103 | return 0; | |
104 | } | |
105 | ||
16486d0c | 106 | static int s35390a_init(struct s35390a *s35390a) |
c46288b0 | 107 | { |
ef0f02fd | 108 | u8 buf; |
8e6583f1 UKK |
109 | int ret; |
110 | unsigned initcount = 0; | |
c46288b0 | 111 | |
8e6583f1 UKK |
112 | /* |
113 | * At least one of POC and BLD are set, so reinitialise chip. Keeping | |
114 | * this information in the hardware to know later that the time isn't | |
115 | * valid is unfortunately not possible because POC and BLD are cleared | |
116 | * on read. So the reset is best done now. | |
117 | * | |
118 | * The 24H bit is kept over reset, so set it already here. | |
119 | */ | |
120 | initialize: | |
8e6583f1 UKK |
121 | buf = S35390A_FLAG_RESET | S35390A_FLAG_24H; |
122 | ret = s35390a_set_reg(s35390a, S35390A_CMD_STATUS1, &buf, 1); | |
123 | ||
124 | if (ret < 0) | |
125 | return ret; | |
126 | ||
127 | ret = s35390a_get_reg(s35390a, S35390A_CMD_STATUS1, &buf, 1); | |
128 | if (ret < 0) | |
129 | return ret; | |
130 | ||
131 | if (buf & (S35390A_FLAG_POC | S35390A_FLAG_BLD)) { | |
132 | /* Try up to five times to reset the chip */ | |
133 | if (initcount < 5) { | |
134 | ++initcount; | |
135 | goto initialize; | |
136 | } else | |
137 | return -EIO; | |
138 | } | |
139 | ||
140 | return 1; | |
c46288b0 BB |
141 | } |
142 | ||
16486d0c FL |
143 | /* |
144 | * Returns <0 on error, 0 if rtc is setup fine and 1 if the chip was reset. | |
145 | * To keep the information if an irq is pending, pass the value read from | |
146 | * STATUS1 to the caller. | |
147 | */ | |
148 | static int s35390a_read_status(struct s35390a *s35390a, char *status1) | |
149 | { | |
150 | int ret; | |
151 | ||
152 | ret = s35390a_get_reg(s35390a, S35390A_CMD_STATUS1, status1, 1); | |
153 | if (ret < 0) | |
154 | return ret; | |
155 | ||
156 | if (*status1 & S35390A_FLAG_POC) { | |
157 | /* | |
158 | * Do not communicate for 0.5 seconds since the power-on | |
159 | * detection circuit is in operation. | |
160 | */ | |
161 | msleep(500); | |
162 | return 1; | |
163 | } else if (*status1 & S35390A_FLAG_BLD) | |
164 | return 1; | |
165 | /* | |
166 | * If both POC and BLD are unset everything is fine. | |
167 | */ | |
168 | return 0; | |
169 | } | |
170 | ||
c46288b0 BB |
171 | static int s35390a_disable_test_mode(struct s35390a *s35390a) |
172 | { | |
173 | char buf[1]; | |
174 | ||
175 | if (s35390a_get_reg(s35390a, S35390A_CMD_STATUS2, buf, sizeof(buf)) < 0) | |
176 | return -EIO; | |
177 | ||
178 | if (!(buf[0] & S35390A_FLAG_TEST)) | |
179 | return 0; | |
180 | ||
181 | buf[0] &= ~S35390A_FLAG_TEST; | |
182 | return s35390a_set_reg(s35390a, S35390A_CMD_STATUS2, buf, sizeof(buf)); | |
183 | } | |
184 | ||
185 | static char s35390a_hr2reg(struct s35390a *s35390a, int hour) | |
186 | { | |
187 | if (s35390a->twentyfourhour) | |
fe20ba70 | 188 | return bin2bcd(hour); |
c46288b0 BB |
189 | |
190 | if (hour < 12) | |
fe20ba70 | 191 | return bin2bcd(hour); |
c46288b0 | 192 | |
fe20ba70 | 193 | return 0x40 | bin2bcd(hour - 12); |
c46288b0 BB |
194 | } |
195 | ||
196 | static int s35390a_reg2hr(struct s35390a *s35390a, char reg) | |
197 | { | |
198 | unsigned hour; | |
199 | ||
200 | if (s35390a->twentyfourhour) | |
fe20ba70 | 201 | return bcd2bin(reg & 0x3f); |
c46288b0 | 202 | |
fe20ba70 | 203 | hour = bcd2bin(reg & 0x3f); |
c46288b0 BB |
204 | if (reg & 0x40) |
205 | hour += 12; | |
206 | ||
207 | return hour; | |
208 | } | |
209 | ||
779e1aab | 210 | static int s35390a_rtc_set_time(struct device *dev, struct rtc_time *tm) |
c46288b0 | 211 | { |
779e1aab | 212 | struct i2c_client *client = to_i2c_client(dev); |
c46288b0 BB |
213 | struct s35390a *s35390a = i2c_get_clientdata(client); |
214 | int i, err; | |
16486d0c | 215 | char buf[7], status; |
c46288b0 BB |
216 | |
217 | dev_dbg(&client->dev, "%s: tm is secs=%d, mins=%d, hours=%d mday=%d, " | |
218 | "mon=%d, year=%d, wday=%d\n", __func__, tm->tm_sec, | |
219 | tm->tm_min, tm->tm_hour, tm->tm_mday, tm->tm_mon, tm->tm_year, | |
220 | tm->tm_wday); | |
221 | ||
16486d0c FL |
222 | if (s35390a_read_status(s35390a, &status) == 1) |
223 | s35390a_init(s35390a); | |
224 | ||
fe20ba70 AB |
225 | buf[S35390A_BYTE_YEAR] = bin2bcd(tm->tm_year - 100); |
226 | buf[S35390A_BYTE_MONTH] = bin2bcd(tm->tm_mon + 1); | |
227 | buf[S35390A_BYTE_DAY] = bin2bcd(tm->tm_mday); | |
228 | buf[S35390A_BYTE_WDAY] = bin2bcd(tm->tm_wday); | |
c46288b0 | 229 | buf[S35390A_BYTE_HOURS] = s35390a_hr2reg(s35390a, tm->tm_hour); |
fe20ba70 AB |
230 | buf[S35390A_BYTE_MINS] = bin2bcd(tm->tm_min); |
231 | buf[S35390A_BYTE_SECS] = bin2bcd(tm->tm_sec); | |
c46288b0 BB |
232 | |
233 | /* This chip expects the bits of each byte to be in reverse order */ | |
234 | for (i = 0; i < 7; ++i) | |
235 | buf[i] = bitrev8(buf[i]); | |
236 | ||
237 | err = s35390a_set_reg(s35390a, S35390A_CMD_TIME1, buf, sizeof(buf)); | |
238 | ||
239 | return err; | |
240 | } | |
241 | ||
779e1aab | 242 | static int s35390a_rtc_read_time(struct device *dev, struct rtc_time *tm) |
c46288b0 | 243 | { |
779e1aab | 244 | struct i2c_client *client = to_i2c_client(dev); |
c46288b0 | 245 | struct s35390a *s35390a = i2c_get_clientdata(client); |
16486d0c | 246 | char buf[7], status; |
c46288b0 BB |
247 | int i, err; |
248 | ||
16486d0c FL |
249 | if (s35390a_read_status(s35390a, &status) == 1) |
250 | return -EINVAL; | |
251 | ||
c46288b0 BB |
252 | err = s35390a_get_reg(s35390a, S35390A_CMD_TIME1, buf, sizeof(buf)); |
253 | if (err < 0) | |
254 | return err; | |
255 | ||
256 | /* This chip returns the bits of each byte in reverse order */ | |
257 | for (i = 0; i < 7; ++i) | |
258 | buf[i] = bitrev8(buf[i]); | |
259 | ||
fe20ba70 AB |
260 | tm->tm_sec = bcd2bin(buf[S35390A_BYTE_SECS]); |
261 | tm->tm_min = bcd2bin(buf[S35390A_BYTE_MINS]); | |
c46288b0 | 262 | tm->tm_hour = s35390a_reg2hr(s35390a, buf[S35390A_BYTE_HOURS]); |
fe20ba70 AB |
263 | tm->tm_wday = bcd2bin(buf[S35390A_BYTE_WDAY]); |
264 | tm->tm_mday = bcd2bin(buf[S35390A_BYTE_DAY]); | |
265 | tm->tm_mon = bcd2bin(buf[S35390A_BYTE_MONTH]) - 1; | |
266 | tm->tm_year = bcd2bin(buf[S35390A_BYTE_YEAR]) + 100; | |
c46288b0 BB |
267 | |
268 | dev_dbg(&client->dev, "%s: tm is secs=%d, mins=%d, hours=%d, mday=%d, " | |
269 | "mon=%d, year=%d, wday=%d\n", __func__, tm->tm_sec, | |
270 | tm->tm_min, tm->tm_hour, tm->tm_mday, tm->tm_mon, tm->tm_year, | |
271 | tm->tm_wday); | |
272 | ||
bb530199 | 273 | return 0; |
c46288b0 BB |
274 | } |
275 | ||
779e1aab | 276 | static int s35390a_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm) |
542dd33a | 277 | { |
779e1aab | 278 | struct i2c_client *client = to_i2c_client(dev); |
542dd33a ML |
279 | struct s35390a *s35390a = i2c_get_clientdata(client); |
280 | char buf[3], sts = 0; | |
281 | int err, i; | |
282 | ||
283 | dev_dbg(&client->dev, "%s: alm is secs=%d, mins=%d, hours=%d mday=%d, "\ | |
284 | "mon=%d, year=%d, wday=%d\n", __func__, alm->time.tm_sec, | |
285 | alm->time.tm_min, alm->time.tm_hour, alm->time.tm_mday, | |
286 | alm->time.tm_mon, alm->time.tm_year, alm->time.tm_wday); | |
287 | ||
c0e12848 RL |
288 | if (alm->time.tm_sec != 0) |
289 | dev_warn(&client->dev, "Alarms are only supported on a per minute basis!\n"); | |
290 | ||
5227e8a2 | 291 | /* disable interrupt (which deasserts the irq line) */ |
542dd33a ML |
292 | err = s35390a_set_reg(s35390a, S35390A_CMD_STATUS2, &sts, sizeof(sts)); |
293 | if (err < 0) | |
294 | return err; | |
295 | ||
5227e8a2 | 296 | /* clear pending interrupt (in STATUS1 only), if any */ |
542dd33a ML |
297 | err = s35390a_get_reg(s35390a, S35390A_CMD_STATUS1, &sts, sizeof(sts)); |
298 | if (err < 0) | |
299 | return err; | |
300 | ||
301 | if (alm->enabled) | |
302 | sts = S35390A_INT2_MODE_ALARM; | |
303 | else | |
304 | sts = S35390A_INT2_MODE_NOINTR; | |
305 | ||
542dd33a ML |
306 | /* set interupt mode*/ |
307 | err = s35390a_set_reg(s35390a, S35390A_CMD_STATUS2, &sts, sizeof(sts)); | |
308 | if (err < 0) | |
309 | return err; | |
310 | ||
311 | if (alm->time.tm_wday != -1) | |
312 | buf[S35390A_ALRM_BYTE_WDAY] = bin2bcd(alm->time.tm_wday) | 0x80; | |
f87e904d UKK |
313 | else |
314 | buf[S35390A_ALRM_BYTE_WDAY] = 0; | |
542dd33a ML |
315 | |
316 | buf[S35390A_ALRM_BYTE_HOURS] = s35390a_hr2reg(s35390a, | |
317 | alm->time.tm_hour) | 0x80; | |
318 | buf[S35390A_ALRM_BYTE_MINS] = bin2bcd(alm->time.tm_min) | 0x80; | |
319 | ||
320 | if (alm->time.tm_hour >= 12) | |
321 | buf[S35390A_ALRM_BYTE_HOURS] |= 0x40; | |
322 | ||
323 | for (i = 0; i < 3; ++i) | |
324 | buf[i] = bitrev8(buf[i]); | |
325 | ||
326 | err = s35390a_set_reg(s35390a, S35390A_CMD_INT2_REG1, buf, | |
327 | sizeof(buf)); | |
328 | ||
329 | return err; | |
330 | } | |
331 | ||
779e1aab | 332 | static int s35390a_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alm) |
542dd33a | 333 | { |
779e1aab | 334 | struct i2c_client *client = to_i2c_client(dev); |
542dd33a ML |
335 | struct s35390a *s35390a = i2c_get_clientdata(client); |
336 | char buf[3], sts; | |
337 | int i, err; | |
338 | ||
339 | err = s35390a_get_reg(s35390a, S35390A_CMD_STATUS2, &sts, sizeof(sts)); | |
340 | if (err < 0) | |
341 | return err; | |
342 | ||
a86bd904 | 343 | if ((sts & S35390A_INT2_MODE_MASK) != S35390A_INT2_MODE_ALARM) { |
f87e904d UKK |
344 | /* |
345 | * When the alarm isn't enabled, the register to configure | |
346 | * the alarm time isn't accessible. | |
347 | */ | |
348 | alm->enabled = 0; | |
349 | return 0; | |
350 | } else { | |
351 | alm->enabled = 1; | |
352 | } | |
542dd33a ML |
353 | |
354 | err = s35390a_get_reg(s35390a, S35390A_CMD_INT2_REG1, buf, sizeof(buf)); | |
355 | if (err < 0) | |
356 | return err; | |
357 | ||
358 | /* This chip returns the bits of each byte in reverse order */ | |
f87e904d | 359 | for (i = 0; i < 3; ++i) |
542dd33a | 360 | buf[i] = bitrev8(buf[i]); |
542dd33a | 361 | |
f87e904d UKK |
362 | /* |
363 | * B0 of the three matching registers is an enable flag. Iff it is set | |
364 | * the configured value is used for matching. | |
365 | */ | |
366 | if (buf[S35390A_ALRM_BYTE_WDAY] & 0x80) | |
367 | alm->time.tm_wday = | |
368 | bcd2bin(buf[S35390A_ALRM_BYTE_WDAY] & ~0x80); | |
369 | ||
370 | if (buf[S35390A_ALRM_BYTE_HOURS] & 0x80) | |
371 | alm->time.tm_hour = | |
372 | s35390a_reg2hr(s35390a, | |
373 | buf[S35390A_ALRM_BYTE_HOURS] & ~0x80); | |
374 | ||
375 | if (buf[S35390A_ALRM_BYTE_MINS] & 0x80) | |
376 | alm->time.tm_min = bcd2bin(buf[S35390A_ALRM_BYTE_MINS] & ~0x80); | |
377 | ||
378 | /* alarm triggers always at s=0 */ | |
379 | alm->time.tm_sec = 0; | |
542dd33a ML |
380 | |
381 | dev_dbg(&client->dev, "%s: alm is mins=%d, hours=%d, wday=%d\n", | |
382 | __func__, alm->time.tm_min, alm->time.tm_hour, | |
383 | alm->time.tm_wday); | |
384 | ||
385 | return 0; | |
386 | } | |
387 | ||
7a1fe407 FL |
388 | static int s35390a_rtc_ioctl(struct device *dev, unsigned int cmd, |
389 | unsigned long arg) | |
390 | { | |
391 | struct i2c_client *client = to_i2c_client(dev); | |
392 | struct s35390a *s35390a = i2c_get_clientdata(client); | |
393 | char sts; | |
394 | int err; | |
395 | ||
396 | switch (cmd) { | |
397 | case RTC_VL_READ: | |
398 | /* s35390a_reset set lowvoltage flag and init RTC if needed */ | |
399 | err = s35390a_read_status(s35390a, &sts); | |
400 | if (err < 0) | |
401 | return err; | |
402 | if (copy_to_user((void __user *)arg, &err, sizeof(int))) | |
403 | return -EFAULT; | |
404 | break; | |
405 | case RTC_VL_CLR: | |
406 | /* update flag and clear register */ | |
407 | err = s35390a_init(s35390a); | |
408 | if (err < 0) | |
409 | return err; | |
410 | break; | |
411 | default: | |
412 | return -ENOIOCTLCMD; | |
413 | } | |
414 | ||
415 | return 0; | |
416 | } | |
417 | ||
c46288b0 BB |
418 | static const struct rtc_class_ops s35390a_rtc_ops = { |
419 | .read_time = s35390a_rtc_read_time, | |
420 | .set_time = s35390a_rtc_set_time, | |
542dd33a ML |
421 | .set_alarm = s35390a_rtc_set_alarm, |
422 | .read_alarm = s35390a_rtc_read_alarm, | |
7a1fe407 | 423 | .ioctl = s35390a_rtc_ioctl, |
c46288b0 BB |
424 | }; |
425 | ||
d2653e92 JD |
426 | static int s35390a_probe(struct i2c_client *client, |
427 | const struct i2c_device_id *id) | |
c46288b0 | 428 | { |
16486d0c | 429 | int err, err_read; |
c46288b0 BB |
430 | unsigned int i; |
431 | struct s35390a *s35390a; | |
3bd32722 | 432 | char buf, status1; |
03279634 | 433 | struct device *dev = &client->dev; |
c46288b0 | 434 | |
4053e749 WS |
435 | if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) |
436 | return -ENODEV; | |
c46288b0 | 437 | |
03279634 | 438 | s35390a = devm_kzalloc(dev, sizeof(struct s35390a), GFP_KERNEL); |
4053e749 WS |
439 | if (!s35390a) |
440 | return -ENOMEM; | |
c46288b0 BB |
441 | |
442 | s35390a->client[0] = client; | |
443 | i2c_set_clientdata(client, s35390a); | |
444 | ||
445 | /* This chip uses multiple addresses, use dummy devices for them */ | |
446 | for (i = 1; i < 8; ++i) { | |
4053e749 WS |
447 | s35390a->client[i] = devm_i2c_new_dummy_device(dev, |
448 | client->adapter, | |
449 | client->addr + i); | |
ca83542c | 450 | if (IS_ERR(s35390a->client[i])) { |
03279634 RL |
451 | dev_err(dev, "Address %02x unavailable\n", |
452 | client->addr + i); | |
4053e749 | 453 | return PTR_ERR(s35390a->client[i]); |
c46288b0 BB |
454 | } |
455 | } | |
456 | ||
ed6c6dfd AB |
457 | s35390a->rtc = devm_rtc_allocate_device(dev); |
458 | if (IS_ERR(s35390a->rtc)) | |
459 | return PTR_ERR(s35390a->rtc); | |
460 | ||
16486d0c FL |
461 | err_read = s35390a_read_status(s35390a, &status1); |
462 | if (err_read < 0) { | |
03279634 | 463 | dev_err(dev, "error resetting chip\n"); |
4053e749 | 464 | return err_read; |
c46288b0 BB |
465 | } |
466 | ||
3bd32722 | 467 | if (status1 & S35390A_FLAG_24H) |
c46288b0 BB |
468 | s35390a->twentyfourhour = 1; |
469 | else | |
470 | s35390a->twentyfourhour = 0; | |
471 | ||
3bd32722 UKK |
472 | if (status1 & S35390A_FLAG_INT2) { |
473 | /* disable alarm (and maybe test mode) */ | |
474 | buf = 0; | |
475 | err = s35390a_set_reg(s35390a, S35390A_CMD_STATUS2, &buf, 1); | |
476 | if (err < 0) { | |
03279634 | 477 | dev_err(dev, "error disabling alarm"); |
4053e749 | 478 | return err; |
3bd32722 UKK |
479 | } |
480 | } else { | |
481 | err = s35390a_disable_test_mode(s35390a); | |
482 | if (err < 0) { | |
03279634 | 483 | dev_err(dev, "error disabling test mode\n"); |
4053e749 | 484 | return err; |
3bd32722 UKK |
485 | } |
486 | } | |
487 | ||
03279634 | 488 | device_set_wakeup_capable(dev, 1); |
542dd33a | 489 | |
ed6c6dfd | 490 | s35390a->rtc->ops = &s35390a_rtc_ops; |
9e8a968f AB |
491 | s35390a->rtc->range_min = RTC_TIMESTAMP_BEGIN_2000; |
492 | s35390a->rtc->range_max = RTC_TIMESTAMP_END_2099; | |
3bd32722 | 493 | |
c0e12848 RL |
494 | /* supports per-minute alarms only, therefore set uie_unsupported */ |
495 | s35390a->rtc->uie_unsupported = 1; | |
496 | ||
3bd32722 UKK |
497 | if (status1 & S35390A_FLAG_INT2) |
498 | rtc_update_irq(s35390a->rtc, 1, RTC_AF); | |
499 | ||
fdcfd854 | 500 | return devm_rtc_register_device(s35390a->rtc); |
c46288b0 BB |
501 | } |
502 | ||
503 | static struct i2c_driver s35390a_driver = { | |
504 | .driver = { | |
505 | .name = "rtc-s35390a", | |
21f27432 | 506 | .of_match_table = of_match_ptr(s35390a_of_match), |
c46288b0 BB |
507 | }, |
508 | .probe = s35390a_probe, | |
3760f736 | 509 | .id_table = s35390a_id, |
c46288b0 BB |
510 | }; |
511 | ||
0abc9201 | 512 | module_i2c_driver(s35390a_driver); |
c46288b0 BB |
513 | |
514 | MODULE_AUTHOR("Byron Bradley <byron.bbradley@gmail.com>"); | |
515 | MODULE_DESCRIPTION("S35390A RTC driver"); | |
516 | MODULE_LICENSE("GPL"); |