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 
10 #include "qcom-vadc-common.h"
11 
12 /* Voltage to temperature */
13 static const struct vadc_map_pt adcmap_100k_104ef_104fb[] = {
14 	{1758,	-40},
15 	{1742,	-35},
16 	{1719,	-30},
17 	{1691,	-25},
18 	{1654,	-20},
19 	{1608,	-15},
20 	{1551,	-10},
21 	{1483,	-5},
22 	{1404,	0},
23 	{1315,	5},
24 	{1218,	10},
25 	{1114,	15},
26 	{1007,	20},
27 	{900,	25},
28 	{795,	30},
29 	{696,	35},
30 	{605,	40},
31 	{522,	45},
32 	{448,	50},
33 	{383,	55},
34 	{327,	60},
35 	{278,	65},
36 	{237,	70},
37 	{202,	75},
38 	{172,	80},
39 	{146,	85},
40 	{125,	90},
41 	{107,	95},
42 	{92,	100},
43 	{79,	105},
44 	{68,	110},
45 	{59,	115},
46 	{51,	120},
47 	{44,	125}
48 };
49 
50 /*
51  * Voltage to temperature table for 100k pull up for NTCG104EF104 with
52  * 1.875V reference.
53  */
54 static const struct vadc_map_pt adcmap_100k_104ef_104fb_1875_vref[] = {
55 	{ 1831,	-40000 },
56 	{ 1814,	-35000 },
57 	{ 1791,	-30000 },
58 	{ 1761,	-25000 },
59 	{ 1723,	-20000 },
60 	{ 1675,	-15000 },
61 	{ 1616,	-10000 },
62 	{ 1545,	-5000 },
63 	{ 1463,	0 },
64 	{ 1370,	5000 },
65 	{ 1268,	10000 },
66 	{ 1160,	15000 },
67 	{ 1049,	20000 },
68 	{ 937,	25000 },
69 	{ 828,	30000 },
70 	{ 726,	35000 },
71 	{ 630,	40000 },
72 	{ 544,	45000 },
73 	{ 467,	50000 },
74 	{ 399,	55000 },
75 	{ 340,	60000 },
76 	{ 290,	65000 },
77 	{ 247,	70000 },
78 	{ 209,	75000 },
79 	{ 179,	80000 },
80 	{ 153,	85000 },
81 	{ 130,	90000 },
82 	{ 112,	95000 },
83 	{ 96,	100000 },
84 	{ 82,	105000 },
85 	{ 71,	110000 },
86 	{ 62,	115000 },
87 	{ 53,	120000 },
88 	{ 46,	125000 },
89 };
90 
91 static int qcom_vadc_scale_hw_calib_volt(
92 				const struct vadc_prescale_ratio *prescale,
93 				const struct adc5_data *data,
94 				u16 adc_code, int *result_uv);
95 static int qcom_vadc_scale_hw_calib_therm(
96 				const struct vadc_prescale_ratio *prescale,
97 				const struct adc5_data *data,
98 				u16 adc_code, int *result_mdec);
99 static int qcom_vadc_scale_hw_smb_temp(
100 				const struct vadc_prescale_ratio *prescale,
101 				const struct adc5_data *data,
102 				u16 adc_code, int *result_mdec);
103 static int qcom_vadc_scale_hw_chg5_temp(
104 				const struct vadc_prescale_ratio *prescale,
105 				const struct adc5_data *data,
106 				u16 adc_code, int *result_mdec);
107 static int qcom_vadc_scale_hw_calib_die_temp(
108 				const struct vadc_prescale_ratio *prescale,
109 				const struct adc5_data *data,
110 				u16 adc_code, int *result_mdec);
111 
112 static struct qcom_adc5_scale_type scale_adc5_fn[] = {
113 	[SCALE_HW_CALIB_DEFAULT] = {qcom_vadc_scale_hw_calib_volt},
114 	[SCALE_HW_CALIB_THERM_100K_PULLUP] = {qcom_vadc_scale_hw_calib_therm},
115 	[SCALE_HW_CALIB_XOTHERM] = {qcom_vadc_scale_hw_calib_therm},
116 	[SCALE_HW_CALIB_PMIC_THERM] = {qcom_vadc_scale_hw_calib_die_temp},
117 	[SCALE_HW_CALIB_PM5_CHG_TEMP] = {qcom_vadc_scale_hw_chg5_temp},
118 	[SCALE_HW_CALIB_PM5_SMB_TEMP] = {qcom_vadc_scale_hw_smb_temp},
119 };
120 
121 static int qcom_vadc_map_voltage_temp(const struct vadc_map_pt *pts,
122 				      u32 tablesize, s32 input, int *output)
123 {
124 	bool descending = 1;
125 	u32 i = 0;
126 
127 	if (!pts)
128 		return -EINVAL;
129 
130 	/* Check if table is descending or ascending */
131 	if (tablesize > 1) {
132 		if (pts[0].x < pts[1].x)
133 			descending = 0;
134 	}
135 
136 	while (i < tablesize) {
137 		if ((descending) && (pts[i].x < input)) {
138 			/* table entry is less than measured*/
139 			 /* value and table is descending, stop */
140 			break;
141 		} else if ((!descending) &&
142 				(pts[i].x > input)) {
143 			/* table entry is greater than measured*/
144 			/*value and table is ascending, stop */
145 			break;
146 		}
147 		i++;
148 	}
149 
150 	if (i == 0) {
151 		*output = pts[0].y;
152 	} else if (i == tablesize) {
153 		*output = pts[tablesize - 1].y;
154 	} else {
155 		/* result is between search_index and search_index-1 */
156 		/* interpolate linearly */
157 		*output = (((s32)((pts[i].y - pts[i - 1].y) *
158 			(input - pts[i - 1].x)) /
159 			(pts[i].x - pts[i - 1].x)) +
160 			pts[i - 1].y);
161 	}
162 
163 	return 0;
164 }
165 
166 static void qcom_vadc_scale_calib(const struct vadc_linear_graph *calib_graph,
167 				  u16 adc_code,
168 				  bool absolute,
169 				  s64 *scale_voltage)
170 {
171 	*scale_voltage = (adc_code - calib_graph->gnd);
172 	*scale_voltage *= calib_graph->dx;
173 	*scale_voltage = div64_s64(*scale_voltage, calib_graph->dy);
174 	if (absolute)
175 		*scale_voltage += calib_graph->dx;
176 
177 	if (*scale_voltage < 0)
178 		*scale_voltage = 0;
179 }
180 
181 static int qcom_vadc_scale_volt(const struct vadc_linear_graph *calib_graph,
182 				const struct vadc_prescale_ratio *prescale,
183 				bool absolute, u16 adc_code,
184 				int *result_uv)
185 {
186 	s64 voltage = 0, result = 0;
187 
188 	qcom_vadc_scale_calib(calib_graph, adc_code, absolute, &voltage);
189 
190 	voltage = voltage * prescale->den;
191 	result = div64_s64(voltage, prescale->num);
192 	*result_uv = result;
193 
194 	return 0;
195 }
196 
197 static int qcom_vadc_scale_therm(const struct vadc_linear_graph *calib_graph,
198 				 const struct vadc_prescale_ratio *prescale,
199 				 bool absolute, u16 adc_code,
200 				 int *result_mdec)
201 {
202 	s64 voltage = 0;
203 	int ret;
204 
205 	qcom_vadc_scale_calib(calib_graph, adc_code, absolute, &voltage);
206 
207 	if (absolute)
208 		voltage = div64_s64(voltage, 1000);
209 
210 	ret = qcom_vadc_map_voltage_temp(adcmap_100k_104ef_104fb,
211 					 ARRAY_SIZE(adcmap_100k_104ef_104fb),
212 					 voltage, result_mdec);
213 	if (ret)
214 		return ret;
215 
216 	*result_mdec *= 1000;
217 
218 	return 0;
219 }
220 
221 static int qcom_vadc_scale_die_temp(const struct vadc_linear_graph *calib_graph,
222 				    const struct vadc_prescale_ratio *prescale,
223 				    bool absolute,
224 				    u16 adc_code, int *result_mdec)
225 {
226 	s64 voltage = 0;
227 	u64 temp; /* Temporary variable for do_div */
228 
229 	qcom_vadc_scale_calib(calib_graph, adc_code, absolute, &voltage);
230 
231 	if (voltage > 0) {
232 		temp = voltage * prescale->den;
233 		do_div(temp, prescale->num * 2);
234 		voltage = temp;
235 	} else {
236 		voltage = 0;
237 	}
238 
239 	voltage -= KELVINMIL_CELSIUSMIL;
240 	*result_mdec = voltage;
241 
242 	return 0;
243 }
244 
245 static int qcom_vadc_scale_chg_temp(const struct vadc_linear_graph *calib_graph,
246 				    const struct vadc_prescale_ratio *prescale,
247 				    bool absolute,
248 				    u16 adc_code, int *result_mdec)
249 {
250 	s64 voltage = 0, result = 0;
251 
252 	qcom_vadc_scale_calib(calib_graph, adc_code, absolute, &voltage);
253 
254 	voltage = voltage * prescale->den;
255 	voltage = div64_s64(voltage, prescale->num);
256 	voltage = ((PMI_CHG_SCALE_1) * (voltage * 2));
257 	voltage = (voltage + PMI_CHG_SCALE_2);
258 	result =  div64_s64(voltage, 1000000);
259 	*result_mdec = result;
260 
261 	return 0;
262 }
263 
264 static int qcom_vadc_scale_code_voltage_factor(u16 adc_code,
265 				const struct vadc_prescale_ratio *prescale,
266 				const struct adc5_data *data,
267 				unsigned int factor)
268 {
269 	s64 voltage, temp, adc_vdd_ref_mv = 1875;
270 
271 	/*
272 	 * The normal data range is between 0V to 1.875V. On cases where
273 	 * we read low voltage values, the ADC code can go beyond the
274 	 * range and the scale result is incorrect so we clamp the values
275 	 * for the cases where the code represents a value below 0V
276 	 */
277 	if (adc_code > VADC5_MAX_CODE)
278 		adc_code = 0;
279 
280 	/* (ADC code * vref_vadc (1.875V)) / full_scale_code */
281 	voltage = (s64) adc_code * adc_vdd_ref_mv * 1000;
282 	voltage = div64_s64(voltage, data->full_scale_code_volt);
283 	if (voltage > 0) {
284 		voltage *= prescale->den;
285 		temp = prescale->num * factor;
286 		voltage = div64_s64(voltage, temp);
287 	} else {
288 		voltage = 0;
289 	}
290 
291 	return (int) voltage;
292 }
293 
294 static int qcom_vadc_scale_hw_calib_volt(
295 				const struct vadc_prescale_ratio *prescale,
296 				const struct adc5_data *data,
297 				u16 adc_code, int *result_uv)
298 {
299 	*result_uv = qcom_vadc_scale_code_voltage_factor(adc_code,
300 				prescale, data, 1);
301 
302 	return 0;
303 }
304 
305 static int qcom_vadc_scale_hw_calib_therm(
306 				const struct vadc_prescale_ratio *prescale,
307 				const struct adc5_data *data,
308 				u16 adc_code, int *result_mdec)
309 {
310 	int voltage;
311 
312 	voltage = qcom_vadc_scale_code_voltage_factor(adc_code,
313 				prescale, data, 1000);
314 
315 	/* Map voltage to temperature from look-up table */
316 	return qcom_vadc_map_voltage_temp(adcmap_100k_104ef_104fb_1875_vref,
317 				 ARRAY_SIZE(adcmap_100k_104ef_104fb_1875_vref),
318 				 voltage, result_mdec);
319 }
320 
321 static int qcom_vadc_scale_hw_calib_die_temp(
322 				const struct vadc_prescale_ratio *prescale,
323 				const struct adc5_data *data,
324 				u16 adc_code, int *result_mdec)
325 {
326 	*result_mdec = qcom_vadc_scale_code_voltage_factor(adc_code,
327 				prescale, data, 2);
328 	*result_mdec -= KELVINMIL_CELSIUSMIL;
329 
330 	return 0;
331 }
332 
333 static int qcom_vadc_scale_hw_smb_temp(
334 				const struct vadc_prescale_ratio *prescale,
335 				const struct adc5_data *data,
336 				u16 adc_code, int *result_mdec)
337 {
338 	*result_mdec = qcom_vadc_scale_code_voltage_factor(adc_code * 100,
339 				prescale, data, PMIC5_SMB_TEMP_SCALE_FACTOR);
340 	*result_mdec = PMIC5_SMB_TEMP_CONSTANT - *result_mdec;
341 
342 	return 0;
343 }
344 
345 static int qcom_vadc_scale_hw_chg5_temp(
346 				const struct vadc_prescale_ratio *prescale,
347 				const struct adc5_data *data,
348 				u16 adc_code, int *result_mdec)
349 {
350 	*result_mdec = qcom_vadc_scale_code_voltage_factor(adc_code,
351 				prescale, data, 4);
352 	*result_mdec = PMIC5_CHG_TEMP_SCALE_FACTOR - *result_mdec;
353 
354 	return 0;
355 }
356 
357 int qcom_vadc_scale(enum vadc_scale_fn_type scaletype,
358 		    const struct vadc_linear_graph *calib_graph,
359 		    const struct vadc_prescale_ratio *prescale,
360 		    bool absolute,
361 		    u16 adc_code, int *result)
362 {
363 	switch (scaletype) {
364 	case SCALE_DEFAULT:
365 		return qcom_vadc_scale_volt(calib_graph, prescale,
366 					    absolute, adc_code,
367 					    result);
368 	case SCALE_THERM_100K_PULLUP:
369 	case SCALE_XOTHERM:
370 		return qcom_vadc_scale_therm(calib_graph, prescale,
371 					     absolute, adc_code,
372 					     result);
373 	case SCALE_PMIC_THERM:
374 		return qcom_vadc_scale_die_temp(calib_graph, prescale,
375 						absolute, adc_code,
376 						result);
377 	case SCALE_PMI_CHG_TEMP:
378 		return qcom_vadc_scale_chg_temp(calib_graph, prescale,
379 						absolute, adc_code,
380 						result);
381 	default:
382 		return -EINVAL;
383 	}
384 }
385 EXPORT_SYMBOL(qcom_vadc_scale);
386 
387 int qcom_adc5_hw_scale(enum vadc_scale_fn_type scaletype,
388 		    const struct vadc_prescale_ratio *prescale,
389 		    const struct adc5_data *data,
390 		    u16 adc_code, int *result)
391 {
392 	if (!(scaletype >= SCALE_HW_CALIB_DEFAULT &&
393 		scaletype < SCALE_HW_CALIB_INVALID)) {
394 		pr_err("Invalid scale type %d\n", scaletype);
395 		return -EINVAL;
396 	}
397 
398 	return scale_adc5_fn[scaletype].scale_fn(prescale, data,
399 					adc_code, result);
400 }
401 EXPORT_SYMBOL(qcom_adc5_hw_scale);
402 
403 int qcom_vadc_decimation_from_dt(u32 value)
404 {
405 	if (!is_power_of_2(value) || value < VADC_DECIMATION_MIN ||
406 	    value > VADC_DECIMATION_MAX)
407 		return -EINVAL;
408 
409 	return __ffs64(value / VADC_DECIMATION_MIN);
410 }
411 EXPORT_SYMBOL(qcom_vadc_decimation_from_dt);
412 
413 MODULE_LICENSE("GPL v2");
414 MODULE_DESCRIPTION("Qualcomm ADC common functionality");
415