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 #include <linux/hwmon.h> 21 22 /* ISL register offsets */ 23 #define ISL12022_REG_SC 0x00 24 #define ISL12022_REG_MN 0x01 25 #define ISL12022_REG_HR 0x02 26 #define ISL12022_REG_DT 0x03 27 #define ISL12022_REG_MO 0x04 28 #define ISL12022_REG_YR 0x05 29 #define ISL12022_REG_DW 0x06 30 31 #define ISL12022_REG_SR 0x07 32 #define ISL12022_REG_INT 0x08 33 34 #define ISL12022_REG_BETA 0x0d 35 #define ISL12022_REG_TEMP_L 0x28 36 37 /* ISL register bits */ 38 #define ISL12022_HR_MIL (1 << 7) /* military or 24 hour time */ 39 40 #define ISL12022_SR_LBAT85 (1 << 2) 41 #define ISL12022_SR_LBAT75 (1 << 1) 42 43 #define ISL12022_INT_WRTC (1 << 6) 44 45 #define ISL12022_BETA_TSE (1 << 7) 46 47 static struct i2c_driver isl12022_driver; 48 49 struct isl12022 { 50 struct rtc_device *rtc; 51 struct regmap *regmap; 52 }; 53 54 static umode_t isl12022_hwmon_is_visible(const void *data, 55 enum hwmon_sensor_types type, 56 u32 attr, int channel) 57 { 58 if (type == hwmon_temp && attr == hwmon_temp_input) 59 return 0444; 60 61 return 0; 62 } 63 64 /* 65 * A user-initiated temperature conversion is not started by this function, 66 * so the temperature is updated once every ~60 seconds. 67 */ 68 static int isl12022_hwmon_read_temp(struct device *dev, long *mC) 69 { 70 struct isl12022 *isl12022 = dev_get_drvdata(dev); 71 struct regmap *regmap = isl12022->regmap; 72 u8 temp_buf[2]; 73 int temp, ret; 74 75 ret = regmap_bulk_read(regmap, ISL12022_REG_TEMP_L, 76 temp_buf, sizeof(temp_buf)); 77 if (ret) 78 return ret; 79 /* 80 * Temperature is represented as a 10-bit number, unit half-Kelvins. 81 */ 82 temp = (temp_buf[1] << 8) | temp_buf[0]; 83 temp *= 500; 84 temp -= 273000; 85 86 *mC = temp; 87 88 return 0; 89 } 90 91 static int isl12022_hwmon_read(struct device *dev, 92 enum hwmon_sensor_types type, 93 u32 attr, int channel, long *val) 94 { 95 if (type == hwmon_temp && attr == hwmon_temp_input) 96 return isl12022_hwmon_read_temp(dev, val); 97 98 return -EOPNOTSUPP; 99 } 100 101 static const struct hwmon_channel_info *isl12022_hwmon_info[] = { 102 HWMON_CHANNEL_INFO(temp, HWMON_T_INPUT), 103 NULL 104 }; 105 106 static const struct hwmon_ops isl12022_hwmon_ops = { 107 .is_visible = isl12022_hwmon_is_visible, 108 .read = isl12022_hwmon_read, 109 }; 110 111 static const struct hwmon_chip_info isl12022_hwmon_chip_info = { 112 .ops = &isl12022_hwmon_ops, 113 .info = isl12022_hwmon_info, 114 }; 115 116 static void isl12022_hwmon_register(struct device *dev) 117 { 118 struct isl12022 *isl12022; 119 struct device *hwmon; 120 int ret; 121 122 if (!IS_REACHABLE(CONFIG_HWMON)) 123 return; 124 125 isl12022 = dev_get_drvdata(dev); 126 127 ret = regmap_update_bits(isl12022->regmap, ISL12022_REG_BETA, 128 ISL12022_BETA_TSE, ISL12022_BETA_TSE); 129 if (ret) { 130 dev_warn(dev, "unable to enable temperature sensor\n"); 131 return; 132 } 133 134 hwmon = devm_hwmon_device_register_with_info(dev, "isl12022", isl12022, 135 &isl12022_hwmon_chip_info, 136 NULL); 137 if (IS_ERR(hwmon)) 138 dev_warn(dev, "unable to register hwmon device: %pe\n", hwmon); 139 } 140 141 /* 142 * In the routines that deal directly with the isl12022 hardware, we use 143 * rtc_time -- month 0-11, hour 0-23, yr = calendar year-epoch. 144 */ 145 static int isl12022_rtc_read_time(struct device *dev, struct rtc_time *tm) 146 { 147 struct isl12022 *isl12022 = dev_get_drvdata(dev); 148 struct regmap *regmap = isl12022->regmap; 149 uint8_t buf[ISL12022_REG_INT + 1]; 150 int ret; 151 152 ret = regmap_bulk_read(regmap, ISL12022_REG_SC, buf, sizeof(buf)); 153 if (ret) 154 return ret; 155 156 if (buf[ISL12022_REG_SR] & (ISL12022_SR_LBAT85 | ISL12022_SR_LBAT75)) { 157 dev_warn(dev, 158 "voltage dropped below %u%%, " 159 "date and time is not reliable.\n", 160 buf[ISL12022_REG_SR] & ISL12022_SR_LBAT85 ? 85 : 75); 161 } 162 163 dev_dbg(dev, 164 "%s: raw data is sec=%02x, min=%02x, hr=%02x, " 165 "mday=%02x, mon=%02x, year=%02x, wday=%02x, " 166 "sr=%02x, int=%02x", 167 __func__, 168 buf[ISL12022_REG_SC], 169 buf[ISL12022_REG_MN], 170 buf[ISL12022_REG_HR], 171 buf[ISL12022_REG_DT], 172 buf[ISL12022_REG_MO], 173 buf[ISL12022_REG_YR], 174 buf[ISL12022_REG_DW], 175 buf[ISL12022_REG_SR], 176 buf[ISL12022_REG_INT]); 177 178 tm->tm_sec = bcd2bin(buf[ISL12022_REG_SC] & 0x7F); 179 tm->tm_min = bcd2bin(buf[ISL12022_REG_MN] & 0x7F); 180 tm->tm_hour = bcd2bin(buf[ISL12022_REG_HR] & 0x3F); 181 tm->tm_mday = bcd2bin(buf[ISL12022_REG_DT] & 0x3F); 182 tm->tm_wday = buf[ISL12022_REG_DW] & 0x07; 183 tm->tm_mon = bcd2bin(buf[ISL12022_REG_MO] & 0x1F) - 1; 184 tm->tm_year = bcd2bin(buf[ISL12022_REG_YR]) + 100; 185 186 dev_dbg(dev, "%s: %ptR\n", __func__, tm); 187 188 return 0; 189 } 190 191 static int isl12022_rtc_set_time(struct device *dev, struct rtc_time *tm) 192 { 193 struct isl12022 *isl12022 = dev_get_drvdata(dev); 194 struct regmap *regmap = isl12022->regmap; 195 int ret; 196 uint8_t buf[ISL12022_REG_DW + 1]; 197 198 dev_dbg(dev, "%s: %ptR\n", __func__, tm); 199 200 /* Ensure the write enable bit is set. */ 201 ret = regmap_update_bits(regmap, ISL12022_REG_INT, 202 ISL12022_INT_WRTC, ISL12022_INT_WRTC); 203 if (ret) 204 return ret; 205 206 /* hours, minutes and seconds */ 207 buf[ISL12022_REG_SC] = bin2bcd(tm->tm_sec); 208 buf[ISL12022_REG_MN] = bin2bcd(tm->tm_min); 209 buf[ISL12022_REG_HR] = bin2bcd(tm->tm_hour) | ISL12022_HR_MIL; 210 211 buf[ISL12022_REG_DT] = bin2bcd(tm->tm_mday); 212 213 /* month, 1 - 12 */ 214 buf[ISL12022_REG_MO] = bin2bcd(tm->tm_mon + 1); 215 216 /* year and century */ 217 buf[ISL12022_REG_YR] = bin2bcd(tm->tm_year % 100); 218 219 buf[ISL12022_REG_DW] = tm->tm_wday & 0x07; 220 221 return regmap_bulk_write(isl12022->regmap, ISL12022_REG_SC, 222 buf, sizeof(buf)); 223 } 224 225 static const struct rtc_class_ops isl12022_rtc_ops = { 226 .read_time = isl12022_rtc_read_time, 227 .set_time = isl12022_rtc_set_time, 228 }; 229 230 static const struct regmap_config regmap_config = { 231 .reg_bits = 8, 232 .val_bits = 8, 233 .use_single_write = true, 234 }; 235 236 static int isl12022_probe(struct i2c_client *client) 237 { 238 struct isl12022 *isl12022; 239 240 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) 241 return -ENODEV; 242 243 isl12022 = devm_kzalloc(&client->dev, sizeof(struct isl12022), 244 GFP_KERNEL); 245 if (!isl12022) 246 return -ENOMEM; 247 dev_set_drvdata(&client->dev, isl12022); 248 249 isl12022->regmap = devm_regmap_init_i2c(client, ®map_config); 250 if (IS_ERR(isl12022->regmap)) { 251 dev_err(&client->dev, "regmap allocation failed\n"); 252 return PTR_ERR(isl12022->regmap); 253 } 254 255 isl12022_hwmon_register(&client->dev); 256 257 isl12022->rtc = devm_rtc_allocate_device(&client->dev); 258 if (IS_ERR(isl12022->rtc)) 259 return PTR_ERR(isl12022->rtc); 260 261 isl12022->rtc->ops = &isl12022_rtc_ops; 262 isl12022->rtc->range_min = RTC_TIMESTAMP_BEGIN_2000; 263 isl12022->rtc->range_max = RTC_TIMESTAMP_END_2099; 264 265 return devm_rtc_register_device(isl12022->rtc); 266 } 267 268 #ifdef CONFIG_OF 269 static const struct of_device_id isl12022_dt_match[] = { 270 { .compatible = "isl,isl12022" }, /* for backward compat., don't use */ 271 { .compatible = "isil,isl12022" }, 272 { }, 273 }; 274 MODULE_DEVICE_TABLE(of, isl12022_dt_match); 275 #endif 276 277 static const struct i2c_device_id isl12022_id[] = { 278 { "isl12022", 0 }, 279 { } 280 }; 281 MODULE_DEVICE_TABLE(i2c, isl12022_id); 282 283 static struct i2c_driver isl12022_driver = { 284 .driver = { 285 .name = "rtc-isl12022", 286 #ifdef CONFIG_OF 287 .of_match_table = of_match_ptr(isl12022_dt_match), 288 #endif 289 }, 290 .probe_new = isl12022_probe, 291 .id_table = isl12022_id, 292 }; 293 294 module_i2c_driver(isl12022_driver); 295 296 MODULE_AUTHOR("roman.fietze@telemotive.de"); 297 MODULE_DESCRIPTION("ISL 12022 RTC driver"); 298 MODULE_LICENSE("GPL"); 299