blob: f4e94869d6129a60d1da63cd851cbf0183ceb8fd [file] [log] [blame]
Arun Murthydae2db32011-02-22 10:11:13 +01001/*
2 * Copyright (C) ST-Ericsson SA 2010
3 *
4 * License Terms: GNU General Public License v2
5 * Author: Arun R Murthy <arun.murthy@stericsson.com>
Daniel Willerud63219922011-03-05 11:46:13 +01006 * Author: Daniel Willerud <daniel.willerud@stericsson.com>
Johan Palsson586f3312011-03-05 11:46:37 +01007 * Author: Johan Palsson <johan.palsson@stericsson.com>
Paul Gortmaker1d57c392016-10-29 21:24:38 -04008 * Author: M'boumba Cedric Madianga
Arun Murthydae2db32011-02-22 10:11:13 +01009 */
10#include <linux/init.h>
Arun Murthydae2db32011-02-22 10:11:13 +010011#include <linux/device.h>
12#include <linux/interrupt.h>
13#include <linux/spinlock.h>
14#include <linux/delay.h>
Lee Jones5f8aaef2013-02-04 08:33:13 +000015#include <linux/pm_runtime.h>
Arun Murthydae2db32011-02-22 10:11:13 +010016#include <linux/platform_device.h>
17#include <linux/completion.h>
18#include <linux/regulator/consumer.h>
19#include <linux/err.h>
20#include <linux/slab.h>
Daniel Willerud63219922011-03-05 11:46:13 +010021#include <linux/list.h>
Arun Murthydae2db32011-02-22 10:11:13 +010022#include <linux/mfd/abx500.h>
Linus Walleijee66e652011-12-02 14:16:33 +010023#include <linux/mfd/abx500/ab8500.h>
24#include <linux/mfd/abx500/ab8500-gpadc.h>
Arun Murthydae2db32011-02-22 10:11:13 +010025
26/*
27 * GPADC register offsets
28 * Bank : 0x0A
29 */
30#define AB8500_GPADC_CTRL1_REG 0x00
31#define AB8500_GPADC_CTRL2_REG 0x01
32#define AB8500_GPADC_CTRL3_REG 0x02
33#define AB8500_GPADC_AUTO_TIMER_REG 0x03
34#define AB8500_GPADC_STAT_REG 0x04
35#define AB8500_GPADC_MANDATAL_REG 0x05
36#define AB8500_GPADC_MANDATAH_REG 0x06
37#define AB8500_GPADC_AUTODATAL_REG 0x07
38#define AB8500_GPADC_AUTODATAH_REG 0x08
39#define AB8500_GPADC_MUX_CTRL_REG 0x09
Lee Jonese4bffe82013-02-11 10:38:00 +000040#define AB8540_GPADC_MANDATA2L_REG 0x09
41#define AB8540_GPADC_MANDATA2H_REG 0x0A
42#define AB8540_GPADC_APEAAX_REG 0x10
43#define AB8540_GPADC_APEAAT_REG 0x11
44#define AB8540_GPADC_APEAAM_REG 0x12
45#define AB8540_GPADC_APEAAH_REG 0x13
46#define AB8540_GPADC_APEAAL_REG 0x14
Arun Murthydae2db32011-02-22 10:11:13 +010047
Johan Palsson586f3312011-03-05 11:46:37 +010048/*
49 * OTP register offsets
50 * Bank : 0x15
51 */
Lee Jonesdf364422015-10-28 10:32:10 +000052#define AB8500_GPADC_CAL_1 0x0F
53#define AB8500_GPADC_CAL_2 0x10
54#define AB8500_GPADC_CAL_3 0x11
55#define AB8500_GPADC_CAL_4 0x12
56#define AB8500_GPADC_CAL_5 0x13
57#define AB8500_GPADC_CAL_6 0x14
58#define AB8500_GPADC_CAL_7 0x15
Lee Jonese4bffe82013-02-11 10:38:00 +000059/* New calibration for 8540 */
60#define AB8540_GPADC_OTP4_REG_7 0x38
61#define AB8540_GPADC_OTP4_REG_6 0x39
62#define AB8540_GPADC_OTP4_REG_5 0x3A
Johan Palsson586f3312011-03-05 11:46:37 +010063
Arun Murthydae2db32011-02-22 10:11:13 +010064/* gpadc constants */
Lee Jonesdf364422015-10-28 10:32:10 +000065#define EN_VINTCORE12 0x04
66#define EN_VTVOUT 0x02
67#define EN_GPADC 0x01
68#define DIS_GPADC 0x00
69#define AVG_1 0x00
70#define AVG_4 0x20
71#define AVG_8 0x40
72#define AVG_16 0x60
73#define ADC_SW_CONV 0x04
74#define EN_ICHAR 0x80
75#define BTEMP_PULL_UP 0x08
76#define EN_BUF 0x40
77#define DIS_ZERO 0x00
78#define GPADC_BUSY 0x01
79#define EN_FALLING 0x10
80#define EN_TRIG_EDGE 0x02
81#define EN_VBIAS_XTAL_TEMP 0x02
Arun Murthydae2db32011-02-22 10:11:13 +010082
Johan Palsson586f3312011-03-05 11:46:37 +010083/* GPADC constants from AB8500 spec, UM0836 */
Lee Jonesdf364422015-10-28 10:32:10 +000084#define ADC_RESOLUTION 1024
85#define ADC_CH_BTEMP_MIN 0
86#define ADC_CH_BTEMP_MAX 1350
87#define ADC_CH_DIETEMP_MIN 0
88#define ADC_CH_DIETEMP_MAX 1350
89#define ADC_CH_CHG_V_MIN 0
90#define ADC_CH_CHG_V_MAX 20030
91#define ADC_CH_ACCDET2_MIN 0
92#define ADC_CH_ACCDET2_MAX 2500
93#define ADC_CH_VBAT_MIN 2300
94#define ADC_CH_VBAT_MAX 4800
95#define ADC_CH_CHG_I_MIN 0
96#define ADC_CH_CHG_I_MAX 1500
97#define ADC_CH_BKBAT_MIN 0
98#define ADC_CH_BKBAT_MAX 3200
Johan Palsson586f3312011-03-05 11:46:37 +010099
Lee Jonese4bffe82013-02-11 10:38:00 +0000100/* GPADC constants from AB8540 spec */
Lee Jonesdf364422015-10-28 10:32:10 +0000101#define ADC_CH_IBAT_MIN (-6000) /* mA range measured by ADC for ibat */
102#define ADC_CH_IBAT_MAX 6000
103#define ADC_CH_IBAT_MIN_V (-60) /* mV range measured by ADC for ibat */
104#define ADC_CH_IBAT_MAX_V 60
105#define IBAT_VDROP_L (-56) /* mV */
106#define IBAT_VDROP_H 56
Lee Jonese4bffe82013-02-11 10:38:00 +0000107
Johan Palsson586f3312011-03-05 11:46:37 +0100108/* This is used to not lose precision when dividing to get gain and offset */
Lee Jonese4bffe82013-02-11 10:38:00 +0000109#define CALIB_SCALE 1000
110/*
111 * Number of bits shift used to not lose precision
112 * when dividing to get ibat gain.
113 */
114#define CALIB_SHIFT_IBAT 20
Johan Palsson586f3312011-03-05 11:46:37 +0100115
Lee Jones5f8aaef2013-02-04 08:33:13 +0000116/* Time in ms before disabling regulator */
117#define GPADC_AUDOSUSPEND_DELAY 1
118
Lee Jonesf825ebe2013-01-28 09:20:45 +0000119#define CONVERSION_TIME 500 /* ms */
120
Johan Palsson586f3312011-03-05 11:46:37 +0100121enum cal_channels {
122 ADC_INPUT_VMAIN = 0,
123 ADC_INPUT_BTEMP,
124 ADC_INPUT_VBAT,
Lee Jonese4bffe82013-02-11 10:38:00 +0000125 ADC_INPUT_IBAT,
Johan Palsson586f3312011-03-05 11:46:37 +0100126 NBR_CAL_INPUTS,
127};
128
Arun Murthydae2db32011-02-22 10:11:13 +0100129/**
Johan Palsson586f3312011-03-05 11:46:37 +0100130 * struct adc_cal_data - Table for storing gain and offset for the calibrated
131 * ADC channels
132 * @gain: Gain of the ADC channel
133 * @offset: Offset of the ADC channel
134 */
135struct adc_cal_data {
Lee Jonese4bffe82013-02-11 10:38:00 +0000136 s64 gain;
137 s64 offset;
Lee Jonesbc6b4132013-02-26 14:02:31 +0000138 u16 otp_calib_hi;
139 u16 otp_calib_lo;
Johan Palsson586f3312011-03-05 11:46:37 +0100140};
141
142/**
143 * struct ab8500_gpadc - AB8500 GPADC device information
Arun Murthydae2db32011-02-22 10:11:13 +0100144 * @dev: pointer to the struct device
Daniel Willerud63219922011-03-05 11:46:13 +0100145 * @node: a list of AB8500 GPADCs, hence prepared for
146 reentrance
Michel JAOUEN20bf4282012-02-09 12:06:47 +0100147 * @parent: pointer to the struct ab8500
Arun Murthydae2db32011-02-22 10:11:13 +0100148 * @ab8500_gpadc_complete: pointer to the struct completion, to indicate
149 * the completion of gpadc conversion
150 * @ab8500_gpadc_lock: structure of type mutex
151 * @regu: pointer to the struct regulator
Lee Jones73482342013-02-26 10:06:55 +0000152 * @irq_sw: interrupt number that is used by gpadc for Sw
153 * conversion
154 * @irq_hw: interrupt number that is used by gpadc for Hw
155 * conversion
Johan Palsson586f3312011-03-05 11:46:37 +0100156 * @cal_data array of ADC calibration data structs
Arun Murthydae2db32011-02-22 10:11:13 +0100157 */
Daniel Willerud63219922011-03-05 11:46:13 +0100158struct ab8500_gpadc {
Arun Murthydae2db32011-02-22 10:11:13 +0100159 struct device *dev;
Daniel Willerud63219922011-03-05 11:46:13 +0100160 struct list_head node;
Michel JAOUEN20bf4282012-02-09 12:06:47 +0100161 struct ab8500 *parent;
Arun Murthydae2db32011-02-22 10:11:13 +0100162 struct completion ab8500_gpadc_complete;
163 struct mutex ab8500_gpadc_lock;
164 struct regulator *regu;
Lee Jones73482342013-02-26 10:06:55 +0000165 int irq_sw;
166 int irq_hw;
Johan Palsson586f3312011-03-05 11:46:37 +0100167 struct adc_cal_data cal_data[NBR_CAL_INPUTS];
Daniel Willerud63219922011-03-05 11:46:13 +0100168};
169
170static LIST_HEAD(ab8500_gpadc_list);
171
172/**
173 * ab8500_gpadc_get() - returns a reference to the primary AB8500 GPADC
174 * (i.e. the first GPADC in the instance list)
175 */
176struct ab8500_gpadc *ab8500_gpadc_get(char *name)
177{
178 struct ab8500_gpadc *gpadc;
179
180 list_for_each_entry(gpadc, &ab8500_gpadc_list, node) {
181 if (!strcmp(name, dev_name(gpadc->dev)))
Lee Jonesdf364422015-10-28 10:32:10 +0000182 return gpadc;
Daniel Willerud63219922011-03-05 11:46:13 +0100183 }
184
185 return ERR_PTR(-ENOENT);
186}
187EXPORT_SYMBOL(ab8500_gpadc_get);
Arun Murthydae2db32011-02-22 10:11:13 +0100188
Karl Komierowskibd4a40b2011-08-10 15:09:43 +0200189/**
190 * ab8500_gpadc_ad_to_voltage() - Convert a raw ADC value to a voltage
191 */
192int ab8500_gpadc_ad_to_voltage(struct ab8500_gpadc *gpadc, u8 channel,
Johan Palsson586f3312011-03-05 11:46:37 +0100193 int ad_value)
194{
195 int res;
196
Karl Komierowskibd4a40b2011-08-10 15:09:43 +0200197 switch (channel) {
Johan Palsson586f3312011-03-05 11:46:37 +0100198 case MAIN_CHARGER_V:
199 /* For some reason we don't have calibrated data */
200 if (!gpadc->cal_data[ADC_INPUT_VMAIN].gain) {
201 res = ADC_CH_CHG_V_MIN + (ADC_CH_CHG_V_MAX -
202 ADC_CH_CHG_V_MIN) * ad_value /
203 ADC_RESOLUTION;
204 break;
205 }
206 /* Here we can use the calibrated data */
207 res = (int) (ad_value * gpadc->cal_data[ADC_INPUT_VMAIN].gain +
208 gpadc->cal_data[ADC_INPUT_VMAIN].offset) / CALIB_SCALE;
209 break;
210
Lee Jonese4bffe82013-02-11 10:38:00 +0000211 case XTAL_TEMP:
Johan Palsson586f3312011-03-05 11:46:37 +0100212 case BAT_CTRL:
213 case BTEMP_BALL:
214 case ACC_DETECT1:
215 case ADC_AUX1:
216 case ADC_AUX2:
217 /* For some reason we don't have calibrated data */
218 if (!gpadc->cal_data[ADC_INPUT_BTEMP].gain) {
219 res = ADC_CH_BTEMP_MIN + (ADC_CH_BTEMP_MAX -
220 ADC_CH_BTEMP_MIN) * ad_value /
221 ADC_RESOLUTION;
222 break;
223 }
224 /* Here we can use the calibrated data */
225 res = (int) (ad_value * gpadc->cal_data[ADC_INPUT_BTEMP].gain +
226 gpadc->cal_data[ADC_INPUT_BTEMP].offset) / CALIB_SCALE;
227 break;
228
229 case MAIN_BAT_V:
Lee Jonese4bffe82013-02-11 10:38:00 +0000230 case VBAT_TRUE_MEAS:
Johan Palsson586f3312011-03-05 11:46:37 +0100231 /* For some reason we don't have calibrated data */
232 if (!gpadc->cal_data[ADC_INPUT_VBAT].gain) {
233 res = ADC_CH_VBAT_MIN + (ADC_CH_VBAT_MAX -
234 ADC_CH_VBAT_MIN) * ad_value /
235 ADC_RESOLUTION;
236 break;
237 }
238 /* Here we can use the calibrated data */
239 res = (int) (ad_value * gpadc->cal_data[ADC_INPUT_VBAT].gain +
240 gpadc->cal_data[ADC_INPUT_VBAT].offset) / CALIB_SCALE;
241 break;
242
243 case DIE_TEMP:
244 res = ADC_CH_DIETEMP_MIN +
245 (ADC_CH_DIETEMP_MAX - ADC_CH_DIETEMP_MIN) * ad_value /
246 ADC_RESOLUTION;
247 break;
248
249 case ACC_DETECT2:
250 res = ADC_CH_ACCDET2_MIN +
251 (ADC_CH_ACCDET2_MAX - ADC_CH_ACCDET2_MIN) * ad_value /
252 ADC_RESOLUTION;
253 break;
254
255 case VBUS_V:
256 res = ADC_CH_CHG_V_MIN +
257 (ADC_CH_CHG_V_MAX - ADC_CH_CHG_V_MIN) * ad_value /
258 ADC_RESOLUTION;
259 break;
260
261 case MAIN_CHARGER_C:
262 case USB_CHARGER_C:
263 res = ADC_CH_CHG_I_MIN +
264 (ADC_CH_CHG_I_MAX - ADC_CH_CHG_I_MIN) * ad_value /
265 ADC_RESOLUTION;
266 break;
267
268 case BK_BAT_V:
269 res = ADC_CH_BKBAT_MIN +
270 (ADC_CH_BKBAT_MAX - ADC_CH_BKBAT_MIN) * ad_value /
271 ADC_RESOLUTION;
272 break;
273
Lee Jonese4bffe82013-02-11 10:38:00 +0000274 case IBAT_VIRTUAL_CHANNEL:
275 /* For some reason we don't have calibrated data */
276 if (!gpadc->cal_data[ADC_INPUT_IBAT].gain) {
277 res = ADC_CH_IBAT_MIN + (ADC_CH_IBAT_MAX -
278 ADC_CH_IBAT_MIN) * ad_value /
279 ADC_RESOLUTION;
280 break;
281 }
282 /* Here we can use the calibrated data */
283 res = (int) (ad_value * gpadc->cal_data[ADC_INPUT_IBAT].gain +
284 gpadc->cal_data[ADC_INPUT_IBAT].offset)
285 >> CALIB_SHIFT_IBAT;
286 break;
287
Johan Palsson586f3312011-03-05 11:46:37 +0100288 default:
289 dev_err(gpadc->dev,
290 "unknown channel, not possible to convert\n");
291 res = -EINVAL;
292 break;
293
294 }
295 return res;
296}
Karl Komierowskibd4a40b2011-08-10 15:09:43 +0200297EXPORT_SYMBOL(ab8500_gpadc_ad_to_voltage);
Johan Palsson586f3312011-03-05 11:46:37 +0100298
Arun Murthydae2db32011-02-22 10:11:13 +0100299/**
Lee Jones73482342013-02-26 10:06:55 +0000300 * ab8500_gpadc_sw_hw_convert() - gpadc conversion
Karl Komierowskibd4a40b2011-08-10 15:09:43 +0200301 * @channel: analog channel to be converted to digital data
Lee Jones73482342013-02-26 10:06:55 +0000302 * @avg_sample: number of ADC sample to average
303 * @trig_egde: selected ADC trig edge
304 * @trig_timer: selected ADC trigger delay timer
305 * @conv_type: selected conversion type (HW or SW conversion)
Arun Murthydae2db32011-02-22 10:11:13 +0100306 *
307 * This function converts the selected analog i/p to digital
Johan Palsson586f3312011-03-05 11:46:37 +0100308 * data.
Arun Murthydae2db32011-02-22 10:11:13 +0100309 */
Lee Jones73482342013-02-26 10:06:55 +0000310int ab8500_gpadc_sw_hw_convert(struct ab8500_gpadc *gpadc, u8 channel,
311 u8 avg_sample, u8 trig_edge, u8 trig_timer, u8 conv_type)
Karl Komierowskibd4a40b2011-08-10 15:09:43 +0200312{
313 int ad_value;
314 int voltage;
315
Lee Jones73482342013-02-26 10:06:55 +0000316 ad_value = ab8500_gpadc_read_raw(gpadc, channel, avg_sample,
317 trig_edge, trig_timer, conv_type);
Lee Jonesdf364422015-10-28 10:32:10 +0000318
319 /* On failure retry a second time */
Jonas Aabergd89cc5a2012-04-17 16:10:46 +0200320 if (ad_value < 0)
Lee Jones73482342013-02-26 10:06:55 +0000321 ad_value = ab8500_gpadc_read_raw(gpadc, channel, avg_sample,
322 trig_edge, trig_timer, conv_type);
Lee Jonesdf364422015-10-28 10:32:10 +0000323 if (ad_value < 0) {
Lee Jones73482342013-02-26 10:06:55 +0000324 dev_err(gpadc->dev, "GPADC raw value failed ch: %d\n",
325 channel);
Karl Komierowskibd4a40b2011-08-10 15:09:43 +0200326 return ad_value;
327 }
328
329 voltage = ab8500_gpadc_ad_to_voltage(gpadc, channel, ad_value);
Karl Komierowskibd4a40b2011-08-10 15:09:43 +0200330 if (voltage < 0)
Lee Jonesdf364422015-10-28 10:32:10 +0000331 dev_err(gpadc->dev,
332 "GPADC to voltage conversion failed ch: %d AD: 0x%x\n",
333 channel, ad_value);
Karl Komierowskibd4a40b2011-08-10 15:09:43 +0200334
335 return voltage;
336}
Arnd Bergmann8bf874a2013-04-23 18:30:52 +0200337EXPORT_SYMBOL(ab8500_gpadc_sw_hw_convert);
Karl Komierowskibd4a40b2011-08-10 15:09:43 +0200338
339/**
340 * ab8500_gpadc_read_raw() - gpadc read
341 * @channel: analog channel to be read
Lee Jones73482342013-02-26 10:06:55 +0000342 * @avg_sample: number of ADC sample to average
343 * @trig_edge: selected trig edge
344 * @trig_timer: selected ADC trigger delay timer
345 * @conv_type: selected conversion type (HW or SW conversion)
Karl Komierowskibd4a40b2011-08-10 15:09:43 +0200346 *
Lee Jones73482342013-02-26 10:06:55 +0000347 * This function obtains the raw ADC value for an hardware conversion,
348 * this then needs to be converted by calling ab8500_gpadc_ad_to_voltage()
Karl Komierowskibd4a40b2011-08-10 15:09:43 +0200349 */
Lee Jones73482342013-02-26 10:06:55 +0000350int ab8500_gpadc_read_raw(struct ab8500_gpadc *gpadc, u8 channel,
351 u8 avg_sample, u8 trig_edge, u8 trig_timer, u8 conv_type)
Arun Murthydae2db32011-02-22 10:11:13 +0100352{
Lee Jonesdf364422015-10-28 10:32:10 +0000353 return ab8500_gpadc_double_read_raw(gpadc, channel, avg_sample,
354 trig_edge, trig_timer, conv_type,
355 NULL);
Lee Jonese4bffe82013-02-11 10:38:00 +0000356}
357
358int ab8500_gpadc_double_read_raw(struct ab8500_gpadc *gpadc, u8 channel,
359 u8 avg_sample, u8 trig_edge, u8 trig_timer, u8 conv_type,
360 int *ibat)
Arun Murthydae2db32011-02-22 10:11:13 +0100361{
362 int ret;
Arun Murthydae2db32011-02-22 10:11:13 +0100363 int looplimit = 0;
Lee Jones7c8f02362013-02-11 10:49:41 +0000364 unsigned long completion_timeout;
Lee Jonese4bffe82013-02-11 10:38:00 +0000365 u8 val, low_data, high_data, low_data2, high_data2;
Lee Jones7c8f02362013-02-11 10:49:41 +0000366 u8 val_reg1 = 0;
367 unsigned int delay_min = 0;
368 unsigned int delay_max = 0;
369 u8 data_low_addr, data_high_addr;
Arun Murthydae2db32011-02-22 10:11:13 +0100370
Daniel Willerud63219922011-03-05 11:46:13 +0100371 if (!gpadc)
Arun Murthydae2db32011-02-22 10:11:13 +0100372 return -ENODEV;
373
Lee Jonesc0eda9a2013-02-12 15:04:09 +0000374 /* check if convertion is supported */
375 if ((gpadc->irq_sw < 0) && (conv_type == ADC_SW))
376 return -ENOTSUPP;
377 if ((gpadc->irq_hw < 0) && (conv_type == ADC_HW))
378 return -ENOTSUPP;
Lee Jones5f8aaef2013-02-04 08:33:13 +0000379
Arun Murthydae2db32011-02-22 10:11:13 +0100380 mutex_lock(&gpadc->ab8500_gpadc_lock);
Arun Murthydae2db32011-02-22 10:11:13 +0100381 /* Enable VTVout LDO this is required for GPADC */
Lee Jones5f8aaef2013-02-04 08:33:13 +0000382 pm_runtime_get_sync(gpadc->dev);
Arun Murthydae2db32011-02-22 10:11:13 +0100383
384 /* Check if ADC is not busy, lock and proceed */
385 do {
Daniel Willerud63219922011-03-05 11:46:13 +0100386 ret = abx500_get_register_interruptible(gpadc->dev,
387 AB8500_GPADC, AB8500_GPADC_STAT_REG, &val);
Arun Murthydae2db32011-02-22 10:11:13 +0100388 if (ret < 0)
389 goto out;
390 if (!(val & GPADC_BUSY))
391 break;
Lee Jonesdf364422015-10-28 10:32:10 +0000392 msleep(20);
Arun Murthydae2db32011-02-22 10:11:13 +0100393 } while (++looplimit < 10);
394 if (looplimit >= 10 && (val & GPADC_BUSY)) {
Daniel Willerud63219922011-03-05 11:46:13 +0100395 dev_err(gpadc->dev, "gpadc_conversion: GPADC busy");
Arun Murthydae2db32011-02-22 10:11:13 +0100396 ret = -EINVAL;
397 goto out;
398 }
399
400 /* Enable GPADC */
Lee Jones7c8f02362013-02-11 10:49:41 +0000401 val_reg1 |= EN_GPADC;
Karl Komierowskic9c95132011-05-08 00:55:31 +0200402
Lee Jones73482342013-02-26 10:06:55 +0000403 /* Select the channel source and set average samples */
404 switch (avg_sample) {
405 case SAMPLE_1:
406 val = channel | AVG_1;
407 break;
408 case SAMPLE_4:
409 val = channel | AVG_4;
410 break;
411 case SAMPLE_8:
412 val = channel | AVG_8;
413 break;
414 default:
415 val = channel | AVG_16;
416 break;
Arun Murthydae2db32011-02-22 10:11:13 +0100417 }
418
Lee Jones7c8f02362013-02-11 10:49:41 +0000419 if (conv_type == ADC_HW) {
Lee Jones73482342013-02-26 10:06:55 +0000420 ret = abx500_set_register_interruptible(gpadc->dev,
421 AB8500_GPADC, AB8500_GPADC_CTRL3_REG, val);
Lee Jones7c8f02362013-02-11 10:49:41 +0000422 val_reg1 |= EN_TRIG_EDGE;
423 if (trig_edge)
424 val_reg1 |= EN_FALLING;
Lee Jonesdf364422015-10-28 10:32:10 +0000425 } else
Lee Jones73482342013-02-26 10:06:55 +0000426 ret = abx500_set_register_interruptible(gpadc->dev,
427 AB8500_GPADC, AB8500_GPADC_CTRL2_REG, val);
Arun Murthydae2db32011-02-22 10:11:13 +0100428 if (ret < 0) {
Daniel Willerud63219922011-03-05 11:46:13 +0100429 dev_err(gpadc->dev,
Arun Murthydae2db32011-02-22 10:11:13 +0100430 "gpadc_conversion: set avg samples failed\n");
431 goto out;
432 }
Karl Komierowskic9c95132011-05-08 00:55:31 +0200433
Karl Komierowski4aad5a92011-03-05 11:46:45 +0100434 /*
435 * Enable ADC, buffering, select rising edge and enable ADC path
Karl Komierowskic9c95132011-05-08 00:55:31 +0200436 * charging current sense if it needed, ABB 3.0 needs some special
437 * treatment too.
Karl Komierowski4aad5a92011-03-05 11:46:45 +0100438 */
Karl Komierowskibd4a40b2011-08-10 15:09:43 +0200439 switch (channel) {
Karl Komierowski4aad5a92011-03-05 11:46:45 +0100440 case MAIN_CHARGER_C:
441 case USB_CHARGER_C:
Lee Jones7c8f02362013-02-11 10:49:41 +0000442 val_reg1 |= EN_BUF | EN_ICHAR;
Karl Komierowski4aad5a92011-03-05 11:46:45 +0100443 break;
Karl Komierowskic9c95132011-05-08 00:55:31 +0200444 case BTEMP_BALL:
Michel JAOUEN20bf4282012-02-09 12:06:47 +0100445 if (!is_ab8500_2p0_or_earlier(gpadc->parent)) {
Lee Jones7c8f02362013-02-11 10:49:41 +0000446 val_reg1 |= EN_BUF | BTEMP_PULL_UP;
447 /*
448 * Delay might be needed for ABB8500 cut 3.0, if not,
449 * remove when hardware will be availible
450 */
451 delay_min = 1000; /* Delay in micro seconds */
Lee Jonesdf364422015-10-28 10:32:10 +0000452 delay_max = 10000; /* large range optimises sleepmode */
Karl Komierowskic9c95132011-05-08 00:55:31 +0200453 break;
454 }
455 /* Intentional fallthrough */
Karl Komierowski4aad5a92011-03-05 11:46:45 +0100456 default:
Lee Jones7c8f02362013-02-11 10:49:41 +0000457 val_reg1 |= EN_BUF;
Karl Komierowski4aad5a92011-03-05 11:46:45 +0100458 break;
459 }
Lee Jones7c8f02362013-02-11 10:49:41 +0000460
461 /* Write configuration to register */
462 ret = abx500_set_register_interruptible(gpadc->dev,
463 AB8500_GPADC, AB8500_GPADC_CTRL1_REG, val_reg1);
Arun Murthydae2db32011-02-22 10:11:13 +0100464 if (ret < 0) {
Daniel Willerud63219922011-03-05 11:46:13 +0100465 dev_err(gpadc->dev,
Lee Jones7c8f02362013-02-11 10:49:41 +0000466 "gpadc_conversion: set Control register failed\n");
Arun Murthydae2db32011-02-22 10:11:13 +0100467 goto out;
468 }
Karl Komierowskic9c95132011-05-08 00:55:31 +0200469
Lee Jones7c8f02362013-02-11 10:49:41 +0000470 if (delay_min != 0)
471 usleep_range(delay_min, delay_max);
472
Lee Jones73482342013-02-26 10:06:55 +0000473 if (conv_type == ADC_HW) {
Lee Jones7c8f02362013-02-11 10:49:41 +0000474 /* Set trigger delay timer */
Lee Jones73482342013-02-26 10:06:55 +0000475 ret = abx500_set_register_interruptible(gpadc->dev,
476 AB8500_GPADC, AB8500_GPADC_AUTO_TIMER_REG, trig_timer);
477 if (ret < 0) {
478 dev_err(gpadc->dev,
479 "gpadc_conversion: trig timer failed\n");
480 goto out;
481 }
Lee Jones7c8f02362013-02-11 10:49:41 +0000482 completion_timeout = 2 * HZ;
483 data_low_addr = AB8500_GPADC_AUTODATAL_REG;
484 data_high_addr = AB8500_GPADC_AUTODATAH_REG;
485 } else {
486 /* Start SW conversion */
Lee Jones73482342013-02-26 10:06:55 +0000487 ret = abx500_mask_and_set_register_interruptible(gpadc->dev,
488 AB8500_GPADC, AB8500_GPADC_CTRL1_REG,
489 ADC_SW_CONV, ADC_SW_CONV);
490 if (ret < 0) {
491 dev_err(gpadc->dev,
492 "gpadc_conversion: start s/w conv failed\n");
493 goto out;
494 }
Lee Jones7c8f02362013-02-11 10:49:41 +0000495 completion_timeout = msecs_to_jiffies(CONVERSION_TIME);
496 data_low_addr = AB8500_GPADC_MANDATAL_REG;
497 data_high_addr = AB8500_GPADC_MANDATAH_REG;
Arun Murthydae2db32011-02-22 10:11:13 +0100498 }
Lee Jones73482342013-02-26 10:06:55 +0000499
Arun Murthydae2db32011-02-22 10:11:13 +0100500 /* wait for completion of conversion */
Lee Jonesf825ebe2013-01-28 09:20:45 +0000501 if (!wait_for_completion_timeout(&gpadc->ab8500_gpadc_complete,
Lee Jones7c8f02362013-02-11 10:49:41 +0000502 completion_timeout)) {
Daniel Willerud63219922011-03-05 11:46:13 +0100503 dev_err(gpadc->dev,
Lee Jones7c8f02362013-02-11 10:49:41 +0000504 "timeout didn't receive GPADC conv interrupt\n");
Arun Murthydae2db32011-02-22 10:11:13 +0100505 ret = -EINVAL;
506 goto out;
507 }
508
509 /* Read the converted RAW data */
Lee Jones7c8f02362013-02-11 10:49:41 +0000510 ret = abx500_get_register_interruptible(gpadc->dev,
511 AB8500_GPADC, data_low_addr, &low_data);
Arun Murthydae2db32011-02-22 10:11:13 +0100512 if (ret < 0) {
Daniel Willerud63219922011-03-05 11:46:13 +0100513 dev_err(gpadc->dev, "gpadc_conversion: read low data failed\n");
Arun Murthydae2db32011-02-22 10:11:13 +0100514 goto out;
515 }
516
Lee Jones7c8f02362013-02-11 10:49:41 +0000517 ret = abx500_get_register_interruptible(gpadc->dev,
518 AB8500_GPADC, data_high_addr, &high_data);
Arun Murthydae2db32011-02-22 10:11:13 +0100519 if (ret < 0) {
Lee Jones7c8f02362013-02-11 10:49:41 +0000520 dev_err(gpadc->dev, "gpadc_conversion: read high data failed\n");
Arun Murthydae2db32011-02-22 10:11:13 +0100521 goto out;
522 }
523
Lee Jonese4bffe82013-02-11 10:38:00 +0000524 /* Check if double convertion is required */
525 if ((channel == BAT_CTRL_AND_IBAT) ||
526 (channel == VBAT_MEAS_AND_IBAT) ||
527 (channel == VBAT_TRUE_MEAS_AND_IBAT) ||
528 (channel == BAT_TEMP_AND_IBAT)) {
529
530 if (conv_type == ADC_HW) {
531 /* not supported */
532 ret = -ENOTSUPP;
533 dev_err(gpadc->dev,
534 "gpadc_conversion: only SW double conversion supported\n");
535 goto out;
536 } else {
537 /* Read the converted RAW data 2 */
538 ret = abx500_get_register_interruptible(gpadc->dev,
539 AB8500_GPADC, AB8540_GPADC_MANDATA2L_REG,
540 &low_data2);
541 if (ret < 0) {
542 dev_err(gpadc->dev,
543 "gpadc_conversion: read sw low data 2 failed\n");
544 goto out;
545 }
546
547 ret = abx500_get_register_interruptible(gpadc->dev,
548 AB8500_GPADC, AB8540_GPADC_MANDATA2H_REG,
549 &high_data2);
550 if (ret < 0) {
551 dev_err(gpadc->dev,
552 "gpadc_conversion: read sw high data 2 failed\n");
553 goto out;
554 }
555 if (ibat != NULL) {
556 *ibat = (high_data2 << 8) | low_data2;
557 } else {
558 dev_warn(gpadc->dev,
559 "gpadc_conversion: ibat not stored\n");
560 }
561
562 }
563 }
Arun Murthydae2db32011-02-22 10:11:13 +0100564
Arun Murthydae2db32011-02-22 10:11:13 +0100565 /* Disable GPADC */
Daniel Willerud63219922011-03-05 11:46:13 +0100566 ret = abx500_set_register_interruptible(gpadc->dev, AB8500_GPADC,
Arun Murthydae2db32011-02-22 10:11:13 +0100567 AB8500_GPADC_CTRL1_REG, DIS_GPADC);
568 if (ret < 0) {
Daniel Willerud63219922011-03-05 11:46:13 +0100569 dev_err(gpadc->dev, "gpadc_conversion: disable gpadc failed\n");
Arun Murthydae2db32011-02-22 10:11:13 +0100570 goto out;
571 }
Lee Jones5f8aaef2013-02-04 08:33:13 +0000572
Lee Jones73482342013-02-26 10:06:55 +0000573 /* Disable VTVout LDO this is required for GPADC */
Lee Jones5f8aaef2013-02-04 08:33:13 +0000574 pm_runtime_mark_last_busy(gpadc->dev);
575 pm_runtime_put_autosuspend(gpadc->dev);
576
Daniel Willerud63219922011-03-05 11:46:13 +0100577 mutex_unlock(&gpadc->ab8500_gpadc_lock);
Karl Komierowskibd4a40b2011-08-10 15:09:43 +0200578
579 return (high_data << 8) | low_data;
Arun Murthydae2db32011-02-22 10:11:13 +0100580
581out:
582 /*
583 * It has shown to be needed to turn off the GPADC if an error occurs,
584 * otherwise we might have problem when waiting for the busy bit in the
585 * GPADC status register to go low. In V1.1 there wait_for_completion
586 * seems to timeout when waiting for an interrupt.. Not seen in V2.0
587 */
Daniel Willerud63219922011-03-05 11:46:13 +0100588 (void) abx500_set_register_interruptible(gpadc->dev, AB8500_GPADC,
Arun Murthydae2db32011-02-22 10:11:13 +0100589 AB8500_GPADC_CTRL1_REG, DIS_GPADC);
Lee Jones5f8aaef2013-02-04 08:33:13 +0000590 pm_runtime_put(gpadc->dev);
Daniel Willerud63219922011-03-05 11:46:13 +0100591 mutex_unlock(&gpadc->ab8500_gpadc_lock);
592 dev_err(gpadc->dev,
Karl Komierowskibd4a40b2011-08-10 15:09:43 +0200593 "gpadc_conversion: Failed to AD convert channel %d\n", channel);
Arun Murthydae2db32011-02-22 10:11:13 +0100594 return ret;
595}
Karl Komierowskibd4a40b2011-08-10 15:09:43 +0200596EXPORT_SYMBOL(ab8500_gpadc_read_raw);
Arun Murthydae2db32011-02-22 10:11:13 +0100597
598/**
Lee Jones73482342013-02-26 10:06:55 +0000599 * ab8500_bm_gpadcconvend_handler() - isr for gpadc conversion completion
Arun Murthydae2db32011-02-22 10:11:13 +0100600 * @irq: irq number
601 * @data: pointer to the data passed during request irq
602 *
Lee Jones73482342013-02-26 10:06:55 +0000603 * This is a interrupt service routine for gpadc conversion completion.
Arun Murthydae2db32011-02-22 10:11:13 +0100604 * Notifies the gpadc completion is completed and the converted raw value
605 * can be read from the registers.
606 * Returns IRQ status(IRQ_HANDLED)
607 */
Lee Jones73482342013-02-26 10:06:55 +0000608static irqreturn_t ab8500_bm_gpadcconvend_handler(int irq, void *_gpadc)
Arun Murthydae2db32011-02-22 10:11:13 +0100609{
Daniel Willerud63219922011-03-05 11:46:13 +0100610 struct ab8500_gpadc *gpadc = _gpadc;
Arun Murthydae2db32011-02-22 10:11:13 +0100611
612 complete(&gpadc->ab8500_gpadc_complete);
613
614 return IRQ_HANDLED;
615}
616
Johan Palsson586f3312011-03-05 11:46:37 +0100617static int otp_cal_regs[] = {
618 AB8500_GPADC_CAL_1,
619 AB8500_GPADC_CAL_2,
620 AB8500_GPADC_CAL_3,
621 AB8500_GPADC_CAL_4,
622 AB8500_GPADC_CAL_5,
623 AB8500_GPADC_CAL_6,
624 AB8500_GPADC_CAL_7,
625};
626
Lee Jonese4bffe82013-02-11 10:38:00 +0000627static int otp4_cal_regs[] = {
628 AB8540_GPADC_OTP4_REG_7,
629 AB8540_GPADC_OTP4_REG_6,
630 AB8540_GPADC_OTP4_REG_5,
631};
632
Johan Palsson586f3312011-03-05 11:46:37 +0100633static void ab8500_gpadc_read_calibration_data(struct ab8500_gpadc *gpadc)
634{
635 int i;
636 int ret[ARRAY_SIZE(otp_cal_regs)];
637 u8 gpadc_cal[ARRAY_SIZE(otp_cal_regs)];
Lee Jonese4bffe82013-02-11 10:38:00 +0000638 int ret_otp4[ARRAY_SIZE(otp4_cal_regs)];
639 u8 gpadc_otp4[ARRAY_SIZE(otp4_cal_regs)];
Johan Palsson586f3312011-03-05 11:46:37 +0100640 int vmain_high, vmain_low;
641 int btemp_high, btemp_low;
642 int vbat_high, vbat_low;
Lee Jonese4bffe82013-02-11 10:38:00 +0000643 int ibat_high, ibat_low;
644 s64 V_gain, V_offset, V2A_gain, V2A_offset;
645 struct ab8500 *ab8500;
646
647 ab8500 = gpadc->parent;
Johan Palsson586f3312011-03-05 11:46:37 +0100648
649 /* First we read all OTP registers and store the error code */
650 for (i = 0; i < ARRAY_SIZE(otp_cal_regs); i++) {
651 ret[i] = abx500_get_register_interruptible(gpadc->dev,
652 AB8500_OTP_EMUL, otp_cal_regs[i], &gpadc_cal[i]);
653 if (ret[i] < 0)
654 dev_err(gpadc->dev, "%s: read otp reg 0x%02x failed\n",
655 __func__, otp_cal_regs[i]);
656 }
657
658 /*
659 * The ADC calibration data is stored in OTP registers.
660 * The layout of the calibration data is outlined below and a more
661 * detailed description can be found in UM0836
662 *
663 * vm_h/l = vmain_high/low
664 * bt_h/l = btemp_high/low
665 * vb_h/l = vbat_high/low
666 *
Lee Jonese4bffe82013-02-11 10:38:00 +0000667 * Data bits 8500/9540:
Johan Palsson586f3312011-03-05 11:46:37 +0100668 * | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0
669 * |.......|.......|.......|.......|.......|.......|.......|.......
670 * | | vm_h9 | vm_h8
671 * |.......|.......|.......|.......|.......|.......|.......|.......
672 * | | vm_h7 | vm_h6 | vm_h5 | vm_h4 | vm_h3 | vm_h2
673 * |.......|.......|.......|.......|.......|.......|.......|.......
674 * | vm_h1 | vm_h0 | vm_l4 | vm_l3 | vm_l2 | vm_l1 | vm_l0 | bt_h9
675 * |.......|.......|.......|.......|.......|.......|.......|.......
676 * | bt_h8 | bt_h7 | bt_h6 | bt_h5 | bt_h4 | bt_h3 | bt_h2 | bt_h1
677 * |.......|.......|.......|.......|.......|.......|.......|.......
678 * | bt_h0 | bt_l4 | bt_l3 | bt_l2 | bt_l1 | bt_l0 | vb_h9 | vb_h8
679 * |.......|.......|.......|.......|.......|.......|.......|.......
680 * | vb_h7 | vb_h6 | vb_h5 | vb_h4 | vb_h3 | vb_h2 | vb_h1 | vb_h0
681 * |.......|.......|.......|.......|.......|.......|.......|.......
682 * | vb_l5 | vb_l4 | vb_l3 | vb_l2 | vb_l1 | vb_l0 |
683 * |.......|.......|.......|.......|.......|.......|.......|.......
684 *
Lee Jonese4bffe82013-02-11 10:38:00 +0000685 * Data bits 8540:
686 * OTP2
687 * | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0
688 * |.......|.......|.......|.......|.......|.......|.......|.......
689 * |
690 * |.......|.......|.......|.......|.......|.......|.......|.......
691 * | vm_h9 | vm_h8 | vm_h7 | vm_h6 | vm_h5 | vm_h4 | vm_h3 | vm_h2
692 * |.......|.......|.......|.......|.......|.......|.......|.......
693 * | vm_h1 | vm_h0 | vm_l4 | vm_l3 | vm_l2 | vm_l1 | vm_l0 | bt_h9
694 * |.......|.......|.......|.......|.......|.......|.......|.......
695 * | bt_h8 | bt_h7 | bt_h6 | bt_h5 | bt_h4 | bt_h3 | bt_h2 | bt_h1
696 * |.......|.......|.......|.......|.......|.......|.......|.......
697 * | bt_h0 | bt_l4 | bt_l3 | bt_l2 | bt_l1 | bt_l0 | vb_h9 | vb_h8
698 * |.......|.......|.......|.......|.......|.......|.......|.......
699 * | vb_h7 | vb_h6 | vb_h5 | vb_h4 | vb_h3 | vb_h2 | vb_h1 | vb_h0
700 * |.......|.......|.......|.......|.......|.......|.......|.......
701 * | vb_l5 | vb_l4 | vb_l3 | vb_l2 | vb_l1 | vb_l0 |
702 * |.......|.......|.......|.......|.......|.......|.......|.......
703 *
704 * Data bits 8540:
705 * OTP4
706 * | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0
707 * |.......|.......|.......|.......|.......|.......|.......|.......
708 * | | ib_h9 | ib_h8 | ib_h7
709 * |.......|.......|.......|.......|.......|.......|.......|.......
710 * | ib_h6 | ib_h5 | ib_h4 | ib_h3 | ib_h2 | ib_h1 | ib_h0 | ib_l5
711 * |.......|.......|.......|.......|.......|.......|.......|.......
712 * | ib_l4 | ib_l3 | ib_l2 | ib_l1 | ib_l0 |
713 *
Johan Palsson586f3312011-03-05 11:46:37 +0100714 *
715 * Ideal output ADC codes corresponding to injected input voltages
716 * during manufacturing is:
717 *
718 * vmain_high: Vin = 19500mV / ADC ideal code = 997
719 * vmain_low: Vin = 315mV / ADC ideal code = 16
720 * btemp_high: Vin = 1300mV / ADC ideal code = 985
721 * btemp_low: Vin = 21mV / ADC ideal code = 16
722 * vbat_high: Vin = 4700mV / ADC ideal code = 982
723 * vbat_low: Vin = 2380mV / ADC ideal code = 33
724 */
725
Lee Jonese4bffe82013-02-11 10:38:00 +0000726 if (is_ab8540(ab8500)) {
727 /* Calculate gain and offset for VMAIN if all reads succeeded*/
728 if (!(ret[1] < 0 || ret[2] < 0)) {
729 vmain_high = (((gpadc_cal[1] & 0xFF) << 2) |
730 ((gpadc_cal[2] & 0xC0) >> 6));
731 vmain_low = ((gpadc_cal[2] & 0x3E) >> 1);
Johan Palsson586f3312011-03-05 11:46:37 +0100732
Lee Jonesbc6b4132013-02-26 14:02:31 +0000733 gpadc->cal_data[ADC_INPUT_VMAIN].otp_calib_hi =
734 (u16)vmain_high;
735 gpadc->cal_data[ADC_INPUT_VMAIN].otp_calib_lo =
736 (u16)vmain_low;
Johan Palsson586f3312011-03-05 11:46:37 +0100737
Lee Jonese4bffe82013-02-11 10:38:00 +0000738 gpadc->cal_data[ADC_INPUT_VMAIN].gain = CALIB_SCALE *
739 (19500 - 315) / (vmain_high - vmain_low);
740 gpadc->cal_data[ADC_INPUT_VMAIN].offset = CALIB_SCALE *
741 19500 - (CALIB_SCALE * (19500 - 315) /
742 (vmain_high - vmain_low)) * vmain_high;
743 } else {
Johan Palsson586f3312011-03-05 11:46:37 +0100744 gpadc->cal_data[ADC_INPUT_VMAIN].gain = 0;
Lee Jonese4bffe82013-02-11 10:38:00 +0000745 }
Johan Palsson586f3312011-03-05 11:46:37 +0100746
Lee Jonese4bffe82013-02-11 10:38:00 +0000747 /* Read IBAT calibration Data */
748 for (i = 0; i < ARRAY_SIZE(otp4_cal_regs); i++) {
749 ret_otp4[i] = abx500_get_register_interruptible(
750 gpadc->dev, AB8500_OTP_EMUL,
751 otp4_cal_regs[i], &gpadc_otp4[i]);
752 if (ret_otp4[i] < 0)
753 dev_err(gpadc->dev,
754 "%s: read otp4 reg 0x%02x failed\n",
755 __func__, otp4_cal_regs[i]);
756 }
757
758 /* Calculate gain and offset for IBAT if all reads succeeded */
759 if (!(ret_otp4[0] < 0 || ret_otp4[1] < 0 || ret_otp4[2] < 0)) {
760 ibat_high = (((gpadc_otp4[0] & 0x07) << 7) |
761 ((gpadc_otp4[1] & 0xFE) >> 1));
762 ibat_low = (((gpadc_otp4[1] & 0x01) << 5) |
763 ((gpadc_otp4[2] & 0xF8) >> 3));
764
Lee Jonesbc6b4132013-02-26 14:02:31 +0000765 gpadc->cal_data[ADC_INPUT_IBAT].otp_calib_hi =
766 (u16)ibat_high;
767 gpadc->cal_data[ADC_INPUT_IBAT].otp_calib_lo =
768 (u16)ibat_low;
769
Lee Jonese4bffe82013-02-11 10:38:00 +0000770 V_gain = ((IBAT_VDROP_H - IBAT_VDROP_L)
771 << CALIB_SHIFT_IBAT) / (ibat_high - ibat_low);
772
773 V_offset = (IBAT_VDROP_H << CALIB_SHIFT_IBAT) -
774 (((IBAT_VDROP_H - IBAT_VDROP_L) <<
775 CALIB_SHIFT_IBAT) / (ibat_high - ibat_low))
776 * ibat_high;
777 /*
778 * Result obtained is in mV (at a scale factor),
779 * we need to calculate gain and offset to get mA
780 */
781 V2A_gain = (ADC_CH_IBAT_MAX - ADC_CH_IBAT_MIN)/
782 (ADC_CH_IBAT_MAX_V - ADC_CH_IBAT_MIN_V);
783 V2A_offset = ((ADC_CH_IBAT_MAX_V * ADC_CH_IBAT_MIN -
784 ADC_CH_IBAT_MAX * ADC_CH_IBAT_MIN_V)
785 << CALIB_SHIFT_IBAT)
786 / (ADC_CH_IBAT_MAX_V - ADC_CH_IBAT_MIN_V);
787
Lee Jonesdf364422015-10-28 10:32:10 +0000788 gpadc->cal_data[ADC_INPUT_IBAT].gain =
789 V_gain * V2A_gain;
790 gpadc->cal_data[ADC_INPUT_IBAT].offset =
791 V_offset * V2A_gain + V2A_offset;
Lee Jonese4bffe82013-02-11 10:38:00 +0000792 } else {
793 gpadc->cal_data[ADC_INPUT_IBAT].gain = 0;
794 }
795
796 dev_dbg(gpadc->dev, "IBAT gain %llu offset %llu\n",
797 gpadc->cal_data[ADC_INPUT_IBAT].gain,
798 gpadc->cal_data[ADC_INPUT_IBAT].offset);
799 } else {
800 /* Calculate gain and offset for VMAIN if all reads succeeded */
801 if (!(ret[0] < 0 || ret[1] < 0 || ret[2] < 0)) {
802 vmain_high = (((gpadc_cal[0] & 0x03) << 8) |
803 ((gpadc_cal[1] & 0x3F) << 2) |
804 ((gpadc_cal[2] & 0xC0) >> 6));
805 vmain_low = ((gpadc_cal[2] & 0x3E) >> 1);
806
Lee Jonesbc6b4132013-02-26 14:02:31 +0000807 gpadc->cal_data[ADC_INPUT_VMAIN].otp_calib_hi =
808 (u16)vmain_high;
809 gpadc->cal_data[ADC_INPUT_VMAIN].otp_calib_lo =
810 (u16)vmain_low;
811
Lee Jonese4bffe82013-02-11 10:38:00 +0000812 gpadc->cal_data[ADC_INPUT_VMAIN].gain = CALIB_SCALE *
813 (19500 - 315) / (vmain_high - vmain_low);
814
815 gpadc->cal_data[ADC_INPUT_VMAIN].offset = CALIB_SCALE *
816 19500 - (CALIB_SCALE * (19500 - 315) /
817 (vmain_high - vmain_low)) * vmain_high;
818 } else {
819 gpadc->cal_data[ADC_INPUT_VMAIN].gain = 0;
820 }
Johan Palsson586f3312011-03-05 11:46:37 +0100821 }
822
823 /* Calculate gain and offset for BTEMP if all reads succeeded */
824 if (!(ret[2] < 0 || ret[3] < 0 || ret[4] < 0)) {
825 btemp_high = (((gpadc_cal[2] & 0x01) << 9) |
Lee Jonese4bffe82013-02-11 10:38:00 +0000826 (gpadc_cal[3] << 1) | ((gpadc_cal[4] & 0x80) >> 7));
Johan Palsson586f3312011-03-05 11:46:37 +0100827 btemp_low = ((gpadc_cal[4] & 0x7C) >> 2);
828
Lee Jonesbc6b4132013-02-26 14:02:31 +0000829 gpadc->cal_data[ADC_INPUT_BTEMP].otp_calib_hi = (u16)btemp_high;
830 gpadc->cal_data[ADC_INPUT_BTEMP].otp_calib_lo = (u16)btemp_low;
831
Johan Palsson586f3312011-03-05 11:46:37 +0100832 gpadc->cal_data[ADC_INPUT_BTEMP].gain =
833 CALIB_SCALE * (1300 - 21) / (btemp_high - btemp_low);
Johan Palsson586f3312011-03-05 11:46:37 +0100834 gpadc->cal_data[ADC_INPUT_BTEMP].offset = CALIB_SCALE * 1300 -
Lee Jonese4bffe82013-02-11 10:38:00 +0000835 (CALIB_SCALE * (1300 - 21) / (btemp_high - btemp_low))
836 * btemp_high;
Johan Palsson586f3312011-03-05 11:46:37 +0100837 } else {
838 gpadc->cal_data[ADC_INPUT_BTEMP].gain = 0;
839 }
840
841 /* Calculate gain and offset for VBAT if all reads succeeded */
842 if (!(ret[4] < 0 || ret[5] < 0 || ret[6] < 0)) {
843 vbat_high = (((gpadc_cal[4] & 0x03) << 8) | gpadc_cal[5]);
844 vbat_low = ((gpadc_cal[6] & 0xFC) >> 2);
845
Lee Jonesbc6b4132013-02-26 14:02:31 +0000846 gpadc->cal_data[ADC_INPUT_VBAT].otp_calib_hi = (u16)vbat_high;
847 gpadc->cal_data[ADC_INPUT_VBAT].otp_calib_lo = (u16)vbat_low;
848
Johan Palsson586f3312011-03-05 11:46:37 +0100849 gpadc->cal_data[ADC_INPUT_VBAT].gain = CALIB_SCALE *
850 (4700 - 2380) / (vbat_high - vbat_low);
Johan Palsson586f3312011-03-05 11:46:37 +0100851 gpadc->cal_data[ADC_INPUT_VBAT].offset = CALIB_SCALE * 4700 -
852 (CALIB_SCALE * (4700 - 2380) /
853 (vbat_high - vbat_low)) * vbat_high;
854 } else {
855 gpadc->cal_data[ADC_INPUT_VBAT].gain = 0;
856 }
857
858 dev_dbg(gpadc->dev, "VMAIN gain %llu offset %llu\n",
859 gpadc->cal_data[ADC_INPUT_VMAIN].gain,
860 gpadc->cal_data[ADC_INPUT_VMAIN].offset);
861
862 dev_dbg(gpadc->dev, "BTEMP gain %llu offset %llu\n",
863 gpadc->cal_data[ADC_INPUT_BTEMP].gain,
864 gpadc->cal_data[ADC_INPUT_BTEMP].offset);
865
866 dev_dbg(gpadc->dev, "VBAT gain %llu offset %llu\n",
867 gpadc->cal_data[ADC_INPUT_VBAT].gain,
868 gpadc->cal_data[ADC_INPUT_VBAT].offset);
869}
870
Rafael J. Wysocki48bb9fe2014-12-05 03:04:12 +0100871#ifdef CONFIG_PM
Lee Jones5f8aaef2013-02-04 08:33:13 +0000872static int ab8500_gpadc_runtime_suspend(struct device *dev)
873{
874 struct ab8500_gpadc *gpadc = dev_get_drvdata(dev);
875
876 regulator_disable(gpadc->regu);
877 return 0;
878}
879
880static int ab8500_gpadc_runtime_resume(struct device *dev)
881{
882 struct ab8500_gpadc *gpadc = dev_get_drvdata(dev);
Axel Lin54fc4032013-03-09 17:46:45 +0800883 int ret;
Lee Jones5f8aaef2013-02-04 08:33:13 +0000884
Axel Lin54fc4032013-03-09 17:46:45 +0800885 ret = regulator_enable(gpadc->regu);
886 if (ret)
887 dev_err(dev, "Failed to enable vtvout LDO: %d\n", ret);
888 return ret;
Lee Jones5f8aaef2013-02-04 08:33:13 +0000889}
Jingoo Hanf28d7ed2013-08-02 14:20:51 +0900890#endif
Lee Jones5f8aaef2013-02-04 08:33:13 +0000891
Jingoo Hane0e2e6e2013-08-02 14:21:26 +0900892#ifdef CONFIG_PM_SLEEP
Daniel WILLERUD774c50a2012-04-12 08:15:05 +0200893static int ab8500_gpadc_suspend(struct device *dev)
894{
895 struct ab8500_gpadc *gpadc = dev_get_drvdata(dev);
896
897 mutex_lock(&gpadc->ab8500_gpadc_lock);
898
899 pm_runtime_get_sync(dev);
900
901 regulator_disable(gpadc->regu);
902 return 0;
903}
904
905static int ab8500_gpadc_resume(struct device *dev)
906{
907 struct ab8500_gpadc *gpadc = dev_get_drvdata(dev);
Lee Jones33a0d192013-05-02 15:46:34 +0100908 int ret;
Daniel WILLERUD774c50a2012-04-12 08:15:05 +0200909
Lee Jones33a0d192013-05-02 15:46:34 +0100910 ret = regulator_enable(gpadc->regu);
911 if (ret)
912 dev_err(dev, "Failed to enable vtvout LDO: %d\n", ret);
Daniel WILLERUD774c50a2012-04-12 08:15:05 +0200913
914 pm_runtime_mark_last_busy(gpadc->dev);
915 pm_runtime_put_autosuspend(gpadc->dev);
916
917 mutex_unlock(&gpadc->ab8500_gpadc_lock);
Lee Jones33a0d192013-05-02 15:46:34 +0100918 return ret;
Daniel WILLERUD774c50a2012-04-12 08:15:05 +0200919}
Jingoo Hane0e2e6e2013-08-02 14:21:26 +0900920#endif
Daniel WILLERUD774c50a2012-04-12 08:15:05 +0200921
Bill Pembertonf791be42012-11-19 13:23:04 -0500922static int ab8500_gpadc_probe(struct platform_device *pdev)
Arun Murthydae2db32011-02-22 10:11:13 +0100923{
924 int ret = 0;
925 struct ab8500_gpadc *gpadc;
926
Lee Jonesdf364422015-10-28 10:32:10 +0000927 gpadc = devm_kzalloc(&pdev->dev,
928 sizeof(struct ab8500_gpadc), GFP_KERNEL);
929 if (!gpadc)
Arun Murthydae2db32011-02-22 10:11:13 +0100930 return -ENOMEM;
Arun Murthydae2db32011-02-22 10:11:13 +0100931
Lee Jones73482342013-02-26 10:06:55 +0000932 gpadc->irq_sw = platform_get_irq_byname(pdev, "SW_CONV_END");
Lee Jonesc0eda9a2013-02-12 15:04:09 +0000933 if (gpadc->irq_sw < 0)
934 dev_err(gpadc->dev, "failed to get platform sw_conv_end irq\n");
Lee Jones73482342013-02-26 10:06:55 +0000935
936 gpadc->irq_hw = platform_get_irq_byname(pdev, "HW_CONV_END");
Lee Jonesc0eda9a2013-02-12 15:04:09 +0000937 if (gpadc->irq_hw < 0)
938 dev_err(gpadc->dev, "failed to get platform hw_conv_end irq\n");
Arun Murthydae2db32011-02-22 10:11:13 +0100939
940 gpadc->dev = &pdev->dev;
Michel JAOUEN20bf4282012-02-09 12:06:47 +0100941 gpadc->parent = dev_get_drvdata(pdev->dev.parent);
Daniel Willerud63219922011-03-05 11:46:13 +0100942 mutex_init(&gpadc->ab8500_gpadc_lock);
Arun Murthydae2db32011-02-22 10:11:13 +0100943
944 /* Initialize completion used to notify completion of conversion */
945 init_completion(&gpadc->ab8500_gpadc_complete);
946
Lee Jones73482342013-02-26 10:06:55 +0000947 /* Register interrupts */
Lee Jonesc0eda9a2013-02-12 15:04:09 +0000948 if (gpadc->irq_sw >= 0) {
949 ret = request_threaded_irq(gpadc->irq_sw, NULL,
950 ab8500_bm_gpadcconvend_handler,
Fabio Estevame7d8ae32015-05-16 15:42:16 -0300951 IRQF_NO_SUSPEND | IRQF_SHARED | IRQF_ONESHOT,
952 "ab8500-gpadc-sw",
Lee Jonesc0eda9a2013-02-12 15:04:09 +0000953 gpadc);
954 if (ret < 0) {
955 dev_err(gpadc->dev,
956 "Failed to register interrupt irq: %d\n",
957 gpadc->irq_sw);
958 goto fail;
959 }
Lee Jones73482342013-02-26 10:06:55 +0000960 }
Lee Jonesc0eda9a2013-02-12 15:04:09 +0000961
962 if (gpadc->irq_hw >= 0) {
963 ret = request_threaded_irq(gpadc->irq_hw, NULL,
964 ab8500_bm_gpadcconvend_handler,
Fabio Estevame7d8ae32015-05-16 15:42:16 -0300965 IRQF_NO_SUSPEND | IRQF_SHARED | IRQF_ONESHOT,
966 "ab8500-gpadc-hw",
Lee Jonesc0eda9a2013-02-12 15:04:09 +0000967 gpadc);
968 if (ret < 0) {
969 dev_err(gpadc->dev,
970 "Failed to register interrupt irq: %d\n",
971 gpadc->irq_hw);
972 goto fail_irq;
973 }
Arun Murthydae2db32011-02-22 10:11:13 +0100974 }
975
976 /* VTVout LDO used to power up ab8500-GPADC */
Axel Lin54fc4032013-03-09 17:46:45 +0800977 gpadc->regu = devm_regulator_get(&pdev->dev, "vddadc");
Arun Murthydae2db32011-02-22 10:11:13 +0100978 if (IS_ERR(gpadc->regu)) {
979 ret = PTR_ERR(gpadc->regu);
980 dev_err(gpadc->dev, "failed to get vtvout LDO\n");
Daniel Willerud633e0fa2011-03-05 11:46:27 +0100981 goto fail_irq;
Arun Murthydae2db32011-02-22 10:11:13 +0100982 }
Lee Jones5f8aaef2013-02-04 08:33:13 +0000983
984 platform_set_drvdata(pdev, gpadc);
985
Axel Lin54fc4032013-03-09 17:46:45 +0800986 ret = regulator_enable(gpadc->regu);
987 if (ret) {
988 dev_err(gpadc->dev, "Failed to enable vtvout LDO: %d\n", ret);
989 goto fail_enable;
990 }
Lee Jones5f8aaef2013-02-04 08:33:13 +0000991
992 pm_runtime_set_autosuspend_delay(gpadc->dev, GPADC_AUDOSUSPEND_DELAY);
993 pm_runtime_use_autosuspend(gpadc->dev);
994 pm_runtime_set_active(gpadc->dev);
995 pm_runtime_enable(gpadc->dev);
996
Johan Palsson586f3312011-03-05 11:46:37 +0100997 ab8500_gpadc_read_calibration_data(gpadc);
Daniel Willerud63219922011-03-05 11:46:13 +0100998 list_add_tail(&gpadc->node, &ab8500_gpadc_list);
Arun Murthydae2db32011-02-22 10:11:13 +0100999 dev_dbg(gpadc->dev, "probe success\n");
Lee Jonesc0eda9a2013-02-12 15:04:09 +00001000
Arun Murthydae2db32011-02-22 10:11:13 +01001001 return 0;
Axel Lin54fc4032013-03-09 17:46:45 +08001002
1003fail_enable:
Daniel Willerud633e0fa2011-03-05 11:46:27 +01001004fail_irq:
Lee Jones73482342013-02-26 10:06:55 +00001005 free_irq(gpadc->irq_sw, gpadc);
1006 free_irq(gpadc->irq_hw, gpadc);
Arun Murthydae2db32011-02-22 10:11:13 +01001007fail:
Arun Murthydae2db32011-02-22 10:11:13 +01001008 return ret;
1009}
1010
Bill Pemberton4740f732012-11-19 13:26:01 -05001011static int ab8500_gpadc_remove(struct platform_device *pdev)
Arun Murthydae2db32011-02-22 10:11:13 +01001012{
1013 struct ab8500_gpadc *gpadc = platform_get_drvdata(pdev);
1014
Daniel Willerud63219922011-03-05 11:46:13 +01001015 /* remove this gpadc entry from the list */
1016 list_del(&gpadc->node);
Arun Murthydae2db32011-02-22 10:11:13 +01001017 /* remove interrupt - completion of Sw ADC conversion */
Lee Jonesc0eda9a2013-02-12 15:04:09 +00001018 if (gpadc->irq_sw >= 0)
1019 free_irq(gpadc->irq_sw, gpadc);
1020 if (gpadc->irq_hw >= 0)
1021 free_irq(gpadc->irq_hw, gpadc);
Lee Jones5f8aaef2013-02-04 08:33:13 +00001022
1023 pm_runtime_get_sync(gpadc->dev);
1024 pm_runtime_disable(gpadc->dev);
1025
1026 regulator_disable(gpadc->regu);
1027
1028 pm_runtime_set_suspended(gpadc->dev);
1029
1030 pm_runtime_put_noidle(gpadc->dev);
1031
Arun Murthydae2db32011-02-22 10:11:13 +01001032 return 0;
1033}
1034
Lee Jones5f8aaef2013-02-04 08:33:13 +00001035static const struct dev_pm_ops ab8500_gpadc_pm_ops = {
1036 SET_RUNTIME_PM_OPS(ab8500_gpadc_runtime_suspend,
1037 ab8500_gpadc_runtime_resume,
Rafael J. Wysocki45f0a852013-06-03 21:49:52 +02001038 NULL)
Daniel WILLERUD774c50a2012-04-12 08:15:05 +02001039 SET_SYSTEM_SLEEP_PM_OPS(ab8500_gpadc_suspend,
1040 ab8500_gpadc_resume)
1041
Lee Jones5f8aaef2013-02-04 08:33:13 +00001042};
1043
Arun Murthydae2db32011-02-22 10:11:13 +01001044static struct platform_driver ab8500_gpadc_driver = {
1045 .probe = ab8500_gpadc_probe,
Bill Pemberton84449212012-11-19 13:20:24 -05001046 .remove = ab8500_gpadc_remove,
Arun Murthydae2db32011-02-22 10:11:13 +01001047 .driver = {
1048 .name = "ab8500-gpadc",
Lee Jones5f8aaef2013-02-04 08:33:13 +00001049 .pm = &ab8500_gpadc_pm_ops,
Arun Murthydae2db32011-02-22 10:11:13 +01001050 },
1051};
1052
1053static int __init ab8500_gpadc_init(void)
1054{
1055 return platform_driver_register(&ab8500_gpadc_driver);
1056}
Paul Gortmaker1d57c392016-10-29 21:24:38 -04001057subsys_initcall_sync(ab8500_gpadc_init);
Arun Murthydae2db32011-02-22 10:11:13 +01001058
Lee Jonesbc6b4132013-02-26 14:02:31 +00001059/**
1060 * ab8540_gpadc_get_otp() - returns OTP values
1061 *
1062 */
1063void ab8540_gpadc_get_otp(struct ab8500_gpadc *gpadc,
1064 u16 *vmain_l, u16 *vmain_h, u16 *btemp_l, u16 *btemp_h,
1065 u16 *vbat_l, u16 *vbat_h, u16 *ibat_l, u16 *ibat_h)
1066{
1067 *vmain_l = gpadc->cal_data[ADC_INPUT_VMAIN].otp_calib_lo;
1068 *vmain_h = gpadc->cal_data[ADC_INPUT_VMAIN].otp_calib_hi;
1069 *btemp_l = gpadc->cal_data[ADC_INPUT_BTEMP].otp_calib_lo;
1070 *btemp_h = gpadc->cal_data[ADC_INPUT_BTEMP].otp_calib_hi;
Lee Jonesdf364422015-10-28 10:32:10 +00001071 *vbat_l = gpadc->cal_data[ADC_INPUT_VBAT].otp_calib_lo;
1072 *vbat_h = gpadc->cal_data[ADC_INPUT_VBAT].otp_calib_hi;
1073 *ibat_l = gpadc->cal_data[ADC_INPUT_IBAT].otp_calib_lo;
1074 *ibat_h = gpadc->cal_data[ADC_INPUT_IBAT].otp_calib_hi;
Lee Jonesbc6b4132013-02-26 14:02:31 +00001075}