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