drivers/iio/adc/max9611.c

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