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.
7 * Copyright (C) 2011 Texas Instruments Incorporated - http://www.ti.com/
8 * J Keerthy <j-keerthy@ti.com>
10 * Based on twl4030-madc.c
11 * Copyright (C) 2008 Nokia Corporation
12 * Mikko Ylinen <mikko.k.ylinen@nokia.com>
14 * Amit Kucheria <amit.kucheria@canonical.com>
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.
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.
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
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/module.h>
40 #include <linux/stddef.h>
41 #include <linux/mutex.h>
42 #include <linux/bitops.h>
43 #include <linux/jiffies.h>
44 #include <linux/types.h>
45 #include <linux/gfp.h>
46 #include <linux/err.h>
47 #include <linux/regulator/consumer.h>
49 #include <linux/iio/iio.h>
51 #define TWL4030_MADC_MAX_CHANNELS 16
53 #define TWL4030_MADC_CTRL1 0x00
54 #define TWL4030_MADC_CTRL2 0x01
56 #define TWL4030_MADC_RTSELECT_LSB 0x02
57 #define TWL4030_MADC_SW1SELECT_LSB 0x06
58 #define TWL4030_MADC_SW2SELECT_LSB 0x0A
60 #define TWL4030_MADC_RTAVERAGE_LSB 0x04
61 #define TWL4030_MADC_SW1AVERAGE_LSB 0x08
62 #define TWL4030_MADC_SW2AVERAGE_LSB 0x0C
64 #define TWL4030_MADC_CTRL_SW1 0x12
65 #define TWL4030_MADC_CTRL_SW2 0x13
67 #define TWL4030_MADC_RTCH0_LSB 0x17
68 #define TWL4030_MADC_GPCH0_LSB 0x37
70 #define TWL4030_MADC_MADCON (1 << 0) /* MADC power on */
71 #define TWL4030_MADC_BUSY (1 << 0) /* MADC busy */
72 /* MADC conversion completion */
73 #define TWL4030_MADC_EOC_SW (1 << 1)
74 /* MADC SWx start conversion */
75 #define TWL4030_MADC_SW_START (1 << 5)
76 #define TWL4030_MADC_ADCIN0 (1 << 0)
77 #define TWL4030_MADC_ADCIN1 (1 << 1)
78 #define TWL4030_MADC_ADCIN2 (1 << 2)
79 #define TWL4030_MADC_ADCIN3 (1 << 3)
80 #define TWL4030_MADC_ADCIN4 (1 << 4)
81 #define TWL4030_MADC_ADCIN5 (1 << 5)
82 #define TWL4030_MADC_ADCIN6 (1 << 6)
83 #define TWL4030_MADC_ADCIN7 (1 << 7)
84 #define TWL4030_MADC_ADCIN8 (1 << 8)
85 #define TWL4030_MADC_ADCIN9 (1 << 9)
86 #define TWL4030_MADC_ADCIN10 (1 << 10)
87 #define TWL4030_MADC_ADCIN11 (1 << 11)
88 #define TWL4030_MADC_ADCIN12 (1 << 12)
89 #define TWL4030_MADC_ADCIN13 (1 << 13)
90 #define TWL4030_MADC_ADCIN14 (1 << 14)
91 #define TWL4030_MADC_ADCIN15 (1 << 15)
94 #define TWL4030_MADC_BTEMP TWL4030_MADC_ADCIN1
95 #define TWL4030_MADC_VBUS TWL4030_MADC_ADCIN8
96 #define TWL4030_MADC_VBKB TWL4030_MADC_ADCIN9
97 #define TWL4030_MADC_ICHG TWL4030_MADC_ADCIN10
98 #define TWL4030_MADC_VCHG TWL4030_MADC_ADCIN11
99 #define TWL4030_MADC_VBAT TWL4030_MADC_ADCIN12
101 /* Step size and prescaler ratio */
102 #define TEMP_STEP_SIZE 147
103 #define TEMP_PSR_R 100
104 #define CURR_STEP_SIZE 147
105 #define CURR_PSR_R1 44
106 #define CURR_PSR_R2 88
108 #define TWL4030_BCI_BCICTL1 0x23
109 #define TWL4030_BCI_CGAIN 0x020
110 #define TWL4030_BCI_MESBAT (1 << 1)
111 #define TWL4030_BCI_TYPEN (1 << 4)
112 #define TWL4030_BCI_ITHEN (1 << 3)
114 #define REG_BCICTL2 0x024
115 #define TWL4030_BCI_ITHSENS 0x007
117 /* Register and bits for GPBR1 register */
118 #define TWL4030_REG_GPBR1 0x0c
119 #define TWL4030_GPBR1_MADC_HFCLK_EN (1 << 7)
121 #define TWL4030_USB_SEL_MADC_MCPC (1<<3)
122 #define TWL4030_USB_CARKIT_ANA_CTRL 0xBB
124 struct twl4030_madc_conversion_method {
132 * struct twl4030_madc_request - madc request packet for channel conversion
133 * @channels: 16 bit bitmap for individual channels
134 * @do_avg: sample the input channel for 4 consecutive cycles
135 * @method: RT, SW1, SW2
136 * @type: Polling or interrupt based method
137 * @active: Flag if request is active
138 * @result_pending: Flag from irq handler, that result is ready
139 * @raw: Return raw value, do not convert it
140 * @rbuf: Result buffer
142 struct twl4030_madc_request {
143 unsigned long channels;
150 int rbuf[TWL4030_MADC_MAX_CHANNELS];
153 enum conversion_methods {
157 TWL4030_MADC_NUM_METHODS
162 TWL4030_MADC_IRQ_ONESHOT,
163 TWL4030_MADC_IRQ_REARM
167 * struct twl4030_madc_data - a container for madc info
168 * @dev: Pointer to device structure for madc
169 * @lock: Mutex protecting this data structure
170 * @regulator: Pointer to bias regulator for madc
171 * @requests: Array of request struct corresponding to SW1, SW2 and RT
172 * @use_second_irq: IRQ selection (main or co-processor)
173 * @imr: Interrupt mask register of MADC
174 * @isr: Interrupt status register of MADC
176 struct twl4030_madc_data {
178 struct mutex lock; /* mutex protecting this data structure */
179 struct regulator *usb3v1;
180 struct twl4030_madc_request requests[TWL4030_MADC_NUM_METHODS];
186 static int twl4030_madc_conversion(struct twl4030_madc_request *req);
188 static int twl4030_madc_read(struct iio_dev *iio_dev,
189 const struct iio_chan_spec *chan,
190 int *val, int *val2, long mask)
192 struct twl4030_madc_data *madc = iio_priv(iio_dev);
193 struct twl4030_madc_request req;
196 req.method = madc->use_second_irq ? TWL4030_MADC_SW2 : TWL4030_MADC_SW1;
198 req.channels = BIT(chan->channel);
200 req.type = TWL4030_MADC_WAIT;
201 req.raw = !(mask == IIO_CHAN_INFO_PROCESSED);
202 req.do_avg = (mask == IIO_CHAN_INFO_AVERAGE_RAW);
204 ret = twl4030_madc_conversion(&req);
208 *val = req.rbuf[chan->channel];
213 static const struct iio_info twl4030_madc_iio_info = {
214 .read_raw = &twl4030_madc_read,
215 .driver_module = THIS_MODULE,
218 #define TWL4030_ADC_CHANNEL(_channel, _type, _name) { \
220 .channel = _channel, \
221 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
222 BIT(IIO_CHAN_INFO_AVERAGE_RAW) | \
223 BIT(IIO_CHAN_INFO_PROCESSED), \
224 .datasheet_name = _name, \
228 static const struct iio_chan_spec twl4030_madc_iio_channels[] = {
229 TWL4030_ADC_CHANNEL(0, IIO_VOLTAGE, "ADCIN0"),
230 TWL4030_ADC_CHANNEL(1, IIO_TEMP, "ADCIN1"),
231 TWL4030_ADC_CHANNEL(2, IIO_VOLTAGE, "ADCIN2"),
232 TWL4030_ADC_CHANNEL(3, IIO_VOLTAGE, "ADCIN3"),
233 TWL4030_ADC_CHANNEL(4, IIO_VOLTAGE, "ADCIN4"),
234 TWL4030_ADC_CHANNEL(5, IIO_VOLTAGE, "ADCIN5"),
235 TWL4030_ADC_CHANNEL(6, IIO_VOLTAGE, "ADCIN6"),
236 TWL4030_ADC_CHANNEL(7, IIO_VOLTAGE, "ADCIN7"),
237 TWL4030_ADC_CHANNEL(8, IIO_VOLTAGE, "ADCIN8"),
238 TWL4030_ADC_CHANNEL(9, IIO_VOLTAGE, "ADCIN9"),
239 TWL4030_ADC_CHANNEL(10, IIO_CURRENT, "ADCIN10"),
240 TWL4030_ADC_CHANNEL(11, IIO_VOLTAGE, "ADCIN11"),
241 TWL4030_ADC_CHANNEL(12, IIO_VOLTAGE, "ADCIN12"),
242 TWL4030_ADC_CHANNEL(13, IIO_VOLTAGE, "ADCIN13"),
243 TWL4030_ADC_CHANNEL(14, IIO_VOLTAGE, "ADCIN14"),
244 TWL4030_ADC_CHANNEL(15, IIO_VOLTAGE, "ADCIN15"),
247 static struct twl4030_madc_data *twl4030_madc;
249 struct twl4030_prescale_divider_ratios {
254 static const struct twl4030_prescale_divider_ratios
255 twl4030_divider_ratios[16] = {
256 {1, 1}, /* CHANNEL 0 No Prescaler */
257 {1, 1}, /* CHANNEL 1 No Prescaler */
258 {6, 10}, /* CHANNEL 2 */
259 {6, 10}, /* CHANNEL 3 */
260 {6, 10}, /* CHANNEL 4 */
261 {6, 10}, /* CHANNEL 5 */
262 {6, 10}, /* CHANNEL 6 */
263 {6, 10}, /* CHANNEL 7 */
264 {3, 14}, /* CHANNEL 8 */
265 {1, 3}, /* CHANNEL 9 */
266 {1, 1}, /* CHANNEL 10 No Prescaler */
267 {15, 100}, /* CHANNEL 11 */
268 {1, 4}, /* CHANNEL 12 */
269 {1, 1}, /* CHANNEL 13 Reserved channels */
270 {1, 1}, /* CHANNEL 14 Reseved channels */
271 {5, 11}, /* CHANNEL 15 */
275 /* Conversion table from -3 to 55 degrees Celcius */
276 static int twl4030_therm_tbl[] = {
277 30800, 29500, 28300, 27100,
278 26000, 24900, 23900, 22900, 22000, 21100, 20300, 19400, 18700,
279 17900, 17200, 16500, 15900, 15300, 14700, 14100, 13600, 13100,
280 12600, 12100, 11600, 11200, 10800, 10400, 10000, 9630, 9280,
281 8950, 8620, 8310, 8020, 7730, 7460, 7200, 6950, 6710,
282 6470, 6250, 6040, 5830, 5640, 5450, 5260, 5090, 4920,
283 4760, 4600, 4450, 4310, 4170, 4040, 3910, 3790, 3670,
288 * Structure containing the registers
289 * of different conversion methods supported by MADC.
290 * Hardware or RT real time conversion request initiated by external host
291 * processor for RT Signal conversions.
292 * External host processors can also request for non RT conversions
293 * SW1 and SW2 software conversions also called asynchronous or GPC request.
296 const struct twl4030_madc_conversion_method twl4030_conversion_methods[] = {
297 [TWL4030_MADC_RT] = {
298 .sel = TWL4030_MADC_RTSELECT_LSB,
299 .avg = TWL4030_MADC_RTAVERAGE_LSB,
300 .rbase = TWL4030_MADC_RTCH0_LSB,
302 [TWL4030_MADC_SW1] = {
303 .sel = TWL4030_MADC_SW1SELECT_LSB,
304 .avg = TWL4030_MADC_SW1AVERAGE_LSB,
305 .rbase = TWL4030_MADC_GPCH0_LSB,
306 .ctrl = TWL4030_MADC_CTRL_SW1,
308 [TWL4030_MADC_SW2] = {
309 .sel = TWL4030_MADC_SW2SELECT_LSB,
310 .avg = TWL4030_MADC_SW2AVERAGE_LSB,
311 .rbase = TWL4030_MADC_GPCH0_LSB,
312 .ctrl = TWL4030_MADC_CTRL_SW2,
317 * twl4030_madc_channel_raw_read() - Function to read a particular channel value
318 * @madc: pointer to struct twl4030_madc_data
319 * @reg: lsb of ADC Channel
321 * Return: 0 on success, an error code otherwise.
323 static int twl4030_madc_channel_raw_read(struct twl4030_madc_data *madc, u8 reg)
328 * For each ADC channel, we have MSB and LSB register pair. MSB address
329 * is always LSB address+1. reg parameter is the address of LSB register
331 ret = twl_i2c_read_u16(TWL4030_MODULE_MADC, &val, reg);
333 dev_err(madc->dev, "unable to read register 0x%X\n", reg);
337 return (int)(val >> 6);
341 * Return battery temperature in degrees Celsius
344 static int twl4030battery_temperature(int raw_volt)
347 int temp, curr, volt, res, ret;
349 volt = (raw_volt * TEMP_STEP_SIZE) / TEMP_PSR_R;
350 /* Getting and calculating the supply current in micro amperes */
351 ret = twl_i2c_read_u8(TWL_MODULE_MAIN_CHARGE, &val,
356 curr = ((val & TWL4030_BCI_ITHSENS) + 1) * 10;
357 /* Getting and calculating the thermistor resistance in ohms */
358 res = volt * 1000 / curr;
359 /* calculating temperature */
360 for (temp = 58; temp >= 0; temp--) {
361 int actual = twl4030_therm_tbl[temp];
362 if ((actual - res) >= 0)
369 static int twl4030battery_current(int raw_volt)
374 ret = twl_i2c_read_u8(TWL_MODULE_MAIN_CHARGE, &val,
375 TWL4030_BCI_BCICTL1);
378 if (val & TWL4030_BCI_CGAIN) /* slope of 0.44 mV/mA */
379 return (raw_volt * CURR_STEP_SIZE) / CURR_PSR_R1;
380 else /* slope of 0.88 mV/mA */
381 return (raw_volt * CURR_STEP_SIZE) / CURR_PSR_R2;
385 * Function to read channel values
386 * @madc - pointer to twl4030_madc_data struct
387 * @reg_base - Base address of the first channel
388 * @Channels - 16 bit bitmap. If the bit is set, channel's value is read
389 * @buf - The channel values are stored here. if read fails error
390 * @raw - Return raw values without conversion
392 * Returns the number of successfully read channels.
394 static int twl4030_madc_read_channels(struct twl4030_madc_data *madc,
395 u8 reg_base, unsigned
396 long channels, int *buf,
403 for_each_set_bit(i, &channels, TWL4030_MADC_MAX_CHANNELS) {
404 reg = reg_base + (2 * i);
405 buf[i] = twl4030_madc_channel_raw_read(madc, reg);
407 dev_err(madc->dev, "Unable to read register 0x%X\n",
417 buf[i] = twl4030battery_current(buf[i]);
419 dev_err(madc->dev, "err reading current\n");
423 buf[i] = buf[i] - 750;
427 buf[i] = twl4030battery_temperature(buf[i]);
429 dev_err(madc->dev, "err reading temperature\n");
438 /* Analog Input (V) = conv_result * step_size / R
439 * conv_result = decimal value of 10-bit conversion
441 * step size = 1.5 / (2 ^ 10 -1)
442 * R = Prescaler ratio for input channels.
443 * Result given in mV hence multiplied by 1000.
445 buf[i] = (buf[i] * 3 * 1000 *
446 twl4030_divider_ratios[i].denominator)
448 twl4030_divider_ratios[i].numerator);
457 * @madc - pointer to twl4030_madc_data struct
458 * @id - irq number to be disabled
459 * can take one of TWL4030_MADC_RT, TWL4030_MADC_SW1, TWL4030_MADC_SW2
460 * corresponding to RT, SW1, SW2 conversion requests.
461 * Returns error if i2c read/write fails.
463 static int twl4030_madc_disable_irq(struct twl4030_madc_data *madc, u8 id)
468 ret = twl_i2c_read_u8(TWL4030_MODULE_MADC, &val, madc->imr);
470 dev_err(madc->dev, "unable to read imr register 0x%X\n",
475 ret = twl_i2c_write_u8(TWL4030_MODULE_MADC, val, madc->imr);
478 "unable to write imr register 0x%X\n", madc->imr);
485 static irqreturn_t twl4030_madc_threaded_irq_handler(int irq, void *_madc)
487 struct twl4030_madc_data *madc = _madc;
488 const struct twl4030_madc_conversion_method *method;
491 struct twl4030_madc_request *r;
493 mutex_lock(&madc->lock);
494 ret = twl_i2c_read_u8(TWL4030_MODULE_MADC, &isr_val, madc->isr);
496 dev_err(madc->dev, "unable to read isr register 0x%X\n",
500 ret = twl_i2c_read_u8(TWL4030_MODULE_MADC, &imr_val, madc->imr);
502 dev_err(madc->dev, "unable to read imr register 0x%X\n",
507 for (i = 0; i < TWL4030_MADC_NUM_METHODS; i++) {
508 if (!(isr_val & (1 << i)))
510 ret = twl4030_madc_disable_irq(madc, i);
512 dev_dbg(madc->dev, "Disable interrupt failed %d\n", i);
513 madc->requests[i].result_pending = 1;
515 for (i = 0; i < TWL4030_MADC_NUM_METHODS; i++) {
516 r = &madc->requests[i];
517 /* No pending results for this method, move to next one */
518 if (!r->result_pending)
520 method = &twl4030_conversion_methods[r->method];
522 len = twl4030_madc_read_channels(madc, method->rbase,
523 r->channels, r->rbuf, r->raw);
525 r->result_pending = 0;
528 mutex_unlock(&madc->lock);
534 * In case of error check whichever request is active
535 * and service the same.
537 for (i = 0; i < TWL4030_MADC_NUM_METHODS; i++) {
538 r = &madc->requests[i];
541 method = &twl4030_conversion_methods[r->method];
543 len = twl4030_madc_read_channels(madc, method->rbase,
544 r->channels, r->rbuf, r->raw);
546 r->result_pending = 0;
549 mutex_unlock(&madc->lock);
555 * Function which enables the madc conversion
556 * by writing to the control register.
557 * @madc - pointer to twl4030_madc_data struct
558 * @conv_method - can be TWL4030_MADC_RT, TWL4030_MADC_SW2, TWL4030_MADC_SW1
559 * corresponding to RT SW1 or SW2 conversion methods.
560 * Returns 0 if succeeds else a negative error value
562 static int twl4030_madc_start_conversion(struct twl4030_madc_data *madc,
565 const struct twl4030_madc_conversion_method *method;
568 if (conv_method != TWL4030_MADC_SW1 && conv_method != TWL4030_MADC_SW2)
571 method = &twl4030_conversion_methods[conv_method];
572 ret = twl_i2c_write_u8(TWL4030_MODULE_MADC, TWL4030_MADC_SW_START,
575 dev_err(madc->dev, "unable to write ctrl register 0x%X\n",
584 * Function that waits for conversion to be ready
585 * @madc - pointer to twl4030_madc_data struct
586 * @timeout_ms - timeout value in milliseconds
587 * @status_reg - ctrl register
588 * returns 0 if succeeds else a negative error value
590 static int twl4030_madc_wait_conversion_ready(struct twl4030_madc_data *madc,
591 unsigned int timeout_ms,
594 unsigned long timeout;
597 timeout = jiffies + msecs_to_jiffies(timeout_ms);
601 ret = twl_i2c_read_u8(TWL4030_MODULE_MADC, ®, status_reg);
604 "unable to read status register 0x%X\n",
608 if (!(reg & TWL4030_MADC_BUSY) && (reg & TWL4030_MADC_EOC_SW))
610 usleep_range(500, 2000);
611 } while (!time_after(jiffies, timeout));
612 dev_err(madc->dev, "conversion timeout!\n");
618 * An exported function which can be called from other kernel drivers.
619 * @req twl4030_madc_request structure
620 * req->rbuf will be filled with read values of channels based on the
621 * channel index. If a particular channel reading fails there will
622 * be a negative error value in the corresponding array element.
623 * returns 0 if succeeds else error value
625 static int twl4030_madc_conversion(struct twl4030_madc_request *req)
627 const struct twl4030_madc_conversion_method *method;
630 if (!req || !twl4030_madc)
633 mutex_lock(&twl4030_madc->lock);
634 if (req->method < TWL4030_MADC_RT || req->method > TWL4030_MADC_SW2) {
638 /* Do we have a conversion request ongoing */
639 if (twl4030_madc->requests[req->method].active) {
643 method = &twl4030_conversion_methods[req->method];
644 /* Select channels to be converted */
645 ret = twl_i2c_write_u16(TWL4030_MODULE_MADC, req->channels, method->sel);
647 dev_err(twl4030_madc->dev,
648 "unable to write sel register 0x%X\n", method->sel);
651 /* Select averaging for all channels if do_avg is set */
653 ret = twl_i2c_write_u16(TWL4030_MODULE_MADC, req->channels,
656 dev_err(twl4030_madc->dev,
657 "unable to write avg register 0x%X\n",
662 /* With RT method we should not be here anymore */
663 if (req->method == TWL4030_MADC_RT) {
667 ret = twl4030_madc_start_conversion(twl4030_madc, req->method);
670 twl4030_madc->requests[req->method].active = 1;
671 /* Wait until conversion is ready (ctrl register returns EOC) */
672 ret = twl4030_madc_wait_conversion_ready(twl4030_madc, 5, method->ctrl);
674 twl4030_madc->requests[req->method].active = 0;
677 ret = twl4030_madc_read_channels(twl4030_madc, method->rbase,
678 req->channels, req->rbuf, req->raw);
679 twl4030_madc->requests[req->method].active = 0;
682 mutex_unlock(&twl4030_madc->lock);
688 * twl4030_madc_set_current_generator() - setup bias current
690 * @madc: pointer to twl4030_madc_data struct
691 * @chan: can be one of the two values:
692 * 0 - Enables bias current for main battery type reading
693 * 1 - Enables bias current for main battery temperature sensing
694 * @on: enable or disable chan.
696 * Function to enable or disable bias current for
697 * main battery type reading or temperature sensing
699 static int twl4030_madc_set_current_generator(struct twl4030_madc_data *madc,
706 ret = twl_i2c_read_u8(TWL_MODULE_MAIN_CHARGE,
707 ®val, TWL4030_BCI_BCICTL1);
709 dev_err(madc->dev, "unable to read BCICTL1 reg 0x%X",
710 TWL4030_BCI_BCICTL1);
714 regmask = chan ? TWL4030_BCI_ITHEN : TWL4030_BCI_TYPEN;
720 ret = twl_i2c_write_u8(TWL_MODULE_MAIN_CHARGE,
721 regval, TWL4030_BCI_BCICTL1);
723 dev_err(madc->dev, "unable to write BCICTL1 reg 0x%X\n",
724 TWL4030_BCI_BCICTL1);
732 * Function that sets MADC software power on bit to enable MADC
733 * @madc - pointer to twl4030_madc_data struct
734 * @on - Enable or disable MADC software power on bit.
735 * returns error if i2c read/write fails else 0
737 static int twl4030_madc_set_power(struct twl4030_madc_data *madc, int on)
742 ret = twl_i2c_read_u8(TWL_MODULE_MAIN_CHARGE,
743 ®val, TWL4030_MADC_CTRL1);
745 dev_err(madc->dev, "unable to read madc ctrl1 reg 0x%X\n",
750 regval |= TWL4030_MADC_MADCON;
752 regval &= ~TWL4030_MADC_MADCON;
753 ret = twl_i2c_write_u8(TWL4030_MODULE_MADC, regval, TWL4030_MADC_CTRL1);
755 dev_err(madc->dev, "unable to write madc ctrl1 reg 0x%X\n",
764 * Initialize MADC and request for threaded irq
766 static int twl4030_madc_probe(struct platform_device *pdev)
768 struct twl4030_madc_data *madc;
769 struct twl4030_madc_platform_data *pdata = dev_get_platdata(&pdev->dev);
770 struct device_node *np = pdev->dev.of_node;
773 struct iio_dev *iio_dev = NULL;
776 dev_err(&pdev->dev, "neither platform data nor Device Tree node available\n");
780 iio_dev = devm_iio_device_alloc(&pdev->dev, sizeof(*madc));
782 dev_err(&pdev->dev, "failed allocating iio device\n");
786 madc = iio_priv(iio_dev);
787 madc->dev = &pdev->dev;
789 iio_dev->name = dev_name(&pdev->dev);
790 iio_dev->dev.parent = &pdev->dev;
791 iio_dev->dev.of_node = pdev->dev.of_node;
792 iio_dev->info = &twl4030_madc_iio_info;
793 iio_dev->modes = INDIO_DIRECT_MODE;
794 iio_dev->channels = twl4030_madc_iio_channels;
795 iio_dev->num_channels = ARRAY_SIZE(twl4030_madc_iio_channels);
798 * Phoenix provides 2 interrupt lines. The first one is connected to
799 * the OMAP. The other one can be connected to the other processor such
800 * as modem. Hence two separate ISR and IMR registers.
803 madc->use_second_irq = (pdata->irq_line != 1);
805 madc->use_second_irq = of_property_read_bool(np,
806 "ti,system-uses-second-madc-irq");
808 madc->imr = madc->use_second_irq ? TWL4030_MADC_IMR2 :
810 madc->isr = madc->use_second_irq ? TWL4030_MADC_ISR2 :
813 ret = twl4030_madc_set_power(madc, 1);
816 ret = twl4030_madc_set_current_generator(madc, 0, 1);
818 goto err_current_generator;
820 ret = twl_i2c_read_u8(TWL_MODULE_MAIN_CHARGE,
821 ®val, TWL4030_BCI_BCICTL1);
823 dev_err(&pdev->dev, "unable to read reg BCI CTL1 0x%X\n",
824 TWL4030_BCI_BCICTL1);
827 regval |= TWL4030_BCI_MESBAT;
828 ret = twl_i2c_write_u8(TWL_MODULE_MAIN_CHARGE,
829 regval, TWL4030_BCI_BCICTL1);
831 dev_err(&pdev->dev, "unable to write reg BCI Ctl1 0x%X\n",
832 TWL4030_BCI_BCICTL1);
836 /* Check that MADC clock is on */
837 ret = twl_i2c_read_u8(TWL4030_MODULE_INTBR, ®val, TWL4030_REG_GPBR1);
839 dev_err(&pdev->dev, "unable to read reg GPBR1 0x%X\n",
844 /* If MADC clk is not on, turn it on */
845 if (!(regval & TWL4030_GPBR1_MADC_HFCLK_EN)) {
846 dev_info(&pdev->dev, "clk disabled, enabling\n");
847 regval |= TWL4030_GPBR1_MADC_HFCLK_EN;
848 ret = twl_i2c_write_u8(TWL4030_MODULE_INTBR, regval,
851 dev_err(&pdev->dev, "unable to write reg GPBR1 0x%X\n",
857 platform_set_drvdata(pdev, iio_dev);
858 mutex_init(&madc->lock);
860 irq = platform_get_irq(pdev, 0);
861 ret = devm_request_threaded_irq(&pdev->dev, irq, NULL,
862 twl4030_madc_threaded_irq_handler,
863 IRQF_TRIGGER_RISING | IRQF_ONESHOT,
864 "twl4030_madc", madc);
866 dev_err(&pdev->dev, "could not request irq\n");
871 /* Configure MADC[3:6] */
872 ret = twl_i2c_read_u8(TWL_MODULE_USB, ®val,
873 TWL4030_USB_CARKIT_ANA_CTRL);
875 dev_err(&pdev->dev, "unable to read reg CARKIT_ANA_CTRL 0x%X\n",
876 TWL4030_USB_CARKIT_ANA_CTRL);
879 regval |= TWL4030_USB_SEL_MADC_MCPC;
880 ret = twl_i2c_write_u8(TWL_MODULE_USB, regval,
881 TWL4030_USB_CARKIT_ANA_CTRL);
883 dev_err(&pdev->dev, "unable to write reg CARKIT_ANA_CTRL 0x%X\n",
884 TWL4030_USB_CARKIT_ANA_CTRL);
888 /* Enable 3v1 bias regulator for MADC[3:6] */
889 madc->usb3v1 = devm_regulator_get(madc->dev, "vusb3v1");
890 if (IS_ERR(madc->usb3v1))
893 ret = regulator_enable(madc->usb3v1);
895 dev_err(madc->dev, "could not enable 3v1 bias regulator\n");
897 ret = iio_device_register(iio_dev);
899 dev_err(&pdev->dev, "could not register iio device\n");
906 twl4030_madc_set_current_generator(madc, 0, 0);
907 err_current_generator:
908 twl4030_madc_set_power(madc, 0);
912 static int twl4030_madc_remove(struct platform_device *pdev)
914 struct iio_dev *iio_dev = platform_get_drvdata(pdev);
915 struct twl4030_madc_data *madc = iio_priv(iio_dev);
917 iio_device_unregister(iio_dev);
919 twl4030_madc_set_current_generator(madc, 0, 0);
920 twl4030_madc_set_power(madc, 0);
922 regulator_disable(madc->usb3v1);
928 static const struct of_device_id twl_madc_of_match[] = {
929 { .compatible = "ti,twl4030-madc", },
932 MODULE_DEVICE_TABLE(of, twl_madc_of_match);
935 static struct platform_driver twl4030_madc_driver = {
936 .probe = twl4030_madc_probe,
937 .remove = twl4030_madc_remove,
939 .name = "twl4030_madc",
940 .of_match_table = of_match_ptr(twl_madc_of_match),
944 module_platform_driver(twl4030_madc_driver);
946 MODULE_DESCRIPTION("TWL4030 ADC driver");
947 MODULE_LICENSE("GPL");
948 MODULE_AUTHOR("J Keerthy");
949 MODULE_ALIAS("platform:twl4030_madc");