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 #define S35390A_CMD_FREE_REG 7 22 23 #define S35390A_BYTE_YEAR 0 24 #define S35390A_BYTE_MONTH 1 25 #define S35390A_BYTE_DAY 2 26 #define S35390A_BYTE_WDAY 3 27 #define S35390A_BYTE_HOURS 4 28 #define S35390A_BYTE_MINS 5 29 #define S35390A_BYTE_SECS 6 30 31 #define S35390A_ALRM_BYTE_WDAY 0 32 #define S35390A_ALRM_BYTE_HOURS 1 33 #define S35390A_ALRM_BYTE_MINS 2 34 35 /* flags for STATUS1 */ 36 #define S35390A_FLAG_POC BIT(0) 37 #define S35390A_FLAG_BLD BIT(1) 38 #define S35390A_FLAG_INT2 BIT(2) 39 #define S35390A_FLAG_24H BIT(6) 40 #define S35390A_FLAG_RESET BIT(7) 41 42 /* flag for STATUS2 */ 43 #define S35390A_FLAG_TEST BIT(0) 44 45 /* INT2 pin output mode */ 46 #define S35390A_INT2_MODE_MASK 0x0E 47 #define S35390A_INT2_MODE_NOINTR 0x00 48 #define S35390A_INT2_MODE_ALARM BIT(1) /* INT2AE */ 49 #define S35390A_INT2_MODE_PMIN_EDG BIT(2) /* INT2ME */ 50 #define S35390A_INT2_MODE_FREQ BIT(3) /* INT2FE */ 51 #define S35390A_INT2_MODE_PMIN (BIT(3) | BIT(2)) /* INT2FE | INT2ME */ 52 53 static const struct i2c_device_id s35390a_id[] = { 54 { "s35390a" }, 55 { } 56 }; 57 MODULE_DEVICE_TABLE(i2c, s35390a_id); 58 59 static const __maybe_unused struct of_device_id s35390a_of_match[] = { 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 int twentyfourhour; 68 }; 69 70 static int s35390a_set_reg(struct s35390a *s35390a, int reg, u8 *buf, int len) 71 { 72 struct i2c_client *client = s35390a->client[reg]; 73 struct i2c_msg msg[] = { 74 { 75 .addr = client->addr, 76 .len = len, 77 .buf = buf 78 }, 79 }; 80 81 if ((i2c_transfer(client->adapter, msg, 1)) != 1) 82 return -EIO; 83 84 return 0; 85 } 86 87 static int s35390a_get_reg(struct s35390a *s35390a, int reg, u8 *buf, int len) 88 { 89 struct i2c_client *client = s35390a->client[reg]; 90 struct i2c_msg msg[] = { 91 { 92 .addr = client->addr, 93 .flags = I2C_M_RD, 94 .len = len, 95 .buf = buf 96 }, 97 }; 98 99 if ((i2c_transfer(client->adapter, msg, 1)) != 1) 100 return -EIO; 101 102 return 0; 103 } 104 105 static int s35390a_init(struct s35390a *s35390a) 106 { 107 u8 buf; 108 int ret; 109 unsigned initcount = 0; 110 111 /* 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. 116 * 117 * The 24H bit is kept over reset, so set it already here. 118 */ 119 initialize: 120 buf = S35390A_FLAG_RESET | S35390A_FLAG_24H; 121 ret = s35390a_set_reg(s35390a, S35390A_CMD_STATUS1, &buf, 1); 122 123 if (ret < 0) 124 return ret; 125 126 ret = s35390a_get_reg(s35390a, S35390A_CMD_STATUS1, &buf, 1); 127 if (ret < 0) 128 return ret; 129 130 if (buf & (S35390A_FLAG_POC | S35390A_FLAG_BLD)) { 131 /* Try up to five times to reset the chip */ 132 if (initcount < 5) { 133 ++initcount; 134 goto initialize; 135 } else 136 return -EIO; 137 } 138 139 return 1; 140 } 141 142 /* 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. 146 */ 147 static int s35390a_read_status(struct s35390a *s35390a, char *status1) 148 { 149 int ret; 150 151 ret = s35390a_get_reg(s35390a, S35390A_CMD_STATUS1, status1, 1); 152 if (ret < 0) 153 return ret; 154 155 if (*status1 & S35390A_FLAG_POC) { 156 /* 157 * Do not communicate for 0.5 seconds since the power-on 158 * detection circuit is in operation. 159 */ 160 msleep(500); 161 return 1; 162 } else if (*status1 & S35390A_FLAG_BLD) 163 return 1; 164 /* 165 * If both POC and BLD are unset everything is fine. 166 */ 167 return 0; 168 } 169 170 static int s35390a_disable_test_mode(struct s35390a *s35390a) 171 { 172 u8 buf[1]; 173 174 if (s35390a_get_reg(s35390a, S35390A_CMD_STATUS2, buf, sizeof(buf)) < 0) 175 return -EIO; 176 177 if (!(buf[0] & S35390A_FLAG_TEST)) 178 return 0; 179 180 buf[0] &= ~S35390A_FLAG_TEST; 181 return s35390a_set_reg(s35390a, S35390A_CMD_STATUS2, buf, sizeof(buf)); 182 } 183 184 static char s35390a_hr2reg(struct s35390a *s35390a, int hour) 185 { 186 if (s35390a->twentyfourhour) 187 return bin2bcd(hour); 188 189 if (hour < 12) 190 return bin2bcd(hour); 191 192 return 0x40 | bin2bcd(hour - 12); 193 } 194 195 static int s35390a_reg2hr(struct s35390a *s35390a, char reg) 196 { 197 unsigned hour; 198 199 if (s35390a->twentyfourhour) 200 return bcd2bin(reg & 0x3f); 201 202 hour = bcd2bin(reg & 0x3f); 203 if (reg & 0x40) 204 hour += 12; 205 206 return hour; 207 } 208 209 static int s35390a_rtc_set_time(struct device *dev, struct rtc_time *tm) 210 { 211 struct i2c_client *client = to_i2c_client(dev); 212 struct s35390a *s35390a = i2c_get_clientdata(client); 213 int i; 214 u8 buf[7], status; 215 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, 219 tm->tm_wday); 220 221 if (s35390a_read_status(s35390a, &status) == 1) 222 s35390a_init(s35390a); 223 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); 231 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]); 235 236 return s35390a_set_reg(s35390a, S35390A_CMD_TIME1, buf, sizeof(buf)); 237 } 238 239 static int s35390a_rtc_read_time(struct device *dev, struct rtc_time *tm) 240 { 241 struct i2c_client *client = to_i2c_client(dev); 242 struct s35390a *s35390a = i2c_get_clientdata(client); 243 u8 buf[7], status; 244 int i, err; 245 246 if (s35390a_read_status(s35390a, &status) == 1) 247 return -EINVAL; 248 249 err = s35390a_get_reg(s35390a, S35390A_CMD_TIME1, buf, sizeof(buf)); 250 if (err < 0) 251 return err; 252 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]); 256 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; 264 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, 268 tm->tm_wday); 269 270 return 0; 271 } 272 273 static int s35390a_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm) 274 { 275 struct i2c_client *client = to_i2c_client(dev); 276 struct s35390a *s35390a = i2c_get_clientdata(client); 277 u8 buf[3], sts = 0; 278 int err, i; 279 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); 284 285 /* disable interrupt (which deasserts the irq line) */ 286 err = s35390a_set_reg(s35390a, S35390A_CMD_STATUS2, &sts, sizeof(sts)); 287 if (err < 0) 288 return err; 289 290 /* clear pending interrupt (in STATUS1 only), if any */ 291 err = s35390a_get_reg(s35390a, S35390A_CMD_STATUS1, &sts, sizeof(sts)); 292 if (err < 0) 293 return err; 294 295 if (alm->enabled) 296 sts = S35390A_INT2_MODE_ALARM; 297 else 298 sts = S35390A_INT2_MODE_NOINTR; 299 300 /* set interupt mode*/ 301 err = s35390a_set_reg(s35390a, S35390A_CMD_STATUS2, &sts, sizeof(sts)); 302 if (err < 0) 303 return err; 304 305 if (alm->time.tm_wday != -1) 306 buf[S35390A_ALRM_BYTE_WDAY] = bin2bcd(alm->time.tm_wday) | 0x80; 307 else 308 buf[S35390A_ALRM_BYTE_WDAY] = 0; 309 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; 313 314 if (alm->time.tm_hour >= 12) 315 buf[S35390A_ALRM_BYTE_HOURS] |= 0x40; 316 317 for (i = 0; i < 3; ++i) 318 buf[i] = bitrev8(buf[i]); 319 320 err = s35390a_set_reg(s35390a, S35390A_CMD_INT2_REG1, buf, 321 sizeof(buf)); 322 323 return err; 324 } 325 326 static int s35390a_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alm) 327 { 328 struct i2c_client *client = to_i2c_client(dev); 329 struct s35390a *s35390a = i2c_get_clientdata(client); 330 u8 buf[3], sts; 331 int i, err; 332 333 err = s35390a_get_reg(s35390a, S35390A_CMD_STATUS2, &sts, sizeof(sts)); 334 if (err < 0) 335 return err; 336 337 if ((sts & S35390A_INT2_MODE_MASK) != S35390A_INT2_MODE_ALARM) { 338 /* 339 * When the alarm isn't enabled, the register to configure 340 * the alarm time isn't accessible. 341 */ 342 alm->enabled = 0; 343 return 0; 344 } else { 345 alm->enabled = 1; 346 } 347 348 err = s35390a_get_reg(s35390a, S35390A_CMD_INT2_REG1, buf, sizeof(buf)); 349 if (err < 0) 350 return err; 351 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]); 355 356 /* 357 * B0 of the three matching registers is an enable flag. Iff it is set 358 * the configured value is used for matching. 359 */ 360 if (buf[S35390A_ALRM_BYTE_WDAY] & 0x80) 361 alm->time.tm_wday = 362 bcd2bin(buf[S35390A_ALRM_BYTE_WDAY] & ~0x80); 363 364 if (buf[S35390A_ALRM_BYTE_HOURS] & 0x80) 365 alm->time.tm_hour = 366 s35390a_reg2hr(s35390a, 367 buf[S35390A_ALRM_BYTE_HOURS] & ~0x80); 368 369 if (buf[S35390A_ALRM_BYTE_MINS] & 0x80) 370 alm->time.tm_min = bcd2bin(buf[S35390A_ALRM_BYTE_MINS] & ~0x80); 371 372 /* alarm triggers always at s=0 */ 373 alm->time.tm_sec = 0; 374 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, 377 alm->time.tm_wday); 378 379 return 0; 380 } 381 382 static int s35390a_rtc_ioctl(struct device *dev, unsigned int cmd, 383 unsigned long arg) 384 { 385 struct i2c_client *client = to_i2c_client(dev); 386 struct s35390a *s35390a = i2c_get_clientdata(client); 387 u8 sts; 388 int err; 389 390 switch (cmd) { 391 case RTC_VL_READ: 392 /* s35390a_reset set lowvoltage flag and init RTC if needed */ 393 err = s35390a_read_status(s35390a, &sts); 394 if (err < 0) 395 return err; 396 if (copy_to_user((void __user *)arg, &err, sizeof(int))) 397 return -EFAULT; 398 break; 399 case RTC_VL_CLR: 400 /* update flag and clear register */ 401 err = s35390a_init(s35390a); 402 if (err < 0) 403 return err; 404 break; 405 default: 406 return -ENOIOCTLCMD; 407 } 408 409 return 0; 410 } 411 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, 418 }; 419 420 static int s35390a_nvmem_read(void *priv, unsigned int offset, void *val, 421 size_t bytes) 422 { 423 struct s35390a *s35390a = priv; 424 425 /* The offset is ignored because the NVMEM region is only 1 byte */ 426 return s35390a_get_reg(s35390a, S35390A_CMD_FREE_REG, val, bytes); 427 } 428 429 static int s35390a_nvmem_write(void *priv, unsigned int offset, void *val, 430 size_t bytes) 431 { 432 struct s35390a *s35390a = priv; 433 434 return s35390a_set_reg(s35390a, S35390A_CMD_FREE_REG, val, bytes); 435 } 436 437 static int s35390a_probe(struct i2c_client *client) 438 { 439 int err, err_read; 440 unsigned int i; 441 struct s35390a *s35390a; 442 struct rtc_device *rtc; 443 u8 buf, status1; 444 struct device *dev = &client->dev; 445 struct nvmem_config nvmem_cfg = { 446 .name = "s35390a_nvram", 447 .type = NVMEM_TYPE_BATTERY_BACKED, 448 .word_size = 1, 449 .stride = 1, 450 .size = 1, 451 .reg_read = s35390a_nvmem_read, 452 .reg_write = s35390a_nvmem_write, 453 }; 454 455 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) 456 return -ENODEV; 457 458 s35390a = devm_kzalloc(dev, sizeof(struct s35390a), GFP_KERNEL); 459 if (!s35390a) 460 return -ENOMEM; 461 462 s35390a->client[0] = client; 463 i2c_set_clientdata(client, s35390a); 464 465 /* This chip uses multiple addresses, use dummy devices for them */ 466 for (i = 1; i < 8; ++i) { 467 s35390a->client[i] = devm_i2c_new_dummy_device(dev, 468 client->adapter, 469 client->addr + i); 470 if (IS_ERR(s35390a->client[i])) { 471 dev_err(dev, "Address %02x unavailable\n", 472 client->addr + i); 473 return PTR_ERR(s35390a->client[i]); 474 } 475 } 476 477 rtc = devm_rtc_allocate_device(dev); 478 if (IS_ERR(rtc)) 479 return PTR_ERR(rtc); 480 481 err_read = s35390a_read_status(s35390a, &status1); 482 if (err_read < 0) { 483 dev_err(dev, "error resetting chip\n"); 484 return err_read; 485 } 486 487 if (status1 & S35390A_FLAG_24H) 488 s35390a->twentyfourhour = 1; 489 else 490 s35390a->twentyfourhour = 0; 491 492 if (status1 & S35390A_FLAG_INT2) { 493 /* disable alarm (and maybe test mode) */ 494 buf = 0; 495 err = s35390a_set_reg(s35390a, S35390A_CMD_STATUS2, &buf, 1); 496 if (err < 0) { 497 dev_err(dev, "error disabling alarm"); 498 return err; 499 } 500 } else { 501 err = s35390a_disable_test_mode(s35390a); 502 if (err < 0) { 503 dev_err(dev, "error disabling test mode\n"); 504 return err; 505 } 506 } 507 508 device_set_wakeup_capable(dev, 1); 509 510 rtc->ops = &s35390a_rtc_ops; 511 rtc->range_min = RTC_TIMESTAMP_BEGIN_2000; 512 rtc->range_max = RTC_TIMESTAMP_END_2099; 513 514 set_bit(RTC_FEATURE_ALARM_RES_MINUTE, rtc->features); 515 clear_bit(RTC_FEATURE_UPDATE_INTERRUPT, rtc->features); 516 517 if (status1 & S35390A_FLAG_INT2) 518 rtc_update_irq(rtc, 1, RTC_AF); 519 520 nvmem_cfg.priv = s35390a; 521 err = devm_rtc_nvmem_register(rtc, &nvmem_cfg); 522 if (err) 523 return err; 524 525 return devm_rtc_register_device(rtc); 526 } 527 528 static struct i2c_driver s35390a_driver = { 529 .driver = { 530 .name = "rtc-s35390a", 531 .of_match_table = of_match_ptr(s35390a_of_match), 532 }, 533 .probe = s35390a_probe, 534 .id_table = s35390a_id, 535 }; 536 537 module_i2c_driver(s35390a_driver); 538 539 MODULE_AUTHOR("Byron Bradley <byron.bbradley@gmail.com>"); 540 MODULE_DESCRIPTION("S35390A RTC driver"); 541 MODULE_LICENSE("GPL"); 542