1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 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 0x1 27 #define VADC_REVISION2_SUPPORTED_VADC 1 28 29 #define VADC_PERPH_TYPE 0x4 30 #define VADC_PERPH_TYPE_ADC 8 31 32 #define VADC_PERPH_SUBTYPE 0x5 33 #define VADC_PERPH_SUBTYPE_VADC 1 34 35 #define VADC_STATUS1 0x8 36 #define VADC_STATUS1_OP_MODE 4 37 #define VADC_STATUS1_REQ_STS BIT(1) 38 #define VADC_STATUS1_EOC BIT(0) 39 #define VADC_STATUS1_REQ_STS_EOC_MASK 0x3 40 41 #define VADC_MODE_CTL 0x40 42 #define VADC_OP_MODE_SHIFT 3 43 #define VADC_OP_MODE_NORMAL 0 44 #define VADC_AMUX_TRIM_EN BIT(1) 45 #define VADC_ADC_TRIM_EN BIT(0) 46 47 #define VADC_EN_CTL1 0x46 48 #define VADC_EN_CTL1_SET BIT(7) 49 50 #define VADC_ADC_CH_SEL_CTL 0x48 51 52 #define VADC_ADC_DIG_PARAM 0x50 53 #define VADC_ADC_DIG_DEC_RATIO_SEL_SHIFT 2 54 55 #define VADC_HW_SETTLE_DELAY 0x51 56 57 #define VADC_CONV_REQ 0x52 58 #define VADC_CONV_REQ_SET BIT(7) 59 60 #define VADC_FAST_AVG_CTL 0x5a 61 #define VADC_FAST_AVG_EN 0x5b 62 #define VADC_FAST_AVG_EN_SET BIT(7) 63 64 #define VADC_ACCESS 0xd0 65 #define VADC_ACCESS_DATA 0xa5 66 67 #define VADC_PERH_RESET_CTL3 0xda 68 #define VADC_FOLLOW_WARM_RB BIT(2) 69 70 #define VADC_DATA 0x60 /* 16 bits */ 71 72 #define VADC_CHAN_MIN VADC_USBIN 73 #define VADC_CHAN_MAX VADC_LR_MUX3_BUF_PU1_PU2_XO_THERM 74 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 the 82 * start of conversion. 83 * @avg_samples: ability to provide single result from the ADC 84 * that is an average of multiple measurements. 85 * @scale_fn_type: Represents the scaling function to convert voltage 86 * physical units desired by the client for the channel. 87 * @channel_name: Channel name used in device tree. 88 */ 89 struct 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 */ 114 struct 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 128 static 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 139 static 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 144 static int vadc_write(struct vadc_priv *vadc, u16 offset, u8 data) 145 { 146 return regmap_write(vadc->regmap, vadc->base + offset, data); 147 } 148 149 static 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 171 static 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 176 static 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 210 static 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 else 246 ret = vadc_write(vadc, VADC_FAST_AVG_EN, 0); 247 248 return ret; 249 } 250 251 static 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 276 static 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 289 static 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 303 static 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 345 err_disable: 346 vadc_set_state(vadc, false); 347 if (ret) 348 dev_err(vadc->dev, "conversion failed\n"); 349 unlock: 350 mutex_unlock(&vadc->lock); 351 return ret; 352 } 353 354 static 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; 403 err: 404 if (ret) 405 dev_err(vadc->dev, "measure reference points failed\n"); 406 407 return ret; 408 } 409 410 static 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 425 static 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 else 433 value = value / 2000 + 10; 434 435 return value; 436 } 437 438 static 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 446 static 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 487 static 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 500 static 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 509 static 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 515 struct 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. The 558 * gaps in the array should be treated as reserved channels. 559 */ 560 static 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 663 static 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 else 745 prop->calibration = VADC_CALIB_ABSOLUTE; 746 747 dev_dbg(dev, "%02x name %s\n", chan, name); 748 749 return 0; 750 } 751 752 static 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 823 static 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 832 static 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 867 static 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 935 static const struct of_device_id vadc_match_table[] = { 936 { .compatible = "qcom,spmi-vadc" }, 937 { } 938 }; 939 MODULE_DEVICE_TABLE(of, vadc_match_table); 940 941 static 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 }; 948 module_platform_driver(vadc_driver); 949 950 MODULE_ALIAS("platform:qcom-spmi-vadc"); 951 MODULE_DESCRIPTION("Qualcomm SPMI PMIC voltage ADC driver"); 952 MODULE_LICENSE("GPL v2"); 953 MODULE_AUTHOR("Stanimir Varbanov <svarbanov@mm-sol.com>"); 954 MODULE_AUTHOR("Ivan T. Ivanov <iivanov@mm-sol.com>"); 955