955 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/*3 * Copyright (c) 2012-2016, The Linux Foundation. All rights reserved.4 */5 6#include <linux/bitops.h>7#include <linux/completion.h>8#include <linux/delay.h>9#include <linux/err.h>10#include <linux/iio/adc/qcom-vadc-common.h>11#include <linux/iio/iio.h>12#include <linux/interrupt.h>13#include <linux/kernel.h>14#include <linux/math64.h>15#include <linux/module.h>16#include <linux/mod_devicetable.h>17#include <linux/platform_device.h>18#include <linux/property.h>19#include <linux/regmap.h>20#include <linux/slab.h>21#include <linux/log2.h>22 23#include <dt-bindings/iio/qcom,spmi-vadc.h>24 25/* VADC register and bit definitions */26#define VADC_REVISION2 0x127#define VADC_REVISION2_SUPPORTED_VADC 128 29#define VADC_PERPH_TYPE 0x430#define VADC_PERPH_TYPE_ADC 831 32#define VADC_PERPH_SUBTYPE 0x533#define VADC_PERPH_SUBTYPE_VADC 134 35#define VADC_STATUS1 0x836#define VADC_STATUS1_OP_MODE 437#define VADC_STATUS1_REQ_STS BIT(1)38#define VADC_STATUS1_EOC BIT(0)39#define VADC_STATUS1_REQ_STS_EOC_MASK 0x340 41#define VADC_MODE_CTL 0x4042#define VADC_OP_MODE_SHIFT 343#define VADC_OP_MODE_NORMAL 044#define VADC_AMUX_TRIM_EN BIT(1)45#define VADC_ADC_TRIM_EN BIT(0)46 47#define VADC_EN_CTL1 0x4648#define VADC_EN_CTL1_SET BIT(7)49 50#define VADC_ADC_CH_SEL_CTL 0x4851 52#define VADC_ADC_DIG_PARAM 0x5053#define VADC_ADC_DIG_DEC_RATIO_SEL_SHIFT 254 55#define VADC_HW_SETTLE_DELAY 0x5156 57#define VADC_CONV_REQ 0x5258#define VADC_CONV_REQ_SET BIT(7)59 60#define VADC_FAST_AVG_CTL 0x5a61#define VADC_FAST_AVG_EN 0x5b62#define VADC_FAST_AVG_EN_SET BIT(7)63 64#define VADC_ACCESS 0xd065#define VADC_ACCESS_DATA 0xa566 67#define VADC_PERH_RESET_CTL3 0xda68#define VADC_FOLLOW_WARM_RB BIT(2)69 70#define VADC_DATA 0x60 /* 16 bits */71 72#define VADC_CHAN_MIN VADC_USBIN73#define VADC_CHAN_MAX VADC_LR_MUX3_BUF_PU1_PU2_XO_THERM74 75/**76 * struct vadc_channel_prop - VADC channel property.77 * @channel: channel number, refer to the channel list.78 * @calibration: calibration type.79 * @decimation: sampling rate supported for the channel.80 * @prescale: channel scaling performed on the input signal.81 * @hw_settle_time: the time between AMUX being configured and the82 * start of conversion.83 * @avg_samples: ability to provide single result from the ADC84 * that is an average of multiple measurements.85 * @scale_fn_type: Represents the scaling function to convert voltage86 * physical units desired by the client for the channel.87 * @channel_name: Channel name used in device tree.88 */89struct vadc_channel_prop {90 unsigned int channel;91 enum vadc_calibration calibration;92 unsigned int decimation;93 unsigned int prescale;94 unsigned int hw_settle_time;95 unsigned int avg_samples;96 enum vadc_scale_fn_type scale_fn_type;97 const char *channel_name;98};99 100/**101 * struct vadc_priv - VADC private structure.102 * @regmap: pointer to struct regmap.103 * @dev: pointer to struct device.104 * @base: base address for the ADC peripheral.105 * @nchannels: number of VADC channels.106 * @chan_props: array of VADC channel properties.107 * @iio_chans: array of IIO channels specification.108 * @are_ref_measured: are reference points measured.109 * @poll_eoc: use polling instead of interrupt.110 * @complete: VADC result notification after interrupt is received.111 * @graph: store parameters for calibration.112 * @lock: ADC lock for access to the peripheral.113 */114struct vadc_priv {115 struct regmap *regmap;116 struct device *dev;117 u16 base;118 unsigned int nchannels;119 struct vadc_channel_prop *chan_props;120 struct iio_chan_spec *iio_chans;121 bool are_ref_measured;122 bool poll_eoc;123 struct completion complete;124 struct vadc_linear_graph graph[2];125 struct mutex lock;126};127 128static const struct u32_fract vadc_prescale_ratios[] = {129 { .numerator = 1, .denominator = 1 },130 { .numerator = 1, .denominator = 3 },131 { .numerator = 1, .denominator = 4 },132 { .numerator = 1, .denominator = 6 },133 { .numerator = 1, .denominator = 20 },134 { .numerator = 1, .denominator = 8 },135 { .numerator = 10, .denominator = 81 },136 { .numerator = 1, .denominator = 10 },137};138 139static int vadc_read(struct vadc_priv *vadc, u16 offset, u8 *data)140{141 return regmap_bulk_read(vadc->regmap, vadc->base + offset, data, 1);142}143 144static int vadc_write(struct vadc_priv *vadc, u16 offset, u8 data)145{146 return regmap_write(vadc->regmap, vadc->base + offset, data);147}148 149static int vadc_reset(struct vadc_priv *vadc)150{151 u8 data;152 int ret;153 154 ret = vadc_write(vadc, VADC_ACCESS, VADC_ACCESS_DATA);155 if (ret)156 return ret;157 158 ret = vadc_read(vadc, VADC_PERH_RESET_CTL3, &data);159 if (ret)160 return ret;161 162 ret = vadc_write(vadc, VADC_ACCESS, VADC_ACCESS_DATA);163 if (ret)164 return ret;165 166 data |= VADC_FOLLOW_WARM_RB;167 168 return vadc_write(vadc, VADC_PERH_RESET_CTL3, data);169}170 171static int vadc_set_state(struct vadc_priv *vadc, bool state)172{173 return vadc_write(vadc, VADC_EN_CTL1, state ? VADC_EN_CTL1_SET : 0);174}175 176static void vadc_show_status(struct vadc_priv *vadc)177{178 u8 mode, sta1, chan, dig, en, req;179 int ret;180 181 ret = vadc_read(vadc, VADC_MODE_CTL, &mode);182 if (ret)183 return;184 185 ret = vadc_read(vadc, VADC_ADC_DIG_PARAM, &dig);186 if (ret)187 return;188 189 ret = vadc_read(vadc, VADC_ADC_CH_SEL_CTL, &chan);190 if (ret)191 return;192 193 ret = vadc_read(vadc, VADC_CONV_REQ, &req);194 if (ret)195 return;196 197 ret = vadc_read(vadc, VADC_STATUS1, &sta1);198 if (ret)199 return;200 201 ret = vadc_read(vadc, VADC_EN_CTL1, &en);202 if (ret)203 return;204 205 dev_err(vadc->dev,206 "mode:%02x en:%02x chan:%02x dig:%02x req:%02x sta1:%02x\n",207 mode, en, chan, dig, req, sta1);208}209 210static int vadc_configure(struct vadc_priv *vadc,211 struct vadc_channel_prop *prop)212{213 u8 decimation, mode_ctrl;214 int ret;215 216 /* Mode selection */217 mode_ctrl = (VADC_OP_MODE_NORMAL << VADC_OP_MODE_SHIFT) |218 VADC_ADC_TRIM_EN | VADC_AMUX_TRIM_EN;219 ret = vadc_write(vadc, VADC_MODE_CTL, mode_ctrl);220 if (ret)221 return ret;222 223 /* Channel selection */224 ret = vadc_write(vadc, VADC_ADC_CH_SEL_CTL, prop->channel);225 if (ret)226 return ret;227 228 /* Digital parameter setup */229 decimation = prop->decimation << VADC_ADC_DIG_DEC_RATIO_SEL_SHIFT;230 ret = vadc_write(vadc, VADC_ADC_DIG_PARAM, decimation);231 if (ret)232 return ret;233 234 /* HW settle time delay */235 ret = vadc_write(vadc, VADC_HW_SETTLE_DELAY, prop->hw_settle_time);236 if (ret)237 return ret;238 239 ret = vadc_write(vadc, VADC_FAST_AVG_CTL, prop->avg_samples);240 if (ret)241 return ret;242 243 if (prop->avg_samples)244 ret = vadc_write(vadc, VADC_FAST_AVG_EN, VADC_FAST_AVG_EN_SET);245 else246 ret = vadc_write(vadc, VADC_FAST_AVG_EN, 0);247 248 return ret;249}250 251static int vadc_poll_wait_eoc(struct vadc_priv *vadc, unsigned int interval_us)252{253 unsigned int count, retry;254 u8 sta1;255 int ret;256 257 retry = interval_us / VADC_CONV_TIME_MIN_US;258 259 for (count = 0; count < retry; count++) {260 ret = vadc_read(vadc, VADC_STATUS1, &sta1);261 if (ret)262 return ret;263 264 sta1 &= VADC_STATUS1_REQ_STS_EOC_MASK;265 if (sta1 == VADC_STATUS1_EOC)266 return 0;267 268 usleep_range(VADC_CONV_TIME_MIN_US, VADC_CONV_TIME_MAX_US);269 }270 271 vadc_show_status(vadc);272 273 return -ETIMEDOUT;274}275 276static int vadc_read_result(struct vadc_priv *vadc, u16 *data)277{278 int ret;279 280 ret = regmap_bulk_read(vadc->regmap, vadc->base + VADC_DATA, data, 2);281 if (ret)282 return ret;283 284 *data = clamp_t(u16, *data, VADC_MIN_ADC_CODE, VADC_MAX_ADC_CODE);285 286 return 0;287}288 289static struct vadc_channel_prop *vadc_get_channel(struct vadc_priv *vadc,290 unsigned int num)291{292 unsigned int i;293 294 for (i = 0; i < vadc->nchannels; i++)295 if (vadc->chan_props[i].channel == num)296 return &vadc->chan_props[i];297 298 dev_dbg(vadc->dev, "no such channel %02x\n", num);299 300 return NULL;301}302 303static int vadc_do_conversion(struct vadc_priv *vadc,304 struct vadc_channel_prop *prop, u16 *data)305{306 unsigned int timeout;307 int ret;308 309 mutex_lock(&vadc->lock);310 311 ret = vadc_configure(vadc, prop);312 if (ret)313 goto unlock;314 315 if (!vadc->poll_eoc)316 reinit_completion(&vadc->complete);317 318 ret = vadc_set_state(vadc, true);319 if (ret)320 goto unlock;321 322 ret = vadc_write(vadc, VADC_CONV_REQ, VADC_CONV_REQ_SET);323 if (ret)324 goto err_disable;325 326 timeout = BIT(prop->avg_samples) * VADC_CONV_TIME_MIN_US * 2;327 328 if (vadc->poll_eoc) {329 ret = vadc_poll_wait_eoc(vadc, timeout);330 } else {331 ret = wait_for_completion_timeout(&vadc->complete, timeout);332 if (!ret) {333 ret = -ETIMEDOUT;334 goto err_disable;335 }336 337 /* Double check conversion status */338 ret = vadc_poll_wait_eoc(vadc, VADC_CONV_TIME_MIN_US);339 if (ret)340 goto err_disable;341 }342 343 ret = vadc_read_result(vadc, data);344 345err_disable:346 vadc_set_state(vadc, false);347 if (ret)348 dev_err(vadc->dev, "conversion failed\n");349unlock:350 mutex_unlock(&vadc->lock);351 return ret;352}353 354static int vadc_measure_ref_points(struct vadc_priv *vadc)355{356 struct vadc_channel_prop *prop;357 u16 read_1, read_2;358 int ret;359 360 vadc->graph[VADC_CALIB_RATIOMETRIC].dx = VADC_RATIOMETRIC_RANGE;361 vadc->graph[VADC_CALIB_ABSOLUTE].dx = VADC_ABSOLUTE_RANGE_UV;362 363 prop = vadc_get_channel(vadc, VADC_REF_1250MV);364 ret = vadc_do_conversion(vadc, prop, &read_1);365 if (ret)366 goto err;367 368 /* Try with buffered 625mV channel first */369 prop = vadc_get_channel(vadc, VADC_SPARE1);370 if (!prop)371 prop = vadc_get_channel(vadc, VADC_REF_625MV);372 373 ret = vadc_do_conversion(vadc, prop, &read_2);374 if (ret)375 goto err;376 377 if (read_1 == read_2) {378 ret = -EINVAL;379 goto err;380 }381 382 vadc->graph[VADC_CALIB_ABSOLUTE].dy = read_1 - read_2;383 vadc->graph[VADC_CALIB_ABSOLUTE].gnd = read_2;384 385 /* Ratiometric calibration */386 prop = vadc_get_channel(vadc, VADC_VDD_VADC);387 ret = vadc_do_conversion(vadc, prop, &read_1);388 if (ret)389 goto err;390 391 prop = vadc_get_channel(vadc, VADC_GND_REF);392 ret = vadc_do_conversion(vadc, prop, &read_2);393 if (ret)394 goto err;395 396 if (read_1 == read_2) {397 ret = -EINVAL;398 goto err;399 }400 401 vadc->graph[VADC_CALIB_RATIOMETRIC].dy = read_1 - read_2;402 vadc->graph[VADC_CALIB_RATIOMETRIC].gnd = read_2;403err:404 if (ret)405 dev_err(vadc->dev, "measure reference points failed\n");406 407 return ret;408}409 410static int vadc_prescaling_from_dt(u32 numerator, u32 denominator)411{412 unsigned int pre;413 414 for (pre = 0; pre < ARRAY_SIZE(vadc_prescale_ratios); pre++)415 if (vadc_prescale_ratios[pre].numerator == numerator &&416 vadc_prescale_ratios[pre].denominator == denominator)417 break;418 419 if (pre == ARRAY_SIZE(vadc_prescale_ratios))420 return -EINVAL;421 422 return pre;423}424 425static int vadc_hw_settle_time_from_dt(u32 value)426{427 if ((value <= 1000 && value % 100) || (value > 1000 && value % 2000))428 return -EINVAL;429 430 if (value <= 1000)431 value /= 100;432 else433 value = value / 2000 + 10;434 435 return value;436}437 438static int vadc_avg_samples_from_dt(u32 value)439{440 if (!is_power_of_2(value) || value > VADC_AVG_SAMPLES_MAX)441 return -EINVAL;442 443 return __ffs64(value);444}445 446static int vadc_read_raw(struct iio_dev *indio_dev,447 struct iio_chan_spec const *chan, int *val, int *val2,448 long mask)449{450 struct vadc_priv *vadc = iio_priv(indio_dev);451 struct vadc_channel_prop *prop;452 u16 adc_code;453 int ret;454 455 switch (mask) {456 case IIO_CHAN_INFO_PROCESSED:457 prop = &vadc->chan_props[chan->address];458 ret = vadc_do_conversion(vadc, prop, &adc_code);459 if (ret)460 break;461 462 ret = qcom_vadc_scale(prop->scale_fn_type,463 &vadc->graph[prop->calibration],464 &vadc_prescale_ratios[prop->prescale],465 (prop->calibration == VADC_CALIB_ABSOLUTE),466 adc_code, val);467 if (ret)468 break;469 470 return IIO_VAL_INT;471 case IIO_CHAN_INFO_RAW:472 prop = &vadc->chan_props[chan->address];473 ret = vadc_do_conversion(vadc, prop, &adc_code);474 if (ret)475 break;476 477 *val = (int)adc_code;478 return IIO_VAL_INT;479 default:480 ret = -EINVAL;481 break;482 }483 484 return ret;485}486 487static int vadc_fwnode_xlate(struct iio_dev *indio_dev,488 const struct fwnode_reference_args *iiospec)489{490 struct vadc_priv *vadc = iio_priv(indio_dev);491 unsigned int i;492 493 for (i = 0; i < vadc->nchannels; i++)494 if (vadc->iio_chans[i].channel == iiospec->args[0])495 return i;496 497 return -EINVAL;498}499 500static int vadc_read_label(struct iio_dev *indio_dev,501 struct iio_chan_spec const *chan, char *label)502{503 struct vadc_priv *vadc = iio_priv(indio_dev);504 const char *name = vadc->chan_props[chan->address].channel_name;505 506 return sysfs_emit(label, "%s\n", name);507}508 509static const struct iio_info vadc_info = {510 .read_raw = vadc_read_raw,511 .read_label = vadc_read_label,512 .fwnode_xlate = vadc_fwnode_xlate,513};514 515struct vadc_channels {516 const char *datasheet_name;517 unsigned int prescale_index;518 enum iio_chan_type type;519 long info_mask;520 enum vadc_scale_fn_type scale_fn_type;521};522 523#define VADC_CHAN(_dname, _type, _mask, _pre, _scale) \524 [VADC_##_dname] = { \525 .datasheet_name = __stringify(_dname), \526 .prescale_index = _pre, \527 .type = _type, \528 .info_mask = _mask, \529 .scale_fn_type = _scale \530 }, \531 532#define VADC_NO_CHAN(_dname, _type, _mask, _pre) \533 [VADC_##_dname] = { \534 .datasheet_name = __stringify(_dname), \535 .prescale_index = _pre, \536 .type = _type, \537 .info_mask = _mask \538 },539 540#define VADC_CHAN_TEMP(_dname, _pre, _scale) \541 VADC_CHAN(_dname, IIO_TEMP, \542 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_PROCESSED), \543 _pre, _scale) \544 545#define VADC_CHAN_VOLT(_dname, _pre, _scale) \546 VADC_CHAN(_dname, IIO_VOLTAGE, \547 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_PROCESSED),\548 _pre, _scale) \549 550#define VADC_CHAN_NO_SCALE(_dname, _pre) \551 VADC_NO_CHAN(_dname, IIO_VOLTAGE, \552 BIT(IIO_CHAN_INFO_RAW), \553 _pre) \554 555/*556 * The array represents all possible ADC channels found in the supported PMICs.557 * Every index in the array is equal to the channel number per datasheet. The558 * gaps in the array should be treated as reserved channels.559 */560static const struct vadc_channels vadc_chans[] = {561 VADC_CHAN_VOLT(USBIN, 4, SCALE_DEFAULT)562 VADC_CHAN_VOLT(DCIN, 4, SCALE_DEFAULT)563 VADC_CHAN_NO_SCALE(VCHG_SNS, 3)564 VADC_CHAN_NO_SCALE(SPARE1_03, 1)565 VADC_CHAN_NO_SCALE(USB_ID_MV, 1)566 VADC_CHAN_VOLT(VCOIN, 1, SCALE_DEFAULT)567 VADC_CHAN_NO_SCALE(VBAT_SNS, 1)568 VADC_CHAN_VOLT(VSYS, 1, SCALE_DEFAULT)569 VADC_CHAN_TEMP(DIE_TEMP, 0, SCALE_PMIC_THERM)570 VADC_CHAN_VOLT(REF_625MV, 0, SCALE_DEFAULT)571 VADC_CHAN_VOLT(REF_1250MV, 0, SCALE_DEFAULT)572 VADC_CHAN_NO_SCALE(CHG_TEMP, 0)573 VADC_CHAN_NO_SCALE(SPARE1, 0)574 VADC_CHAN_TEMP(SPARE2, 0, SCALE_PMI_CHG_TEMP)575 VADC_CHAN_VOLT(GND_REF, 0, SCALE_DEFAULT)576 VADC_CHAN_VOLT(VDD_VADC, 0, SCALE_DEFAULT)577 578 VADC_CHAN_NO_SCALE(P_MUX1_1_1, 0)579 VADC_CHAN_NO_SCALE(P_MUX2_1_1, 0)580 VADC_CHAN_NO_SCALE(P_MUX3_1_1, 0)581 VADC_CHAN_NO_SCALE(P_MUX4_1_1, 0)582 VADC_CHAN_NO_SCALE(P_MUX5_1_1, 0)583 VADC_CHAN_NO_SCALE(P_MUX6_1_1, 0)584 VADC_CHAN_NO_SCALE(P_MUX7_1_1, 0)585 VADC_CHAN_NO_SCALE(P_MUX8_1_1, 0)586 VADC_CHAN_NO_SCALE(P_MUX9_1_1, 0)587 VADC_CHAN_NO_SCALE(P_MUX10_1_1, 0)588 VADC_CHAN_NO_SCALE(P_MUX11_1_1, 0)589 VADC_CHAN_NO_SCALE(P_MUX12_1_1, 0)590 VADC_CHAN_NO_SCALE(P_MUX13_1_1, 0)591 VADC_CHAN_NO_SCALE(P_MUX14_1_1, 0)592 VADC_CHAN_NO_SCALE(P_MUX15_1_1, 0)593 VADC_CHAN_NO_SCALE(P_MUX16_1_1, 0)594 595 VADC_CHAN_NO_SCALE(P_MUX1_1_3, 1)596 VADC_CHAN_NO_SCALE(P_MUX2_1_3, 1)597 VADC_CHAN_NO_SCALE(P_MUX3_1_3, 1)598 VADC_CHAN_NO_SCALE(P_MUX4_1_3, 1)599 VADC_CHAN_NO_SCALE(P_MUX5_1_3, 1)600 VADC_CHAN_NO_SCALE(P_MUX6_1_3, 1)601 VADC_CHAN_NO_SCALE(P_MUX7_1_3, 1)602 VADC_CHAN_NO_SCALE(P_MUX8_1_3, 1)603 VADC_CHAN_NO_SCALE(P_MUX9_1_3, 1)604 VADC_CHAN_NO_SCALE(P_MUX10_1_3, 1)605 VADC_CHAN_NO_SCALE(P_MUX11_1_3, 1)606 VADC_CHAN_NO_SCALE(P_MUX12_1_3, 1)607 VADC_CHAN_NO_SCALE(P_MUX13_1_3, 1)608 VADC_CHAN_NO_SCALE(P_MUX14_1_3, 1)609 VADC_CHAN_NO_SCALE(P_MUX15_1_3, 1)610 VADC_CHAN_NO_SCALE(P_MUX16_1_3, 1)611 612 VADC_CHAN_NO_SCALE(LR_MUX1_BAT_THERM, 0)613 VADC_CHAN_VOLT(LR_MUX2_BAT_ID, 0, SCALE_DEFAULT)614 VADC_CHAN_NO_SCALE(LR_MUX3_XO_THERM, 0)615 VADC_CHAN_NO_SCALE(LR_MUX4_AMUX_THM1, 0)616 VADC_CHAN_NO_SCALE(LR_MUX5_AMUX_THM2, 0)617 VADC_CHAN_NO_SCALE(LR_MUX6_AMUX_THM3, 0)618 VADC_CHAN_NO_SCALE(LR_MUX7_HW_ID, 0)619 VADC_CHAN_NO_SCALE(LR_MUX8_AMUX_THM4, 0)620 VADC_CHAN_NO_SCALE(LR_MUX9_AMUX_THM5, 0)621 VADC_CHAN_NO_SCALE(LR_MUX10_USB_ID, 0)622 VADC_CHAN_NO_SCALE(AMUX_PU1, 0)623 VADC_CHAN_NO_SCALE(AMUX_PU2, 0)624 VADC_CHAN_NO_SCALE(LR_MUX3_BUF_XO_THERM, 0)625 626 VADC_CHAN_NO_SCALE(LR_MUX1_PU1_BAT_THERM, 0)627 VADC_CHAN_NO_SCALE(LR_MUX2_PU1_BAT_ID, 0)628 VADC_CHAN_NO_SCALE(LR_MUX3_PU1_XO_THERM, 0)629 VADC_CHAN_TEMP(LR_MUX4_PU1_AMUX_THM1, 0, SCALE_THERM_100K_PULLUP)630 VADC_CHAN_TEMP(LR_MUX5_PU1_AMUX_THM2, 0, SCALE_THERM_100K_PULLUP)631 VADC_CHAN_TEMP(LR_MUX6_PU1_AMUX_THM3, 0, SCALE_THERM_100K_PULLUP)632 VADC_CHAN_NO_SCALE(LR_MUX7_PU1_AMUX_HW_ID, 0)633 VADC_CHAN_TEMP(LR_MUX8_PU1_AMUX_THM4, 0, SCALE_THERM_100K_PULLUP)634 VADC_CHAN_TEMP(LR_MUX9_PU1_AMUX_THM5, 0, SCALE_THERM_100K_PULLUP)635 VADC_CHAN_NO_SCALE(LR_MUX10_PU1_AMUX_USB_ID, 0)636 VADC_CHAN_TEMP(LR_MUX3_BUF_PU1_XO_THERM, 0, SCALE_XOTHERM)637 638 VADC_CHAN_NO_SCALE(LR_MUX1_PU2_BAT_THERM, 0)639 VADC_CHAN_NO_SCALE(LR_MUX2_PU2_BAT_ID, 0)640 VADC_CHAN_NO_SCALE(LR_MUX3_PU2_XO_THERM, 0)641 VADC_CHAN_NO_SCALE(LR_MUX4_PU2_AMUX_THM1, 0)642 VADC_CHAN_NO_SCALE(LR_MUX5_PU2_AMUX_THM2, 0)643 VADC_CHAN_NO_SCALE(LR_MUX6_PU2_AMUX_THM3, 0)644 VADC_CHAN_NO_SCALE(LR_MUX7_PU2_AMUX_HW_ID, 0)645 VADC_CHAN_NO_SCALE(LR_MUX8_PU2_AMUX_THM4, 0)646 VADC_CHAN_NO_SCALE(LR_MUX9_PU2_AMUX_THM5, 0)647 VADC_CHAN_NO_SCALE(LR_MUX10_PU2_AMUX_USB_ID, 0)648 VADC_CHAN_NO_SCALE(LR_MUX3_BUF_PU2_XO_THERM, 0)649 650 VADC_CHAN_NO_SCALE(LR_MUX1_PU1_PU2_BAT_THERM, 0)651 VADC_CHAN_NO_SCALE(LR_MUX2_PU1_PU2_BAT_ID, 0)652 VADC_CHAN_NO_SCALE(LR_MUX3_PU1_PU2_XO_THERM, 0)653 VADC_CHAN_NO_SCALE(LR_MUX4_PU1_PU2_AMUX_THM1, 0)654 VADC_CHAN_NO_SCALE(LR_MUX5_PU1_PU2_AMUX_THM2, 0)655 VADC_CHAN_NO_SCALE(LR_MUX6_PU1_PU2_AMUX_THM3, 0)656 VADC_CHAN_NO_SCALE(LR_MUX7_PU1_PU2_AMUX_HW_ID, 0)657 VADC_CHAN_NO_SCALE(LR_MUX8_PU1_PU2_AMUX_THM4, 0)658 VADC_CHAN_NO_SCALE(LR_MUX9_PU1_PU2_AMUX_THM5, 0)659 VADC_CHAN_NO_SCALE(LR_MUX10_PU1_PU2_AMUX_USB_ID, 0)660 VADC_CHAN_NO_SCALE(LR_MUX3_BUF_PU1_PU2_XO_THERM, 0)661};662 663static int vadc_get_fw_channel_data(struct device *dev,664 struct vadc_channel_prop *prop,665 struct fwnode_handle *fwnode)666{667 const char *name = fwnode_get_name(fwnode), *label;668 u32 chan, value, varr[2];669 int ret;670 671 ret = fwnode_property_read_u32(fwnode, "reg", &chan);672 if (ret) {673 dev_err(dev, "invalid channel number %s\n", name);674 return ret;675 }676 677 if (chan > VADC_CHAN_MAX || chan < VADC_CHAN_MIN) {678 dev_err(dev, "%s invalid channel number %d\n", name, chan);679 return -EINVAL;680 }681 682 ret = fwnode_property_read_string(fwnode, "label", &label);683 if (ret)684 label = vadc_chans[chan].datasheet_name;685 prop->channel_name = label;686 687 /* the channel has DT description */688 prop->channel = chan;689 690 ret = fwnode_property_read_u32(fwnode, "qcom,decimation", &value);691 if (!ret) {692 ret = qcom_vadc_decimation_from_dt(value);693 if (ret < 0) {694 dev_err(dev, "%02x invalid decimation %d\n",695 chan, value);696 return ret;697 }698 prop->decimation = ret;699 } else {700 prop->decimation = VADC_DEF_DECIMATION;701 }702 703 ret = fwnode_property_read_u32_array(fwnode, "qcom,pre-scaling", varr, 2);704 if (!ret) {705 ret = vadc_prescaling_from_dt(varr[0], varr[1]);706 if (ret < 0) {707 dev_err(dev, "%02x invalid pre-scaling <%d %d>\n",708 chan, varr[0], varr[1]);709 return ret;710 }711 prop->prescale = ret;712 } else {713 prop->prescale = vadc_chans[prop->channel].prescale_index;714 }715 716 ret = fwnode_property_read_u32(fwnode, "qcom,hw-settle-time", &value);717 if (!ret) {718 ret = vadc_hw_settle_time_from_dt(value);719 if (ret < 0) {720 dev_err(dev, "%02x invalid hw-settle-time %d us\n",721 chan, value);722 return ret;723 }724 prop->hw_settle_time = ret;725 } else {726 prop->hw_settle_time = VADC_DEF_HW_SETTLE_TIME;727 }728 729 ret = fwnode_property_read_u32(fwnode, "qcom,avg-samples", &value);730 if (!ret) {731 ret = vadc_avg_samples_from_dt(value);732 if (ret < 0) {733 dev_err(dev, "%02x invalid avg-samples %d\n",734 chan, value);735 return ret;736 }737 prop->avg_samples = ret;738 } else {739 prop->avg_samples = VADC_DEF_AVG_SAMPLES;740 }741 742 if (fwnode_property_read_bool(fwnode, "qcom,ratiometric"))743 prop->calibration = VADC_CALIB_RATIOMETRIC;744 else745 prop->calibration = VADC_CALIB_ABSOLUTE;746 747 dev_dbg(dev, "%02x name %s\n", chan, name);748 749 return 0;750}751 752static int vadc_get_fw_data(struct vadc_priv *vadc)753{754 const struct vadc_channels *vadc_chan;755 struct iio_chan_spec *iio_chan;756 struct vadc_channel_prop prop;757 struct fwnode_handle *child;758 unsigned int index = 0;759 int ret;760 761 vadc->nchannels = device_get_child_node_count(vadc->dev);762 if (!vadc->nchannels)763 return -EINVAL;764 765 vadc->iio_chans = devm_kcalloc(vadc->dev, vadc->nchannels,766 sizeof(*vadc->iio_chans), GFP_KERNEL);767 if (!vadc->iio_chans)768 return -ENOMEM;769 770 vadc->chan_props = devm_kcalloc(vadc->dev, vadc->nchannels,771 sizeof(*vadc->chan_props), GFP_KERNEL);772 if (!vadc->chan_props)773 return -ENOMEM;774 775 iio_chan = vadc->iio_chans;776 777 device_for_each_child_node(vadc->dev, child) {778 ret = vadc_get_fw_channel_data(vadc->dev, &prop, child);779 if (ret) {780 fwnode_handle_put(child);781 return ret;782 }783 784 prop.scale_fn_type = vadc_chans[prop.channel].scale_fn_type;785 vadc->chan_props[index] = prop;786 787 vadc_chan = &vadc_chans[prop.channel];788 789 iio_chan->channel = prop.channel;790 iio_chan->datasheet_name = vadc_chan->datasheet_name;791 iio_chan->info_mask_separate = vadc_chan->info_mask;792 iio_chan->type = vadc_chan->type;793 iio_chan->indexed = 1;794 iio_chan->address = index++;795 796 iio_chan++;797 }798 799 /* These channels are mandatory, they are used as reference points */800 if (!vadc_get_channel(vadc, VADC_REF_1250MV)) {801 dev_err(vadc->dev, "Please define 1.25V channel\n");802 return -ENODEV;803 }804 805 if (!vadc_get_channel(vadc, VADC_REF_625MV)) {806 dev_err(vadc->dev, "Please define 0.625V channel\n");807 return -ENODEV;808 }809 810 if (!vadc_get_channel(vadc, VADC_VDD_VADC)) {811 dev_err(vadc->dev, "Please define VDD channel\n");812 return -ENODEV;813 }814 815 if (!vadc_get_channel(vadc, VADC_GND_REF)) {816 dev_err(vadc->dev, "Please define GND channel\n");817 return -ENODEV;818 }819 820 return 0;821}822 823static irqreturn_t vadc_isr(int irq, void *dev_id)824{825 struct vadc_priv *vadc = dev_id;826 827 complete(&vadc->complete);828 829 return IRQ_HANDLED;830}831 832static int vadc_check_revision(struct vadc_priv *vadc)833{834 u8 val;835 int ret;836 837 ret = vadc_read(vadc, VADC_PERPH_TYPE, &val);838 if (ret)839 return ret;840 841 if (val < VADC_PERPH_TYPE_ADC) {842 dev_err(vadc->dev, "%d is not ADC\n", val);843 return -ENODEV;844 }845 846 ret = vadc_read(vadc, VADC_PERPH_SUBTYPE, &val);847 if (ret)848 return ret;849 850 if (val < VADC_PERPH_SUBTYPE_VADC) {851 dev_err(vadc->dev, "%d is not VADC\n", val);852 return -ENODEV;853 }854 855 ret = vadc_read(vadc, VADC_REVISION2, &val);856 if (ret)857 return ret;858 859 if (val < VADC_REVISION2_SUPPORTED_VADC) {860 dev_err(vadc->dev, "revision %d not supported\n", val);861 return -ENODEV;862 }863 864 return 0;865}866 867static int vadc_probe(struct platform_device *pdev)868{869 struct device *dev = &pdev->dev;870 struct iio_dev *indio_dev;871 struct vadc_priv *vadc;872 struct regmap *regmap;873 int ret, irq_eoc;874 u32 reg;875 876 regmap = dev_get_regmap(dev->parent, NULL);877 if (!regmap)878 return -ENODEV;879 880 ret = device_property_read_u32(dev, "reg", ®);881 if (ret < 0)882 return ret;883 884 indio_dev = devm_iio_device_alloc(dev, sizeof(*vadc));885 if (!indio_dev)886 return -ENOMEM;887 888 vadc = iio_priv(indio_dev);889 vadc->regmap = regmap;890 vadc->dev = dev;891 vadc->base = reg;892 vadc->are_ref_measured = false;893 init_completion(&vadc->complete);894 mutex_init(&vadc->lock);895 896 ret = vadc_check_revision(vadc);897 if (ret)898 return ret;899 900 ret = vadc_get_fw_data(vadc);901 if (ret)902 return ret;903 904 irq_eoc = platform_get_irq(pdev, 0);905 if (irq_eoc < 0) {906 if (irq_eoc == -EPROBE_DEFER || irq_eoc == -EINVAL)907 return irq_eoc;908 vadc->poll_eoc = true;909 } else {910 ret = devm_request_irq(dev, irq_eoc, vadc_isr, 0,911 "spmi-vadc", vadc);912 if (ret)913 return ret;914 }915 916 ret = vadc_reset(vadc);917 if (ret) {918 dev_err(dev, "reset failed\n");919 return ret;920 }921 922 ret = vadc_measure_ref_points(vadc);923 if (ret)924 return ret;925 926 indio_dev->name = pdev->name;927 indio_dev->modes = INDIO_DIRECT_MODE;928 indio_dev->info = &vadc_info;929 indio_dev->channels = vadc->iio_chans;930 indio_dev->num_channels = vadc->nchannels;931 932 return devm_iio_device_register(dev, indio_dev);933}934 935static const struct of_device_id vadc_match_table[] = {936 { .compatible = "qcom,spmi-vadc" },937 { }938};939MODULE_DEVICE_TABLE(of, vadc_match_table);940 941static struct platform_driver vadc_driver = {942 .driver = {943 .name = "qcom-spmi-vadc",944 .of_match_table = vadc_match_table,945 },946 .probe = vadc_probe,947};948module_platform_driver(vadc_driver);949 950MODULE_ALIAS("platform:qcom-spmi-vadc");951MODULE_DESCRIPTION("Qualcomm SPMI PMIC voltage ADC driver");952MODULE_LICENSE("GPL v2");953MODULE_AUTHOR("Stanimir Varbanov <svarbanov@mm-sol.com>");954MODULE_AUTHOR("Ivan T. Ivanov <iivanov@mm-sol.com>");955