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