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, ®map_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"); 205