1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Seiko Instruments S-35390A RTC Driver
5 * Copyright (c) 2007 Byron Bradley
8 #include <linux/module.h>
10 #include <linux/i2c.h>
11 #include <linux/bitrev.h>
12 #include <linux/bcd.h>
13 #include <linux/slab.h>
14 #include <linux/delay.h>
16 #define S35390A_CMD_STATUS1 0
17 #define S35390A_CMD_STATUS2 1
18 #define S35390A_CMD_TIME1 2
19 #define S35390A_CMD_TIME2 3
20 #define S35390A_CMD_INT2_REG1 5
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
30 #define S35390A_ALRM_BYTE_WDAY 0
31 #define S35390A_ALRM_BYTE_HOURS 1
32 #define S35390A_ALRM_BYTE_MINS 2
34 /* flags for STATUS1 */
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)
41 /* flag for STATUS2 */
42 #define S35390A_FLAG_TEST BIT(0)
44 /* INT2 pin output mode */
45 #define S35390A_INT2_MODE_MASK 0x0E
46 #define S35390A_INT2_MODE_NOINTR 0x00
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 */
52 static const struct i2c_device_id s35390a_id
[] = {
56 MODULE_DEVICE_TABLE(i2c
, s35390a_id
);
58 static const __maybe_unused
struct of_device_id s35390a_of_match
[] = {
59 { .compatible
= "sii,s35390a" },
62 MODULE_DEVICE_TABLE(of
, s35390a_of_match
);
65 struct i2c_client
*client
[8];
66 struct rtc_device
*rtc
;
70 static int s35390a_set_reg(struct s35390a
*s35390a
, int reg
, char *buf
, int len
)
72 struct i2c_client
*client
= s35390a
->client
[reg
];
73 struct i2c_msg msg
[] = {
81 if ((i2c_transfer(client
->adapter
, msg
, 1)) != 1)
87 static int s35390a_get_reg(struct s35390a
*s35390a
, int reg
, char *buf
, int len
)
89 struct i2c_client
*client
= s35390a
->client
[reg
];
90 struct i2c_msg msg
[] = {
99 if ((i2c_transfer(client
->adapter
, msg
, 1)) != 1)
105 static int s35390a_init(struct s35390a
*s35390a
)
109 unsigned initcount
= 0;
112 * At least one of POC and BLD are set, so reinitialise chip. Keeping
113 * this information in the hardware to know later that the time isn't
114 * valid is unfortunately not possible because POC and BLD are cleared
115 * on read. So the reset is best done now.
117 * The 24H bit is kept over reset, so set it already here.
120 buf
= S35390A_FLAG_RESET
| S35390A_FLAG_24H
;
121 ret
= s35390a_set_reg(s35390a
, S35390A_CMD_STATUS1
, &buf
, 1);
126 ret
= s35390a_get_reg(s35390a
, S35390A_CMD_STATUS1
, &buf
, 1);
130 if (buf
& (S35390A_FLAG_POC
| S35390A_FLAG_BLD
)) {
131 /* Try up to five times to reset the chip */
143 * Returns <0 on error, 0 if rtc is setup fine and 1 if the chip was reset.
144 * To keep the information if an irq is pending, pass the value read from
145 * STATUS1 to the caller.
147 static int s35390a_read_status(struct s35390a
*s35390a
, char *status1
)
151 ret
= s35390a_get_reg(s35390a
, S35390A_CMD_STATUS1
, status1
, 1);
155 if (*status1
& S35390A_FLAG_POC
) {
157 * Do not communicate for 0.5 seconds since the power-on
158 * detection circuit is in operation.
162 } else if (*status1
& S35390A_FLAG_BLD
)
165 * If both POC and BLD are unset everything is fine.
170 static int s35390a_disable_test_mode(struct s35390a
*s35390a
)
174 if (s35390a_get_reg(s35390a
, S35390A_CMD_STATUS2
, buf
, sizeof(buf
)) < 0)
177 if (!(buf
[0] & S35390A_FLAG_TEST
))
180 buf
[0] &= ~S35390A_FLAG_TEST
;
181 return s35390a_set_reg(s35390a
, S35390A_CMD_STATUS2
, buf
, sizeof(buf
));
184 static char s35390a_hr2reg(struct s35390a
*s35390a
, int hour
)
186 if (s35390a
->twentyfourhour
)
187 return bin2bcd(hour
);
190 return bin2bcd(hour
);
192 return 0x40 | bin2bcd(hour
- 12);
195 static int s35390a_reg2hr(struct s35390a
*s35390a
, char reg
)
199 if (s35390a
->twentyfourhour
)
200 return bcd2bin(reg
& 0x3f);
202 hour
= bcd2bin(reg
& 0x3f);
209 static int s35390a_rtc_set_time(struct device
*dev
, struct rtc_time
*tm
)
211 struct i2c_client
*client
= to_i2c_client(dev
);
212 struct s35390a
*s35390a
= i2c_get_clientdata(client
);
216 dev_dbg(&client
->dev
, "%s: tm is secs=%d, mins=%d, hours=%d mday=%d, "
217 "mon=%d, year=%d, wday=%d\n", __func__
, tm
->tm_sec
,
218 tm
->tm_min
, tm
->tm_hour
, tm
->tm_mday
, tm
->tm_mon
, tm
->tm_year
,
221 if (s35390a_read_status(s35390a
, &status
) == 1)
222 s35390a_init(s35390a
);
224 buf
[S35390A_BYTE_YEAR
] = bin2bcd(tm
->tm_year
- 100);
225 buf
[S35390A_BYTE_MONTH
] = bin2bcd(tm
->tm_mon
+ 1);
226 buf
[S35390A_BYTE_DAY
] = bin2bcd(tm
->tm_mday
);
227 buf
[S35390A_BYTE_WDAY
] = bin2bcd(tm
->tm_wday
);
228 buf
[S35390A_BYTE_HOURS
] = s35390a_hr2reg(s35390a
, tm
->tm_hour
);
229 buf
[S35390A_BYTE_MINS
] = bin2bcd(tm
->tm_min
);
230 buf
[S35390A_BYTE_SECS
] = bin2bcd(tm
->tm_sec
);
232 /* This chip expects the bits of each byte to be in reverse order */
233 for (i
= 0; i
< 7; ++i
)
234 buf
[i
] = bitrev8(buf
[i
]);
236 return s35390a_set_reg(s35390a
, S35390A_CMD_TIME1
, buf
, sizeof(buf
));
239 static int s35390a_rtc_read_time(struct device
*dev
, struct rtc_time
*tm
)
241 struct i2c_client
*client
= to_i2c_client(dev
);
242 struct s35390a
*s35390a
= i2c_get_clientdata(client
);
246 if (s35390a_read_status(s35390a
, &status
) == 1)
249 err
= s35390a_get_reg(s35390a
, S35390A_CMD_TIME1
, buf
, sizeof(buf
));
253 /* This chip returns the bits of each byte in reverse order */
254 for (i
= 0; i
< 7; ++i
)
255 buf
[i
] = bitrev8(buf
[i
]);
257 tm
->tm_sec
= bcd2bin(buf
[S35390A_BYTE_SECS
]);
258 tm
->tm_min
= bcd2bin(buf
[S35390A_BYTE_MINS
]);
259 tm
->tm_hour
= s35390a_reg2hr(s35390a
, buf
[S35390A_BYTE_HOURS
]);
260 tm
->tm_wday
= bcd2bin(buf
[S35390A_BYTE_WDAY
]);
261 tm
->tm_mday
= bcd2bin(buf
[S35390A_BYTE_DAY
]);
262 tm
->tm_mon
= bcd2bin(buf
[S35390A_BYTE_MONTH
]) - 1;
263 tm
->tm_year
= bcd2bin(buf
[S35390A_BYTE_YEAR
]) + 100;
265 dev_dbg(&client
->dev
, "%s: tm is secs=%d, mins=%d, hours=%d, mday=%d, "
266 "mon=%d, year=%d, wday=%d\n", __func__
, tm
->tm_sec
,
267 tm
->tm_min
, tm
->tm_hour
, tm
->tm_mday
, tm
->tm_mon
, tm
->tm_year
,
273 static int s35390a_rtc_set_alarm(struct device
*dev
, struct rtc_wkalrm
*alm
)
275 struct i2c_client
*client
= to_i2c_client(dev
);
276 struct s35390a
*s35390a
= i2c_get_clientdata(client
);
277 char buf
[3], sts
= 0;
280 dev_dbg(&client
->dev
, "%s: alm is secs=%d, mins=%d, hours=%d mday=%d, "\
281 "mon=%d, year=%d, wday=%d\n", __func__
, alm
->time
.tm_sec
,
282 alm
->time
.tm_min
, alm
->time
.tm_hour
, alm
->time
.tm_mday
,
283 alm
->time
.tm_mon
, alm
->time
.tm_year
, alm
->time
.tm_wday
);
285 /* disable interrupt (which deasserts the irq line) */
286 err
= s35390a_set_reg(s35390a
, S35390A_CMD_STATUS2
, &sts
, sizeof(sts
));
290 /* clear pending interrupt (in STATUS1 only), if any */
291 err
= s35390a_get_reg(s35390a
, S35390A_CMD_STATUS1
, &sts
, sizeof(sts
));
296 sts
= S35390A_INT2_MODE_ALARM
;
298 sts
= S35390A_INT2_MODE_NOINTR
;
300 /* set interupt mode*/
301 err
= s35390a_set_reg(s35390a
, S35390A_CMD_STATUS2
, &sts
, sizeof(sts
));
305 if (alm
->time
.tm_wday
!= -1)
306 buf
[S35390A_ALRM_BYTE_WDAY
] = bin2bcd(alm
->time
.tm_wday
) | 0x80;
308 buf
[S35390A_ALRM_BYTE_WDAY
] = 0;
310 buf
[S35390A_ALRM_BYTE_HOURS
] = s35390a_hr2reg(s35390a
,
311 alm
->time
.tm_hour
) | 0x80;
312 buf
[S35390A_ALRM_BYTE_MINS
] = bin2bcd(alm
->time
.tm_min
) | 0x80;
314 if (alm
->time
.tm_hour
>= 12)
315 buf
[S35390A_ALRM_BYTE_HOURS
] |= 0x40;
317 for (i
= 0; i
< 3; ++i
)
318 buf
[i
] = bitrev8(buf
[i
]);
320 err
= s35390a_set_reg(s35390a
, S35390A_CMD_INT2_REG1
, buf
,
326 static int s35390a_rtc_read_alarm(struct device
*dev
, struct rtc_wkalrm
*alm
)
328 struct i2c_client
*client
= to_i2c_client(dev
);
329 struct s35390a
*s35390a
= i2c_get_clientdata(client
);
333 err
= s35390a_get_reg(s35390a
, S35390A_CMD_STATUS2
, &sts
, sizeof(sts
));
337 if ((sts
& S35390A_INT2_MODE_MASK
) != S35390A_INT2_MODE_ALARM
) {
339 * When the alarm isn't enabled, the register to configure
340 * the alarm time isn't accessible.
348 err
= s35390a_get_reg(s35390a
, S35390A_CMD_INT2_REG1
, buf
, sizeof(buf
));
352 /* This chip returns the bits of each byte in reverse order */
353 for (i
= 0; i
< 3; ++i
)
354 buf
[i
] = bitrev8(buf
[i
]);
357 * B0 of the three matching registers is an enable flag. Iff it is set
358 * the configured value is used for matching.
360 if (buf
[S35390A_ALRM_BYTE_WDAY
] & 0x80)
362 bcd2bin(buf
[S35390A_ALRM_BYTE_WDAY
] & ~0x80);
364 if (buf
[S35390A_ALRM_BYTE_HOURS
] & 0x80)
366 s35390a_reg2hr(s35390a
,
367 buf
[S35390A_ALRM_BYTE_HOURS
] & ~0x80);
369 if (buf
[S35390A_ALRM_BYTE_MINS
] & 0x80)
370 alm
->time
.tm_min
= bcd2bin(buf
[S35390A_ALRM_BYTE_MINS
] & ~0x80);
372 /* alarm triggers always at s=0 */
373 alm
->time
.tm_sec
= 0;
375 dev_dbg(&client
->dev
, "%s: alm is mins=%d, hours=%d, wday=%d\n",
376 __func__
, alm
->time
.tm_min
, alm
->time
.tm_hour
,
382 static int s35390a_rtc_ioctl(struct device
*dev
, unsigned int cmd
,
385 struct i2c_client
*client
= to_i2c_client(dev
);
386 struct s35390a
*s35390a
= i2c_get_clientdata(client
);
392 /* s35390a_reset set lowvoltage flag and init RTC if needed */
393 err
= s35390a_read_status(s35390a
, &sts
);
396 if (copy_to_user((void __user
*)arg
, &err
, sizeof(int)))
400 /* update flag and clear register */
401 err
= s35390a_init(s35390a
);
412 static const struct rtc_class_ops s35390a_rtc_ops
= {
413 .read_time
= s35390a_rtc_read_time
,
414 .set_time
= s35390a_rtc_set_time
,
415 .set_alarm
= s35390a_rtc_set_alarm
,
416 .read_alarm
= s35390a_rtc_read_alarm
,
417 .ioctl
= s35390a_rtc_ioctl
,
420 static int s35390a_probe(struct i2c_client
*client
)
424 struct s35390a
*s35390a
;
426 struct device
*dev
= &client
->dev
;
428 if (!i2c_check_functionality(client
->adapter
, I2C_FUNC_I2C
))
431 s35390a
= devm_kzalloc(dev
, sizeof(struct s35390a
), GFP_KERNEL
);
435 s35390a
->client
[0] = client
;
436 i2c_set_clientdata(client
, s35390a
);
438 /* This chip uses multiple addresses, use dummy devices for them */
439 for (i
= 1; i
< 8; ++i
) {
440 s35390a
->client
[i
] = devm_i2c_new_dummy_device(dev
,
443 if (IS_ERR(s35390a
->client
[i
])) {
444 dev_err(dev
, "Address %02x unavailable\n",
446 return PTR_ERR(s35390a
->client
[i
]);
450 s35390a
->rtc
= devm_rtc_allocate_device(dev
);
451 if (IS_ERR(s35390a
->rtc
))
452 return PTR_ERR(s35390a
->rtc
);
454 err_read
= s35390a_read_status(s35390a
, &status1
);
456 dev_err(dev
, "error resetting chip\n");
460 if (status1
& S35390A_FLAG_24H
)
461 s35390a
->twentyfourhour
= 1;
463 s35390a
->twentyfourhour
= 0;
465 if (status1
& S35390A_FLAG_INT2
) {
466 /* disable alarm (and maybe test mode) */
468 err
= s35390a_set_reg(s35390a
, S35390A_CMD_STATUS2
, &buf
, 1);
470 dev_err(dev
, "error disabling alarm");
474 err
= s35390a_disable_test_mode(s35390a
);
476 dev_err(dev
, "error disabling test mode\n");
481 device_set_wakeup_capable(dev
, 1);
483 s35390a
->rtc
->ops
= &s35390a_rtc_ops
;
484 s35390a
->rtc
->range_min
= RTC_TIMESTAMP_BEGIN_2000
;
485 s35390a
->rtc
->range_max
= RTC_TIMESTAMP_END_2099
;
487 set_bit(RTC_FEATURE_ALARM_RES_MINUTE
, s35390a
->rtc
->features
);
488 clear_bit(RTC_FEATURE_UPDATE_INTERRUPT
, s35390a
->rtc
->features
);
490 if (status1
& S35390A_FLAG_INT2
)
491 rtc_update_irq(s35390a
->rtc
, 1, RTC_AF
);
493 return devm_rtc_register_device(s35390a
->rtc
);
496 static struct i2c_driver s35390a_driver
= {
498 .name
= "rtc-s35390a",
499 .of_match_table
= of_match_ptr(s35390a_of_match
),
501 .probe
= s35390a_probe
,
502 .id_table
= s35390a_id
,
505 module_i2c_driver(s35390a_driver
);
507 MODULE_AUTHOR("Byron Bradley <byron.bbradley@gmail.com>");
508 MODULE_DESCRIPTION("S35390A RTC driver");
509 MODULE_LICENSE("GPL");