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