1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * isl28022.c - driver for Renesas ISL28022 power monitor chip monitoring 4 * 5 * Copyright (c) 2023 Carsten Spieß <mail@carsten-spiess.de> 6 */ 7 8 #include <linux/debugfs.h> 9 #include <linux/err.h> 10 #include <linux/hwmon.h> 11 #include <linux/i2c.h> 12 #include <linux/module.h> 13 #include <linux/regmap.h> 14 15 /* ISL28022 registers */ 16 #define ISL28022_REG_CONFIG 0x00 17 #define ISL28022_REG_SHUNT 0x01 18 #define ISL28022_REG_BUS 0x02 19 #define ISL28022_REG_POWER 0x03 20 #define ISL28022_REG_CURRENT 0x04 21 #define ISL28022_REG_CALIB 0x05 22 #define ISL28022_REG_SHUNT_THR 0x06 23 #define ISL28022_REG_BUS_THR 0x07 24 #define ISL28022_REG_INT 0x08 25 #define ISL28022_REG_AUX 0x09 26 #define ISL28022_REG_MAX ISL28022_REG_AUX 27 28 /* ISL28022 config flags */ 29 /* mode flags */ 30 #define ISL28022_MODE_SHIFT 0 31 #define ISL28022_MODE_MASK 0x0007 32 33 #define ISL28022_MODE_PWR_DOWN 0x0 34 #define ISL28022_MODE_TRG_S 0x1 35 #define ISL28022_MODE_TRG_B 0x2 36 #define ISL28022_MODE_TRG_SB 0x3 37 #define ISL28022_MODE_ADC_OFF 0x4 38 #define ISL28022_MODE_CONT_S 0x5 39 #define ISL28022_MODE_CONT_B 0x6 40 #define ISL28022_MODE_CONT_SB 0x7 41 42 /* shunt ADC settings */ 43 #define ISL28022_SADC_SHIFT 3 44 #define ISL28022_SADC_MASK 0x0078 45 46 #define ISL28022_BADC_SHIFT 7 47 #define ISL28022_BADC_MASK 0x0780 48 49 #define ISL28022_ADC_12 0x0 /* 12 bit ADC */ 50 #define ISL28022_ADC_13 0x1 /* 13 bit ADC */ 51 #define ISL28022_ADC_14 0x2 /* 14 bit ADC */ 52 #define ISL28022_ADC_15 0x3 /* 15 bit ADC */ 53 #define ISL28022_ADC_15_1 0x8 /* 15 bit ADC, 1 sample */ 54 #define ISL28022_ADC_15_2 0x9 /* 15 bit ADC, 2 samples */ 55 #define ISL28022_ADC_15_4 0xA /* 15 bit ADC, 4 samples */ 56 #define ISL28022_ADC_15_8 0xB /* 15 bit ADC, 8 samples */ 57 #define ISL28022_ADC_15_16 0xC /* 15 bit ADC, 16 samples */ 58 #define ISL28022_ADC_15_32 0xD /* 15 bit ADC, 32 samples */ 59 #define ISL28022_ADC_15_64 0xE /* 15 bit ADC, 64 samples */ 60 #define ISL28022_ADC_15_128 0xF /* 15 bit ADC, 128 samples */ 61 62 /* shunt voltage range */ 63 #define ISL28022_PG_SHIFT 11 64 #define ISL28022_PG_MASK 0x1800 65 66 #define ISL28022_PG_40 0x0 /* +/-40 mV */ 67 #define ISL28022_PG_80 0x1 /* +/-80 mV */ 68 #define ISL28022_PG_160 0x2 /* +/-160 mV */ 69 #define ISL28022_PG_320 0x3 /* +/-3200 mV */ 70 71 /* bus voltage range */ 72 #define ISL28022_BRNG_SHIFT 13 73 #define ISL28022_BRNG_MASK 0x6000 74 75 #define ISL28022_BRNG_16 0x0 /* 16 V */ 76 #define ISL28022_BRNG_32 0x1 /* 32 V */ 77 #define ISL28022_BRNG_60 0x3 /* 60 V */ 78 79 /* reset */ 80 #define ISL28022_RESET 0x8000 81 82 struct isl28022_data { 83 struct regmap *regmap; 84 u32 shunt; 85 u32 gain; 86 u32 average; 87 }; 88 89 static int isl28022_read_in(struct device *dev, u32 attr, int channel, long *val) 90 { 91 struct isl28022_data *data = dev_get_drvdata(dev); 92 unsigned int regval; 93 int err; 94 u16 sign_bit; 95 96 switch (channel) { 97 case 0: 98 switch (attr) { 99 case hwmon_in_input: 100 err = regmap_read(data->regmap, 101 ISL28022_REG_BUS, ®val); 102 if (err < 0) 103 return err; 104 /* driver supports only 60V mode (BRNG 11) */ 105 *val = (long)(((u16)regval) & 0xFFFC); 106 break; 107 default: 108 return -EOPNOTSUPP; 109 } 110 break; 111 case 1: 112 switch (attr) { 113 case hwmon_in_input: 114 err = regmap_read(data->regmap, 115 ISL28022_REG_SHUNT, ®val); 116 if (err < 0) 117 return err; 118 switch (data->gain) { 119 case 8: 120 sign_bit = (regval >> 15) & 0x01; 121 *val = (long)((((u16)regval) & 0x7FFF) - 122 (sign_bit * 32768)) / 100; 123 break; 124 case 4: 125 sign_bit = (regval >> 14) & 0x01; 126 *val = (long)((((u16)regval) & 0x3FFF) - 127 (sign_bit * 16384)) / 100; 128 break; 129 case 2: 130 sign_bit = (regval >> 13) & 0x01; 131 *val = (long)((((u16)regval) & 0x1FFF) - 132 (sign_bit * 8192)) / 100; 133 break; 134 case 1: 135 sign_bit = (regval >> 12) & 0x01; 136 *val = (long)((((u16)regval) & 0x0FFF) - 137 (sign_bit * 4096)) / 100; 138 break; 139 } 140 break; 141 default: 142 return -EOPNOTSUPP; 143 } 144 break; 145 default: 146 return -EOPNOTSUPP; 147 } 148 149 return 0; 150 } 151 152 static int isl28022_read_current(struct device *dev, u32 attr, long *val) 153 { 154 struct isl28022_data *data = dev_get_drvdata(dev); 155 unsigned int regval; 156 int err; 157 158 switch (attr) { 159 case hwmon_curr_input: 160 err = regmap_read(data->regmap, 161 ISL28022_REG_CURRENT, ®val); 162 if (err < 0) 163 return err; 164 *val = ((long)regval * 1250L * (long)data->gain) / 165 (long)data->shunt; 166 break; 167 default: 168 return -EOPNOTSUPP; 169 } 170 171 return 0; 172 } 173 174 static int isl28022_read_power(struct device *dev, u32 attr, long *val) 175 { 176 struct isl28022_data *data = dev_get_drvdata(dev); 177 unsigned int regval; 178 int err; 179 180 switch (attr) { 181 case hwmon_power_input: 182 err = regmap_read(data->regmap, 183 ISL28022_REG_POWER, ®val); 184 if (err < 0) 185 return err; 186 *val = ((51200000L * ((long)data->gain)) / 187 (long)data->shunt) * (long)regval; 188 break; 189 default: 190 return -EOPNOTSUPP; 191 } 192 193 return 0; 194 } 195 196 static int isl28022_read(struct device *dev, enum hwmon_sensor_types type, 197 u32 attr, int channel, long *val) 198 { 199 switch (type) { 200 case hwmon_in: 201 return isl28022_read_in(dev, attr, channel, val); 202 case hwmon_curr: 203 return isl28022_read_current(dev, attr, val); 204 case hwmon_power: 205 return isl28022_read_power(dev, attr, val); 206 default: 207 return -EOPNOTSUPP; 208 } 209 return 0; 210 } 211 212 static umode_t isl28022_is_visible(const void *data, enum hwmon_sensor_types type, 213 u32 attr, int channel) 214 { 215 switch (type) { 216 case hwmon_in: 217 switch (attr) { 218 case hwmon_in_input: 219 return 0444; 220 default: 221 break; 222 } 223 break; 224 case hwmon_curr: 225 switch (attr) { 226 case hwmon_curr_input: 227 return 0444; 228 default: 229 break; 230 } 231 break; 232 case hwmon_power: 233 switch (attr) { 234 case hwmon_power_input: 235 return 0444; 236 default: 237 break; 238 } 239 break; 240 default: 241 break; 242 } 243 return 0; 244 } 245 246 static const struct hwmon_channel_info *isl28022_info[] = { 247 HWMON_CHANNEL_INFO(in, 248 HWMON_I_INPUT, /* channel 0: bus voltage (mV) */ 249 HWMON_I_INPUT), /* channel 1: shunt voltage (mV) */ 250 HWMON_CHANNEL_INFO(curr, 251 HWMON_C_INPUT), /* channel 1: current (mA) */ 252 HWMON_CHANNEL_INFO(power, 253 HWMON_P_INPUT), /* channel 1: power (µW) */ 254 NULL 255 }; 256 257 static const struct hwmon_ops isl28022_hwmon_ops = { 258 .is_visible = isl28022_is_visible, 259 .read = isl28022_read, 260 }; 261 262 static const struct hwmon_chip_info isl28022_chip_info = { 263 .ops = &isl28022_hwmon_ops, 264 .info = isl28022_info, 265 }; 266 267 static bool isl28022_is_writeable_reg(struct device *dev, unsigned int reg) 268 { 269 switch (reg) { 270 case ISL28022_REG_CONFIG: 271 case ISL28022_REG_CALIB: 272 case ISL28022_REG_SHUNT_THR: 273 case ISL28022_REG_BUS_THR: 274 case ISL28022_REG_INT: 275 case ISL28022_REG_AUX: 276 return true; 277 } 278 279 return false; 280 } 281 282 static bool isl28022_is_volatile_reg(struct device *dev, unsigned int reg) 283 { 284 switch (reg) { 285 case ISL28022_REG_CONFIG: 286 case ISL28022_REG_SHUNT: 287 case ISL28022_REG_BUS: 288 case ISL28022_REG_POWER: 289 case ISL28022_REG_CURRENT: 290 case ISL28022_REG_INT: 291 case ISL28022_REG_AUX: 292 return true; 293 } 294 return true; 295 } 296 297 static const struct regmap_config isl28022_regmap_config = { 298 .reg_bits = 8, 299 .val_bits = 16, 300 .max_register = ISL28022_REG_MAX, 301 .writeable_reg = isl28022_is_writeable_reg, 302 .volatile_reg = isl28022_is_volatile_reg, 303 .val_format_endian = REGMAP_ENDIAN_BIG, 304 .cache_type = REGCACHE_RBTREE, 305 .use_single_read = true, 306 .use_single_write = true, 307 }; 308 309 static int shunt_voltage_show(struct seq_file *seqf, void *unused) 310 { 311 struct isl28022_data *data = seqf->private; 312 unsigned int regval; 313 int err; 314 315 err = regmap_read(data->regmap, 316 ISL28022_REG_SHUNT, ®val); 317 if (err) 318 return err; 319 320 /* print shunt voltage in micro volt */ 321 seq_printf(seqf, "%d\n", regval * 10); 322 323 return 0; 324 } 325 DEFINE_SHOW_ATTRIBUTE(shunt_voltage); 326 327 /* 328 * read property values and make consistency checks. 329 * 330 * following values for shunt range and resistor are allowed: 331 * 40 mV -> gain 1, shunt min. 800 micro ohms 332 * 80 mV -> gain 2, shunt min. 1600 micro ohms 333 * 160 mV -> gain 4, shunt min. 3200 micro ohms 334 * 320 mV -> gain 8, shunt min. 6400 micro ohms 335 */ 336 static int isl28022_read_properties(struct device *dev, struct isl28022_data *data) 337 { 338 u32 val; 339 int err; 340 341 err = device_property_read_u32(dev, "shunt-resistor-micro-ohms", &val); 342 if (err == -EINVAL) 343 val = 10000; 344 else if (err < 0) 345 return err; 346 data->shunt = val; 347 348 err = device_property_read_u32(dev, "renesas,shunt-range-microvolt", &val); 349 if (err == -EINVAL) 350 val = 320000; 351 else if (err < 0) 352 return err; 353 354 switch (val) { 355 case 40000: 356 data->gain = 1; 357 if (data->shunt < 800) 358 goto shunt_invalid; 359 break; 360 case 80000: 361 data->gain = 2; 362 if (data->shunt < 1600) 363 goto shunt_invalid; 364 break; 365 case 160000: 366 data->gain = 4; 367 if (data->shunt < 3200) 368 goto shunt_invalid; 369 break; 370 case 320000: 371 data->gain = 8; 372 if (data->shunt < 6400) 373 goto shunt_invalid; 374 break; 375 default: 376 return dev_err_probe(dev, -EINVAL, 377 "renesas,shunt-range-microvolt invalid value %d\n", 378 val); 379 } 380 381 err = device_property_read_u32(dev, "renesas,average-samples", &val); 382 if (err == -EINVAL) 383 val = 1; 384 else if (err < 0) 385 return err; 386 if (val > 128 || hweight32(val) != 1) 387 return dev_err_probe(dev, -EINVAL, 388 "renesas,average-samples invalid value %d\n", 389 val); 390 391 data->average = val; 392 393 return 0; 394 395 shunt_invalid: 396 return dev_err_probe(dev, -EINVAL, 397 "renesas,shunt-resistor-microvolt invalid value %d\n", 398 data->shunt); 399 } 400 401 /* 402 * write configuration and calibration registers 403 * 404 * The driver supports only shunt and bus continuous ADC mode at 15bit resolution 405 * with averaging from 1 to 128 samples (pow of 2) on both channels. 406 * Shunt voltage gain 1,2,4 or 8 is allowed. 407 * The bus voltage range is 60V fixed. 408 */ 409 static int isl28022_config(struct isl28022_data *data) 410 { 411 int err; 412 u16 config; 413 u16 calib; 414 415 config = (ISL28022_MODE_CONT_SB << ISL28022_MODE_SHIFT) | 416 (ISL28022_BRNG_60 << ISL28022_BRNG_SHIFT) | 417 (__ffs(data->gain) << ISL28022_PG_SHIFT) | 418 ((ISL28022_ADC_15_1 + __ffs(data->average)) << ISL28022_SADC_SHIFT) | 419 ((ISL28022_ADC_15_1 + __ffs(data->average)) << ISL28022_BADC_SHIFT); 420 421 calib = data->shunt ? 0x8000 / data->gain : 0; 422 423 err = regmap_write(data->regmap, ISL28022_REG_CONFIG, config); 424 if (err < 0) 425 return err; 426 427 return regmap_write(data->regmap, ISL28022_REG_CALIB, calib); 428 } 429 430 static int isl28022_probe(struct i2c_client *client) 431 { 432 struct device *dev = &client->dev; 433 struct device *hwmon_dev; 434 struct isl28022_data *data; 435 int err; 436 437 if (!i2c_check_functionality(client->adapter, 438 I2C_FUNC_SMBUS_BYTE_DATA | 439 I2C_FUNC_SMBUS_WORD_DATA)) 440 return -ENODEV; 441 442 data = devm_kzalloc(dev, sizeof(struct isl28022_data), GFP_KERNEL); 443 if (!data) 444 return -ENOMEM; 445 446 err = isl28022_read_properties(dev, data); 447 if (err) 448 return err; 449 450 data->regmap = devm_regmap_init_i2c(client, &isl28022_regmap_config); 451 if (IS_ERR(data->regmap)) 452 return PTR_ERR(data->regmap); 453 454 err = isl28022_config(data); 455 if (err) 456 return err; 457 458 debugfs_create_file("shunt_voltage", 0444, client->debugfs, data, &shunt_voltage_fops); 459 460 hwmon_dev = devm_hwmon_device_register_with_info(dev, client->name, 461 data, &isl28022_chip_info, NULL); 462 if (IS_ERR(hwmon_dev)) 463 return PTR_ERR(hwmon_dev); 464 465 return 0; 466 } 467 468 static const struct i2c_device_id isl28022_ids[] = { 469 { "isl28022" }, 470 { /* LIST END */ } 471 }; 472 MODULE_DEVICE_TABLE(i2c, isl28022_ids); 473 474 static const struct of_device_id __maybe_unused isl28022_of_match[] = { 475 { .compatible = "renesas,isl28022"}, 476 { /* LIST END */ } 477 }; 478 MODULE_DEVICE_TABLE(of, isl28022_of_match); 479 480 static struct i2c_driver isl28022_driver = { 481 .class = I2C_CLASS_HWMON, 482 .driver = { 483 .name = "isl28022", 484 }, 485 .probe = isl28022_probe, 486 .id_table = isl28022_ids, 487 }; 488 module_i2c_driver(isl28022_driver); 489 490 MODULE_AUTHOR("Carsten Spieß <mail@carsten-spiess.de>"); 491 MODULE_DESCRIPTION("ISL28022 driver"); 492 MODULE_LICENSE("GPL"); 493