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