1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * RTC driver for the Micro Crystal RV8803 4 * 5 * Copyright (C) 2015 Micro Crystal SA 6 * Alexandre Belloni <alexandre.belloni@bootlin.com> 7 * 8 */ 9 10 #include <linux/bcd.h> 11 #include <linux/bitops.h> 12 #include <linux/log2.h> 13 #include <linux/i2c.h> 14 #include <linux/interrupt.h> 15 #include <linux/kernel.h> 16 #include <linux/module.h> 17 #include <linux/of_device.h> 18 #include <linux/rtc.h> 19 20 #define RV8803_I2C_TRY_COUNT 4 21 22 #define RV8803_SEC 0x00 23 #define RV8803_MIN 0x01 24 #define RV8803_HOUR 0x02 25 #define RV8803_WEEK 0x03 26 #define RV8803_DAY 0x04 27 #define RV8803_MONTH 0x05 28 #define RV8803_YEAR 0x06 29 #define RV8803_RAM 0x07 30 #define RV8803_ALARM_MIN 0x08 31 #define RV8803_ALARM_HOUR 0x09 32 #define RV8803_ALARM_WEEK_OR_DAY 0x0A 33 #define RV8803_EXT 0x0D 34 #define RV8803_FLAG 0x0E 35 #define RV8803_CTRL 0x0F 36 37 #define RV8803_EXT_WADA BIT(6) 38 39 #define RV8803_FLAG_V1F BIT(0) 40 #define RV8803_FLAG_V2F BIT(1) 41 #define RV8803_FLAG_AF BIT(3) 42 #define RV8803_FLAG_TF BIT(4) 43 #define RV8803_FLAG_UF BIT(5) 44 45 #define RV8803_CTRL_RESET BIT(0) 46 47 #define RV8803_CTRL_EIE BIT(2) 48 #define RV8803_CTRL_AIE BIT(3) 49 #define RV8803_CTRL_TIE BIT(4) 50 #define RV8803_CTRL_UIE BIT(5) 51 52 #define RX8900_BACKUP_CTRL 0x18 53 #define RX8900_FLAG_SWOFF BIT(2) 54 #define RX8900_FLAG_VDETOFF BIT(3) 55 56 enum rv8803_type { 57 rv_8803, 58 rx_8900 59 }; 60 61 struct rv8803_data { 62 struct i2c_client *client; 63 struct rtc_device *rtc; 64 struct mutex flags_lock; 65 u8 ctrl; 66 enum rv8803_type type; 67 }; 68 69 static int rv8803_read_reg(const struct i2c_client *client, u8 reg) 70 { 71 int try = RV8803_I2C_TRY_COUNT; 72 s32 ret; 73 74 /* 75 * There is a 61µs window during which the RTC does not acknowledge I2C 76 * transfers. In that case, ensure that there are multiple attempts. 77 */ 78 do 79 ret = i2c_smbus_read_byte_data(client, reg); 80 while ((ret == -ENXIO || ret == -EIO) && --try); 81 if (ret < 0) 82 dev_err(&client->dev, "Unable to read register 0x%02x\n", reg); 83 84 return ret; 85 } 86 87 static int rv8803_read_regs(const struct i2c_client *client, 88 u8 reg, u8 count, u8 *values) 89 { 90 int try = RV8803_I2C_TRY_COUNT; 91 s32 ret; 92 93 do 94 ret = i2c_smbus_read_i2c_block_data(client, reg, count, values); 95 while ((ret == -ENXIO || ret == -EIO) && --try); 96 if (ret != count) { 97 dev_err(&client->dev, 98 "Unable to read registers 0x%02x..0x%02x\n", 99 reg, reg + count - 1); 100 return ret < 0 ? ret : -EIO; 101 } 102 103 return 0; 104 } 105 106 static int rv8803_write_reg(const struct i2c_client *client, u8 reg, u8 value) 107 { 108 int try = RV8803_I2C_TRY_COUNT; 109 s32 ret; 110 111 do 112 ret = i2c_smbus_write_byte_data(client, reg, value); 113 while ((ret == -ENXIO || ret == -EIO) && --try); 114 if (ret) 115 dev_err(&client->dev, "Unable to write register 0x%02x\n", reg); 116 117 return ret; 118 } 119 120 static int rv8803_write_regs(const struct i2c_client *client, 121 u8 reg, u8 count, const u8 *values) 122 { 123 int try = RV8803_I2C_TRY_COUNT; 124 s32 ret; 125 126 do 127 ret = i2c_smbus_write_i2c_block_data(client, reg, count, 128 values); 129 while ((ret == -ENXIO || ret == -EIO) && --try); 130 if (ret) 131 dev_err(&client->dev, 132 "Unable to write registers 0x%02x..0x%02x\n", 133 reg, reg + count - 1); 134 135 return ret; 136 } 137 138 static irqreturn_t rv8803_handle_irq(int irq, void *dev_id) 139 { 140 struct i2c_client *client = dev_id; 141 struct rv8803_data *rv8803 = i2c_get_clientdata(client); 142 unsigned long events = 0; 143 int flags; 144 145 mutex_lock(&rv8803->flags_lock); 146 147 flags = rv8803_read_reg(client, RV8803_FLAG); 148 if (flags <= 0) { 149 mutex_unlock(&rv8803->flags_lock); 150 return IRQ_NONE; 151 } 152 153 if (flags & RV8803_FLAG_V1F) 154 dev_warn(&client->dev, "Voltage low, temperature compensation stopped.\n"); 155 156 if (flags & RV8803_FLAG_V2F) 157 dev_warn(&client->dev, "Voltage low, data loss detected.\n"); 158 159 if (flags & RV8803_FLAG_TF) { 160 flags &= ~RV8803_FLAG_TF; 161 rv8803->ctrl &= ~RV8803_CTRL_TIE; 162 events |= RTC_PF; 163 } 164 165 if (flags & RV8803_FLAG_AF) { 166 flags &= ~RV8803_FLAG_AF; 167 rv8803->ctrl &= ~RV8803_CTRL_AIE; 168 events |= RTC_AF; 169 } 170 171 if (flags & RV8803_FLAG_UF) { 172 flags &= ~RV8803_FLAG_UF; 173 rv8803->ctrl &= ~RV8803_CTRL_UIE; 174 events |= RTC_UF; 175 } 176 177 if (events) { 178 rtc_update_irq(rv8803->rtc, 1, events); 179 rv8803_write_reg(client, RV8803_FLAG, flags); 180 rv8803_write_reg(rv8803->client, RV8803_CTRL, rv8803->ctrl); 181 } 182 183 mutex_unlock(&rv8803->flags_lock); 184 185 return IRQ_HANDLED; 186 } 187 188 static int rv8803_get_time(struct device *dev, struct rtc_time *tm) 189 { 190 struct rv8803_data *rv8803 = dev_get_drvdata(dev); 191 u8 date1[7]; 192 u8 date2[7]; 193 u8 *date = date1; 194 int ret, flags; 195 196 flags = rv8803_read_reg(rv8803->client, RV8803_FLAG); 197 if (flags < 0) 198 return flags; 199 200 if (flags & RV8803_FLAG_V2F) { 201 dev_warn(dev, "Voltage low, data is invalid.\n"); 202 return -EINVAL; 203 } 204 205 ret = rv8803_read_regs(rv8803->client, RV8803_SEC, 7, date); 206 if (ret) 207 return ret; 208 209 if ((date1[RV8803_SEC] & 0x7f) == bin2bcd(59)) { 210 ret = rv8803_read_regs(rv8803->client, RV8803_SEC, 7, date2); 211 if (ret) 212 return ret; 213 214 if ((date2[RV8803_SEC] & 0x7f) != bin2bcd(59)) 215 date = date2; 216 } 217 218 tm->tm_sec = bcd2bin(date[RV8803_SEC] & 0x7f); 219 tm->tm_min = bcd2bin(date[RV8803_MIN] & 0x7f); 220 tm->tm_hour = bcd2bin(date[RV8803_HOUR] & 0x3f); 221 tm->tm_wday = ilog2(date[RV8803_WEEK] & 0x7f); 222 tm->tm_mday = bcd2bin(date[RV8803_DAY] & 0x3f); 223 tm->tm_mon = bcd2bin(date[RV8803_MONTH] & 0x1f) - 1; 224 tm->tm_year = bcd2bin(date[RV8803_YEAR]) + 100; 225 226 return 0; 227 } 228 229 static int rv8803_set_time(struct device *dev, struct rtc_time *tm) 230 { 231 struct rv8803_data *rv8803 = dev_get_drvdata(dev); 232 u8 date[7]; 233 int ctrl, flags, ret; 234 235 ctrl = rv8803_read_reg(rv8803->client, RV8803_CTRL); 236 if (ctrl < 0) 237 return ctrl; 238 239 /* Stop the clock */ 240 ret = rv8803_write_reg(rv8803->client, RV8803_CTRL, 241 ctrl | RV8803_CTRL_RESET); 242 if (ret) 243 return ret; 244 245 date[RV8803_SEC] = bin2bcd(tm->tm_sec); 246 date[RV8803_MIN] = bin2bcd(tm->tm_min); 247 date[RV8803_HOUR] = bin2bcd(tm->tm_hour); 248 date[RV8803_WEEK] = 1 << (tm->tm_wday); 249 date[RV8803_DAY] = bin2bcd(tm->tm_mday); 250 date[RV8803_MONTH] = bin2bcd(tm->tm_mon + 1); 251 date[RV8803_YEAR] = bin2bcd(tm->tm_year - 100); 252 253 ret = rv8803_write_regs(rv8803->client, RV8803_SEC, 7, date); 254 if (ret) 255 return ret; 256 257 /* Restart the clock */ 258 ret = rv8803_write_reg(rv8803->client, RV8803_CTRL, 259 ctrl & ~RV8803_CTRL_RESET); 260 if (ret) 261 return ret; 262 263 mutex_lock(&rv8803->flags_lock); 264 265 flags = rv8803_read_reg(rv8803->client, RV8803_FLAG); 266 if (flags < 0) { 267 mutex_unlock(&rv8803->flags_lock); 268 return flags; 269 } 270 271 ret = rv8803_write_reg(rv8803->client, RV8803_FLAG, 272 flags & ~(RV8803_FLAG_V1F | RV8803_FLAG_V2F)); 273 274 mutex_unlock(&rv8803->flags_lock); 275 276 return ret; 277 } 278 279 static int rv8803_get_alarm(struct device *dev, struct rtc_wkalrm *alrm) 280 { 281 struct rv8803_data *rv8803 = dev_get_drvdata(dev); 282 struct i2c_client *client = rv8803->client; 283 u8 alarmvals[3]; 284 int flags, ret; 285 286 ret = rv8803_read_regs(client, RV8803_ALARM_MIN, 3, alarmvals); 287 if (ret) 288 return ret; 289 290 flags = rv8803_read_reg(client, RV8803_FLAG); 291 if (flags < 0) 292 return flags; 293 294 alrm->time.tm_sec = 0; 295 alrm->time.tm_min = bcd2bin(alarmvals[0] & 0x7f); 296 alrm->time.tm_hour = bcd2bin(alarmvals[1] & 0x3f); 297 alrm->time.tm_mday = bcd2bin(alarmvals[2] & 0x3f); 298 299 alrm->enabled = !!(rv8803->ctrl & RV8803_CTRL_AIE); 300 alrm->pending = (flags & RV8803_FLAG_AF) && alrm->enabled; 301 302 return 0; 303 } 304 305 static int rv8803_set_alarm(struct device *dev, struct rtc_wkalrm *alrm) 306 { 307 struct i2c_client *client = to_i2c_client(dev); 308 struct rv8803_data *rv8803 = dev_get_drvdata(dev); 309 u8 alarmvals[3]; 310 u8 ctrl[2]; 311 int ret, err; 312 313 /* The alarm has no seconds, round up to nearest minute */ 314 if (alrm->time.tm_sec) { 315 time64_t alarm_time = rtc_tm_to_time64(&alrm->time); 316 317 alarm_time += 60 - alrm->time.tm_sec; 318 rtc_time64_to_tm(alarm_time, &alrm->time); 319 } 320 321 mutex_lock(&rv8803->flags_lock); 322 323 ret = rv8803_read_regs(client, RV8803_FLAG, 2, ctrl); 324 if (ret) { 325 mutex_unlock(&rv8803->flags_lock); 326 return ret; 327 } 328 329 alarmvals[0] = bin2bcd(alrm->time.tm_min); 330 alarmvals[1] = bin2bcd(alrm->time.tm_hour); 331 alarmvals[2] = bin2bcd(alrm->time.tm_mday); 332 333 if (rv8803->ctrl & (RV8803_CTRL_AIE | RV8803_CTRL_UIE)) { 334 rv8803->ctrl &= ~(RV8803_CTRL_AIE | RV8803_CTRL_UIE); 335 err = rv8803_write_reg(rv8803->client, RV8803_CTRL, 336 rv8803->ctrl); 337 if (err) { 338 mutex_unlock(&rv8803->flags_lock); 339 return err; 340 } 341 } 342 343 ctrl[1] &= ~RV8803_FLAG_AF; 344 err = rv8803_write_reg(rv8803->client, RV8803_FLAG, ctrl[1]); 345 mutex_unlock(&rv8803->flags_lock); 346 if (err) 347 return err; 348 349 err = rv8803_write_regs(rv8803->client, RV8803_ALARM_MIN, 3, alarmvals); 350 if (err) 351 return err; 352 353 if (alrm->enabled) { 354 if (rv8803->rtc->uie_rtctimer.enabled) 355 rv8803->ctrl |= RV8803_CTRL_UIE; 356 if (rv8803->rtc->aie_timer.enabled) 357 rv8803->ctrl |= RV8803_CTRL_AIE; 358 359 err = rv8803_write_reg(rv8803->client, RV8803_CTRL, 360 rv8803->ctrl); 361 if (err) 362 return err; 363 } 364 365 return 0; 366 } 367 368 static int rv8803_alarm_irq_enable(struct device *dev, unsigned int enabled) 369 { 370 struct i2c_client *client = to_i2c_client(dev); 371 struct rv8803_data *rv8803 = dev_get_drvdata(dev); 372 int ctrl, flags, err; 373 374 ctrl = rv8803->ctrl; 375 376 if (enabled) { 377 if (rv8803->rtc->uie_rtctimer.enabled) 378 ctrl |= RV8803_CTRL_UIE; 379 if (rv8803->rtc->aie_timer.enabled) 380 ctrl |= RV8803_CTRL_AIE; 381 } else { 382 if (!rv8803->rtc->uie_rtctimer.enabled) 383 ctrl &= ~RV8803_CTRL_UIE; 384 if (!rv8803->rtc->aie_timer.enabled) 385 ctrl &= ~RV8803_CTRL_AIE; 386 } 387 388 mutex_lock(&rv8803->flags_lock); 389 flags = rv8803_read_reg(client, RV8803_FLAG); 390 if (flags < 0) { 391 mutex_unlock(&rv8803->flags_lock); 392 return flags; 393 } 394 flags &= ~(RV8803_FLAG_AF | RV8803_FLAG_UF); 395 err = rv8803_write_reg(client, RV8803_FLAG, flags); 396 mutex_unlock(&rv8803->flags_lock); 397 if (err) 398 return err; 399 400 if (ctrl != rv8803->ctrl) { 401 rv8803->ctrl = ctrl; 402 err = rv8803_write_reg(client, RV8803_CTRL, rv8803->ctrl); 403 if (err) 404 return err; 405 } 406 407 return 0; 408 } 409 410 static int rv8803_ioctl(struct device *dev, unsigned int cmd, unsigned long arg) 411 { 412 struct i2c_client *client = to_i2c_client(dev); 413 struct rv8803_data *rv8803 = dev_get_drvdata(dev); 414 unsigned int vl = 0; 415 int flags, ret = 0; 416 417 switch (cmd) { 418 case RTC_VL_READ: 419 flags = rv8803_read_reg(client, RV8803_FLAG); 420 if (flags < 0) 421 return flags; 422 423 if (flags & RV8803_FLAG_V1F) { 424 dev_warn(&client->dev, "Voltage low, temperature compensation stopped.\n"); 425 vl = RTC_VL_ACCURACY_LOW; 426 } 427 428 if (flags & RV8803_FLAG_V2F) 429 vl |= RTC_VL_DATA_INVALID; 430 431 return put_user(vl, (unsigned int __user *)arg); 432 433 case RTC_VL_CLR: 434 mutex_lock(&rv8803->flags_lock); 435 flags = rv8803_read_reg(client, RV8803_FLAG); 436 if (flags < 0) { 437 mutex_unlock(&rv8803->flags_lock); 438 return flags; 439 } 440 441 flags &= ~RV8803_FLAG_V1F; 442 ret = rv8803_write_reg(client, RV8803_FLAG, flags); 443 mutex_unlock(&rv8803->flags_lock); 444 if (ret) 445 return ret; 446 447 return 0; 448 449 default: 450 return -ENOIOCTLCMD; 451 } 452 } 453 454 static int rv8803_nvram_write(void *priv, unsigned int offset, void *val, 455 size_t bytes) 456 { 457 return rv8803_write_reg(priv, RV8803_RAM, *(u8 *)val); 458 } 459 460 static int rv8803_nvram_read(void *priv, unsigned int offset, 461 void *val, size_t bytes) 462 { 463 int ret; 464 465 ret = rv8803_read_reg(priv, RV8803_RAM); 466 if (ret < 0) 467 return ret; 468 469 *(u8 *)val = ret; 470 471 return 0; 472 } 473 474 static const struct rtc_class_ops rv8803_rtc_ops = { 475 .read_time = rv8803_get_time, 476 .set_time = rv8803_set_time, 477 .ioctl = rv8803_ioctl, 478 .read_alarm = rv8803_get_alarm, 479 .set_alarm = rv8803_set_alarm, 480 .alarm_irq_enable = rv8803_alarm_irq_enable, 481 }; 482 483 static int rx8900_trickle_charger_init(struct rv8803_data *rv8803) 484 { 485 struct i2c_client *client = rv8803->client; 486 struct device_node *node = client->dev.of_node; 487 int err; 488 u8 flags; 489 490 if (!node) 491 return 0; 492 493 if (rv8803->type != rx_8900) 494 return 0; 495 496 err = i2c_smbus_read_byte_data(rv8803->client, RX8900_BACKUP_CTRL); 497 if (err < 0) 498 return err; 499 500 flags = ~(RX8900_FLAG_VDETOFF | RX8900_FLAG_SWOFF) & (u8)err; 501 502 if (of_property_read_bool(node, "epson,vdet-disable")) 503 flags |= RX8900_FLAG_VDETOFF; 504 505 if (of_property_read_bool(node, "trickle-diode-disable")) 506 flags |= RX8900_FLAG_SWOFF; 507 508 return i2c_smbus_write_byte_data(rv8803->client, RX8900_BACKUP_CTRL, 509 flags); 510 } 511 512 static int rv8803_probe(struct i2c_client *client, 513 const struct i2c_device_id *id) 514 { 515 struct i2c_adapter *adapter = client->adapter; 516 struct rv8803_data *rv8803; 517 int err, flags; 518 struct nvmem_config nvmem_cfg = { 519 .name = "rv8803_nvram", 520 .word_size = 1, 521 .stride = 1, 522 .size = 1, 523 .reg_read = rv8803_nvram_read, 524 .reg_write = rv8803_nvram_write, 525 .priv = client, 526 }; 527 528 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA | 529 I2C_FUNC_SMBUS_I2C_BLOCK)) { 530 dev_err(&adapter->dev, "doesn't support I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_I2C_BLOCK\n"); 531 return -EIO; 532 } 533 534 rv8803 = devm_kzalloc(&client->dev, sizeof(struct rv8803_data), 535 GFP_KERNEL); 536 if (!rv8803) 537 return -ENOMEM; 538 539 mutex_init(&rv8803->flags_lock); 540 rv8803->client = client; 541 if (client->dev.of_node) 542 rv8803->type = (enum rv8803_type) 543 of_device_get_match_data(&client->dev); 544 else 545 rv8803->type = id->driver_data; 546 i2c_set_clientdata(client, rv8803); 547 548 flags = rv8803_read_reg(client, RV8803_FLAG); 549 if (flags < 0) 550 return flags; 551 552 if (flags & RV8803_FLAG_V1F) 553 dev_warn(&client->dev, "Voltage low, temperature compensation stopped.\n"); 554 555 if (flags & RV8803_FLAG_V2F) 556 dev_warn(&client->dev, "Voltage low, data loss detected.\n"); 557 558 if (flags & RV8803_FLAG_AF) 559 dev_warn(&client->dev, "An alarm maybe have been missed.\n"); 560 561 rv8803->rtc = devm_rtc_allocate_device(&client->dev); 562 if (IS_ERR(rv8803->rtc)) 563 return PTR_ERR(rv8803->rtc); 564 565 if (client->irq > 0) { 566 err = devm_request_threaded_irq(&client->dev, client->irq, 567 NULL, rv8803_handle_irq, 568 IRQF_TRIGGER_LOW | IRQF_ONESHOT, 569 "rv8803", client); 570 if (err) { 571 dev_warn(&client->dev, "unable to request IRQ, alarms disabled\n"); 572 client->irq = 0; 573 } 574 } 575 if (!client->irq) 576 clear_bit(RTC_FEATURE_ALARM, rv8803->rtc->features); 577 578 err = rv8803_write_reg(rv8803->client, RV8803_EXT, RV8803_EXT_WADA); 579 if (err) 580 return err; 581 582 err = rx8900_trickle_charger_init(rv8803); 583 if (err) { 584 dev_err(&client->dev, "failed to init charger\n"); 585 return err; 586 } 587 588 rv8803->rtc->ops = &rv8803_rtc_ops; 589 rv8803->rtc->range_min = RTC_TIMESTAMP_BEGIN_2000; 590 rv8803->rtc->range_max = RTC_TIMESTAMP_END_2099; 591 err = devm_rtc_register_device(rv8803->rtc); 592 if (err) 593 return err; 594 595 devm_rtc_nvmem_register(rv8803->rtc, &nvmem_cfg); 596 597 rv8803->rtc->max_user_freq = 1; 598 599 return 0; 600 } 601 602 static const struct i2c_device_id rv8803_id[] = { 603 { "rv8803", rv_8803 }, 604 { "rx8803", rv_8803 }, 605 { "rx8900", rx_8900 }, 606 { } 607 }; 608 MODULE_DEVICE_TABLE(i2c, rv8803_id); 609 610 static const __maybe_unused struct of_device_id rv8803_of_match[] = { 611 { 612 .compatible = "microcrystal,rv8803", 613 .data = (void *)rv_8803 614 }, 615 { 616 .compatible = "epson,rx8803", 617 .data = (void *)rv_8803 618 }, 619 { 620 .compatible = "epson,rx8900", 621 .data = (void *)rx_8900 622 }, 623 { } 624 }; 625 MODULE_DEVICE_TABLE(of, rv8803_of_match); 626 627 static struct i2c_driver rv8803_driver = { 628 .driver = { 629 .name = "rtc-rv8803", 630 .of_match_table = of_match_ptr(rv8803_of_match), 631 }, 632 .probe = rv8803_probe, 633 .id_table = rv8803_id, 634 }; 635 module_i2c_driver(rv8803_driver); 636 637 MODULE_AUTHOR("Alexandre Belloni <alexandre.belloni@bootlin.com>"); 638 MODULE_DESCRIPTION("Micro Crystal RV8803 RTC driver"); 639 MODULE_LICENSE("GPL v2"); 640