drivers/rtc/rtc-rv3029c2.c

   1 /*
   2  * Micro Crystal RV-3029 / RV-3049 rtc class driver
   3  *
   4  * Author: Gregory Hermant <gregory.hermant@calao-systems.com>
   5  *         Michael Buesch <m@bues.ch>
   6  *
   7  * based on previously existing rtc class drivers
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License version 2 as
  11  * published by the Free Software Foundation.
  12  *
  13  */
  14
  15 #include <linux/module.h>
  16 #include <linux/i2c.h>
  17 #include <linux/spi/spi.h>
  18 #include <linux/bcd.h>
  19 #include <linux/rtc.h>
  20 #include <linux/delay.h>
  21 #include <linux/of.h>
  22 #include <linux/hwmon.h>
  23 #include <linux/hwmon-sysfs.h>
  24 #include <linux/regmap.h>
  25
  26 /* Register map */
  27 /* control section */
  28 #define RV3029_ONOFF_CTRL               0x00
  29 #define RV3029_ONOFF_CTRL_WE            BIT(0)
  30 #define RV3029_ONOFF_CTRL_TE            BIT(1)
  31 #define RV3029_ONOFF_CTRL_TAR           BIT(2)
  32 #define RV3029_ONOFF_CTRL_EERE          BIT(3)
  33 #define RV3029_ONOFF_CTRL_SRON          BIT(4)
  34 #define RV3029_ONOFF_CTRL_TD0           BIT(5)
  35 #define RV3029_ONOFF_CTRL_TD1           BIT(6)
  36 #define RV3029_ONOFF_CTRL_CLKINT        BIT(7)
  37 #define RV3029_IRQ_CTRL                 0x01
  38 #define RV3029_IRQ_CTRL_AIE             BIT(0)
  39 #define RV3029_IRQ_CTRL_TIE             BIT(1)
  40 #define RV3029_IRQ_CTRL_V1IE            BIT(2)
  41 #define RV3029_IRQ_CTRL_V2IE            BIT(3)
  42 #define RV3029_IRQ_CTRL_SRIE            BIT(4)
  43 #define RV3029_IRQ_FLAGS                0x02
  44 #define RV3029_IRQ_FLAGS_AF             BIT(0)
  45 #define RV3029_IRQ_FLAGS_TF             BIT(1)
  46 #define RV3029_IRQ_FLAGS_V1IF           BIT(2)
  47 #define RV3029_IRQ_FLAGS_V2IF           BIT(3)
  48 #define RV3029_IRQ_FLAGS_SRF            BIT(4)
  49 #define RV3029_STATUS                   0x03
  50 #define RV3029_STATUS_VLOW1             BIT(2)
  51 #define RV3029_STATUS_VLOW2             BIT(3)
  52 #define RV3029_STATUS_SR                BIT(4)
  53 #define RV3029_STATUS_PON               BIT(5)
  54 #define RV3029_STATUS_EEBUSY            BIT(7)
  55 #define RV3029_RST_CTRL                 0x04
  56 #define RV3029_RST_CTRL_SYSR            BIT(4)
  57 #define RV3029_CONTROL_SECTION_LEN      0x05
  58
  59 /* watch section */
  60 #define RV3029_W_SEC                    0x08
  61 #define RV3029_W_MINUTES                0x09
  62 #define RV3029_W_HOURS                  0x0A
  63 #define RV3029_REG_HR_12_24             BIT(6) /* 24h/12h mode */
  64 #define RV3029_REG_HR_PM                BIT(5) /* PM/AM bit in 12h mode */
  65 #define RV3029_W_DATE                   0x0B
  66 #define RV3029_W_DAYS                   0x0C
  67 #define RV3029_W_MONTHS                 0x0D
  68 #define RV3029_W_YEARS                  0x0E
  69 #define RV3029_WATCH_SECTION_LEN        0x07
  70
  71 /* alarm section */
  72 #define RV3029_A_SC                     0x10
  73 #define RV3029_A_MN                     0x11
  74 #define RV3029_A_HR                     0x12
  75 #define RV3029_A_DT                     0x13
  76 #define RV3029_A_DW                     0x14
  77 #define RV3029_A_MO                     0x15
  78 #define RV3029_A_YR                     0x16
  79 #define RV3029_ALARM_SECTION_LEN        0x07
  80
  81 /* timer section */
  82 #define RV3029_TIMER_LOW                0x18
  83 #define RV3029_TIMER_HIGH               0x19
  84
  85 /* temperature section */
  86 #define RV3029_TEMP_PAGE                0x20
  87
  88 /* eeprom data section */
  89 #define RV3029_E2P_EEDATA1              0x28
  90 #define RV3029_E2P_EEDATA2              0x29
  91 #define RV3029_E2PDATA_SECTION_LEN      0x02
  92
  93 /* eeprom control section */
  94 #define RV3029_CONTROL_E2P_EECTRL       0x30
  95 #define RV3029_EECTRL_THP               BIT(0) /* temp scan interval */
  96 #define RV3029_EECTRL_THE               BIT(1) /* thermometer enable */
  97 #define RV3029_EECTRL_FD0               BIT(2) /* CLKOUT */
  98 #define RV3029_EECTRL_FD1               BIT(3) /* CLKOUT */
  99 #define RV3029_TRICKLE_1K               BIT(4) /* 1.5K resistance */
 100 #define RV3029_TRICKLE_5K               BIT(5) /* 5K   resistance */
 101 #define RV3029_TRICKLE_20K              BIT(6) /* 20K  resistance */
 102 #define RV3029_TRICKLE_80K              BIT(7) /* 80K  resistance */
 103 #define RV3029_TRICKLE_MASK             (RV3029_TRICKLE_1K |\
 104                                          RV3029_TRICKLE_5K |\
 105                                          RV3029_TRICKLE_20K |\
 106                                          RV3029_TRICKLE_80K)
 107 #define RV3029_TRICKLE_SHIFT            4
 108 #define RV3029_CONTROL_E2P_XOFFS        0x31 /* XTAL offset */
 109 #define RV3029_CONTROL_E2P_XOFFS_SIGN   BIT(7) /* Sign: 1->pos, 0->neg */
 110 #define RV3029_CONTROL_E2P_QCOEF        0x32 /* XTAL temp drift coef */
 111 #define RV3029_CONTROL_E2P_TURNOVER     0x33 /* XTAL turnover temp (in *C) */
 112 #define RV3029_CONTROL_E2P_TOV_MASK     0x3F /* XTAL turnover temp mask */
 113
 114 /* user ram section */
 115 #define RV3029_USR1_RAM_PAGE            0x38
 116 #define RV3029_USR1_SECTION_LEN         0x04
 117 #define RV3029_USR2_RAM_PAGE            0x3C
 118 #define RV3029_USR2_SECTION_LEN         0x04
 119
 120 struct rv3029_data {
 121         struct device           *dev;
 122         struct rtc_device       *rtc;
 123         struct regmap           *regmap;
 124         int irq;
 125 };
 126
 127 static int rv3029_read_regs(struct device *dev, u8 reg, u8 *buf,
 128                             unsigned int len)
 129 {
 130         struct rv3029_data *rv3029 = dev_get_drvdata(dev);
 131
 132         if ((reg > RV3029_USR1_RAM_PAGE + 7) ||
 133             (reg + len > RV3029_USR1_RAM_PAGE + 8))
 134                 return -EINVAL;
 135
 136         return regmap_bulk_read(rv3029->regmap, reg, buf, len);
 137 }
 138
 139 static int rv3029_write_regs(struct device *dev, u8 reg, u8 const buf[],
 140                              unsigned int len)
 141 {
 142         struct rv3029_data *rv3029 = dev_get_drvdata(dev);
 143
 144         if ((reg > RV3029_USR1_RAM_PAGE + 7) ||
 145             (reg + len > RV3029_USR1_RAM_PAGE + 8))
 146                 return -EINVAL;
 147
 148         return regmap_bulk_write(rv3029->regmap, reg, buf, len);
 149 }
 150
 151 static int rv3029_update_bits(struct device *dev, u8 reg, u8 mask, u8 set)
 152 {
 153         u8 buf;
 154         int ret;
 155
 156         ret = rv3029_read_regs(dev, reg, &buf, 1);
 157         if (ret < 0)
 158                 return ret;
 159         buf &= ~mask;
 160         buf |= set & mask;
 161         ret = rv3029_write_regs(dev, reg, &buf, 1);
 162         if (ret < 0)
 163                 return ret;
 164
 165         return 0;
 166 }
 167
 168 static int rv3029_get_sr(struct device *dev, u8 *buf)
 169 {
 170         int ret = rv3029_read_regs(dev, RV3029_STATUS, buf, 1);
 171
 172         if (ret < 0)
 173                 return -EIO;
 174         dev_dbg(dev, "status = 0x%.2x (%d)\n", buf[0], buf[0]);
 175         return 0;
 176 }
 177
 178 static int rv3029_set_sr(struct device *dev, u8 val)
 179 {
 180         u8 buf[1];
 181         int sr;
 182
 183         buf[0] = val;
 184         sr = rv3029_write_regs(dev, RV3029_STATUS, buf, 1);
 185         dev_dbg(dev, "status = 0x%.2x (%d)\n", buf[0], buf[0]);
 186         if (sr < 0)
 187                 return -EIO;
 188         return 0;
 189 }
 190
 191 static int rv3029_eeprom_busywait(struct device *dev)
 192 {
 193         int i, ret;
 194         u8 sr;
 195
 196         for (i = 100; i > 0; i--) {
 197                 ret = rv3029_get_sr(dev, &sr);
 198                 if (ret < 0)
 199                         break;
 200                 if (!(sr & RV3029_STATUS_EEBUSY))
 201                         break;
 202                 usleep_range(1000, 10000);
 203         }
 204         if (i <= 0) {
 205                 dev_err(dev, "EEPROM busy wait timeout.\n");
 206                 return -ETIMEDOUT;
 207         }
 208
 209         return ret;
 210 }
 211
 212 static int rv3029_eeprom_exit(struct device *dev)
 213 {
 214         /* Re-enable eeprom refresh */
 215         return rv3029_update_bits(dev, RV3029_ONOFF_CTRL,
 216                                   RV3029_ONOFF_CTRL_EERE,
 217                                   RV3029_ONOFF_CTRL_EERE);
 218 }
 219
 220 static int rv3029_eeprom_enter(struct device *dev)
 221 {
 222         int ret;
 223         u8 sr;
 224
 225         /* Check whether we are in the allowed voltage range. */
 226         ret = rv3029_get_sr(dev, &sr);
 227         if (ret < 0)
 228                 return ret;
 229         if (sr & (RV3029_STATUS_VLOW1 | RV3029_STATUS_VLOW2)) {
 230                 /* We clear the bits and retry once just in case
 231                  * we had a brown out in early startup.
 232                  */
 233                 sr &= ~RV3029_STATUS_VLOW1;
 234                 sr &= ~RV3029_STATUS_VLOW2;
 235                 ret = rv3029_set_sr(dev, sr);
 236                 if (ret < 0)
 237                         return ret;
 238                 usleep_range(1000, 10000);
 239                 ret = rv3029_get_sr(dev, &sr);
 240                 if (ret < 0)
 241                         return ret;
 242                 if (sr & (RV3029_STATUS_VLOW1 | RV3029_STATUS_VLOW2)) {
 243                         dev_err(dev,
 244                                 "Supply voltage is too low to safely access the EEPROM.\n");
 245                         return -ENODEV;
 246                 }
 247         }
 248
 249         /* Disable eeprom refresh. */
 250         ret = rv3029_update_bits(dev, RV3029_ONOFF_CTRL, RV3029_ONOFF_CTRL_EERE,
 251                                  0);
 252         if (ret < 0)
 253                 return ret;
 254
 255         /* Wait for any previous eeprom accesses to finish. */
 256         ret = rv3029_eeprom_busywait(dev);
 257         if (ret < 0)
 258                 rv3029_eeprom_exit(dev);
 259
 260         return ret;
 261 }
 262
 263 static int rv3029_eeprom_read(struct device *dev, u8 reg,
 264                               u8 buf[], size_t len)
 265 {
 266         int ret, err;
 267
 268         err = rv3029_eeprom_enter(dev);
 269         if (err < 0)
 270                 return err;
 271
 272         ret = rv3029_read_regs(dev, reg, buf, len);
 273
 274         err = rv3029_eeprom_exit(dev);
 275         if (err < 0)
 276                 return err;
 277
 278         return ret;
 279 }
 280
 281 static int rv3029_eeprom_write(struct device *dev, u8 reg,
 282                                u8 const buf[], size_t len)
 283 {
 284         int ret, err;
 285         size_t i;
 286         u8 tmp;
 287
 288         err = rv3029_eeprom_enter(dev);
 289         if (err < 0)
 290                 return err;
 291
 292         for (i = 0; i < len; i++, reg++) {
 293                 ret = rv3029_read_regs(dev, reg, &tmp, 1);
 294                 if (ret < 0)
 295                         break;
 296                 if (tmp != buf[i]) {
 297                         ret = rv3029_write_regs(dev, reg, &buf[i], 1);
 298                         if (ret < 0)
 299                                 break;
 300                 }
 301                 ret = rv3029_eeprom_busywait(dev);
 302                 if (ret < 0)
 303                         break;
 304         }
 305
 306         err = rv3029_eeprom_exit(dev);
 307         if (err < 0)
 308                 return err;
 309
 310         return ret;
 311 }
 312
 313 static int rv3029_eeprom_update_bits(struct device *dev,
 314                                      u8 reg, u8 mask, u8 set)
 315 {
 316         u8 buf;
 317         int ret;
 318
 319         ret = rv3029_eeprom_read(dev, reg, &buf, 1);
 320         if (ret < 0)
 321                 return ret;
 322         buf &= ~mask;
 323         buf |= set & mask;
 324         ret = rv3029_eeprom_write(dev, reg, &buf, 1);
 325         if (ret < 0)
 326                 return ret;
 327
 328         return 0;
 329 }
 330
 331 static int rv3029_read_time(struct device *dev, struct rtc_time *tm)
 332 {
 333         u8 buf[1];
 334         int ret;
 335         u8 regs[RV3029_WATCH_SECTION_LEN] = { 0, };
 336
 337         ret = rv3029_get_sr(dev, buf);
 338         if (ret < 0) {
 339                 dev_err(dev, "%s: reading SR failed\n", __func__);
 340                 return -EIO;
 341         }
 342
 343         ret = rv3029_read_regs(dev, RV3029_W_SEC, regs,
 344                                RV3029_WATCH_SECTION_LEN);
 345         if (ret < 0) {
 346                 dev_err(dev, "%s: reading RTC section failed\n", __func__);
 347                 return ret;
 348         }
 349
 350         tm->tm_sec = bcd2bin(regs[RV3029_W_SEC - RV3029_W_SEC]);
 351         tm->tm_min = bcd2bin(regs[RV3029_W_MINUTES - RV3029_W_SEC]);
 352
 353         /* HR field has a more complex interpretation */
 354         {
 355                 const u8 _hr = regs[RV3029_W_HOURS - RV3029_W_SEC];
 356
 357                 if (_hr & RV3029_REG_HR_12_24) {
 358                         /* 12h format */
 359                         tm->tm_hour = bcd2bin(_hr & 0x1f);
 360                         if (_hr & RV3029_REG_HR_PM)     /* PM flag set */
 361                                 tm->tm_hour += 12;
 362                 } else /* 24h format */
 363                         tm->tm_hour = bcd2bin(_hr & 0x3f);
 364         }
 365
 366         tm->tm_mday = bcd2bin(regs[RV3029_W_DATE - RV3029_W_SEC]);
 367         tm->tm_mon = bcd2bin(regs[RV3029_W_MONTHS - RV3029_W_SEC]) - 1;
 368         tm->tm_year = bcd2bin(regs[RV3029_W_YEARS - RV3029_W_SEC]) + 100;
 369         tm->tm_wday = bcd2bin(regs[RV3029_W_DAYS - RV3029_W_SEC]) - 1;
 370
 371         return 0;
 372 }
 373
 374 static int rv3029_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
 375 {
 376         struct rtc_time *const tm = &alarm->time;
 377         int ret;
 378         u8 regs[8];
 379
 380         ret = rv3029_get_sr(dev, regs);
 381         if (ret < 0) {
 382                 dev_err(dev, "%s: reading SR failed\n", __func__);
 383                 return -EIO;
 384         }
 385
 386         ret = rv3029_read_regs(dev, RV3029_A_SC, regs,
 387                                RV3029_ALARM_SECTION_LEN);
 388
 389         if (ret < 0) {
 390                 dev_err(dev, "%s: reading alarm section failed\n", __func__);
 391                 return ret;
 392         }
 393
 394         tm->tm_sec = bcd2bin(regs[RV3029_A_SC - RV3029_A_SC] & 0x7f);
 395         tm->tm_min = bcd2bin(regs[RV3029_A_MN - RV3029_A_SC] & 0x7f);
 396         tm->tm_hour = bcd2bin(regs[RV3029_A_HR - RV3029_A_SC] & 0x3f);
 397         tm->tm_mday = bcd2bin(regs[RV3029_A_DT - RV3029_A_SC] & 0x3f);
 398         tm->tm_mon = bcd2bin(regs[RV3029_A_MO - RV3029_A_SC] & 0x1f) - 1;
 399         tm->tm_year = bcd2bin(regs[RV3029_A_YR - RV3029_A_SC] & 0x7f) + 100;
 400         tm->tm_wday = bcd2bin(regs[RV3029_A_DW - RV3029_A_SC] & 0x07) - 1;
 401
 402         return 0;
 403 }
 404
 405 static int rv3029_rtc_alarm_set_irq(struct device *dev, int enable)
 406 {
 407         int ret;
 408
 409         /* enable/disable AIE irq */
 410         ret = rv3029_update_bits(dev, RV3029_IRQ_CTRL, RV3029_IRQ_CTRL_AIE,
 411                                  (enable ? RV3029_IRQ_CTRL_AIE : 0));
 412         if (ret < 0) {
 413                 dev_err(dev, "can't update INT reg\n");
 414                 return ret;
 415         }
 416
 417         return 0;
 418 }
 419
 420 static int rv3029_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
 421 {
 422         struct rtc_time *const tm = &alarm->time;
 423         int ret;
 424         u8 regs[8];
 425
 426         /*
 427          * The clock has an 8 bit wide bcd-coded register (they never learn)
 428          * for the year. tm_year is an offset from 1900 and we are interested
 429          * in the 2000-2099 range, so any value less than 100 is invalid.
 430         */
 431         if (tm->tm_year < 100)
 432                 return -EINVAL;
 433
 434         ret = rv3029_get_sr(dev, regs);
 435         if (ret < 0) {
 436                 dev_err(dev, "%s: reading SR failed\n", __func__);
 437                 return -EIO;
 438         }
 439         regs[RV3029_A_SC - RV3029_A_SC] = bin2bcd(tm->tm_sec & 0x7f);
 440         regs[RV3029_A_MN - RV3029_A_SC] = bin2bcd(tm->tm_min & 0x7f);
 441         regs[RV3029_A_HR - RV3029_A_SC] = bin2bcd(tm->tm_hour & 0x3f);
 442         regs[RV3029_A_DT - RV3029_A_SC] = bin2bcd(tm->tm_mday & 0x3f);
 443         regs[RV3029_A_MO - RV3029_A_SC] = bin2bcd((tm->tm_mon & 0x1f) - 1);
 444         regs[RV3029_A_DW - RV3029_A_SC] = bin2bcd((tm->tm_wday & 7) - 1);
 445         regs[RV3029_A_YR - RV3029_A_SC] = bin2bcd((tm->tm_year & 0x7f) - 100);
 446
 447         ret = rv3029_write_regs(dev, RV3029_A_SC, regs,
 448                                 RV3029_ALARM_SECTION_LEN);
 449         if (ret < 0)
 450                 return ret;
 451
 452         if (alarm->enabled) {
 453                 /* clear AF flag */
 454                 ret = rv3029_update_bits(dev, RV3029_IRQ_FLAGS,
 455                                          RV3029_IRQ_FLAGS_AF, 0);
 456                 if (ret < 0) {
 457                         dev_err(dev, "can't clear alarm flag\n");
 458                         return ret;
 459                 }
 460                 /* enable AIE irq */
 461                 ret = rv3029_rtc_alarm_set_irq(dev, 1);
 462                 if (ret)
 463                         return ret;
 464
 465                 dev_dbg(dev, "alarm IRQ armed\n");
 466         } else {
 467                 /* disable AIE irq */
 468                 ret = rv3029_rtc_alarm_set_irq(dev, 0);
 469                 if (ret)
 470                         return ret;
 471
 472                 dev_dbg(dev, "alarm IRQ disabled\n");
 473         }
 474
 475         return 0;
 476 }
 477
 478 static int rv3029_set_time(struct device *dev, struct rtc_time *tm)
 479 {
 480         u8 regs[8];
 481         int ret;
 482
 483         /*
 484          * The clock has an 8 bit wide bcd-coded register (they never learn)
 485          * for the year. tm_year is an offset from 1900 and we are interested
 486          * in the 2000-2099 range, so any value less than 100 is invalid.
 487         */
 488         if (tm->tm_year < 100)
 489                 return -EINVAL;
 490
 491         regs[RV3029_W_SEC - RV3029_W_SEC] = bin2bcd(tm->tm_sec);
 492         regs[RV3029_W_MINUTES - RV3029_W_SEC] = bin2bcd(tm->tm_min);
 493         regs[RV3029_W_HOURS - RV3029_W_SEC] = bin2bcd(tm->tm_hour);
 494         regs[RV3029_W_DATE - RV3029_W_SEC] = bin2bcd(tm->tm_mday);
 495         regs[RV3029_W_MONTHS - RV3029_W_SEC] = bin2bcd(tm->tm_mon + 1);
 496         regs[RV3029_W_DAYS - RV3029_W_SEC] = bin2bcd((tm->tm_wday & 7) + 1);
 497         regs[RV3029_W_YEARS - RV3029_W_SEC] = bin2bcd(tm->tm_year - 100);
 498
 499         ret = rv3029_write_regs(dev, RV3029_W_SEC, regs,
 500                                 RV3029_WATCH_SECTION_LEN);
 501         if (ret < 0)
 502                 return ret;
 503
 504         ret = rv3029_get_sr(dev, regs);
 505         if (ret < 0) {
 506                 dev_err(dev, "%s: reading SR failed\n", __func__);
 507                 return ret;
 508         }
 509         /* clear PON bit */
 510         ret = rv3029_set_sr(dev, (regs[0] & ~RV3029_STATUS_PON));
 511         if (ret < 0) {
 512                 dev_err(dev, "%s: reading SR failed\n", __func__);
 513                 return ret;
 514         }
 515
 516         return 0;
 517 }
 518
 519 static const struct rv3029_trickle_tab_elem {
 520         u32 r;          /* resistance in ohms */
 521         u8 conf;        /* trickle config bits */
 522 } rv3029_trickle_tab[] = {
 523         {
 524                 .r      = 1076,
 525                 .conf   = RV3029_TRICKLE_1K | RV3029_TRICKLE_5K |
 526                           RV3029_TRICKLE_20K | RV3029_TRICKLE_80K,
 527         }, {
 528                 .r      = 1091,
 529                 .conf   = RV3029_TRICKLE_1K | RV3029_TRICKLE_5K |
 530                           RV3029_TRICKLE_20K,
 531         }, {
 532                 .r      = 1137,
 533                 .conf   = RV3029_TRICKLE_1K | RV3029_TRICKLE_5K |
 534                           RV3029_TRICKLE_80K,
 535         }, {
 536                 .r      = 1154,
 537                 .conf   = RV3029_TRICKLE_1K | RV3029_TRICKLE_5K,
 538         }, {
 539                 .r      = 1371,
 540                 .conf   = RV3029_TRICKLE_1K | RV3029_TRICKLE_20K |
 541                           RV3029_TRICKLE_80K,
 542         }, {
 543                 .r      = 1395,
 544                 .conf   = RV3029_TRICKLE_1K | RV3029_TRICKLE_20K,
 545         }, {
 546                 .r      = 1472,
 547                 .conf   = RV3029_TRICKLE_1K | RV3029_TRICKLE_80K,
 548         }, {
 549                 .r      = 1500,
 550                 .conf   = RV3029_TRICKLE_1K,
 551         }, {
 552                 .r      = 3810,
 553                 .conf   = RV3029_TRICKLE_5K | RV3029_TRICKLE_20K |
 554                           RV3029_TRICKLE_80K,
 555         }, {
 556                 .r      = 4000,
 557                 .conf   = RV3029_TRICKLE_5K | RV3029_TRICKLE_20K,
 558         }, {
 559                 .r      = 4706,
 560                 .conf   = RV3029_TRICKLE_5K | RV3029_TRICKLE_80K,
 561         }, {
 562                 .r      = 5000,
 563                 .conf   = RV3029_TRICKLE_5K,
 564         }, {
 565                 .r      = 16000,
 566                 .conf   = RV3029_TRICKLE_20K | RV3029_TRICKLE_80K,
 567         }, {
 568                 .r      = 20000,
 569                 .conf   = RV3029_TRICKLE_20K,
 570         }, {
 571                 .r      = 80000,
 572                 .conf   = RV3029_TRICKLE_80K,
 573         },
 574 };
 575
 576 static void rv3029_trickle_config(struct device *dev)
 577 {
 578         struct device_node *of_node = dev->of_node;
 579         const struct rv3029_trickle_tab_elem *elem;
 580         int i, err;
 581         u32 ohms;
 582         u8 trickle_set_bits;
 583
 584         if (!of_node)
 585                 return;
 586
 587         /* Configure the trickle charger. */
 588         err = of_property_read_u32(of_node, "trickle-resistor-ohms", &ohms);
 589         if (err) {
 590                 /* Disable trickle charger. */
 591                 trickle_set_bits = 0;
 592         } else {
 593                 /* Enable trickle charger. */
 594                 for (i = 0; i < ARRAY_SIZE(rv3029_trickle_tab); i++) {
 595                         elem = &rv3029_trickle_tab[i];
 596                         if (elem->r >= ohms)
 597                                 break;
 598                 }
 599                 trickle_set_bits = elem->conf;
 600                 dev_info(dev,
 601                          "Trickle charger enabled at %d ohms resistance.\n",
 602                          elem->r);
 603         }
 604         err = rv3029_eeprom_update_bits(dev, RV3029_CONTROL_E2P_EECTRL,
 605                                         RV3029_TRICKLE_MASK,
 606                                         trickle_set_bits);
 607         if (err < 0)
 608                 dev_err(dev, "Failed to update trickle charger config\n");
 609 }
 610
 611 #ifdef CONFIG_RTC_DRV_RV3029_HWMON
 612
 613 static int rv3029_read_temp(struct device *dev, int *temp_mC)
 614 {
 615         int ret;
 616         u8 temp;
 617
 618         ret = rv3029_read_regs(dev, RV3029_TEMP_PAGE, &temp, 1);
 619         if (ret < 0)
 620                 return ret;
 621
 622         *temp_mC = ((int)temp - 60) * 1000;
 623
 624         return 0;
 625 }
 626
 627 static ssize_t rv3029_hwmon_show_temp(struct device *dev,
 628                                       struct device_attribute *attr,
 629                                       char *buf)
 630 {
 631         int ret, temp_mC;
 632
 633         ret = rv3029_read_temp(dev, &temp_mC);
 634         if (ret < 0)
 635                 return ret;
 636
 637         return sprintf(buf, "%d\n", temp_mC);
 638 }
 639
 640 static ssize_t rv3029_hwmon_set_update_interval(struct device *dev,
 641                                                 struct device_attribute *attr,
 642                                                 const char *buf,
 643                                                 size_t count)
 644 {
 645         unsigned long interval_ms;
 646         int ret;
 647         u8 th_set_bits = 0;
 648
 649         ret = kstrtoul(buf, 10, &interval_ms);
 650         if (ret < 0)
 651                 return ret;
 652
 653         if (interval_ms != 0) {
 654                 th_set_bits |= RV3029_EECTRL_THE;
 655                 if (interval_ms >= 16000)
 656                         th_set_bits |= RV3029_EECTRL_THP;
 657         }
 658         ret = rv3029_eeprom_update_bits(dev, RV3029_CONTROL_E2P_EECTRL,
 659                                         RV3029_EECTRL_THE | RV3029_EECTRL_THP,
 660                                         th_set_bits);
 661         if (ret < 0)
 662                 return ret;
 663
 664         return count;
 665 }
 666
 667 static ssize_t rv3029_hwmon_show_update_interval(struct device *dev,
 668                                                  struct device_attribute *attr,
 669                                                  char *buf)
 670 {
 671         int ret, interval_ms;
 672         u8 eectrl;
 673
 674         ret = rv3029_eeprom_read(dev, RV3029_CONTROL_E2P_EECTRL,
 675                                  &eectrl, 1);
 676         if (ret < 0)
 677                 return ret;
 678
 679         if (eectrl & RV3029_EECTRL_THE) {
 680                 if (eectrl & RV3029_EECTRL_THP)
 681                         interval_ms = 16000;
 682                 else
 683                         interval_ms = 1000;
 684         } else {
 685                 interval_ms = 0;
 686         }
 687
 688         return sprintf(buf, "%d\n", interval_ms);
 689 }
 690
 691 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, rv3029_hwmon_show_temp,
 692                           NULL, 0);
 693 static SENSOR_DEVICE_ATTR(update_interval, S_IWUSR | S_IRUGO,
 694                           rv3029_hwmon_show_update_interval,
 695                           rv3029_hwmon_set_update_interval, 0);
 696
 697 static struct attribute *rv3029_hwmon_attrs[] = {
 698         &sensor_dev_attr_temp1_input.dev_attr.attr,
 699         &sensor_dev_attr_update_interval.dev_attr.attr,
 700         NULL,
 701 };
 702 ATTRIBUTE_GROUPS(rv3029_hwmon);
 703
 704 static void rv3029_hwmon_register(struct device *dev, const char *name)
 705 {
 706         struct rv3029_data *rv3029 = dev_get_drvdata(dev);
 707         struct device *hwmon_dev;
 708
 709         hwmon_dev = devm_hwmon_device_register_with_groups(dev, name, rv3029,
 710                                                            rv3029_hwmon_groups);
 711         if (IS_ERR(hwmon_dev)) {
 712                 dev_warn(dev, "unable to register hwmon device %ld\n",
 713                          PTR_ERR(hwmon_dev));
 714         }
 715 }
 716
 717 #else /* CONFIG_RTC_DRV_RV3029_HWMON */
 718
 719 static void rv3029_hwmon_register(struct device *dev, const char *name)
 720 {
 721 }
 722
 723 #endif /* CONFIG_RTC_DRV_RV3029_HWMON */
 724
 725 static const struct rtc_class_ops rv3029_rtc_ops = {
 726         .read_time      = rv3029_read_time,
 727         .set_time       = rv3029_set_time,
 728         .read_alarm     = rv3029_read_alarm,
 729         .set_alarm      = rv3029_set_alarm,
 730 };
 731
 732 static struct i2c_device_id rv3029_id[] = {
 733         { "rv3029", 0 },
 734         { "rv3029c2", 0 },
 735         { }
 736 };
 737 MODULE_DEVICE_TABLE(i2c, rv3029_id);
 738
 739 static int rv3029_probe(struct device *dev, struct regmap *regmap, int irq,
 740                         const char *name)
 741 {
 742         struct rv3029_data *rv3029;
 743         int rc = 0;
 744         u8 buf[1];
 745
 746         rv3029 = devm_kzalloc(dev, sizeof(*rv3029), GFP_KERNEL);
 747         if (!rv3029)
 748                 return -ENOMEM;
 749
 750         rv3029->regmap = regmap;
 751         rv3029->irq = irq;
 752         rv3029->dev = dev;
 753         dev_set_drvdata(dev, rv3029);
 754
 755         rc = rv3029_get_sr(dev, buf);
 756         if (rc < 0) {
 757                 dev_err(dev, "reading status failed\n");
 758                 return rc;
 759         }
 760
 761         rv3029_trickle_config(dev);
 762         rv3029_hwmon_register(dev, name);
 763
 764         rv3029->rtc = devm_rtc_device_register(dev, name, &rv3029_rtc_ops,
 765                                                THIS_MODULE);
 766
 767         return PTR_ERR_OR_ZERO(rv3029->rtc);
 768 }
 769
 770 #if IS_ENABLED(CONFIG_I2C)
 771
 772 static int rv3029_i2c_probe(struct i2c_client *client,
 773                             const struct i2c_device_id *id)
 774 {
 775         struct regmap *regmap;
 776         static const struct regmap_config config = {
 777                 .reg_bits = 8,
 778                 .val_bits = 8,
 779         };
 780
 781         if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_I2C_BLOCK |
 782                                      I2C_FUNC_SMBUS_BYTE)) {
 783                 dev_err(&client->dev, "Adapter does not support SMBUS_I2C_BLOCK or SMBUS_I2C_BYTE\n");
 784                 return -ENODEV;
 785         }
 786
 787         regmap = devm_regmap_init_i2c(client, &config);
 788         if (IS_ERR(regmap)) {
 789                 dev_err(&client->dev, "%s: regmap allocation failed: %ld\n",
 790                         __func__, PTR_ERR(regmap));
 791                 return PTR_ERR(regmap);
 792         }
 793
 794         return rv3029_probe(&client->dev, regmap, client->irq, client->name);
 795 }
 796
 797 static struct i2c_driver rv3029_driver = {
 798         .driver = {
 799                 .name = "rtc-rv3029c2",
 800         },
 801         .probe          = rv3029_i2c_probe,
 802         .id_table       = rv3029_id,
 803 };
 804
 805 static int rv3029_register_driver(void)
 806 {
 807         return i2c_add_driver(&rv3029_driver);
 808 }
 809
 810 static void rv3029_unregister_driver(void)
 811 {
 812         i2c_del_driver(&rv3029_driver);
 813 }
 814
 815 #else
 816
 817 static int rv3029_register_driver(void)
 818 {
 819         return 0;
 820 }
 821
 822 static void rv3029_unregister_driver(void)
 823 {
 824 }
 825
 826 #endif
 827
 828 #if IS_ENABLED(CONFIG_SPI_MASTER)
 829
 830 static int rv3049_probe(struct spi_device *spi)
 831 {
 832         static const struct regmap_config config = {
 833                 .reg_bits = 8,
 834                 .val_bits = 8,
 835         };
 836         struct regmap *regmap;
 837
 838         regmap = devm_regmap_init_spi(spi, &config);
 839         if (IS_ERR(regmap)) {
 840                 dev_err(&spi->dev, "%s: regmap allocation failed: %ld\n",
 841                         __func__, PTR_ERR(regmap));
 842                 return PTR_ERR(regmap);
 843         }
 844
 845         return rv3029_probe(&spi->dev, regmap, spi->irq, "rv3049");
 846 }
 847
 848 static struct spi_driver rv3049_driver = {
 849         .driver = {
 850                 .name    = "rv3049",
 851         },
 852         .probe   = rv3049_probe,
 853 };
 854
 855 static int rv3049_register_driver(void)
 856 {
 857         return spi_register_driver(&rv3049_driver);
 858 }
 859
 860 static void rv3049_unregister_driver(void)
 861 {
 862         spi_unregister_driver(&rv3049_driver);
 863 }
 864
 865 #else
 866
 867 static int rv3049_register_driver(void)
 868 {
 869         return 0;
 870 }
 871
 872 static void rv3049_unregister_driver(void)
 873 {
 874 }
 875
 876 #endif
 877
 878 static int __init rv30x9_init(void)
 879 {
 880         int ret;
 881
 882         ret = rv3029_register_driver();
 883         if (ret) {
 884                 pr_err("Failed to register rv3029 driver: %d\n", ret);
 885                 return ret;
 886         }
 887
 888         ret = rv3049_register_driver();
 889         if (ret) {
 890                 pr_err("Failed to register rv3049 driver: %d\n", ret);
 891                 rv3029_unregister_driver();
 892         }
 893
 894         return ret;
 895 }
 896 module_init(rv30x9_init)
 897
 898 static void __exit rv30x9_exit(void)
 899 {
 900         rv3049_unregister_driver();
 901         rv3029_unregister_driver();
 902 }
 903 module_exit(rv30x9_exit)
 904
 905 MODULE_AUTHOR("Gregory Hermant <gregory.hermant@calao-systems.com>");
 906 MODULE_AUTHOR("Michael Buesch <m@bues.ch>");
 907 MODULE_DESCRIPTION("Micro Crystal RV3029/RV3049 RTC driver");
 908 MODULE_LICENSE("GPL");
 909 MODULE_ALIAS("spi:rv3049");