Version:  2.0.40 2.2.26 2.4.37 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16

Linux/drivers/iio/adc/twl6030-gpadc.c

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us