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 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 if (alm->time.tm_sec != 0) 289 dev_warn(&client->dev, "Alarms are only supported on a per minute basis!\n"); 290 291 /* disable interrupt (which deasserts the irq line) */ 292 err = s35390a_set_reg(s35390a, S35390A_CMD_STATUS2, &sts, sizeof(sts)); 293 if (err < 0) 294 return err; 295 296 /* clear pending interrupt (in STATUS1 only), if any */ 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 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; 313 else 314 buf[S35390A_ALRM_BYTE_WDAY] = 0; 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 332 static int s35390a_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alm) 333 { 334 struct i2c_client *client = to_i2c_client(dev); 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 343 if ((sts & S35390A_INT2_MODE_MASK) != S35390A_INT2_MODE_ALARM) { 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 } 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 */ 359 for (i = 0; i < 3; ++i) 360 buf[i] = bitrev8(buf[i]); 361 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; 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 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 418 static const struct rtc_class_ops s35390a_rtc_ops = { 419 .read_time = s35390a_rtc_read_time, 420 .set_time = s35390a_rtc_set_time, 421 .set_alarm = s35390a_rtc_set_alarm, 422 .read_alarm = s35390a_rtc_read_alarm, 423 .ioctl = s35390a_rtc_ioctl, 424 }; 425 426 static struct i2c_driver s35390a_driver; 427 428 static int s35390a_probe(struct i2c_client *client, 429 const struct i2c_device_id *id) 430 { 431 int err, err_read; 432 unsigned int i; 433 struct s35390a *s35390a; 434 char buf, status1; 435 struct device *dev = &client->dev; 436 437 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) 438 return -ENODEV; 439 440 s35390a = devm_kzalloc(dev, sizeof(struct s35390a), GFP_KERNEL); 441 if (!s35390a) 442 return -ENOMEM; 443 444 s35390a->client[0] = client; 445 i2c_set_clientdata(client, s35390a); 446 447 /* This chip uses multiple addresses, use dummy devices for them */ 448 for (i = 1; i < 8; ++i) { 449 s35390a->client[i] = devm_i2c_new_dummy_device(dev, 450 client->adapter, 451 client->addr + i); 452 if (IS_ERR(s35390a->client[i])) { 453 dev_err(dev, "Address %02x unavailable\n", 454 client->addr + i); 455 return PTR_ERR(s35390a->client[i]); 456 } 457 } 458 459 err_read = s35390a_read_status(s35390a, &status1); 460 if (err_read < 0) { 461 dev_err(dev, "error resetting chip\n"); 462 return err_read; 463 } 464 465 if (status1 & S35390A_FLAG_24H) 466 s35390a->twentyfourhour = 1; 467 else 468 s35390a->twentyfourhour = 0; 469 470 if (status1 & S35390A_FLAG_INT2) { 471 /* disable alarm (and maybe test mode) */ 472 buf = 0; 473 err = s35390a_set_reg(s35390a, S35390A_CMD_STATUS2, &buf, 1); 474 if (err < 0) { 475 dev_err(dev, "error disabling alarm"); 476 return err; 477 } 478 } else { 479 err = s35390a_disable_test_mode(s35390a); 480 if (err < 0) { 481 dev_err(dev, "error disabling test mode\n"); 482 return err; 483 } 484 } 485 486 device_set_wakeup_capable(dev, 1); 487 488 s35390a->rtc = devm_rtc_device_register(dev, s35390a_driver.driver.name, 489 &s35390a_rtc_ops, THIS_MODULE); 490 491 if (IS_ERR(s35390a->rtc)) 492 return PTR_ERR(s35390a->rtc); 493 494 /* supports per-minute alarms only, therefore set uie_unsupported */ 495 s35390a->rtc->uie_unsupported = 1; 496 497 if (status1 & S35390A_FLAG_INT2) 498 rtc_update_irq(s35390a->rtc, 1, RTC_AF); 499 500 return 0; 501 } 502 503 static struct i2c_driver s35390a_driver = { 504 .driver = { 505 .name = "rtc-s35390a", 506 .of_match_table = of_match_ptr(s35390a_of_match), 507 }, 508 .probe = s35390a_probe, 509 .id_table = s35390a_id, 510 }; 511 512 module_i2c_driver(s35390a_driver); 513 514 MODULE_AUTHOR("Byron Bradley <byron.bbradley@gmail.com>"); 515 MODULE_DESCRIPTION("S35390A RTC driver"); 516 MODULE_LICENSE("GPL"); 517