1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Seiko Instruments S-35390A RTC Driver 4 * 5 * Copyright (c) 2007 Byron Bradley 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> 14 #include <linux/delay.h> 15 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 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 30 #define S35390A_ALRM_BYTE_WDAY 0 31 #define S35390A_ALRM_BYTE_HOURS 1 32 #define S35390A_ALRM_BYTE_MINS 2 33 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) 40 41 /* flag for STATUS2 */ 42 #define S35390A_FLAG_TEST BIT(0) 43 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 */ 51 52 static const struct i2c_device_id s35390a_id[] = { 53 { "s35390a", 0 }, 54 { } 55 }; 56 MODULE_DEVICE_TABLE(i2c, s35390a_id); 57 58 static const __maybe_unused 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 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[] = { 75 { 76 .addr = client->addr, 77 .len = len, 78 .buf = buf 79 }, 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[] = { 92 { 93 .addr = client->addr, 94 .flags = I2C_M_RD, 95 .len = len, 96 .buf = buf 97 }, 98 }; 99 100 if ((i2c_transfer(client->adapter, msg, 1)) != 1) 101 return -EIO; 102 103 return 0; 104 } 105 106 static int s35390a_init(struct s35390a *s35390a) 107 { 108 u8 buf; 109 int ret; 110 unsigned initcount = 0; 111 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: 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; 141 } 142 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 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) 188 return bin2bcd(hour); 189 190 if (hour < 12) 191 return bin2bcd(hour); 192 193 return 0x40 | bin2bcd(hour - 12); 194 } 195 196 static int s35390a_reg2hr(struct s35390a *s35390a, char reg) 197 { 198 unsigned hour; 199 200 if (s35390a->twentyfourhour) 201 return bcd2bin(reg & 0x3f); 202 203 hour = bcd2bin(reg & 0x3f); 204 if (reg & 0x40) 205 hour += 12; 206 207 return hour; 208 } 209 210 static int s35390a_rtc_set_time(struct device *dev, struct rtc_time *tm) 211 { 212 struct i2c_client *client = to_i2c_client(dev); 213 struct s35390a *s35390a = i2c_get_clientdata(client); 214 int i, err; 215 char buf[7], status; 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 222 if (s35390a_read_status(s35390a, &status) == 1) 223 s35390a_init(s35390a); 224 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); 229 buf[S35390A_BYTE_HOURS] = s35390a_hr2reg(s35390a, tm->tm_hour); 230 buf[S35390A_BYTE_MINS] = bin2bcd(tm->tm_min); 231 buf[S35390A_BYTE_SECS] = bin2bcd(tm->tm_sec); 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 242 static int s35390a_rtc_read_time(struct device *dev, struct rtc_time *tm) 243 { 244 struct i2c_client *client = to_i2c_client(dev); 245 struct s35390a *s35390a = i2c_get_clientdata(client); 246 char buf[7], status; 247 int i, err; 248 249 if (s35390a_read_status(s35390a, &status) == 1) 250 return -EINVAL; 251 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 260 tm->tm_sec = bcd2bin(buf[S35390A_BYTE_SECS]); 261 tm->tm_min = bcd2bin(buf[S35390A_BYTE_MINS]); 262 tm->tm_hour = s35390a_reg2hr(s35390a, buf[S35390A_BYTE_HOURS]); 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; 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 273 return 0; 274 } 275 276 static int s35390a_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm) 277 { 278 struct i2c_client *client = to_i2c_client(dev); 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 288 /* disable interrupt (which deasserts the irq line) */ 289 err = s35390a_set_reg(s35390a, S35390A_CMD_STATUS2, &sts, sizeof(sts)); 290 if (err < 0) 291 return err; 292 293 /* clear pending interrupt (in STATUS1 only), if any */ 294 err = s35390a_get_reg(s35390a, S35390A_CMD_STATUS1, &sts, sizeof(sts)); 295 if (err < 0) 296 return err; 297 298 if (alm->enabled) 299 sts = S35390A_INT2_MODE_ALARM; 300 else 301 sts = S35390A_INT2_MODE_NOINTR; 302 303 /* set interupt mode*/ 304 err = s35390a_set_reg(s35390a, S35390A_CMD_STATUS2, &sts, sizeof(sts)); 305 if (err < 0) 306 return err; 307 308 if (alm->time.tm_wday != -1) 309 buf[S35390A_ALRM_BYTE_WDAY] = bin2bcd(alm->time.tm_wday) | 0x80; 310 else 311 buf[S35390A_ALRM_BYTE_WDAY] = 0; 312 313 buf[S35390A_ALRM_BYTE_HOURS] = s35390a_hr2reg(s35390a, 314 alm->time.tm_hour) | 0x80; 315 buf[S35390A_ALRM_BYTE_MINS] = bin2bcd(alm->time.tm_min) | 0x80; 316 317 if (alm->time.tm_hour >= 12) 318 buf[S35390A_ALRM_BYTE_HOURS] |= 0x40; 319 320 for (i = 0; i < 3; ++i) 321 buf[i] = bitrev8(buf[i]); 322 323 err = s35390a_set_reg(s35390a, S35390A_CMD_INT2_REG1, buf, 324 sizeof(buf)); 325 326 return err; 327 } 328 329 static int s35390a_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alm) 330 { 331 struct i2c_client *client = to_i2c_client(dev); 332 struct s35390a *s35390a = i2c_get_clientdata(client); 333 char buf[3], sts; 334 int i, err; 335 336 err = s35390a_get_reg(s35390a, S35390A_CMD_STATUS2, &sts, sizeof(sts)); 337 if (err < 0) 338 return err; 339 340 if ((sts & S35390A_INT2_MODE_MASK) != S35390A_INT2_MODE_ALARM) { 341 /* 342 * When the alarm isn't enabled, the register to configure 343 * the alarm time isn't accessible. 344 */ 345 alm->enabled = 0; 346 return 0; 347 } else { 348 alm->enabled = 1; 349 } 350 351 err = s35390a_get_reg(s35390a, S35390A_CMD_INT2_REG1, buf, sizeof(buf)); 352 if (err < 0) 353 return err; 354 355 /* This chip returns the bits of each byte in reverse order */ 356 for (i = 0; i < 3; ++i) 357 buf[i] = bitrev8(buf[i]); 358 359 /* 360 * B0 of the three matching registers is an enable flag. Iff it is set 361 * the configured value is used for matching. 362 */ 363 if (buf[S35390A_ALRM_BYTE_WDAY] & 0x80) 364 alm->time.tm_wday = 365 bcd2bin(buf[S35390A_ALRM_BYTE_WDAY] & ~0x80); 366 367 if (buf[S35390A_ALRM_BYTE_HOURS] & 0x80) 368 alm->time.tm_hour = 369 s35390a_reg2hr(s35390a, 370 buf[S35390A_ALRM_BYTE_HOURS] & ~0x80); 371 372 if (buf[S35390A_ALRM_BYTE_MINS] & 0x80) 373 alm->time.tm_min = bcd2bin(buf[S35390A_ALRM_BYTE_MINS] & ~0x80); 374 375 /* alarm triggers always at s=0 */ 376 alm->time.tm_sec = 0; 377 378 dev_dbg(&client->dev, "%s: alm is mins=%d, hours=%d, wday=%d\n", 379 __func__, alm->time.tm_min, alm->time.tm_hour, 380 alm->time.tm_wday); 381 382 return 0; 383 } 384 385 static int s35390a_rtc_ioctl(struct device *dev, unsigned int cmd, 386 unsigned long arg) 387 { 388 struct i2c_client *client = to_i2c_client(dev); 389 struct s35390a *s35390a = i2c_get_clientdata(client); 390 char sts; 391 int err; 392 393 switch (cmd) { 394 case RTC_VL_READ: 395 /* s35390a_reset set lowvoltage flag and init RTC if needed */ 396 err = s35390a_read_status(s35390a, &sts); 397 if (err < 0) 398 return err; 399 if (copy_to_user((void __user *)arg, &err, sizeof(int))) 400 return -EFAULT; 401 break; 402 case RTC_VL_CLR: 403 /* update flag and clear register */ 404 err = s35390a_init(s35390a); 405 if (err < 0) 406 return err; 407 break; 408 default: 409 return -ENOIOCTLCMD; 410 } 411 412 return 0; 413 } 414 415 static const struct rtc_class_ops s35390a_rtc_ops = { 416 .read_time = s35390a_rtc_read_time, 417 .set_time = s35390a_rtc_set_time, 418 .set_alarm = s35390a_rtc_set_alarm, 419 .read_alarm = s35390a_rtc_read_alarm, 420 .ioctl = s35390a_rtc_ioctl, 421 }; 422 423 static int s35390a_probe(struct i2c_client *client) 424 { 425 int err, err_read; 426 unsigned int i; 427 struct s35390a *s35390a; 428 char buf, status1; 429 struct device *dev = &client->dev; 430 431 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) 432 return -ENODEV; 433 434 s35390a = devm_kzalloc(dev, sizeof(struct s35390a), GFP_KERNEL); 435 if (!s35390a) 436 return -ENOMEM; 437 438 s35390a->client[0] = client; 439 i2c_set_clientdata(client, s35390a); 440 441 /* This chip uses multiple addresses, use dummy devices for them */ 442 for (i = 1; i < 8; ++i) { 443 s35390a->client[i] = devm_i2c_new_dummy_device(dev, 444 client->adapter, 445 client->addr + i); 446 if (IS_ERR(s35390a->client[i])) { 447 dev_err(dev, "Address %02x unavailable\n", 448 client->addr + i); 449 return PTR_ERR(s35390a->client[i]); 450 } 451 } 452 453 s35390a->rtc = devm_rtc_allocate_device(dev); 454 if (IS_ERR(s35390a->rtc)) 455 return PTR_ERR(s35390a->rtc); 456 457 err_read = s35390a_read_status(s35390a, &status1); 458 if (err_read < 0) { 459 dev_err(dev, "error resetting chip\n"); 460 return err_read; 461 } 462 463 if (status1 & S35390A_FLAG_24H) 464 s35390a->twentyfourhour = 1; 465 else 466 s35390a->twentyfourhour = 0; 467 468 if (status1 & S35390A_FLAG_INT2) { 469 /* disable alarm (and maybe test mode) */ 470 buf = 0; 471 err = s35390a_set_reg(s35390a, S35390A_CMD_STATUS2, &buf, 1); 472 if (err < 0) { 473 dev_err(dev, "error disabling alarm"); 474 return err; 475 } 476 } else { 477 err = s35390a_disable_test_mode(s35390a); 478 if (err < 0) { 479 dev_err(dev, "error disabling test mode\n"); 480 return err; 481 } 482 } 483 484 device_set_wakeup_capable(dev, 1); 485 486 s35390a->rtc->ops = &s35390a_rtc_ops; 487 s35390a->rtc->range_min = RTC_TIMESTAMP_BEGIN_2000; 488 s35390a->rtc->range_max = RTC_TIMESTAMP_END_2099; 489 490 set_bit(RTC_FEATURE_ALARM_RES_MINUTE, s35390a->rtc->features); 491 clear_bit(RTC_FEATURE_UPDATE_INTERRUPT, s35390a->rtc->features ); 492 493 if (status1 & S35390A_FLAG_INT2) 494 rtc_update_irq(s35390a->rtc, 1, RTC_AF); 495 496 return devm_rtc_register_device(s35390a->rtc); 497 } 498 499 static struct i2c_driver s35390a_driver = { 500 .driver = { 501 .name = "rtc-s35390a", 502 .of_match_table = of_match_ptr(s35390a_of_match), 503 }, 504 .probe_new = s35390a_probe, 505 .id_table = s35390a_id, 506 }; 507 508 module_i2c_driver(s35390a_driver); 509 510 MODULE_AUTHOR("Byron Bradley <byron.bbradley@gmail.com>"); 511 MODULE_DESCRIPTION("S35390A RTC driver"); 512 MODULE_LICENSE("GPL"); 513