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