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_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, &regmap_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");