drivers/iio/adc/twl4030-madc.c

   1 /*
   2  *
   3  * TWL4030 MADC module driver-This driver monitors the real time
   4  * conversion of analog signals like battery temperature,
   5  * battery type, battery level etc.
   6  *
   7  * Copyright (C) 2011 Texas Instruments Incorporated - http://www.ti.com/
   8  * J Keerthy <j-keerthy@ti.com>
   9  *
  10  * Based on twl4030-madc.c
  11  * Copyright (C) 2008 Nokia Corporation
  12  * Mikko Ylinen <mikko.k.ylinen@nokia.com>
  13  *
  14  * Amit Kucheria <amit.kucheria@canonical.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
  32 #include <linux/device.h>
  33 #include <linux/interrupt.h>
  34 #include <linux/kernel.h>
  35 #include <linux/delay.h>
  36 #include <linux/platform_device.h>
  37 #include <linux/slab.h>
  38 #include <linux/i2c/twl.h>
  39 #include <linux/i2c/twl4030-madc.h>
  40 #include <linux/module.h>
  41 #include <linux/stddef.h>
  42 #include <linux/mutex.h>
  43 #include <linux/bitops.h>
  44 #include <linux/jiffies.h>
  45 #include <linux/types.h>
  46 #include <linux/gfp.h>
  47 #include <linux/err.h>
  48 #include <linux/regulator/consumer.h>
  49
  50 #include <linux/iio/iio.h>
  51
  52 #define TWL4030_USB_SEL_MADC_MCPC       (1<<3)
  53 #define TWL4030_USB_CARKIT_ANA_CTRL     0xBB
  54
  55 /**
  56  * struct twl4030_madc_data - a container for madc info
  57  * @dev:                Pointer to device structure for madc
  58  * @lock:               Mutex protecting this data structure
  59  * @regulator:          Pointer to bias regulator for madc
  60  * @requests:           Array of request struct corresponding to SW1, SW2 and RT
  61  * @use_second_irq:     IRQ selection (main or co-processor)
  62  * @imr:                Interrupt mask register of MADC
  63  * @isr:                Interrupt status register of MADC
  64  */
  65 struct twl4030_madc_data {
  66         struct device *dev;
  67         struct mutex lock;      /* mutex protecting this data structure */
  68         struct regulator *usb3v1;
  69         struct twl4030_madc_request requests[TWL4030_MADC_NUM_METHODS];
  70         bool use_second_irq;
  71         u8 imr;
  72         u8 isr;
  73 };
  74
  75 static int twl4030_madc_read(struct iio_dev *iio_dev,
  76                              const struct iio_chan_spec *chan,
  77                              int *val, int *val2, long mask)
  78 {
  79         struct twl4030_madc_data *madc = iio_priv(iio_dev);
  80         struct twl4030_madc_request req;
  81         int ret;
  82
  83         req.method = madc->use_second_irq ? TWL4030_MADC_SW2 : TWL4030_MADC_SW1;
  84
  85         req.channels = BIT(chan->channel);
  86         req.active = false;
  87         req.func_cb = NULL;
  88         req.type = TWL4030_MADC_WAIT;
  89         req.raw = !(mask == IIO_CHAN_INFO_PROCESSED);
  90         req.do_avg = (mask == IIO_CHAN_INFO_AVERAGE_RAW);
  91
  92         ret = twl4030_madc_conversion(&req);
  93         if (ret < 0)
  94                 return ret;
  95
  96         *val = req.rbuf[chan->channel];
  97
  98         return IIO_VAL_INT;
  99 }
 100
 101 static const struct iio_info twl4030_madc_iio_info = {
 102         .read_raw = &twl4030_madc_read,
 103         .driver_module = THIS_MODULE,
 104 };
 105
 106 #define TWL4030_ADC_CHANNEL(_channel, _type, _name) {   \
 107         .type = _type,                                  \
 108         .channel = _channel,                            \
 109         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |  \
 110                               BIT(IIO_CHAN_INFO_AVERAGE_RAW) | \
 111                               BIT(IIO_CHAN_INFO_PROCESSED), \
 112         .datasheet_name = _name,                        \
 113         .indexed = 1,                                   \
 114 }
 115
 116 static const struct iio_chan_spec twl4030_madc_iio_channels[] = {
 117         TWL4030_ADC_CHANNEL(0, IIO_VOLTAGE, "ADCIN0"),
 118         TWL4030_ADC_CHANNEL(1, IIO_TEMP, "ADCIN1"),
 119         TWL4030_ADC_CHANNEL(2, IIO_VOLTAGE, "ADCIN2"),
 120         TWL4030_ADC_CHANNEL(3, IIO_VOLTAGE, "ADCIN3"),
 121         TWL4030_ADC_CHANNEL(4, IIO_VOLTAGE, "ADCIN4"),
 122         TWL4030_ADC_CHANNEL(5, IIO_VOLTAGE, "ADCIN5"),
 123         TWL4030_ADC_CHANNEL(6, IIO_VOLTAGE, "ADCIN6"),
 124         TWL4030_ADC_CHANNEL(7, IIO_VOLTAGE, "ADCIN7"),
 125         TWL4030_ADC_CHANNEL(8, IIO_VOLTAGE, "ADCIN8"),
 126         TWL4030_ADC_CHANNEL(9, IIO_VOLTAGE, "ADCIN9"),
 127         TWL4030_ADC_CHANNEL(10, IIO_CURRENT, "ADCIN10"),
 128         TWL4030_ADC_CHANNEL(11, IIO_VOLTAGE, "ADCIN11"),
 129         TWL4030_ADC_CHANNEL(12, IIO_VOLTAGE, "ADCIN12"),
 130         TWL4030_ADC_CHANNEL(13, IIO_VOLTAGE, "ADCIN13"),
 131         TWL4030_ADC_CHANNEL(14, IIO_VOLTAGE, "ADCIN14"),
 132         TWL4030_ADC_CHANNEL(15, IIO_VOLTAGE, "ADCIN15"),
 133 };
 134
 135 static struct twl4030_madc_data *twl4030_madc;
 136
 137 struct twl4030_prescale_divider_ratios {
 138         s16 numerator;
 139         s16 denominator;
 140 };
 141
 142 static const struct twl4030_prescale_divider_ratios
 143 twl4030_divider_ratios[16] = {
 144         {1, 1},         /* CHANNEL 0 No Prescaler */
 145         {1, 1},         /* CHANNEL 1 No Prescaler */
 146         {6, 10},        /* CHANNEL 2 */
 147         {6, 10},        /* CHANNEL 3 */
 148         {6, 10},        /* CHANNEL 4 */
 149         {6, 10},        /* CHANNEL 5 */
 150         {6, 10},        /* CHANNEL 6 */
 151         {6, 10},        /* CHANNEL 7 */
 152         {3, 14},        /* CHANNEL 8 */
 153         {1, 3},         /* CHANNEL 9 */
 154         {1, 1},         /* CHANNEL 10 No Prescaler */
 155         {15, 100},      /* CHANNEL 11 */
 156         {1, 4},         /* CHANNEL 12 */
 157         {1, 1},         /* CHANNEL 13 Reserved channels */
 158         {1, 1},         /* CHANNEL 14 Reseved channels */
 159         {5, 11},        /* CHANNEL 15 */
 160 };
 161
 162
 163 /* Conversion table from -3 to 55 degrees Celcius */
 164 static int twl4030_therm_tbl[] = {
 165         30800,  29500,  28300,  27100,
 166         26000,  24900,  23900,  22900,  22000,  21100,  20300,  19400,  18700,
 167         17900,  17200,  16500,  15900,  15300,  14700,  14100,  13600,  13100,
 168         12600,  12100,  11600,  11200,  10800,  10400,  10000,  9630,   9280,
 169         8950,   8620,   8310,   8020,   7730,   7460,   7200,   6950,   6710,
 170         6470,   6250,   6040,   5830,   5640,   5450,   5260,   5090,   4920,
 171         4760,   4600,   4450,   4310,   4170,   4040,   3910,   3790,   3670,
 172         3550
 173 };
 174
 175 /*
 176  * Structure containing the registers
 177  * of different conversion methods supported by MADC.
 178  * Hardware or RT real time conversion request initiated by external host
 179  * processor for RT Signal conversions.
 180  * External host processors can also request for non RT conversions
 181  * SW1 and SW2 software conversions also called asynchronous or GPC request.
 182  */
 183 static
 184 const struct twl4030_madc_conversion_method twl4030_conversion_methods[] = {
 185         [TWL4030_MADC_RT] = {
 186                              .sel = TWL4030_MADC_RTSELECT_LSB,
 187                              .avg = TWL4030_MADC_RTAVERAGE_LSB,
 188                              .rbase = TWL4030_MADC_RTCH0_LSB,
 189                              },
 190         [TWL4030_MADC_SW1] = {
 191                               .sel = TWL4030_MADC_SW1SELECT_LSB,
 192                               .avg = TWL4030_MADC_SW1AVERAGE_LSB,
 193                               .rbase = TWL4030_MADC_GPCH0_LSB,
 194                               .ctrl = TWL4030_MADC_CTRL_SW1,
 195                               },
 196         [TWL4030_MADC_SW2] = {
 197                               .sel = TWL4030_MADC_SW2SELECT_LSB,
 198                               .avg = TWL4030_MADC_SW2AVERAGE_LSB,
 199                               .rbase = TWL4030_MADC_GPCH0_LSB,
 200                               .ctrl = TWL4030_MADC_CTRL_SW2,
 201                               },
 202 };
 203
 204 /**
 205  * twl4030_madc_channel_raw_read() - Function to read a particular channel value
 206  * @madc:       pointer to struct twl4030_madc_data
 207  * @reg:        lsb of ADC Channel
 208  *
 209  * Return: 0 on success, an error code otherwise.
 210  */
 211 static int twl4030_madc_channel_raw_read(struct twl4030_madc_data *madc, u8 reg)
 212 {
 213         u16 val;
 214         int ret;
 215         /*
 216          * For each ADC channel, we have MSB and LSB register pair. MSB address
 217          * is always LSB address+1. reg parameter is the address of LSB register
 218          */
 219         ret = twl_i2c_read_u16(TWL4030_MODULE_MADC, &val, reg);
 220         if (ret) {
 221                 dev_err(madc->dev, "unable to read register 0x%X\n", reg);
 222                 return ret;
 223         }
 224
 225         return (int)(val >> 6);
 226 }
 227
 228 /*
 229  * Return battery temperature in degrees Celsius
 230  * Or < 0 on failure.
 231  */
 232 static int twl4030battery_temperature(int raw_volt)
 233 {
 234         u8 val;
 235         int temp, curr, volt, res, ret;
 236
 237         volt = (raw_volt * TEMP_STEP_SIZE) / TEMP_PSR_R;
 238         /* Getting and calculating the supply current in micro amperes */
 239         ret = twl_i2c_read_u8(TWL_MODULE_MAIN_CHARGE, &val,
 240                 REG_BCICTL2);
 241         if (ret < 0)
 242                 return ret;
 243
 244         curr = ((val & TWL4030_BCI_ITHSENS) + 1) * 10;
 245         /* Getting and calculating the thermistor resistance in ohms */
 246         res = volt * 1000 / curr;
 247         /* calculating temperature */
 248         for (temp = 58; temp >= 0; temp--) {
 249                 int actual = twl4030_therm_tbl[temp];
 250                 if ((actual - res) >= 0)
 251                         break;
 252         }
 253
 254         return temp + 1;
 255 }
 256
 257 static int twl4030battery_current(int raw_volt)
 258 {
 259         int ret;
 260         u8 val;
 261
 262         ret = twl_i2c_read_u8(TWL_MODULE_MAIN_CHARGE, &val,
 263                 TWL4030_BCI_BCICTL1);
 264         if (ret)
 265                 return ret;
 266         if (val & TWL4030_BCI_CGAIN) /* slope of 0.44 mV/mA */
 267                 return (raw_volt * CURR_STEP_SIZE) / CURR_PSR_R1;
 268         else /* slope of 0.88 mV/mA */
 269                 return (raw_volt * CURR_STEP_SIZE) / CURR_PSR_R2;
 270 }
 271
 272 /*
 273  * Function to read channel values
 274  * @madc - pointer to twl4030_madc_data struct
 275  * @reg_base - Base address of the first channel
 276  * @Channels - 16 bit bitmap. If the bit is set, channel's value is read
 277  * @buf - The channel values are stored here. if read fails error
 278  * @raw - Return raw values without conversion
 279  * value is stored
 280  * Returns the number of successfully read channels.
 281  */
 282 static int twl4030_madc_read_channels(struct twl4030_madc_data *madc,
 283                                       u8 reg_base, unsigned
 284                                       long channels, int *buf,
 285                                       bool raw)
 286 {
 287         int count = 0;
 288         int i;
 289         u8 reg;
 290
 291         for_each_set_bit(i, &channels, TWL4030_MADC_MAX_CHANNELS) {
 292                 reg = reg_base + (2 * i);
 293                 buf[i] = twl4030_madc_channel_raw_read(madc, reg);
 294                 if (buf[i] < 0) {
 295                         dev_err(madc->dev, "Unable to read register 0x%X\n",
 296                                 reg);
 297                         return buf[i];
 298                 }
 299                 if (raw) {
 300                         count++;
 301                         continue;
 302                 }
 303                 switch (i) {
 304                 case 10:
 305                         buf[i] = twl4030battery_current(buf[i]);
 306                         if (buf[i] < 0) {
 307                                 dev_err(madc->dev, "err reading current\n");
 308                                 return buf[i];
 309                         } else {
 310                                 count++;
 311                                 buf[i] = buf[i] - 750;
 312                         }
 313                         break;
 314                 case 1:
 315                         buf[i] = twl4030battery_temperature(buf[i]);
 316                         if (buf[i] < 0) {
 317                                 dev_err(madc->dev, "err reading temperature\n");
 318                                 return buf[i];
 319                         } else {
 320                                 buf[i] -= 3;
 321                                 count++;
 322                         }
 323                         break;
 324                 default:
 325                         count++;
 326                         /* Analog Input (V) = conv_result * step_size / R
 327                          * conv_result = decimal value of 10-bit conversion
 328                          *               result
 329                          * step size = 1.5 / (2 ^ 10 -1)
 330                          * R = Prescaler ratio for input channels.
 331                          * Result given in mV hence multiplied by 1000.
 332                          */
 333                         buf[i] = (buf[i] * 3 * 1000 *
 334                                  twl4030_divider_ratios[i].denominator)
 335                                 / (2 * 1023 *
 336                                 twl4030_divider_ratios[i].numerator);
 337                 }
 338         }
 339
 340         return count;
 341 }
 342
 343 /*
 344  * Enables irq.
 345  * @madc - pointer to twl4030_madc_data struct
 346  * @id - irq number to be enabled
 347  * can take one of TWL4030_MADC_RT, TWL4030_MADC_SW1, TWL4030_MADC_SW2
 348  * corresponding to RT, SW1, SW2 conversion requests.
 349  * If the i2c read fails it returns an error else returns 0.
 350  */
 351 static int twl4030_madc_enable_irq(struct twl4030_madc_data *madc, u8 id)
 352 {
 353         u8 val;
 354         int ret;
 355
 356         ret = twl_i2c_read_u8(TWL4030_MODULE_MADC, &val, madc->imr);
 357         if (ret) {
 358                 dev_err(madc->dev, "unable to read imr register 0x%X\n",
 359                         madc->imr);
 360                 return ret;
 361         }
 362
 363         val &= ~(1 << id);
 364         ret = twl_i2c_write_u8(TWL4030_MODULE_MADC, val, madc->imr);
 365         if (ret) {
 366                 dev_err(madc->dev,
 367                         "unable to write imr register 0x%X\n", madc->imr);
 368                 return ret;
 369         }
 370
 371         return 0;
 372 }
 373
 374 /*
 375  * Disables irq.
 376  * @madc - pointer to twl4030_madc_data struct
 377  * @id - irq number to be disabled
 378  * can take one of TWL4030_MADC_RT, TWL4030_MADC_SW1, TWL4030_MADC_SW2
 379  * corresponding to RT, SW1, SW2 conversion requests.
 380  * Returns error if i2c read/write fails.
 381  */
 382 static int twl4030_madc_disable_irq(struct twl4030_madc_data *madc, u8 id)
 383 {
 384         u8 val;
 385         int ret;
 386
 387         ret = twl_i2c_read_u8(TWL4030_MODULE_MADC, &val, madc->imr);
 388         if (ret) {
 389                 dev_err(madc->dev, "unable to read imr register 0x%X\n",
 390                         madc->imr);
 391                 return ret;
 392         }
 393         val |= (1 << id);
 394         ret = twl_i2c_write_u8(TWL4030_MODULE_MADC, val, madc->imr);
 395         if (ret) {
 396                 dev_err(madc->dev,
 397                         "unable to write imr register 0x%X\n", madc->imr);
 398                 return ret;
 399         }
 400
 401         return 0;
 402 }
 403
 404 static irqreturn_t twl4030_madc_threaded_irq_handler(int irq, void *_madc)
 405 {
 406         struct twl4030_madc_data *madc = _madc;
 407         const struct twl4030_madc_conversion_method *method;
 408         u8 isr_val, imr_val;
 409         int i, len, ret;
 410         struct twl4030_madc_request *r;
 411
 412         mutex_lock(&madc->lock);
 413         ret = twl_i2c_read_u8(TWL4030_MODULE_MADC, &isr_val, madc->isr);
 414         if (ret) {
 415                 dev_err(madc->dev, "unable to read isr register 0x%X\n",
 416                         madc->isr);
 417                 goto err_i2c;
 418         }
 419         ret = twl_i2c_read_u8(TWL4030_MODULE_MADC, &imr_val, madc->imr);
 420         if (ret) {
 421                 dev_err(madc->dev, "unable to read imr register 0x%X\n",
 422                         madc->imr);
 423                 goto err_i2c;
 424         }
 425         isr_val &= ~imr_val;
 426         for (i = 0; i < TWL4030_MADC_NUM_METHODS; i++) {
 427                 if (!(isr_val & (1 << i)))
 428                         continue;
 429                 ret = twl4030_madc_disable_irq(madc, i);
 430                 if (ret < 0)
 431                         dev_dbg(madc->dev, "Disable interrupt failed %d\n", i);
 432                 madc->requests[i].result_pending = 1;
 433         }
 434         for (i = 0; i < TWL4030_MADC_NUM_METHODS; i++) {
 435                 r = &madc->requests[i];
 436                 /* No pending results for this method, move to next one */
 437                 if (!r->result_pending)
 438                         continue;
 439                 method = &twl4030_conversion_methods[r->method];
 440                 /* Read results */
 441                 len = twl4030_madc_read_channels(madc, method->rbase,
 442                                                  r->channels, r->rbuf, r->raw);
 443                 /* Return results to caller */
 444                 if (r->func_cb != NULL) {
 445                         r->func_cb(len, r->channels, r->rbuf);
 446                         r->func_cb = NULL;
 447                 }
 448                 /* Free request */
 449                 r->result_pending = 0;
 450                 r->active = 0;
 451         }
 452         mutex_unlock(&madc->lock);
 453
 454         return IRQ_HANDLED;
 455
 456 err_i2c:
 457         /*
 458          * In case of error check whichever request is active
 459          * and service the same.
 460          */
 461         for (i = 0; i < TWL4030_MADC_NUM_METHODS; i++) {
 462                 r = &madc->requests[i];
 463                 if (r->active == 0)
 464                         continue;
 465                 method = &twl4030_conversion_methods[r->method];
 466                 /* Read results */
 467                 len = twl4030_madc_read_channels(madc, method->rbase,
 468                                                  r->channels, r->rbuf, r->raw);
 469                 /* Return results to caller */
 470                 if (r->func_cb != NULL) {
 471                         r->func_cb(len, r->channels, r->rbuf);
 472                         r->func_cb = NULL;
 473                 }
 474                 /* Free request */
 475                 r->result_pending = 0;
 476                 r->active = 0;
 477         }
 478         mutex_unlock(&madc->lock);
 479
 480         return IRQ_HANDLED;
 481 }
 482
 483 static int twl4030_madc_set_irq(struct twl4030_madc_data *madc,
 484                                 struct twl4030_madc_request *req)
 485 {
 486         struct twl4030_madc_request *p;
 487         int ret;
 488
 489         p = &madc->requests[req->method];
 490         memcpy(p, req, sizeof(*req));
 491         ret = twl4030_madc_enable_irq(madc, req->method);
 492         if (ret < 0) {
 493                 dev_err(madc->dev, "enable irq failed!!\n");
 494                 return ret;
 495         }
 496
 497         return 0;
 498 }
 499
 500 /*
 501  * Function which enables the madc conversion
 502  * by writing to the control register.
 503  * @madc - pointer to twl4030_madc_data struct
 504  * @conv_method - can be TWL4030_MADC_RT, TWL4030_MADC_SW2, TWL4030_MADC_SW1
 505  * corresponding to RT SW1 or SW2 conversion methods.
 506  * Returns 0 if succeeds else a negative error value
 507  */
 508 static int twl4030_madc_start_conversion(struct twl4030_madc_data *madc,
 509                                          int conv_method)
 510 {
 511         const struct twl4030_madc_conversion_method *method;
 512         int ret = 0;
 513
 514         if (conv_method != TWL4030_MADC_SW1 && conv_method != TWL4030_MADC_SW2)
 515                 return -ENOTSUPP;
 516
 517         method = &twl4030_conversion_methods[conv_method];
 518         ret = twl_i2c_write_u8(TWL4030_MODULE_MADC, TWL4030_MADC_SW_START,
 519                                method->ctrl);
 520         if (ret) {
 521                 dev_err(madc->dev, "unable to write ctrl register 0x%X\n",
 522                         method->ctrl);
 523                 return ret;
 524         }
 525
 526         return 0;
 527 }
 528
 529 /*
 530  * Function that waits for conversion to be ready
 531  * @madc - pointer to twl4030_madc_data struct
 532  * @timeout_ms - timeout value in milliseconds
 533  * @status_reg - ctrl register
 534  * returns 0 if succeeds else a negative error value
 535  */
 536 static int twl4030_madc_wait_conversion_ready(struct twl4030_madc_data *madc,
 537                                               unsigned int timeout_ms,
 538                                               u8 status_reg)
 539 {
 540         unsigned long timeout;
 541         int ret;
 542
 543         timeout = jiffies + msecs_to_jiffies(timeout_ms);
 544         do {
 545                 u8 reg;
 546
 547                 ret = twl_i2c_read_u8(TWL4030_MODULE_MADC, &reg, status_reg);
 548                 if (ret) {
 549                         dev_err(madc->dev,
 550                                 "unable to read status register 0x%X\n",
 551                                 status_reg);
 552                         return ret;
 553                 }
 554                 if (!(reg & TWL4030_MADC_BUSY) && (reg & TWL4030_MADC_EOC_SW))
 555                         return 0;
 556                 usleep_range(500, 2000);
 557         } while (!time_after(jiffies, timeout));
 558         dev_err(madc->dev, "conversion timeout!\n");
 559
 560         return -EAGAIN;
 561 }
 562
 563 /*
 564  * An exported function which can be called from other kernel drivers.
 565  * @req twl4030_madc_request structure
 566  * req->rbuf will be filled with read values of channels based on the
 567  * channel index. If a particular channel reading fails there will
 568  * be a negative error value in the corresponding array element.
 569  * returns 0 if succeeds else error value
 570  */
 571 int twl4030_madc_conversion(struct twl4030_madc_request *req)
 572 {
 573         const struct twl4030_madc_conversion_method *method;
 574         int ret;
 575
 576         if (!req || !twl4030_madc)
 577                 return -EINVAL;
 578
 579         mutex_lock(&twl4030_madc->lock);
 580         if (req->method < TWL4030_MADC_RT || req->method > TWL4030_MADC_SW2) {
 581                 ret = -EINVAL;
 582                 goto out;
 583         }
 584         /* Do we have a conversion request ongoing */
 585         if (twl4030_madc->requests[req->method].active) {
 586                 ret = -EBUSY;
 587                 goto out;
 588         }
 589         method = &twl4030_conversion_methods[req->method];
 590         /* Select channels to be converted */
 591         ret = twl_i2c_write_u16(TWL4030_MODULE_MADC, req->channels, method->sel);
 592         if (ret) {
 593                 dev_err(twl4030_madc->dev,
 594                         "unable to write sel register 0x%X\n", method->sel);
 595                 goto out;
 596         }
 597         /* Select averaging for all channels if do_avg is set */
 598         if (req->do_avg) {
 599                 ret = twl_i2c_write_u16(TWL4030_MODULE_MADC, req->channels,
 600                                        method->avg);
 601                 if (ret) {
 602                         dev_err(twl4030_madc->dev,
 603                                 "unable to write avg register 0x%X\n",
 604                                 method->avg);
 605                         goto out;
 606                 }
 607         }
 608         if (req->type == TWL4030_MADC_IRQ_ONESHOT && req->func_cb != NULL) {
 609                 ret = twl4030_madc_set_irq(twl4030_madc, req);
 610                 if (ret < 0)
 611                         goto out;
 612                 ret = twl4030_madc_start_conversion(twl4030_madc, req->method);
 613                 if (ret < 0)
 614                         goto out;
 615                 twl4030_madc->requests[req->method].active = 1;
 616                 ret = 0;
 617                 goto out;
 618         }
 619         /* With RT method we should not be here anymore */
 620         if (req->method == TWL4030_MADC_RT) {
 621                 ret = -EINVAL;
 622                 goto out;
 623         }
 624         ret = twl4030_madc_start_conversion(twl4030_madc, req->method);
 625         if (ret < 0)
 626                 goto out;
 627         twl4030_madc->requests[req->method].active = 1;
 628         /* Wait until conversion is ready (ctrl register returns EOC) */
 629         ret = twl4030_madc_wait_conversion_ready(twl4030_madc, 5, method->ctrl);
 630         if (ret) {
 631                 twl4030_madc->requests[req->method].active = 0;
 632                 goto out;
 633         }
 634         ret = twl4030_madc_read_channels(twl4030_madc, method->rbase,
 635                                          req->channels, req->rbuf, req->raw);
 636         twl4030_madc->requests[req->method].active = 0;
 637
 638 out:
 639         mutex_unlock(&twl4030_madc->lock);
 640
 641         return ret;
 642 }
 643 EXPORT_SYMBOL_GPL(twl4030_madc_conversion);
 644
 645 int twl4030_get_madc_conversion(int channel_no)
 646 {
 647         struct twl4030_madc_request req;
 648         int temp = 0;
 649         int ret;
 650
 651         req.channels = (1 << channel_no);
 652         req.method = TWL4030_MADC_SW2;
 653         req.active = 0;
 654         req.raw = 0;
 655         req.func_cb = NULL;
 656         ret = twl4030_madc_conversion(&req);
 657         if (ret < 0)
 658                 return ret;
 659         if (req.rbuf[channel_no] > 0)
 660                 temp = req.rbuf[channel_no];
 661
 662         return temp;
 663 }
 664 EXPORT_SYMBOL_GPL(twl4030_get_madc_conversion);
 665
 666 /**
 667  * twl4030_madc_set_current_generator() - setup bias current
 668  *
 669  * @madc:       pointer to twl4030_madc_data struct
 670  * @chan:       can be one of the two values:
 671  *              0 - Enables bias current for main battery type reading
 672  *              1 - Enables bias current for main battery temperature sensing
 673  * @on:         enable or disable chan.
 674  *
 675  * Function to enable or disable bias current for
 676  * main battery type reading or temperature sensing
 677  */
 678 static int twl4030_madc_set_current_generator(struct twl4030_madc_data *madc,
 679                                               int chan, int on)
 680 {
 681         int ret;
 682         int regmask;
 683         u8 regval;
 684
 685         ret = twl_i2c_read_u8(TWL_MODULE_MAIN_CHARGE,
 686                               &regval, TWL4030_BCI_BCICTL1);
 687         if (ret) {
 688                 dev_err(madc->dev, "unable to read BCICTL1 reg 0x%X",
 689                         TWL4030_BCI_BCICTL1);
 690                 return ret;
 691         }
 692
 693         regmask = chan ? TWL4030_BCI_ITHEN : TWL4030_BCI_TYPEN;
 694         if (on)
 695                 regval |= regmask;
 696         else
 697                 regval &= ~regmask;
 698
 699         ret = twl_i2c_write_u8(TWL_MODULE_MAIN_CHARGE,
 700                                regval, TWL4030_BCI_BCICTL1);
 701         if (ret) {
 702                 dev_err(madc->dev, "unable to write BCICTL1 reg 0x%X\n",
 703                         TWL4030_BCI_BCICTL1);
 704                 return ret;
 705         }
 706
 707         return 0;
 708 }
 709
 710 /*
 711  * Function that sets MADC software power on bit to enable MADC
 712  * @madc - pointer to twl4030_madc_data struct
 713  * @on - Enable or disable MADC software power on bit.
 714  * returns error if i2c read/write fails else 0
 715  */
 716 static int twl4030_madc_set_power(struct twl4030_madc_data *madc, int on)
 717 {
 718         u8 regval;
 719         int ret;
 720
 721         ret = twl_i2c_read_u8(TWL_MODULE_MAIN_CHARGE,
 722                               &regval, TWL4030_MADC_CTRL1);
 723         if (ret) {
 724                 dev_err(madc->dev, "unable to read madc ctrl1 reg 0x%X\n",
 725                         TWL4030_MADC_CTRL1);
 726                 return ret;
 727         }
 728         if (on)
 729                 regval |= TWL4030_MADC_MADCON;
 730         else
 731                 regval &= ~TWL4030_MADC_MADCON;
 732         ret = twl_i2c_write_u8(TWL4030_MODULE_MADC, regval, TWL4030_MADC_CTRL1);
 733         if (ret) {
 734                 dev_err(madc->dev, "unable to write madc ctrl1 reg 0x%X\n",
 735                         TWL4030_MADC_CTRL1);
 736                 return ret;
 737         }
 738
 739         return 0;
 740 }
 741
 742 /*
 743  * Initialize MADC and request for threaded irq
 744  */
 745 static int twl4030_madc_probe(struct platform_device *pdev)
 746 {
 747         struct twl4030_madc_data *madc;
 748         struct twl4030_madc_platform_data *pdata = dev_get_platdata(&pdev->dev);
 749         struct device_node *np = pdev->dev.of_node;
 750         int irq, ret;
 751         u8 regval;
 752         struct iio_dev *iio_dev = NULL;
 753
 754         if (!pdata && !np) {
 755                 dev_err(&pdev->dev, "neither platform data nor Device Tree node available\n");
 756                 return -EINVAL;
 757         }
 758
 759         iio_dev = devm_iio_device_alloc(&pdev->dev, sizeof(*madc));
 760         if (!iio_dev) {
 761                 dev_err(&pdev->dev, "failed allocating iio device\n");
 762                 return -ENOMEM;
 763         }
 764
 765         madc = iio_priv(iio_dev);
 766         madc->dev = &pdev->dev;
 767
 768         iio_dev->name = dev_name(&pdev->dev);
 769         iio_dev->dev.parent = &pdev->dev;
 770         iio_dev->dev.of_node = pdev->dev.of_node;
 771         iio_dev->info = &twl4030_madc_iio_info;
 772         iio_dev->modes = INDIO_DIRECT_MODE;
 773         iio_dev->channels = twl4030_madc_iio_channels;
 774         iio_dev->num_channels = ARRAY_SIZE(twl4030_madc_iio_channels);
 775
 776         /*
 777          * Phoenix provides 2 interrupt lines. The first one is connected to
 778          * the OMAP. The other one can be connected to the other processor such
 779          * as modem. Hence two separate ISR and IMR registers.
 780          */
 781         if (pdata)
 782                 madc->use_second_irq = (pdata->irq_line != 1);
 783         else
 784                 madc->use_second_irq = of_property_read_bool(np,
 785                                        "ti,system-uses-second-madc-irq");
 786
 787         madc->imr = madc->use_second_irq ? TWL4030_MADC_IMR2 :
 788                                            TWL4030_MADC_IMR1;
 789         madc->isr = madc->use_second_irq ? TWL4030_MADC_ISR2 :
 790                                            TWL4030_MADC_ISR1;
 791
 792         ret = twl4030_madc_set_power(madc, 1);
 793         if (ret < 0)
 794                 return ret;
 795         ret = twl4030_madc_set_current_generator(madc, 0, 1);
 796         if (ret < 0)
 797                 goto err_current_generator;
 798
 799         ret = twl_i2c_read_u8(TWL_MODULE_MAIN_CHARGE,
 800                               &regval, TWL4030_BCI_BCICTL1);
 801         if (ret) {
 802                 dev_err(&pdev->dev, "unable to read reg BCI CTL1 0x%X\n",
 803                         TWL4030_BCI_BCICTL1);
 804                 goto err_i2c;
 805         }
 806         regval |= TWL4030_BCI_MESBAT;
 807         ret = twl_i2c_write_u8(TWL_MODULE_MAIN_CHARGE,
 808                                regval, TWL4030_BCI_BCICTL1);
 809         if (ret) {
 810                 dev_err(&pdev->dev, "unable to write reg BCI Ctl1 0x%X\n",
 811                         TWL4030_BCI_BCICTL1);
 812                 goto err_i2c;
 813         }
 814
 815         /* Check that MADC clock is on */
 816         ret = twl_i2c_read_u8(TWL4030_MODULE_INTBR, &regval, TWL4030_REG_GPBR1);
 817         if (ret) {
 818                 dev_err(&pdev->dev, "unable to read reg GPBR1 0x%X\n",
 819                                 TWL4030_REG_GPBR1);
 820                 goto err_i2c;
 821         }
 822
 823         /* If MADC clk is not on, turn it on */
 824         if (!(regval & TWL4030_GPBR1_MADC_HFCLK_EN)) {
 825                 dev_info(&pdev->dev, "clk disabled, enabling\n");
 826                 regval |= TWL4030_GPBR1_MADC_HFCLK_EN;
 827                 ret = twl_i2c_write_u8(TWL4030_MODULE_INTBR, regval,
 828                                        TWL4030_REG_GPBR1);
 829                 if (ret) {
 830                         dev_err(&pdev->dev, "unable to write reg GPBR1 0x%X\n",
 831                                         TWL4030_REG_GPBR1);
 832                         goto err_i2c;
 833                 }
 834         }
 835
 836         platform_set_drvdata(pdev, iio_dev);
 837         mutex_init(&madc->lock);
 838
 839         irq = platform_get_irq(pdev, 0);
 840         ret = devm_request_threaded_irq(&pdev->dev, irq, NULL,
 841                                    twl4030_madc_threaded_irq_handler,
 842                                    IRQF_TRIGGER_RISING | IRQF_ONESHOT,
 843                                    "twl4030_madc", madc);
 844         if (ret) {
 845                 dev_err(&pdev->dev, "could not request irq\n");
 846                 goto err_i2c;
 847         }
 848         twl4030_madc = madc;
 849
 850         /* Configure MADC[3:6] */
 851         ret = twl_i2c_read_u8(TWL_MODULE_USB, &regval,
 852                         TWL4030_USB_CARKIT_ANA_CTRL);
 853         if (ret) {
 854                 dev_err(&pdev->dev, "unable to read reg CARKIT_ANA_CTRL  0x%X\n",
 855                                 TWL4030_USB_CARKIT_ANA_CTRL);
 856                 goto err_i2c;
 857         }
 858         regval |= TWL4030_USB_SEL_MADC_MCPC;
 859         ret = twl_i2c_write_u8(TWL_MODULE_USB, regval,
 860                                  TWL4030_USB_CARKIT_ANA_CTRL);
 861         if (ret) {
 862                 dev_err(&pdev->dev, "unable to write reg CARKIT_ANA_CTRL 0x%X\n",
 863                                 TWL4030_USB_CARKIT_ANA_CTRL);
 864                 goto err_i2c;
 865         }
 866
 867         /* Enable 3v1 bias regulator for MADC[3:6] */
 868         madc->usb3v1 = devm_regulator_get(madc->dev, "vusb3v1");
 869         if (IS_ERR(madc->usb3v1)) {
 870                 ret = -ENODEV;
 871                 goto err_i2c;
 872         }
 873
 874         ret = regulator_enable(madc->usb3v1);
 875         if (ret)
 876                 dev_err(madc->dev, "could not enable 3v1 bias regulator\n");
 877
 878         ret = iio_device_register(iio_dev);
 879         if (ret) {
 880                 dev_err(&pdev->dev, "could not register iio device\n");
 881                 goto err_usb3v1;
 882         }
 883
 884         return 0;
 885
 886 err_usb3v1:
 887         regulator_disable(madc->usb3v1);
 888 err_i2c:
 889         twl4030_madc_set_current_generator(madc, 0, 0);
 890 err_current_generator:
 891         twl4030_madc_set_power(madc, 0);
 892         return ret;
 893 }
 894
 895 static int twl4030_madc_remove(struct platform_device *pdev)
 896 {
 897         struct iio_dev *iio_dev = platform_get_drvdata(pdev);
 898         struct twl4030_madc_data *madc = iio_priv(iio_dev);
 899
 900         iio_device_unregister(iio_dev);
 901
 902         twl4030_madc_set_current_generator(madc, 0, 0);
 903         twl4030_madc_set_power(madc, 0);
 904
 905         regulator_disable(madc->usb3v1);
 906
 907         return 0;
 908 }
 909
 910 #ifdef CONFIG_OF
 911 static const struct of_device_id twl_madc_of_match[] = {
 912         { .compatible = "ti,twl4030-madc", },
 913         { },
 914 };
 915 MODULE_DEVICE_TABLE(of, twl_madc_of_match);
 916 #endif
 917
 918 static struct platform_driver twl4030_madc_driver = {
 919         .probe = twl4030_madc_probe,
 920         .remove = twl4030_madc_remove,
 921         .driver = {
 922                    .name = "twl4030_madc",
 923                    .of_match_table = of_match_ptr(twl_madc_of_match),
 924         },
 925 };
 926
 927 module_platform_driver(twl4030_madc_driver);
 928
 929 MODULE_DESCRIPTION("TWL4030 ADC driver");
 930 MODULE_LICENSE("GPL");
 931 MODULE_AUTHOR("J Keerthy");
 932 MODULE_ALIAS("platform:twl4030_madc");