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