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