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