drivers/rtc/rtc-rx8581.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * An I2C driver for the Epson RX8581 RTC
0004  *
0005  * Author: Martyn Welch <martyn.welch@ge.com>
0006  * Copyright 2008 GE Intelligent Platforms Embedded Systems, Inc.
0007  *
0008  * Based on: rtc-pcf8563.c (An I2C driver for the Philips PCF8563 RTC)
0009  * Copyright 2005-06 Tower Technologies
0010  */
0011
0012 #include <linux/module.h>
0013 #include <linux/i2c.h>
0014 #include <linux/bcd.h>
0015 #include <linux/of.h>
0016 #include <linux/of_device.h>
0017 #include <linux/regmap.h>
0018 #include <linux/rtc.h>
0019 #include <linux/log2.h>
0020
0021 #define RX8581_REG_SC       0x00 /* Second in BCD */
0022 #define RX8581_REG_MN       0x01 /* Minute in BCD */
0023 #define RX8581_REG_HR       0x02 /* Hour in BCD */
0024 #define RX8581_REG_DW       0x03 /* Day of Week */
0025 #define RX8581_REG_DM       0x04 /* Day of Month in BCD */
0026 #define RX8581_REG_MO       0x05 /* Month in BCD */
0027 #define RX8581_REG_YR       0x06 /* Year in BCD */
0028 #define RX8581_REG_RAM      0x07 /* RAM */
0029 #define RX8581_REG_AMN      0x08 /* Alarm Min in BCD*/
0030 #define RX8581_REG_AHR      0x09 /* Alarm Hour in BCD */
0031 #define RX8581_REG_ADM      0x0A
0032 #define RX8581_REG_ADW      0x0A
0033 #define RX8581_REG_TMR0     0x0B
0034 #define RX8581_REG_TMR1     0x0C
0035 #define RX8581_REG_EXT      0x0D /* Extension Register */
0036 #define RX8581_REG_FLAG     0x0E /* Flag Register */
0037 #define RX8581_REG_CTRL     0x0F /* Control Register */
0038
0039
0040 /* Flag Register bit definitions */
0041 #define RX8581_FLAG_UF      0x20 /* Update */
0042 #define RX8581_FLAG_TF      0x10 /* Timer */
0043 #define RX8581_FLAG_AF      0x08 /* Alarm */
0044 #define RX8581_FLAG_VLF     0x02 /* Voltage Low */
0045
0046 /* Control Register bit definitions */
0047 #define RX8581_CTRL_UIE     0x20 /* Update Interrupt Enable */
0048 #define RX8581_CTRL_TIE     0x10 /* Timer Interrupt Enable */
0049 #define RX8581_CTRL_AIE     0x08 /* Alarm Interrupt Enable */
0050 #define RX8581_CTRL_STOP    0x02 /* STOP bit */
0051 #define RX8581_CTRL_RESET   0x01 /* RESET bit */
0052
0053 #define RX8571_USER_RAM     0x10
0054 #define RX8571_NVRAM_SIZE   0x10
0055
0056 struct rx8581 {
0057     struct regmap       *regmap;
0058     struct rtc_device   *rtc;
0059 };
0060
0061 struct rx85x1_config {
0062     struct regmap_config regmap;
0063     unsigned int num_nvram;
0064 };
0065
0066 /*
0067  * In the routines that deal directly with the rx8581 hardware, we use
0068  * rtc_time -- month 0-11, hour 0-23, yr = calendar year-epoch.
0069  */
0070 static int rx8581_rtc_read_time(struct device *dev, struct rtc_time *tm)
0071 {
0072     struct i2c_client *client = to_i2c_client(dev);
0073     unsigned char date[7];
0074     unsigned int data;
0075     int err;
0076     struct rx8581 *rx8581 = i2c_get_clientdata(client);
0077
0078     /* First we ensure that the "update flag" is not set, we read the
0079      * time and date then re-read the "update flag". If the update flag
0080      * has been set, we know that the time has changed during the read so
0081      * we repeat the whole process again.
0082      */
0083     err = regmap_read(rx8581->regmap, RX8581_REG_FLAG, &data);
0084     if (err < 0)
0085         return err;
0086
0087     if (data & RX8581_FLAG_VLF) {
0088         dev_warn(dev,
0089              "low voltage detected, date/time is not reliable.\n");
0090         return -EINVAL;
0091     }
0092
0093     do {
0094         /* If update flag set, clear it */
0095         if (data & RX8581_FLAG_UF) {
0096             err = regmap_write(rx8581->regmap, RX8581_REG_FLAG,
0097                       data & ~RX8581_FLAG_UF);
0098             if (err < 0)
0099                 return err;
0100         }
0101
0102         /* Now read time and date */
0103         err = regmap_bulk_read(rx8581->regmap, RX8581_REG_SC, date,
0104                        sizeof(date));
0105         if (err < 0)
0106             return err;
0107
0108         /* Check flag register */
0109         err = regmap_read(rx8581->regmap, RX8581_REG_FLAG, &data);
0110         if (err < 0)
0111             return err;
0112     } while (data & RX8581_FLAG_UF);
0113
0114     dev_dbg(dev, "%s: raw data is sec=%02x, min=%02x, hr=%02x, "
0115         "wday=%02x, mday=%02x, mon=%02x, year=%02x\n",
0116         __func__,
0117         date[0], date[1], date[2], date[3], date[4], date[5], date[6]);
0118
0119     tm->tm_sec = bcd2bin(date[RX8581_REG_SC] & 0x7F);
0120     tm->tm_min = bcd2bin(date[RX8581_REG_MN] & 0x7F);
0121     tm->tm_hour = bcd2bin(date[RX8581_REG_HR] & 0x3F); /* rtc hr 0-23 */
0122     tm->tm_wday = ilog2(date[RX8581_REG_DW] & 0x7F);
0123     tm->tm_mday = bcd2bin(date[RX8581_REG_DM] & 0x3F);
0124     tm->tm_mon = bcd2bin(date[RX8581_REG_MO] & 0x1F) - 1; /* rtc mn 1-12 */
0125     tm->tm_year = bcd2bin(date[RX8581_REG_YR]) + 100;
0126
0127     dev_dbg(dev, "%s: tm is secs=%d, mins=%d, hours=%d, "
0128         "mday=%d, mon=%d, year=%d, wday=%d\n",
0129         __func__,
0130         tm->tm_sec, tm->tm_min, tm->tm_hour,
0131         tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
0132
0133     return 0;
0134 }
0135
0136 static int rx8581_rtc_set_time(struct device *dev, struct rtc_time *tm)
0137 {
0138     struct i2c_client *client = to_i2c_client(dev);
0139     int err;
0140     unsigned char buf[7];
0141     struct rx8581 *rx8581 = i2c_get_clientdata(client);
0142
0143     dev_dbg(dev, "%s: secs=%d, mins=%d, hours=%d, "
0144         "mday=%d, mon=%d, year=%d, wday=%d\n",
0145         __func__,
0146         tm->tm_sec, tm->tm_min, tm->tm_hour,
0147         tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
0148
0149     /* hours, minutes and seconds */
0150     buf[RX8581_REG_SC] = bin2bcd(tm->tm_sec);
0151     buf[RX8581_REG_MN] = bin2bcd(tm->tm_min);
0152     buf[RX8581_REG_HR] = bin2bcd(tm->tm_hour);
0153
0154     buf[RX8581_REG_DM] = bin2bcd(tm->tm_mday);
0155
0156     /* month, 1 - 12 */
0157     buf[RX8581_REG_MO] = bin2bcd(tm->tm_mon + 1);
0158
0159     /* year and century */
0160     buf[RX8581_REG_YR] = bin2bcd(tm->tm_year - 100);
0161     buf[RX8581_REG_DW] = (0x1 << tm->tm_wday);
0162
0163     /* Stop the clock */
0164     err = regmap_update_bits(rx8581->regmap, RX8581_REG_CTRL,
0165                  RX8581_CTRL_STOP, RX8581_CTRL_STOP);
0166     if (err < 0)
0167         return err;
0168
0169     /* write register's data */
0170     err = regmap_bulk_write(rx8581->regmap, RX8581_REG_SC,
0171                 buf, sizeof(buf));
0172     if (err < 0)
0173         return err;
0174
0175     /* get VLF and clear it */
0176     err = regmap_update_bits(rx8581->regmap, RX8581_REG_FLAG,
0177                  RX8581_FLAG_VLF, 0);
0178     if (err < 0)
0179         return err;
0180
0181     /* Restart the clock */
0182     return regmap_update_bits(rx8581->regmap, RX8581_REG_CTRL,
0183                  RX8581_CTRL_STOP, 0);
0184 }
0185
0186 static const struct rtc_class_ops rx8581_rtc_ops = {
0187     .read_time  = rx8581_rtc_read_time,
0188     .set_time   = rx8581_rtc_set_time,
0189 };
0190
0191 static int rx8571_nvram_read(void *priv, unsigned int offset, void *val,
0192                  size_t bytes)
0193 {
0194     struct rx8581 *rx8581 = priv;
0195
0196     return regmap_bulk_read(rx8581->regmap, RX8571_USER_RAM + offset,
0197                 val, bytes);
0198 }
0199
0200 static int rx8571_nvram_write(void *priv, unsigned int offset, void *val,
0201                   size_t bytes)
0202 {
0203     struct rx8581 *rx8581 = priv;
0204
0205     return regmap_bulk_write(rx8581->regmap, RX8571_USER_RAM + offset,
0206                  val, bytes);
0207 }
0208
0209 static int rx85x1_nvram_read(void *priv, unsigned int offset, void *val,
0210                  size_t bytes)
0211 {
0212     struct rx8581 *rx8581 = priv;
0213     unsigned int tmp_val;
0214     int ret;
0215
0216     ret = regmap_read(rx8581->regmap, RX8581_REG_RAM, &tmp_val);
0217     (*(unsigned char *)val) = (unsigned char) tmp_val;
0218
0219     return ret;
0220 }
0221
0222 static int rx85x1_nvram_write(void *priv, unsigned int offset, void *val,
0223                   size_t bytes)
0224 {
0225     struct rx8581 *rx8581 = priv;
0226     unsigned char tmp_val;
0227
0228     tmp_val = *((unsigned char *)val);
0229     return regmap_write(rx8581->regmap, RX8581_REG_RAM,
0230                 (unsigned int)tmp_val);
0231 }
0232
0233 static const struct rx85x1_config rx8581_config = {
0234     .regmap = {
0235         .reg_bits = 8,
0236         .val_bits = 8,
0237         .max_register = 0xf,
0238     },
0239     .num_nvram = 1
0240 };
0241
0242 static const struct rx85x1_config rx8571_config = {
0243     .regmap = {
0244         .reg_bits = 8,
0245         .val_bits = 8,
0246         .max_register = 0x1f,
0247     },
0248     .num_nvram = 2
0249 };
0250
0251 static int rx8581_probe(struct i2c_client *client)
0252 {
0253     struct rx8581 *rx8581;
0254     const struct rx85x1_config *config = &rx8581_config;
0255     const void *data = of_device_get_match_data(&client->dev);
0256     static struct nvmem_config nvmem_cfg[] = {
0257         {
0258             .name = "rx85x1-",
0259             .word_size = 1,
0260             .stride = 1,
0261             .size = 1,
0262             .reg_read = rx85x1_nvram_read,
0263             .reg_write = rx85x1_nvram_write,
0264         }, {
0265             .name = "rx8571-",
0266             .word_size = 1,
0267             .stride = 1,
0268             .size = RX8571_NVRAM_SIZE,
0269             .reg_read = rx8571_nvram_read,
0270             .reg_write = rx8571_nvram_write,
0271         },
0272     };
0273     int ret, i;
0274
0275     dev_dbg(&client->dev, "%s\n", __func__);
0276
0277     if (data)
0278         config = data;
0279
0280     rx8581 = devm_kzalloc(&client->dev, sizeof(struct rx8581), GFP_KERNEL);
0281     if (!rx8581)
0282         return -ENOMEM;
0283
0284     i2c_set_clientdata(client, rx8581);
0285
0286     rx8581->regmap = devm_regmap_init_i2c(client, &config->regmap);
0287     if (IS_ERR(rx8581->regmap))
0288         return PTR_ERR(rx8581->regmap);
0289
0290     rx8581->rtc = devm_rtc_allocate_device(&client->dev);
0291     if (IS_ERR(rx8581->rtc))
0292         return PTR_ERR(rx8581->rtc);
0293
0294     rx8581->rtc->ops = &rx8581_rtc_ops;
0295     rx8581->rtc->range_min = RTC_TIMESTAMP_BEGIN_2000;
0296     rx8581->rtc->range_max = RTC_TIMESTAMP_END_2099;
0297     rx8581->rtc->start_secs = 0;
0298     rx8581->rtc->set_start_time = true;
0299
0300     ret = devm_rtc_register_device(rx8581->rtc);
0301
0302     for (i = 0; i < config->num_nvram; i++) {
0303         nvmem_cfg[i].priv = rx8581;
0304         devm_rtc_nvmem_register(rx8581->rtc, &nvmem_cfg[i]);
0305     }
0306
0307     return ret;
0308 }
0309
0310 static const struct i2c_device_id rx8581_id[] = {
0311     { "rx8581", 0 },
0312     { }
0313 };
0314 MODULE_DEVICE_TABLE(i2c, rx8581_id);
0315
0316 static const __maybe_unused struct of_device_id rx8581_of_match[] = {
0317     { .compatible = "epson,rx8571", .data = &rx8571_config },
0318     { .compatible = "epson,rx8581", .data = &rx8581_config },
0319     { /* sentinel */ }
0320 };
0321 MODULE_DEVICE_TABLE(of, rx8581_of_match);
0322
0323 static struct i2c_driver rx8581_driver = {
0324     .driver     = {
0325         .name   = "rtc-rx8581",
0326         .of_match_table = of_match_ptr(rx8581_of_match),
0327     },
0328     .probe_new  = rx8581_probe,
0329     .id_table   = rx8581_id,
0330 };
0331
0332 module_i2c_driver(rx8581_driver);
0333
0334 MODULE_AUTHOR("Martyn Welch <martyn.welch@ge.com>");
0335 MODULE_DESCRIPTION("Epson RX-8571/RX-8581 RTC driver");
0336 MODULE_LICENSE("GPL");