forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
761 lines
18 KiB
761 lines
18 KiB
// 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 vadc_prescale_ratio adc5_prescale_ratios[] = { |
|
{.num = 1, .den = 1}, |
|
{.num = 1, .den = 3}, |
|
{.num = 1, .den = 4}, |
|
{.num = 1, .den = 6}, |
|
{.num = 1, .den = 20}, |
|
{.num = 1, .den = 8}, |
|
{.num = 10, .den = 81}, |
|
{.num = 1, .den = 10}, |
|
{.num = 1, .den = 16} |
|
}; |
|
|
|
static int qcom_vadc_scale_hw_calib_volt( |
|
const struct vadc_prescale_ratio *prescale, |
|
const struct adc5_data *data, |
|
u16 adc_code, int *result_uv); |
|
static int qcom_vadc_scale_hw_calib_therm( |
|
const struct vadc_prescale_ratio *prescale, |
|
const struct adc5_data *data, |
|
u16 adc_code, int *result_mdec); |
|
static int qcom_vadc7_scale_hw_calib_therm( |
|
const struct vadc_prescale_ratio *prescale, |
|
const struct adc5_data *data, |
|
u16 adc_code, int *result_mdec); |
|
static int qcom_vadc_scale_hw_smb_temp( |
|
const struct vadc_prescale_ratio *prescale, |
|
const struct adc5_data *data, |
|
u16 adc_code, int *result_mdec); |
|
static int qcom_vadc_scale_hw_chg5_temp( |
|
const struct vadc_prescale_ratio *prescale, |
|
const struct adc5_data *data, |
|
u16 adc_code, int *result_mdec); |
|
static int qcom_vadc_scale_hw_calib_die_temp( |
|
const struct vadc_prescale_ratio *prescale, |
|
const struct adc5_data *data, |
|
u16 adc_code, int *result_mdec); |
|
static int qcom_vadc7_scale_hw_calib_die_temp( |
|
const struct vadc_prescale_ratio *prescale, |
|
const struct adc5_data *data, |
|
u16 adc_code, int *result_mdec); |
|
|
|
static 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 vadc_prescale_ratio *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 = voltage * prescale->den; |
|
result = div64_s64(voltage, prescale->num); |
|
*result_uv = result; |
|
|
|
return 0; |
|
} |
|
|
|
static int qcom_vadc_scale_therm(const struct vadc_linear_graph *calib_graph, |
|
const struct vadc_prescale_ratio *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 vadc_prescale_ratio *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->den; |
|
do_div(temp, prescale->num * 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 vadc_prescale_ratio *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 = voltage * prescale->den; |
|
voltage = div64_s64(voltage, prescale->num); |
|
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 vadc_prescale_ratio *prescale, |
|
const u32 full_scale_code_volt, |
|
unsigned int factor) |
|
{ |
|
s64 volt = voltage; |
|
s64 adc_vdd_ref_mv = 1875; /* reference voltage */ |
|
|
|
volt *= prescale->num * factor * full_scale_code_volt; |
|
volt = div64_s64(volt, (s64)prescale->den * adc_vdd_ref_mv * 1000); |
|
|
|
return volt; |
|
} |
|
|
|
static int qcom_vadc_scale_code_voltage_factor(u16 adc_code, |
|
const struct vadc_prescale_ratio *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->den; |
|
temp = prescale->num * factor; |
|
voltage = div64_s64(voltage, temp); |
|
} else { |
|
voltage = 0; |
|
} |
|
|
|
return (int) voltage; |
|
} |
|
|
|
static int qcom_vadc7_scale_hw_calib_therm( |
|
const struct vadc_prescale_ratio *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 vadc_prescale_ratio *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 vadc_prescale_ratio *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 vadc_prescale_ratio *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 vadc_prescale_ratio *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 vadc_prescale_ratio *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 vadc_prescale_ratio *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 vadc_prescale_ratio *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 vadc_prescale_ratio *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); |
|
|
|
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 vadc_prescale_ratio *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 num, u32 den) |
|
{ |
|
unsigned int pre; |
|
|
|
for (pre = 0; pre < ARRAY_SIZE(adc5_prescale_ratios); pre++) |
|
if (adc5_prescale_ratios[pre].num == num && |
|
adc5_prescale_ratios[pre].den == den) |
|
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");
|
|
|