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