Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Micro Crystal RV-3029 / RV-3049 rtc class driver
0004  *
0005  * Author: Gregory Hermant <gregory.hermant@calao-systems.com>
0006  *         Michael Buesch <m@bues.ch>
0007  *
0008  * based on previously existing rtc class drivers
0009  */
0010 
0011 #include <linux/module.h>
0012 #include <linux/i2c.h>
0013 #include <linux/spi/spi.h>
0014 #include <linux/bcd.h>
0015 #include <linux/rtc.h>
0016 #include <linux/delay.h>
0017 #include <linux/of.h>
0018 #include <linux/hwmon.h>
0019 #include <linux/hwmon-sysfs.h>
0020 #include <linux/regmap.h>
0021 
0022 /* Register map */
0023 /* control section */
0024 #define RV3029_ONOFF_CTRL       0x00
0025 #define RV3029_ONOFF_CTRL_WE        BIT(0)
0026 #define RV3029_ONOFF_CTRL_TE        BIT(1)
0027 #define RV3029_ONOFF_CTRL_TAR       BIT(2)
0028 #define RV3029_ONOFF_CTRL_EERE      BIT(3)
0029 #define RV3029_ONOFF_CTRL_SRON      BIT(4)
0030 #define RV3029_ONOFF_CTRL_TD0       BIT(5)
0031 #define RV3029_ONOFF_CTRL_TD1       BIT(6)
0032 #define RV3029_ONOFF_CTRL_CLKINT    BIT(7)
0033 #define RV3029_IRQ_CTRL         0x01
0034 #define RV3029_IRQ_CTRL_AIE     BIT(0)
0035 #define RV3029_IRQ_CTRL_TIE     BIT(1)
0036 #define RV3029_IRQ_CTRL_V1IE        BIT(2)
0037 #define RV3029_IRQ_CTRL_V2IE        BIT(3)
0038 #define RV3029_IRQ_CTRL_SRIE        BIT(4)
0039 #define RV3029_IRQ_FLAGS        0x02
0040 #define RV3029_IRQ_FLAGS_AF     BIT(0)
0041 #define RV3029_IRQ_FLAGS_TF     BIT(1)
0042 #define RV3029_IRQ_FLAGS_V1IF       BIT(2)
0043 #define RV3029_IRQ_FLAGS_V2IF       BIT(3)
0044 #define RV3029_IRQ_FLAGS_SRF        BIT(4)
0045 #define RV3029_STATUS           0x03
0046 #define RV3029_STATUS_VLOW1     BIT(2)
0047 #define RV3029_STATUS_VLOW2     BIT(3)
0048 #define RV3029_STATUS_SR        BIT(4)
0049 #define RV3029_STATUS_PON       BIT(5)
0050 #define RV3029_STATUS_EEBUSY        BIT(7)
0051 #define RV3029_RST_CTRL         0x04
0052 #define RV3029_RST_CTRL_SYSR        BIT(4)
0053 #define RV3029_CONTROL_SECTION_LEN  0x05
0054 
0055 /* watch section */
0056 #define RV3029_W_SEC            0x08
0057 #define RV3029_W_MINUTES        0x09
0058 #define RV3029_W_HOURS          0x0A
0059 #define RV3029_REG_HR_12_24     BIT(6) /* 24h/12h mode */
0060 #define RV3029_REG_HR_PM        BIT(5) /* PM/AM bit in 12h mode */
0061 #define RV3029_W_DATE           0x0B
0062 #define RV3029_W_DAYS           0x0C
0063 #define RV3029_W_MONTHS         0x0D
0064 #define RV3029_W_YEARS          0x0E
0065 #define RV3029_WATCH_SECTION_LEN    0x07
0066 
0067 /* alarm section */
0068 #define RV3029_A_SC         0x10
0069 #define RV3029_A_MN         0x11
0070 #define RV3029_A_HR         0x12
0071 #define RV3029_A_DT         0x13
0072 #define RV3029_A_DW         0x14
0073 #define RV3029_A_MO         0x15
0074 #define RV3029_A_YR         0x16
0075 #define RV3029_A_AE_X           BIT(7)
0076 #define RV3029_ALARM_SECTION_LEN    0x07
0077 
0078 /* timer section */
0079 #define RV3029_TIMER_LOW        0x18
0080 #define RV3029_TIMER_HIGH       0x19
0081 
0082 /* temperature section */
0083 #define RV3029_TEMP_PAGE        0x20
0084 
0085 /* eeprom data section */
0086 #define RV3029_E2P_EEDATA1      0x28
0087 #define RV3029_E2P_EEDATA2      0x29
0088 #define RV3029_E2PDATA_SECTION_LEN  0x02
0089 
0090 /* eeprom control section */
0091 #define RV3029_CONTROL_E2P_EECTRL   0x30
0092 #define RV3029_EECTRL_THP       BIT(0) /* temp scan interval */
0093 #define RV3029_EECTRL_THE       BIT(1) /* thermometer enable */
0094 #define RV3029_EECTRL_FD0       BIT(2) /* CLKOUT */
0095 #define RV3029_EECTRL_FD1       BIT(3) /* CLKOUT */
0096 #define RV3029_TRICKLE_1K       BIT(4) /* 1.5K resistance */
0097 #define RV3029_TRICKLE_5K       BIT(5) /* 5K   resistance */
0098 #define RV3029_TRICKLE_20K      BIT(6) /* 20K  resistance */
0099 #define RV3029_TRICKLE_80K      BIT(7) /* 80K  resistance */
0100 #define RV3029_TRICKLE_MASK     (RV3029_TRICKLE_1K |\
0101                      RV3029_TRICKLE_5K |\
0102                      RV3029_TRICKLE_20K |\
0103                      RV3029_TRICKLE_80K)
0104 #define RV3029_TRICKLE_SHIFT        4
0105 #define RV3029_CONTROL_E2P_XOFFS    0x31 /* XTAL offset */
0106 #define RV3029_CONTROL_E2P_XOFFS_SIGN   BIT(7) /* Sign: 1->pos, 0->neg */
0107 #define RV3029_CONTROL_E2P_QCOEF    0x32 /* XTAL temp drift coef */
0108 #define RV3029_CONTROL_E2P_TURNOVER 0x33 /* XTAL turnover temp (in *C) */
0109 #define RV3029_CONTROL_E2P_TOV_MASK 0x3F /* XTAL turnover temp mask */
0110 
0111 /* user ram section */
0112 #define RV3029_RAM_PAGE         0x38
0113 #define RV3029_RAM_SECTION_LEN      8
0114 
0115 struct rv3029_data {
0116     struct device       *dev;
0117     struct rtc_device   *rtc;
0118     struct regmap       *regmap;
0119     int irq;
0120 };
0121 
0122 static int rv3029_eeprom_busywait(struct rv3029_data *rv3029)
0123 {
0124     unsigned int sr;
0125     int i, ret;
0126 
0127     for (i = 100; i > 0; i--) {
0128         ret = regmap_read(rv3029->regmap, RV3029_STATUS, &sr);
0129         if (ret < 0)
0130             break;
0131         if (!(sr & RV3029_STATUS_EEBUSY))
0132             break;
0133         usleep_range(1000, 10000);
0134     }
0135     if (i <= 0) {
0136         dev_err(rv3029->dev, "EEPROM busy wait timeout.\n");
0137         return -ETIMEDOUT;
0138     }
0139 
0140     return ret;
0141 }
0142 
0143 static int rv3029_eeprom_exit(struct rv3029_data *rv3029)
0144 {
0145     /* Re-enable eeprom refresh */
0146     return regmap_update_bits(rv3029->regmap, RV3029_ONOFF_CTRL,
0147                   RV3029_ONOFF_CTRL_EERE,
0148                   RV3029_ONOFF_CTRL_EERE);
0149 }
0150 
0151 static int rv3029_eeprom_enter(struct rv3029_data *rv3029)
0152 {
0153     unsigned int sr;
0154     int ret;
0155 
0156     /* Check whether we are in the allowed voltage range. */
0157     ret = regmap_read(rv3029->regmap, RV3029_STATUS, &sr);
0158     if (ret < 0)
0159         return ret;
0160     if (sr & RV3029_STATUS_VLOW2)
0161         return -ENODEV;
0162     if (sr & RV3029_STATUS_VLOW1) {
0163         /* We clear the bits and retry once just in case
0164          * we had a brown out in early startup.
0165          */
0166         ret = regmap_update_bits(rv3029->regmap, RV3029_STATUS,
0167                      RV3029_STATUS_VLOW1, 0);
0168         if (ret < 0)
0169             return ret;
0170         usleep_range(1000, 10000);
0171         ret = regmap_read(rv3029->regmap, RV3029_STATUS, &sr);
0172         if (ret < 0)
0173             return ret;
0174         if (sr & RV3029_STATUS_VLOW1) {
0175             dev_err(rv3029->dev,
0176                 "Supply voltage is too low to safely access the EEPROM.\n");
0177             return -ENODEV;
0178         }
0179     }
0180 
0181     /* Disable eeprom refresh. */
0182     ret = regmap_update_bits(rv3029->regmap, RV3029_ONOFF_CTRL,
0183                  RV3029_ONOFF_CTRL_EERE, 0);
0184     if (ret < 0)
0185         return ret;
0186 
0187     /* Wait for any previous eeprom accesses to finish. */
0188     ret = rv3029_eeprom_busywait(rv3029);
0189     if (ret < 0)
0190         rv3029_eeprom_exit(rv3029);
0191 
0192     return ret;
0193 }
0194 
0195 static int rv3029_eeprom_read(struct rv3029_data *rv3029, u8 reg,
0196                   u8 buf[], size_t len)
0197 {
0198     int ret, err;
0199 
0200     err = rv3029_eeprom_enter(rv3029);
0201     if (err < 0)
0202         return err;
0203 
0204     ret = regmap_bulk_read(rv3029->regmap, reg, buf, len);
0205 
0206     err = rv3029_eeprom_exit(rv3029);
0207     if (err < 0)
0208         return err;
0209 
0210     return ret;
0211 }
0212 
0213 static int rv3029_eeprom_write(struct rv3029_data *rv3029, u8 reg,
0214                    u8 const buf[], size_t len)
0215 {
0216     unsigned int tmp;
0217     int ret, err;
0218     size_t i;
0219 
0220     err = rv3029_eeprom_enter(rv3029);
0221     if (err < 0)
0222         return err;
0223 
0224     for (i = 0; i < len; i++, reg++) {
0225         ret = regmap_read(rv3029->regmap, reg, &tmp);
0226         if (ret < 0)
0227             break;
0228         if (tmp != buf[i]) {
0229             tmp = buf[i];
0230             ret = regmap_write(rv3029->regmap, reg, tmp);
0231             if (ret < 0)
0232                 break;
0233         }
0234         ret = rv3029_eeprom_busywait(rv3029);
0235         if (ret < 0)
0236             break;
0237     }
0238 
0239     err = rv3029_eeprom_exit(rv3029);
0240     if (err < 0)
0241         return err;
0242 
0243     return ret;
0244 }
0245 
0246 static int rv3029_eeprom_update_bits(struct rv3029_data *rv3029,
0247                      u8 reg, u8 mask, u8 set)
0248 {
0249     u8 buf;
0250     int ret;
0251 
0252     ret = rv3029_eeprom_read(rv3029, reg, &buf, 1);
0253     if (ret < 0)
0254         return ret;
0255     buf &= ~mask;
0256     buf |= set & mask;
0257     ret = rv3029_eeprom_write(rv3029, reg, &buf, 1);
0258     if (ret < 0)
0259         return ret;
0260 
0261     return 0;
0262 }
0263 
0264 static irqreturn_t rv3029_handle_irq(int irq, void *dev_id)
0265 {
0266     struct device *dev = dev_id;
0267     struct rv3029_data *rv3029 = dev_get_drvdata(dev);
0268     unsigned int flags, controls;
0269     unsigned long events = 0;
0270     int ret;
0271 
0272     rtc_lock(rv3029->rtc);
0273 
0274     ret = regmap_read(rv3029->regmap, RV3029_IRQ_CTRL, &controls);
0275     if (ret) {
0276         dev_warn(dev, "Read IRQ Control Register error %d\n", ret);
0277         rtc_unlock(rv3029->rtc);
0278         return IRQ_NONE;
0279     }
0280 
0281     ret = regmap_read(rv3029->regmap, RV3029_IRQ_FLAGS, &flags);
0282     if (ret) {
0283         dev_warn(dev, "Read IRQ Flags Register error %d\n", ret);
0284         rtc_unlock(rv3029->rtc);
0285         return IRQ_NONE;
0286     }
0287 
0288     if (flags & RV3029_IRQ_FLAGS_AF) {
0289         flags &= ~RV3029_IRQ_FLAGS_AF;
0290         controls &= ~RV3029_IRQ_CTRL_AIE;
0291         events |= RTC_AF;
0292     }
0293 
0294     if (events) {
0295         rtc_update_irq(rv3029->rtc, 1, events);
0296         regmap_write(rv3029->regmap, RV3029_IRQ_FLAGS, flags);
0297         regmap_write(rv3029->regmap, RV3029_IRQ_CTRL, controls);
0298     }
0299     rtc_unlock(rv3029->rtc);
0300 
0301     return IRQ_HANDLED;
0302 }
0303 
0304 static int rv3029_read_time(struct device *dev, struct rtc_time *tm)
0305 {
0306     struct rv3029_data *rv3029 = dev_get_drvdata(dev);
0307     unsigned int sr;
0308     int ret;
0309     u8 regs[RV3029_WATCH_SECTION_LEN] = { 0, };
0310 
0311     ret = regmap_read(rv3029->regmap, RV3029_STATUS, &sr);
0312     if (ret < 0)
0313         return ret;
0314 
0315     if (sr & (RV3029_STATUS_VLOW2 | RV3029_STATUS_PON))
0316         return -EINVAL;
0317 
0318     ret = regmap_bulk_read(rv3029->regmap, RV3029_W_SEC, regs,
0319                    RV3029_WATCH_SECTION_LEN);
0320     if (ret < 0)
0321         return ret;
0322 
0323     tm->tm_sec = bcd2bin(regs[RV3029_W_SEC - RV3029_W_SEC]);
0324     tm->tm_min = bcd2bin(regs[RV3029_W_MINUTES - RV3029_W_SEC]);
0325 
0326     /* HR field has a more complex interpretation */
0327     {
0328         const u8 _hr = regs[RV3029_W_HOURS - RV3029_W_SEC];
0329 
0330         if (_hr & RV3029_REG_HR_12_24) {
0331             /* 12h format */
0332             tm->tm_hour = bcd2bin(_hr & 0x1f);
0333             if (_hr & RV3029_REG_HR_PM) /* PM flag set */
0334                 tm->tm_hour += 12;
0335         } else /* 24h format */
0336             tm->tm_hour = bcd2bin(_hr & 0x3f);
0337     }
0338 
0339     tm->tm_mday = bcd2bin(regs[RV3029_W_DATE - RV3029_W_SEC]);
0340     tm->tm_mon = bcd2bin(regs[RV3029_W_MONTHS - RV3029_W_SEC]) - 1;
0341     tm->tm_year = bcd2bin(regs[RV3029_W_YEARS - RV3029_W_SEC]) + 100;
0342     tm->tm_wday = bcd2bin(regs[RV3029_W_DAYS - RV3029_W_SEC]) - 1;
0343 
0344     return 0;
0345 }
0346 
0347 static int rv3029_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
0348 {
0349     struct rv3029_data *rv3029 = dev_get_drvdata(dev);
0350     struct rtc_time *const tm = &alarm->time;
0351     unsigned int controls, flags;
0352     int ret;
0353     u8 regs[8];
0354 
0355     ret = regmap_bulk_read(rv3029->regmap, RV3029_A_SC, regs,
0356                    RV3029_ALARM_SECTION_LEN);
0357     if (ret < 0)
0358         return ret;
0359 
0360     ret = regmap_read(rv3029->regmap, RV3029_IRQ_CTRL, &controls);
0361     if (ret)
0362         return ret;
0363 
0364     ret = regmap_read(rv3029->regmap, RV3029_IRQ_FLAGS, &flags);
0365     if (ret < 0)
0366         return ret;
0367 
0368     tm->tm_sec = bcd2bin(regs[RV3029_A_SC - RV3029_A_SC] & 0x7f);
0369     tm->tm_min = bcd2bin(regs[RV3029_A_MN - RV3029_A_SC] & 0x7f);
0370     tm->tm_hour = bcd2bin(regs[RV3029_A_HR - RV3029_A_SC] & 0x3f);
0371     tm->tm_mday = bcd2bin(regs[RV3029_A_DT - RV3029_A_SC] & 0x3f);
0372     tm->tm_mon = bcd2bin(regs[RV3029_A_MO - RV3029_A_SC] & 0x1f) - 1;
0373     tm->tm_year = bcd2bin(regs[RV3029_A_YR - RV3029_A_SC] & 0x7f) + 100;
0374     tm->tm_wday = bcd2bin(regs[RV3029_A_DW - RV3029_A_SC] & 0x07) - 1;
0375 
0376     alarm->enabled = !!(controls & RV3029_IRQ_CTRL_AIE);
0377     alarm->pending = (flags & RV3029_IRQ_FLAGS_AF) && alarm->enabled;
0378 
0379     return 0;
0380 }
0381 
0382 static int rv3029_alarm_irq_enable(struct device *dev, unsigned int enable)
0383 {
0384     struct rv3029_data *rv3029 = dev_get_drvdata(dev);
0385 
0386     return regmap_update_bits(rv3029->regmap, RV3029_IRQ_CTRL,
0387                   RV3029_IRQ_CTRL_AIE,
0388                   enable ? RV3029_IRQ_CTRL_AIE : 0);
0389 }
0390 
0391 static int rv3029_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
0392 {
0393     struct rv3029_data *rv3029 = dev_get_drvdata(dev);
0394     struct rtc_time *const tm = &alarm->time;
0395     int ret;
0396     u8 regs[8];
0397 
0398     /* Activate all the alarms with AE_x bit */
0399     regs[RV3029_A_SC - RV3029_A_SC] = bin2bcd(tm->tm_sec) | RV3029_A_AE_X;
0400     regs[RV3029_A_MN - RV3029_A_SC] = bin2bcd(tm->tm_min) | RV3029_A_AE_X;
0401     regs[RV3029_A_HR - RV3029_A_SC] = (bin2bcd(tm->tm_hour) & 0x3f)
0402         | RV3029_A_AE_X;
0403     regs[RV3029_A_DT - RV3029_A_SC] = (bin2bcd(tm->tm_mday) & 0x3f)
0404         | RV3029_A_AE_X;
0405     regs[RV3029_A_MO - RV3029_A_SC] = (bin2bcd(tm->tm_mon + 1) & 0x1f)
0406         | RV3029_A_AE_X;
0407     regs[RV3029_A_DW - RV3029_A_SC] = (bin2bcd(tm->tm_wday + 1) & 0x7)
0408         | RV3029_A_AE_X;
0409     regs[RV3029_A_YR - RV3029_A_SC] = (bin2bcd(tm->tm_year - 100))
0410         | RV3029_A_AE_X;
0411 
0412     /* Write the alarm */
0413     ret = regmap_bulk_write(rv3029->regmap, RV3029_A_SC, regs,
0414                 RV3029_ALARM_SECTION_LEN);
0415     if (ret < 0)
0416         return ret;
0417 
0418     return rv3029_alarm_irq_enable(dev, alarm->enabled);
0419 }
0420 
0421 static int rv3029_set_time(struct device *dev, struct rtc_time *tm)
0422 {
0423     struct rv3029_data *rv3029 = dev_get_drvdata(dev);
0424     u8 regs[8];
0425     int ret;
0426 
0427     regs[RV3029_W_SEC - RV3029_W_SEC] = bin2bcd(tm->tm_sec);
0428     regs[RV3029_W_MINUTES - RV3029_W_SEC] = bin2bcd(tm->tm_min);
0429     regs[RV3029_W_HOURS - RV3029_W_SEC] = bin2bcd(tm->tm_hour);
0430     regs[RV3029_W_DATE - RV3029_W_SEC] = bin2bcd(tm->tm_mday);
0431     regs[RV3029_W_MONTHS - RV3029_W_SEC] = bin2bcd(tm->tm_mon + 1);
0432     regs[RV3029_W_DAYS - RV3029_W_SEC] = bin2bcd(tm->tm_wday + 1) & 0x7;
0433     regs[RV3029_W_YEARS - RV3029_W_SEC] = bin2bcd(tm->tm_year - 100);
0434 
0435     ret = regmap_bulk_write(rv3029->regmap, RV3029_W_SEC, regs,
0436                 RV3029_WATCH_SECTION_LEN);
0437     if (ret < 0)
0438         return ret;
0439 
0440     /* clear PON and VLOW2 bits */
0441     return regmap_update_bits(rv3029->regmap, RV3029_STATUS,
0442                   RV3029_STATUS_PON | RV3029_STATUS_VLOW2, 0);
0443 }
0444 
0445 static int rv3029_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
0446 {
0447     struct rv3029_data *rv3029 = dev_get_drvdata(dev);
0448     unsigned long vl = 0;
0449     int sr, ret = 0;
0450 
0451     switch (cmd) {
0452     case RTC_VL_READ:
0453         ret = regmap_read(rv3029->regmap, RV3029_STATUS, &sr);
0454         if (ret < 0)
0455             return ret;
0456 
0457         if (sr & RV3029_STATUS_VLOW1)
0458             vl = RTC_VL_ACCURACY_LOW;
0459 
0460         if (sr & (RV3029_STATUS_VLOW2 | RV3029_STATUS_PON))
0461             vl |= RTC_VL_DATA_INVALID;
0462 
0463         return put_user(vl, (unsigned int __user *)arg);
0464 
0465     case RTC_VL_CLR:
0466         return regmap_update_bits(rv3029->regmap, RV3029_STATUS,
0467                       RV3029_STATUS_VLOW1, 0);
0468 
0469     default:
0470         return -ENOIOCTLCMD;
0471     }
0472 }
0473 
0474 static int rv3029_nvram_write(void *priv, unsigned int offset, void *val,
0475                   size_t bytes)
0476 {
0477     return regmap_bulk_write(priv, RV3029_RAM_PAGE + offset, val, bytes);
0478 }
0479 
0480 static int rv3029_nvram_read(void *priv, unsigned int offset, void *val,
0481                  size_t bytes)
0482 {
0483     return regmap_bulk_read(priv, RV3029_RAM_PAGE + offset, val, bytes);
0484 }
0485 
0486 static const struct rv3029_trickle_tab_elem {
0487     u32 r;      /* resistance in ohms */
0488     u8 conf;    /* trickle config bits */
0489 } rv3029_trickle_tab[] = {
0490     {
0491         .r  = 1076,
0492         .conf   = RV3029_TRICKLE_1K | RV3029_TRICKLE_5K |
0493               RV3029_TRICKLE_20K | RV3029_TRICKLE_80K,
0494     }, {
0495         .r  = 1091,
0496         .conf   = RV3029_TRICKLE_1K | RV3029_TRICKLE_5K |
0497               RV3029_TRICKLE_20K,
0498     }, {
0499         .r  = 1137,
0500         .conf   = RV3029_TRICKLE_1K | RV3029_TRICKLE_5K |
0501               RV3029_TRICKLE_80K,
0502     }, {
0503         .r  = 1154,
0504         .conf   = RV3029_TRICKLE_1K | RV3029_TRICKLE_5K,
0505     }, {
0506         .r  = 1371,
0507         .conf   = RV3029_TRICKLE_1K | RV3029_TRICKLE_20K |
0508               RV3029_TRICKLE_80K,
0509     }, {
0510         .r  = 1395,
0511         .conf   = RV3029_TRICKLE_1K | RV3029_TRICKLE_20K,
0512     }, {
0513         .r  = 1472,
0514         .conf   = RV3029_TRICKLE_1K | RV3029_TRICKLE_80K,
0515     }, {
0516         .r  = 1500,
0517         .conf   = RV3029_TRICKLE_1K,
0518     }, {
0519         .r  = 3810,
0520         .conf   = RV3029_TRICKLE_5K | RV3029_TRICKLE_20K |
0521               RV3029_TRICKLE_80K,
0522     }, {
0523         .r  = 4000,
0524         .conf   = RV3029_TRICKLE_5K | RV3029_TRICKLE_20K,
0525     }, {
0526         .r  = 4706,
0527         .conf   = RV3029_TRICKLE_5K | RV3029_TRICKLE_80K,
0528     }, {
0529         .r  = 5000,
0530         .conf   = RV3029_TRICKLE_5K,
0531     }, {
0532         .r  = 16000,
0533         .conf   = RV3029_TRICKLE_20K | RV3029_TRICKLE_80K,
0534     }, {
0535         .r  = 20000,
0536         .conf   = RV3029_TRICKLE_20K,
0537     }, {
0538         .r  = 80000,
0539         .conf   = RV3029_TRICKLE_80K,
0540     },
0541 };
0542 
0543 static void rv3029_trickle_config(struct device *dev)
0544 {
0545     struct rv3029_data *rv3029 = dev_get_drvdata(dev);
0546     struct device_node *of_node = dev->of_node;
0547     const struct rv3029_trickle_tab_elem *elem;
0548     int i, err;
0549     u32 ohms;
0550     u8 trickle_set_bits;
0551 
0552     if (!of_node)
0553         return;
0554 
0555     /* Configure the trickle charger. */
0556     err = of_property_read_u32(of_node, "trickle-resistor-ohms", &ohms);
0557     if (err) {
0558         /* Disable trickle charger. */
0559         trickle_set_bits = 0;
0560     } else {
0561         /* Enable trickle charger. */
0562         for (i = 0; i < ARRAY_SIZE(rv3029_trickle_tab); i++) {
0563             elem = &rv3029_trickle_tab[i];
0564             if (elem->r >= ohms)
0565                 break;
0566         }
0567         trickle_set_bits = elem->conf;
0568         dev_info(dev,
0569              "Trickle charger enabled at %d ohms resistance.\n",
0570              elem->r);
0571     }
0572     err = rv3029_eeprom_update_bits(rv3029, RV3029_CONTROL_E2P_EECTRL,
0573                     RV3029_TRICKLE_MASK,
0574                     trickle_set_bits);
0575     if (err < 0)
0576         dev_err(dev, "Failed to update trickle charger config\n");
0577 }
0578 
0579 #ifdef CONFIG_RTC_DRV_RV3029_HWMON
0580 
0581 static int rv3029_read_temp(struct rv3029_data *rv3029, int *temp_mC)
0582 {
0583     unsigned int temp;
0584     int ret;
0585 
0586     ret = regmap_read(rv3029->regmap, RV3029_TEMP_PAGE, &temp);
0587     if (ret < 0)
0588         return ret;
0589 
0590     *temp_mC = ((int)temp - 60) * 1000;
0591 
0592     return 0;
0593 }
0594 
0595 static ssize_t rv3029_hwmon_show_temp(struct device *dev,
0596                       struct device_attribute *attr,
0597                       char *buf)
0598 {
0599     struct rv3029_data *rv3029 = dev_get_drvdata(dev);
0600     int ret, temp_mC;
0601 
0602     ret = rv3029_read_temp(rv3029, &temp_mC);
0603     if (ret < 0)
0604         return ret;
0605 
0606     return sprintf(buf, "%d\n", temp_mC);
0607 }
0608 
0609 static ssize_t rv3029_hwmon_set_update_interval(struct device *dev,
0610                         struct device_attribute *attr,
0611                         const char *buf,
0612                         size_t count)
0613 {
0614     struct rv3029_data *rv3029 = dev_get_drvdata(dev);
0615     unsigned int th_set_bits = 0;
0616     unsigned long interval_ms;
0617     int ret;
0618 
0619     ret = kstrtoul(buf, 10, &interval_ms);
0620     if (ret < 0)
0621         return ret;
0622 
0623     if (interval_ms != 0) {
0624         th_set_bits |= RV3029_EECTRL_THE;
0625         if (interval_ms >= 16000)
0626             th_set_bits |= RV3029_EECTRL_THP;
0627     }
0628     ret = rv3029_eeprom_update_bits(rv3029, RV3029_CONTROL_E2P_EECTRL,
0629                     RV3029_EECTRL_THE | RV3029_EECTRL_THP,
0630                     th_set_bits);
0631     if (ret < 0)
0632         return ret;
0633 
0634     return count;
0635 }
0636 
0637 static ssize_t rv3029_hwmon_show_update_interval(struct device *dev,
0638                          struct device_attribute *attr,
0639                          char *buf)
0640 {
0641     struct rv3029_data *rv3029 = dev_get_drvdata(dev);
0642     int ret, interval_ms;
0643     u8 eectrl;
0644 
0645     ret = rv3029_eeprom_read(rv3029, RV3029_CONTROL_E2P_EECTRL,
0646                  &eectrl, 1);
0647     if (ret < 0)
0648         return ret;
0649 
0650     if (eectrl & RV3029_EECTRL_THE) {
0651         if (eectrl & RV3029_EECTRL_THP)
0652             interval_ms = 16000;
0653         else
0654             interval_ms = 1000;
0655     } else {
0656         interval_ms = 0;
0657     }
0658 
0659     return sprintf(buf, "%d\n", interval_ms);
0660 }
0661 
0662 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, rv3029_hwmon_show_temp,
0663               NULL, 0);
0664 static SENSOR_DEVICE_ATTR(update_interval, S_IWUSR | S_IRUGO,
0665               rv3029_hwmon_show_update_interval,
0666               rv3029_hwmon_set_update_interval, 0);
0667 
0668 static struct attribute *rv3029_hwmon_attrs[] = {
0669     &sensor_dev_attr_temp1_input.dev_attr.attr,
0670     &sensor_dev_attr_update_interval.dev_attr.attr,
0671     NULL,
0672 };
0673 ATTRIBUTE_GROUPS(rv3029_hwmon);
0674 
0675 static void rv3029_hwmon_register(struct device *dev, const char *name)
0676 {
0677     struct rv3029_data *rv3029 = dev_get_drvdata(dev);
0678     struct device *hwmon_dev;
0679 
0680     hwmon_dev = devm_hwmon_device_register_with_groups(dev, name, rv3029,
0681                                rv3029_hwmon_groups);
0682     if (IS_ERR(hwmon_dev)) {
0683         dev_warn(dev, "unable to register hwmon device %ld\n",
0684              PTR_ERR(hwmon_dev));
0685     }
0686 }
0687 
0688 #else /* CONFIG_RTC_DRV_RV3029_HWMON */
0689 
0690 static void rv3029_hwmon_register(struct device *dev, const char *name)
0691 {
0692 }
0693 
0694 #endif /* CONFIG_RTC_DRV_RV3029_HWMON */
0695 
0696 static const struct rtc_class_ops rv3029_rtc_ops = {
0697     .read_time  = rv3029_read_time,
0698     .set_time   = rv3029_set_time,
0699     .ioctl      = rv3029_ioctl,
0700     .read_alarm = rv3029_read_alarm,
0701     .set_alarm  = rv3029_set_alarm,
0702     .alarm_irq_enable = rv3029_alarm_irq_enable,
0703 };
0704 
0705 static int rv3029_probe(struct device *dev, struct regmap *regmap, int irq,
0706             const char *name)
0707 {
0708     struct rv3029_data *rv3029;
0709     struct nvmem_config nvmem_cfg = {
0710         .name = "rv3029_nvram",
0711         .word_size = 1,
0712         .stride = 1,
0713         .size = RV3029_RAM_SECTION_LEN,
0714         .type = NVMEM_TYPE_BATTERY_BACKED,
0715         .reg_read = rv3029_nvram_read,
0716         .reg_write = rv3029_nvram_write,
0717     };
0718     int rc = 0;
0719 
0720     rv3029 = devm_kzalloc(dev, sizeof(*rv3029), GFP_KERNEL);
0721     if (!rv3029)
0722         return -ENOMEM;
0723 
0724     rv3029->regmap = regmap;
0725     rv3029->irq = irq;
0726     rv3029->dev = dev;
0727     dev_set_drvdata(dev, rv3029);
0728 
0729     rv3029_trickle_config(dev);
0730     rv3029_hwmon_register(dev, name);
0731 
0732     rv3029->rtc = devm_rtc_allocate_device(dev);
0733     if (IS_ERR(rv3029->rtc))
0734         return PTR_ERR(rv3029->rtc);
0735 
0736     if (rv3029->irq > 0) {
0737         rc = devm_request_threaded_irq(dev, rv3029->irq,
0738                            NULL, rv3029_handle_irq,
0739                            IRQF_TRIGGER_LOW | IRQF_ONESHOT,
0740                            "rv3029", dev);
0741         if (rc) {
0742             dev_warn(dev, "unable to request IRQ, alarms disabled\n");
0743             rv3029->irq = 0;
0744         }
0745     }
0746     if (!rv3029->irq)
0747         clear_bit(RTC_FEATURE_ALARM, rv3029->rtc->features);
0748 
0749     rv3029->rtc->ops = &rv3029_rtc_ops;
0750     rv3029->rtc->range_min = RTC_TIMESTAMP_BEGIN_2000;
0751     rv3029->rtc->range_max = RTC_TIMESTAMP_END_2079;
0752 
0753     rc = devm_rtc_register_device(rv3029->rtc);
0754     if (rc)
0755         return rc;
0756 
0757     nvmem_cfg.priv = rv3029->regmap;
0758     devm_rtc_nvmem_register(rv3029->rtc, &nvmem_cfg);
0759 
0760     return 0;
0761 }
0762 
0763 static const struct regmap_range rv3029_holes_range[] = {
0764     regmap_reg_range(0x05, 0x07),
0765     regmap_reg_range(0x0f, 0x0f),
0766     regmap_reg_range(0x17, 0x17),
0767     regmap_reg_range(0x1a, 0x1f),
0768     regmap_reg_range(0x21, 0x27),
0769     regmap_reg_range(0x34, 0x37),
0770 };
0771 
0772 static const struct regmap_access_table rv3029_regs = {
0773     .no_ranges =    rv3029_holes_range,
0774     .n_no_ranges =  ARRAY_SIZE(rv3029_holes_range),
0775 };
0776 
0777 static const struct regmap_config config = {
0778     .reg_bits = 8,
0779     .val_bits = 8,
0780     .rd_table = &rv3029_regs,
0781     .wr_table = &rv3029_regs,
0782     .max_register = 0x3f,
0783 };
0784 
0785 #if IS_ENABLED(CONFIG_I2C)
0786 
0787 static int rv3029_i2c_probe(struct i2c_client *client)
0788 {
0789     struct regmap *regmap;
0790     if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_I2C_BLOCK |
0791                      I2C_FUNC_SMBUS_BYTE)) {
0792         dev_err(&client->dev, "Adapter does not support SMBUS_I2C_BLOCK or SMBUS_I2C_BYTE\n");
0793         return -ENODEV;
0794     }
0795 
0796     regmap = devm_regmap_init_i2c(client, &config);
0797     if (IS_ERR(regmap))
0798         return PTR_ERR(regmap);
0799 
0800     return rv3029_probe(&client->dev, regmap, client->irq, client->name);
0801 }
0802 
0803 static const struct i2c_device_id rv3029_id[] = {
0804     { "rv3029", 0 },
0805     { "rv3029c2", 0 },
0806     { }
0807 };
0808 MODULE_DEVICE_TABLE(i2c, rv3029_id);
0809 
0810 static const __maybe_unused struct of_device_id rv3029_of_match[] = {
0811     { .compatible = "microcrystal,rv3029" },
0812     { }
0813 };
0814 MODULE_DEVICE_TABLE(of, rv3029_of_match);
0815 
0816 static struct i2c_driver rv3029_driver = {
0817     .driver = {
0818         .name = "rv3029",
0819         .of_match_table = of_match_ptr(rv3029_of_match),
0820     },
0821     .probe_new  = rv3029_i2c_probe,
0822     .id_table   = rv3029_id,
0823 };
0824 
0825 static int __init rv3029_register_driver(void)
0826 {
0827     return i2c_add_driver(&rv3029_driver);
0828 }
0829 
0830 static void rv3029_unregister_driver(void)
0831 {
0832     i2c_del_driver(&rv3029_driver);
0833 }
0834 
0835 #else
0836 
0837 static int __init rv3029_register_driver(void)
0838 {
0839     return 0;
0840 }
0841 
0842 static void rv3029_unregister_driver(void)
0843 {
0844 }
0845 
0846 #endif
0847 
0848 #if IS_ENABLED(CONFIG_SPI_MASTER)
0849 
0850 static int rv3049_probe(struct spi_device *spi)
0851 {
0852     struct regmap *regmap;
0853 
0854     regmap = devm_regmap_init_spi(spi, &config);
0855     if (IS_ERR(regmap))
0856         return PTR_ERR(regmap);
0857 
0858     return rv3029_probe(&spi->dev, regmap, spi->irq, "rv3049");
0859 }
0860 
0861 static struct spi_driver rv3049_driver = {
0862     .driver = {
0863         .name    = "rv3049",
0864     },
0865     .probe   = rv3049_probe,
0866 };
0867 
0868 static int __init rv3049_register_driver(void)
0869 {
0870     return spi_register_driver(&rv3049_driver);
0871 }
0872 
0873 static void __exit rv3049_unregister_driver(void)
0874 {
0875     spi_unregister_driver(&rv3049_driver);
0876 }
0877 
0878 #else
0879 
0880 static int __init rv3049_register_driver(void)
0881 {
0882     return 0;
0883 }
0884 
0885 static void __exit rv3049_unregister_driver(void)
0886 {
0887 }
0888 
0889 #endif
0890 
0891 static int __init rv30x9_init(void)
0892 {
0893     int ret;
0894 
0895     ret = rv3029_register_driver();
0896     if (ret)
0897         return ret;
0898 
0899     ret = rv3049_register_driver();
0900     if (ret)
0901         rv3029_unregister_driver();
0902 
0903     return ret;
0904 }
0905 module_init(rv30x9_init)
0906 
0907 static void __exit rv30x9_exit(void)
0908 {
0909     rv3049_unregister_driver();
0910     rv3029_unregister_driver();
0911 }
0912 module_exit(rv30x9_exit)
0913 
0914 MODULE_AUTHOR("Gregory Hermant <gregory.hermant@calao-systems.com>");
0915 MODULE_AUTHOR("Michael Buesch <m@bues.ch>");
0916 MODULE_DESCRIPTION("Micro Crystal RV3029/RV3049 RTC driver");
0917 MODULE_LICENSE("GPL");
0918 MODULE_ALIAS("spi:rv3049");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!