drivers/rtc/rtc-rv3028.c

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