Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 #include <linux/bug.h>
0003 #include <linux/kernel.h>
0004 #include <linux/bitops.h>
0005 #include <linux/fixp-arith.h>
0006 #include <linux/iio/adc/qcom-vadc-common.h>
0007 #include <linux/math64.h>
0008 #include <linux/log2.h>
0009 #include <linux/err.h>
0010 #include <linux/module.h>
0011 #include <linux/units.h>
0012 
0013 /**
0014  * struct vadc_map_pt - Map the graph representation for ADC channel
0015  * @x: Represent the ADC digitized code.
0016  * @y: Represent the physical data which can be temperature, voltage,
0017  *     resistance.
0018  */
0019 struct vadc_map_pt {
0020     s32 x;
0021     s32 y;
0022 };
0023 
0024 /* Voltage to temperature */
0025 static const struct vadc_map_pt adcmap_100k_104ef_104fb[] = {
0026     {1758,  -40000 },
0027     {1742,  -35000 },
0028     {1719,  -30000 },
0029     {1691,  -25000 },
0030     {1654,  -20000 },
0031     {1608,  -15000 },
0032     {1551,  -10000 },
0033     {1483,  -5000 },
0034     {1404,  0 },
0035     {1315,  5000 },
0036     {1218,  10000 },
0037     {1114,  15000 },
0038     {1007,  20000 },
0039     {900,   25000 },
0040     {795,   30000 },
0041     {696,   35000 },
0042     {605,   40000 },
0043     {522,   45000 },
0044     {448,   50000 },
0045     {383,   55000 },
0046     {327,   60000 },
0047     {278,   65000 },
0048     {237,   70000 },
0049     {202,   75000 },
0050     {172,   80000 },
0051     {146,   85000 },
0052     {125,   90000 },
0053     {107,   95000 },
0054     {92,    100000 },
0055     {79,    105000 },
0056     {68,    110000 },
0057     {59,    115000 },
0058     {51,    120000 },
0059     {44,    125000 }
0060 };
0061 
0062 /*
0063  * Voltage to temperature table for 100k pull up for NTCG104EF104 with
0064  * 1.875V reference.
0065  */
0066 static const struct vadc_map_pt adcmap_100k_104ef_104fb_1875_vref[] = {
0067     { 1831, -40000 },
0068     { 1814, -35000 },
0069     { 1791, -30000 },
0070     { 1761, -25000 },
0071     { 1723, -20000 },
0072     { 1675, -15000 },
0073     { 1616, -10000 },
0074     { 1545, -5000 },
0075     { 1463, 0 },
0076     { 1370, 5000 },
0077     { 1268, 10000 },
0078     { 1160, 15000 },
0079     { 1049, 20000 },
0080     { 937,  25000 },
0081     { 828,  30000 },
0082     { 726,  35000 },
0083     { 630,  40000 },
0084     { 544,  45000 },
0085     { 467,  50000 },
0086     { 399,  55000 },
0087     { 340,  60000 },
0088     { 290,  65000 },
0089     { 247,  70000 },
0090     { 209,  75000 },
0091     { 179,  80000 },
0092     { 153,  85000 },
0093     { 130,  90000 },
0094     { 112,  95000 },
0095     { 96,   100000 },
0096     { 82,   105000 },
0097     { 71,   110000 },
0098     { 62,   115000 },
0099     { 53,   120000 },
0100     { 46,   125000 },
0101 };
0102 
0103 static const struct vadc_map_pt adcmap7_die_temp[] = {
0104     { 857300, 160000 },
0105     { 820100, 140000 },
0106     { 782500, 120000 },
0107     { 744600, 100000 },
0108     { 706400, 80000 },
0109     { 667900, 60000 },
0110     { 629300, 40000 },
0111     { 590500, 20000 },
0112     { 551500, 0 },
0113     { 512400, -20000 },
0114     { 473100, -40000 },
0115     { 433700, -60000 },
0116 };
0117 
0118 /*
0119  * Resistance to temperature table for 100k pull up for NTCG104EF104.
0120  */
0121 static const struct vadc_map_pt adcmap7_100k[] = {
0122     { 4250657, -40960 },
0123     { 3962085, -39936 },
0124     { 3694875, -38912 },
0125     { 3447322, -37888 },
0126     { 3217867, -36864 },
0127     { 3005082, -35840 },
0128     { 2807660, -34816 },
0129     { 2624405, -33792 },
0130     { 2454218, -32768 },
0131     { 2296094, -31744 },
0132     { 2149108, -30720 },
0133     { 2012414, -29696 },
0134     { 1885232, -28672 },
0135     { 1766846, -27648 },
0136     { 1656598, -26624 },
0137     { 1553884, -25600 },
0138     { 1458147, -24576 },
0139     { 1368873, -23552 },
0140     { 1285590, -22528 },
0141     { 1207863, -21504 },
0142     { 1135290, -20480 },
0143     { 1067501, -19456 },
0144     { 1004155, -18432 },
0145     { 944935, -17408 },
0146     { 889550, -16384 },
0147     { 837731, -15360 },
0148     { 789229, -14336 },
0149     { 743813, -13312 },
0150     { 701271, -12288 },
0151     { 661405, -11264 },
0152     { 624032, -10240 },
0153     { 588982, -9216 },
0154     { 556100, -8192 },
0155     { 525239, -7168 },
0156     { 496264, -6144 },
0157     { 469050, -5120 },
0158     { 443480, -4096 },
0159     { 419448, -3072 },
0160     { 396851, -2048 },
0161     { 375597, -1024 },
0162     { 355598, 0 },
0163     { 336775, 1024 },
0164     { 319052, 2048 },
0165     { 302359, 3072 },
0166     { 286630, 4096 },
0167     { 271806, 5120 },
0168     { 257829, 6144 },
0169     { 244646, 7168 },
0170     { 232209, 8192 },
0171     { 220471, 9216 },
0172     { 209390, 10240 },
0173     { 198926, 11264 },
0174     { 189040, 12288 },
0175     { 179698, 13312 },
0176     { 170868, 14336 },
0177     { 162519, 15360 },
0178     { 154622, 16384 },
0179     { 147150, 17408 },
0180     { 140079, 18432 },
0181     { 133385, 19456 },
0182     { 127046, 20480 },
0183     { 121042, 21504 },
0184     { 115352, 22528 },
0185     { 109960, 23552 },
0186     { 104848, 24576 },
0187     { 100000, 25600 },
0188     { 95402, 26624 },
0189     { 91038, 27648 },
0190     { 86897, 28672 },
0191     { 82965, 29696 },
0192     { 79232, 30720 },
0193     { 75686, 31744 },
0194     { 72316, 32768 },
0195     { 69114, 33792 },
0196     { 66070, 34816 },
0197     { 63176, 35840 },
0198     { 60423, 36864 },
0199     { 57804, 37888 },
0200     { 55312, 38912 },
0201     { 52940, 39936 },
0202     { 50681, 40960 },
0203     { 48531, 41984 },
0204     { 46482, 43008 },
0205     { 44530, 44032 },
0206     { 42670, 45056 },
0207     { 40897, 46080 },
0208     { 39207, 47104 },
0209     { 37595, 48128 },
0210     { 36057, 49152 },
0211     { 34590, 50176 },
0212     { 33190, 51200 },
0213     { 31853, 52224 },
0214     { 30577, 53248 },
0215     { 29358, 54272 },
0216     { 28194, 55296 },
0217     { 27082, 56320 },
0218     { 26020, 57344 },
0219     { 25004, 58368 },
0220     { 24033, 59392 },
0221     { 23104, 60416 },
0222     { 22216, 61440 },
0223     { 21367, 62464 },
0224     { 20554, 63488 },
0225     { 19776, 64512 },
0226     { 19031, 65536 },
0227     { 18318, 66560 },
0228     { 17636, 67584 },
0229     { 16982, 68608 },
0230     { 16355, 69632 },
0231     { 15755, 70656 },
0232     { 15180, 71680 },
0233     { 14628, 72704 },
0234     { 14099, 73728 },
0235     { 13592, 74752 },
0236     { 13106, 75776 },
0237     { 12640, 76800 },
0238     { 12192, 77824 },
0239     { 11762, 78848 },
0240     { 11350, 79872 },
0241     { 10954, 80896 },
0242     { 10574, 81920 },
0243     { 10209, 82944 },
0244     { 9858, 83968 },
0245     { 9521, 84992 },
0246     { 9197, 86016 },
0247     { 8886, 87040 },
0248     { 8587, 88064 },
0249     { 8299, 89088 },
0250     { 8023, 90112 },
0251     { 7757, 91136 },
0252     { 7501, 92160 },
0253     { 7254, 93184 },
0254     { 7017, 94208 },
0255     { 6789, 95232 },
0256     { 6570, 96256 },
0257     { 6358, 97280 },
0258     { 6155, 98304 },
0259     { 5959, 99328 },
0260     { 5770, 100352 },
0261     { 5588, 101376 },
0262     { 5412, 102400 },
0263     { 5243, 103424 },
0264     { 5080, 104448 },
0265     { 4923, 105472 },
0266     { 4771, 106496 },
0267     { 4625, 107520 },
0268     { 4484, 108544 },
0269     { 4348, 109568 },
0270     { 4217, 110592 },
0271     { 4090, 111616 },
0272     { 3968, 112640 },
0273     { 3850, 113664 },
0274     { 3736, 114688 },
0275     { 3626, 115712 },
0276     { 3519, 116736 },
0277     { 3417, 117760 },
0278     { 3317, 118784 },
0279     { 3221, 119808 },
0280     { 3129, 120832 },
0281     { 3039, 121856 },
0282     { 2952, 122880 },
0283     { 2868, 123904 },
0284     { 2787, 124928 },
0285     { 2709, 125952 },
0286     { 2633, 126976 },
0287     { 2560, 128000 },
0288     { 2489, 129024 },
0289     { 2420, 130048 }
0290 };
0291 
0292 static const struct u32_fract adc5_prescale_ratios[] = {
0293     { .numerator =  1, .denominator =  1 },
0294     { .numerator =  1, .denominator =  3 },
0295     { .numerator =  1, .denominator =  4 },
0296     { .numerator =  1, .denominator =  6 },
0297     { .numerator =  1, .denominator = 20 },
0298     { .numerator =  1, .denominator =  8 },
0299     { .numerator = 10, .denominator = 81 },
0300     { .numerator =  1, .denominator = 10 },
0301     { .numerator =  1, .denominator = 16 },
0302 };
0303 
0304 static int qcom_vadc_scale_hw_calib_volt(
0305                 const struct u32_fract *prescale,
0306                 const struct adc5_data *data,
0307                 u16 adc_code, int *result_uv);
0308 static int qcom_vadc_scale_hw_calib_therm(
0309                 const struct u32_fract *prescale,
0310                 const struct adc5_data *data,
0311                 u16 adc_code, int *result_mdec);
0312 static int qcom_vadc7_scale_hw_calib_therm(
0313                 const struct u32_fract *prescale,
0314                 const struct adc5_data *data,
0315                 u16 adc_code, int *result_mdec);
0316 static int qcom_vadc_scale_hw_smb_temp(
0317                 const struct u32_fract *prescale,
0318                 const struct adc5_data *data,
0319                 u16 adc_code, int *result_mdec);
0320 static int qcom_vadc_scale_hw_chg5_temp(
0321                 const struct u32_fract *prescale,
0322                 const struct adc5_data *data,
0323                 u16 adc_code, int *result_mdec);
0324 static int qcom_vadc_scale_hw_calib_die_temp(
0325                 const struct u32_fract *prescale,
0326                 const struct adc5_data *data,
0327                 u16 adc_code, int *result_mdec);
0328 static int qcom_vadc7_scale_hw_calib_die_temp(
0329                 const struct u32_fract *prescale,
0330                 const struct adc5_data *data,
0331                 u16 adc_code, int *result_mdec);
0332 
0333 static struct qcom_adc5_scale_type scale_adc5_fn[] = {
0334     [SCALE_HW_CALIB_DEFAULT] = {qcom_vadc_scale_hw_calib_volt},
0335     [SCALE_HW_CALIB_THERM_100K_PULLUP] = {qcom_vadc_scale_hw_calib_therm},
0336     [SCALE_HW_CALIB_XOTHERM] = {qcom_vadc_scale_hw_calib_therm},
0337     [SCALE_HW_CALIB_THERM_100K_PU_PM7] = {
0338                     qcom_vadc7_scale_hw_calib_therm},
0339     [SCALE_HW_CALIB_PMIC_THERM] = {qcom_vadc_scale_hw_calib_die_temp},
0340     [SCALE_HW_CALIB_PMIC_THERM_PM7] = {
0341                     qcom_vadc7_scale_hw_calib_die_temp},
0342     [SCALE_HW_CALIB_PM5_CHG_TEMP] = {qcom_vadc_scale_hw_chg5_temp},
0343     [SCALE_HW_CALIB_PM5_SMB_TEMP] = {qcom_vadc_scale_hw_smb_temp},
0344 };
0345 
0346 static int qcom_vadc_map_voltage_temp(const struct vadc_map_pt *pts,
0347                       u32 tablesize, s32 input, int *output)
0348 {
0349     u32 i = 0;
0350 
0351     if (!pts)
0352         return -EINVAL;
0353 
0354     while (i < tablesize && pts[i].x > input)
0355         i++;
0356 
0357     if (i == 0) {
0358         *output = pts[0].y;
0359     } else if (i == tablesize) {
0360         *output = pts[tablesize - 1].y;
0361     } else {
0362         /* interpolate linearly */
0363         *output = fixp_linear_interpolate(pts[i - 1].x, pts[i - 1].y,
0364                           pts[i].x, pts[i].y,
0365                           input);
0366     }
0367 
0368     return 0;
0369 }
0370 
0371 static s32 qcom_vadc_map_temp_voltage(const struct vadc_map_pt *pts,
0372                       u32 tablesize, int input)
0373 {
0374     u32 i = 0;
0375 
0376     /*
0377      * Table must be sorted, find the interval of 'y' which contains value
0378      * 'input' and map it to proper 'x' value
0379      */
0380     while (i < tablesize && pts[i].y < input)
0381         i++;
0382 
0383     if (i == 0)
0384         return pts[0].x;
0385     if (i == tablesize)
0386         return pts[tablesize - 1].x;
0387 
0388     /* interpolate linearly */
0389     return fixp_linear_interpolate(pts[i - 1].y, pts[i - 1].x,
0390             pts[i].y, pts[i].x, input);
0391 }
0392 
0393 static void qcom_vadc_scale_calib(const struct vadc_linear_graph *calib_graph,
0394                   u16 adc_code,
0395                   bool absolute,
0396                   s64 *scale_voltage)
0397 {
0398     *scale_voltage = (adc_code - calib_graph->gnd);
0399     *scale_voltage *= calib_graph->dx;
0400     *scale_voltage = div64_s64(*scale_voltage, calib_graph->dy);
0401     if (absolute)
0402         *scale_voltage += calib_graph->dx;
0403 
0404     if (*scale_voltage < 0)
0405         *scale_voltage = 0;
0406 }
0407 
0408 static int qcom_vadc_scale_volt(const struct vadc_linear_graph *calib_graph,
0409                 const struct u32_fract *prescale,
0410                 bool absolute, u16 adc_code,
0411                 int *result_uv)
0412 {
0413     s64 voltage = 0, result = 0;
0414 
0415     qcom_vadc_scale_calib(calib_graph, adc_code, absolute, &voltage);
0416 
0417     voltage *= prescale->denominator;
0418     result = div64_s64(voltage, prescale->numerator);
0419     *result_uv = result;
0420 
0421     return 0;
0422 }
0423 
0424 static int qcom_vadc_scale_therm(const struct vadc_linear_graph *calib_graph,
0425                  const struct u32_fract *prescale,
0426                  bool absolute, u16 adc_code,
0427                  int *result_mdec)
0428 {
0429     s64 voltage = 0;
0430     int ret;
0431 
0432     qcom_vadc_scale_calib(calib_graph, adc_code, absolute, &voltage);
0433 
0434     if (absolute)
0435         voltage = div64_s64(voltage, 1000);
0436 
0437     ret = qcom_vadc_map_voltage_temp(adcmap_100k_104ef_104fb,
0438                      ARRAY_SIZE(adcmap_100k_104ef_104fb),
0439                      voltage, result_mdec);
0440     if (ret)
0441         return ret;
0442 
0443     return 0;
0444 }
0445 
0446 static int qcom_vadc_scale_die_temp(const struct vadc_linear_graph *calib_graph,
0447                     const struct u32_fract *prescale,
0448                     bool absolute,
0449                     u16 adc_code, int *result_mdec)
0450 {
0451     s64 voltage = 0;
0452     u64 temp; /* Temporary variable for do_div */
0453 
0454     qcom_vadc_scale_calib(calib_graph, adc_code, absolute, &voltage);
0455 
0456     if (voltage > 0) {
0457         temp = voltage * prescale->denominator;
0458         do_div(temp, prescale->numerator * 2);
0459         voltage = temp;
0460     } else {
0461         voltage = 0;
0462     }
0463 
0464     *result_mdec = milli_kelvin_to_millicelsius(voltage);
0465 
0466     return 0;
0467 }
0468 
0469 static int qcom_vadc_scale_chg_temp(const struct vadc_linear_graph *calib_graph,
0470                     const struct u32_fract *prescale,
0471                     bool absolute,
0472                     u16 adc_code, int *result_mdec)
0473 {
0474     s64 voltage = 0, result = 0;
0475 
0476     qcom_vadc_scale_calib(calib_graph, adc_code, absolute, &voltage);
0477 
0478     voltage *= prescale->denominator;
0479     voltage = div64_s64(voltage, prescale->numerator);
0480     voltage = ((PMI_CHG_SCALE_1) * (voltage * 2));
0481     voltage = (voltage + PMI_CHG_SCALE_2);
0482     result =  div64_s64(voltage, 1000000);
0483     *result_mdec = result;
0484 
0485     return 0;
0486 }
0487 
0488 /* convert voltage to ADC code, using 1.875V reference */
0489 static u16 qcom_vadc_scale_voltage_code(s32 voltage,
0490                     const struct u32_fract *prescale,
0491                     const u32 full_scale_code_volt,
0492                     unsigned int factor)
0493 {
0494     s64 volt = voltage;
0495     s64 adc_vdd_ref_mv = 1875; /* reference voltage */
0496 
0497     volt *= prescale->numerator * factor * full_scale_code_volt;
0498     volt = div64_s64(volt, (s64)prescale->denominator * adc_vdd_ref_mv * 1000);
0499 
0500     return volt;
0501 }
0502 
0503 static int qcom_vadc_scale_code_voltage_factor(u16 adc_code,
0504                 const struct u32_fract *prescale,
0505                 const struct adc5_data *data,
0506                 unsigned int factor)
0507 {
0508     s64 voltage, temp, adc_vdd_ref_mv = 1875;
0509 
0510     /*
0511      * The normal data range is between 0V to 1.875V. On cases where
0512      * we read low voltage values, the ADC code can go beyond the
0513      * range and the scale result is incorrect so we clamp the values
0514      * for the cases where the code represents a value below 0V
0515      */
0516     if (adc_code > VADC5_MAX_CODE)
0517         adc_code = 0;
0518 
0519     /* (ADC code * vref_vadc (1.875V)) / full_scale_code */
0520     voltage = (s64) adc_code * adc_vdd_ref_mv * 1000;
0521     voltage = div64_s64(voltage, data->full_scale_code_volt);
0522     if (voltage > 0) {
0523         voltage *= prescale->denominator;
0524         temp = prescale->numerator * factor;
0525         voltage = div64_s64(voltage, temp);
0526     } else {
0527         voltage = 0;
0528     }
0529 
0530     return (int) voltage;
0531 }
0532 
0533 static int qcom_vadc7_scale_hw_calib_therm(
0534                 const struct u32_fract *prescale,
0535                 const struct adc5_data *data,
0536                 u16 adc_code, int *result_mdec)
0537 {
0538     s64 resistance = adc_code;
0539     int ret, result;
0540 
0541     if (adc_code >= RATIO_MAX_ADC7)
0542         return -EINVAL;
0543 
0544     /* (ADC code * R_PULLUP (100Kohm)) / (full_scale_code - ADC code)*/
0545     resistance *= R_PU_100K;
0546     resistance = div64_s64(resistance, RATIO_MAX_ADC7 - adc_code);
0547 
0548     ret = qcom_vadc_map_voltage_temp(adcmap7_100k,
0549                  ARRAY_SIZE(adcmap7_100k),
0550                  resistance, &result);
0551     if (ret)
0552         return ret;
0553 
0554     *result_mdec = result;
0555 
0556     return 0;
0557 }
0558 
0559 static int qcom_vadc_scale_hw_calib_volt(
0560                 const struct u32_fract *prescale,
0561                 const struct adc5_data *data,
0562                 u16 adc_code, int *result_uv)
0563 {
0564     *result_uv = qcom_vadc_scale_code_voltage_factor(adc_code,
0565                 prescale, data, 1);
0566 
0567     return 0;
0568 }
0569 
0570 static int qcom_vadc_scale_hw_calib_therm(
0571                 const struct u32_fract *prescale,
0572                 const struct adc5_data *data,
0573                 u16 adc_code, int *result_mdec)
0574 {
0575     int voltage;
0576 
0577     voltage = qcom_vadc_scale_code_voltage_factor(adc_code,
0578                 prescale, data, 1000);
0579 
0580     /* Map voltage to temperature from look-up table */
0581     return qcom_vadc_map_voltage_temp(adcmap_100k_104ef_104fb_1875_vref,
0582                  ARRAY_SIZE(adcmap_100k_104ef_104fb_1875_vref),
0583                  voltage, result_mdec);
0584 }
0585 
0586 static int qcom_vadc_scale_hw_calib_die_temp(
0587                 const struct u32_fract *prescale,
0588                 const struct adc5_data *data,
0589                 u16 adc_code, int *result_mdec)
0590 {
0591     *result_mdec = qcom_vadc_scale_code_voltage_factor(adc_code,
0592                 prescale, data, 2);
0593     *result_mdec = milli_kelvin_to_millicelsius(*result_mdec);
0594 
0595     return 0;
0596 }
0597 
0598 static int qcom_vadc7_scale_hw_calib_die_temp(
0599                 const struct u32_fract *prescale,
0600                 const struct adc5_data *data,
0601                 u16 adc_code, int *result_mdec)
0602 {
0603 
0604     int voltage;
0605 
0606     voltage = qcom_vadc_scale_code_voltage_factor(adc_code,
0607                 prescale, data, 1);
0608 
0609     return qcom_vadc_map_voltage_temp(adcmap7_die_temp, ARRAY_SIZE(adcmap7_die_temp),
0610             voltage, result_mdec);
0611 }
0612 
0613 static int qcom_vadc_scale_hw_smb_temp(
0614                 const struct u32_fract *prescale,
0615                 const struct adc5_data *data,
0616                 u16 adc_code, int *result_mdec)
0617 {
0618     *result_mdec = qcom_vadc_scale_code_voltage_factor(adc_code * 100,
0619                 prescale, data, PMIC5_SMB_TEMP_SCALE_FACTOR);
0620     *result_mdec = PMIC5_SMB_TEMP_CONSTANT - *result_mdec;
0621 
0622     return 0;
0623 }
0624 
0625 static int qcom_vadc_scale_hw_chg5_temp(
0626                 const struct u32_fract *prescale,
0627                 const struct adc5_data *data,
0628                 u16 adc_code, int *result_mdec)
0629 {
0630     *result_mdec = qcom_vadc_scale_code_voltage_factor(adc_code,
0631                 prescale, data, 4);
0632     *result_mdec = PMIC5_CHG_TEMP_SCALE_FACTOR - *result_mdec;
0633 
0634     return 0;
0635 }
0636 
0637 int qcom_vadc_scale(enum vadc_scale_fn_type scaletype,
0638             const struct vadc_linear_graph *calib_graph,
0639             const struct u32_fract *prescale,
0640             bool absolute,
0641             u16 adc_code, int *result)
0642 {
0643     switch (scaletype) {
0644     case SCALE_DEFAULT:
0645         return qcom_vadc_scale_volt(calib_graph, prescale,
0646                         absolute, adc_code,
0647                         result);
0648     case SCALE_THERM_100K_PULLUP:
0649     case SCALE_XOTHERM:
0650         return qcom_vadc_scale_therm(calib_graph, prescale,
0651                          absolute, adc_code,
0652                          result);
0653     case SCALE_PMIC_THERM:
0654         return qcom_vadc_scale_die_temp(calib_graph, prescale,
0655                         absolute, adc_code,
0656                         result);
0657     case SCALE_PMI_CHG_TEMP:
0658         return qcom_vadc_scale_chg_temp(calib_graph, prescale,
0659                         absolute, adc_code,
0660                         result);
0661     default:
0662         return -EINVAL;
0663     }
0664 }
0665 EXPORT_SYMBOL(qcom_vadc_scale);
0666 
0667 u16 qcom_adc_tm5_temp_volt_scale(unsigned int prescale_ratio,
0668                  u32 full_scale_code_volt, int temp)
0669 {
0670     const struct u32_fract *prescale = &adc5_prescale_ratios[prescale_ratio];
0671     s32 voltage;
0672 
0673     voltage = qcom_vadc_map_temp_voltage(adcmap_100k_104ef_104fb_1875_vref,
0674                          ARRAY_SIZE(adcmap_100k_104ef_104fb_1875_vref),
0675                          temp);
0676     return qcom_vadc_scale_voltage_code(voltage, prescale, full_scale_code_volt, 1000);
0677 }
0678 EXPORT_SYMBOL(qcom_adc_tm5_temp_volt_scale);
0679 
0680 u16 qcom_adc_tm5_gen2_temp_res_scale(int temp)
0681 {
0682     int64_t resistance;
0683 
0684     resistance = qcom_vadc_map_temp_voltage(adcmap7_100k,
0685         ARRAY_SIZE(adcmap7_100k), temp);
0686 
0687     return div64_s64(resistance * RATIO_MAX_ADC7, resistance + R_PU_100K);
0688 }
0689 EXPORT_SYMBOL(qcom_adc_tm5_gen2_temp_res_scale);
0690 
0691 int qcom_adc5_hw_scale(enum vadc_scale_fn_type scaletype,
0692             unsigned int prescale_ratio,
0693             const struct adc5_data *data,
0694             u16 adc_code, int *result)
0695 {
0696     const struct u32_fract *prescale = &adc5_prescale_ratios[prescale_ratio];
0697 
0698     if (!(scaletype >= SCALE_HW_CALIB_DEFAULT &&
0699         scaletype < SCALE_HW_CALIB_INVALID)) {
0700         pr_err("Invalid scale type %d\n", scaletype);
0701         return -EINVAL;
0702     }
0703 
0704     return scale_adc5_fn[scaletype].scale_fn(prescale, data,
0705                     adc_code, result);
0706 }
0707 EXPORT_SYMBOL(qcom_adc5_hw_scale);
0708 
0709 int qcom_adc5_prescaling_from_dt(u32 numerator, u32 denominator)
0710 {
0711     unsigned int pre;
0712 
0713     for (pre = 0; pre < ARRAY_SIZE(adc5_prescale_ratios); pre++)
0714         if (adc5_prescale_ratios[pre].numerator == numerator &&
0715             adc5_prescale_ratios[pre].denominator == denominator)
0716             break;
0717 
0718     if (pre == ARRAY_SIZE(adc5_prescale_ratios))
0719         return -EINVAL;
0720 
0721     return pre;
0722 }
0723 EXPORT_SYMBOL(qcom_adc5_prescaling_from_dt);
0724 
0725 int qcom_adc5_hw_settle_time_from_dt(u32 value,
0726                      const unsigned int *hw_settle)
0727 {
0728     unsigned int i;
0729 
0730     for (i = 0; i < VADC_HW_SETTLE_SAMPLES_MAX; i++) {
0731         if (value == hw_settle[i])
0732             return i;
0733     }
0734 
0735     return -EINVAL;
0736 }
0737 EXPORT_SYMBOL(qcom_adc5_hw_settle_time_from_dt);
0738 
0739 int qcom_adc5_avg_samples_from_dt(u32 value)
0740 {
0741     if (!is_power_of_2(value) || value > ADC5_AVG_SAMPLES_MAX)
0742         return -EINVAL;
0743 
0744     return __ffs(value);
0745 }
0746 EXPORT_SYMBOL(qcom_adc5_avg_samples_from_dt);
0747 
0748 int qcom_adc5_decimation_from_dt(u32 value, const unsigned int *decimation)
0749 {
0750     unsigned int i;
0751 
0752     for (i = 0; i < ADC5_DECIMATION_SAMPLES_MAX; i++) {
0753         if (value == decimation[i])
0754             return i;
0755     }
0756 
0757     return -EINVAL;
0758 }
0759 EXPORT_SYMBOL(qcom_adc5_decimation_from_dt);
0760 
0761 int qcom_vadc_decimation_from_dt(u32 value)
0762 {
0763     if (!is_power_of_2(value) || value < VADC_DECIMATION_MIN ||
0764         value > VADC_DECIMATION_MAX)
0765         return -EINVAL;
0766 
0767     return __ffs64(value / VADC_DECIMATION_MIN);
0768 }
0769 EXPORT_SYMBOL(qcom_vadc_decimation_from_dt);
0770 
0771 MODULE_LICENSE("GPL v2");
0772 MODULE_DESCRIPTION("Qualcomm ADC common functionality");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!