drivers/iio/adc/qcom-vadc-common.c

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