?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
drm/tests: hdmi: Fix memory leaks in drm_display_mode_from_cea_vic()
[drm/drm-misc.git] / drivers / iio / adc / qcom-vadc-common.c
blobd5209f32adb3e265acd51d56dda32e6d0be42e21
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] = {qcom_vadc_scale_hw_calib_therm},
336 [SCALE_HW_CALIB_XOTHERM] = {qcom_vadc_scale_hw_calib_therm},
337 [SCALE_HW_CALIB_THERM_100K_PU_PM7] = {
338 qcom_vadc7_scale_hw_calib_therm},
339 [SCALE_HW_CALIB_PMIC_THERM] = {qcom_vadc_scale_hw_calib_die_temp},
340 [SCALE_HW_CALIB_PMIC_THERM_PM7] = {
341 qcom_vadc7_scale_hw_calib_die_temp},
342 [SCALE_HW_CALIB_PM5_CHG_TEMP] = {qcom_vadc_scale_hw_chg5_temp},
343 [SCALE_HW_CALIB_PM5_SMB_TEMP] = {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(pts[i - 1].x, pts[i - 1].y,
364 pts[i].x, pts[i].y,
365 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(pts[i - 1].y, pts[i - 1].x,
390 pts[i].y, pts[i].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(*scale_voltage, 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, &voltage);
416
417 voltage *= prescale->denominator;
418 result = div64_s64(voltage, 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, &voltage);
433
434 if (absolute)
435 voltage = div64_s64(voltage, 1000);
436
437 ret = qcom_vadc_map_voltage_temp(adcmap_100k_104ef_104fb,
438 ARRAY_SIZE(adcmap_100k_104ef_104fb),
439 voltage, 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, &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(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, &voltage);
477
478 voltage *= prescale->denominator;
479 voltage = div64_s64(voltage, prescale->numerator);
480 voltage = ((PMI_CHG_SCALE_1) * (voltage * 2));
481 voltage = (voltage + PMI_CHG_SCALE_2);
482 result = div64_s64(voltage, 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(volt, (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(voltage, data->full_scale_code_volt);
522 if (voltage > 0) {
523 voltage *= prescale->denominator;
524 temp = prescale->numerator * factor;
525 voltage = div64_s64(voltage, 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(resistance, RATIO_MAX_ADC7 - adc_code);
547
548 ret = qcom_vadc_map_voltage_temp(adcmap7_100k,
549 ARRAY_SIZE(adcmap7_100k),
550 resistance, &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, 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, 1000);
579
580 /* Map voltage to temperature from look-up table */
581 return qcom_vadc_map_voltage_temp(adcmap_100k_104ef_104fb_1875_vref,
582 ARRAY_SIZE(adcmap_100k_104ef_104fb_1875_vref),
583 voltage, 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, 2);
593 *result_mdec = milli_kelvin_to_millicelsius(*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, 1);
608
609 return qcom_vadc_map_voltage_temp(adcmap7_die_temp, ARRAY_SIZE(adcmap7_die_temp),
610 voltage, 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 * 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, 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);
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);
653 case SCALE_PMIC_THERM:
654 return qcom_vadc_scale_die_temp(calib_graph, prescale,
655 absolute, adc_code,
656 result);
657 case SCALE_PMI_CHG_TEMP:
658 return qcom_vadc_scale_chg_temp(calib_graph, prescale,
659 absolute, adc_code,
660 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(adcmap_100k_104ef_104fb_1875_vref,
674 ARRAY_SIZE(adcmap_100k_104ef_104fb_1875_vref),
675 temp);
676 return qcom_vadc_scale_voltage_code(voltage, prescale, full_scale_code_volt, 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(adcmap7_100k,
685 ARRAY_SIZE(adcmap7_100k), temp);
686
687 return div64_s64(resistance * RATIO_MAX_ADC7, 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(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(value) || value < VADC_DECIMATION_MIN ||
764 value > VADC_DECIMATION_MAX)
765 return -EINVAL;
766
767 return __ffs64(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");
Kernel DRM miscellaneous fixes and cross-tree changes