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 u16 sign_bit; 158 159 switch (attr) { 160 case hwmon_curr_input: 161 err = regmap_read(data->regmap, 162 ISL28022_REG_CURRENT, ®val); 163 if (err < 0) 164 return err; 165 sign_bit = (regval >> 15) & 0x01; 166 *val = (((long)(((u16)regval) & 0x7FFF) - (sign_bit * 32768)) * 167 1250L * (long)data->gain) / (long)data->shunt; 168 break; 169 default: 170 return -EOPNOTSUPP; 171 } 172 173 return 0; 174 } 175 176 static int isl28022_read_power(struct device *dev, u32 attr, long *val) 177 { 178 struct isl28022_data *data = dev_get_drvdata(dev); 179 unsigned int regval; 180 int err; 181 182 switch (attr) { 183 case hwmon_power_input: 184 err = regmap_read(data->regmap, 185 ISL28022_REG_POWER, ®val); 186 if (err < 0) 187 return err; 188 *val = ((51200000L * ((long)data->gain)) / 189 (long)data->shunt) * (long)regval; 190 break; 191 default: 192 return -EOPNOTSUPP; 193 } 194 195 return 0; 196 } 197 198 static int isl28022_read(struct device *dev, enum hwmon_sensor_types type, 199 u32 attr, int channel, long *val) 200 { 201 switch (type) { 202 case hwmon_in: 203 return isl28022_read_in(dev, attr, channel, val); 204 case hwmon_curr: 205 return isl28022_read_current(dev, attr, val); 206 case hwmon_power: 207 return isl28022_read_power(dev, attr, val); 208 default: 209 return -EOPNOTSUPP; 210 } 211 return 0; 212 } 213 214 static umode_t isl28022_is_visible(const void *data, enum hwmon_sensor_types type, 215 u32 attr, int channel) 216 { 217 switch (type) { 218 case hwmon_in: 219 switch (attr) { 220 case hwmon_in_input: 221 return 0444; 222 default: 223 break; 224 } 225 break; 226 case hwmon_curr: 227 switch (attr) { 228 case hwmon_curr_input: 229 return 0444; 230 default: 231 break; 232 } 233 break; 234 case hwmon_power: 235 switch (attr) { 236 case hwmon_power_input: 237 return 0444; 238 default: 239 break; 240 } 241 break; 242 default: 243 break; 244 } 245 return 0; 246 } 247 248 static const struct hwmon_channel_info *isl28022_info[] = { 249 HWMON_CHANNEL_INFO(in, 250 HWMON_I_INPUT, /* channel 0: bus voltage (mV) */ 251 HWMON_I_INPUT), /* channel 1: shunt voltage (mV) */ 252 HWMON_CHANNEL_INFO(curr, 253 HWMON_C_INPUT), /* channel 1: current (mA) */ 254 HWMON_CHANNEL_INFO(power, 255 HWMON_P_INPUT), /* channel 1: power (µW) */ 256 NULL 257 }; 258 259 static const struct hwmon_ops isl28022_hwmon_ops = { 260 .is_visible = isl28022_is_visible, 261 .read = isl28022_read, 262 }; 263 264 static const struct hwmon_chip_info isl28022_chip_info = { 265 .ops = &isl28022_hwmon_ops, 266 .info = isl28022_info, 267 }; 268 269 static bool isl28022_is_writeable_reg(struct device *dev, unsigned int reg) 270 { 271 switch (reg) { 272 case ISL28022_REG_CONFIG: 273 case ISL28022_REG_CALIB: 274 case ISL28022_REG_SHUNT_THR: 275 case ISL28022_REG_BUS_THR: 276 case ISL28022_REG_INT: 277 case ISL28022_REG_AUX: 278 return true; 279 } 280 281 return false; 282 } 283 284 static bool isl28022_is_volatile_reg(struct device *dev, unsigned int reg) 285 { 286 switch (reg) { 287 case ISL28022_REG_CONFIG: 288 case ISL28022_REG_SHUNT: 289 case ISL28022_REG_BUS: 290 case ISL28022_REG_POWER: 291 case ISL28022_REG_CURRENT: 292 case ISL28022_REG_INT: 293 case ISL28022_REG_AUX: 294 return true; 295 } 296 return true; 297 } 298 299 static const struct regmap_config isl28022_regmap_config = { 300 .reg_bits = 8, 301 .val_bits = 16, 302 .max_register = ISL28022_REG_MAX, 303 .writeable_reg = isl28022_is_writeable_reg, 304 .volatile_reg = isl28022_is_volatile_reg, 305 .val_format_endian = REGMAP_ENDIAN_BIG, 306 .cache_type = REGCACHE_MAPLE, 307 .use_single_read = true, 308 .use_single_write = true, 309 }; 310 311 static int shunt_voltage_show(struct seq_file *seqf, void *unused) 312 { 313 struct isl28022_data *data = seqf->private; 314 unsigned int regval; 315 int err; 316 317 err = regmap_read(data->regmap, 318 ISL28022_REG_SHUNT, ®val); 319 if (err) 320 return err; 321 322 /* print shunt voltage in micro volt */ 323 seq_printf(seqf, "%d\n", regval * 10); 324 325 return 0; 326 } 327 DEFINE_SHOW_ATTRIBUTE(shunt_voltage); 328 329 /* 330 * read property values and make consistency checks. 331 * 332 * following values for shunt range and resistor are allowed: 333 * 40 mV -> gain 1, shunt min. 800 micro ohms 334 * 80 mV -> gain 2, shunt min. 1600 micro ohms 335 * 160 mV -> gain 4, shunt min. 3200 micro ohms 336 * 320 mV -> gain 8, shunt min. 6400 micro ohms 337 */ 338 static int isl28022_read_properties(struct device *dev, struct isl28022_data *data) 339 { 340 u32 val; 341 int err; 342 343 err = device_property_read_u32(dev, "shunt-resistor-micro-ohms", &val); 344 if (err == -EINVAL) 345 val = 10000; 346 else if (err < 0) 347 return err; 348 data->shunt = val; 349 350 err = device_property_read_u32(dev, "renesas,shunt-range-microvolt", &val); 351 if (err == -EINVAL) 352 val = 320000; 353 else if (err < 0) 354 return err; 355 356 switch (val) { 357 case 40000: 358 data->gain = 1; 359 if (data->shunt < 800) 360 goto shunt_invalid; 361 break; 362 case 80000: 363 data->gain = 2; 364 if (data->shunt < 1600) 365 goto shunt_invalid; 366 break; 367 case 160000: 368 data->gain = 4; 369 if (data->shunt < 3200) 370 goto shunt_invalid; 371 break; 372 case 320000: 373 data->gain = 8; 374 if (data->shunt < 6400) 375 goto shunt_invalid; 376 break; 377 default: 378 return dev_err_probe(dev, -EINVAL, 379 "renesas,shunt-range-microvolt invalid value %d\n", 380 val); 381 } 382 383 err = device_property_read_u32(dev, "renesas,average-samples", &val); 384 if (err == -EINVAL) 385 val = 1; 386 else if (err < 0) 387 return err; 388 if (val > 128 || hweight32(val) != 1) 389 return dev_err_probe(dev, -EINVAL, 390 "renesas,average-samples invalid value %d\n", 391 val); 392 393 data->average = val; 394 395 return 0; 396 397 shunt_invalid: 398 return dev_err_probe(dev, -EINVAL, 399 "renesas,shunt-resistor-microvolt invalid value %d\n", 400 data->shunt); 401 } 402 403 /* 404 * write configuration and calibration registers 405 * 406 * The driver supports only shunt and bus continuous ADC mode at 15bit resolution 407 * with averaging from 1 to 128 samples (pow of 2) on both channels. 408 * Shunt voltage gain 1,2,4 or 8 is allowed. 409 * The bus voltage range is 60V fixed. 410 */ 411 static int isl28022_config(struct isl28022_data *data) 412 { 413 int err; 414 u16 config; 415 u16 calib; 416 417 config = (ISL28022_MODE_CONT_SB << ISL28022_MODE_SHIFT) | 418 (ISL28022_BRNG_60 << ISL28022_BRNG_SHIFT) | 419 (__ffs(data->gain) << ISL28022_PG_SHIFT) | 420 ((ISL28022_ADC_15_1 + __ffs(data->average)) << ISL28022_SADC_SHIFT) | 421 ((ISL28022_ADC_15_1 + __ffs(data->average)) << ISL28022_BADC_SHIFT); 422 423 calib = data->shunt ? 0x8000 / data->gain : 0; 424 425 err = regmap_write(data->regmap, ISL28022_REG_CONFIG, config); 426 if (err < 0) 427 return err; 428 429 return regmap_write(data->regmap, ISL28022_REG_CALIB, calib); 430 } 431 432 static int isl28022_probe(struct i2c_client *client) 433 { 434 struct device *dev = &client->dev; 435 struct device *hwmon_dev; 436 struct isl28022_data *data; 437 int err; 438 439 if (!i2c_check_functionality(client->adapter, 440 I2C_FUNC_SMBUS_BYTE_DATA | 441 I2C_FUNC_SMBUS_WORD_DATA)) 442 return -ENODEV; 443 444 data = devm_kzalloc(dev, sizeof(struct isl28022_data), GFP_KERNEL); 445 if (!data) 446 return -ENOMEM; 447 448 err = isl28022_read_properties(dev, data); 449 if (err) 450 return err; 451 452 data->regmap = devm_regmap_init_i2c(client, &isl28022_regmap_config); 453 if (IS_ERR(data->regmap)) 454 return PTR_ERR(data->regmap); 455 456 err = isl28022_config(data); 457 if (err) 458 return err; 459 460 debugfs_create_file("shunt_voltage", 0444, client->debugfs, data, &shunt_voltage_fops); 461 462 hwmon_dev = devm_hwmon_device_register_with_info(dev, client->name, 463 data, &isl28022_chip_info, NULL); 464 if (IS_ERR(hwmon_dev)) 465 return PTR_ERR(hwmon_dev); 466 467 return 0; 468 } 469 470 static const struct i2c_device_id isl28022_ids[] = { 471 { "isl28022" }, 472 { /* LIST END */ } 473 }; 474 MODULE_DEVICE_TABLE(i2c, isl28022_ids); 475 476 static const struct of_device_id __maybe_unused isl28022_of_match[] = { 477 { .compatible = "renesas,isl28022"}, 478 { /* LIST END */ } 479 }; 480 MODULE_DEVICE_TABLE(of, isl28022_of_match); 481 482 static struct i2c_driver isl28022_driver = { 483 .class = I2C_CLASS_HWMON, 484 .driver = { 485 .name = "isl28022", 486 }, 487 .probe = isl28022_probe, 488 .id_table = isl28022_ids, 489 }; 490 module_i2c_driver(isl28022_driver); 491 492 MODULE_AUTHOR("Carsten Spieß <mail@carsten-spiess.de>"); 493 MODULE_DESCRIPTION("ISL28022 driver"); 494 MODULE_LICENSE("GPL"); 495