1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * TWL6030 GPADC module driver
4 *
5 * Copyright (C) 2009-2013 Texas Instruments Inc.
6 * Nishant Kamat <nskamat@ti.com>
7 * Balaji T K <balajitk@ti.com>
8 * Graeme Gregory <gg@slimlogic.co.uk>
9 * Girish S Ghongdemath <girishsg@ti.com>
10 * Ambresh K <ambresh@ti.com>
11 * Oleksandr Kozaruk <oleksandr.kozaruk@ti.com
12 *
13 * Based on twl4030-madc.c
14 * Copyright (C) 2008 Nokia Corporation
15 * Mikko Ylinen <mikko.k.ylinen@nokia.com>
16 */
17 #include <linux/interrupt.h>
18 #include <linux/kernel.h>
19 #include <linux/module.h>
20 #include <linux/platform_device.h>
21 #include <linux/of_platform.h>
22 #include <linux/mfd/twl.h>
23 #include <linux/iio/iio.h>
24 #include <linux/iio/sysfs.h>
25
26 #define DRIVER_NAME "twl6030_gpadc"
27
28 /*
29 * twl6030 per TRM has 17 channels, and twl6032 has 19 channels
30 * 2 test network channels are not used,
31 * 2 die temperature channels are not used either, as it is not
32 * defined how to convert ADC value to temperature
33 */
34 #define TWL6030_GPADC_USED_CHANNELS 13
35 #define TWL6030_GPADC_MAX_CHANNELS 15
36 #define TWL6032_GPADC_USED_CHANNELS 15
37 #define TWL6032_GPADC_MAX_CHANNELS 19
38 #define TWL6030_GPADC_NUM_TRIM_REGS 16
39
40 #define TWL6030_GPADC_CTRL_P1 0x05
41
42 #define TWL6032_GPADC_GPSELECT_ISB 0x07
43 #define TWL6032_GPADC_CTRL_P1 0x08
44
45 #define TWL6032_GPADC_GPCH0_LSB 0x0d
46 #define TWL6032_GPADC_GPCH0_MSB 0x0e
47
48 #define TWL6030_GPADC_CTRL_P1_SP1 BIT(3)
49
50 #define TWL6030_GPADC_GPCH0_LSB (0x29)
51
52 #define TWL6030_GPADC_RT_SW1_EOC_MASK BIT(5)
53
54 #define TWL6030_GPADC_TRIM1 0xCD
55
56 #define TWL6030_REG_TOGGLE1 0x90
57 #define TWL6030_GPADCS BIT(1)
58 #define TWL6030_GPADCR BIT(0)
59
60 #define USB_VBUS_CTRL_SET 0x04
61 #define USB_ID_CTRL_SET 0x06
62
63 #define TWL6030_MISC1 0xE4
64 #define VBUS_MEAS 0x01
65 #define ID_MEAS 0x01
66
67 #define VAC_MEAS 0x04
68 #define VBAT_MEAS 0x02
69 #define BB_MEAS 0x01
70
71
72 /**
73 * struct twl6030_chnl_calib - channel calibration
74 * @gain: slope coefficient for ideal curve
75 * @gain_error: gain error
76 * @offset_error: offset of the real curve
77 */
78 struct twl6030_chnl_calib {
79 s32 gain;
80 s32 gain_error;
81 s32 offset_error;
82 };
83
84 /**
85 * struct twl6030_ideal_code - GPADC calibration parameters
86 * GPADC is calibrated in two points: close to the beginning and
87 * to the and of the measurable input range
88 *
89 * @channel: channel number
90 * @code1: ideal code for the input at the beginning
91 * @code2: ideal code for at the end of the range
92 * @volt1: voltage input at the beginning(low voltage)
93 * @volt2: voltage input at the end(high voltage)
94 */
95 struct twl6030_ideal_code {
96 int channel;
97 u16 code1;
98 u16 code2;
99 u16 volt1;
100 u16 volt2;
101 };
102
103 struct twl6030_gpadc_data;
104
105 /**
106 * struct twl6030_gpadc_platform_data - platform specific data
107 * @nchannels: number of GPADC channels
108 * @iio_channels: iio channels
109 * @ideal: pointer to calibration parameters
110 * @start_conversion: pointer to ADC start conversion function
111 * @channel_to_reg: pointer to ADC function to convert channel to
112 * register address for reading conversion result
113 * @calibrate: pointer to calibration function
114 */
115 struct twl6030_gpadc_platform_data {
116 const int nchannels;
117 const struct iio_chan_spec *iio_channels;
118 const struct twl6030_ideal_code *ideal;
119 int (*start_conversion)(int channel);
120 u8 (*channel_to_reg)(int channel);
121 int (*calibrate)(struct twl6030_gpadc_data *gpadc);
122 };
123
124 /**
125 * struct twl6030_gpadc_data - GPADC data
126 * @dev: device pointer
127 * @lock: mutual exclusion lock for the structure
128 * @irq_complete: completion to signal end of conversion
129 * @twl6030_cal_tbl: pointer to calibration data for each
130 * channel with gain error and offset
131 * @pdata: pointer to device specific data
132 */
133 struct twl6030_gpadc_data {
134 struct device *dev;
135 struct mutex lock;
136 struct completion irq_complete;
137 struct twl6030_chnl_calib *twl6030_cal_tbl;
138 const struct twl6030_gpadc_platform_data *pdata;
139 };
140
141 /*
142 * channels 11, 12, 13, 15 and 16 have no calibration data
143 * calibration offset is same for channels 1, 3, 4, 5
144 *
145 * The data is taken from GPADC_TRIM registers description.
146 * GPADC_TRIM registers keep difference between the code measured
147 * at volt1 and volt2 input voltages and corresponding code1 and code2
148 */
149 static const struct twl6030_ideal_code
150 twl6030_ideal[TWL6030_GPADC_USED_CHANNELS] = {
151 [0] = { /* ch 0, external, battery type, resistor value */
152 .channel = 0,
153 .code1 = 116,
154 .code2 = 745,
155 .volt1 = 141,
156 .volt2 = 910,
157 },
158 [1] = { /* ch 1, external, battery temperature, NTC resistor value */
159 .channel = 1,
160 .code1 = 82,
161 .code2 = 900,
162 .volt1 = 100,
163 .volt2 = 1100,
164 },
165 [2] = { /* ch 2, external, audio accessory/general purpose */
166 .channel = 2,
167 .code1 = 55,
168 .code2 = 818,
169 .volt1 = 101,
170 .volt2 = 1499,
171 },
172 [3] = { /* ch 3, external, general purpose */
173 .channel = 3,
174 .code1 = 82,
175 .code2 = 900,
176 .volt1 = 100,
177 .volt2 = 1100,
178 },
179 [4] = { /* ch 4, external, temperature measurement/general purpose */
180 .channel = 4,
181 .code1 = 82,
182 .code2 = 900,
183 .volt1 = 100,
184 .volt2 = 1100,
185 },
186 [5] = { /* ch 5, external, general purpose */
187 .channel = 5,
188 .code1 = 82,
189 .code2 = 900,
190 .volt1 = 100,
191 .volt2 = 1100,
192 },
193 [6] = { /* ch 6, external, general purpose */
194 .channel = 6,
195 .code1 = 82,
196 .code2 = 900,
197 .volt1 = 100,
198 .volt2 = 1100,
199 },
200 [7] = { /* ch 7, internal, main battery */
201 .channel = 7,
202 .code1 = 614,
203 .code2 = 941,
204 .volt1 = 3001,
205 .volt2 = 4599,
206 },
207 [8] = { /* ch 8, internal, backup battery */
208 .channel = 8,
209 .code1 = 82,
210 .code2 = 688,
211 .volt1 = 501,
212 .volt2 = 4203,
213 },
214 [9] = { /* ch 9, internal, external charger input */
215 .channel = 9,
216 .code1 = 182,
217 .code2 = 818,
218 .volt1 = 2001,
219 .volt2 = 8996,
220 },
221 [10] = { /* ch 10, internal, VBUS */
222 .channel = 10,
223 .code1 = 149,
224 .code2 = 818,
225 .volt1 = 1001,
226 .volt2 = 5497,
227 },
228 [11] = { /* ch 11, internal, VBUS charging current */
229 .channel = 11,
230 },
231 /* ch 12, internal, Die temperature */
232 /* ch 13, internal, Die temperature */
233 [12] = { /* ch 14, internal, USB ID line */
234 .channel = 14,
235 .code1 = 48,
236 .code2 = 714,
237 .volt1 = 323,
238 .volt2 = 4800,
239 },
240 };
241
242 static const struct twl6030_ideal_code
243 twl6032_ideal[TWL6032_GPADC_USED_CHANNELS] = {
244 [0] = { /* ch 0, external, battery type, resistor value */
245 .channel = 0,
246 .code1 = 1441,
247 .code2 = 3276,
248 .volt1 = 440,
249 .volt2 = 1000,
250 },
251 [1] = { /* ch 1, external, battery temperature, NTC resistor value */
252 .channel = 1,
253 .code1 = 1441,
254 .code2 = 3276,
255 .volt1 = 440,
256 .volt2 = 1000,
257 },
258 [2] = { /* ch 2, external, audio accessory/general purpose */
259 .channel = 2,
260 .code1 = 1441,
261 .code2 = 3276,
262 .volt1 = 660,
263 .volt2 = 1500,
264 },
265 [3] = { /* ch 3, external, temperature with external diode/general
266 purpose */
267 .channel = 3,
268 .code1 = 1441,
269 .code2 = 3276,
270 .volt1 = 440,
271 .volt2 = 1000,
272 },
273 [4] = { /* ch 4, external, temperature measurement/general purpose */
274 .channel = 4,
275 .code1 = 1441,
276 .code2 = 3276,
277 .volt1 = 440,
278 .volt2 = 1000,
279 },
280 [5] = { /* ch 5, external, general purpose */
281 .channel = 5,
282 .code1 = 1441,
283 .code2 = 3276,
284 .volt1 = 440,
285 .volt2 = 1000,
286 },
287 [6] = { /* ch 6, external, general purpose */
288 .channel = 6,
289 .code1 = 1441,
290 .code2 = 3276,
291 .volt1 = 440,
292 .volt2 = 1000,
293 },
294 [7] = { /* ch7, internal, system supply */
295 .channel = 7,
296 .code1 = 1441,
297 .code2 = 3276,
298 .volt1 = 2200,
299 .volt2 = 5000,
300 },
301 [8] = { /* ch8, internal, backup battery */
302 .channel = 8,
303 .code1 = 1441,
304 .code2 = 3276,
305 .volt1 = 2200,
306 .volt2 = 5000,
307 },
308 [9] = { /* ch 9, internal, external charger input */
309 .channel = 9,
310 .code1 = 1441,
311 .code2 = 3276,
312 .volt1 = 3960,
313 .volt2 = 9000,
314 },
315 [10] = { /* ch10, internal, VBUS */
316 .channel = 10,
317 .code1 = 150,
318 .code2 = 751,
319 .volt1 = 1000,
320 .volt2 = 5000,
321 },
322 [11] = { /* ch 11, internal, VBUS DC-DC output current */
323 .channel = 11,
324 .code1 = 1441,
325 .code2 = 3276,
326 .volt1 = 660,
327 .volt2 = 1500,
328 },
329 /* ch 12, internal, Die temperature */
330 /* ch 13, internal, Die temperature */
331 [12] = { /* ch 14, internal, USB ID line */
332 .channel = 14,
333 .code1 = 1441,
334 .code2 = 3276,
335 .volt1 = 2420,
336 .volt2 = 5500,
337 },
338 /* ch 15, internal, test network */
339 /* ch 16, internal, test network */
340 [13] = { /* ch 17, internal, battery charging current */
341 .channel = 17,
342 },
343 [14] = { /* ch 18, internal, battery voltage */
344 .channel = 18,
345 .code1 = 1441,
346 .code2 = 3276,
347 .volt1 = 2200,
348 .volt2 = 5000,
349 },
350 };
351
twl6030_gpadc_write(u8 reg,u8 val)352 static inline int twl6030_gpadc_write(u8 reg, u8 val)
353 {
354 return twl_i2c_write_u8(TWL6030_MODULE_GPADC, val, reg);
355 }
356
twl6030_gpadc_read(u8 reg,u8 * val)357 static inline int twl6030_gpadc_read(u8 reg, u8 *val)
358 {
359
360 return twl_i2c_read(TWL6030_MODULE_GPADC, val, reg, 2);
361 }
362
twl6030_gpadc_enable_irq(u8 mask)363 static int twl6030_gpadc_enable_irq(u8 mask)
364 {
365 int ret;
366
367 ret = twl6030_interrupt_unmask(mask, REG_INT_MSK_LINE_B);
368 if (ret < 0)
369 return ret;
370
371 ret = twl6030_interrupt_unmask(mask, REG_INT_MSK_STS_B);
372
373 return ret;
374 }
375
twl6030_gpadc_disable_irq(u8 mask)376 static void twl6030_gpadc_disable_irq(u8 mask)
377 {
378 twl6030_interrupt_mask(mask, REG_INT_MSK_LINE_B);
379 twl6030_interrupt_mask(mask, REG_INT_MSK_STS_B);
380 }
381
twl6030_gpadc_irq_handler(int irq,void * indio_dev)382 static irqreturn_t twl6030_gpadc_irq_handler(int irq, void *indio_dev)
383 {
384 struct twl6030_gpadc_data *gpadc = iio_priv(indio_dev);
385
386 complete(&gpadc->irq_complete);
387
388 return IRQ_HANDLED;
389 }
390
twl6030_start_conversion(int channel)391 static int twl6030_start_conversion(int channel)
392 {
393 return twl6030_gpadc_write(TWL6030_GPADC_CTRL_P1,
394 TWL6030_GPADC_CTRL_P1_SP1);
395 }
396
twl6032_start_conversion(int channel)397 static int twl6032_start_conversion(int channel)
398 {
399 int ret;
400
401 ret = twl6030_gpadc_write(TWL6032_GPADC_GPSELECT_ISB, channel);
402 if (ret)
403 return ret;
404
405 return twl6030_gpadc_write(TWL6032_GPADC_CTRL_P1,
406 TWL6030_GPADC_CTRL_P1_SP1);
407 }
408
twl6030_channel_to_reg(int channel)409 static u8 twl6030_channel_to_reg(int channel)
410 {
411 return TWL6030_GPADC_GPCH0_LSB + 2 * channel;
412 }
413
twl6032_channel_to_reg(int channel)414 static u8 twl6032_channel_to_reg(int channel)
415 {
416 /*
417 * for any prior chosen channel, when the conversion is ready
418 * the result is avalable in GPCH0_LSB, GPCH0_MSB.
419 */
420
421 return TWL6032_GPADC_GPCH0_LSB;
422 }
423
twl6030_gpadc_lookup(const struct twl6030_ideal_code * ideal,int channel,int size)424 static int twl6030_gpadc_lookup(const struct twl6030_ideal_code *ideal,
425 int channel, int size)
426 {
427 int i;
428
429 for (i = 0; i < size; i++)
430 if (ideal[i].channel == channel)
431 break;
432
433 return i;
434 }
435
twl6030_channel_calibrated(const struct twl6030_gpadc_platform_data * pdata,int channel)436 static int twl6030_channel_calibrated(const struct twl6030_gpadc_platform_data
437 *pdata, int channel)
438 {
439 const struct twl6030_ideal_code *ideal = pdata->ideal;
440 int i;
441
442 i = twl6030_gpadc_lookup(ideal, channel, pdata->nchannels);
443 /* not calibrated channels have 0 in all structure members */
444 return pdata->ideal[i].code2;
445 }
446
twl6030_gpadc_make_correction(struct twl6030_gpadc_data * gpadc,int channel,int raw_code)447 static int twl6030_gpadc_make_correction(struct twl6030_gpadc_data *gpadc,
448 int channel, int raw_code)
449 {
450 const struct twl6030_ideal_code *ideal = gpadc->pdata->ideal;
451 int corrected_code;
452 int i;
453
454 i = twl6030_gpadc_lookup(ideal, channel, gpadc->pdata->nchannels);
455 corrected_code = ((raw_code * 1000) -
456 gpadc->twl6030_cal_tbl[i].offset_error) /
457 gpadc->twl6030_cal_tbl[i].gain_error;
458
459 return corrected_code;
460 }
461
twl6030_gpadc_get_raw(struct twl6030_gpadc_data * gpadc,int channel,int * res)462 static int twl6030_gpadc_get_raw(struct twl6030_gpadc_data *gpadc,
463 int channel, int *res)
464 {
465 u8 reg = gpadc->pdata->channel_to_reg(channel);
466 __le16 val;
467 int raw_code;
468 int ret;
469
470 ret = twl6030_gpadc_read(reg, (u8 *)&val);
471 if (ret) {
472 dev_dbg(gpadc->dev, "unable to read register 0x%X\n", reg);
473 return ret;
474 }
475
476 raw_code = le16_to_cpu(val);
477 dev_dbg(gpadc->dev, "GPADC raw code: %d", raw_code);
478
479 if (twl6030_channel_calibrated(gpadc->pdata, channel))
480 *res = twl6030_gpadc_make_correction(gpadc, channel, raw_code);
481 else
482 *res = raw_code;
483
484 return ret;
485 }
486
twl6030_gpadc_get_processed(struct twl6030_gpadc_data * gpadc,int channel,int * val)487 static int twl6030_gpadc_get_processed(struct twl6030_gpadc_data *gpadc,
488 int channel, int *val)
489 {
490 const struct twl6030_ideal_code *ideal = gpadc->pdata->ideal;
491 int corrected_code;
492 int channel_value;
493 int i;
494 int ret;
495
496 ret = twl6030_gpadc_get_raw(gpadc, channel, &corrected_code);
497 if (ret)
498 return ret;
499
500 i = twl6030_gpadc_lookup(ideal, channel, gpadc->pdata->nchannels);
501 channel_value = corrected_code *
502 gpadc->twl6030_cal_tbl[i].gain;
503
504 /* Shift back into mV range */
505 channel_value /= 1000;
506
507 dev_dbg(gpadc->dev, "GPADC corrected code: %d", corrected_code);
508 dev_dbg(gpadc->dev, "GPADC value: %d", channel_value);
509
510 *val = channel_value;
511
512 return ret;
513 }
514
twl6030_gpadc_read_raw(struct iio_dev * indio_dev,const struct iio_chan_spec * chan,int * val,int * val2,long mask)515 static int twl6030_gpadc_read_raw(struct iio_dev *indio_dev,
516 const struct iio_chan_spec *chan,
517 int *val, int *val2, long mask)
518 {
519 struct twl6030_gpadc_data *gpadc = iio_priv(indio_dev);
520 int ret;
521 long timeout;
522
523 mutex_lock(&gpadc->lock);
524
525 ret = gpadc->pdata->start_conversion(chan->channel);
526 if (ret) {
527 dev_err(gpadc->dev, "failed to start conversion\n");
528 goto err;
529 }
530 /* wait for conversion to complete */
531 timeout = wait_for_completion_interruptible_timeout(
532 &gpadc->irq_complete, msecs_to_jiffies(5000));
533 if (timeout == 0) {
534 ret = -ETIMEDOUT;
535 goto err;
536 } else if (timeout < 0) {
537 ret = -EINTR;
538 goto err;
539 }
540
541 switch (mask) {
542 case IIO_CHAN_INFO_RAW:
543 ret = twl6030_gpadc_get_raw(gpadc, chan->channel, val);
544 ret = ret ? -EIO : IIO_VAL_INT;
545 break;
546
547 case IIO_CHAN_INFO_PROCESSED:
548 ret = twl6030_gpadc_get_processed(gpadc, chan->channel, val);
549 ret = ret ? -EIO : IIO_VAL_INT;
550 break;
551
552 default:
553 break;
554 }
555 err:
556 mutex_unlock(&gpadc->lock);
557
558 return ret;
559 }
560
561 /*
562 * The GPADC channels are calibrated using a two point calibration method.
563 * The channels measured with two known values: volt1 and volt2, and
564 * ideal corresponding output codes are known: code1, code2.
565 * The difference(d1, d2) between ideal and measured codes stored in trim
566 * registers.
567 * The goal is to find offset and gain of the real curve for each calibrated
568 * channel.
569 * gain: k = 1 + ((d2 - d1) / (x2 - x1))
570 * offset: b = d1 + (k - 1) * x1
571 */
twl6030_calibrate_channel(struct twl6030_gpadc_data * gpadc,int channel,int d1,int d2)572 static void twl6030_calibrate_channel(struct twl6030_gpadc_data *gpadc,
573 int channel, int d1, int d2)
574 {
575 int b, k, gain, x1, x2, i;
576 const struct twl6030_ideal_code *ideal = gpadc->pdata->ideal;
577
578 i = twl6030_gpadc_lookup(ideal, channel, gpadc->pdata->nchannels);
579
580 /* Gain */
581 gain = ((ideal[i].volt2 - ideal[i].volt1) * 1000) /
582 (ideal[i].code2 - ideal[i].code1);
583
584 x1 = ideal[i].code1;
585 x2 = ideal[i].code2;
586
587 /* k - real curve gain */
588 k = 1000 + (((d2 - d1) * 1000) / (x2 - x1));
589
590 /* b - offset of the real curve gain */
591 b = (d1 * 1000) - (k - 1000) * x1;
592
593 gpadc->twl6030_cal_tbl[i].gain = gain;
594 gpadc->twl6030_cal_tbl[i].gain_error = k;
595 gpadc->twl6030_cal_tbl[i].offset_error = b;
596
597 dev_dbg(gpadc->dev, "GPADC d1 for Chn: %d = %d\n", channel, d1);
598 dev_dbg(gpadc->dev, "GPADC d2 for Chn: %d = %d\n", channel, d2);
599 dev_dbg(gpadc->dev, "GPADC x1 for Chn: %d = %d\n", channel, x1);
600 dev_dbg(gpadc->dev, "GPADC x2 for Chn: %d = %d\n", channel, x2);
601 dev_dbg(gpadc->dev, "GPADC Gain for Chn: %d = %d\n", channel, gain);
602 dev_dbg(gpadc->dev, "GPADC k for Chn: %d = %d\n", channel, k);
603 dev_dbg(gpadc->dev, "GPADC b for Chn: %d = %d\n", channel, b);
604 }
605
twl6030_gpadc_get_trim_offset(s8 d)606 static inline int twl6030_gpadc_get_trim_offset(s8 d)
607 {
608 /*
609 * XXX NOTE!
610 * bit 0 - sign, bit 7 - reserved, 6..1 - trim value
611 * though, the documentation states that trim value
612 * is absolute value, the correct conversion results are
613 * obtained if the value is interpreted as 2's complement.
614 */
615 __u32 temp = ((d & 0x7f) >> 1) | ((d & 1) << 6);
616
617 return sign_extend32(temp, 6);
618 }
619
twl6030_calibration(struct twl6030_gpadc_data * gpadc)620 static int twl6030_calibration(struct twl6030_gpadc_data *gpadc)
621 {
622 int ret;
623 int chn;
624 u8 trim_regs[TWL6030_GPADC_NUM_TRIM_REGS];
625 s8 d1, d2;
626
627 /*
628 * for calibration two measurements have been performed at
629 * factory, for some channels, during the production test and
630 * have been stored in registers. This two stored values are
631 * used to correct the measurements. The values represent
632 * offsets for the given input from the output on ideal curve.
633 */
634 ret = twl_i2c_read(TWL6030_MODULE_ID2, trim_regs,
635 TWL6030_GPADC_TRIM1, TWL6030_GPADC_NUM_TRIM_REGS);
636 if (ret < 0) {
637 dev_err(gpadc->dev, "calibration failed\n");
638 return ret;
639 }
640
641 for (chn = 0; chn < TWL6030_GPADC_MAX_CHANNELS; chn++) {
642
643 switch (chn) {
644 case 0:
645 d1 = trim_regs[0];
646 d2 = trim_regs[1];
647 break;
648 case 1:
649 case 3:
650 case 4:
651 case 5:
652 case 6:
653 d1 = trim_regs[4];
654 d2 = trim_regs[5];
655 break;
656 case 2:
657 d1 = trim_regs[12];
658 d2 = trim_regs[13];
659 break;
660 case 7:
661 d1 = trim_regs[6];
662 d2 = trim_regs[7];
663 break;
664 case 8:
665 d1 = trim_regs[2];
666 d2 = trim_regs[3];
667 break;
668 case 9:
669 d1 = trim_regs[8];
670 d2 = trim_regs[9];
671 break;
672 case 10:
673 d1 = trim_regs[10];
674 d2 = trim_regs[11];
675 break;
676 case 14:
677 d1 = trim_regs[14];
678 d2 = trim_regs[15];
679 break;
680 default:
681 continue;
682 }
683
684 d1 = twl6030_gpadc_get_trim_offset(d1);
685 d2 = twl6030_gpadc_get_trim_offset(d2);
686
687 twl6030_calibrate_channel(gpadc, chn, d1, d2);
688 }
689
690 return 0;
691 }
692
twl6032_get_trim_value(u8 * trim_regs,unsigned int reg0,unsigned int reg1,unsigned int mask0,unsigned int mask1,unsigned int shift0)693 static int twl6032_get_trim_value(u8 *trim_regs, unsigned int reg0,
694 unsigned int reg1, unsigned int mask0, unsigned int mask1,
695 unsigned int shift0)
696 {
697 int val;
698
699 val = (trim_regs[reg0] & mask0) << shift0;
700 val |= (trim_regs[reg1] & mask1) >> 1;
701 if (trim_regs[reg1] & 0x01)
702 val = -val;
703
704 return val;
705 }
706
twl6032_calibration(struct twl6030_gpadc_data * gpadc)707 static int twl6032_calibration(struct twl6030_gpadc_data *gpadc)
708 {
709 int chn, d1 = 0, d2 = 0, temp;
710 u8 trim_regs[TWL6030_GPADC_NUM_TRIM_REGS];
711 int ret;
712
713 ret = twl_i2c_read(TWL6030_MODULE_ID2, trim_regs,
714 TWL6030_GPADC_TRIM1, TWL6030_GPADC_NUM_TRIM_REGS);
715 if (ret < 0) {
716 dev_err(gpadc->dev, "calibration failed\n");
717 return ret;
718 }
719
720 /*
721 * Loop to calculate the value needed for returning voltages from
722 * GPADC not values.
723 *
724 * gain is calculated to 3 decimal places fixed point.
725 */
726 for (chn = 0; chn < TWL6032_GPADC_MAX_CHANNELS; chn++) {
727
728 switch (chn) {
729 case 0:
730 case 1:
731 case 2:
732 case 3:
733 case 4:
734 case 5:
735 case 6:
736 case 11:
737 case 14:
738 d1 = twl6032_get_trim_value(trim_regs, 2, 0, 0x1f,
739 0x06, 2);
740 d2 = twl6032_get_trim_value(trim_regs, 3, 1, 0x3f,
741 0x06, 2);
742 break;
743 case 8:
744 temp = twl6032_get_trim_value(trim_regs, 2, 0, 0x1f,
745 0x06, 2);
746 d1 = temp + twl6032_get_trim_value(trim_regs, 7, 6,
747 0x18, 0x1E, 1);
748
749 temp = twl6032_get_trim_value(trim_regs, 3, 1, 0x3F,
750 0x06, 2);
751 d2 = temp + twl6032_get_trim_value(trim_regs, 9, 7,
752 0x1F, 0x06, 2);
753 break;
754 case 9:
755 temp = twl6032_get_trim_value(trim_regs, 2, 0, 0x1f,
756 0x06, 2);
757 d1 = temp + twl6032_get_trim_value(trim_regs, 13, 11,
758 0x18, 0x1E, 1);
759
760 temp = twl6032_get_trim_value(trim_regs, 3, 1, 0x3f,
761 0x06, 2);
762 d2 = temp + twl6032_get_trim_value(trim_regs, 15, 13,
763 0x1F, 0x06, 1);
764 break;
765 case 10:
766 d1 = twl6032_get_trim_value(trim_regs, 10, 8, 0x0f,
767 0x0E, 3);
768 d2 = twl6032_get_trim_value(trim_regs, 14, 12, 0x0f,
769 0x0E, 3);
770 break;
771 case 7:
772 case 18:
773 temp = twl6032_get_trim_value(trim_regs, 2, 0, 0x1f,
774 0x06, 2);
775
776 d1 = (trim_regs[4] & 0x7E) >> 1;
777 if (trim_regs[4] & 0x01)
778 d1 = -d1;
779 d1 += temp;
780
781 temp = twl6032_get_trim_value(trim_regs, 3, 1, 0x3f,
782 0x06, 2);
783
784 d2 = (trim_regs[5] & 0xFE) >> 1;
785 if (trim_regs[5] & 0x01)
786 d2 = -d2;
787
788 d2 += temp;
789 break;
790 default:
791 /* No data for other channels */
792 continue;
793 }
794
795 twl6030_calibrate_channel(gpadc, chn, d1, d2);
796 }
797
798 return 0;
799 }
800
801 #define TWL6030_GPADC_CHAN(chn, _type, chan_info) { \
802 .type = _type, \
803 .channel = chn, \
804 .info_mask_separate = BIT(chan_info), \
805 .indexed = 1, \
806 }
807
808 static const struct iio_chan_spec twl6030_gpadc_iio_channels[] = {
809 TWL6030_GPADC_CHAN(0, IIO_VOLTAGE, IIO_CHAN_INFO_PROCESSED),
810 TWL6030_GPADC_CHAN(1, IIO_TEMP, IIO_CHAN_INFO_RAW),
811 TWL6030_GPADC_CHAN(2, IIO_VOLTAGE, IIO_CHAN_INFO_PROCESSED),
812 TWL6030_GPADC_CHAN(3, IIO_VOLTAGE, IIO_CHAN_INFO_PROCESSED),
813 TWL6030_GPADC_CHAN(4, IIO_TEMP, IIO_CHAN_INFO_RAW),
814 TWL6030_GPADC_CHAN(5, IIO_VOLTAGE, IIO_CHAN_INFO_PROCESSED),
815 TWL6030_GPADC_CHAN(6, IIO_VOLTAGE, IIO_CHAN_INFO_PROCESSED),
816 TWL6030_GPADC_CHAN(7, IIO_VOLTAGE, IIO_CHAN_INFO_PROCESSED),
817 TWL6030_GPADC_CHAN(8, IIO_VOLTAGE, IIO_CHAN_INFO_PROCESSED),
818 TWL6030_GPADC_CHAN(9, IIO_VOLTAGE, IIO_CHAN_INFO_PROCESSED),
819 TWL6030_GPADC_CHAN(10, IIO_VOLTAGE, IIO_CHAN_INFO_PROCESSED),
820 TWL6030_GPADC_CHAN(11, IIO_VOLTAGE, IIO_CHAN_INFO_RAW),
821 TWL6030_GPADC_CHAN(14, IIO_VOLTAGE, IIO_CHAN_INFO_PROCESSED),
822 };
823
824 static const struct iio_chan_spec twl6032_gpadc_iio_channels[] = {
825 TWL6030_GPADC_CHAN(0, IIO_VOLTAGE, IIO_CHAN_INFO_PROCESSED),
826 TWL6030_GPADC_CHAN(1, IIO_TEMP, IIO_CHAN_INFO_RAW),
827 TWL6030_GPADC_CHAN(2, IIO_VOLTAGE, IIO_CHAN_INFO_PROCESSED),
828 TWL6030_GPADC_CHAN(3, IIO_VOLTAGE, IIO_CHAN_INFO_PROCESSED),
829 TWL6030_GPADC_CHAN(4, IIO_TEMP, IIO_CHAN_INFO_RAW),
830 TWL6030_GPADC_CHAN(5, IIO_VOLTAGE, IIO_CHAN_INFO_PROCESSED),
831 TWL6030_GPADC_CHAN(6, IIO_VOLTAGE, IIO_CHAN_INFO_PROCESSED),
832 TWL6030_GPADC_CHAN(7, IIO_VOLTAGE, IIO_CHAN_INFO_PROCESSED),
833 TWL6030_GPADC_CHAN(8, IIO_VOLTAGE, IIO_CHAN_INFO_PROCESSED),
834 TWL6030_GPADC_CHAN(9, IIO_VOLTAGE, IIO_CHAN_INFO_PROCESSED),
835 TWL6030_GPADC_CHAN(10, IIO_VOLTAGE, IIO_CHAN_INFO_PROCESSED),
836 TWL6030_GPADC_CHAN(11, IIO_VOLTAGE, IIO_CHAN_INFO_PROCESSED),
837 TWL6030_GPADC_CHAN(14, IIO_VOLTAGE, IIO_CHAN_INFO_PROCESSED),
838 TWL6030_GPADC_CHAN(17, IIO_VOLTAGE, IIO_CHAN_INFO_RAW),
839 TWL6030_GPADC_CHAN(18, IIO_VOLTAGE, IIO_CHAN_INFO_PROCESSED),
840 };
841
842 static const struct iio_info twl6030_gpadc_iio_info = {
843 .read_raw = &twl6030_gpadc_read_raw,
844 };
845
846 static const struct twl6030_gpadc_platform_data twl6030_pdata = {
847 .iio_channels = twl6030_gpadc_iio_channels,
848 .nchannels = TWL6030_GPADC_USED_CHANNELS,
849 .ideal = twl6030_ideal,
850 .start_conversion = twl6030_start_conversion,
851 .channel_to_reg = twl6030_channel_to_reg,
852 .calibrate = twl6030_calibration,
853 };
854
855 static const struct twl6030_gpadc_platform_data twl6032_pdata = {
856 .iio_channels = twl6032_gpadc_iio_channels,
857 .nchannels = TWL6032_GPADC_USED_CHANNELS,
858 .ideal = twl6032_ideal,
859 .start_conversion = twl6032_start_conversion,
860 .channel_to_reg = twl6032_channel_to_reg,
861 .calibrate = twl6032_calibration,
862 };
863
864 static const struct of_device_id of_twl6030_match_tbl[] = {
865 {
866 .compatible = "ti,twl6030-gpadc",
867 .data = &twl6030_pdata,
868 },
869 {
870 .compatible = "ti,twl6032-gpadc",
871 .data = &twl6032_pdata,
872 },
873 { /* end */ }
874 };
875 MODULE_DEVICE_TABLE(of, of_twl6030_match_tbl);
876
twl6030_gpadc_probe(struct platform_device * pdev)877 static int twl6030_gpadc_probe(struct platform_device *pdev)
878 {
879 struct device *dev = &pdev->dev;
880 struct twl6030_gpadc_data *gpadc;
881 const struct twl6030_gpadc_platform_data *pdata;
882 const struct of_device_id *match;
883 struct iio_dev *indio_dev;
884 int irq;
885 int ret;
886
887 match = of_match_device(of_twl6030_match_tbl, dev);
888 if (!match)
889 return -EINVAL;
890
891 pdata = match->data;
892
893 indio_dev = devm_iio_device_alloc(dev, sizeof(*gpadc));
894 if (!indio_dev)
895 return -ENOMEM;
896
897 gpadc = iio_priv(indio_dev);
898
899 gpadc->twl6030_cal_tbl = devm_kcalloc(dev,
900 pdata->nchannels,
901 sizeof(*gpadc->twl6030_cal_tbl),
902 GFP_KERNEL);
903 if (!gpadc->twl6030_cal_tbl)
904 return -ENOMEM;
905
906 gpadc->dev = dev;
907 gpadc->pdata = pdata;
908
909 platform_set_drvdata(pdev, indio_dev);
910 mutex_init(&gpadc->lock);
911 init_completion(&gpadc->irq_complete);
912
913 ret = pdata->calibrate(gpadc);
914 if (ret < 0) {
915 dev_err(&pdev->dev, "failed to read calibration registers\n");
916 return ret;
917 }
918
919 irq = platform_get_irq(pdev, 0);
920 if (irq < 0)
921 return irq;
922
923 ret = devm_request_threaded_irq(dev, irq, NULL,
924 twl6030_gpadc_irq_handler,
925 IRQF_ONESHOT, "twl6030_gpadc", indio_dev);
926 if (ret)
927 return ret;
928
929 ret = twl6030_gpadc_enable_irq(TWL6030_GPADC_RT_SW1_EOC_MASK);
930 if (ret < 0) {
931 dev_err(&pdev->dev, "failed to enable GPADC interrupt\n");
932 return ret;
933 }
934
935 ret = twl_i2c_write_u8(TWL6030_MODULE_ID1, TWL6030_GPADCS,
936 TWL6030_REG_TOGGLE1);
937 if (ret < 0) {
938 dev_err(&pdev->dev, "failed to enable GPADC module\n");
939 return ret;
940 }
941
942 ret = twl_i2c_write_u8(TWL_MODULE_USB, VBUS_MEAS, USB_VBUS_CTRL_SET);
943 if (ret < 0) {
944 dev_err(dev, "failed to wire up inputs\n");
945 return ret;
946 }
947
948 ret = twl_i2c_write_u8(TWL_MODULE_USB, ID_MEAS, USB_ID_CTRL_SET);
949 if (ret < 0) {
950 dev_err(dev, "failed to wire up inputs\n");
951 return ret;
952 }
953
954 ret = twl_i2c_write_u8(TWL6030_MODULE_ID0,
955 VBAT_MEAS | BB_MEAS | VAC_MEAS,
956 TWL6030_MISC1);
957 if (ret < 0) {
958 dev_err(dev, "failed to wire up inputs\n");
959 return ret;
960 }
961
962 indio_dev->name = DRIVER_NAME;
963 indio_dev->info = &twl6030_gpadc_iio_info;
964 indio_dev->modes = INDIO_DIRECT_MODE;
965 indio_dev->channels = pdata->iio_channels;
966 indio_dev->num_channels = pdata->nchannels;
967
968 return iio_device_register(indio_dev);
969 }
970
twl6030_gpadc_remove(struct platform_device * pdev)971 static int twl6030_gpadc_remove(struct platform_device *pdev)
972 {
973 struct iio_dev *indio_dev = platform_get_drvdata(pdev);
974
975 twl6030_gpadc_disable_irq(TWL6030_GPADC_RT_SW1_EOC_MASK);
976 iio_device_unregister(indio_dev);
977
978 return 0;
979 }
980
981 #ifdef CONFIG_PM_SLEEP
twl6030_gpadc_suspend(struct device * pdev)982 static int twl6030_gpadc_suspend(struct device *pdev)
983 {
984 int ret;
985
986 ret = twl_i2c_write_u8(TWL6030_MODULE_ID1, TWL6030_GPADCR,
987 TWL6030_REG_TOGGLE1);
988 if (ret)
989 dev_err(pdev, "error resetting GPADC (%d)!\n", ret);
990
991 return 0;
992 };
993
twl6030_gpadc_resume(struct device * pdev)994 static int twl6030_gpadc_resume(struct device *pdev)
995 {
996 int ret;
997
998 ret = twl_i2c_write_u8(TWL6030_MODULE_ID1, TWL6030_GPADCS,
999 TWL6030_REG_TOGGLE1);
1000 if (ret)
1001 dev_err(pdev, "error setting GPADC (%d)!\n", ret);
1002
1003 return 0;
1004 };
1005 #endif
1006
1007 static SIMPLE_DEV_PM_OPS(twl6030_gpadc_pm_ops, twl6030_gpadc_suspend,
1008 twl6030_gpadc_resume);
1009
1010 static struct platform_driver twl6030_gpadc_driver = {
1011 .probe = twl6030_gpadc_probe,
1012 .remove = twl6030_gpadc_remove,
1013 .driver = {
1014 .name = DRIVER_NAME,
1015 .pm = &twl6030_gpadc_pm_ops,
1016 .of_match_table = of_twl6030_match_tbl,
1017 },
1018 };
1019
1020 module_platform_driver(twl6030_gpadc_driver);
1021
1022 MODULE_ALIAS("platform:" DRIVER_NAME);
1023 MODULE_AUTHOR("Balaji T K <balajitk@ti.com>");
1024 MODULE_AUTHOR("Graeme Gregory <gg@slimlogic.co.uk>");
1025 MODULE_AUTHOR("Oleksandr Kozaruk <oleksandr.kozaruk@ti.com");
1026 MODULE_DESCRIPTION("twl6030 ADC driver");
1027 MODULE_LICENSE("GPL");
1028