drivers/iio/adc/qcom-spmi-vadc.c

   1 /*
   2  * Copyright (c) 2012-2016, The Linux Foundation. All rights reserved.
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License version 2 and
   6  * only version 2 as published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  */
  13
  14 #include <linux/bitops.h>
  15 #include <linux/completion.h>
  16 #include <linux/delay.h>
  17 #include <linux/err.h>
  18 #include <linux/iio/iio.h>
  19 #include <linux/interrupt.h>
  20 #include <linux/kernel.h>
  21 #include <linux/math64.h>
  22 #include <linux/module.h>
  23 #include <linux/of.h>
  24 #include <linux/platform_device.h>
  25 #include <linux/regmap.h>
  26 #include <linux/slab.h>
  27 #include <linux/log2.h>
  28
  29 #include <dt-bindings/iio/qcom,spmi-vadc.h>
  30
  31 /* VADC register and bit definitions */
  32 #define VADC_REVISION2                          0x1
  33 #define VADC_REVISION2_SUPPORTED_VADC           1
  34
  35 #define VADC_PERPH_TYPE                         0x4
  36 #define VADC_PERPH_TYPE_ADC                     8
  37
  38 #define VADC_PERPH_SUBTYPE                      0x5
  39 #define VADC_PERPH_SUBTYPE_VADC                 1
  40
  41 #define VADC_STATUS1                            0x8
  42 #define VADC_STATUS1_OP_MODE                    4
  43 #define VADC_STATUS1_REQ_STS                    BIT(1)
  44 #define VADC_STATUS1_EOC                        BIT(0)
  45 #define VADC_STATUS1_REQ_STS_EOC_MASK           0x3
  46
  47 #define VADC_MODE_CTL                           0x40
  48 #define VADC_OP_MODE_SHIFT                      3
  49 #define VADC_OP_MODE_NORMAL                     0
  50 #define VADC_AMUX_TRIM_EN                       BIT(1)
  51 #define VADC_ADC_TRIM_EN                        BIT(0)
  52
  53 #define VADC_EN_CTL1                            0x46
  54 #define VADC_EN_CTL1_SET                        BIT(7)
  55
  56 #define VADC_ADC_CH_SEL_CTL                     0x48
  57
  58 #define VADC_ADC_DIG_PARAM                      0x50
  59 #define VADC_ADC_DIG_DEC_RATIO_SEL_SHIFT        2
  60
  61 #define VADC_HW_SETTLE_DELAY                    0x51
  62
  63 #define VADC_CONV_REQ                           0x52
  64 #define VADC_CONV_REQ_SET                       BIT(7)
  65
  66 #define VADC_FAST_AVG_CTL                       0x5a
  67 #define VADC_FAST_AVG_EN                        0x5b
  68 #define VADC_FAST_AVG_EN_SET                    BIT(7)
  69
  70 #define VADC_ACCESS                             0xd0
  71 #define VADC_ACCESS_DATA                        0xa5
  72
  73 #define VADC_PERH_RESET_CTL3                    0xda
  74 #define VADC_FOLLOW_WARM_RB                     BIT(2)
  75
  76 #define VADC_DATA                               0x60    /* 16 bits */
  77
  78 #define VADC_CONV_TIME_MIN_US                   2000
  79 #define VADC_CONV_TIME_MAX_US                   2100
  80
  81 /* Min ADC code represents 0V */
  82 #define VADC_MIN_ADC_CODE                       0x6000
  83 /* Max ADC code represents full-scale range of 1.8V */
  84 #define VADC_MAX_ADC_CODE                       0xa800
  85
  86 #define VADC_ABSOLUTE_RANGE_UV                  625000
  87 #define VADC_RATIOMETRIC_RANGE                  1800
  88
  89 #define VADC_DEF_PRESCALING                     0 /* 1:1 */
  90 #define VADC_DEF_DECIMATION                     0 /* 512 */
  91 #define VADC_DEF_HW_SETTLE_TIME                 0 /* 0 us */
  92 #define VADC_DEF_AVG_SAMPLES                    0 /* 1 sample */
  93 #define VADC_DEF_CALIB_TYPE                     VADC_CALIB_ABSOLUTE
  94
  95 #define VADC_DECIMATION_MIN                     512
  96 #define VADC_DECIMATION_MAX                     4096
  97
  98 #define VADC_HW_SETTLE_DELAY_MAX                10000
  99 #define VADC_AVG_SAMPLES_MAX                    512
 100
 101 #define KELVINMIL_CELSIUSMIL                    273150
 102
 103 #define PMI_CHG_SCALE_1                         -138890
 104 #define PMI_CHG_SCALE_2                         391750000000LL
 105
 106 #define VADC_CHAN_MIN                   VADC_USBIN
 107 #define VADC_CHAN_MAX                   VADC_LR_MUX3_BUF_PU1_PU2_XO_THERM
 108
 109 /**
 110  * struct vadc_map_pt - Map the graph representation for ADC channel
 111  * @x: Represent the ADC digitized code.
 112  * @y: Represent the physical data which can be temperature, voltage,
 113  *     resistance.
 114  */
 115 struct vadc_map_pt {
 116         s32 x;
 117         s32 y;
 118 };
 119
 120 /*
 121  * VADC_CALIB_ABSOLUTE: uses the 625mV and 1.25V as reference channels.
 122  * VADC_CALIB_RATIOMETRIC: uses the reference voltage (1.8V) and GND for
 123  * calibration.
 124  */
 125 enum vadc_calibration {
 126         VADC_CALIB_ABSOLUTE = 0,
 127         VADC_CALIB_RATIOMETRIC
 128 };
 129
 130 /**
 131  * struct vadc_linear_graph - Represent ADC characteristics.
 132  * @dy: numerator slope to calculate the gain.
 133  * @dx: denominator slope to calculate the gain.
 134  * @gnd: A/D word of the ground reference used for the channel.
 135  *
 136  * Each ADC device has different offset and gain parameters which are
 137  * computed to calibrate the device.
 138  */
 139 struct vadc_linear_graph {
 140         s32 dy;
 141         s32 dx;
 142         s32 gnd;
 143 };
 144
 145 /**
 146  * struct vadc_prescale_ratio - Represent scaling ratio for ADC input.
 147  * @num: the inverse numerator of the gain applied to the input channel.
 148  * @den: the inverse denominator of the gain applied to the input channel.
 149  */
 150 struct vadc_prescale_ratio {
 151         u32 num;
 152         u32 den;
 153 };
 154
 155 /**
 156  * struct vadc_channel_prop - VADC channel property.
 157  * @channel: channel number, refer to the channel list.
 158  * @calibration: calibration type.
 159  * @decimation: sampling rate supported for the channel.
 160  * @prescale: channel scaling performed on the input signal.
 161  * @hw_settle_time: the time between AMUX being configured and the
 162  *      start of conversion.
 163  * @avg_samples: ability to provide single result from the ADC
 164  *      that is an average of multiple measurements.
 165  * @scale_fn: Represents the scaling function to convert voltage
 166  *      physical units desired by the client for the channel.
 167  *      Referenced from enum vadc_scale_fn_type.
 168  */
 169 struct vadc_channel_prop {
 170         unsigned int channel;
 171         enum vadc_calibration calibration;
 172         unsigned int decimation;
 173         unsigned int prescale;
 174         unsigned int hw_settle_time;
 175         unsigned int avg_samples;
 176         unsigned int scale_fn;
 177 };
 178
 179 /**
 180  * struct vadc_priv - VADC private structure.
 181  * @regmap: pointer to struct regmap.
 182  * @dev: pointer to struct device.
 183  * @base: base address for the ADC peripheral.
 184  * @nchannels: number of VADC channels.
 185  * @chan_props: array of VADC channel properties.
 186  * @iio_chans: array of IIO channels specification.
 187  * @are_ref_measured: are reference points measured.
 188  * @poll_eoc: use polling instead of interrupt.
 189  * @complete: VADC result notification after interrupt is received.
 190  * @graph: store parameters for calibration.
 191  * @lock: ADC lock for access to the peripheral.
 192  */
 193 struct vadc_priv {
 194         struct regmap            *regmap;
 195         struct device            *dev;
 196         u16                      base;
 197         unsigned int             nchannels;
 198         struct vadc_channel_prop *chan_props;
 199         struct iio_chan_spec     *iio_chans;
 200         bool                     are_ref_measured;
 201         bool                     poll_eoc;
 202         struct completion        complete;
 203         struct vadc_linear_graph graph[2];
 204         struct mutex             lock;
 205 };
 206
 207 /**
 208  * struct vadc_scale_fn - Scaling function prototype
 209  * @scale: Function pointer to one of the scaling functions
 210  *      which takes the adc properties, channel properties,
 211  *      and returns the physical result.
 212  */
 213 struct vadc_scale_fn {
 214         int (*scale)(struct vadc_priv *, const struct vadc_channel_prop *,
 215                      u16, int *);
 216 };
 217
 218 /**
 219  * enum vadc_scale_fn_type - Scaling function to convert ADC code to
 220  *                              physical scaled units for the channel.
 221  * SCALE_DEFAULT: Default scaling to convert raw adc code to voltage (uV).
 222  * SCALE_THERM_100K_PULLUP: Returns temperature in millidegC.
 223  *                               Uses a mapping table with 100K pullup.
 224  * SCALE_PMIC_THERM: Returns result in milli degree's Centigrade.
 225  * SCALE_XOTHERM: Returns XO thermistor voltage in millidegC.
 226  * SCALE_PMI_CHG_TEMP: Conversion for PMI CHG temp
 227  */
 228 enum vadc_scale_fn_type {
 229         SCALE_DEFAULT = 0,
 230         SCALE_THERM_100K_PULLUP,
 231         SCALE_PMIC_THERM,
 232         SCALE_XOTHERM,
 233         SCALE_PMI_CHG_TEMP,
 234 };
 235
 236 static const struct vadc_prescale_ratio vadc_prescale_ratios[] = {
 237         {.num =  1, .den =  1},
 238         {.num =  1, .den =  3},
 239         {.num =  1, .den =  4},
 240         {.num =  1, .den =  6},
 241         {.num =  1, .den = 20},
 242         {.num =  1, .den =  8},
 243         {.num = 10, .den = 81},
 244         {.num =  1, .den = 10}
 245 };
 246
 247 /* Voltage to temperature */
 248 static const struct vadc_map_pt adcmap_100k_104ef_104fb[] = {
 249         {1758,  -40},
 250         {1742,  -35},
 251         {1719,  -30},
 252         {1691,  -25},
 253         {1654,  -20},
 254         {1608,  -15},
 255         {1551,  -10},
 256         {1483,  -5},
 257         {1404,  0},
 258         {1315,  5},
 259         {1218,  10},
 260         {1114,  15},
 261         {1007,  20},
 262         {900,   25},
 263         {795,   30},
 264         {696,   35},
 265         {605,   40},
 266         {522,   45},
 267         {448,   50},
 268         {383,   55},
 269         {327,   60},
 270         {278,   65},
 271         {237,   70},
 272         {202,   75},
 273         {172,   80},
 274         {146,   85},
 275         {125,   90},
 276         {107,   95},
 277         {92,    100},
 278         {79,    105},
 279         {68,    110},
 280         {59,    115},
 281         {51,    120},
 282         {44,    125}
 283 };
 284
 285 static int vadc_read(struct vadc_priv *vadc, u16 offset, u8 *data)
 286 {
 287         return regmap_bulk_read(vadc->regmap, vadc->base + offset, data, 1);
 288 }
 289
 290 static int vadc_write(struct vadc_priv *vadc, u16 offset, u8 data)
 291 {
 292         return regmap_write(vadc->regmap, vadc->base + offset, data);
 293 }
 294
 295 static int vadc_reset(struct vadc_priv *vadc)
 296 {
 297         u8 data;
 298         int ret;
 299
 300         ret = vadc_write(vadc, VADC_ACCESS, VADC_ACCESS_DATA);
 301         if (ret)
 302                 return ret;
 303
 304         ret = vadc_read(vadc, VADC_PERH_RESET_CTL3, &data);
 305         if (ret)
 306                 return ret;
 307
 308         ret = vadc_write(vadc, VADC_ACCESS, VADC_ACCESS_DATA);
 309         if (ret)
 310                 return ret;
 311
 312         data |= VADC_FOLLOW_WARM_RB;
 313
 314         return vadc_write(vadc, VADC_PERH_RESET_CTL3, data);
 315 }
 316
 317 static int vadc_set_state(struct vadc_priv *vadc, bool state)
 318 {
 319         return vadc_write(vadc, VADC_EN_CTL1, state ? VADC_EN_CTL1_SET : 0);
 320 }
 321
 322 static void vadc_show_status(struct vadc_priv *vadc)
 323 {
 324         u8 mode, sta1, chan, dig, en, req;
 325         int ret;
 326
 327         ret = vadc_read(vadc, VADC_MODE_CTL, &mode);
 328         if (ret)
 329                 return;
 330
 331         ret = vadc_read(vadc, VADC_ADC_DIG_PARAM, &dig);
 332         if (ret)
 333                 return;
 334
 335         ret = vadc_read(vadc, VADC_ADC_CH_SEL_CTL, &chan);
 336         if (ret)
 337                 return;
 338
 339         ret = vadc_read(vadc, VADC_CONV_REQ, &req);
 340         if (ret)
 341                 return;
 342
 343         ret = vadc_read(vadc, VADC_STATUS1, &sta1);
 344         if (ret)
 345                 return;
 346
 347         ret = vadc_read(vadc, VADC_EN_CTL1, &en);
 348         if (ret)
 349                 return;
 350
 351         dev_err(vadc->dev,
 352                 "mode:%02x en:%02x chan:%02x dig:%02x req:%02x sta1:%02x\n",
 353                 mode, en, chan, dig, req, sta1);
 354 }
 355
 356 static int vadc_configure(struct vadc_priv *vadc,
 357                           struct vadc_channel_prop *prop)
 358 {
 359         u8 decimation, mode_ctrl;
 360         int ret;
 361
 362         /* Mode selection */
 363         mode_ctrl = (VADC_OP_MODE_NORMAL << VADC_OP_MODE_SHIFT) |
 364                      VADC_ADC_TRIM_EN | VADC_AMUX_TRIM_EN;
 365         ret = vadc_write(vadc, VADC_MODE_CTL, mode_ctrl);
 366         if (ret)
 367                 return ret;
 368
 369         /* Channel selection */
 370         ret = vadc_write(vadc, VADC_ADC_CH_SEL_CTL, prop->channel);
 371         if (ret)
 372                 return ret;
 373
 374         /* Digital parameter setup */
 375         decimation = prop->decimation << VADC_ADC_DIG_DEC_RATIO_SEL_SHIFT;
 376         ret = vadc_write(vadc, VADC_ADC_DIG_PARAM, decimation);
 377         if (ret)
 378                 return ret;
 379
 380         /* HW settle time delay */
 381         ret = vadc_write(vadc, VADC_HW_SETTLE_DELAY, prop->hw_settle_time);
 382         if (ret)
 383                 return ret;
 384
 385         ret = vadc_write(vadc, VADC_FAST_AVG_CTL, prop->avg_samples);
 386         if (ret)
 387                 return ret;
 388
 389         if (prop->avg_samples)
 390                 ret = vadc_write(vadc, VADC_FAST_AVG_EN, VADC_FAST_AVG_EN_SET);
 391         else
 392                 ret = vadc_write(vadc, VADC_FAST_AVG_EN, 0);
 393
 394         return ret;
 395 }
 396
 397 static int vadc_poll_wait_eoc(struct vadc_priv *vadc, unsigned int interval_us)
 398 {
 399         unsigned int count, retry;
 400         u8 sta1;
 401         int ret;
 402
 403         retry = interval_us / VADC_CONV_TIME_MIN_US;
 404
 405         for (count = 0; count < retry; count++) {
 406                 ret = vadc_read(vadc, VADC_STATUS1, &sta1);
 407                 if (ret)
 408                         return ret;
 409
 410                 sta1 &= VADC_STATUS1_REQ_STS_EOC_MASK;
 411                 if (sta1 == VADC_STATUS1_EOC)
 412                         return 0;
 413
 414                 usleep_range(VADC_CONV_TIME_MIN_US, VADC_CONV_TIME_MAX_US);
 415         }
 416
 417         vadc_show_status(vadc);
 418
 419         return -ETIMEDOUT;
 420 }
 421
 422 static int vadc_read_result(struct vadc_priv *vadc, u16 *data)
 423 {
 424         int ret;
 425
 426         ret = regmap_bulk_read(vadc->regmap, vadc->base + VADC_DATA, data, 2);
 427         if (ret)
 428                 return ret;
 429
 430         *data = clamp_t(u16, *data, VADC_MIN_ADC_CODE, VADC_MAX_ADC_CODE);
 431
 432         return 0;
 433 }
 434
 435 static struct vadc_channel_prop *vadc_get_channel(struct vadc_priv *vadc,
 436                                                   unsigned int num)
 437 {
 438         unsigned int i;
 439
 440         for (i = 0; i < vadc->nchannels; i++)
 441                 if (vadc->chan_props[i].channel == num)
 442                         return &vadc->chan_props[i];
 443
 444         dev_dbg(vadc->dev, "no such channel %02x\n", num);
 445
 446         return NULL;
 447 }
 448
 449 static int vadc_do_conversion(struct vadc_priv *vadc,
 450                               struct vadc_channel_prop *prop, u16 *data)
 451 {
 452         unsigned int timeout;
 453         int ret;
 454
 455         mutex_lock(&vadc->lock);
 456
 457         ret = vadc_configure(vadc, prop);
 458         if (ret)
 459                 goto unlock;
 460
 461         if (!vadc->poll_eoc)
 462                 reinit_completion(&vadc->complete);
 463
 464         ret = vadc_set_state(vadc, true);
 465         if (ret)
 466                 goto unlock;
 467
 468         ret = vadc_write(vadc, VADC_CONV_REQ, VADC_CONV_REQ_SET);
 469         if (ret)
 470                 goto err_disable;
 471
 472         timeout = BIT(prop->avg_samples) * VADC_CONV_TIME_MIN_US * 2;
 473
 474         if (vadc->poll_eoc) {
 475                 ret = vadc_poll_wait_eoc(vadc, timeout);
 476         } else {
 477                 ret = wait_for_completion_timeout(&vadc->complete, timeout);
 478                 if (!ret) {
 479                         ret = -ETIMEDOUT;
 480                         goto err_disable;
 481                 }
 482
 483                 /* Double check conversion status */
 484                 ret = vadc_poll_wait_eoc(vadc, VADC_CONV_TIME_MIN_US);
 485                 if (ret)
 486                         goto err_disable;
 487         }
 488
 489         ret = vadc_read_result(vadc, data);
 490
 491 err_disable:
 492         vadc_set_state(vadc, false);
 493         if (ret)
 494                 dev_err(vadc->dev, "conversion failed\n");
 495 unlock:
 496         mutex_unlock(&vadc->lock);
 497         return ret;
 498 }
 499
 500 static int vadc_measure_ref_points(struct vadc_priv *vadc)
 501 {
 502         struct vadc_channel_prop *prop;
 503         u16 read_1, read_2;
 504         int ret;
 505
 506         vadc->graph[VADC_CALIB_RATIOMETRIC].dx = VADC_RATIOMETRIC_RANGE;
 507         vadc->graph[VADC_CALIB_ABSOLUTE].dx = VADC_ABSOLUTE_RANGE_UV;
 508
 509         prop = vadc_get_channel(vadc, VADC_REF_1250MV);
 510         ret = vadc_do_conversion(vadc, prop, &read_1);
 511         if (ret)
 512                 goto err;
 513
 514         /* Try with buffered 625mV channel first */
 515         prop = vadc_get_channel(vadc, VADC_SPARE1);
 516         if (!prop)
 517                 prop = vadc_get_channel(vadc, VADC_REF_625MV);
 518
 519         ret = vadc_do_conversion(vadc, prop, &read_2);
 520         if (ret)
 521                 goto err;
 522
 523         if (read_1 == read_2) {
 524                 ret = -EINVAL;
 525                 goto err;
 526         }
 527
 528         vadc->graph[VADC_CALIB_ABSOLUTE].dy = read_1 - read_2;
 529         vadc->graph[VADC_CALIB_ABSOLUTE].gnd = read_2;
 530
 531         /* Ratiometric calibration */
 532         prop = vadc_get_channel(vadc, VADC_VDD_VADC);
 533         ret = vadc_do_conversion(vadc, prop, &read_1);
 534         if (ret)
 535                 goto err;
 536
 537         prop = vadc_get_channel(vadc, VADC_GND_REF);
 538         ret = vadc_do_conversion(vadc, prop, &read_2);
 539         if (ret)
 540                 goto err;
 541
 542         if (read_1 == read_2) {
 543                 ret = -EINVAL;
 544                 goto err;
 545         }
 546
 547         vadc->graph[VADC_CALIB_RATIOMETRIC].dy = read_1 - read_2;
 548         vadc->graph[VADC_CALIB_RATIOMETRIC].gnd = read_2;
 549 err:
 550         if (ret)
 551                 dev_err(vadc->dev, "measure reference points failed\n");
 552
 553         return ret;
 554 }
 555
 556 static int vadc_map_voltage_temp(const struct vadc_map_pt *pts,
 557                                  u32 tablesize, s32 input, s64 *output)
 558 {
 559         bool descending = 1;
 560         u32 i = 0;
 561
 562         if (!pts)
 563                 return -EINVAL;
 564
 565         /* Check if table is descending or ascending */
 566         if (tablesize > 1) {
 567                 if (pts[0].x < pts[1].x)
 568                         descending = 0;
 569         }
 570
 571         while (i < tablesize) {
 572                 if ((descending) && (pts[i].x < input)) {
 573                         /* table entry is less than measured*/
 574                          /* value and table is descending, stop */
 575                         break;
 576                 } else if ((!descending) &&
 577                                 (pts[i].x > input)) {
 578                         /* table entry is greater than measured*/
 579                         /*value and table is ascending, stop */
 580                         break;
 581                 }
 582                 i++;
 583         }
 584
 585         if (i == 0) {
 586                 *output = pts[0].y;
 587         } else if (i == tablesize) {
 588                 *output = pts[tablesize - 1].y;
 589         } else {
 590                 /* result is between search_index and search_index-1 */
 591                 /* interpolate linearly */
 592                 *output = (((s32)((pts[i].y - pts[i - 1].y) *
 593                         (input - pts[i - 1].x)) /
 594                         (pts[i].x - pts[i - 1].x)) +
 595                         pts[i - 1].y);
 596         }
 597
 598         return 0;
 599 }
 600
 601 static void vadc_scale_calib(struct vadc_priv *vadc, u16 adc_code,
 602                              const struct vadc_channel_prop *prop,
 603                              s64 *scale_voltage)
 604 {
 605         *scale_voltage = (adc_code -
 606                 vadc->graph[prop->calibration].gnd);
 607         *scale_voltage *= vadc->graph[prop->calibration].dx;
 608         *scale_voltage = div64_s64(*scale_voltage,
 609                 vadc->graph[prop->calibration].dy);
 610         if (prop->calibration == VADC_CALIB_ABSOLUTE)
 611                 *scale_voltage +=
 612                 vadc->graph[prop->calibration].dx;
 613
 614         if (*scale_voltage < 0)
 615                 *scale_voltage = 0;
 616 }
 617
 618 static int vadc_scale_volt(struct vadc_priv *vadc,
 619                            const struct vadc_channel_prop *prop, u16 adc_code,
 620                            int *result_uv)
 621 {
 622         const struct vadc_prescale_ratio *prescale;
 623         s64 voltage = 0, result = 0;
 624
 625         vadc_scale_calib(vadc, adc_code, prop, &voltage);
 626
 627         prescale = &vadc_prescale_ratios[prop->prescale];
 628         voltage = voltage * prescale->den;
 629         result = div64_s64(voltage, prescale->num);
 630         *result_uv = result;
 631
 632         return 0;
 633 }
 634
 635 static int vadc_scale_therm(struct vadc_priv *vadc,
 636                             const struct vadc_channel_prop *prop, u16 adc_code,
 637                             int *result_mdec)
 638 {
 639         s64 voltage = 0, result = 0;
 640
 641         vadc_scale_calib(vadc, adc_code, prop, &voltage);
 642
 643         if (prop->calibration == VADC_CALIB_ABSOLUTE)
 644                 voltage = div64_s64(voltage, 1000);
 645
 646         vadc_map_voltage_temp(adcmap_100k_104ef_104fb,
 647                               ARRAY_SIZE(adcmap_100k_104ef_104fb),
 648                               voltage, &result);
 649         result *= 1000;
 650         *result_mdec = result;
 651
 652         return 0;
 653 }
 654
 655 static int vadc_scale_die_temp(struct vadc_priv *vadc,
 656                                const struct vadc_channel_prop *prop,
 657                                u16 adc_code, int *result_mdec)
 658 {
 659         const struct vadc_prescale_ratio *prescale;
 660         s64 voltage = 0;
 661         u64 temp; /* Temporary variable for do_div */
 662
 663         vadc_scale_calib(vadc, adc_code, prop, &voltage);
 664
 665         if (voltage > 0) {
 666                 prescale = &vadc_prescale_ratios[prop->prescale];
 667                 temp = voltage * prescale->den;
 668                 do_div(temp, prescale->num * 2);
 669                 voltage = temp;
 670         } else {
 671                 voltage = 0;
 672         }
 673
 674         voltage -= KELVINMIL_CELSIUSMIL;
 675         *result_mdec = voltage;
 676
 677         return 0;
 678 }
 679
 680 static int vadc_scale_chg_temp(struct vadc_priv *vadc,
 681                                const struct vadc_channel_prop *prop,
 682                                u16 adc_code, int *result_mdec)
 683 {
 684         const struct vadc_prescale_ratio *prescale;
 685         s64 voltage = 0, result = 0;
 686
 687         vadc_scale_calib(vadc, adc_code, prop, &voltage);
 688
 689         prescale = &vadc_prescale_ratios[prop->prescale];
 690         voltage = voltage * prescale->den;
 691         voltage = div64_s64(voltage, prescale->num);
 692         voltage = ((PMI_CHG_SCALE_1) * (voltage * 2));
 693         voltage = (voltage + PMI_CHG_SCALE_2);
 694         result =  div64_s64(voltage, 1000000);
 695         *result_mdec = result;
 696
 697         return 0;
 698 }
 699
 700 static int vadc_decimation_from_dt(u32 value)
 701 {
 702         if (!is_power_of_2(value) || value < VADC_DECIMATION_MIN ||
 703             value > VADC_DECIMATION_MAX)
 704                 return -EINVAL;
 705
 706         return __ffs64(value / VADC_DECIMATION_MIN);
 707 }
 708
 709 static int vadc_prescaling_from_dt(u32 num, u32 den)
 710 {
 711         unsigned int pre;
 712
 713         for (pre = 0; pre < ARRAY_SIZE(vadc_prescale_ratios); pre++)
 714                 if (vadc_prescale_ratios[pre].num == num &&
 715                     vadc_prescale_ratios[pre].den == den)
 716                         break;
 717
 718         if (pre == ARRAY_SIZE(vadc_prescale_ratios))
 719                 return -EINVAL;
 720
 721         return pre;
 722 }
 723
 724 static int vadc_hw_settle_time_from_dt(u32 value)
 725 {
 726         if ((value <= 1000 && value % 100) || (value > 1000 && value % 2000))
 727                 return -EINVAL;
 728
 729         if (value <= 1000)
 730                 value /= 100;
 731         else
 732                 value = value / 2000 + 10;
 733
 734         return value;
 735 }
 736
 737 static int vadc_avg_samples_from_dt(u32 value)
 738 {
 739         if (!is_power_of_2(value) || value > VADC_AVG_SAMPLES_MAX)
 740                 return -EINVAL;
 741
 742         return __ffs64(value);
 743 }
 744
 745 static struct vadc_scale_fn scale_fn[] = {
 746         [SCALE_DEFAULT] = {vadc_scale_volt},
 747         [SCALE_THERM_100K_PULLUP] = {vadc_scale_therm},
 748         [SCALE_PMIC_THERM] = {vadc_scale_die_temp},
 749         [SCALE_XOTHERM] = {vadc_scale_therm},
 750         [SCALE_PMI_CHG_TEMP] = {vadc_scale_chg_temp},
 751 };
 752
 753 static int vadc_read_raw(struct iio_dev *indio_dev,
 754                          struct iio_chan_spec const *chan, int *val, int *val2,
 755                          long mask)
 756 {
 757         struct vadc_priv *vadc = iio_priv(indio_dev);
 758         struct vadc_channel_prop *prop;
 759         u16 adc_code;
 760         int ret;
 761
 762         switch (mask) {
 763         case IIO_CHAN_INFO_PROCESSED:
 764                 prop = &vadc->chan_props[chan->address];
 765                 ret = vadc_do_conversion(vadc, prop, &adc_code);
 766                 if (ret)
 767                         break;
 768
 769                 scale_fn[prop->scale_fn].scale(vadc, prop, adc_code, val);
 770
 771                 return IIO_VAL_INT;
 772         case IIO_CHAN_INFO_RAW:
 773                 prop = &vadc->chan_props[chan->address];
 774                 ret = vadc_do_conversion(vadc, prop, &adc_code);
 775                 if (ret)
 776                         break;
 777
 778                 *val = (int)adc_code;
 779                 return IIO_VAL_INT;
 780         default:
 781                 ret = -EINVAL;
 782                 break;
 783         }
 784
 785         return ret;
 786 }
 787
 788 static int vadc_of_xlate(struct iio_dev *indio_dev,
 789                          const struct of_phandle_args *iiospec)
 790 {
 791         struct vadc_priv *vadc = iio_priv(indio_dev);
 792         unsigned int i;
 793
 794         for (i = 0; i < vadc->nchannels; i++)
 795                 if (vadc->iio_chans[i].channel == iiospec->args[0])
 796                         return i;
 797
 798         return -EINVAL;
 799 }
 800
 801 static const struct iio_info vadc_info = {
 802         .read_raw = vadc_read_raw,
 803         .of_xlate = vadc_of_xlate,
 804         .driver_module = THIS_MODULE,
 805 };
 806
 807 struct vadc_channels {
 808         const char *datasheet_name;
 809         unsigned int prescale_index;
 810         enum iio_chan_type type;
 811         long info_mask;
 812         unsigned int scale_fn;
 813 };
 814
 815 #define VADC_CHAN(_dname, _type, _mask, _pre, _scale)                   \
 816         [VADC_##_dname] = {                                             \
 817                 .datasheet_name = __stringify(_dname),                  \
 818                 .prescale_index = _pre,                                 \
 819                 .type = _type,                                          \
 820                 .info_mask = _mask,                                     \
 821                 .scale_fn = _scale                                      \
 822         },                                                              \
 823
 824 #define VADC_NO_CHAN(_dname, _type, _mask, _pre)                        \
 825         [VADC_##_dname] = {                                             \
 826                 .datasheet_name = __stringify(_dname),                  \
 827                 .prescale_index = _pre,                                 \
 828                 .type = _type,                                          \
 829                 .info_mask = _mask                                      \
 830         },
 831
 832 #define VADC_CHAN_TEMP(_dname, _pre, _scale)                            \
 833         VADC_CHAN(_dname, IIO_TEMP,                                     \
 834                 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_PROCESSED),  \
 835                 _pre, _scale)                                           \
 836
 837 #define VADC_CHAN_VOLT(_dname, _pre, _scale)                            \
 838         VADC_CHAN(_dname, IIO_VOLTAGE,                                  \
 839                   BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_PROCESSED),\
 840                   _pre, _scale)                                         \
 841
 842 #define VADC_CHAN_NO_SCALE(_dname, _pre)                                \
 843         VADC_NO_CHAN(_dname, IIO_VOLTAGE,                               \
 844                   BIT(IIO_CHAN_INFO_RAW),                               \
 845                   _pre)                                                 \
 846
 847 /*
 848  * The array represents all possible ADC channels found in the supported PMICs.
 849  * Every index in the array is equal to the channel number per datasheet. The
 850  * gaps in the array should be treated as reserved channels.
 851  */
 852 static const struct vadc_channels vadc_chans[] = {
 853         VADC_CHAN_VOLT(USBIN, 4, SCALE_DEFAULT)
 854         VADC_CHAN_VOLT(DCIN, 4, SCALE_DEFAULT)
 855         VADC_CHAN_NO_SCALE(VCHG_SNS, 3)
 856         VADC_CHAN_NO_SCALE(SPARE1_03, 1)
 857         VADC_CHAN_NO_SCALE(USB_ID_MV, 1)
 858         VADC_CHAN_VOLT(VCOIN, 1, SCALE_DEFAULT)
 859         VADC_CHAN_NO_SCALE(VBAT_SNS, 1)
 860         VADC_CHAN_VOLT(VSYS, 1, SCALE_DEFAULT)
 861         VADC_CHAN_TEMP(DIE_TEMP, 0, SCALE_PMIC_THERM)
 862         VADC_CHAN_VOLT(REF_625MV, 0, SCALE_DEFAULT)
 863         VADC_CHAN_VOLT(REF_1250MV, 0, SCALE_DEFAULT)
 864         VADC_CHAN_NO_SCALE(CHG_TEMP, 0)
 865         VADC_CHAN_NO_SCALE(SPARE1, 0)
 866         VADC_CHAN_TEMP(SPARE2, 0, SCALE_PMI_CHG_TEMP)
 867         VADC_CHAN_VOLT(GND_REF, 0, SCALE_DEFAULT)
 868         VADC_CHAN_VOLT(VDD_VADC, 0, SCALE_DEFAULT)
 869
 870         VADC_CHAN_NO_SCALE(P_MUX1_1_1, 0)
 871         VADC_CHAN_NO_SCALE(P_MUX2_1_1, 0)
 872         VADC_CHAN_NO_SCALE(P_MUX3_1_1, 0)
 873         VADC_CHAN_NO_SCALE(P_MUX4_1_1, 0)
 874         VADC_CHAN_NO_SCALE(P_MUX5_1_1, 0)
 875         VADC_CHAN_NO_SCALE(P_MUX6_1_1, 0)
 876         VADC_CHAN_NO_SCALE(P_MUX7_1_1, 0)
 877         VADC_CHAN_NO_SCALE(P_MUX8_1_1, 0)
 878         VADC_CHAN_NO_SCALE(P_MUX9_1_1, 0)
 879         VADC_CHAN_NO_SCALE(P_MUX10_1_1, 0)
 880         VADC_CHAN_NO_SCALE(P_MUX11_1_1, 0)
 881         VADC_CHAN_NO_SCALE(P_MUX12_1_1, 0)
 882         VADC_CHAN_NO_SCALE(P_MUX13_1_1, 0)
 883         VADC_CHAN_NO_SCALE(P_MUX14_1_1, 0)
 884         VADC_CHAN_NO_SCALE(P_MUX15_1_1, 0)
 885         VADC_CHAN_NO_SCALE(P_MUX16_1_1, 0)
 886
 887         VADC_CHAN_NO_SCALE(P_MUX1_1_3, 1)
 888         VADC_CHAN_NO_SCALE(P_MUX2_1_3, 1)
 889         VADC_CHAN_NO_SCALE(P_MUX3_1_3, 1)
 890         VADC_CHAN_NO_SCALE(P_MUX4_1_3, 1)
 891         VADC_CHAN_NO_SCALE(P_MUX5_1_3, 1)
 892         VADC_CHAN_NO_SCALE(P_MUX6_1_3, 1)
 893         VADC_CHAN_NO_SCALE(P_MUX7_1_3, 1)
 894         VADC_CHAN_NO_SCALE(P_MUX8_1_3, 1)
 895         VADC_CHAN_NO_SCALE(P_MUX9_1_3, 1)
 896         VADC_CHAN_NO_SCALE(P_MUX10_1_3, 1)
 897         VADC_CHAN_NO_SCALE(P_MUX11_1_3, 1)
 898         VADC_CHAN_NO_SCALE(P_MUX12_1_3, 1)
 899         VADC_CHAN_NO_SCALE(P_MUX13_1_3, 1)
 900         VADC_CHAN_NO_SCALE(P_MUX14_1_3, 1)
 901         VADC_CHAN_NO_SCALE(P_MUX15_1_3, 1)
 902         VADC_CHAN_NO_SCALE(P_MUX16_1_3, 1)
 903
 904         VADC_CHAN_NO_SCALE(LR_MUX1_BAT_THERM, 0)
 905         VADC_CHAN_NO_SCALE(LR_MUX2_BAT_ID, 0)
 906         VADC_CHAN_NO_SCALE(LR_MUX3_XO_THERM, 0)
 907         VADC_CHAN_NO_SCALE(LR_MUX4_AMUX_THM1, 0)
 908         VADC_CHAN_NO_SCALE(LR_MUX5_AMUX_THM2, 0)
 909         VADC_CHAN_NO_SCALE(LR_MUX6_AMUX_THM3, 0)
 910         VADC_CHAN_NO_SCALE(LR_MUX7_HW_ID, 0)
 911         VADC_CHAN_NO_SCALE(LR_MUX8_AMUX_THM4, 0)
 912         VADC_CHAN_NO_SCALE(LR_MUX9_AMUX_THM5, 0)
 913         VADC_CHAN_NO_SCALE(LR_MUX10_USB_ID, 0)
 914         VADC_CHAN_NO_SCALE(AMUX_PU1, 0)
 915         VADC_CHAN_NO_SCALE(AMUX_PU2, 0)
 916         VADC_CHAN_NO_SCALE(LR_MUX3_BUF_XO_THERM, 0)
 917
 918         VADC_CHAN_NO_SCALE(LR_MUX1_PU1_BAT_THERM, 0)
 919         VADC_CHAN_NO_SCALE(LR_MUX2_PU1_BAT_ID, 0)
 920         VADC_CHAN_NO_SCALE(LR_MUX3_PU1_XO_THERM, 0)
 921         VADC_CHAN_TEMP(LR_MUX4_PU1_AMUX_THM1, 0, SCALE_THERM_100K_PULLUP)
 922         VADC_CHAN_TEMP(LR_MUX5_PU1_AMUX_THM2, 0, SCALE_THERM_100K_PULLUP)
 923         VADC_CHAN_TEMP(LR_MUX6_PU1_AMUX_THM3, 0, SCALE_THERM_100K_PULLUP)
 924         VADC_CHAN_NO_SCALE(LR_MUX7_PU1_AMUX_HW_ID, 0)
 925         VADC_CHAN_TEMP(LR_MUX8_PU1_AMUX_THM4, 0, SCALE_THERM_100K_PULLUP)
 926         VADC_CHAN_TEMP(LR_MUX9_PU1_AMUX_THM5, 0, SCALE_THERM_100K_PULLUP)
 927         VADC_CHAN_NO_SCALE(LR_MUX10_PU1_AMUX_USB_ID, 0)
 928         VADC_CHAN_TEMP(LR_MUX3_BUF_PU1_XO_THERM, 0, SCALE_XOTHERM)
 929
 930         VADC_CHAN_NO_SCALE(LR_MUX1_PU2_BAT_THERM, 0)
 931         VADC_CHAN_NO_SCALE(LR_MUX2_PU2_BAT_ID, 0)
 932         VADC_CHAN_NO_SCALE(LR_MUX3_PU2_XO_THERM, 0)
 933         VADC_CHAN_NO_SCALE(LR_MUX4_PU2_AMUX_THM1, 0)
 934         VADC_CHAN_NO_SCALE(LR_MUX5_PU2_AMUX_THM2, 0)
 935         VADC_CHAN_NO_SCALE(LR_MUX6_PU2_AMUX_THM3, 0)
 936         VADC_CHAN_NO_SCALE(LR_MUX7_PU2_AMUX_HW_ID, 0)
 937         VADC_CHAN_NO_SCALE(LR_MUX8_PU2_AMUX_THM4, 0)
 938         VADC_CHAN_NO_SCALE(LR_MUX9_PU2_AMUX_THM5, 0)
 939         VADC_CHAN_NO_SCALE(LR_MUX10_PU2_AMUX_USB_ID, 0)
 940         VADC_CHAN_NO_SCALE(LR_MUX3_BUF_PU2_XO_THERM, 0)
 941
 942         VADC_CHAN_NO_SCALE(LR_MUX1_PU1_PU2_BAT_THERM, 0)
 943         VADC_CHAN_NO_SCALE(LR_MUX2_PU1_PU2_BAT_ID, 0)
 944         VADC_CHAN_NO_SCALE(LR_MUX3_PU1_PU2_XO_THERM, 0)
 945         VADC_CHAN_NO_SCALE(LR_MUX4_PU1_PU2_AMUX_THM1, 0)
 946         VADC_CHAN_NO_SCALE(LR_MUX5_PU1_PU2_AMUX_THM2, 0)
 947         VADC_CHAN_NO_SCALE(LR_MUX6_PU1_PU2_AMUX_THM3, 0)
 948         VADC_CHAN_NO_SCALE(LR_MUX7_PU1_PU2_AMUX_HW_ID, 0)
 949         VADC_CHAN_NO_SCALE(LR_MUX8_PU1_PU2_AMUX_THM4, 0)
 950         VADC_CHAN_NO_SCALE(LR_MUX9_PU1_PU2_AMUX_THM5, 0)
 951         VADC_CHAN_NO_SCALE(LR_MUX10_PU1_PU2_AMUX_USB_ID, 0)
 952         VADC_CHAN_NO_SCALE(LR_MUX3_BUF_PU1_PU2_XO_THERM, 0)
 953 };
 954
 955 static int vadc_get_dt_channel_data(struct device *dev,
 956                                     struct vadc_channel_prop *prop,
 957                                     struct device_node *node)
 958 {
 959         const char *name = node->name;
 960         u32 chan, value, varr[2];
 961         int ret;
 962
 963         ret = of_property_read_u32(node, "reg", &chan);
 964         if (ret) {
 965                 dev_err(dev, "invalid channel number %s\n", name);
 966                 return ret;
 967         }
 968
 969         if (chan > VADC_CHAN_MAX || chan < VADC_CHAN_MIN) {
 970                 dev_err(dev, "%s invalid channel number %d\n", name, chan);
 971                 return -EINVAL;
 972         }
 973
 974         /* the channel has DT description */
 975         prop->channel = chan;
 976
 977         ret = of_property_read_u32(node, "qcom,decimation", &value);
 978         if (!ret) {
 979                 ret = vadc_decimation_from_dt(value);
 980                 if (ret < 0) {
 981                         dev_err(dev, "%02x invalid decimation %d\n",
 982                                 chan, value);
 983                         return ret;
 984                 }
 985                 prop->decimation = ret;
 986         } else {
 987                 prop->decimation = VADC_DEF_DECIMATION;
 988         }
 989
 990         ret = of_property_read_u32_array(node, "qcom,pre-scaling", varr, 2);
 991         if (!ret) {
 992                 ret = vadc_prescaling_from_dt(varr[0], varr[1]);
 993                 if (ret < 0) {
 994                         dev_err(dev, "%02x invalid pre-scaling <%d %d>\n",
 995                                 chan, varr[0], varr[1]);
 996                         return ret;
 997                 }
 998                 prop->prescale = ret;
 999         } else {
1000                 prop->prescale = vadc_chans[prop->channel].prescale_index;
1001         }
1002
1003         ret = of_property_read_u32(node, "qcom,hw-settle-time", &value);
1004         if (!ret) {
1005                 ret = vadc_hw_settle_time_from_dt(value);
1006                 if (ret < 0) {
1007                         dev_err(dev, "%02x invalid hw-settle-time %d us\n",
1008                                 chan, value);
1009                         return ret;
1010                 }
1011                 prop->hw_settle_time = ret;
1012         } else {
1013                 prop->hw_settle_time = VADC_DEF_HW_SETTLE_TIME;
1014         }
1015
1016         ret = of_property_read_u32(node, "qcom,avg-samples", &value);
1017         if (!ret) {
1018                 ret = vadc_avg_samples_from_dt(value);
1019                 if (ret < 0) {
1020                         dev_err(dev, "%02x invalid avg-samples %d\n",
1021                                 chan, value);
1022                         return ret;
1023                 }
1024                 prop->avg_samples = ret;
1025         } else {
1026                 prop->avg_samples = VADC_DEF_AVG_SAMPLES;
1027         }
1028
1029         if (of_property_read_bool(node, "qcom,ratiometric"))
1030                 prop->calibration = VADC_CALIB_RATIOMETRIC;
1031         else
1032                 prop->calibration = VADC_CALIB_ABSOLUTE;
1033
1034         dev_dbg(dev, "%02x name %s\n", chan, name);
1035
1036         return 0;
1037 }
1038
1039 static int vadc_get_dt_data(struct vadc_priv *vadc, struct device_node *node)
1040 {
1041         const struct vadc_channels *vadc_chan;
1042         struct iio_chan_spec *iio_chan;
1043         struct vadc_channel_prop prop;
1044         struct device_node *child;
1045         unsigned int index = 0;
1046         int ret;
1047
1048         vadc->nchannels = of_get_available_child_count(node);
1049         if (!vadc->nchannels)
1050                 return -EINVAL;
1051
1052         vadc->iio_chans = devm_kcalloc(vadc->dev, vadc->nchannels,
1053                                        sizeof(*vadc->iio_chans), GFP_KERNEL);
1054         if (!vadc->iio_chans)
1055                 return -ENOMEM;
1056
1057         vadc->chan_props = devm_kcalloc(vadc->dev, vadc->nchannels,
1058                                         sizeof(*vadc->chan_props), GFP_KERNEL);
1059         if (!vadc->chan_props)
1060                 return -ENOMEM;
1061
1062         iio_chan = vadc->iio_chans;
1063
1064         for_each_available_child_of_node(node, child) {
1065                 ret = vadc_get_dt_channel_data(vadc->dev, &prop, child);
1066                 if (ret) {
1067                         of_node_put(child);
1068                         return ret;
1069                 }
1070
1071                 prop.scale_fn = vadc_chans[prop.channel].scale_fn;
1072                 vadc->chan_props[index] = prop;
1073
1074                 vadc_chan = &vadc_chans[prop.channel];
1075
1076                 iio_chan->channel = prop.channel;
1077                 iio_chan->datasheet_name = vadc_chan->datasheet_name;
1078                 iio_chan->info_mask_separate = vadc_chan->info_mask;
1079                 iio_chan->type = vadc_chan->type;
1080                 iio_chan->indexed = 1;
1081                 iio_chan->address = index++;
1082
1083                 iio_chan++;
1084         }
1085
1086         /* These channels are mandatory, they are used as reference points */
1087         if (!vadc_get_channel(vadc, VADC_REF_1250MV)) {
1088                 dev_err(vadc->dev, "Please define 1.25V channel\n");
1089                 return -ENODEV;
1090         }
1091
1092         if (!vadc_get_channel(vadc, VADC_REF_625MV)) {
1093                 dev_err(vadc->dev, "Please define 0.625V channel\n");
1094                 return -ENODEV;
1095         }
1096
1097         if (!vadc_get_channel(vadc, VADC_VDD_VADC)) {
1098                 dev_err(vadc->dev, "Please define VDD channel\n");
1099                 return -ENODEV;
1100         }
1101
1102         if (!vadc_get_channel(vadc, VADC_GND_REF)) {
1103                 dev_err(vadc->dev, "Please define GND channel\n");
1104                 return -ENODEV;
1105         }
1106
1107         return 0;
1108 }
1109
1110 static irqreturn_t vadc_isr(int irq, void *dev_id)
1111 {
1112         struct vadc_priv *vadc = dev_id;
1113
1114         complete(&vadc->complete);
1115
1116         return IRQ_HANDLED;
1117 }
1118
1119 static int vadc_check_revision(struct vadc_priv *vadc)
1120 {
1121         u8 val;
1122         int ret;
1123
1124         ret = vadc_read(vadc, VADC_PERPH_TYPE, &val);
1125         if (ret)
1126                 return ret;
1127
1128         if (val < VADC_PERPH_TYPE_ADC) {
1129                 dev_err(vadc->dev, "%d is not ADC\n", val);
1130                 return -ENODEV;
1131         }
1132
1133         ret = vadc_read(vadc, VADC_PERPH_SUBTYPE, &val);
1134         if (ret)
1135                 return ret;
1136
1137         if (val < VADC_PERPH_SUBTYPE_VADC) {
1138                 dev_err(vadc->dev, "%d is not VADC\n", val);
1139                 return -ENODEV;
1140         }
1141
1142         ret = vadc_read(vadc, VADC_REVISION2, &val);
1143         if (ret)
1144                 return ret;
1145
1146         if (val < VADC_REVISION2_SUPPORTED_VADC) {
1147                 dev_err(vadc->dev, "revision %d not supported\n", val);
1148                 return -ENODEV;
1149         }
1150
1151         return 0;
1152 }
1153
1154 static int vadc_probe(struct platform_device *pdev)
1155 {
1156         struct device_node *node = pdev->dev.of_node;
1157         struct device *dev = &pdev->dev;
1158         struct iio_dev *indio_dev;
1159         struct vadc_priv *vadc;
1160         struct regmap *regmap;
1161         int ret, irq_eoc;
1162         u32 reg;
1163
1164         regmap = dev_get_regmap(dev->parent, NULL);
1165         if (!regmap)
1166                 return -ENODEV;
1167
1168         ret = of_property_read_u32(node, "reg", &reg);
1169         if (ret < 0)
1170                 return ret;
1171
1172         indio_dev = devm_iio_device_alloc(dev, sizeof(*vadc));
1173         if (!indio_dev)
1174                 return -ENOMEM;
1175
1176         vadc = iio_priv(indio_dev);
1177         vadc->regmap = regmap;
1178         vadc->dev = dev;
1179         vadc->base = reg;
1180         vadc->are_ref_measured = false;
1181         init_completion(&vadc->complete);
1182         mutex_init(&vadc->lock);
1183
1184         ret = vadc_check_revision(vadc);
1185         if (ret)
1186                 return ret;
1187
1188         ret = vadc_get_dt_data(vadc, node);
1189         if (ret)
1190                 return ret;
1191
1192         irq_eoc = platform_get_irq(pdev, 0);
1193         if (irq_eoc < 0) {
1194                 if (irq_eoc == -EPROBE_DEFER || irq_eoc == -EINVAL)
1195                         return irq_eoc;
1196                 vadc->poll_eoc = true;
1197         } else {
1198                 ret = devm_request_irq(dev, irq_eoc, vadc_isr, 0,
1199                                        "spmi-vadc", vadc);
1200                 if (ret)
1201                         return ret;
1202         }
1203
1204         ret = vadc_reset(vadc);
1205         if (ret) {
1206                 dev_err(dev, "reset failed\n");
1207                 return ret;
1208         }
1209
1210         ret = vadc_measure_ref_points(vadc);
1211         if (ret)
1212                 return ret;
1213
1214         indio_dev->dev.parent = dev;
1215         indio_dev->dev.of_node = node;
1216         indio_dev->name = pdev->name;
1217         indio_dev->modes = INDIO_DIRECT_MODE;
1218         indio_dev->info = &vadc_info;
1219         indio_dev->channels = vadc->iio_chans;
1220         indio_dev->num_channels = vadc->nchannels;
1221
1222         return devm_iio_device_register(dev, indio_dev);
1223 }
1224
1225 static const struct of_device_id vadc_match_table[] = {
1226         { .compatible = "qcom,spmi-vadc" },
1227         { }
1228 };
1229 MODULE_DEVICE_TABLE(of, vadc_match_table);
1230
1231 static struct platform_driver vadc_driver = {
1232         .driver = {
1233                    .name = "qcom-spmi-vadc",
1234                    .of_match_table = vadc_match_table,
1235         },
1236         .probe = vadc_probe,
1237 };
1238 module_platform_driver(vadc_driver);
1239
1240 MODULE_ALIAS("platform:qcom-spmi-vadc");
1241 MODULE_DESCRIPTION("Qualcomm SPMI PMIC voltage ADC driver");
1242 MODULE_LICENSE("GPL v2");
1243 MODULE_AUTHOR("Stanimir Varbanov <[email protected]>");
1244 MODULE_AUTHOR("Ivan T. Ivanov <[email protected]>");