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