1 // SPDX-License-Identifier: GPL-2.0 2 #include <linux/bug.h> 3 #include <linux/kernel.h> 4 #include <linux/bitops.h> 5 #include <linux/fixp-arith.h> 6 #include <linux/iio/adc/qcom-vadc-common.h> 7 #include <linux/math64.h> 8 #include <linux/log2.h> 9 #include <linux/err.h> 10 #include <linux/module.h> 11 #include <linux/units.h> 12 13 /** 14 * struct vadc_map_pt - Map the graph representation for ADC channel 15 * @x: Represent the ADC digitized code. 16 * @y: Represent the physical data which can be temperature, voltage, 17 * resistance. 18 */ 19 struct vadc_map_pt { 20 s32 x; 21 s32 y; 22 }; 23 24 /* Voltage to temperature */ 25 static const struct vadc_map_pt adcmap_100k_104ef_104fb[] = { 26 {1758, -40000 }, 27 {1742, -35000 }, 28 {1719, -30000 }, 29 {1691, -25000 }, 30 {1654, -20000 }, 31 {1608, -15000 }, 32 {1551, -10000 }, 33 {1483, -5000 }, 34 {1404, 0 }, 35 {1315, 5000 }, 36 {1218, 10000 }, 37 {1114, 15000 }, 38 {1007, 20000 }, 39 {900, 25000 }, 40 {795, 30000 }, 41 {696, 35000 }, 42 {605, 40000 }, 43 {522, 45000 }, 44 {448, 50000 }, 45 {383, 55000 }, 46 {327, 60000 }, 47 {278, 65000 }, 48 {237, 70000 }, 49 {202, 75000 }, 50 {172, 80000 }, 51 {146, 85000 }, 52 {125, 90000 }, 53 {107, 95000 }, 54 {92, 100000 }, 55 {79, 105000 }, 56 {68, 110000 }, 57 {59, 115000 }, 58 {51, 120000 }, 59 {44, 125000 } 60 }; 61 62 /* 63 * Voltage to temperature table for 100k pull up for NTCG104EF104 with 64 * 1.875V reference. 65 */ 66 static const struct vadc_map_pt adcmap_100k_104ef_104fb_1875_vref[] = { 67 { 1831, -40000 }, 68 { 1814, -35000 }, 69 { 1791, -30000 }, 70 { 1761, -25000 }, 71 { 1723, -20000 }, 72 { 1675, -15000 }, 73 { 1616, -10000 }, 74 { 1545, -5000 }, 75 { 1463, 0 }, 76 { 1370, 5000 }, 77 { 1268, 10000 }, 78 { 1160, 15000 }, 79 { 1049, 20000 }, 80 { 937, 25000 }, 81 { 828, 30000 }, 82 { 726, 35000 }, 83 { 630, 40000 }, 84 { 544, 45000 }, 85 { 467, 50000 }, 86 { 399, 55000 }, 87 { 340, 60000 }, 88 { 290, 65000 }, 89 { 247, 70000 }, 90 { 209, 75000 }, 91 { 179, 80000 }, 92 { 153, 85000 }, 93 { 130, 90000 }, 94 { 112, 95000 }, 95 { 96, 100000 }, 96 { 82, 105000 }, 97 { 71, 110000 }, 98 { 62, 115000 }, 99 { 53, 120000 }, 100 { 46, 125000 }, 101 }; 102 103 static const struct vadc_map_pt adcmap7_die_temp[] = { 104 { 857300, 160000 }, 105 { 820100, 140000 }, 106 { 782500, 120000 }, 107 { 744600, 100000 }, 108 { 706400, 80000 }, 109 { 667900, 60000 }, 110 { 629300, 40000 }, 111 { 590500, 20000 }, 112 { 551500, 0 }, 113 { 512400, -20000 }, 114 { 473100, -40000 }, 115 { 433700, -60000 }, 116 }; 117 118 /* 119 * Resistance to temperature table for 100k pull up for NTCG104EF104. 120 */ 121 static const struct vadc_map_pt adcmap7_100k[] = { 122 { 4250657, -40960 }, 123 { 3962085, -39936 }, 124 { 3694875, -38912 }, 125 { 3447322, -37888 }, 126 { 3217867, -36864 }, 127 { 3005082, -35840 }, 128 { 2807660, -34816 }, 129 { 2624405, -33792 }, 130 { 2454218, -32768 }, 131 { 2296094, -31744 }, 132 { 2149108, -30720 }, 133 { 2012414, -29696 }, 134 { 1885232, -28672 }, 135 { 1766846, -27648 }, 136 { 1656598, -26624 }, 137 { 1553884, -25600 }, 138 { 1458147, -24576 }, 139 { 1368873, -23552 }, 140 { 1285590, -22528 }, 141 { 1207863, -21504 }, 142 { 1135290, -20480 }, 143 { 1067501, -19456 }, 144 { 1004155, -18432 }, 145 { 944935, -17408 }, 146 { 889550, -16384 }, 147 { 837731, -15360 }, 148 { 789229, -14336 }, 149 { 743813, -13312 }, 150 { 701271, -12288 }, 151 { 661405, -11264 }, 152 { 624032, -10240 }, 153 { 588982, -9216 }, 154 { 556100, -8192 }, 155 { 525239, -7168 }, 156 { 496264, -6144 }, 157 { 469050, -5120 }, 158 { 443480, -4096 }, 159 { 419448, -3072 }, 160 { 396851, -2048 }, 161 { 375597, -1024 }, 162 { 355598, 0 }, 163 { 336775, 1024 }, 164 { 319052, 2048 }, 165 { 302359, 3072 }, 166 { 286630, 4096 }, 167 { 271806, 5120 }, 168 { 257829, 6144 }, 169 { 244646, 7168 }, 170 { 232209, 8192 }, 171 { 220471, 9216 }, 172 { 209390, 10240 }, 173 { 198926, 11264 }, 174 { 189040, 12288 }, 175 { 179698, 13312 }, 176 { 170868, 14336 }, 177 { 162519, 15360 }, 178 { 154622, 16384 }, 179 { 147150, 17408 }, 180 { 140079, 18432 }, 181 { 133385, 19456 }, 182 { 127046, 20480 }, 183 { 121042, 21504 }, 184 { 115352, 22528 }, 185 { 109960, 23552 }, 186 { 104848, 24576 }, 187 { 100000, 25600 }, 188 { 95402, 26624 }, 189 { 91038, 27648 }, 190 { 86897, 28672 }, 191 { 82965, 29696 }, 192 { 79232, 30720 }, 193 { 75686, 31744 }, 194 { 72316, 32768 }, 195 { 69114, 33792 }, 196 { 66070, 34816 }, 197 { 63176, 35840 }, 198 { 60423, 36864 }, 199 { 57804, 37888 }, 200 { 55312, 38912 }, 201 { 52940, 39936 }, 202 { 50681, 40960 }, 203 { 48531, 41984 }, 204 { 46482, 43008 }, 205 { 44530, 44032 }, 206 { 42670, 45056 }, 207 { 40897, 46080 }, 208 { 39207, 47104 }, 209 { 37595, 48128 }, 210 { 36057, 49152 }, 211 { 34590, 50176 }, 212 { 33190, 51200 }, 213 { 31853, 52224 }, 214 { 30577, 53248 }, 215 { 29358, 54272 }, 216 { 28194, 55296 }, 217 { 27082, 56320 }, 218 { 26020, 57344 }, 219 { 25004, 58368 }, 220 { 24033, 59392 }, 221 { 23104, 60416 }, 222 { 22216, 61440 }, 223 { 21367, 62464 }, 224 { 20554, 63488 }, 225 { 19776, 64512 }, 226 { 19031, 65536 }, 227 { 18318, 66560 }, 228 { 17636, 67584 }, 229 { 16982, 68608 }, 230 { 16355, 69632 }, 231 { 15755, 70656 }, 232 { 15180, 71680 }, 233 { 14628, 72704 }, 234 { 14099, 73728 }, 235 { 13592, 74752 }, 236 { 13106, 75776 }, 237 { 12640, 76800 }, 238 { 12192, 77824 }, 239 { 11762, 78848 }, 240 { 11350, 79872 }, 241 { 10954, 80896 }, 242 { 10574, 81920 }, 243 { 10209, 82944 }, 244 { 9858, 83968 }, 245 { 9521, 84992 }, 246 { 9197, 86016 }, 247 { 8886, 87040 }, 248 { 8587, 88064 }, 249 { 8299, 89088 }, 250 { 8023, 90112 }, 251 { 7757, 91136 }, 252 { 7501, 92160 }, 253 { 7254, 93184 }, 254 { 7017, 94208 }, 255 { 6789, 95232 }, 256 { 6570, 96256 }, 257 { 6358, 97280 }, 258 { 6155, 98304 }, 259 { 5959, 99328 }, 260 { 5770, 100352 }, 261 { 5588, 101376 }, 262 { 5412, 102400 }, 263 { 5243, 103424 }, 264 { 5080, 104448 }, 265 { 4923, 105472 }, 266 { 4771, 106496 }, 267 { 4625, 107520 }, 268 { 4484, 108544 }, 269 { 4348, 109568 }, 270 { 4217, 110592 }, 271 { 4090, 111616 }, 272 { 3968, 112640 }, 273 { 3850, 113664 }, 274 { 3736, 114688 }, 275 { 3626, 115712 }, 276 { 3519, 116736 }, 277 { 3417, 117760 }, 278 { 3317, 118784 }, 279 { 3221, 119808 }, 280 { 3129, 120832 }, 281 { 3039, 121856 }, 282 { 2952, 122880 }, 283 { 2868, 123904 }, 284 { 2787, 124928 }, 285 { 2709, 125952 }, 286 { 2633, 126976 }, 287 { 2560, 128000 }, 288 { 2489, 129024 }, 289 { 2420, 130048 } 290 }; 291 292 static const struct u32_fract adc5_prescale_ratios[] = { 293 { .numerator = 1, .denominator = 1 }, 294 { .numerator = 1, .denominator = 3 }, 295 { .numerator = 1, .denominator = 4 }, 296 { .numerator = 1, .denominator = 6 }, 297 { .numerator = 1, .denominator = 20 }, 298 { .numerator = 1, .denominator = 8 }, 299 { .numerator = 10, .denominator = 81 }, 300 { .numerator = 1, .denominator = 10 }, 301 { .numerator = 1, .denominator = 16 }, 302 }; 303 304 static int qcom_vadc_scale_hw_calib_volt( 305 const struct u32_fract *prescale, 306 const struct adc5_data *data, 307 u16 adc_code, int *result_uv); 308 static int qcom_vadc_scale_hw_calib_therm( 309 const struct u32_fract *prescale, 310 const struct adc5_data *data, 311 u16 adc_code, int *result_mdec); 312 static int qcom_vadc7_scale_hw_calib_therm( 313 const struct u32_fract *prescale, 314 const struct adc5_data *data, 315 u16 adc_code, int *result_mdec); 316 static int qcom_vadc_scale_hw_smb_temp( 317 const struct u32_fract *prescale, 318 const struct adc5_data *data, 319 u16 adc_code, int *result_mdec); 320 static int qcom_vadc_scale_hw_chg5_temp( 321 const struct u32_fract *prescale, 322 const struct adc5_data *data, 323 u16 adc_code, int *result_mdec); 324 static int qcom_vadc_scale_hw_calib_die_temp( 325 const struct u32_fract *prescale, 326 const struct adc5_data *data, 327 u16 adc_code, int *result_mdec); 328 static int qcom_vadc7_scale_hw_calib_die_temp( 329 const struct u32_fract *prescale, 330 const struct adc5_data *data, 331 u16 adc_code, int *result_mdec); 332 333 static struct qcom_adc5_scale_type scale_adc5_fn[] = { 334 [SCALE_HW_CALIB_DEFAULT] = {qcom_vadc_scale_hw_calib_volt}, 335 [SCALE_HW_CALIB_THERM_100K_PULLUP] = {qcom_vadc_scale_hw_calib_therm}, 336 [SCALE_HW_CALIB_XOTHERM] = {qcom_vadc_scale_hw_calib_therm}, 337 [SCALE_HW_CALIB_THERM_100K_PU_PM7] = { 338 qcom_vadc7_scale_hw_calib_therm}, 339 [SCALE_HW_CALIB_PMIC_THERM] = {qcom_vadc_scale_hw_calib_die_temp}, 340 [SCALE_HW_CALIB_PMIC_THERM_PM7] = { 341 qcom_vadc7_scale_hw_calib_die_temp}, 342 [SCALE_HW_CALIB_PM5_CHG_TEMP] = {qcom_vadc_scale_hw_chg5_temp}, 343 [SCALE_HW_CALIB_PM5_SMB_TEMP] = {qcom_vadc_scale_hw_smb_temp}, 344 }; 345 346 static int qcom_vadc_map_voltage_temp(const struct vadc_map_pt *pts, 347 u32 tablesize, s32 input, int *output) 348 { 349 u32 i = 0; 350 351 if (!pts) 352 return -EINVAL; 353 354 while (i < tablesize && pts[i].x > input) 355 i++; 356 357 if (i == 0) { 358 *output = pts[0].y; 359 } else if (i == tablesize) { 360 *output = pts[tablesize - 1].y; 361 } else { 362 /* interpolate linearly */ 363 *output = fixp_linear_interpolate(pts[i - 1].x, pts[i - 1].y, 364 pts[i].x, pts[i].y, 365 input); 366 } 367 368 return 0; 369 } 370 371 static s32 qcom_vadc_map_temp_voltage(const struct vadc_map_pt *pts, 372 u32 tablesize, int input) 373 { 374 u32 i = 0; 375 376 /* 377 * Table must be sorted, find the interval of 'y' which contains value 378 * 'input' and map it to proper 'x' value 379 */ 380 while (i < tablesize && pts[i].y < input) 381 i++; 382 383 if (i == 0) 384 return pts[0].x; 385 if (i == tablesize) 386 return pts[tablesize - 1].x; 387 388 /* interpolate linearly */ 389 return fixp_linear_interpolate(pts[i - 1].y, pts[i - 1].x, 390 pts[i].y, pts[i].x, input); 391 } 392 393 static void qcom_vadc_scale_calib(const struct vadc_linear_graph *calib_graph, 394 u16 adc_code, 395 bool absolute, 396 s64 *scale_voltage) 397 { 398 *scale_voltage = (adc_code - calib_graph->gnd); 399 *scale_voltage *= calib_graph->dx; 400 *scale_voltage = div64_s64(*scale_voltage, calib_graph->dy); 401 if (absolute) 402 *scale_voltage += calib_graph->dx; 403 404 if (*scale_voltage < 0) 405 *scale_voltage = 0; 406 } 407 408 static int qcom_vadc_scale_volt(const struct vadc_linear_graph *calib_graph, 409 const struct u32_fract *prescale, 410 bool absolute, u16 adc_code, 411 int *result_uv) 412 { 413 s64 voltage = 0, result = 0; 414 415 qcom_vadc_scale_calib(calib_graph, adc_code, absolute, &voltage); 416 417 voltage *= prescale->denominator; 418 result = div64_s64(voltage, prescale->numerator); 419 *result_uv = result; 420 421 return 0; 422 } 423 424 static int qcom_vadc_scale_therm(const struct vadc_linear_graph *calib_graph, 425 const struct u32_fract *prescale, 426 bool absolute, u16 adc_code, 427 int *result_mdec) 428 { 429 s64 voltage = 0; 430 int ret; 431 432 qcom_vadc_scale_calib(calib_graph, adc_code, absolute, &voltage); 433 434 if (absolute) 435 voltage = div64_s64(voltage, 1000); 436 437 ret = qcom_vadc_map_voltage_temp(adcmap_100k_104ef_104fb, 438 ARRAY_SIZE(adcmap_100k_104ef_104fb), 439 voltage, result_mdec); 440 if (ret) 441 return ret; 442 443 return 0; 444 } 445 446 static int qcom_vadc_scale_die_temp(const struct vadc_linear_graph *calib_graph, 447 const struct u32_fract *prescale, 448 bool absolute, 449 u16 adc_code, int *result_mdec) 450 { 451 s64 voltage = 0; 452 u64 temp; /* Temporary variable for do_div */ 453 454 qcom_vadc_scale_calib(calib_graph, adc_code, absolute, &voltage); 455 456 if (voltage > 0) { 457 temp = voltage * prescale->denominator; 458 do_div(temp, prescale->numerator * 2); 459 voltage = temp; 460 } else { 461 voltage = 0; 462 } 463 464 *result_mdec = milli_kelvin_to_millicelsius(voltage); 465 466 return 0; 467 } 468 469 static int qcom_vadc_scale_chg_temp(const struct vadc_linear_graph *calib_graph, 470 const struct u32_fract *prescale, 471 bool absolute, 472 u16 adc_code, int *result_mdec) 473 { 474 s64 voltage = 0, result = 0; 475 476 qcom_vadc_scale_calib(calib_graph, adc_code, absolute, &voltage); 477 478 voltage *= prescale->denominator; 479 voltage = div64_s64(voltage, prescale->numerator); 480 voltage = ((PMI_CHG_SCALE_1) * (voltage * 2)); 481 voltage = (voltage + PMI_CHG_SCALE_2); 482 result = div64_s64(voltage, 1000000); 483 *result_mdec = result; 484 485 return 0; 486 } 487 488 /* convert voltage to ADC code, using 1.875V reference */ 489 static u16 qcom_vadc_scale_voltage_code(s32 voltage, 490 const struct u32_fract *prescale, 491 const u32 full_scale_code_volt, 492 unsigned int factor) 493 { 494 s64 volt = voltage; 495 s64 adc_vdd_ref_mv = 1875; /* reference voltage */ 496 497 volt *= prescale->numerator * factor * full_scale_code_volt; 498 volt = div64_s64(volt, (s64)prescale->denominator * adc_vdd_ref_mv * 1000); 499 500 return volt; 501 } 502 503 static int qcom_vadc_scale_code_voltage_factor(u16 adc_code, 504 const struct u32_fract *prescale, 505 const struct adc5_data *data, 506 unsigned int factor) 507 { 508 s64 voltage, temp, adc_vdd_ref_mv = 1875; 509 510 /* 511 * The normal data range is between 0V to 1.875V. On cases where 512 * we read low voltage values, the ADC code can go beyond the 513 * range and the scale result is incorrect so we clamp the values 514 * for the cases where the code represents a value below 0V 515 */ 516 if (adc_code > VADC5_MAX_CODE) 517 adc_code = 0; 518 519 /* (ADC code * vref_vadc (1.875V)) / full_scale_code */ 520 voltage = (s64) adc_code * adc_vdd_ref_mv * 1000; 521 voltage = div64_s64(voltage, data->full_scale_code_volt); 522 if (voltage > 0) { 523 voltage *= prescale->denominator; 524 temp = prescale->numerator * factor; 525 voltage = div64_s64(voltage, temp); 526 } else { 527 voltage = 0; 528 } 529 530 return (int) voltage; 531 } 532 533 static int qcom_vadc7_scale_hw_calib_therm( 534 const struct u32_fract *prescale, 535 const struct adc5_data *data, 536 u16 adc_code, int *result_mdec) 537 { 538 s64 resistance = adc_code; 539 int ret, result; 540 541 if (adc_code >= RATIO_MAX_ADC7) 542 return -EINVAL; 543 544 /* (ADC code * R_PULLUP (100Kohm)) / (full_scale_code - ADC code)*/ 545 resistance *= R_PU_100K; 546 resistance = div64_s64(resistance, RATIO_MAX_ADC7 - adc_code); 547 548 ret = qcom_vadc_map_voltage_temp(adcmap7_100k, 549 ARRAY_SIZE(adcmap7_100k), 550 resistance, &result); 551 if (ret) 552 return ret; 553 554 *result_mdec = result; 555 556 return 0; 557 } 558 559 static int qcom_vadc_scale_hw_calib_volt( 560 const struct u32_fract *prescale, 561 const struct adc5_data *data, 562 u16 adc_code, int *result_uv) 563 { 564 *result_uv = qcom_vadc_scale_code_voltage_factor(adc_code, 565 prescale, data, 1); 566 567 return 0; 568 } 569 570 static int qcom_vadc_scale_hw_calib_therm( 571 const struct u32_fract *prescale, 572 const struct adc5_data *data, 573 u16 adc_code, int *result_mdec) 574 { 575 int voltage; 576 577 voltage = qcom_vadc_scale_code_voltage_factor(adc_code, 578 prescale, data, 1000); 579 580 /* Map voltage to temperature from look-up table */ 581 return qcom_vadc_map_voltage_temp(adcmap_100k_104ef_104fb_1875_vref, 582 ARRAY_SIZE(adcmap_100k_104ef_104fb_1875_vref), 583 voltage, result_mdec); 584 } 585 586 static int qcom_vadc_scale_hw_calib_die_temp( 587 const struct u32_fract *prescale, 588 const struct adc5_data *data, 589 u16 adc_code, int *result_mdec) 590 { 591 *result_mdec = qcom_vadc_scale_code_voltage_factor(adc_code, 592 prescale, data, 2); 593 *result_mdec = milli_kelvin_to_millicelsius(*result_mdec); 594 595 return 0; 596 } 597 598 static int qcom_vadc7_scale_hw_calib_die_temp( 599 const struct u32_fract *prescale, 600 const struct adc5_data *data, 601 u16 adc_code, int *result_mdec) 602 { 603 604 int voltage; 605 606 voltage = qcom_vadc_scale_code_voltage_factor(adc_code, 607 prescale, data, 1); 608 609 return qcom_vadc_map_voltage_temp(adcmap7_die_temp, ARRAY_SIZE(adcmap7_die_temp), 610 voltage, result_mdec); 611 } 612 613 static int qcom_vadc_scale_hw_smb_temp( 614 const struct u32_fract *prescale, 615 const struct adc5_data *data, 616 u16 adc_code, int *result_mdec) 617 { 618 *result_mdec = qcom_vadc_scale_code_voltage_factor(adc_code * 100, 619 prescale, data, PMIC5_SMB_TEMP_SCALE_FACTOR); 620 *result_mdec = PMIC5_SMB_TEMP_CONSTANT - *result_mdec; 621 622 return 0; 623 } 624 625 static int qcom_vadc_scale_hw_chg5_temp( 626 const struct u32_fract *prescale, 627 const struct adc5_data *data, 628 u16 adc_code, int *result_mdec) 629 { 630 *result_mdec = qcom_vadc_scale_code_voltage_factor(adc_code, 631 prescale, data, 4); 632 *result_mdec = PMIC5_CHG_TEMP_SCALE_FACTOR - *result_mdec; 633 634 return 0; 635 } 636 637 int qcom_vadc_scale(enum vadc_scale_fn_type scaletype, 638 const struct vadc_linear_graph *calib_graph, 639 const struct u32_fract *prescale, 640 bool absolute, 641 u16 adc_code, int *result) 642 { 643 switch (scaletype) { 644 case SCALE_DEFAULT: 645 return qcom_vadc_scale_volt(calib_graph, prescale, 646 absolute, adc_code, 647 result); 648 case SCALE_THERM_100K_PULLUP: 649 case SCALE_XOTHERM: 650 return qcom_vadc_scale_therm(calib_graph, prescale, 651 absolute, adc_code, 652 result); 653 case SCALE_PMIC_THERM: 654 return qcom_vadc_scale_die_temp(calib_graph, prescale, 655 absolute, adc_code, 656 result); 657 case SCALE_PMI_CHG_TEMP: 658 return qcom_vadc_scale_chg_temp(calib_graph, prescale, 659 absolute, adc_code, 660 result); 661 default: 662 return -EINVAL; 663 } 664 } 665 EXPORT_SYMBOL(qcom_vadc_scale); 666 667 u16 qcom_adc_tm5_temp_volt_scale(unsigned int prescale_ratio, 668 u32 full_scale_code_volt, int temp) 669 { 670 const struct u32_fract *prescale = &adc5_prescale_ratios[prescale_ratio]; 671 s32 voltage; 672 673 voltage = qcom_vadc_map_temp_voltage(adcmap_100k_104ef_104fb_1875_vref, 674 ARRAY_SIZE(adcmap_100k_104ef_104fb_1875_vref), 675 temp); 676 return qcom_vadc_scale_voltage_code(voltage, prescale, full_scale_code_volt, 1000); 677 } 678 EXPORT_SYMBOL(qcom_adc_tm5_temp_volt_scale); 679 680 int qcom_adc5_hw_scale(enum vadc_scale_fn_type scaletype, 681 unsigned int prescale_ratio, 682 const struct adc5_data *data, 683 u16 adc_code, int *result) 684 { 685 const struct u32_fract *prescale = &adc5_prescale_ratios[prescale_ratio]; 686 687 if (!(scaletype >= SCALE_HW_CALIB_DEFAULT && 688 scaletype < SCALE_HW_CALIB_INVALID)) { 689 pr_err("Invalid scale type %d\n", scaletype); 690 return -EINVAL; 691 } 692 693 return scale_adc5_fn[scaletype].scale_fn(prescale, data, 694 adc_code, result); 695 } 696 EXPORT_SYMBOL(qcom_adc5_hw_scale); 697 698 int qcom_adc5_prescaling_from_dt(u32 numerator, u32 denominator) 699 { 700 unsigned int pre; 701 702 for (pre = 0; pre < ARRAY_SIZE(adc5_prescale_ratios); pre++) 703 if (adc5_prescale_ratios[pre].numerator == numerator && 704 adc5_prescale_ratios[pre].denominator == denominator) 705 break; 706 707 if (pre == ARRAY_SIZE(adc5_prescale_ratios)) 708 return -EINVAL; 709 710 return pre; 711 } 712 EXPORT_SYMBOL(qcom_adc5_prescaling_from_dt); 713 714 int qcom_adc5_hw_settle_time_from_dt(u32 value, 715 const unsigned int *hw_settle) 716 { 717 unsigned int i; 718 719 for (i = 0; i < VADC_HW_SETTLE_SAMPLES_MAX; i++) { 720 if (value == hw_settle[i]) 721 return i; 722 } 723 724 return -EINVAL; 725 } 726 EXPORT_SYMBOL(qcom_adc5_hw_settle_time_from_dt); 727 728 int qcom_adc5_avg_samples_from_dt(u32 value) 729 { 730 if (!is_power_of_2(value) || value > ADC5_AVG_SAMPLES_MAX) 731 return -EINVAL; 732 733 return __ffs(value); 734 } 735 EXPORT_SYMBOL(qcom_adc5_avg_samples_from_dt); 736 737 int qcom_adc5_decimation_from_dt(u32 value, const unsigned int *decimation) 738 { 739 unsigned int i; 740 741 for (i = 0; i < ADC5_DECIMATION_SAMPLES_MAX; i++) { 742 if (value == decimation[i]) 743 return i; 744 } 745 746 return -EINVAL; 747 } 748 EXPORT_SYMBOL(qcom_adc5_decimation_from_dt); 749 750 int qcom_vadc_decimation_from_dt(u32 value) 751 { 752 if (!is_power_of_2(value) || value < VADC_DECIMATION_MIN || 753 value > VADC_DECIMATION_MAX) 754 return -EINVAL; 755 756 return __ffs64(value / VADC_DECIMATION_MIN); 757 } 758 EXPORT_SYMBOL(qcom_vadc_decimation_from_dt); 759 760 MODULE_LICENSE("GPL v2"); 761 MODULE_DESCRIPTION("Qualcomm ADC common functionality"); 762