drivers/rtc/rtc-isl12022.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * An I2C driver for the Intersil ISL 12022
   4  *
   5  * Author: Roman Fietze <roman.fietze@telemotive.de>
   6  *
   7  * Based on the Philips PCF8563 RTC
   8  * by Alessandro Zummo <a.zummo@towertech.it>.
   9  */
  10
  11 #include <linux/i2c.h>
  12 #include <linux/bcd.h>
  13 #include <linux/rtc.h>
  14 #include <linux/slab.h>
  15 #include <linux/module.h>
  16 #include <linux/err.h>
  17 #include <linux/of.h>
  18 #include <linux/of_device.h>
  19 #include <linux/regmap.h>
  20
  21 /* ISL register offsets */
  22 #define ISL12022_REG_SC         0x00
  23 #define ISL12022_REG_MN         0x01
  24 #define ISL12022_REG_HR         0x02
  25 #define ISL12022_REG_DT         0x03
  26 #define ISL12022_REG_MO         0x04
  27 #define ISL12022_REG_YR         0x05
  28 #define ISL12022_REG_DW         0x06
  29
  30 #define ISL12022_REG_SR         0x07
  31 #define ISL12022_REG_INT        0x08
  32
  33 /* ISL register bits */
  34 #define ISL12022_HR_MIL         (1 << 7)        /* military or 24 hour time */
  35
  36 #define ISL12022_SR_LBAT85      (1 << 2)
  37 #define ISL12022_SR_LBAT75      (1 << 1)
  38
  39 #define ISL12022_INT_WRTC       (1 << 6)
  40
  41
  42 static struct i2c_driver isl12022_driver;
  43
  44 struct isl12022 {
  45         struct rtc_device *rtc;
  46         struct regmap *regmap;
  47 };
  48
  49 /*
  50  * In the routines that deal directly with the isl12022 hardware, we use
  51  * rtc_time -- month 0-11, hour 0-23, yr = calendar year-epoch.
  52  */
  53 static int isl12022_rtc_read_time(struct device *dev, struct rtc_time *tm)
  54 {
  55         struct isl12022 *isl12022 = dev_get_drvdata(dev);
  56         struct regmap *regmap = isl12022->regmap;
  57         uint8_t buf[ISL12022_REG_INT + 1];
  58         int ret;
  59
  60         ret = regmap_bulk_read(regmap, ISL12022_REG_SC, buf, sizeof(buf));
  61         if (ret)
  62                 return ret;
  63
  64         if (buf[ISL12022_REG_SR] & (ISL12022_SR_LBAT85 | ISL12022_SR_LBAT75)) {
  65                 dev_warn(dev,
  66                          "voltage dropped below %u%%, "
  67                          "date and time is not reliable.\n",
  68                          buf[ISL12022_REG_SR] & ISL12022_SR_LBAT85 ? 85 : 75);
  69         }
  70
  71         dev_dbg(dev,
  72                 "%s: raw data is sec=%02x, min=%02x, hr=%02x, "
  73                 "mday=%02x, mon=%02x, year=%02x, wday=%02x, "
  74                 "sr=%02x, int=%02x",
  75                 __func__,
  76                 buf[ISL12022_REG_SC],
  77                 buf[ISL12022_REG_MN],
  78                 buf[ISL12022_REG_HR],
  79                 buf[ISL12022_REG_DT],
  80                 buf[ISL12022_REG_MO],
  81                 buf[ISL12022_REG_YR],
  82                 buf[ISL12022_REG_DW],
  83                 buf[ISL12022_REG_SR],
  84                 buf[ISL12022_REG_INT]);
  85
  86         tm->tm_sec = bcd2bin(buf[ISL12022_REG_SC] & 0x7F);
  87         tm->tm_min = bcd2bin(buf[ISL12022_REG_MN] & 0x7F);
  88         tm->tm_hour = bcd2bin(buf[ISL12022_REG_HR] & 0x3F);
  89         tm->tm_mday = bcd2bin(buf[ISL12022_REG_DT] & 0x3F);
  90         tm->tm_wday = buf[ISL12022_REG_DW] & 0x07;
  91         tm->tm_mon = bcd2bin(buf[ISL12022_REG_MO] & 0x1F) - 1;
  92         tm->tm_year = bcd2bin(buf[ISL12022_REG_YR]) + 100;
  93
  94         dev_dbg(dev, "%s: %ptR\n", __func__, tm);
  95
  96         return 0;
  97 }
  98
  99 static int isl12022_rtc_set_time(struct device *dev, struct rtc_time *tm)
 100 {
 101         struct isl12022 *isl12022 = dev_get_drvdata(dev);
 102         struct regmap *regmap = isl12022->regmap;
 103         int ret;
 104         uint8_t buf[ISL12022_REG_DW + 1];
 105
 106         dev_dbg(dev, "%s: %ptR\n", __func__, tm);
 107
 108         /* Ensure the write enable bit is set. */
 109         ret = regmap_update_bits(regmap, ISL12022_REG_INT,
 110                                  ISL12022_INT_WRTC, ISL12022_INT_WRTC);
 111         if (ret)
 112                 return ret;
 113
 114         /* hours, minutes and seconds */
 115         buf[ISL12022_REG_SC] = bin2bcd(tm->tm_sec);
 116         buf[ISL12022_REG_MN] = bin2bcd(tm->tm_min);
 117         buf[ISL12022_REG_HR] = bin2bcd(tm->tm_hour) | ISL12022_HR_MIL;
 118
 119         buf[ISL12022_REG_DT] = bin2bcd(tm->tm_mday);
 120
 121         /* month, 1 - 12 */
 122         buf[ISL12022_REG_MO] = bin2bcd(tm->tm_mon + 1);
 123
 124         /* year and century */
 125         buf[ISL12022_REG_YR] = bin2bcd(tm->tm_year % 100);
 126
 127         buf[ISL12022_REG_DW] = tm->tm_wday & 0x07;
 128
 129         return regmap_bulk_write(isl12022->regmap, ISL12022_REG_SC,
 130                                  buf, sizeof(buf));
 131 }
 132
 133 static const struct rtc_class_ops isl12022_rtc_ops = {
 134         .read_time      = isl12022_rtc_read_time,
 135         .set_time       = isl12022_rtc_set_time,
 136 };
 137
 138 static const struct regmap_config regmap_config = {
 139         .reg_bits = 8,
 140         .val_bits = 8,
 141         .use_single_write = true,
 142 };
 143
 144 static int isl12022_probe(struct i2c_client *client)
 145 {
 146         struct isl12022 *isl12022;
 147
 148         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
 149                 return -ENODEV;
 150
 151         isl12022 = devm_kzalloc(&client->dev, sizeof(struct isl12022),
 152                                 GFP_KERNEL);
 153         if (!isl12022)
 154                 return -ENOMEM;
 155         dev_set_drvdata(&client->dev, isl12022);
 156
 157         isl12022->regmap = devm_regmap_init_i2c(client, &regmap_config);
 158         if (IS_ERR(isl12022->regmap)) {
 159                 dev_err(&client->dev, "regmap allocation failed\n");
 160                 return PTR_ERR(isl12022->regmap);
 161         }
 162
 163         isl12022->rtc = devm_rtc_allocate_device(&client->dev);
 164         if (IS_ERR(isl12022->rtc))
 165                 return PTR_ERR(isl12022->rtc);
 166
 167         isl12022->rtc->ops = &isl12022_rtc_ops;
 168         isl12022->rtc->range_min = RTC_TIMESTAMP_BEGIN_2000;
 169         isl12022->rtc->range_max = RTC_TIMESTAMP_END_2099;
 170
 171         return devm_rtc_register_device(isl12022->rtc);
 172 }
 173
 174 #ifdef CONFIG_OF
 175 static const struct of_device_id isl12022_dt_match[] = {
 176         { .compatible = "isl,isl12022" }, /* for backward compat., don't use */
 177         { .compatible = "isil,isl12022" },
 178         { },
 179 };
 180 MODULE_DEVICE_TABLE(of, isl12022_dt_match);
 181 #endif
 182
 183 static const struct i2c_device_id isl12022_id[] = {
 184         { "isl12022", 0 },
 185         { }
 186 };
 187 MODULE_DEVICE_TABLE(i2c, isl12022_id);
 188
 189 static struct i2c_driver isl12022_driver = {
 190         .driver         = {
 191                 .name   = "rtc-isl12022",
 192 #ifdef CONFIG_OF
 193                 .of_match_table = of_match_ptr(isl12022_dt_match),
 194 #endif
 195         },
 196         .probe_new      = isl12022_probe,
 197         .id_table       = isl12022_id,
 198 };
 199
 200 module_i2c_driver(isl12022_driver);
 201
 202 MODULE_AUTHOR("roman.fietze@telemotive.de");
 203 MODULE_DESCRIPTION("ISL 12022 RTC driver");
 204 MODULE_LICENSE("GPL");