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