Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * RTC driver for the Micro Crystal RV8803
0004  *
0005  * Copyright (C) 2015 Micro Crystal SA
0006  * Alexandre Belloni <alexandre.belloni@bootlin.com>
0007  *
0008  */
0009 
0010 #include <linux/bcd.h>
0011 #include <linux/bitops.h>
0012 #include <linux/bitfield.h>
0013 #include <linux/log2.h>
0014 #include <linux/i2c.h>
0015 #include <linux/interrupt.h>
0016 #include <linux/kernel.h>
0017 #include <linux/module.h>
0018 #include <linux/of_device.h>
0019 #include <linux/rtc.h>
0020 
0021 #define RV8803_I2C_TRY_COUNT        4
0022 
0023 #define RV8803_SEC          0x00
0024 #define RV8803_MIN          0x01
0025 #define RV8803_HOUR         0x02
0026 #define RV8803_WEEK         0x03
0027 #define RV8803_DAY          0x04
0028 #define RV8803_MONTH            0x05
0029 #define RV8803_YEAR         0x06
0030 #define RV8803_RAM          0x07
0031 #define RV8803_ALARM_MIN        0x08
0032 #define RV8803_ALARM_HOUR       0x09
0033 #define RV8803_ALARM_WEEK_OR_DAY    0x0A
0034 #define RV8803_EXT          0x0D
0035 #define RV8803_FLAG         0x0E
0036 #define RV8803_CTRL         0x0F
0037 #define RV8803_OSC_OFFSET       0x2C
0038 
0039 #define RV8803_EXT_WADA         BIT(6)
0040 
0041 #define RV8803_FLAG_V1F         BIT(0)
0042 #define RV8803_FLAG_V2F         BIT(1)
0043 #define RV8803_FLAG_AF          BIT(3)
0044 #define RV8803_FLAG_TF          BIT(4)
0045 #define RV8803_FLAG_UF          BIT(5)
0046 
0047 #define RV8803_CTRL_RESET       BIT(0)
0048 
0049 #define RV8803_CTRL_EIE         BIT(2)
0050 #define RV8803_CTRL_AIE         BIT(3)
0051 #define RV8803_CTRL_TIE         BIT(4)
0052 #define RV8803_CTRL_UIE         BIT(5)
0053 
0054 #define RX8803_CTRL_CSEL        GENMASK(7, 6)
0055 
0056 #define RX8900_BACKUP_CTRL      0x18
0057 #define RX8900_FLAG_SWOFF       BIT(2)
0058 #define RX8900_FLAG_VDETOFF     BIT(3)
0059 
0060 enum rv8803_type {
0061     rv_8803,
0062     rx_8803,
0063     rx_8804,
0064     rx_8900
0065 };
0066 
0067 struct rv8803_data {
0068     struct i2c_client *client;
0069     struct rtc_device *rtc;
0070     struct mutex flags_lock;
0071     u8 ctrl;
0072     u8 backup;
0073     enum rv8803_type type;
0074 };
0075 
0076 static int rv8803_read_reg(const struct i2c_client *client, u8 reg)
0077 {
0078     int try = RV8803_I2C_TRY_COUNT;
0079     s32 ret;
0080 
0081     /*
0082      * There is a 61µs window during which the RTC does not acknowledge I2C
0083      * transfers. In that case, ensure that there are multiple attempts.
0084      */
0085     do
0086         ret = i2c_smbus_read_byte_data(client, reg);
0087     while ((ret == -ENXIO || ret == -EIO) && --try);
0088     if (ret < 0)
0089         dev_err(&client->dev, "Unable to read register 0x%02x\n", reg);
0090 
0091     return ret;
0092 }
0093 
0094 static int rv8803_read_regs(const struct i2c_client *client,
0095                 u8 reg, u8 count, u8 *values)
0096 {
0097     int try = RV8803_I2C_TRY_COUNT;
0098     s32 ret;
0099 
0100     do
0101         ret = i2c_smbus_read_i2c_block_data(client, reg, count, values);
0102     while ((ret == -ENXIO || ret == -EIO) && --try);
0103     if (ret != count) {
0104         dev_err(&client->dev,
0105             "Unable to read registers 0x%02x..0x%02x\n",
0106             reg, reg + count - 1);
0107         return ret < 0 ? ret : -EIO;
0108     }
0109 
0110     return 0;
0111 }
0112 
0113 static int rv8803_write_reg(const struct i2c_client *client, u8 reg, u8 value)
0114 {
0115     int try = RV8803_I2C_TRY_COUNT;
0116     s32 ret;
0117 
0118     do
0119         ret = i2c_smbus_write_byte_data(client, reg, value);
0120     while ((ret == -ENXIO || ret == -EIO) && --try);
0121     if (ret)
0122         dev_err(&client->dev, "Unable to write register 0x%02x\n", reg);
0123 
0124     return ret;
0125 }
0126 
0127 static int rv8803_write_regs(const struct i2c_client *client,
0128                  u8 reg, u8 count, const u8 *values)
0129 {
0130     int try = RV8803_I2C_TRY_COUNT;
0131     s32 ret;
0132 
0133     do
0134         ret = i2c_smbus_write_i2c_block_data(client, reg, count,
0135                              values);
0136     while ((ret == -ENXIO || ret == -EIO) && --try);
0137     if (ret)
0138         dev_err(&client->dev,
0139             "Unable to write registers 0x%02x..0x%02x\n",
0140             reg, reg + count - 1);
0141 
0142     return ret;
0143 }
0144 
0145 static int rv8803_regs_init(struct rv8803_data *rv8803)
0146 {
0147     int ret;
0148 
0149     ret = rv8803_write_reg(rv8803->client, RV8803_OSC_OFFSET, 0x00);
0150     if (ret)
0151         return ret;
0152 
0153     ret = rv8803_write_reg(rv8803->client, RV8803_CTRL,
0154                    FIELD_PREP(RX8803_CTRL_CSEL, 1)); /* 2s */
0155     if (ret)
0156         return ret;
0157 
0158     ret = rv8803_write_regs(rv8803->client, RV8803_ALARM_MIN, 3,
0159                 (u8[]){ 0, 0, 0 });
0160     if (ret)
0161         return ret;
0162 
0163     return rv8803_write_reg(rv8803->client, RV8803_RAM, 0x00);
0164 }
0165 
0166 static int rv8803_regs_configure(struct rv8803_data *rv8803);
0167 
0168 static int rv8803_regs_reset(struct rv8803_data *rv8803)
0169 {
0170     /*
0171      * The RV-8803 resets all registers to POR defaults after voltage-loss,
0172      * the Epson RTCs don't, so we manually reset the remainder here.
0173      */
0174     if (rv8803->type == rx_8803 || rv8803->type == rx_8900) {
0175         int ret = rv8803_regs_init(rv8803);
0176         if (ret)
0177             return ret;
0178     }
0179 
0180     return rv8803_regs_configure(rv8803);
0181 }
0182 
0183 static irqreturn_t rv8803_handle_irq(int irq, void *dev_id)
0184 {
0185     struct i2c_client *client = dev_id;
0186     struct rv8803_data *rv8803 = i2c_get_clientdata(client);
0187     unsigned long events = 0;
0188     int flags;
0189 
0190     mutex_lock(&rv8803->flags_lock);
0191 
0192     flags = rv8803_read_reg(client, RV8803_FLAG);
0193     if (flags <= 0) {
0194         mutex_unlock(&rv8803->flags_lock);
0195         return IRQ_NONE;
0196     }
0197 
0198     if (flags & RV8803_FLAG_V1F)
0199         dev_warn(&client->dev, "Voltage low, temperature compensation stopped.\n");
0200 
0201     if (flags & RV8803_FLAG_V2F)
0202         dev_warn(&client->dev, "Voltage low, data loss detected.\n");
0203 
0204     if (flags & RV8803_FLAG_TF) {
0205         flags &= ~RV8803_FLAG_TF;
0206         rv8803->ctrl &= ~RV8803_CTRL_TIE;
0207         events |= RTC_PF;
0208     }
0209 
0210     if (flags & RV8803_FLAG_AF) {
0211         flags &= ~RV8803_FLAG_AF;
0212         rv8803->ctrl &= ~RV8803_CTRL_AIE;
0213         events |= RTC_AF;
0214     }
0215 
0216     if (flags & RV8803_FLAG_UF) {
0217         flags &= ~RV8803_FLAG_UF;
0218         rv8803->ctrl &= ~RV8803_CTRL_UIE;
0219         events |= RTC_UF;
0220     }
0221 
0222     if (events) {
0223         rtc_update_irq(rv8803->rtc, 1, events);
0224         rv8803_write_reg(client, RV8803_FLAG, flags);
0225         rv8803_write_reg(rv8803->client, RV8803_CTRL, rv8803->ctrl);
0226     }
0227 
0228     mutex_unlock(&rv8803->flags_lock);
0229 
0230     return IRQ_HANDLED;
0231 }
0232 
0233 static int rv8803_get_time(struct device *dev, struct rtc_time *tm)
0234 {
0235     struct rv8803_data *rv8803 = dev_get_drvdata(dev);
0236     u8 date1[7];
0237     u8 date2[7];
0238     u8 *date = date1;
0239     int ret, flags;
0240 
0241     flags = rv8803_read_reg(rv8803->client, RV8803_FLAG);
0242     if (flags < 0)
0243         return flags;
0244 
0245     if (flags & RV8803_FLAG_V2F) {
0246         dev_warn(dev, "Voltage low, data is invalid.\n");
0247         return -EINVAL;
0248     }
0249 
0250     ret = rv8803_read_regs(rv8803->client, RV8803_SEC, 7, date);
0251     if (ret)
0252         return ret;
0253 
0254     if ((date1[RV8803_SEC] & 0x7f) == bin2bcd(59)) {
0255         ret = rv8803_read_regs(rv8803->client, RV8803_SEC, 7, date2);
0256         if (ret)
0257             return ret;
0258 
0259         if ((date2[RV8803_SEC] & 0x7f) != bin2bcd(59))
0260             date = date2;
0261     }
0262 
0263     tm->tm_sec  = bcd2bin(date[RV8803_SEC] & 0x7f);
0264     tm->tm_min  = bcd2bin(date[RV8803_MIN] & 0x7f);
0265     tm->tm_hour = bcd2bin(date[RV8803_HOUR] & 0x3f);
0266     tm->tm_wday = ilog2(date[RV8803_WEEK] & 0x7f);
0267     tm->tm_mday = bcd2bin(date[RV8803_DAY] & 0x3f);
0268     tm->tm_mon  = bcd2bin(date[RV8803_MONTH] & 0x1f) - 1;
0269     tm->tm_year = bcd2bin(date[RV8803_YEAR]) + 100;
0270 
0271     return 0;
0272 }
0273 
0274 static int rv8803_set_time(struct device *dev, struct rtc_time *tm)
0275 {
0276     struct rv8803_data *rv8803 = dev_get_drvdata(dev);
0277     u8 date[7];
0278     int ctrl, flags, ret;
0279 
0280     ctrl = rv8803_read_reg(rv8803->client, RV8803_CTRL);
0281     if (ctrl < 0)
0282         return ctrl;
0283 
0284     /* Stop the clock */
0285     ret = rv8803_write_reg(rv8803->client, RV8803_CTRL,
0286                    ctrl | RV8803_CTRL_RESET);
0287     if (ret)
0288         return ret;
0289 
0290     date[RV8803_SEC]   = bin2bcd(tm->tm_sec);
0291     date[RV8803_MIN]   = bin2bcd(tm->tm_min);
0292     date[RV8803_HOUR]  = bin2bcd(tm->tm_hour);
0293     date[RV8803_WEEK]  = 1 << (tm->tm_wday);
0294     date[RV8803_DAY]   = bin2bcd(tm->tm_mday);
0295     date[RV8803_MONTH] = bin2bcd(tm->tm_mon + 1);
0296     date[RV8803_YEAR]  = bin2bcd(tm->tm_year - 100);
0297 
0298     ret = rv8803_write_regs(rv8803->client, RV8803_SEC, 7, date);
0299     if (ret)
0300         return ret;
0301 
0302     /* Restart the clock */
0303     ret = rv8803_write_reg(rv8803->client, RV8803_CTRL,
0304                    ctrl & ~RV8803_CTRL_RESET);
0305     if (ret)
0306         return ret;
0307 
0308     mutex_lock(&rv8803->flags_lock);
0309 
0310     flags = rv8803_read_reg(rv8803->client, RV8803_FLAG);
0311     if (flags < 0) {
0312         mutex_unlock(&rv8803->flags_lock);
0313         return flags;
0314     }
0315 
0316     if (flags & RV8803_FLAG_V2F) {
0317         ret = rv8803_regs_reset(rv8803);
0318         if (ret) {
0319             mutex_unlock(&rv8803->flags_lock);
0320             return ret;
0321         }
0322     }
0323 
0324     ret = rv8803_write_reg(rv8803->client, RV8803_FLAG,
0325                    flags & ~(RV8803_FLAG_V1F | RV8803_FLAG_V2F));
0326 
0327     mutex_unlock(&rv8803->flags_lock);
0328 
0329     return ret;
0330 }
0331 
0332 static int rv8803_get_alarm(struct device *dev, struct rtc_wkalrm *alrm)
0333 {
0334     struct rv8803_data *rv8803 = dev_get_drvdata(dev);
0335     struct i2c_client *client = rv8803->client;
0336     u8 alarmvals[3];
0337     int flags, ret;
0338 
0339     ret = rv8803_read_regs(client, RV8803_ALARM_MIN, 3, alarmvals);
0340     if (ret)
0341         return ret;
0342 
0343     flags = rv8803_read_reg(client, RV8803_FLAG);
0344     if (flags < 0)
0345         return flags;
0346 
0347     alrm->time.tm_sec  = 0;
0348     alrm->time.tm_min  = bcd2bin(alarmvals[0] & 0x7f);
0349     alrm->time.tm_hour = bcd2bin(alarmvals[1] & 0x3f);
0350     alrm->time.tm_mday = bcd2bin(alarmvals[2] & 0x3f);
0351 
0352     alrm->enabled = !!(rv8803->ctrl & RV8803_CTRL_AIE);
0353     alrm->pending = (flags & RV8803_FLAG_AF) && alrm->enabled;
0354 
0355     return 0;
0356 }
0357 
0358 static int rv8803_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
0359 {
0360     struct i2c_client *client = to_i2c_client(dev);
0361     struct rv8803_data *rv8803 = dev_get_drvdata(dev);
0362     u8 alarmvals[3];
0363     u8 ctrl[2];
0364     int ret, err;
0365 
0366     /* The alarm has no seconds, round up to nearest minute */
0367     if (alrm->time.tm_sec) {
0368         time64_t alarm_time = rtc_tm_to_time64(&alrm->time);
0369 
0370         alarm_time += 60 - alrm->time.tm_sec;
0371         rtc_time64_to_tm(alarm_time, &alrm->time);
0372     }
0373 
0374     mutex_lock(&rv8803->flags_lock);
0375 
0376     ret = rv8803_read_regs(client, RV8803_FLAG, 2, ctrl);
0377     if (ret) {
0378         mutex_unlock(&rv8803->flags_lock);
0379         return ret;
0380     }
0381 
0382     alarmvals[0] = bin2bcd(alrm->time.tm_min);
0383     alarmvals[1] = bin2bcd(alrm->time.tm_hour);
0384     alarmvals[2] = bin2bcd(alrm->time.tm_mday);
0385 
0386     if (rv8803->ctrl & (RV8803_CTRL_AIE | RV8803_CTRL_UIE)) {
0387         rv8803->ctrl &= ~(RV8803_CTRL_AIE | RV8803_CTRL_UIE);
0388         err = rv8803_write_reg(rv8803->client, RV8803_CTRL,
0389                        rv8803->ctrl);
0390         if (err) {
0391             mutex_unlock(&rv8803->flags_lock);
0392             return err;
0393         }
0394     }
0395 
0396     ctrl[0] &= ~RV8803_FLAG_AF;
0397     err = rv8803_write_reg(rv8803->client, RV8803_FLAG, ctrl[0]);
0398     mutex_unlock(&rv8803->flags_lock);
0399     if (err)
0400         return err;
0401 
0402     err = rv8803_write_regs(rv8803->client, RV8803_ALARM_MIN, 3, alarmvals);
0403     if (err)
0404         return err;
0405 
0406     if (alrm->enabled) {
0407         if (rv8803->rtc->uie_rtctimer.enabled)
0408             rv8803->ctrl |= RV8803_CTRL_UIE;
0409         if (rv8803->rtc->aie_timer.enabled)
0410             rv8803->ctrl |= RV8803_CTRL_AIE;
0411 
0412         err = rv8803_write_reg(rv8803->client, RV8803_CTRL,
0413                        rv8803->ctrl);
0414         if (err)
0415             return err;
0416     }
0417 
0418     return 0;
0419 }
0420 
0421 static int rv8803_alarm_irq_enable(struct device *dev, unsigned int enabled)
0422 {
0423     struct i2c_client *client = to_i2c_client(dev);
0424     struct rv8803_data *rv8803 = dev_get_drvdata(dev);
0425     int ctrl, flags, err;
0426 
0427     ctrl = rv8803->ctrl;
0428 
0429     if (enabled) {
0430         if (rv8803->rtc->uie_rtctimer.enabled)
0431             ctrl |= RV8803_CTRL_UIE;
0432         if (rv8803->rtc->aie_timer.enabled)
0433             ctrl |= RV8803_CTRL_AIE;
0434     } else {
0435         if (!rv8803->rtc->uie_rtctimer.enabled)
0436             ctrl &= ~RV8803_CTRL_UIE;
0437         if (!rv8803->rtc->aie_timer.enabled)
0438             ctrl &= ~RV8803_CTRL_AIE;
0439     }
0440 
0441     mutex_lock(&rv8803->flags_lock);
0442     flags = rv8803_read_reg(client, RV8803_FLAG);
0443     if (flags < 0) {
0444         mutex_unlock(&rv8803->flags_lock);
0445         return flags;
0446     }
0447     flags &= ~(RV8803_FLAG_AF | RV8803_FLAG_UF);
0448     err = rv8803_write_reg(client, RV8803_FLAG, flags);
0449     mutex_unlock(&rv8803->flags_lock);
0450     if (err)
0451         return err;
0452 
0453     if (ctrl != rv8803->ctrl) {
0454         rv8803->ctrl = ctrl;
0455         err = rv8803_write_reg(client, RV8803_CTRL, rv8803->ctrl);
0456         if (err)
0457             return err;
0458     }
0459 
0460     return 0;
0461 }
0462 
0463 static int rv8803_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
0464 {
0465     struct i2c_client *client = to_i2c_client(dev);
0466     struct rv8803_data *rv8803 = dev_get_drvdata(dev);
0467     unsigned int vl = 0;
0468     int flags, ret = 0;
0469 
0470     switch (cmd) {
0471     case RTC_VL_READ:
0472         flags = rv8803_read_reg(client, RV8803_FLAG);
0473         if (flags < 0)
0474             return flags;
0475 
0476         if (flags & RV8803_FLAG_V1F) {
0477             dev_warn(&client->dev, "Voltage low, temperature compensation stopped.\n");
0478             vl = RTC_VL_ACCURACY_LOW;
0479         }
0480 
0481         if (flags & RV8803_FLAG_V2F)
0482             vl |= RTC_VL_DATA_INVALID;
0483 
0484         return put_user(vl, (unsigned int __user *)arg);
0485 
0486     case RTC_VL_CLR:
0487         mutex_lock(&rv8803->flags_lock);
0488         flags = rv8803_read_reg(client, RV8803_FLAG);
0489         if (flags < 0) {
0490             mutex_unlock(&rv8803->flags_lock);
0491             return flags;
0492         }
0493 
0494         flags &= ~RV8803_FLAG_V1F;
0495         ret = rv8803_write_reg(client, RV8803_FLAG, flags);
0496         mutex_unlock(&rv8803->flags_lock);
0497         if (ret)
0498             return ret;
0499 
0500         return 0;
0501 
0502     default:
0503         return -ENOIOCTLCMD;
0504     }
0505 }
0506 
0507 static int rv8803_nvram_write(void *priv, unsigned int offset, void *val,
0508                   size_t bytes)
0509 {
0510     return rv8803_write_reg(priv, RV8803_RAM, *(u8 *)val);
0511 }
0512 
0513 static int rv8803_nvram_read(void *priv, unsigned int offset,
0514                  void *val, size_t bytes)
0515 {
0516     int ret;
0517 
0518     ret = rv8803_read_reg(priv, RV8803_RAM);
0519     if (ret < 0)
0520         return ret;
0521 
0522     *(u8 *)val = ret;
0523 
0524     return 0;
0525 }
0526 
0527 static const struct rtc_class_ops rv8803_rtc_ops = {
0528     .read_time = rv8803_get_time,
0529     .set_time = rv8803_set_time,
0530     .ioctl = rv8803_ioctl,
0531     .read_alarm = rv8803_get_alarm,
0532     .set_alarm = rv8803_set_alarm,
0533     .alarm_irq_enable = rv8803_alarm_irq_enable,
0534 };
0535 
0536 static int rx8900_trickle_charger_init(struct rv8803_data *rv8803)
0537 {
0538     struct i2c_client *client = rv8803->client;
0539     struct device_node *node = client->dev.of_node;
0540     int err;
0541     u8 flags;
0542 
0543     if (!node)
0544         return 0;
0545 
0546     if (rv8803->type != rx_8900)
0547         return 0;
0548 
0549     err = i2c_smbus_read_byte_data(rv8803->client, RX8900_BACKUP_CTRL);
0550     if (err < 0)
0551         return err;
0552 
0553     flags = (u8)err;
0554     flags &= ~(RX8900_FLAG_VDETOFF | RX8900_FLAG_SWOFF);
0555     flags |= rv8803->backup;
0556 
0557     return i2c_smbus_write_byte_data(rv8803->client, RX8900_BACKUP_CTRL,
0558                      flags);
0559 }
0560 
0561 /* configure registers with values different than the Power-On reset defaults */
0562 static int rv8803_regs_configure(struct rv8803_data *rv8803)
0563 {
0564     int err;
0565 
0566     err = rv8803_write_reg(rv8803->client, RV8803_EXT, RV8803_EXT_WADA);
0567     if (err)
0568         return err;
0569 
0570     err = rx8900_trickle_charger_init(rv8803);
0571     if (err) {
0572         dev_err(&rv8803->client->dev, "failed to init charger\n");
0573         return err;
0574     }
0575 
0576     return 0;
0577 }
0578 
0579 static int rv8803_probe(struct i2c_client *client,
0580             const struct i2c_device_id *id)
0581 {
0582     struct i2c_adapter *adapter = client->adapter;
0583     struct rv8803_data *rv8803;
0584     int err, flags;
0585     struct nvmem_config nvmem_cfg = {
0586         .name = "rv8803_nvram",
0587         .word_size = 1,
0588         .stride = 1,
0589         .size = 1,
0590         .reg_read = rv8803_nvram_read,
0591         .reg_write = rv8803_nvram_write,
0592         .priv = client,
0593     };
0594 
0595     if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA |
0596                      I2C_FUNC_SMBUS_I2C_BLOCK)) {
0597         dev_err(&adapter->dev, "doesn't support I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_I2C_BLOCK\n");
0598         return -EIO;
0599     }
0600 
0601     rv8803 = devm_kzalloc(&client->dev, sizeof(struct rv8803_data),
0602                   GFP_KERNEL);
0603     if (!rv8803)
0604         return -ENOMEM;
0605 
0606     mutex_init(&rv8803->flags_lock);
0607     rv8803->client = client;
0608     if (client->dev.of_node)
0609         rv8803->type = (enum rv8803_type)
0610             of_device_get_match_data(&client->dev);
0611     else
0612         rv8803->type = id->driver_data;
0613     i2c_set_clientdata(client, rv8803);
0614 
0615     flags = rv8803_read_reg(client, RV8803_FLAG);
0616     if (flags < 0)
0617         return flags;
0618 
0619     if (flags & RV8803_FLAG_V1F)
0620         dev_warn(&client->dev, "Voltage low, temperature compensation stopped.\n");
0621 
0622     if (flags & RV8803_FLAG_V2F)
0623         dev_warn(&client->dev, "Voltage low, data loss detected.\n");
0624 
0625     if (flags & RV8803_FLAG_AF)
0626         dev_warn(&client->dev, "An alarm maybe have been missed.\n");
0627 
0628     rv8803->rtc = devm_rtc_allocate_device(&client->dev);
0629     if (IS_ERR(rv8803->rtc))
0630         return PTR_ERR(rv8803->rtc);
0631 
0632     if (client->irq > 0) {
0633         err = devm_request_threaded_irq(&client->dev, client->irq,
0634                         NULL, rv8803_handle_irq,
0635                         IRQF_TRIGGER_LOW | IRQF_ONESHOT,
0636                         "rv8803", client);
0637         if (err) {
0638             dev_warn(&client->dev, "unable to request IRQ, alarms disabled\n");
0639             client->irq = 0;
0640         }
0641     }
0642     if (!client->irq)
0643         clear_bit(RTC_FEATURE_ALARM, rv8803->rtc->features);
0644 
0645     if (of_property_read_bool(client->dev.of_node, "epson,vdet-disable"))
0646         rv8803->backup |= RX8900_FLAG_VDETOFF;
0647 
0648     if (of_property_read_bool(client->dev.of_node, "trickle-diode-disable"))
0649         rv8803->backup |= RX8900_FLAG_SWOFF;
0650 
0651     err = rv8803_regs_configure(rv8803);
0652     if (err)
0653         return err;
0654 
0655     rv8803->rtc->ops = &rv8803_rtc_ops;
0656     rv8803->rtc->range_min = RTC_TIMESTAMP_BEGIN_2000;
0657     rv8803->rtc->range_max = RTC_TIMESTAMP_END_2099;
0658     err = devm_rtc_register_device(rv8803->rtc);
0659     if (err)
0660         return err;
0661 
0662     devm_rtc_nvmem_register(rv8803->rtc, &nvmem_cfg);
0663 
0664     rv8803->rtc->max_user_freq = 1;
0665 
0666     return 0;
0667 }
0668 
0669 static const struct i2c_device_id rv8803_id[] = {
0670     { "rv8803", rv_8803 },
0671     { "rv8804", rx_8804 },
0672     { "rx8803", rx_8803 },
0673     { "rx8900", rx_8900 },
0674     { }
0675 };
0676 MODULE_DEVICE_TABLE(i2c, rv8803_id);
0677 
0678 static const __maybe_unused struct of_device_id rv8803_of_match[] = {
0679     {
0680         .compatible = "microcrystal,rv8803",
0681         .data = (void *)rv_8803
0682     },
0683     {
0684         .compatible = "epson,rx8803",
0685         .data = (void *)rx_8803
0686     },
0687     {
0688         .compatible = "epson,rx8804",
0689         .data = (void *)rx_8804
0690     },
0691     {
0692         .compatible = "epson,rx8900",
0693         .data = (void *)rx_8900
0694     },
0695     { }
0696 };
0697 MODULE_DEVICE_TABLE(of, rv8803_of_match);
0698 
0699 static struct i2c_driver rv8803_driver = {
0700     .driver = {
0701         .name = "rtc-rv8803",
0702         .of_match_table = of_match_ptr(rv8803_of_match),
0703     },
0704     .probe      = rv8803_probe,
0705     .id_table   = rv8803_id,
0706 };
0707 module_i2c_driver(rv8803_driver);
0708 
0709 MODULE_AUTHOR("Alexandre Belloni <alexandre.belloni@bootlin.com>");
0710 MODULE_DESCRIPTION("Micro Crystal RV8803 RTC driver");
0711 MODULE_LICENSE("GPL v2");
[ 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!