config: tegra3: enable /dev mount with ACL
[linux-2.6.git] / drivers / mfd / ab8500-gpadc.c
1 /*
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>
6  * Author: Daniel Willerud <daniel.willerud@stericsson.com>
7  * Author: Johan Palsson <johan.palsson@stericsson.com>
8  */
9 #include <linux/init.h>
10 #include <linux/module.h>
11 #include <linux/device.h>
12 #include <linux/interrupt.h>
13 #include <linux/spinlock.h>
14 #include <linux/delay.h>
15 #include <linux/platform_device.h>
16 #include <linux/completion.h>
17 #include <linux/regulator/consumer.h>
18 #include <linux/err.h>
19 #include <linux/slab.h>
20 #include <linux/list.h>
21 #include <linux/mfd/ab8500.h>
22 #include <linux/mfd/abx500.h>
23 #include <linux/mfd/ab8500/gpadc.h>
24
25 /*
26  * GPADC register offsets
27  * Bank : 0x0A
28  */
29 #define AB8500_GPADC_CTRL1_REG          0x00
30 #define AB8500_GPADC_CTRL2_REG          0x01
31 #define AB8500_GPADC_CTRL3_REG          0x02
32 #define AB8500_GPADC_AUTO_TIMER_REG     0x03
33 #define AB8500_GPADC_STAT_REG           0x04
34 #define AB8500_GPADC_MANDATAL_REG       0x05
35 #define AB8500_GPADC_MANDATAH_REG       0x06
36 #define AB8500_GPADC_AUTODATAL_REG      0x07
37 #define AB8500_GPADC_AUTODATAH_REG      0x08
38 #define AB8500_GPADC_MUX_CTRL_REG       0x09
39
40 /*
41  * OTP register offsets
42  * Bank : 0x15
43  */
44 #define AB8500_GPADC_CAL_1              0x0F
45 #define AB8500_GPADC_CAL_2              0x10
46 #define AB8500_GPADC_CAL_3              0x11
47 #define AB8500_GPADC_CAL_4              0x12
48 #define AB8500_GPADC_CAL_5              0x13
49 #define AB8500_GPADC_CAL_6              0x14
50 #define AB8500_GPADC_CAL_7              0x15
51
52 /* gpadc constants */
53 #define EN_VINTCORE12                   0x04
54 #define EN_VTVOUT                       0x02
55 #define EN_GPADC                        0x01
56 #define DIS_GPADC                       0x00
57 #define SW_AVG_16                       0x60
58 #define ADC_SW_CONV                     0x04
59 #define EN_ICHAR                        0x80
60 #define BTEMP_PULL_UP                   0x08
61 #define EN_BUF                          0x40
62 #define DIS_ZERO                        0x00
63 #define GPADC_BUSY                      0x01
64
65 /* GPADC constants from AB8500 spec, UM0836 */
66 #define ADC_RESOLUTION                  1024
67 #define ADC_CH_BTEMP_MIN                0
68 #define ADC_CH_BTEMP_MAX                1350
69 #define ADC_CH_DIETEMP_MIN              0
70 #define ADC_CH_DIETEMP_MAX              1350
71 #define ADC_CH_CHG_V_MIN                0
72 #define ADC_CH_CHG_V_MAX                20030
73 #define ADC_CH_ACCDET2_MIN              0
74 #define ADC_CH_ACCDET2_MAX              2500
75 #define ADC_CH_VBAT_MIN                 2300
76 #define ADC_CH_VBAT_MAX                 4800
77 #define ADC_CH_CHG_I_MIN                0
78 #define ADC_CH_CHG_I_MAX                1500
79 #define ADC_CH_BKBAT_MIN                0
80 #define ADC_CH_BKBAT_MAX                3200
81
82 /* This is used to not lose precision when dividing to get gain and offset */
83 #define CALIB_SCALE                     1000
84
85 enum cal_channels {
86         ADC_INPUT_VMAIN = 0,
87         ADC_INPUT_BTEMP,
88         ADC_INPUT_VBAT,
89         NBR_CAL_INPUTS,
90 };
91
92 /**
93  * struct adc_cal_data - Table for storing gain and offset for the calibrated
94  * ADC channels
95  * @gain:               Gain of the ADC channel
96  * @offset:             Offset of the ADC channel
97  */
98 struct adc_cal_data {
99         u64 gain;
100         u64 offset;
101 };
102
103 /**
104  * struct ab8500_gpadc - AB8500 GPADC device information
105  * @chip_id                     ABB chip id
106  * @dev:                        pointer to the struct device
107  * @node:                       a list of AB8500 GPADCs, hence prepared for
108                                 reentrance
109  * @ab8500_gpadc_complete:      pointer to the struct completion, to indicate
110  *                              the completion of gpadc conversion
111  * @ab8500_gpadc_lock:          structure of type mutex
112  * @regu:                       pointer to the struct regulator
113  * @irq:                        interrupt number that is used by gpadc
114  * @cal_data                    array of ADC calibration data structs
115  */
116 struct ab8500_gpadc {
117         u8 chip_id;
118         struct device *dev;
119         struct list_head node;
120         struct completion ab8500_gpadc_complete;
121         struct mutex ab8500_gpadc_lock;
122         struct regulator *regu;
123         int irq;
124         struct adc_cal_data cal_data[NBR_CAL_INPUTS];
125 };
126
127 static LIST_HEAD(ab8500_gpadc_list);
128
129 /**
130  * ab8500_gpadc_get() - returns a reference to the primary AB8500 GPADC
131  * (i.e. the first GPADC in the instance list)
132  */
133 struct ab8500_gpadc *ab8500_gpadc_get(char *name)
134 {
135         struct ab8500_gpadc *gpadc;
136
137         list_for_each_entry(gpadc, &ab8500_gpadc_list, node) {
138                 if (!strcmp(name, dev_name(gpadc->dev)))
139                     return gpadc;
140         }
141
142         return ERR_PTR(-ENOENT);
143 }
144 EXPORT_SYMBOL(ab8500_gpadc_get);
145
146 static int ab8500_gpadc_ad_to_voltage(struct ab8500_gpadc *gpadc, u8 input,
147         int ad_value)
148 {
149         int res;
150
151         switch (input) {
152         case MAIN_CHARGER_V:
153                 /* For some reason we don't have calibrated data */
154                 if (!gpadc->cal_data[ADC_INPUT_VMAIN].gain) {
155                         res = ADC_CH_CHG_V_MIN + (ADC_CH_CHG_V_MAX -
156                                 ADC_CH_CHG_V_MIN) * ad_value /
157                                 ADC_RESOLUTION;
158                         break;
159                 }
160                 /* Here we can use the calibrated data */
161                 res = (int) (ad_value * gpadc->cal_data[ADC_INPUT_VMAIN].gain +
162                         gpadc->cal_data[ADC_INPUT_VMAIN].offset) / CALIB_SCALE;
163                 break;
164
165         case BAT_CTRL:
166         case BTEMP_BALL:
167         case ACC_DETECT1:
168         case ADC_AUX1:
169         case ADC_AUX2:
170                 /* For some reason we don't have calibrated data */
171                 if (!gpadc->cal_data[ADC_INPUT_BTEMP].gain) {
172                         res = ADC_CH_BTEMP_MIN + (ADC_CH_BTEMP_MAX -
173                                 ADC_CH_BTEMP_MIN) * ad_value /
174                                 ADC_RESOLUTION;
175                         break;
176                 }
177                 /* Here we can use the calibrated data */
178                 res = (int) (ad_value * gpadc->cal_data[ADC_INPUT_BTEMP].gain +
179                         gpadc->cal_data[ADC_INPUT_BTEMP].offset) / CALIB_SCALE;
180                 break;
181
182         case MAIN_BAT_V:
183                 /* For some reason we don't have calibrated data */
184                 if (!gpadc->cal_data[ADC_INPUT_VBAT].gain) {
185                         res = ADC_CH_VBAT_MIN + (ADC_CH_VBAT_MAX -
186                                 ADC_CH_VBAT_MIN) * ad_value /
187                                 ADC_RESOLUTION;
188                         break;
189                 }
190                 /* Here we can use the calibrated data */
191                 res = (int) (ad_value * gpadc->cal_data[ADC_INPUT_VBAT].gain +
192                         gpadc->cal_data[ADC_INPUT_VBAT].offset) / CALIB_SCALE;
193                 break;
194
195         case DIE_TEMP:
196                 res = ADC_CH_DIETEMP_MIN +
197                         (ADC_CH_DIETEMP_MAX - ADC_CH_DIETEMP_MIN) * ad_value /
198                         ADC_RESOLUTION;
199                 break;
200
201         case ACC_DETECT2:
202                 res = ADC_CH_ACCDET2_MIN +
203                         (ADC_CH_ACCDET2_MAX - ADC_CH_ACCDET2_MIN) * ad_value /
204                         ADC_RESOLUTION;
205                 break;
206
207         case VBUS_V:
208                 res = ADC_CH_CHG_V_MIN +
209                         (ADC_CH_CHG_V_MAX - ADC_CH_CHG_V_MIN) * ad_value /
210                         ADC_RESOLUTION;
211                 break;
212
213         case MAIN_CHARGER_C:
214         case USB_CHARGER_C:
215                 res = ADC_CH_CHG_I_MIN +
216                         (ADC_CH_CHG_I_MAX - ADC_CH_CHG_I_MIN) * ad_value /
217                         ADC_RESOLUTION;
218                 break;
219
220         case BK_BAT_V:
221                 res = ADC_CH_BKBAT_MIN +
222                         (ADC_CH_BKBAT_MAX - ADC_CH_BKBAT_MIN) * ad_value /
223                         ADC_RESOLUTION;
224                 break;
225
226         default:
227                 dev_err(gpadc->dev,
228                         "unknown channel, not possible to convert\n");
229                 res = -EINVAL;
230                 break;
231
232         }
233         return res;
234 }
235
236 /**
237  * ab8500_gpadc_convert() - gpadc conversion
238  * @input:      analog input to be converted to digital data
239  *
240  * This function converts the selected analog i/p to digital
241  * data.
242  */
243 int ab8500_gpadc_convert(struct ab8500_gpadc *gpadc, u8 input)
244 {
245         int ret;
246         u16 data = 0;
247         int looplimit = 0;
248         u8 val, low_data, high_data;
249
250         if (!gpadc)
251                 return -ENODEV;
252
253         mutex_lock(&gpadc->ab8500_gpadc_lock);
254         /* Enable VTVout LDO this is required for GPADC */
255         regulator_enable(gpadc->regu);
256
257         /* Check if ADC is not busy, lock and proceed */
258         do {
259                 ret = abx500_get_register_interruptible(gpadc->dev,
260                         AB8500_GPADC, AB8500_GPADC_STAT_REG, &val);
261                 if (ret < 0)
262                         goto out;
263                 if (!(val & GPADC_BUSY))
264                         break;
265                 msleep(10);
266         } while (++looplimit < 10);
267         if (looplimit >= 10 && (val & GPADC_BUSY)) {
268                 dev_err(gpadc->dev, "gpadc_conversion: GPADC busy");
269                 ret = -EINVAL;
270                 goto out;
271         }
272
273         /* Enable GPADC */
274         ret = abx500_mask_and_set_register_interruptible(gpadc->dev,
275                 AB8500_GPADC, AB8500_GPADC_CTRL1_REG, EN_GPADC, EN_GPADC);
276         if (ret < 0) {
277                 dev_err(gpadc->dev, "gpadc_conversion: enable gpadc failed\n");
278                 goto out;
279         }
280
281         /* Select the input source and set average samples to 16 */
282         ret = abx500_set_register_interruptible(gpadc->dev, AB8500_GPADC,
283                 AB8500_GPADC_CTRL2_REG, (input | SW_AVG_16));
284         if (ret < 0) {
285                 dev_err(gpadc->dev,
286                         "gpadc_conversion: set avg samples failed\n");
287                 goto out;
288         }
289
290         /*
291          * Enable ADC, buffering, select rising edge and enable ADC path
292          * charging current sense if it needed, ABB 3.0 needs some special
293          * treatment too.
294          */
295         switch (input) {
296         case MAIN_CHARGER_C:
297         case USB_CHARGER_C:
298                 ret = abx500_mask_and_set_register_interruptible(gpadc->dev,
299                         AB8500_GPADC, AB8500_GPADC_CTRL1_REG,
300                         EN_BUF | EN_ICHAR,
301                         EN_BUF | EN_ICHAR);
302                 break;
303         case BTEMP_BALL:
304                 if (gpadc->chip_id >= AB8500_CUT3P0) {
305                         /* Turn on btemp pull-up on ABB 3.0 */
306                         ret = abx500_mask_and_set_register_interruptible(
307                                 gpadc->dev,
308                                 AB8500_GPADC, AB8500_GPADC_CTRL1_REG,
309                                 EN_BUF | BTEMP_PULL_UP,
310                                 EN_BUF | BTEMP_PULL_UP);
311
312                  /*
313                   * Delay might be needed for ABB8500 cut 3.0, if not, remove
314                   * when hardware will be availible
315                   */
316                         msleep(1);
317                         break;
318                 }
319                 /* Intentional fallthrough */
320         default:
321                 ret = abx500_mask_and_set_register_interruptible(gpadc->dev,
322                         AB8500_GPADC, AB8500_GPADC_CTRL1_REG, EN_BUF, EN_BUF);
323                 break;
324         }
325         if (ret < 0) {
326                 dev_err(gpadc->dev,
327                         "gpadc_conversion: select falling edge failed\n");
328                 goto out;
329         }
330
331         ret = abx500_mask_and_set_register_interruptible(gpadc->dev,
332                 AB8500_GPADC, AB8500_GPADC_CTRL1_REG, ADC_SW_CONV, ADC_SW_CONV);
333         if (ret < 0) {
334                 dev_err(gpadc->dev,
335                         "gpadc_conversion: start s/w conversion failed\n");
336                 goto out;
337         }
338         /* wait for completion of conversion */
339         if (!wait_for_completion_timeout(&gpadc->ab8500_gpadc_complete, 2*HZ)) {
340                 dev_err(gpadc->dev,
341                         "timeout: didn't receive GPADC conversion interrupt\n");
342                 ret = -EINVAL;
343                 goto out;
344         }
345
346         /* Read the converted RAW data */
347         ret = abx500_get_register_interruptible(gpadc->dev, AB8500_GPADC,
348                 AB8500_GPADC_MANDATAL_REG, &low_data);
349         if (ret < 0) {
350                 dev_err(gpadc->dev, "gpadc_conversion: read low data failed\n");
351                 goto out;
352         }
353
354         ret = abx500_get_register_interruptible(gpadc->dev, AB8500_GPADC,
355                 AB8500_GPADC_MANDATAH_REG, &high_data);
356         if (ret < 0) {
357                 dev_err(gpadc->dev,
358                         "gpadc_conversion: read high data failed\n");
359                 goto out;
360         }
361
362         data = (high_data << 8) | low_data;
363         /* Disable GPADC */
364         ret = abx500_set_register_interruptible(gpadc->dev, AB8500_GPADC,
365                 AB8500_GPADC_CTRL1_REG, DIS_GPADC);
366         if (ret < 0) {
367                 dev_err(gpadc->dev, "gpadc_conversion: disable gpadc failed\n");
368                 goto out;
369         }
370         /* Disable VTVout LDO this is required for GPADC */
371         regulator_disable(gpadc->regu);
372         mutex_unlock(&gpadc->ab8500_gpadc_lock);
373         ret = ab8500_gpadc_ad_to_voltage(gpadc, input, data);
374         return ret;
375
376 out:
377         /*
378          * It has shown to be needed to turn off the GPADC if an error occurs,
379          * otherwise we might have problem when waiting for the busy bit in the
380          * GPADC status register to go low. In V1.1 there wait_for_completion
381          * seems to timeout when waiting for an interrupt.. Not seen in V2.0
382          */
383         (void) abx500_set_register_interruptible(gpadc->dev, AB8500_GPADC,
384                 AB8500_GPADC_CTRL1_REG, DIS_GPADC);
385         regulator_disable(gpadc->regu);
386         mutex_unlock(&gpadc->ab8500_gpadc_lock);
387         dev_err(gpadc->dev,
388                 "gpadc_conversion: Failed to AD convert channel %d\n", input);
389         return ret;
390 }
391 EXPORT_SYMBOL(ab8500_gpadc_convert);
392
393 /**
394  * ab8500_bm_gpswadcconvend_handler() - isr for s/w gpadc conversion completion
395  * @irq:        irq number
396  * @data:       pointer to the data passed during request irq
397  *
398  * This is a interrupt service routine for s/w gpadc conversion completion.
399  * Notifies the gpadc completion is completed and the converted raw value
400  * can be read from the registers.
401  * Returns IRQ status(IRQ_HANDLED)
402  */
403 static irqreturn_t ab8500_bm_gpswadcconvend_handler(int irq, void *_gpadc)
404 {
405         struct ab8500_gpadc *gpadc = _gpadc;
406
407         complete(&gpadc->ab8500_gpadc_complete);
408
409         return IRQ_HANDLED;
410 }
411
412 static int otp_cal_regs[] = {
413         AB8500_GPADC_CAL_1,
414         AB8500_GPADC_CAL_2,
415         AB8500_GPADC_CAL_3,
416         AB8500_GPADC_CAL_4,
417         AB8500_GPADC_CAL_5,
418         AB8500_GPADC_CAL_6,
419         AB8500_GPADC_CAL_7,
420 };
421
422 static void ab8500_gpadc_read_calibration_data(struct ab8500_gpadc *gpadc)
423 {
424         int i;
425         int ret[ARRAY_SIZE(otp_cal_regs)];
426         u8 gpadc_cal[ARRAY_SIZE(otp_cal_regs)];
427
428         int vmain_high, vmain_low;
429         int btemp_high, btemp_low;
430         int vbat_high, vbat_low;
431
432         /* First we read all OTP registers and store the error code */
433         for (i = 0; i < ARRAY_SIZE(otp_cal_regs); i++) {
434                 ret[i] = abx500_get_register_interruptible(gpadc->dev,
435                         AB8500_OTP_EMUL, otp_cal_regs[i],  &gpadc_cal[i]);
436                 if (ret[i] < 0)
437                         dev_err(gpadc->dev, "%s: read otp reg 0x%02x failed\n",
438                                 __func__, otp_cal_regs[i]);
439         }
440
441         /*
442          * The ADC calibration data is stored in OTP registers.
443          * The layout of the calibration data is outlined below and a more
444          * detailed description can be found in UM0836
445          *
446          * vm_h/l = vmain_high/low
447          * bt_h/l = btemp_high/low
448          * vb_h/l = vbat_high/low
449          *
450          * Data bits:
451          * | 7     | 6     | 5     | 4     | 3     | 2     | 1     | 0
452          * |.......|.......|.......|.......|.......|.......|.......|.......
453          * |                                               | vm_h9 | vm_h8
454          * |.......|.......|.......|.......|.......|.......|.......|.......
455          * |               | vm_h7 | vm_h6 | vm_h5 | vm_h4 | vm_h3 | vm_h2
456          * |.......|.......|.......|.......|.......|.......|.......|.......
457          * | vm_h1 | vm_h0 | vm_l4 | vm_l3 | vm_l2 | vm_l1 | vm_l0 | bt_h9
458          * |.......|.......|.......|.......|.......|.......|.......|.......
459          * | bt_h8 | bt_h7 | bt_h6 | bt_h5 | bt_h4 | bt_h3 | bt_h2 | bt_h1
460          * |.......|.......|.......|.......|.......|.......|.......|.......
461          * | bt_h0 | bt_l4 | bt_l3 | bt_l2 | bt_l1 | bt_l0 | vb_h9 | vb_h8
462          * |.......|.......|.......|.......|.......|.......|.......|.......
463          * | vb_h7 | vb_h6 | vb_h5 | vb_h4 | vb_h3 | vb_h2 | vb_h1 | vb_h0
464          * |.......|.......|.......|.......|.......|.......|.......|.......
465          * | vb_l5 | vb_l4 | vb_l3 | vb_l2 | vb_l1 | vb_l0 |
466          * |.......|.......|.......|.......|.......|.......|.......|.......
467          *
468          *
469          * Ideal output ADC codes corresponding to injected input voltages
470          * during manufacturing is:
471          *
472          * vmain_high: Vin = 19500mV / ADC ideal code = 997
473          * vmain_low:  Vin = 315mV   / ADC ideal code = 16
474          * btemp_high: Vin = 1300mV  / ADC ideal code = 985
475          * btemp_low:  Vin = 21mV    / ADC ideal code = 16
476          * vbat_high:  Vin = 4700mV  / ADC ideal code = 982
477          * vbat_low:   Vin = 2380mV  / ADC ideal code = 33
478          */
479
480         /* Calculate gain and offset for VMAIN if all reads succeeded */
481         if (!(ret[0] < 0 || ret[1] < 0 || ret[2] < 0)) {
482                 vmain_high = (((gpadc_cal[0] & 0x03) << 8) |
483                         ((gpadc_cal[1] & 0x3F) << 2) |
484                         ((gpadc_cal[2] & 0xC0) >> 6));
485
486                 vmain_low = ((gpadc_cal[2] & 0x3E) >> 1);
487
488                 gpadc->cal_data[ADC_INPUT_VMAIN].gain = CALIB_SCALE *
489                         (19500 - 315) / (vmain_high - vmain_low);
490
491                 gpadc->cal_data[ADC_INPUT_VMAIN].offset = CALIB_SCALE * 19500 -
492                         (CALIB_SCALE * (19500 - 315) /
493                          (vmain_high - vmain_low)) * vmain_high;
494         } else {
495                 gpadc->cal_data[ADC_INPUT_VMAIN].gain = 0;
496         }
497
498         /* Calculate gain and offset for BTEMP if all reads succeeded */
499         if (!(ret[2] < 0 || ret[3] < 0 || ret[4] < 0)) {
500                 btemp_high = (((gpadc_cal[2] & 0x01) << 9) |
501                         (gpadc_cal[3] << 1) |
502                         ((gpadc_cal[4] & 0x80) >> 7));
503
504                 btemp_low = ((gpadc_cal[4] & 0x7C) >> 2);
505
506                 gpadc->cal_data[ADC_INPUT_BTEMP].gain =
507                         CALIB_SCALE * (1300 - 21) / (btemp_high - btemp_low);
508
509                 gpadc->cal_data[ADC_INPUT_BTEMP].offset = CALIB_SCALE * 1300 -
510                         (CALIB_SCALE * (1300 - 21) /
511                         (btemp_high - btemp_low)) * btemp_high;
512         } else {
513                 gpadc->cal_data[ADC_INPUT_BTEMP].gain = 0;
514         }
515
516         /* Calculate gain and offset for VBAT if all reads succeeded */
517         if (!(ret[4] < 0 || ret[5] < 0 || ret[6] < 0)) {
518                 vbat_high = (((gpadc_cal[4] & 0x03) << 8) | gpadc_cal[5]);
519                 vbat_low = ((gpadc_cal[6] & 0xFC) >> 2);
520
521                 gpadc->cal_data[ADC_INPUT_VBAT].gain = CALIB_SCALE *
522                         (4700 - 2380) / (vbat_high - vbat_low);
523
524                 gpadc->cal_data[ADC_INPUT_VBAT].offset = CALIB_SCALE * 4700 -
525                         (CALIB_SCALE * (4700 - 2380) /
526                         (vbat_high - vbat_low)) * vbat_high;
527         } else {
528                 gpadc->cal_data[ADC_INPUT_VBAT].gain = 0;
529         }
530
531         dev_dbg(gpadc->dev, "VMAIN gain %llu offset %llu\n",
532                 gpadc->cal_data[ADC_INPUT_VMAIN].gain,
533                 gpadc->cal_data[ADC_INPUT_VMAIN].offset);
534
535         dev_dbg(gpadc->dev, "BTEMP gain %llu offset %llu\n",
536                 gpadc->cal_data[ADC_INPUT_BTEMP].gain,
537                 gpadc->cal_data[ADC_INPUT_BTEMP].offset);
538
539         dev_dbg(gpadc->dev, "VBAT gain %llu offset %llu\n",
540                 gpadc->cal_data[ADC_INPUT_VBAT].gain,
541                 gpadc->cal_data[ADC_INPUT_VBAT].offset);
542 }
543
544 static int __devinit ab8500_gpadc_probe(struct platform_device *pdev)
545 {
546         int ret = 0;
547         struct ab8500_gpadc *gpadc;
548
549         gpadc = kzalloc(sizeof(struct ab8500_gpadc), GFP_KERNEL);
550         if (!gpadc) {
551                 dev_err(&pdev->dev, "Error: No memory\n");
552                 return -ENOMEM;
553         }
554
555         gpadc->irq = platform_get_irq_byname(pdev, "SW_CONV_END");
556         if (gpadc->irq < 0) {
557                 dev_err(gpadc->dev, "failed to get platform irq-%d\n",
558                         gpadc->irq);
559                 ret = gpadc->irq;
560                 goto fail;
561         }
562
563         gpadc->dev = &pdev->dev;
564         mutex_init(&gpadc->ab8500_gpadc_lock);
565
566         /* Initialize completion used to notify completion of conversion */
567         init_completion(&gpadc->ab8500_gpadc_complete);
568
569         /* Register interrupt  - SwAdcComplete */
570         ret = request_threaded_irq(gpadc->irq, NULL,
571                 ab8500_bm_gpswadcconvend_handler,
572                 IRQF_NO_SUSPEND | IRQF_SHARED, "ab8500-gpadc", gpadc);
573         if (ret < 0) {
574                 dev_err(gpadc->dev, "Failed to register interrupt, irq: %d\n",
575                         gpadc->irq);
576                 goto fail;
577         }
578
579         /* Get Chip ID of the ABB ASIC  */
580         ret = abx500_get_chip_id(gpadc->dev);
581         if (ret < 0) {
582                 dev_err(gpadc->dev, "failed to get chip ID\n");
583                 goto fail_irq;
584         }
585         gpadc->chip_id = (u8) ret;
586
587         /* VTVout LDO used to power up ab8500-GPADC */
588         gpadc->regu = regulator_get(&pdev->dev, "vddadc");
589         if (IS_ERR(gpadc->regu)) {
590                 ret = PTR_ERR(gpadc->regu);
591                 dev_err(gpadc->dev, "failed to get vtvout LDO\n");
592                 goto fail_irq;
593         }
594         ab8500_gpadc_read_calibration_data(gpadc);
595         list_add_tail(&gpadc->node, &ab8500_gpadc_list);
596         dev_dbg(gpadc->dev, "probe success\n");
597         return 0;
598 fail_irq:
599         free_irq(gpadc->irq, gpadc);
600 fail:
601         kfree(gpadc);
602         gpadc = NULL;
603         return ret;
604 }
605
606 static int __devexit ab8500_gpadc_remove(struct platform_device *pdev)
607 {
608         struct ab8500_gpadc *gpadc = platform_get_drvdata(pdev);
609
610         /* remove this gpadc entry from the list */
611         list_del(&gpadc->node);
612         /* remove interrupt  - completion of Sw ADC conversion */
613         free_irq(gpadc->irq, gpadc);
614         /* disable VTVout LDO that is being used by GPADC */
615         regulator_put(gpadc->regu);
616         kfree(gpadc);
617         gpadc = NULL;
618         return 0;
619 }
620
621 static struct platform_driver ab8500_gpadc_driver = {
622         .probe = ab8500_gpadc_probe,
623         .remove = __devexit_p(ab8500_gpadc_remove),
624         .driver = {
625                 .name = "ab8500-gpadc",
626                 .owner = THIS_MODULE,
627         },
628 };
629
630 static int __init ab8500_gpadc_init(void)
631 {
632         return platform_driver_register(&ab8500_gpadc_driver);
633 }
634
635 static void __exit ab8500_gpadc_exit(void)
636 {
637         platform_driver_unregister(&ab8500_gpadc_driver);
638 }
639
640 subsys_initcall_sync(ab8500_gpadc_init);
641 module_exit(ab8500_gpadc_exit);
642
643 MODULE_LICENSE("GPL v2");
644 MODULE_AUTHOR("Arun R Murthy, Daniel Willerud, Johan Palsson");
645 MODULE_ALIAS("platform:ab8500_gpadc");
646 MODULE_DESCRIPTION("AB8500 GPADC driver");