drivers/rtc/rtc-rv3029c2.c

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