1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * RTC driver for the Micro Crystal RV3028 4 * 5 * Copyright (C) 2019 Micro Crystal SA 6 * 7 * Alexandre Belloni <alexandre.belloni@bootlin.com> 8 * 9 */ 10 11 #include <linux/clk-provider.h> 12 #include <linux/bcd.h> 13 #include <linux/bitops.h> 14 #include <linux/i2c.h> 15 #include <linux/interrupt.h> 16 #include <linux/kernel.h> 17 #include <linux/log2.h> 18 #include <linux/module.h> 19 #include <linux/of_device.h> 20 #include <linux/regmap.h> 21 #include <linux/rtc.h> 22 23 #define RV3028_SEC 0x00 24 #define RV3028_MIN 0x01 25 #define RV3028_HOUR 0x02 26 #define RV3028_WDAY 0x03 27 #define RV3028_DAY 0x04 28 #define RV3028_MONTH 0x05 29 #define RV3028_YEAR 0x06 30 #define RV3028_ALARM_MIN 0x07 31 #define RV3028_ALARM_HOUR 0x08 32 #define RV3028_ALARM_DAY 0x09 33 #define RV3028_STATUS 0x0E 34 #define RV3028_CTRL1 0x0F 35 #define RV3028_CTRL2 0x10 36 #define RV3028_EVT_CTRL 0x13 37 #define RV3028_TS_COUNT 0x14 38 #define RV3028_TS_SEC 0x15 39 #define RV3028_RAM1 0x1F 40 #define RV3028_EEPROM_ADDR 0x25 41 #define RV3028_EEPROM_DATA 0x26 42 #define RV3028_EEPROM_CMD 0x27 43 #define RV3028_CLKOUT 0x35 44 #define RV3028_OFFSET 0x36 45 #define RV3028_BACKUP 0x37 46 47 #define RV3028_STATUS_PORF BIT(0) 48 #define RV3028_STATUS_EVF BIT(1) 49 #define RV3028_STATUS_AF BIT(2) 50 #define RV3028_STATUS_TF BIT(3) 51 #define RV3028_STATUS_UF BIT(4) 52 #define RV3028_STATUS_BSF BIT(5) 53 #define RV3028_STATUS_CLKF BIT(6) 54 #define RV3028_STATUS_EEBUSY BIT(7) 55 56 #define RV3028_CLKOUT_FD_MASK GENMASK(2, 0) 57 #define RV3028_CLKOUT_PORIE BIT(3) 58 #define RV3028_CLKOUT_CLKSY BIT(6) 59 #define RV3028_CLKOUT_CLKOE BIT(7) 60 61 #define RV3028_CTRL1_EERD BIT(3) 62 #define RV3028_CTRL1_WADA BIT(5) 63 64 #define RV3028_CTRL2_RESET BIT(0) 65 #define RV3028_CTRL2_12_24 BIT(1) 66 #define RV3028_CTRL2_EIE BIT(2) 67 #define RV3028_CTRL2_AIE BIT(3) 68 #define RV3028_CTRL2_TIE BIT(4) 69 #define RV3028_CTRL2_UIE BIT(5) 70 #define RV3028_CTRL2_TSE BIT(7) 71 72 #define RV3028_EVT_CTRL_TSR BIT(2) 73 74 #define RV3028_EEPROM_CMD_WRITE 0x21 75 #define RV3028_EEPROM_CMD_READ 0x22 76 77 #define RV3028_EEBUSY_POLL 10000 78 #define RV3028_EEBUSY_TIMEOUT 100000 79 80 #define RV3028_BACKUP_TCE BIT(5) 81 #define RV3028_BACKUP_TCR_MASK GENMASK(1,0) 82 83 #define OFFSET_STEP_PPT 953674 84 85 enum rv3028_type { 86 rv_3028, 87 }; 88 89 struct rv3028_data { 90 struct regmap *regmap; 91 struct rtc_device *rtc; 92 enum rv3028_type type; 93 #ifdef CONFIG_COMMON_CLK 94 struct clk_hw clkout_hw; 95 #endif 96 }; 97 98 static u16 rv3028_trickle_resistors[] = {1000, 3000, 6000, 11000}; 99 100 static ssize_t timestamp0_store(struct device *dev, 101 struct device_attribute *attr, 102 const char *buf, size_t count) 103 { 104 struct rv3028_data *rv3028 = dev_get_drvdata(dev->parent); 105 106 regmap_update_bits(rv3028->regmap, RV3028_EVT_CTRL, RV3028_EVT_CTRL_TSR, 107 RV3028_EVT_CTRL_TSR); 108 109 return count; 110 }; 111 112 static ssize_t timestamp0_show(struct device *dev, 113 struct device_attribute *attr, char *buf) 114 { 115 struct rv3028_data *rv3028 = dev_get_drvdata(dev->parent); 116 struct rtc_time tm; 117 int ret, count; 118 u8 date[6]; 119 120 ret = regmap_read(rv3028->regmap, RV3028_TS_COUNT, &count); 121 if (ret) 122 return ret; 123 124 if (!count) 125 return 0; 126 127 ret = regmap_bulk_read(rv3028->regmap, RV3028_TS_SEC, date, 128 sizeof(date)); 129 if (ret) 130 return ret; 131 132 tm.tm_sec = bcd2bin(date[0]); 133 tm.tm_min = bcd2bin(date[1]); 134 tm.tm_hour = bcd2bin(date[2]); 135 tm.tm_mday = bcd2bin(date[3]); 136 tm.tm_mon = bcd2bin(date[4]) - 1; 137 tm.tm_year = bcd2bin(date[5]) + 100; 138 139 ret = rtc_valid_tm(&tm); 140 if (ret) 141 return ret; 142 143 return sprintf(buf, "%llu\n", 144 (unsigned long long)rtc_tm_to_time64(&tm)); 145 }; 146 147 static DEVICE_ATTR_RW(timestamp0); 148 149 static ssize_t timestamp0_count_show(struct device *dev, 150 struct device_attribute *attr, char *buf) 151 { 152 struct rv3028_data *rv3028 = dev_get_drvdata(dev->parent); 153 int ret, count; 154 155 ret = regmap_read(rv3028->regmap, RV3028_TS_COUNT, &count); 156 if (ret) 157 return ret; 158 159 return sprintf(buf, "%u\n", count); 160 }; 161 162 static DEVICE_ATTR_RO(timestamp0_count); 163 164 static struct attribute *rv3028_attrs[] = { 165 &dev_attr_timestamp0.attr, 166 &dev_attr_timestamp0_count.attr, 167 NULL 168 }; 169 170 static const struct attribute_group rv3028_attr_group = { 171 .attrs = rv3028_attrs, 172 }; 173 174 static irqreturn_t rv3028_handle_irq(int irq, void *dev_id) 175 { 176 struct rv3028_data *rv3028 = dev_id; 177 unsigned long events = 0; 178 u32 status = 0, ctrl = 0; 179 180 if (regmap_read(rv3028->regmap, RV3028_STATUS, &status) < 0 || 181 status == 0) { 182 return IRQ_NONE; 183 } 184 185 if (status & RV3028_STATUS_PORF) 186 dev_warn(&rv3028->rtc->dev, "Voltage low, data loss detected.\n"); 187 188 if (status & RV3028_STATUS_TF) { 189 status |= RV3028_STATUS_TF; 190 ctrl |= RV3028_CTRL2_TIE; 191 events |= RTC_PF; 192 } 193 194 if (status & RV3028_STATUS_AF) { 195 status |= RV3028_STATUS_AF; 196 ctrl |= RV3028_CTRL2_AIE; 197 events |= RTC_AF; 198 } 199 200 if (status & RV3028_STATUS_UF) { 201 status |= RV3028_STATUS_UF; 202 ctrl |= RV3028_CTRL2_UIE; 203 events |= RTC_UF; 204 } 205 206 if (events) { 207 rtc_update_irq(rv3028->rtc, 1, events); 208 regmap_update_bits(rv3028->regmap, RV3028_STATUS, status, 0); 209 regmap_update_bits(rv3028->regmap, RV3028_CTRL2, ctrl, 0); 210 } 211 212 if (status & RV3028_STATUS_EVF) { 213 sysfs_notify(&rv3028->rtc->dev.kobj, NULL, 214 dev_attr_timestamp0.attr.name); 215 dev_warn(&rv3028->rtc->dev, "event detected"); 216 } 217 218 return IRQ_HANDLED; 219 } 220 221 static int rv3028_get_time(struct device *dev, struct rtc_time *tm) 222 { 223 struct rv3028_data *rv3028 = dev_get_drvdata(dev); 224 u8 date[7]; 225 int ret, status; 226 227 ret = regmap_read(rv3028->regmap, RV3028_STATUS, &status); 228 if (ret < 0) 229 return ret; 230 231 if (status & RV3028_STATUS_PORF) { 232 dev_warn(dev, "Voltage low, data is invalid.\n"); 233 return -EINVAL; 234 } 235 236 ret = regmap_bulk_read(rv3028->regmap, RV3028_SEC, date, sizeof(date)); 237 if (ret) 238 return ret; 239 240 tm->tm_sec = bcd2bin(date[RV3028_SEC] & 0x7f); 241 tm->tm_min = bcd2bin(date[RV3028_MIN] & 0x7f); 242 tm->tm_hour = bcd2bin(date[RV3028_HOUR] & 0x3f); 243 tm->tm_wday = ilog2(date[RV3028_WDAY] & 0x7f); 244 tm->tm_mday = bcd2bin(date[RV3028_DAY] & 0x3f); 245 tm->tm_mon = bcd2bin(date[RV3028_MONTH] & 0x1f) - 1; 246 tm->tm_year = bcd2bin(date[RV3028_YEAR]) + 100; 247 248 return 0; 249 } 250 251 static int rv3028_set_time(struct device *dev, struct rtc_time *tm) 252 { 253 struct rv3028_data *rv3028 = dev_get_drvdata(dev); 254 u8 date[7]; 255 int ret; 256 257 date[RV3028_SEC] = bin2bcd(tm->tm_sec); 258 date[RV3028_MIN] = bin2bcd(tm->tm_min); 259 date[RV3028_HOUR] = bin2bcd(tm->tm_hour); 260 date[RV3028_WDAY] = 1 << (tm->tm_wday); 261 date[RV3028_DAY] = bin2bcd(tm->tm_mday); 262 date[RV3028_MONTH] = bin2bcd(tm->tm_mon + 1); 263 date[RV3028_YEAR] = bin2bcd(tm->tm_year - 100); 264 265 /* 266 * Writing to the Seconds register has the same effect as setting RESET 267 * bit to 1 268 */ 269 ret = regmap_bulk_write(rv3028->regmap, RV3028_SEC, date, 270 sizeof(date)); 271 if (ret) 272 return ret; 273 274 ret = regmap_update_bits(rv3028->regmap, RV3028_STATUS, 275 RV3028_STATUS_PORF, 0); 276 277 return ret; 278 } 279 280 static int rv3028_get_alarm(struct device *dev, struct rtc_wkalrm *alrm) 281 { 282 struct rv3028_data *rv3028 = dev_get_drvdata(dev); 283 u8 alarmvals[3]; 284 int status, ctrl, ret; 285 286 ret = regmap_bulk_read(rv3028->regmap, RV3028_ALARM_MIN, alarmvals, 287 sizeof(alarmvals)); 288 if (ret) 289 return ret; 290 291 ret = regmap_read(rv3028->regmap, RV3028_STATUS, &status); 292 if (ret < 0) 293 return ret; 294 295 ret = regmap_read(rv3028->regmap, RV3028_CTRL2, &ctrl); 296 if (ret < 0) 297 return ret; 298 299 alrm->time.tm_sec = 0; 300 alrm->time.tm_min = bcd2bin(alarmvals[0] & 0x7f); 301 alrm->time.tm_hour = bcd2bin(alarmvals[1] & 0x3f); 302 alrm->time.tm_mday = bcd2bin(alarmvals[2] & 0x3f); 303 304 alrm->enabled = !!(ctrl & RV3028_CTRL2_AIE); 305 alrm->pending = (status & RV3028_STATUS_AF) && alrm->enabled; 306 307 return 0; 308 } 309 310 static int rv3028_set_alarm(struct device *dev, struct rtc_wkalrm *alrm) 311 { 312 struct rv3028_data *rv3028 = dev_get_drvdata(dev); 313 u8 alarmvals[3]; 314 u8 ctrl = 0; 315 int ret; 316 317 /* The alarm has no seconds, round up to nearest minute */ 318 if (alrm->time.tm_sec) { 319 time64_t alarm_time = rtc_tm_to_time64(&alrm->time); 320 321 alarm_time += 60 - alrm->time.tm_sec; 322 rtc_time64_to_tm(alarm_time, &alrm->time); 323 } 324 325 ret = regmap_update_bits(rv3028->regmap, RV3028_CTRL2, 326 RV3028_CTRL2_AIE | RV3028_CTRL2_UIE, 0); 327 if (ret) 328 return ret; 329 330 alarmvals[0] = bin2bcd(alrm->time.tm_min); 331 alarmvals[1] = bin2bcd(alrm->time.tm_hour); 332 alarmvals[2] = bin2bcd(alrm->time.tm_mday); 333 334 ret = regmap_update_bits(rv3028->regmap, RV3028_STATUS, 335 RV3028_STATUS_AF, 0); 336 if (ret) 337 return ret; 338 339 ret = regmap_bulk_write(rv3028->regmap, RV3028_ALARM_MIN, alarmvals, 340 sizeof(alarmvals)); 341 if (ret) 342 return ret; 343 344 if (alrm->enabled) { 345 if (rv3028->rtc->uie_rtctimer.enabled) 346 ctrl |= RV3028_CTRL2_UIE; 347 if (rv3028->rtc->aie_timer.enabled) 348 ctrl |= RV3028_CTRL2_AIE; 349 } 350 351 ret = regmap_update_bits(rv3028->regmap, RV3028_CTRL2, 352 RV3028_CTRL2_UIE | RV3028_CTRL2_AIE, ctrl); 353 354 return ret; 355 } 356 357 static int rv3028_alarm_irq_enable(struct device *dev, unsigned int enabled) 358 { 359 struct rv3028_data *rv3028 = dev_get_drvdata(dev); 360 int ctrl = 0, ret; 361 362 if (enabled) { 363 if (rv3028->rtc->uie_rtctimer.enabled) 364 ctrl |= RV3028_CTRL2_UIE; 365 if (rv3028->rtc->aie_timer.enabled) 366 ctrl |= RV3028_CTRL2_AIE; 367 } 368 369 ret = regmap_update_bits(rv3028->regmap, RV3028_STATUS, 370 RV3028_STATUS_AF | RV3028_STATUS_UF, 0); 371 if (ret) 372 return ret; 373 374 ret = regmap_update_bits(rv3028->regmap, RV3028_CTRL2, 375 RV3028_CTRL2_UIE | RV3028_CTRL2_AIE, ctrl); 376 if (ret) 377 return ret; 378 379 return 0; 380 } 381 382 static int rv3028_read_offset(struct device *dev, long *offset) 383 { 384 struct rv3028_data *rv3028 = dev_get_drvdata(dev); 385 int ret, value, steps; 386 387 ret = regmap_read(rv3028->regmap, RV3028_OFFSET, &value); 388 if (ret < 0) 389 return ret; 390 391 steps = sign_extend32(value << 1, 8); 392 393 ret = regmap_read(rv3028->regmap, RV3028_BACKUP, &value); 394 if (ret < 0) 395 return ret; 396 397 steps += value >> 7; 398 399 *offset = DIV_ROUND_CLOSEST(steps * OFFSET_STEP_PPT, 1000); 400 401 return 0; 402 } 403 404 static int rv3028_set_offset(struct device *dev, long offset) 405 { 406 struct rv3028_data *rv3028 = dev_get_drvdata(dev); 407 int ret; 408 409 offset = clamp(offset, -244141L, 243187L) * 1000; 410 offset = DIV_ROUND_CLOSEST(offset, OFFSET_STEP_PPT); 411 412 ret = regmap_write(rv3028->regmap, RV3028_OFFSET, offset >> 1); 413 if (ret < 0) 414 return ret; 415 416 return regmap_update_bits(rv3028->regmap, RV3028_BACKUP, BIT(7), 417 offset << 7); 418 } 419 420 static int rv3028_ioctl(struct device *dev, unsigned int cmd, unsigned long arg) 421 { 422 struct rv3028_data *rv3028 = dev_get_drvdata(dev); 423 int status, ret = 0; 424 425 switch (cmd) { 426 case RTC_VL_READ: 427 ret = regmap_read(rv3028->regmap, RV3028_STATUS, &status); 428 if (ret < 0) 429 return ret; 430 431 if (status & RV3028_STATUS_PORF) 432 dev_warn(&rv3028->rtc->dev, "Voltage low, data loss detected.\n"); 433 434 status &= RV3028_STATUS_PORF; 435 436 if (copy_to_user((void __user *)arg, &status, sizeof(int))) 437 return -EFAULT; 438 439 return 0; 440 441 case RTC_VL_CLR: 442 ret = regmap_update_bits(rv3028->regmap, RV3028_STATUS, 443 RV3028_STATUS_PORF, 0); 444 445 return ret; 446 447 default: 448 return -ENOIOCTLCMD; 449 } 450 } 451 452 static int rv3028_nvram_write(void *priv, unsigned int offset, void *val, 453 size_t bytes) 454 { 455 return regmap_bulk_write(priv, RV3028_RAM1 + offset, val, bytes); 456 } 457 458 static int rv3028_nvram_read(void *priv, unsigned int offset, void *val, 459 size_t bytes) 460 { 461 return regmap_bulk_read(priv, RV3028_RAM1 + offset, val, bytes); 462 } 463 464 static int rv3028_eeprom_write(void *priv, unsigned int offset, void *val, 465 size_t bytes) 466 { 467 u32 status, ctrl1; 468 int i, ret, err; 469 u8 *buf = val; 470 471 ret = regmap_read(priv, RV3028_CTRL1, &ctrl1); 472 if (ret) 473 return ret; 474 475 if (!(ctrl1 & RV3028_CTRL1_EERD)) { 476 ret = regmap_update_bits(priv, RV3028_CTRL1, 477 RV3028_CTRL1_EERD, RV3028_CTRL1_EERD); 478 if (ret) 479 return ret; 480 481 ret = regmap_read_poll_timeout(priv, RV3028_STATUS, status, 482 !(status & RV3028_STATUS_EEBUSY), 483 RV3028_EEBUSY_POLL, 484 RV3028_EEBUSY_TIMEOUT); 485 if (ret) 486 goto restore_eerd; 487 } 488 489 for (i = 0; i < bytes; i++) { 490 ret = regmap_write(priv, RV3028_EEPROM_ADDR, offset + i); 491 if (ret) 492 goto restore_eerd; 493 494 ret = regmap_write(priv, RV3028_EEPROM_DATA, buf[i]); 495 if (ret) 496 goto restore_eerd; 497 498 ret = regmap_write(priv, RV3028_EEPROM_CMD, 0x0); 499 if (ret) 500 goto restore_eerd; 501 502 ret = regmap_write(priv, RV3028_EEPROM_CMD, 503 RV3028_EEPROM_CMD_WRITE); 504 if (ret) 505 goto restore_eerd; 506 507 usleep_range(RV3028_EEBUSY_POLL, RV3028_EEBUSY_TIMEOUT); 508 509 ret = regmap_read_poll_timeout(priv, RV3028_STATUS, status, 510 !(status & RV3028_STATUS_EEBUSY), 511 RV3028_EEBUSY_POLL, 512 RV3028_EEBUSY_TIMEOUT); 513 if (ret) 514 goto restore_eerd; 515 } 516 517 restore_eerd: 518 if (!(ctrl1 & RV3028_CTRL1_EERD)) 519 { 520 err = regmap_update_bits(priv, RV3028_CTRL1, RV3028_CTRL1_EERD, 521 0); 522 if (err && !ret) 523 ret = err; 524 } 525 526 return ret; 527 } 528 529 static int rv3028_eeprom_read(void *priv, unsigned int offset, void *val, 530 size_t bytes) 531 { 532 u32 status, ctrl1, data; 533 int i, ret, err; 534 u8 *buf = val; 535 536 ret = regmap_read(priv, RV3028_CTRL1, &ctrl1); 537 if (ret) 538 return ret; 539 540 if (!(ctrl1 & RV3028_CTRL1_EERD)) { 541 ret = regmap_update_bits(priv, RV3028_CTRL1, 542 RV3028_CTRL1_EERD, RV3028_CTRL1_EERD); 543 if (ret) 544 return ret; 545 546 ret = regmap_read_poll_timeout(priv, RV3028_STATUS, status, 547 !(status & RV3028_STATUS_EEBUSY), 548 RV3028_EEBUSY_POLL, 549 RV3028_EEBUSY_TIMEOUT); 550 if (ret) 551 goto restore_eerd; 552 } 553 554 for (i = 0; i < bytes; i++) { 555 ret = regmap_write(priv, RV3028_EEPROM_ADDR, offset + i); 556 if (ret) 557 goto restore_eerd; 558 559 ret = regmap_write(priv, RV3028_EEPROM_CMD, 0x0); 560 if (ret) 561 goto restore_eerd; 562 563 ret = regmap_write(priv, RV3028_EEPROM_CMD, 564 RV3028_EEPROM_CMD_READ); 565 if (ret) 566 goto restore_eerd; 567 568 ret = regmap_read_poll_timeout(priv, RV3028_STATUS, status, 569 !(status & RV3028_STATUS_EEBUSY), 570 RV3028_EEBUSY_POLL, 571 RV3028_EEBUSY_TIMEOUT); 572 if (ret) 573 goto restore_eerd; 574 575 ret = regmap_read(priv, RV3028_EEPROM_DATA, &data); 576 if (ret) 577 goto restore_eerd; 578 buf[i] = data; 579 } 580 581 restore_eerd: 582 if (!(ctrl1 & RV3028_CTRL1_EERD)) 583 { 584 err = regmap_update_bits(priv, RV3028_CTRL1, RV3028_CTRL1_EERD, 585 0); 586 if (err && !ret) 587 ret = err; 588 } 589 590 return ret; 591 } 592 593 #ifdef CONFIG_COMMON_CLK 594 #define clkout_hw_to_rv3028(hw) container_of(hw, struct rv3028_data, clkout_hw) 595 596 static int clkout_rates[] = { 597 32768, 598 8192, 599 1024, 600 64, 601 32, 602 1, 603 }; 604 605 static unsigned long rv3028_clkout_recalc_rate(struct clk_hw *hw, 606 unsigned long parent_rate) 607 { 608 int clkout, ret; 609 struct rv3028_data *rv3028 = clkout_hw_to_rv3028(hw); 610 611 ret = regmap_read(rv3028->regmap, RV3028_CLKOUT, &clkout); 612 if (ret < 0) 613 return 0; 614 615 clkout &= RV3028_CLKOUT_FD_MASK; 616 return clkout_rates[clkout]; 617 } 618 619 static long rv3028_clkout_round_rate(struct clk_hw *hw, unsigned long rate, 620 unsigned long *prate) 621 { 622 int i; 623 624 for (i = 0; i < ARRAY_SIZE(clkout_rates); i++) 625 if (clkout_rates[i] <= rate) 626 return clkout_rates[i]; 627 628 return 0; 629 } 630 631 static int rv3028_clkout_set_rate(struct clk_hw *hw, unsigned long rate, 632 unsigned long parent_rate) 633 { 634 int i, ret; 635 struct rv3028_data *rv3028 = clkout_hw_to_rv3028(hw); 636 637 ret = regmap_write(rv3028->regmap, RV3028_CLKOUT, 0x0); 638 if (ret < 0) 639 return ret; 640 641 for (i = 0; i < ARRAY_SIZE(clkout_rates); i++) { 642 if (clkout_rates[i] == rate) { 643 ret = regmap_update_bits(rv3028->regmap, 644 RV3028_CLKOUT, 645 RV3028_CLKOUT_FD_MASK, i); 646 if (ret < 0) 647 return ret; 648 649 return regmap_write(rv3028->regmap, RV3028_CLKOUT, 650 RV3028_CLKOUT_CLKSY | RV3028_CLKOUT_CLKOE); 651 } 652 } 653 654 return -EINVAL; 655 } 656 657 static int rv3028_clkout_prepare(struct clk_hw *hw) 658 { 659 struct rv3028_data *rv3028 = clkout_hw_to_rv3028(hw); 660 661 return regmap_write(rv3028->regmap, RV3028_CLKOUT, 662 RV3028_CLKOUT_CLKSY | RV3028_CLKOUT_CLKOE); 663 } 664 665 static void rv3028_clkout_unprepare(struct clk_hw *hw) 666 { 667 struct rv3028_data *rv3028 = clkout_hw_to_rv3028(hw); 668 669 regmap_write(rv3028->regmap, RV3028_CLKOUT, 0x0); 670 regmap_update_bits(rv3028->regmap, RV3028_STATUS, 671 RV3028_STATUS_CLKF, 0); 672 } 673 674 static int rv3028_clkout_is_prepared(struct clk_hw *hw) 675 { 676 int clkout, ret; 677 struct rv3028_data *rv3028 = clkout_hw_to_rv3028(hw); 678 679 ret = regmap_read(rv3028->regmap, RV3028_CLKOUT, &clkout); 680 if (ret < 0) 681 return ret; 682 683 return !!(clkout & RV3028_CLKOUT_CLKOE); 684 } 685 686 static const struct clk_ops rv3028_clkout_ops = { 687 .prepare = rv3028_clkout_prepare, 688 .unprepare = rv3028_clkout_unprepare, 689 .is_prepared = rv3028_clkout_is_prepared, 690 .recalc_rate = rv3028_clkout_recalc_rate, 691 .round_rate = rv3028_clkout_round_rate, 692 .set_rate = rv3028_clkout_set_rate, 693 }; 694 695 static int rv3028_clkout_register_clk(struct rv3028_data *rv3028, 696 struct i2c_client *client) 697 { 698 int ret; 699 struct clk *clk; 700 struct clk_init_data init; 701 struct device_node *node = client->dev.of_node; 702 703 ret = regmap_update_bits(rv3028->regmap, RV3028_STATUS, 704 RV3028_STATUS_CLKF, 0); 705 if (ret < 0) 706 return ret; 707 708 init.name = "rv3028-clkout"; 709 init.ops = &rv3028_clkout_ops; 710 init.flags = 0; 711 init.parent_names = NULL; 712 init.num_parents = 0; 713 rv3028->clkout_hw.init = &init; 714 715 /* optional override of the clockname */ 716 of_property_read_string(node, "clock-output-names", &init.name); 717 718 /* register the clock */ 719 clk = devm_clk_register(&client->dev, &rv3028->clkout_hw); 720 if (!IS_ERR(clk)) 721 of_clk_add_provider(node, of_clk_src_simple_get, clk); 722 723 return 0; 724 } 725 #endif 726 727 static struct rtc_class_ops rv3028_rtc_ops = { 728 .read_time = rv3028_get_time, 729 .set_time = rv3028_set_time, 730 .read_offset = rv3028_read_offset, 731 .set_offset = rv3028_set_offset, 732 .ioctl = rv3028_ioctl, 733 }; 734 735 static const struct regmap_config regmap_config = { 736 .reg_bits = 8, 737 .val_bits = 8, 738 .max_register = 0x37, 739 }; 740 741 static int rv3028_probe(struct i2c_client *client) 742 { 743 struct rv3028_data *rv3028; 744 int ret, status; 745 u32 ohms; 746 struct nvmem_config nvmem_cfg = { 747 .name = "rv3028_nvram", 748 .word_size = 1, 749 .stride = 1, 750 .size = 2, 751 .type = NVMEM_TYPE_BATTERY_BACKED, 752 .reg_read = rv3028_nvram_read, 753 .reg_write = rv3028_nvram_write, 754 }; 755 struct nvmem_config eeprom_cfg = { 756 .name = "rv3028_eeprom", 757 .word_size = 1, 758 .stride = 1, 759 .size = 43, 760 .type = NVMEM_TYPE_EEPROM, 761 .reg_read = rv3028_eeprom_read, 762 .reg_write = rv3028_eeprom_write, 763 }; 764 765 rv3028 = devm_kzalloc(&client->dev, sizeof(struct rv3028_data), 766 GFP_KERNEL); 767 if (!rv3028) 768 return -ENOMEM; 769 770 rv3028->regmap = devm_regmap_init_i2c(client, ®map_config); 771 772 i2c_set_clientdata(client, rv3028); 773 774 ret = regmap_read(rv3028->regmap, RV3028_STATUS, &status); 775 if (ret < 0) 776 return ret; 777 778 if (status & RV3028_STATUS_PORF) 779 dev_warn(&client->dev, "Voltage low, data loss detected.\n"); 780 781 if (status & RV3028_STATUS_AF) 782 dev_warn(&client->dev, "An alarm may have been missed.\n"); 783 784 rv3028->rtc = devm_rtc_allocate_device(&client->dev); 785 if (IS_ERR(rv3028->rtc)) 786 return PTR_ERR(rv3028->rtc); 787 788 if (client->irq > 0) { 789 ret = devm_request_threaded_irq(&client->dev, client->irq, 790 NULL, rv3028_handle_irq, 791 IRQF_TRIGGER_LOW | IRQF_ONESHOT, 792 "rv3028", rv3028); 793 if (ret) { 794 dev_warn(&client->dev, "unable to request IRQ, alarms disabled\n"); 795 client->irq = 0; 796 } else { 797 rv3028_rtc_ops.read_alarm = rv3028_get_alarm; 798 rv3028_rtc_ops.set_alarm = rv3028_set_alarm; 799 rv3028_rtc_ops.alarm_irq_enable = rv3028_alarm_irq_enable; 800 } 801 } 802 803 ret = regmap_update_bits(rv3028->regmap, RV3028_CTRL1, 804 RV3028_CTRL1_WADA, RV3028_CTRL1_WADA); 805 if (ret) 806 return ret; 807 808 /* setup timestamping */ 809 ret = regmap_update_bits(rv3028->regmap, RV3028_CTRL2, 810 RV3028_CTRL2_EIE | RV3028_CTRL2_TSE, 811 RV3028_CTRL2_EIE | RV3028_CTRL2_TSE); 812 if (ret) 813 return ret; 814 815 /* setup trickle charger */ 816 if (!device_property_read_u32(&client->dev, "trickle-resistor-ohms", 817 &ohms)) { 818 int i; 819 820 for (i = 0; i < ARRAY_SIZE(rv3028_trickle_resistors); i++) 821 if (ohms == rv3028_trickle_resistors[i]) 822 break; 823 824 if (i < ARRAY_SIZE(rv3028_trickle_resistors)) { 825 ret = regmap_update_bits(rv3028->regmap, RV3028_BACKUP, 826 RV3028_BACKUP_TCE | 827 RV3028_BACKUP_TCR_MASK, 828 RV3028_BACKUP_TCE | i); 829 if (ret) 830 return ret; 831 } else { 832 dev_warn(&client->dev, "invalid trickle resistor value\n"); 833 } 834 } 835 836 ret = rtc_add_group(rv3028->rtc, &rv3028_attr_group); 837 if (ret) 838 return ret; 839 840 rv3028->rtc->range_min = RTC_TIMESTAMP_BEGIN_2000; 841 rv3028->rtc->range_max = RTC_TIMESTAMP_END_2099; 842 rv3028->rtc->ops = &rv3028_rtc_ops; 843 ret = rtc_register_device(rv3028->rtc); 844 if (ret) 845 return ret; 846 847 nvmem_cfg.priv = rv3028->regmap; 848 rtc_nvmem_register(rv3028->rtc, &nvmem_cfg); 849 eeprom_cfg.priv = rv3028->regmap; 850 rtc_nvmem_register(rv3028->rtc, &eeprom_cfg); 851 852 rv3028->rtc->max_user_freq = 1; 853 854 #ifdef CONFIG_COMMON_CLK 855 rv3028_clkout_register_clk(rv3028, client); 856 #endif 857 return 0; 858 } 859 860 static const struct of_device_id rv3028_of_match[] = { 861 { .compatible = "microcrystal,rv3028", }, 862 { } 863 }; 864 MODULE_DEVICE_TABLE(of, rv3028_of_match); 865 866 static struct i2c_driver rv3028_driver = { 867 .driver = { 868 .name = "rtc-rv3028", 869 .of_match_table = of_match_ptr(rv3028_of_match), 870 }, 871 .probe_new = rv3028_probe, 872 }; 873 module_i2c_driver(rv3028_driver); 874 875 MODULE_AUTHOR("Alexandre Belloni <alexandre.belloni@bootlin.com>"); 876 MODULE_DESCRIPTION("Micro Crystal RV3028 RTC driver"); 877 MODULE_LICENSE("GPL v2"); 878