drivers/iio/adc/max9611.c

   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, &regval);
 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");