Quelle  qcom-vadc-common.c

// SPDX-License-Identifier: GPL-2.0
#include <linux/bug.h>
#include <linux/kernel.h>
#include <linux/bitops.h>
#include <linux/fixp-arith.h>
#include <linux/iio/adc/qcom-vadc-common.h>
#include <linux/math64.h>
#include <linux/log2.h>
#include <linux/err.h>
#include <linux/module.h>
#include <linux/units.h>

/**
 * struct vadc_map_pt - Map the graph representation for ADC channel
 * @x: Represent the ADC digitized code.
 * @y: Represent the physical data which can be temperature, voltage,
 *     resistance.
 */
struct vadc_map_pt {
 s32 x;
 s32 y;
};

/* Voltage to temperature */
static const struct vadc_map_pt adcmap_100k_104ef_104fb[] = {
 {1758, -40000 },
 {1742, -35000 },
 {1719, -30000 },
 {1691, -25000 },
 {1654, -20000 },
 {1608, -15000 },
 {1551, -10000 },
 {1483, -5000 },
 {1404, 0 },
 {1315, 5000 },
 {1218, 10000 },
 {1114, 15000 },
 {1007, 20000 },
 {900, 25000 },
 {795, 30000 },
 {696, 35000 },
 {605, 40000 },
 {522, 45000 },
 {448, 50000 },
 {383, 55000 },
 {327, 60000 },
 {278, 65000 },
 {237, 70000 },
 {202, 75000 },
 {172, 80000 },
 {146, 85000 },
 {125, 90000 },
 {107, 95000 },
 {92, 100000 },
 {79, 105000 },
 {68, 110000 },
 {59, 115000 },
 {51, 120000 },
 {44, 125000 }
};

/*
 * Voltage to temperature table for 100k pull up for NTCG104EF104 with
 * 1.875V reference.
 */
static const struct vadc_map_pt adcmap_100k_104ef_104fb_1875_vref[] = {
 { 1831, -40000 },
 { 1814, -35000 },
 { 1791, -30000 },
 { 1761, -25000 },
 { 1723, -20000 },
 { 1675, -15000 },
 { 1616, -10000 },
 { 1545, -5000 },
 { 1463, 0 },
 { 1370, 5000 },
 { 1268, 10000 },
 { 1160, 15000 },
 { 1049, 20000 },
 { 937, 25000 },
 { 828, 30000 },
 { 726, 35000 },
 { 630, 40000 },
 { 544, 45000 },
 { 467, 50000 },
 { 399, 55000 },
 { 340, 60000 },
 { 290, 65000 },
 { 247, 70000 },
 { 209, 75000 },
 { 179, 80000 },
 { 153, 85000 },
 { 130, 90000 },
 { 112, 95000 },
 { 96, 100000 },
 { 82, 105000 },
 { 71, 110000 },
 { 62, 115000 },
 { 53, 120000 },
 { 46, 125000 },
};

static const struct vadc_map_pt adcmap7_die_temp[] = {
 { 857300, 160000 },
 { 820100, 140000 },
 { 782500, 120000 },
 { 744600, 100000 },
 { 706400, 80000 },
 { 667900, 60000 },
 { 629300, 40000 },
 { 590500, 20000 },
 { 551500, 0 },
 { 512400, -20000 },
 { 473100, -40000 },
 { 433700, -60000 },
};

/*
 * Resistance to temperature table for 100k pull up for NTCG104EF104.
 */
static const struct vadc_map_pt adcmap7_100k[] = {
 { 4250657, -40960 },
 { 3962085, -39936 },
 { 3694875, -38912 },
 { 3447322, -37888 },
 { 3217867, -36864 },
 { 3005082, -35840 },
 { 2807660, -34816 },
 { 2624405, -33792 },
 { 2454218, -32768 },
 { 2296094, -31744 },
 { 2149108, -30720 },
 { 2012414, -29696 },
 { 1885232, -28672 },
 { 1766846, -27648 },
 { 1656598, -26624 },
 { 1553884, -25600 },
 { 1458147, -24576 },
 { 1368873, -23552 },
 { 1285590, -22528 },
 { 1207863, -21504 },
 { 1135290, -20480 },
 { 1067501, -19456 },
 { 1004155, -18432 },
 { 944935, -17408 },
 { 889550, -16384 },
 { 837731, -15360 },
 { 789229, -14336 },
 { 743813, -13312 },
 { 701271, -12288 },
 { 661405, -11264 },
 { 624032, -10240 },
 { 588982, -9216 },
 { 556100, -8192 },
 { 525239, -7168 },
 { 496264, -6144 },
 { 469050, -5120 },
 { 443480, -4096 },
 { 419448, -3072 },
 { 396851, -2048 },
 { 375597, -1024 },
 { 355598, 0 },
 { 336775, 1024 },
 { 319052, 2048 },
 { 302359, 3072 },
 { 286630, 4096 },
 { 271806, 5120 },
 { 257829, 6144 },
 { 244646, 7168 },
 { 232209, 8192 },
 { 220471, 9216 },
 { 209390, 10240 },
 { 198926, 11264 },
 { 189040, 12288 },
 { 179698, 13312 },
 { 170868, 14336 },
 { 162519, 15360 },
 { 154622, 16384 },
 { 147150, 17408 },
 { 140079, 18432 },
 { 133385, 19456 },
 { 127046, 20480 },
 { 121042, 21504 },
 { 115352, 22528 },
 { 109960, 23552 },
 { 104848, 24576 },
 { 100000, 25600 },
 { 95402, 26624 },
 { 91038, 27648 },
 { 86897, 28672 },
 { 82965, 29696 },
 { 79232, 30720 },
 { 75686, 31744 },
 { 72316, 32768 },
 { 69114, 33792 },
 { 66070, 34816 },
 { 63176, 35840 },
 { 60423, 36864 },
 { 57804, 37888 },
 { 55312, 38912 },
 { 52940, 39936 },
 { 50681, 40960 },
 { 48531, 41984 },
 { 46482, 43008 },
 { 44530, 44032 },
 { 42670, 45056 },
 { 40897, 46080 },
 { 39207, 47104 },
 { 37595, 48128 },
 { 36057, 49152 },
 { 34590, 50176 },
 { 33190, 51200 },
 { 31853, 52224 },
 { 30577, 53248 },
 { 29358, 54272 },
 { 28194, 55296 },
 { 27082, 56320 },
 { 26020, 57344 },
 { 25004, 58368 },
 { 24033, 59392 },
 { 23104, 60416 },
 { 22216, 61440 },
 { 21367, 62464 },
 { 20554, 63488 },
 { 19776, 64512 },
 { 19031, 65536 },
 { 18318, 66560 },
 { 17636, 67584 },
 { 16982, 68608 },
 { 16355, 69632 },
 { 15755, 70656 },
 { 15180, 71680 },
 { 14628, 72704 },
 { 14099, 73728 },
 { 13592, 74752 },
 { 13106, 75776 },
 { 12640, 76800 },
 { 12192, 77824 },
 { 11762, 78848 },
 { 11350, 79872 },
 { 10954, 80896 },
 { 10574, 81920 },
 { 10209, 82944 },
 { 9858, 83968 },
 { 9521, 84992 },
 { 9197, 86016 },
 { 8886, 87040 },
 { 8587, 88064 },
 { 8299, 89088 },
 { 8023, 90112 },
 { 7757, 91136 },
 { 7501, 92160 },
 { 7254, 93184 },
 { 7017, 94208 },
 { 6789, 95232 },
 { 6570, 96256 },
 { 6358, 97280 },
 { 6155, 98304 },
 { 5959, 99328 },
 { 5770, 100352 },
 { 5588, 101376 },
 { 5412, 102400 },
 { 5243, 103424 },
 { 5080, 104448 },
 { 4923, 105472 },
 { 4771, 106496 },
 { 4625, 107520 },
 { 4484, 108544 },
 { 4348, 109568 },
 { 4217, 110592 },
 { 4090, 111616 },
 { 3968, 112640 },
 { 3850, 113664 },
 { 3736, 114688 },
 { 3626, 115712 },
 { 3519, 116736 },
 { 3417, 117760 },
 { 3317, 118784 },
 { 3221, 119808 },
 { 3129, 120832 },
 { 3039, 121856 },
 { 2952, 122880 },
 { 2868, 123904 },
 { 2787, 124928 },
 { 2709, 125952 },
 { 2633, 126976 },
 { 2560, 128000 },
 { 2489, 129024 },
 { 2420, 130048 }
};

static const struct u32_fract adc5_prescale_ratios[] = {
 { .numerator =  1, .denominator =  1 },
 { .numerator =  1, .denominator =  3 },
 { .numerator =  1, .denominator =  4 },
 { .numerator =  1, .denominator =  6 },
 { .numerator =  1, .denominator = 20 },
 { .numerator =  1, .denominator =  8 },
 { .numerator = 10, .denominator = 81 },
 { .numerator =  1, .denominator = 10 },
 { .numerator =  1, .denominator = 16 },
};

static int qcom_vadc_scale_hw_calib_volt(
    const struct u32_fract *prescale,
    const struct adc5_data *data,
    u16 adc_code, int *result_uv);
static int qcom_vadc_scale_hw_calib_therm(
    const struct u32_fract *prescale,
    const struct adc5_data *data,
    u16 adc_code, int *result_mdec);
static int qcom_vadc7_scale_hw_calib_therm(
    const struct u32_fract *prescale,
    const struct adc5_data *data,
    u16 adc_code, int *result_mdec);
static int qcom_vadc_scale_hw_smb_temp(
    const struct u32_fract *prescale,
    const struct adc5_data *data,
    u16 adc_code, int *result_mdec);
static int qcom_vadc_scale_hw_chg5_temp(
    const struct u32_fract *prescale,
    const struct adc5_data *data,
    u16 adc_code, int *result_mdec);
static int qcom_vadc_scale_hw_calib_die_temp(
    const struct u32_fract *prescale,
    const struct adc5_data *data,
    u16 adc_code, int *result_mdec);
static int qcom_vadc7_scale_hw_calib_die_temp(
    const struct u32_fract *prescale,
    const struct adc5_data *data,
    u16 adc_code, int *result_mdec);

static const struct qcom_adc5_scale_type scale_adc5_fn[] = {
 [SCALE_HW_CALIB_DEFAULT] = {qcom_vadc_scale_hw_calib_volt},
 [SCALE_HW_CALIB_THERM_100K_PULLUP] = {qcom_vadc_scale_hw_calib_therm},
 [SCALE_HW_CALIB_XOTHERM] = {qcom_vadc_scale_hw_calib_therm},
 [SCALE_HW_CALIB_THERM_100K_PU_PM7] = {
     qcom_vadc7_scale_hw_calib_therm},
 [SCALE_HW_CALIB_PMIC_THERM] = {qcom_vadc_scale_hw_calib_die_temp},
 [SCALE_HW_CALIB_PMIC_THERM_PM7] = {
     qcom_vadc7_scale_hw_calib_die_temp},
 [SCALE_HW_CALIB_PM5_CHG_TEMP] = {qcom_vadc_scale_hw_chg5_temp},
 [SCALE_HW_CALIB_PM5_SMB_TEMP] = {qcom_vadc_scale_hw_smb_temp},
};

static int qcom_vadc_map_voltage_temp(const struct vadc_map_pt *pts,
          u32 tablesize, s32 input, int *output)
{
 u32 i = 0;

 if (!pts)
  return -EINVAL;

 while (i < tablesize && pts[i].x > input)
  i++;

 if (i == 0) {
  *output = pts[0].y;
 } else if (i == tablesize) {
  *output = pts[tablesize - 1].y;
 } else {
  /* interpolate linearly */
  *output = fixp_linear_interpolate(pts[i - 1].x, pts[i - 1].y,
        pts[i].x, pts[i].y,
        input);
 }

 return 0;
}

static s32 qcom_vadc_map_temp_voltage(const struct vadc_map_pt *pts,
          u32 tablesize, int input)
{
 u32 i = 0;

 /*
 * Table must be sorted, find the interval of 'y' which contains value
 * 'input' and map it to proper 'x' value
 */
 while (i < tablesize && pts[i].y < input)
  i++;

 if (i == 0)
  return pts[0].x;
 if (i == tablesize)
  return pts[tablesize - 1].x;

 /* interpolate linearly */
 return fixp_linear_interpolate(pts[i - 1].y, pts[i - 1].x,
   pts[i].y, pts[i].x, input);
}

static void qcom_vadc_scale_calib(const struct vadc_linear_graph *calib_graph,
      u16 adc_code,
      bool absolute,
      s64 *scale_voltage)
{
 *scale_voltage = (adc_code - calib_graph->gnd);
 *scale_voltage *= calib_graph->dx;
 *scale_voltage = div64_s64(*scale_voltage, calib_graph->dy);
 if (absolute)
  *scale_voltage += calib_graph->dx;

 if (*scale_voltage < 0)
  *scale_voltage = 0;
}

static int qcom_vadc_scale_volt(const struct vadc_linear_graph *calib_graph,
    const struct u32_fract *prescale,
    bool absolute, u16 adc_code,
    int *result_uv)
{
 s64 voltage = 0, result = 0;

 qcom_vadc_scale_calib(calib_graph, adc_code, absolute, &voltage);

 voltage *= prescale->denominator;
 result = div64_s64(voltage, prescale->numerator);
 *result_uv = result;

 return 0;
}

static int qcom_vadc_scale_therm(const struct vadc_linear_graph *calib_graph,
     const struct u32_fract *prescale,
     bool absolute, u16 adc_code,
     int *result_mdec)
{
 s64 voltage = 0;
 int ret;

 qcom_vadc_scale_calib(calib_graph, adc_code, absolute, &voltage);

 if (absolute)
  voltage = div64_s64(voltage, 1000);

 ret = qcom_vadc_map_voltage_temp(adcmap_100k_104ef_104fb,
      ARRAY_SIZE(adcmap_100k_104ef_104fb),
      voltage, result_mdec);
 if (ret)
  return ret;

 return 0;
}

static int qcom_vadc_scale_die_temp(const struct vadc_linear_graph *calib_graph,
        const struct u32_fract *prescale,
        bool absolute,
        u16 adc_code, int *result_mdec)
{
 s64 voltage = 0;
 u64 temp; /* Temporary variable for do_div */

 qcom_vadc_scale_calib(calib_graph, adc_code, absolute, &voltage);

 if (voltage > 0) {
  temp = voltage * prescale->denominator;
  do_div(temp, prescale->numerator * 2);
  voltage = temp;
 } else {
  voltage = 0;
 }

 *result_mdec = milli_kelvin_to_millicelsius(voltage);

 return 0;
}

static int qcom_vadc_scale_chg_temp(const struct vadc_linear_graph *calib_graph,
        const struct u32_fract *prescale,
        bool absolute,
        u16 adc_code, int *result_mdec)
{
 s64 voltage = 0, result = 0;

 qcom_vadc_scale_calib(calib_graph, adc_code, absolute, &voltage);

 voltage *= prescale->denominator;
 voltage = div64_s64(voltage, prescale->numerator);
 voltage = ((PMI_CHG_SCALE_1) * (voltage * 2));
 voltage = (voltage + PMI_CHG_SCALE_2);
 result =  div64_s64(voltage, 1000000);
 *result_mdec = result;

 return 0;
}

/* convert voltage to ADC code, using 1.875V reference */
static u16 qcom_vadc_scale_voltage_code(s32 voltage,
     const struct u32_fract *prescale,
     const u32 full_scale_code_volt,
     unsigned int factor)
{
 s64 volt = voltage;
 s64 adc_vdd_ref_mv = 1875; /* reference voltage */

 volt *= prescale->numerator * factor * full_scale_code_volt;
 volt = div64_s64(volt, (s64)prescale->denominator * adc_vdd_ref_mv * 1000);

 return volt;
}

static int qcom_vadc_scale_code_voltage_factor(u16 adc_code,
    const struct u32_fract *prescale,
    const struct adc5_data *data,
    unsigned int factor)
{
 s64 voltage, temp, adc_vdd_ref_mv = 1875;

 /*
 * The normal data range is between 0V to 1.875V. On cases where
 * we read low voltage values, the ADC code can go beyond the
 * range and the scale result is incorrect so we clamp the values
 * for the cases where the code represents a value below 0V
 */
 if (adc_code > VADC5_MAX_CODE)
  adc_code = 0;

 /* (ADC code * vref_vadc (1.875V)) / full_scale_code */
 voltage = (s64) adc_code * adc_vdd_ref_mv * 1000;
 voltage = div64_s64(voltage, data->full_scale_code_volt);
 if (voltage > 0) {
  voltage *= prescale->denominator;
  temp = prescale->numerator * factor;
  voltage = div64_s64(voltage, temp);
 } else {
  voltage = 0;
 }

 return (int) voltage;
}

static int qcom_vadc7_scale_hw_calib_therm(
    const struct u32_fract *prescale,
    const struct adc5_data *data,
    u16 adc_code, int *result_mdec)
{
 s64 resistance = adc_code;
 int ret, result;

 if (adc_code >= RATIO_MAX_ADC7)
  return -EINVAL;

 /* (ADC code * R_PULLUP (100Kohm)) / (full_scale_code - ADC code)*/
 resistance *= R_PU_100K;
 resistance = div64_s64(resistance, RATIO_MAX_ADC7 - adc_code);

 ret = qcom_vadc_map_voltage_temp(adcmap7_100k,
     ARRAY_SIZE(adcmap7_100k),
     resistance, &result);
 if (ret)
  return ret;

 *result_mdec = result;

 return 0;
}

static int qcom_vadc_scale_hw_calib_volt(
    const struct u32_fract *prescale,
    const struct adc5_data *data,
    u16 adc_code, int *result_uv)
{
 *result_uv = qcom_vadc_scale_code_voltage_factor(adc_code,
    prescale, data, 1);

 return 0;
}

static int qcom_vadc_scale_hw_calib_therm(
    const struct u32_fract *prescale,
    const struct adc5_data *data,
    u16 adc_code, int *result_mdec)
{
 int voltage;

 voltage = qcom_vadc_scale_code_voltage_factor(adc_code,
    prescale, data, 1000);

 /* Map voltage to temperature from look-up table */
 return qcom_vadc_map_voltage_temp(adcmap_100k_104ef_104fb_1875_vref,
     ARRAY_SIZE(adcmap_100k_104ef_104fb_1875_vref),
     voltage, result_mdec);
}

static int qcom_vadc_scale_hw_calib_die_temp(
    const struct u32_fract *prescale,
    const struct adc5_data *data,
    u16 adc_code, int *result_mdec)
{
 *result_mdec = qcom_vadc_scale_code_voltage_factor(adc_code,
    prescale, data, 2);
 *result_mdec = milli_kelvin_to_millicelsius(*result_mdec);

 return 0;
}

static int qcom_vadc7_scale_hw_calib_die_temp(
    const struct u32_fract *prescale,
    const struct adc5_data *data,
    u16 adc_code, int *result_mdec)
{

 int voltage;

 voltage = qcom_vadc_scale_code_voltage_factor(adc_code,
    prescale, data, 1);

 return qcom_vadc_map_voltage_temp(adcmap7_die_temp, ARRAY_SIZE(adcmap7_die_temp),
   voltage, result_mdec);
}

static int qcom_vadc_scale_hw_smb_temp(
    const struct u32_fract *prescale,
    const struct adc5_data *data,
    u16 adc_code, int *result_mdec)
{
 *result_mdec = qcom_vadc_scale_code_voltage_factor(adc_code * 100,
    prescale, data, PMIC5_SMB_TEMP_SCALE_FACTOR);
 *result_mdec = PMIC5_SMB_TEMP_CONSTANT - *result_mdec;

 return 0;
}

static int qcom_vadc_scale_hw_chg5_temp(
    const struct u32_fract *prescale,
    const struct adc5_data *data,
    u16 adc_code, int *result_mdec)
{
 *result_mdec = qcom_vadc_scale_code_voltage_factor(adc_code,
    prescale, data, 4);
 *result_mdec = PMIC5_CHG_TEMP_SCALE_FACTOR - *result_mdec;

 return 0;
}

int qcom_vadc_scale(enum vadc_scale_fn_type scaletype,
      const struct vadc_linear_graph *calib_graph,
      const struct u32_fract *prescale,
      bool absolute,
      u16 adc_code, int *result)
{
 switch (scaletype) {
 case SCALE_DEFAULT:
  return qcom_vadc_scale_volt(calib_graph, prescale,
         absolute, adc_code,
         result);
 case SCALE_THERM_100K_PULLUP:
 case SCALE_XOTHERM:
  return qcom_vadc_scale_therm(calib_graph, prescale,
          absolute, adc_code,
          result);
 case SCALE_PMIC_THERM:
  return qcom_vadc_scale_die_temp(calib_graph, prescale,
      absolute, adc_code,
      result);
 case SCALE_PMI_CHG_TEMP:
  return qcom_vadc_scale_chg_temp(calib_graph, prescale,
      absolute, adc_code,
      result);
 default:
  return -EINVAL;
 }
}
EXPORT_SYMBOL(qcom_vadc_scale);

u16 qcom_adc_tm5_temp_volt_scale(unsigned int prescale_ratio,
     u32 full_scale_code_volt, int temp)
{
 const struct u32_fract *prescale = &adc5_prescale_ratios[prescale_ratio];
 s32 voltage;

 voltage = qcom_vadc_map_temp_voltage(adcmap_100k_104ef_104fb_1875_vref,
          ARRAY_SIZE(adcmap_100k_104ef_104fb_1875_vref),
          temp);
 return qcom_vadc_scale_voltage_code(voltage, prescale, full_scale_code_volt, 1000);
}
EXPORT_SYMBOL(qcom_adc_tm5_temp_volt_scale);

u16 qcom_adc_tm5_gen2_temp_res_scale(int temp)
{
 int64_t resistance;

 resistance = qcom_vadc_map_temp_voltage(adcmap7_100k,
  ARRAY_SIZE(adcmap7_100k), temp);

 return div64_s64(resistance * RATIO_MAX_ADC7, resistance + R_PU_100K);
}
EXPORT_SYMBOL(qcom_adc_tm5_gen2_temp_res_scale);

int qcom_adc5_hw_scale(enum vadc_scale_fn_type scaletype,
      unsigned int prescale_ratio,
      const struct adc5_data *data,
      u16 adc_code, int *result)
{
 const struct u32_fract *prescale = &adc5_prescale_ratios[prescale_ratio];

 if (!(scaletype >= SCALE_HW_CALIB_DEFAULT &&
  scaletype < SCALE_HW_CALIB_INVALID)) {
  pr_err("Invalid scale type %d\n", scaletype);
  return -EINVAL;
 }

 return scale_adc5_fn[scaletype].scale_fn(prescale, data,
     adc_code, result);
}
EXPORT_SYMBOL(qcom_adc5_hw_scale);

int qcom_adc5_prescaling_from_dt(u32 numerator, u32 denominator)
{
 unsigned int pre;

 for (pre = 0; pre < ARRAY_SIZE(adc5_prescale_ratios); pre++)
  if (adc5_prescale_ratios[pre].numerator == numerator &&
      adc5_prescale_ratios[pre].denominator == denominator)
   break;

 if (pre == ARRAY_SIZE(adc5_prescale_ratios))
  return -EINVAL;

 return pre;
}
EXPORT_SYMBOL(qcom_adc5_prescaling_from_dt);

int qcom_adc5_hw_settle_time_from_dt(u32 value,
         const unsigned int *hw_settle)
{
 unsigned int i;

 for (i = 0; i < VADC_HW_SETTLE_SAMPLES_MAX; i++) {
  if (value == hw_settle[i])
   return i;
 }

 return -EINVAL;
}
EXPORT_SYMBOL(qcom_adc5_hw_settle_time_from_dt);

int qcom_adc5_avg_samples_from_dt(u32 value)
{
 if (!is_power_of_2(value) || value > ADC5_AVG_SAMPLES_MAX)
  return -EINVAL;

 return __ffs(value);
}
EXPORT_SYMBOL(qcom_adc5_avg_samples_from_dt);

int qcom_adc5_decimation_from_dt(u32 value, const unsigned int *decimation)
{
 unsigned int i;

 for (i = 0; i < ADC5_DECIMATION_SAMPLES_MAX; i++) {
  if (value == decimation[i])
   return i;
 }

 return -EINVAL;
}
EXPORT_SYMBOL(qcom_adc5_decimation_from_dt);

int qcom_vadc_decimation_from_dt(u32 value)
{
 if (!is_power_of_2(value) || value < VADC_DECIMATION_MIN ||
     value > VADC_DECIMATION_MAX)
  return -EINVAL;

 return __ffs64(value / VADC_DECIMATION_MIN);
}
EXPORT_SYMBOL(qcom_vadc_decimation_from_dt);

MODULE_LICENSE("GPL v2");
MODULE_DESCRIPTION("Qualcomm ADC common functionality");