drivers/rtc/rtc-rv3029c2.c

   1 /*
   2  * Micro Crystal RV-3029 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/bcd.h>
  18 #include <linux/rtc.h>
  19 #include <linux/delay.h>
  20 #include <linux/of.h>
  21
  22
  23 /* Register map */
  24 /* control section */
  25 #define RV3029_ONOFF_CTRL               0x00
  26 #define RV3029_ONOFF_CTRL_WE            BIT(0)
  27 #define RV3029_ONOFF_CTRL_TE            BIT(1)
  28 #define RV3029_ONOFF_CTRL_TAR           BIT(2)
  29 #define RV3029_ONOFF_CTRL_EERE          BIT(3)
  30 #define RV3029_ONOFF_CTRL_SRON          BIT(4)
  31 #define RV3029_ONOFF_CTRL_TD0           BIT(5)
  32 #define RV3029_ONOFF_CTRL_TD1           BIT(6)
  33 #define RV3029_ONOFF_CTRL_CLKINT        BIT(7)
  34 #define RV3029_IRQ_CTRL                 0x01
  35 #define RV3029_IRQ_CTRL_AIE             BIT(0)
  36 #define RV3029_IRQ_CTRL_TIE             BIT(1)
  37 #define RV3029_IRQ_CTRL_V1IE            BIT(2)
  38 #define RV3029_IRQ_CTRL_V2IE            BIT(3)
  39 #define RV3029_IRQ_CTRL_SRIE            BIT(4)
  40 #define RV3029_IRQ_FLAGS                0x02
  41 #define RV3029_IRQ_FLAGS_AF             BIT(0)
  42 #define RV3029_IRQ_FLAGS_TF             BIT(1)
  43 #define RV3029_IRQ_FLAGS_V1IF           BIT(2)
  44 #define RV3029_IRQ_FLAGS_V2IF           BIT(3)
  45 #define RV3029_IRQ_FLAGS_SRF            BIT(4)
  46 #define RV3029_STATUS                   0x03
  47 #define RV3029_STATUS_VLOW1             BIT(2)
  48 #define RV3029_STATUS_VLOW2             BIT(3)
  49 #define RV3029_STATUS_SR                BIT(4)
  50 #define RV3029_STATUS_PON               BIT(5)
  51 #define RV3029_STATUS_EEBUSY            BIT(7)
  52 #define RV3029_RST_CTRL                 0x04
  53 #define RV3029_RST_CTRL_SYSR            BIT(4)
  54 #define RV3029_CONTROL_SECTION_LEN      0x05
  55
  56 /* watch section */
  57 #define RV3029_W_SEC                    0x08
  58 #define RV3029_W_MINUTES                0x09
  59 #define RV3029_W_HOURS                  0x0A
  60 #define RV3029_REG_HR_12_24             BIT(6) /* 24h/12h mode */
  61 #define RV3029_REG_HR_PM                BIT(5) /* PM/AM bit in 12h mode */
  62 #define RV3029_W_DATE                   0x0B
  63 #define RV3029_W_DAYS                   0x0C
  64 #define RV3029_W_MONTHS                 0x0D
  65 #define RV3029_W_YEARS                  0x0E
  66 #define RV3029_WATCH_SECTION_LEN        0x07
  67
  68 /* alarm section */
  69 #define RV3029_A_SC                     0x10
  70 #define RV3029_A_MN                     0x11
  71 #define RV3029_A_HR                     0x12
  72 #define RV3029_A_DT                     0x13
  73 #define RV3029_A_DW                     0x14
  74 #define RV3029_A_MO                     0x15
  75 #define RV3029_A_YR                     0x16
  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_USR1_RAM_PAGE            0x38
 113 #define RV3029_USR1_SECTION_LEN         0x04
 114 #define RV3029_USR2_RAM_PAGE            0x3C
 115 #define RV3029_USR2_SECTION_LEN         0x04
 116
 117 static int
 118 rv3029_i2c_read_regs(struct i2c_client *client, u8 reg, u8 *buf,
 119                      unsigned len)
 120 {
 121         int ret;
 122
 123         if ((reg > RV3029_USR1_RAM_PAGE + 7) ||
 124                 (reg + len > RV3029_USR1_RAM_PAGE + 8))
 125                 return -EINVAL;
 126
 127         ret = i2c_smbus_read_i2c_block_data(client, reg, len, buf);
 128         if (ret < 0)
 129                 return ret;
 130         if (ret < len)
 131                 return -EIO;
 132         return 0;
 133 }
 134
 135 static int
 136 rv3029_i2c_write_regs(struct i2c_client *client, u8 reg, u8 const buf[],
 137                       unsigned len)
 138 {
 139         if ((reg > RV3029_USR1_RAM_PAGE + 7) ||
 140                 (reg + len > RV3029_USR1_RAM_PAGE + 8))
 141                 return -EINVAL;
 142
 143         return i2c_smbus_write_i2c_block_data(client, reg, len, buf);
 144 }
 145
 146 static int
 147 rv3029_i2c_update_bits(struct i2c_client *client, u8 reg, u8 mask, u8 set)
 148 {
 149         u8 buf;
 150         int ret;
 151
 152         ret = rv3029_i2c_read_regs(client, reg, &buf, 1);
 153         if (ret < 0)
 154                 return ret;
 155         buf &= ~mask;
 156         buf |= set & mask;
 157         ret = rv3029_i2c_write_regs(client, reg, &buf, 1);
 158         if (ret < 0)
 159                 return ret;
 160
 161         return 0;
 162 }
 163
 164 static int
 165 rv3029_i2c_get_sr(struct i2c_client *client, u8 *buf)
 166 {
 167         int ret = rv3029_i2c_read_regs(client, RV3029_STATUS, buf, 1);
 168
 169         if (ret < 0)
 170                 return -EIO;
 171         dev_dbg(&client->dev, "status = 0x%.2x (%d)\n", buf[0], buf[0]);
 172         return 0;
 173 }
 174
 175 static int
 176 rv3029_i2c_set_sr(struct i2c_client *client, u8 val)
 177 {
 178         u8 buf[1];
 179         int sr;
 180
 181         buf[0] = val;
 182         sr = rv3029_i2c_write_regs(client, RV3029_STATUS, buf, 1);
 183         dev_dbg(&client->dev, "status = 0x%.2x (%d)\n", buf[0], buf[0]);
 184         if (sr < 0)
 185                 return -EIO;
 186         return 0;
 187 }
 188
 189 static int rv3029_eeprom_busywait(struct i2c_client *client)
 190 {
 191         int i, ret;
 192         u8 sr;
 193
 194         for (i = 100; i > 0; i--) {
 195                 ret = rv3029_i2c_get_sr(client, &sr);
 196                 if (ret < 0)
 197                         break;
 198                 if (!(sr & RV3029_STATUS_EEBUSY))
 199                         break;
 200                 usleep_range(1000, 10000);
 201         }
 202         if (i <= 0) {
 203                 dev_err(&client->dev, "EEPROM busy wait timeout.\n");
 204                 return -ETIMEDOUT;
 205         }
 206
 207         return ret;
 208 }
 209
 210 static int rv3029_eeprom_exit(struct i2c_client *client)
 211 {
 212         /* Re-enable eeprom refresh */
 213         return rv3029_i2c_update_bits(client, RV3029_ONOFF_CTRL,
 214                                       RV3029_ONOFF_CTRL_EERE,
 215                                       RV3029_ONOFF_CTRL_EERE);
 216 }
 217
 218 static int rv3029_eeprom_enter(struct i2c_client *client)
 219 {
 220         int ret;
 221         u8 sr;
 222
 223         /* Check whether we are in the allowed voltage range. */
 224         ret = rv3029_i2c_get_sr(client, &sr);
 225         if (ret < 0)
 226                 return ret;
 227         if (sr & (RV3029_STATUS_VLOW1 | RV3029_STATUS_VLOW2)) {
 228                 /* We clear the bits and retry once just in case
 229                  * we had a brown out in early startup.
 230                  */
 231                 sr &= ~RV3029_STATUS_VLOW1;
 232                 sr &= ~RV3029_STATUS_VLOW2;
 233                 ret = rv3029_i2c_set_sr(client, sr);
 234                 if (ret < 0)
 235                         return ret;
 236                 usleep_range(1000, 10000);
 237                 ret = rv3029_i2c_get_sr(client, &sr);
 238                 if (ret < 0)
 239                         return ret;
 240                 if (sr & (RV3029_STATUS_VLOW1 | RV3029_STATUS_VLOW2)) {
 241                         dev_err(&client->dev,
 242                                 "Supply voltage is too low to safely access the EEPROM.\n");
 243                         return -ENODEV;
 244                 }
 245         }
 246
 247         /* Disable eeprom refresh. */
 248         ret = rv3029_i2c_update_bits(client, RV3029_ONOFF_CTRL,
 249                                      RV3029_ONOFF_CTRL_EERE, 0);
 250         if (ret < 0)
 251                 return ret;
 252
 253         /* Wait for any previous eeprom accesses to finish. */
 254         ret = rv3029_eeprom_busywait(client);
 255         if (ret < 0)
 256                 rv3029_eeprom_exit(client);
 257
 258         return ret;
 259 }
 260
 261 static int rv3029_eeprom_read(struct i2c_client *client, u8 reg,
 262                               u8 buf[], size_t len)
 263 {
 264         int ret, err;
 265
 266         err = rv3029_eeprom_enter(client);
 267         if (err < 0)
 268                 return err;
 269
 270         ret = rv3029_i2c_read_regs(client, reg, buf, len);
 271
 272         err = rv3029_eeprom_exit(client);
 273         if (err < 0)
 274                 return err;
 275
 276         return ret;
 277 }
 278
 279 static int rv3029_eeprom_write(struct i2c_client *client, u8 reg,
 280                                u8 const buf[], size_t len)
 281 {
 282         int ret, err;
 283         size_t i;
 284         u8 tmp;
 285
 286         err = rv3029_eeprom_enter(client);
 287         if (err < 0)
 288                 return err;
 289
 290         for (i = 0; i < len; i++, reg++) {
 291                 ret = rv3029_i2c_read_regs(client, reg, &tmp, 1);
 292                 if (ret < 0)
 293                         break;
 294                 if (tmp != buf[i]) {
 295                         ret = rv3029_i2c_write_regs(client, reg, &buf[i], 1);
 296                         if (ret < 0)
 297                                 break;
 298                 }
 299                 ret = rv3029_eeprom_busywait(client);
 300                 if (ret < 0)
 301                         break;
 302         }
 303
 304         err = rv3029_eeprom_exit(client);
 305         if (err < 0)
 306                 return err;
 307
 308         return ret;
 309 }
 310
 311 static int rv3029_eeprom_update_bits(struct i2c_client *client,
 312                                      u8 reg, u8 mask, u8 set)
 313 {
 314         u8 buf;
 315         int ret;
 316
 317         ret = rv3029_eeprom_read(client, reg, &buf, 1);
 318         if (ret < 0)
 319                 return ret;
 320         buf &= ~mask;
 321         buf |= set & mask;
 322         ret = rv3029_eeprom_write(client, reg, &buf, 1);
 323         if (ret < 0)
 324                 return ret;
 325
 326         return 0;
 327 }
 328
 329 static int
 330 rv3029_i2c_read_time(struct i2c_client *client, struct rtc_time *tm)
 331 {
 332         u8 buf[1];
 333         int ret;
 334         u8 regs[RV3029_WATCH_SECTION_LEN] = { 0, };
 335
 336         ret = rv3029_i2c_get_sr(client, buf);
 337         if (ret < 0) {
 338                 dev_err(&client->dev, "%s: reading SR failed\n", __func__);
 339                 return -EIO;
 340         }
 341
 342         ret = rv3029_i2c_read_regs(client, RV3029_W_SEC, regs,
 343                                    RV3029_WATCH_SECTION_LEN);
 344         if (ret < 0) {
 345                 dev_err(&client->dev, "%s: reading RTC section failed\n",
 346                         __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_rtc_read_time(struct device *dev, struct rtc_time *tm)
 375 {
 376         return rv3029_i2c_read_time(to_i2c_client(dev), tm);
 377 }
 378
 379 static int
 380 rv3029_i2c_read_alarm(struct i2c_client *client, struct rtc_wkalrm *alarm)
 381 {
 382         struct rtc_time *const tm = &alarm->time;
 383         int ret;
 384         u8 regs[8];
 385
 386         ret = rv3029_i2c_get_sr(client, regs);
 387         if (ret < 0) {
 388                 dev_err(&client->dev, "%s: reading SR failed\n", __func__);
 389                 return -EIO;
 390         }
 391
 392         ret = rv3029_i2c_read_regs(client, RV3029_A_SC, regs,
 393                                    RV3029_ALARM_SECTION_LEN);
 394
 395         if (ret < 0) {
 396                 dev_err(&client->dev, "%s: reading alarm section failed\n",
 397                         __func__);
 398                 return ret;
 399         }
 400
 401         tm->tm_sec = bcd2bin(regs[RV3029_A_SC-RV3029_A_SC] & 0x7f);
 402         tm->tm_min = bcd2bin(regs[RV3029_A_MN-RV3029_A_SC] & 0x7f);
 403         tm->tm_hour = bcd2bin(regs[RV3029_A_HR-RV3029_A_SC] & 0x3f);
 404         tm->tm_mday = bcd2bin(regs[RV3029_A_DT-RV3029_A_SC] & 0x3f);
 405         tm->tm_mon = bcd2bin(regs[RV3029_A_MO-RV3029_A_SC] & 0x1f) - 1;
 406         tm->tm_year = bcd2bin(regs[RV3029_A_YR-RV3029_A_SC] & 0x7f) + 100;
 407         tm->tm_wday = bcd2bin(regs[RV3029_A_DW-RV3029_A_SC] & 0x07) - 1;
 408
 409         return 0;
 410 }
 411
 412 static int
 413 rv3029_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
 414 {
 415         return rv3029_i2c_read_alarm(to_i2c_client(dev), alarm);
 416 }
 417
 418 static int rv3029_rtc_i2c_alarm_set_irq(struct i2c_client *client,
 419                                         int enable)
 420 {
 421         int ret;
 422
 423         /* enable/disable AIE irq */
 424         ret = rv3029_i2c_update_bits(client, RV3029_IRQ_CTRL,
 425                                      RV3029_IRQ_CTRL_AIE,
 426                                      (enable ? RV3029_IRQ_CTRL_AIE : 0));
 427         if (ret < 0) {
 428                 dev_err(&client->dev, "can't update INT reg\n");
 429                 return ret;
 430         }
 431
 432         return 0;
 433 }
 434
 435 static int rv3029_rtc_i2c_set_alarm(struct i2c_client *client,
 436                                     struct rtc_wkalrm *alarm)
 437 {
 438         struct rtc_time *const tm = &alarm->time;
 439         int ret;
 440         u8 regs[8];
 441
 442         /*
 443          * The clock has an 8 bit wide bcd-coded register (they never learn)
 444          * for the year. tm_year is an offset from 1900 and we are interested
 445          * in the 2000-2099 range, so any value less than 100 is invalid.
 446         */
 447         if (tm->tm_year < 100)
 448                 return -EINVAL;
 449
 450         ret = rv3029_i2c_get_sr(client, regs);
 451         if (ret < 0) {
 452                 dev_err(&client->dev, "%s: reading SR failed\n", __func__);
 453                 return -EIO;
 454         }
 455         regs[RV3029_A_SC-RV3029_A_SC] = bin2bcd(tm->tm_sec & 0x7f);
 456         regs[RV3029_A_MN-RV3029_A_SC] = bin2bcd(tm->tm_min & 0x7f);
 457         regs[RV3029_A_HR-RV3029_A_SC] = bin2bcd(tm->tm_hour & 0x3f);
 458         regs[RV3029_A_DT-RV3029_A_SC] = bin2bcd(tm->tm_mday & 0x3f);
 459         regs[RV3029_A_MO-RV3029_A_SC] = bin2bcd((tm->tm_mon & 0x1f) - 1);
 460         regs[RV3029_A_DW-RV3029_A_SC] = bin2bcd((tm->tm_wday & 7) - 1);
 461         regs[RV3029_A_YR-RV3029_A_SC] = bin2bcd((tm->tm_year & 0x7f) - 100);
 462
 463         ret = rv3029_i2c_write_regs(client, RV3029_A_SC, regs,
 464                                     RV3029_ALARM_SECTION_LEN);
 465         if (ret < 0)
 466                 return ret;
 467
 468         if (alarm->enabled) {
 469                 /* clear AF flag */
 470                 ret = rv3029_i2c_update_bits(client, RV3029_IRQ_FLAGS,
 471                                              RV3029_IRQ_FLAGS_AF, 0);
 472                 if (ret < 0) {
 473                         dev_err(&client->dev, "can't clear alarm flag\n");
 474                         return ret;
 475                 }
 476                 /* enable AIE irq */
 477                 ret = rv3029_rtc_i2c_alarm_set_irq(client, 1);
 478                 if (ret)
 479                         return ret;
 480
 481                 dev_dbg(&client->dev, "alarm IRQ armed\n");
 482         } else {
 483                 /* disable AIE irq */
 484                 ret = rv3029_rtc_i2c_alarm_set_irq(client, 0);
 485                 if (ret)
 486                         return ret;
 487
 488                 dev_dbg(&client->dev, "alarm IRQ disabled\n");
 489         }
 490
 491         return 0;
 492 }
 493
 494 static int rv3029_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
 495 {
 496         return rv3029_rtc_i2c_set_alarm(to_i2c_client(dev), alarm);
 497 }
 498
 499 static int
 500 rv3029_i2c_set_time(struct i2c_client *client, struct rtc_time const *tm)
 501 {
 502         u8 regs[8];
 503         int ret;
 504
 505         /*
 506          * The clock has an 8 bit wide bcd-coded register (they never learn)
 507          * for the year. tm_year is an offset from 1900 and we are interested
 508          * in the 2000-2099 range, so any value less than 100 is invalid.
 509         */
 510         if (tm->tm_year < 100)
 511                 return -EINVAL;
 512
 513         regs[RV3029_W_SEC-RV3029_W_SEC] = bin2bcd(tm->tm_sec);
 514         regs[RV3029_W_MINUTES-RV3029_W_SEC] = bin2bcd(tm->tm_min);
 515         regs[RV3029_W_HOURS-RV3029_W_SEC] = bin2bcd(tm->tm_hour);
 516         regs[RV3029_W_DATE-RV3029_W_SEC] = bin2bcd(tm->tm_mday);
 517         regs[RV3029_W_MONTHS-RV3029_W_SEC] = bin2bcd(tm->tm_mon+1);
 518         regs[RV3029_W_DAYS-RV3029_W_SEC] = bin2bcd((tm->tm_wday & 7)+1);
 519         regs[RV3029_W_YEARS-RV3029_W_SEC] = bin2bcd(tm->tm_year - 100);
 520
 521         ret = rv3029_i2c_write_regs(client, RV3029_W_SEC, regs,
 522                                     RV3029_WATCH_SECTION_LEN);
 523         if (ret < 0)
 524                 return ret;
 525
 526         ret = rv3029_i2c_get_sr(client, regs);
 527         if (ret < 0) {
 528                 dev_err(&client->dev, "%s: reading SR failed\n", __func__);
 529                 return ret;
 530         }
 531         /* clear PON bit */
 532         ret = rv3029_i2c_set_sr(client, (regs[0] & ~RV3029_STATUS_PON));
 533         if (ret < 0) {
 534                 dev_err(&client->dev, "%s: reading SR failed\n", __func__);
 535                 return ret;
 536         }
 537
 538         return 0;
 539 }
 540
 541 static int rv3029_rtc_set_time(struct device *dev, struct rtc_time *tm)
 542 {
 543         return rv3029_i2c_set_time(to_i2c_client(dev), tm);
 544 }
 545
 546 static const struct rv3029_trickle_tab_elem {
 547         u32 r;          /* resistance in ohms */
 548         u8 conf;        /* trickle config bits */
 549 } rv3029_trickle_tab[] = {
 550         {
 551                 .r      = 1076,
 552                 .conf   = RV3029_TRICKLE_1K | RV3029_TRICKLE_5K |
 553                           RV3029_TRICKLE_20K | RV3029_TRICKLE_80K,
 554         }, {
 555                 .r      = 1091,
 556                 .conf   = RV3029_TRICKLE_1K | RV3029_TRICKLE_5K |
 557                           RV3029_TRICKLE_20K,
 558         }, {
 559                 .r      = 1137,
 560                 .conf   = RV3029_TRICKLE_1K | RV3029_TRICKLE_5K |
 561                           RV3029_TRICKLE_80K,
 562         }, {
 563                 .r      = 1154,
 564                 .conf   = RV3029_TRICKLE_1K | RV3029_TRICKLE_5K,
 565         }, {
 566                 .r      = 1371,
 567                 .conf   = RV3029_TRICKLE_1K | RV3029_TRICKLE_20K |
 568                           RV3029_TRICKLE_80K,
 569         }, {
 570                 .r      = 1395,
 571                 .conf   = RV3029_TRICKLE_1K | RV3029_TRICKLE_20K,
 572         }, {
 573                 .r      = 1472,
 574                 .conf   = RV3029_TRICKLE_1K | RV3029_TRICKLE_80K,
 575         }, {
 576                 .r      = 1500,
 577                 .conf   = RV3029_TRICKLE_1K,
 578         }, {
 579                 .r      = 3810,
 580                 .conf   = RV3029_TRICKLE_5K | RV3029_TRICKLE_20K |
 581                           RV3029_TRICKLE_80K,
 582         }, {
 583                 .r      = 4000,
 584                 .conf   = RV3029_TRICKLE_5K | RV3029_TRICKLE_20K,
 585         }, {
 586                 .r      = 4706,
 587                 .conf   = RV3029_TRICKLE_5K | RV3029_TRICKLE_80K,
 588         }, {
 589                 .r      = 5000,
 590                 .conf   = RV3029_TRICKLE_5K,
 591         }, {
 592                 .r      = 16000,
 593                 .conf   = RV3029_TRICKLE_20K | RV3029_TRICKLE_80K,
 594         }, {
 595                 .r      = 20000,
 596                 .conf   = RV3029_TRICKLE_20K,
 597         }, {
 598                 .r      = 80000,
 599                 .conf   = RV3029_TRICKLE_80K,
 600         },
 601 };
 602
 603 static void rv3029_trickle_config(struct i2c_client *client)
 604 {
 605         struct device_node *of_node = client->dev.of_node;
 606         const struct rv3029_trickle_tab_elem *elem;
 607         int i, err;
 608         u32 ohms;
 609         u8 trickle_set_bits;
 610
 611         if (!of_node)
 612                 return;
 613
 614         /* Configure the trickle charger. */
 615         err = of_property_read_u32(of_node, "trickle-resistor-ohms", &ohms);
 616         if (err) {
 617                 /* Disable trickle charger. */
 618                 trickle_set_bits = 0;
 619         } else {
 620                 /* Enable trickle charger. */
 621                 for (i = 0; i < ARRAY_SIZE(rv3029_trickle_tab); i++) {
 622                         elem = &rv3029_trickle_tab[i];
 623                         if (elem->r >= ohms)
 624                                 break;
 625                 }
 626                 trickle_set_bits = elem->conf;
 627                 dev_info(&client->dev,
 628                          "Trickle charger enabled at %d ohms resistance.\n",
 629                          elem->r);
 630         }
 631         err = rv3029_eeprom_update_bits(client, RV3029_CONTROL_E2P_EECTRL,
 632                                         RV3029_TRICKLE_MASK,
 633                                         trickle_set_bits);
 634         if (err < 0) {
 635                 dev_err(&client->dev,
 636                         "Failed to update trickle charger config\n");
 637         }
 638 }
 639
 640 static const struct rtc_class_ops rv3029_rtc_ops = {
 641         .read_time      = rv3029_rtc_read_time,
 642         .set_time       = rv3029_rtc_set_time,
 643         .read_alarm     = rv3029_rtc_read_alarm,
 644         .set_alarm      = rv3029_rtc_set_alarm,
 645 };
 646
 647 static struct i2c_device_id rv3029_id[] = {
 648         { "rv3029", 0 },
 649         { "rv3029c2", 0 },
 650         { }
 651 };
 652 MODULE_DEVICE_TABLE(i2c, rv3029_id);
 653
 654 static int rv3029_probe(struct i2c_client *client,
 655                         const struct i2c_device_id *id)
 656 {
 657         struct rtc_device *rtc;
 658         int rc = 0;
 659         u8 buf[1];
 660
 661         if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_EMUL))
 662                 return -ENODEV;
 663
 664         rc = rv3029_i2c_get_sr(client, buf);
 665         if (rc < 0) {
 666                 dev_err(&client->dev, "reading status failed\n");
 667                 return rc;
 668         }
 669
 670         rv3029_trickle_config(client);
 671
 672         rtc = devm_rtc_device_register(&client->dev, client->name,
 673                                        &rv3029_rtc_ops, THIS_MODULE);
 674
 675         if (IS_ERR(rtc))
 676                 return PTR_ERR(rtc);
 677
 678         i2c_set_clientdata(client, rtc);
 679
 680         return 0;
 681 }
 682
 683 static struct i2c_driver rv3029_driver = {
 684         .driver = {
 685                 .name = "rtc-rv3029c2",
 686         },
 687         .probe          = rv3029_probe,
 688         .id_table       = rv3029_id,
 689 };
 690
 691 module_i2c_driver(rv3029_driver);
 692
 693 MODULE_AUTHOR("Gregory Hermant <gregory.hermant@calao-systems.com>");
 694 MODULE_AUTHOR("Michael Buesch <m@bues.ch>");
 695 MODULE_DESCRIPTION("Micro Crystal RV3029 RTC driver");
 696 MODULE_LICENSE("GPL");