xref: /openbmc/linux/drivers/iio/adc/twl4030-madc.c (revision d7a3d85e)
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, &reg, 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.raw = 0;
649 	req.func_cb = NULL;
650 	ret = twl4030_madc_conversion(&req);
651 	if (ret < 0)
652 		return ret;
653 	if (req.rbuf[channel_no] > 0)
654 		temp = req.rbuf[channel_no];
655 
656 	return temp;
657 }
658 EXPORT_SYMBOL_GPL(twl4030_get_madc_conversion);
659 
660 /**
661  * twl4030_madc_set_current_generator() - setup bias current
662  *
663  * @madc:	pointer to twl4030_madc_data struct
664  * @chan:	can be one of the two values:
665  *		TWL4030_BCI_ITHEN
666  *		Enables bias current for main battery type reading
667  *		TWL4030_BCI_TYPEN
668  *		Enables bias current for main battery temperature sensing
669  * @on:		enable or disable chan.
670  *
671  * Function to enable or disable bias current for
672  * main battery type reading or temperature sensing
673  */
674 static int twl4030_madc_set_current_generator(struct twl4030_madc_data *madc,
675 					      int chan, int on)
676 {
677 	int ret;
678 	int regmask;
679 	u8 regval;
680 
681 	ret = twl_i2c_read_u8(TWL_MODULE_MAIN_CHARGE,
682 			      &regval, TWL4030_BCI_BCICTL1);
683 	if (ret) {
684 		dev_err(madc->dev, "unable to read BCICTL1 reg 0x%X",
685 			TWL4030_BCI_BCICTL1);
686 		return ret;
687 	}
688 
689 	regmask = chan ? TWL4030_BCI_ITHEN : TWL4030_BCI_TYPEN;
690 	if (on)
691 		regval |= regmask;
692 	else
693 		regval &= ~regmask;
694 
695 	ret = twl_i2c_write_u8(TWL_MODULE_MAIN_CHARGE,
696 			       regval, TWL4030_BCI_BCICTL1);
697 	if (ret) {
698 		dev_err(madc->dev, "unable to write BCICTL1 reg 0x%X\n",
699 			TWL4030_BCI_BCICTL1);
700 		return ret;
701 	}
702 
703 	return 0;
704 }
705 
706 /*
707  * Function that sets MADC software power on bit to enable MADC
708  * @madc - pointer to twl4030_madc_data struct
709  * @on - Enable or disable MADC software power on bit.
710  * returns error if i2c read/write fails else 0
711  */
712 static int twl4030_madc_set_power(struct twl4030_madc_data *madc, int on)
713 {
714 	u8 regval;
715 	int ret;
716 
717 	ret = twl_i2c_read_u8(TWL_MODULE_MAIN_CHARGE,
718 			      &regval, TWL4030_MADC_CTRL1);
719 	if (ret) {
720 		dev_err(madc->dev, "unable to read madc ctrl1 reg 0x%X\n",
721 			TWL4030_MADC_CTRL1);
722 		return ret;
723 	}
724 	if (on)
725 		regval |= TWL4030_MADC_MADCON;
726 	else
727 		regval &= ~TWL4030_MADC_MADCON;
728 	ret = twl_i2c_write_u8(TWL4030_MODULE_MADC, regval, TWL4030_MADC_CTRL1);
729 	if (ret) {
730 		dev_err(madc->dev, "unable to write madc ctrl1 reg 0x%X\n",
731 			TWL4030_MADC_CTRL1);
732 		return ret;
733 	}
734 
735 	return 0;
736 }
737 
738 /*
739  * Initialize MADC and request for threaded irq
740  */
741 static int twl4030_madc_probe(struct platform_device *pdev)
742 {
743 	struct twl4030_madc_data *madc;
744 	struct twl4030_madc_platform_data *pdata = dev_get_platdata(&pdev->dev);
745 	struct device_node *np = pdev->dev.of_node;
746 	int irq, ret;
747 	u8 regval;
748 	struct iio_dev *iio_dev = NULL;
749 
750 	if (!pdata && !np) {
751 		dev_err(&pdev->dev, "neither platform data nor Device Tree node available\n");
752 		return -EINVAL;
753 	}
754 
755 	iio_dev = devm_iio_device_alloc(&pdev->dev, sizeof(*madc));
756 	if (!iio_dev) {
757 		dev_err(&pdev->dev, "failed allocating iio device\n");
758 		return -ENOMEM;
759 	}
760 
761 	madc = iio_priv(iio_dev);
762 	madc->dev = &pdev->dev;
763 
764 	iio_dev->name = dev_name(&pdev->dev);
765 	iio_dev->dev.parent = &pdev->dev;
766 	iio_dev->dev.of_node = pdev->dev.of_node;
767 	iio_dev->info = &twl4030_madc_iio_info;
768 	iio_dev->modes = INDIO_DIRECT_MODE;
769 	iio_dev->channels = twl4030_madc_iio_channels;
770 	iio_dev->num_channels = ARRAY_SIZE(twl4030_madc_iio_channels);
771 
772 	/*
773 	 * Phoenix provides 2 interrupt lines. The first one is connected to
774 	 * the OMAP. The other one can be connected to the other processor such
775 	 * as modem. Hence two separate ISR and IMR registers.
776 	 */
777 	if (pdata)
778 		madc->use_second_irq = (pdata->irq_line != 1);
779 	else
780 		madc->use_second_irq = of_property_read_bool(np,
781 				       "ti,system-uses-second-madc-irq");
782 
783 	madc->imr = madc->use_second_irq ? TWL4030_MADC_IMR2 :
784 					   TWL4030_MADC_IMR1;
785 	madc->isr = madc->use_second_irq ? TWL4030_MADC_ISR2 :
786 					   TWL4030_MADC_ISR1;
787 
788 	ret = twl4030_madc_set_power(madc, 1);
789 	if (ret < 0)
790 		return ret;
791 	ret = twl4030_madc_set_current_generator(madc, 0, 1);
792 	if (ret < 0)
793 		goto err_current_generator;
794 
795 	ret = twl_i2c_read_u8(TWL_MODULE_MAIN_CHARGE,
796 			      &regval, TWL4030_BCI_BCICTL1);
797 	if (ret) {
798 		dev_err(&pdev->dev, "unable to read reg BCI CTL1 0x%X\n",
799 			TWL4030_BCI_BCICTL1);
800 		goto err_i2c;
801 	}
802 	regval |= TWL4030_BCI_MESBAT;
803 	ret = twl_i2c_write_u8(TWL_MODULE_MAIN_CHARGE,
804 			       regval, TWL4030_BCI_BCICTL1);
805 	if (ret) {
806 		dev_err(&pdev->dev, "unable to write reg BCI Ctl1 0x%X\n",
807 			TWL4030_BCI_BCICTL1);
808 		goto err_i2c;
809 	}
810 
811 	/* Check that MADC clock is on */
812 	ret = twl_i2c_read_u8(TWL4030_MODULE_INTBR, &regval, TWL4030_REG_GPBR1);
813 	if (ret) {
814 		dev_err(&pdev->dev, "unable to read reg GPBR1 0x%X\n",
815 				TWL4030_REG_GPBR1);
816 		goto err_i2c;
817 	}
818 
819 	/* If MADC clk is not on, turn it on */
820 	if (!(regval & TWL4030_GPBR1_MADC_HFCLK_EN)) {
821 		dev_info(&pdev->dev, "clk disabled, enabling\n");
822 		regval |= TWL4030_GPBR1_MADC_HFCLK_EN;
823 		ret = twl_i2c_write_u8(TWL4030_MODULE_INTBR, regval,
824 				       TWL4030_REG_GPBR1);
825 		if (ret) {
826 			dev_err(&pdev->dev, "unable to write reg GPBR1 0x%X\n",
827 					TWL4030_REG_GPBR1);
828 			goto err_i2c;
829 		}
830 	}
831 
832 	platform_set_drvdata(pdev, iio_dev);
833 	mutex_init(&madc->lock);
834 
835 	irq = platform_get_irq(pdev, 0);
836 	ret = devm_request_threaded_irq(&pdev->dev, irq, NULL,
837 				   twl4030_madc_threaded_irq_handler,
838 				   IRQF_TRIGGER_RISING, "twl4030_madc", madc);
839 	if (ret) {
840 		dev_err(&pdev->dev, "could not request irq\n");
841 		goto err_i2c;
842 	}
843 	twl4030_madc = madc;
844 
845 	ret = iio_device_register(iio_dev);
846 	if (ret) {
847 		dev_err(&pdev->dev, "could not register iio device\n");
848 		goto err_i2c;
849 	}
850 
851 	return 0;
852 
853 err_i2c:
854 	twl4030_madc_set_current_generator(madc, 0, 0);
855 err_current_generator:
856 	twl4030_madc_set_power(madc, 0);
857 	return ret;
858 }
859 
860 static int twl4030_madc_remove(struct platform_device *pdev)
861 {
862 	struct iio_dev *iio_dev = platform_get_drvdata(pdev);
863 	struct twl4030_madc_data *madc = iio_priv(iio_dev);
864 
865 	iio_device_unregister(iio_dev);
866 
867 	twl4030_madc_set_current_generator(madc, 0, 0);
868 	twl4030_madc_set_power(madc, 0);
869 
870 	return 0;
871 }
872 
873 #ifdef CONFIG_OF
874 static const struct of_device_id twl_madc_of_match[] = {
875 	{ .compatible = "ti,twl4030-madc", },
876 	{ },
877 };
878 MODULE_DEVICE_TABLE(of, twl_madc_of_match);
879 #endif
880 
881 static struct platform_driver twl4030_madc_driver = {
882 	.probe = twl4030_madc_probe,
883 	.remove = twl4030_madc_remove,
884 	.driver = {
885 		   .name = "twl4030_madc",
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