1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * iio/adc/max9611.c 4 * 5 * Maxim max9611/max9612 high side current sense amplifier with 6 * 12-bit ADC interface. 7 * 8 * Copyright (C) 2017 Jacopo Mondi 9 */ 10 11 /* 12 * This driver supports input common-mode voltage, current-sense 13 * amplifier with programmable gains and die temperature reading from 14 * Maxim max9611/max9612. 15 * 16 * Op-amp, analog comparator, and watchdog functionalities are not 17 * supported by this driver. 18 */ 19 20 #include <linux/delay.h> 21 #include <linux/i2c.h> 22 #include <linux/iio/iio.h> 23 #include <linux/iio/sysfs.h> 24 #include <linux/module.h> 25 #include <linux/property.h> 26 27 /* max9611 register addresses */ 28 #define MAX9611_REG_CSA_DATA 0x00 29 #define MAX9611_REG_RS_DATA 0x02 30 #define MAX9611_REG_TEMP_DATA 0x08 31 #define MAX9611_REG_CTRL1 0x0a 32 #define MAX9611_REG_CTRL2 0x0b 33 34 /* max9611 REG1 mux configuration options */ 35 #define MAX9611_MUX_MASK GENMASK(3, 0) 36 #define MAX9611_MUX_SENSE_1x 0x00 37 #define MAX9611_MUX_SENSE_4x 0x01 38 #define MAX9611_MUX_SENSE_8x 0x02 39 #define MAX9611_INPUT_VOLT 0x03 40 #define MAX9611_MUX_TEMP 0x06 41 42 /* max9611 voltage (both csa and input) helper macros */ 43 #define MAX9611_VOLTAGE_SHIFT 0x04 44 #define MAX9611_VOLTAGE_RAW(_r) ((_r) >> MAX9611_VOLTAGE_SHIFT) 45 46 /* 47 * max9611 current sense amplifier voltage output: 48 * LSB and offset values depends on selected gain (1x, 4x, 8x) 49 * 50 * GAIN LSB (nV) OFFSET (LSB steps) 51 * 1x 107500 1 52 * 4x 26880 1 53 * 8x 13440 3 54 * 55 * The complete formula to calculate current sense voltage is: 56 * (((adc_read >> 4) - offset) / ((1 / LSB) * 10^-3) 57 */ 58 #define MAX9611_CSA_1X_LSB_nV 107500 59 #define MAX9611_CSA_4X_LSB_nV 26880 60 #define MAX9611_CSA_8X_LSB_nV 13440 61 62 #define MAX9611_CSA_1X_OFFS_RAW 1 63 #define MAX9611_CSA_4X_OFFS_RAW 1 64 #define MAX9611_CSA_8X_OFFS_RAW 3 65 66 /* 67 * max9611 common input mode (CIM): LSB is 14mV, with 14mV offset at 25 C 68 * 69 * The complete formula to calculate input common voltage is: 70 * (((adc_read >> 4) * 1000) - offset) / (1 / 14 * 1000) 71 */ 72 #define MAX9611_CIM_LSB_mV 14 73 #define MAX9611_CIM_OFFSET_RAW 1 74 75 /* 76 * max9611 temperature reading: LSB is 480 milli degrees Celsius 77 * 78 * The complete formula to calculate temperature is: 79 * ((adc_read >> 7) * 1000) / (1 / 480 * 1000) 80 */ 81 #define MAX9611_TEMP_MAX_POS 0x7f80 82 #define MAX9611_TEMP_MAX_NEG 0xff80 83 #define MAX9611_TEMP_MIN_NEG 0xd980 84 #define MAX9611_TEMP_MASK GENMASK(15, 7) 85 #define MAX9611_TEMP_SHIFT 0x07 86 #define MAX9611_TEMP_RAW(_r) ((_r) >> MAX9611_TEMP_SHIFT) 87 #define MAX9611_TEMP_SCALE_NUM 1000000 88 #define MAX9611_TEMP_SCALE_DIV 2083 89 90 /* 91 * Conversion time is 2 ms (typically) at Ta=25 degreeC 92 * No maximum value is known, so play it safe. 93 */ 94 #define MAX9611_CONV_TIME_US_RANGE 3000, 3300 95 96 struct max9611_dev { 97 struct device *dev; 98 struct i2c_client *i2c_client; 99 struct mutex lock; 100 unsigned int shunt_resistor_uohm; 101 }; 102 103 enum max9611_conf_ids { 104 CONF_SENSE_1x, 105 CONF_SENSE_4x, 106 CONF_SENSE_8x, 107 CONF_IN_VOLT, 108 CONF_TEMP, 109 }; 110 111 /* 112 * max9611_mux_conf - associate ADC mux configuration with register address 113 * where data shall be read from 114 */ 115 static const unsigned int max9611_mux_conf[][2] = { 116 [CONF_SENSE_1x] = { MAX9611_MUX_SENSE_1x, MAX9611_REG_CSA_DATA }, 117 [CONF_SENSE_4x] = { MAX9611_MUX_SENSE_4x, MAX9611_REG_CSA_DATA }, 118 [CONF_SENSE_8x] = { MAX9611_MUX_SENSE_8x, MAX9611_REG_CSA_DATA }, 119 [CONF_IN_VOLT] = { MAX9611_INPUT_VOLT, MAX9611_REG_RS_DATA }, 120 [CONF_TEMP] = { MAX9611_MUX_TEMP, MAX9611_REG_TEMP_DATA }, 121 }; 122 123 enum max9611_csa_gain { 124 CSA_GAIN_1x = CONF_SENSE_1x, 125 CSA_GAIN_4x = CONF_SENSE_4x, 126 CSA_GAIN_8x = CONF_SENSE_8x, 127 }; 128 129 enum max9611_csa_gain_params { 130 CSA_GAIN_LSB_nV, 131 CSA_GAIN_OFFS_RAW, 132 }; 133 134 /* 135 * max9611_csa_gain_conf - associate gain multiplier with LSB and 136 * offset values. 137 * 138 * Group together parameters associated with configurable gain 139 * on current sense amplifier path to ADC interface. 140 * Current sense read routine adjusts gain until it gets a meaningful 141 * value; use this structure to retrieve the correct LSB and offset values. 142 */ 143 static const unsigned int max9611_gain_conf[][2] = { 144 [CSA_GAIN_1x] = { MAX9611_CSA_1X_LSB_nV, MAX9611_CSA_1X_OFFS_RAW, }, 145 [CSA_GAIN_4x] = { MAX9611_CSA_4X_LSB_nV, MAX9611_CSA_4X_OFFS_RAW, }, 146 [CSA_GAIN_8x] = { MAX9611_CSA_8X_LSB_nV, MAX9611_CSA_8X_OFFS_RAW, }, 147 }; 148 149 enum max9611_chan_addrs { 150 MAX9611_CHAN_VOLTAGE_INPUT, 151 MAX9611_CHAN_VOLTAGE_SENSE, 152 MAX9611_CHAN_TEMPERATURE, 153 MAX9611_CHAN_CURRENT_LOAD, 154 MAX9611_CHAN_POWER_LOAD, 155 }; 156 157 static const struct iio_chan_spec max9611_channels[] = { 158 { 159 .type = IIO_TEMP, 160 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 161 BIT(IIO_CHAN_INFO_SCALE), 162 .address = MAX9611_CHAN_TEMPERATURE, 163 }, 164 { 165 .type = IIO_VOLTAGE, 166 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED), 167 .address = MAX9611_CHAN_VOLTAGE_SENSE, 168 .indexed = 1, 169 .channel = 0, 170 }, 171 { 172 .type = IIO_VOLTAGE, 173 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 174 BIT(IIO_CHAN_INFO_SCALE) | 175 BIT(IIO_CHAN_INFO_OFFSET), 176 .address = MAX9611_CHAN_VOLTAGE_INPUT, 177 .indexed = 1, 178 .channel = 1, 179 }, 180 { 181 .type = IIO_CURRENT, 182 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED), 183 .address = MAX9611_CHAN_CURRENT_LOAD, 184 }, 185 { 186 .type = IIO_POWER, 187 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED), 188 .address = MAX9611_CHAN_POWER_LOAD 189 }, 190 }; 191 192 /** 193 * max9611_read_single() - read a single value from ADC interface 194 * 195 * Data registers are 16 bit long, spread between two 8 bit registers 196 * with consecutive addresses. 197 * Configure ADC mux first, then read register at address "reg_addr". 198 * The smbus_read_word routine asks for 16 bits and the ADC is kind enough 199 * to return values from "reg_addr" and "reg_addr + 1" consecutively. 200 * Data are transmitted with big-endian ordering: MSB arrives first. 201 * 202 * @max9611: max9611 device 203 * @selector: index for mux and register configuration 204 * @raw_val: the value returned from ADC 205 */ 206 static int max9611_read_single(struct max9611_dev *max9611, 207 enum max9611_conf_ids selector, 208 u16 *raw_val) 209 { 210 int ret; 211 212 u8 mux_conf = max9611_mux_conf[selector][0] & MAX9611_MUX_MASK; 213 u8 reg_addr = max9611_mux_conf[selector][1]; 214 215 /* 216 * Keep mutex lock held during read-write to avoid mux register 217 * (CTRL1) re-configuration. 218 */ 219 mutex_lock(&max9611->lock); 220 ret = i2c_smbus_write_byte_data(max9611->i2c_client, 221 MAX9611_REG_CTRL1, mux_conf); 222 if (ret) { 223 dev_err(max9611->dev, "i2c write byte failed: 0x%2x - 0x%2x\n", 224 MAX9611_REG_CTRL1, mux_conf); 225 mutex_unlock(&max9611->lock); 226 return ret; 227 } 228 229 /* need a delay here to make register configuration stabilize. */ 230 231 usleep_range(MAX9611_CONV_TIME_US_RANGE); 232 233 ret = i2c_smbus_read_word_swapped(max9611->i2c_client, reg_addr); 234 if (ret < 0) { 235 dev_err(max9611->dev, "i2c read word from 0x%2x failed\n", 236 reg_addr); 237 mutex_unlock(&max9611->lock); 238 return ret; 239 } 240 241 *raw_val = ret; 242 mutex_unlock(&max9611->lock); 243 244 return 0; 245 } 246 247 /** 248 * max9611_read_csa_voltage() - read current sense amplifier output voltage 249 * 250 * Current sense amplifier output voltage is read through a configurable 251 * 1x, 4x or 8x gain. 252 * Start with plain 1x gain, and adjust gain control properly until a 253 * meaningful value is read from ADC output. 254 * 255 * @max9611: max9611 device 256 * @adc_raw: raw value read from ADC output 257 * @csa_gain: gain configuration option selector 258 */ 259 static int max9611_read_csa_voltage(struct max9611_dev *max9611, 260 u16 *adc_raw, 261 enum max9611_csa_gain *csa_gain) 262 { 263 enum max9611_conf_ids gain_selectors[] = { 264 CONF_SENSE_1x, 265 CONF_SENSE_4x, 266 CONF_SENSE_8x 267 }; 268 unsigned int i; 269 int ret; 270 271 for (i = 0; i < ARRAY_SIZE(gain_selectors); ++i) { 272 ret = max9611_read_single(max9611, gain_selectors[i], adc_raw); 273 if (ret) 274 return ret; 275 276 if (*adc_raw > 0) { 277 *csa_gain = (enum max9611_csa_gain)gain_selectors[i]; 278 return 0; 279 } 280 } 281 282 return -EIO; 283 } 284 285 static int max9611_read_raw(struct iio_dev *indio_dev, 286 struct iio_chan_spec const *chan, 287 int *val, int *val2, long mask) 288 { 289 struct max9611_dev *dev = iio_priv(indio_dev); 290 enum max9611_csa_gain gain_selector; 291 const unsigned int *csa_gain; 292 u16 adc_data; 293 int ret; 294 295 switch (mask) { 296 case IIO_CHAN_INFO_RAW: 297 298 switch (chan->address) { 299 case MAX9611_CHAN_TEMPERATURE: 300 ret = max9611_read_single(dev, CONF_TEMP, 301 &adc_data); 302 if (ret) 303 return -EINVAL; 304 305 *val = MAX9611_TEMP_RAW(adc_data); 306 return IIO_VAL_INT; 307 308 case MAX9611_CHAN_VOLTAGE_INPUT: 309 ret = max9611_read_single(dev, CONF_IN_VOLT, 310 &adc_data); 311 if (ret) 312 return -EINVAL; 313 314 *val = MAX9611_VOLTAGE_RAW(adc_data); 315 return IIO_VAL_INT; 316 } 317 318 break; 319 320 case IIO_CHAN_INFO_OFFSET: 321 /* MAX9611_CHAN_VOLTAGE_INPUT */ 322 *val = MAX9611_CIM_OFFSET_RAW; 323 324 return IIO_VAL_INT; 325 326 case IIO_CHAN_INFO_SCALE: 327 328 switch (chan->address) { 329 case MAX9611_CHAN_TEMPERATURE: 330 *val = MAX9611_TEMP_SCALE_NUM; 331 *val2 = MAX9611_TEMP_SCALE_DIV; 332 333 return IIO_VAL_FRACTIONAL; 334 335 case MAX9611_CHAN_VOLTAGE_INPUT: 336 *val = MAX9611_CIM_LSB_mV; 337 338 return IIO_VAL_INT; 339 } 340 341 break; 342 343 case IIO_CHAN_INFO_PROCESSED: 344 345 switch (chan->address) { 346 case MAX9611_CHAN_VOLTAGE_SENSE: 347 /* 348 * processed (mV): (raw - offset) * LSB (nV) / 10^6 349 * 350 * Even if max9611 can output raw csa voltage readings, 351 * use a produced value as scale depends on gain. 352 */ 353 ret = max9611_read_csa_voltage(dev, &adc_data, 354 &gain_selector); 355 if (ret) 356 return -EINVAL; 357 358 csa_gain = max9611_gain_conf[gain_selector]; 359 360 adc_data -= csa_gain[CSA_GAIN_OFFS_RAW]; 361 *val = MAX9611_VOLTAGE_RAW(adc_data) * 362 csa_gain[CSA_GAIN_LSB_nV]; 363 *val2 = 1000000; 364 365 return IIO_VAL_FRACTIONAL; 366 367 case MAX9611_CHAN_CURRENT_LOAD: 368 /* processed (mA): Vcsa (nV) / Rshunt (uOhm) */ 369 ret = max9611_read_csa_voltage(dev, &adc_data, 370 &gain_selector); 371 if (ret) 372 return -EINVAL; 373 374 csa_gain = max9611_gain_conf[gain_selector]; 375 376 adc_data -= csa_gain[CSA_GAIN_OFFS_RAW]; 377 *val = MAX9611_VOLTAGE_RAW(adc_data) * 378 csa_gain[CSA_GAIN_LSB_nV]; 379 *val2 = dev->shunt_resistor_uohm; 380 381 return IIO_VAL_FRACTIONAL; 382 383 case MAX9611_CHAN_POWER_LOAD: 384 /* 385 * processed (mW): Vin (mV) * Vcsa (uV) / 386 * Rshunt (uOhm) 387 */ 388 ret = max9611_read_single(dev, CONF_IN_VOLT, 389 &adc_data); 390 if (ret) 391 return -EINVAL; 392 393 adc_data -= MAX9611_CIM_OFFSET_RAW; 394 *val = MAX9611_VOLTAGE_RAW(adc_data) * 395 MAX9611_CIM_LSB_mV; 396 397 ret = max9611_read_csa_voltage(dev, &adc_data, 398 &gain_selector); 399 if (ret) 400 return -EINVAL; 401 402 csa_gain = max9611_gain_conf[gain_selector]; 403 404 /* divide by 10^3 here to avoid 32bit overflow */ 405 adc_data -= csa_gain[CSA_GAIN_OFFS_RAW]; 406 *val *= MAX9611_VOLTAGE_RAW(adc_data) * 407 csa_gain[CSA_GAIN_LSB_nV] / 1000; 408 *val2 = dev->shunt_resistor_uohm; 409 410 return IIO_VAL_FRACTIONAL; 411 } 412 413 break; 414 } 415 416 return -EINVAL; 417 } 418 419 static ssize_t max9611_shunt_resistor_show(struct device *dev, 420 struct device_attribute *attr, 421 char *buf) 422 { 423 struct max9611_dev *max9611 = iio_priv(dev_to_iio_dev(dev)); 424 unsigned int i, r; 425 426 i = max9611->shunt_resistor_uohm / 1000000; 427 r = max9611->shunt_resistor_uohm % 1000000; 428 429 return sysfs_emit(buf, "%u.%06u\n", i, r); 430 } 431 432 static IIO_DEVICE_ATTR(in_power_shunt_resistor, 0444, 433 max9611_shunt_resistor_show, NULL, 0); 434 static IIO_DEVICE_ATTR(in_current_shunt_resistor, 0444, 435 max9611_shunt_resistor_show, NULL, 0); 436 437 static struct attribute *max9611_attributes[] = { 438 &iio_dev_attr_in_power_shunt_resistor.dev_attr.attr, 439 &iio_dev_attr_in_current_shunt_resistor.dev_attr.attr, 440 NULL, 441 }; 442 443 static const struct attribute_group max9611_attribute_group = { 444 .attrs = max9611_attributes, 445 }; 446 447 static const struct iio_info indio_info = { 448 .read_raw = max9611_read_raw, 449 .attrs = &max9611_attribute_group, 450 }; 451 452 static int max9611_init(struct max9611_dev *max9611) 453 { 454 struct i2c_client *client = max9611->i2c_client; 455 u16 regval; 456 int ret; 457 458 if (!i2c_check_functionality(client->adapter, 459 I2C_FUNC_SMBUS_WRITE_BYTE | 460 I2C_FUNC_SMBUS_READ_WORD_DATA)) { 461 dev_err(max9611->dev, 462 "I2c adapter does not support smbus write_byte or read_word functionalities: aborting probe.\n"); 463 return -EINVAL; 464 } 465 466 /* Make sure die temperature is in range to test communications. */ 467 ret = max9611_read_single(max9611, CONF_TEMP, ®val); 468 if (ret) 469 return ret; 470 471 regval &= MAX9611_TEMP_MASK; 472 473 if ((regval > MAX9611_TEMP_MAX_POS && 474 regval < MAX9611_TEMP_MIN_NEG) || 475 regval > MAX9611_TEMP_MAX_NEG) { 476 dev_err(max9611->dev, 477 "Invalid value received from ADC 0x%4x: aborting\n", 478 regval); 479 return -EIO; 480 } 481 482 /* Mux shall be zeroed back before applying other configurations */ 483 ret = i2c_smbus_write_byte_data(max9611->i2c_client, 484 MAX9611_REG_CTRL1, 0); 485 if (ret) { 486 dev_err(max9611->dev, "i2c write byte failed: 0x%2x - 0x%2x\n", 487 MAX9611_REG_CTRL1, 0); 488 return ret; 489 } 490 491 ret = i2c_smbus_write_byte_data(max9611->i2c_client, 492 MAX9611_REG_CTRL2, 0); 493 if (ret) { 494 dev_err(max9611->dev, "i2c write byte failed: 0x%2x - 0x%2x\n", 495 MAX9611_REG_CTRL2, 0); 496 return ret; 497 } 498 usleep_range(MAX9611_CONV_TIME_US_RANGE); 499 500 return 0; 501 } 502 503 static const struct of_device_id max9611_of_table[] = { 504 { .compatible = "maxim,max9611", .data = "max9611" }, 505 { .compatible = "maxim,max9612", .data = "max9612" }, 506 { } 507 }; 508 509 MODULE_DEVICE_TABLE(of, max9611_of_table); 510 static int max9611_probe(struct i2c_client *client) 511 { 512 const char * const shunt_res_prop = "shunt-resistor-micro-ohms"; 513 struct max9611_dev *max9611; 514 struct iio_dev *indio_dev; 515 struct device *dev = &client->dev; 516 unsigned int of_shunt; 517 int ret; 518 519 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*max9611)); 520 if (!indio_dev) 521 return -ENOMEM; 522 523 i2c_set_clientdata(client, indio_dev); 524 525 max9611 = iio_priv(indio_dev); 526 max9611->dev = dev; 527 max9611->i2c_client = client; 528 mutex_init(&max9611->lock); 529 530 ret = device_property_read_u32(dev, shunt_res_prop, &of_shunt); 531 if (ret) { 532 dev_err(dev, "Missing %s property for %pfw node\n", 533 shunt_res_prop, dev_fwnode(dev)); 534 return ret; 535 } 536 max9611->shunt_resistor_uohm = of_shunt; 537 538 ret = max9611_init(max9611); 539 if (ret) 540 return ret; 541 542 indio_dev->name = device_get_match_data(dev); 543 indio_dev->modes = INDIO_DIRECT_MODE; 544 indio_dev->info = &indio_info; 545 indio_dev->channels = max9611_channels; 546 indio_dev->num_channels = ARRAY_SIZE(max9611_channels); 547 548 return devm_iio_device_register(dev, indio_dev); 549 } 550 551 static struct i2c_driver max9611_driver = { 552 .driver = { 553 .name = "max9611", 554 .of_match_table = max9611_of_table, 555 }, 556 .probe = max9611_probe, 557 }; 558 module_i2c_driver(max9611_driver); 559 560 MODULE_AUTHOR("Jacopo Mondi <jacopo+renesas@jmondi.org>"); 561 MODULE_DESCRIPTION("Maxim max9611/12 current sense amplifier with 12bit ADC"); 562 MODULE_LICENSE("GPL v2"); 563