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