pandora: defconfig: update
[pandora-kernel.git] / drivers / input / misc / ad714x.c
1 /*
2  * AD714X CapTouch Programmable Controller driver supporting AD7142/3/7/8/7A
3  *
4  * Copyright 2009-2011 Analog Devices Inc.
5  *
6  * Licensed under the GPL-2 or later.
7  */
8
9 #include <linux/device.h>
10 #include <linux/init.h>
11 #include <linux/input.h>
12 #include <linux/interrupt.h>
13 #include <linux/slab.h>
14 #include <linux/input/ad714x.h>
15 #include <linux/module.h>
16 #include "ad714x.h"
17
18 #define AD714X_PWR_CTRL           0x0
19 #define AD714X_STG_CAL_EN_REG     0x1
20 #define AD714X_AMB_COMP_CTRL0_REG 0x2
21 #define AD714X_PARTID_REG         0x17
22 #define AD7142_PARTID             0xE620
23 #define AD7143_PARTID             0xE630
24 #define AD7147_PARTID             0x1470
25 #define AD7148_PARTID             0x1480
26 #define AD714X_STAGECFG_REG       0x80
27 #define AD714X_SYSCFG_REG         0x0
28
29 #define STG_LOW_INT_EN_REG     0x5
30 #define STG_HIGH_INT_EN_REG    0x6
31 #define STG_COM_INT_EN_REG     0x7
32 #define STG_LOW_INT_STA_REG    0x8
33 #define STG_HIGH_INT_STA_REG   0x9
34 #define STG_COM_INT_STA_REG    0xA
35
36 #define CDC_RESULT_S0          0xB
37 #define CDC_RESULT_S1          0xC
38 #define CDC_RESULT_S2          0xD
39 #define CDC_RESULT_S3          0xE
40 #define CDC_RESULT_S4          0xF
41 #define CDC_RESULT_S5          0x10
42 #define CDC_RESULT_S6          0x11
43 #define CDC_RESULT_S7          0x12
44 #define CDC_RESULT_S8          0x13
45 #define CDC_RESULT_S9          0x14
46 #define CDC_RESULT_S10         0x15
47 #define CDC_RESULT_S11         0x16
48
49 #define STAGE0_AMBIENT          0xF1
50 #define STAGE1_AMBIENT          0x115
51 #define STAGE2_AMBIENT          0x139
52 #define STAGE3_AMBIENT          0x15D
53 #define STAGE4_AMBIENT          0x181
54 #define STAGE5_AMBIENT          0x1A5
55 #define STAGE6_AMBIENT          0x1C9
56 #define STAGE7_AMBIENT          0x1ED
57 #define STAGE8_AMBIENT          0x211
58 #define STAGE9_AMBIENT          0x234
59 #define STAGE10_AMBIENT         0x259
60 #define STAGE11_AMBIENT         0x27D
61
62 #define PER_STAGE_REG_NUM      36
63 #define STAGE_CFGREG_NUM       8
64 #define SYS_CFGREG_NUM         8
65
66 /*
67  * driver information which will be used to maintain the software flow
68  */
69 enum ad714x_device_state { IDLE, JITTER, ACTIVE, SPACE };
70
71 struct ad714x_slider_drv {
72         int highest_stage;
73         int abs_pos;
74         int flt_pos;
75         enum ad714x_device_state state;
76         struct input_dev *input;
77 };
78
79 struct ad714x_wheel_drv {
80         int abs_pos;
81         int flt_pos;
82         int pre_highest_stage;
83         int highest_stage;
84         enum ad714x_device_state state;
85         struct input_dev *input;
86 };
87
88 struct ad714x_touchpad_drv {
89         int x_highest_stage;
90         int x_flt_pos;
91         int x_abs_pos;
92         int y_highest_stage;
93         int y_flt_pos;
94         int y_abs_pos;
95         int left_ep;
96         int left_ep_val;
97         int right_ep;
98         int right_ep_val;
99         int top_ep;
100         int top_ep_val;
101         int bottom_ep;
102         int bottom_ep_val;
103         enum ad714x_device_state state;
104         struct input_dev *input;
105 };
106
107 struct ad714x_button_drv {
108         enum ad714x_device_state state;
109         /*
110          * Unlike slider/wheel/touchpad, all buttons point to
111          * same input_dev instance
112          */
113         struct input_dev *input;
114 };
115
116 struct ad714x_driver_data {
117         struct ad714x_slider_drv *slider;
118         struct ad714x_wheel_drv *wheel;
119         struct ad714x_touchpad_drv *touchpad;
120         struct ad714x_button_drv *button;
121 };
122
123 /*
124  * information to integrate all things which will be private data
125  * of spi/i2c device
126  */
127
128 static void ad714x_use_com_int(struct ad714x_chip *ad714x,
129                                 int start_stage, int end_stage)
130 {
131         unsigned short data;
132         unsigned short mask;
133
134         mask = ((1 << (end_stage + 1)) - 1) - ((1 << start_stage) - 1);
135
136         ad714x->read(ad714x, STG_COM_INT_EN_REG, &data, 1);
137         data |= 1 << end_stage;
138         ad714x->write(ad714x, STG_COM_INT_EN_REG, data);
139
140         ad714x->read(ad714x, STG_HIGH_INT_EN_REG, &data, 1);
141         data &= ~mask;
142         ad714x->write(ad714x, STG_HIGH_INT_EN_REG, data);
143 }
144
145 static void ad714x_use_thr_int(struct ad714x_chip *ad714x,
146                                 int start_stage, int end_stage)
147 {
148         unsigned short data;
149         unsigned short mask;
150
151         mask = ((1 << (end_stage + 1)) - 1) - ((1 << start_stage) - 1);
152
153         ad714x->read(ad714x, STG_COM_INT_EN_REG, &data, 1);
154         data &= ~(1 << end_stage);
155         ad714x->write(ad714x, STG_COM_INT_EN_REG, data);
156
157         ad714x->read(ad714x, STG_HIGH_INT_EN_REG, &data, 1);
158         data |= mask;
159         ad714x->write(ad714x, STG_HIGH_INT_EN_REG, data);
160 }
161
162 static int ad714x_cal_highest_stage(struct ad714x_chip *ad714x,
163                                         int start_stage, int end_stage)
164 {
165         int max_res = 0;
166         int max_idx = 0;
167         int i;
168
169         for (i = start_stage; i <= end_stage; i++) {
170                 if (ad714x->sensor_val[i] > max_res) {
171                         max_res = ad714x->sensor_val[i];
172                         max_idx = i;
173                 }
174         }
175
176         return max_idx;
177 }
178
179 static int ad714x_cal_abs_pos(struct ad714x_chip *ad714x,
180                                 int start_stage, int end_stage,
181                                 int highest_stage, int max_coord)
182 {
183         int a_param, b_param;
184
185         if (highest_stage == start_stage) {
186                 a_param = ad714x->sensor_val[start_stage + 1];
187                 b_param = ad714x->sensor_val[start_stage] +
188                         ad714x->sensor_val[start_stage + 1];
189         } else if (highest_stage == end_stage) {
190                 a_param = ad714x->sensor_val[end_stage] *
191                         (end_stage - start_stage) +
192                         ad714x->sensor_val[end_stage - 1] *
193                         (end_stage - start_stage - 1);
194                 b_param = ad714x->sensor_val[end_stage] +
195                         ad714x->sensor_val[end_stage - 1];
196         } else {
197                 a_param = ad714x->sensor_val[highest_stage] *
198                         (highest_stage - start_stage) +
199                         ad714x->sensor_val[highest_stage - 1] *
200                         (highest_stage - start_stage - 1) +
201                         ad714x->sensor_val[highest_stage + 1] *
202                         (highest_stage - start_stage + 1);
203                 b_param = ad714x->sensor_val[highest_stage] +
204                         ad714x->sensor_val[highest_stage - 1] +
205                         ad714x->sensor_val[highest_stage + 1];
206         }
207
208         return (max_coord / (end_stage - start_stage)) * a_param / b_param;
209 }
210
211 /*
212  * One button can connect to multi positive and negative of CDCs
213  * Multi-buttons can connect to same positive/negative of one CDC
214  */
215 static void ad714x_button_state_machine(struct ad714x_chip *ad714x, int idx)
216 {
217         struct ad714x_button_plat *hw = &ad714x->hw->button[idx];
218         struct ad714x_button_drv *sw = &ad714x->sw->button[idx];
219
220         switch (sw->state) {
221         case IDLE:
222                 if (((ad714x->h_state & hw->h_mask) == hw->h_mask) &&
223                     ((ad714x->l_state & hw->l_mask) == hw->l_mask)) {
224                         dev_dbg(ad714x->dev, "button %d touched\n", idx);
225                         input_report_key(sw->input, hw->keycode, 1);
226                         input_sync(sw->input);
227                         sw->state = ACTIVE;
228                 }
229                 break;
230
231         case ACTIVE:
232                 if (((ad714x->h_state & hw->h_mask) != hw->h_mask) ||
233                     ((ad714x->l_state & hw->l_mask) != hw->l_mask)) {
234                         dev_dbg(ad714x->dev, "button %d released\n", idx);
235                         input_report_key(sw->input, hw->keycode, 0);
236                         input_sync(sw->input);
237                         sw->state = IDLE;
238                 }
239                 break;
240
241         default:
242                 break;
243         }
244 }
245
246 /*
247  * The response of a sensor is defined by the absolute number of codes
248  * between the current CDC value and the ambient value.
249  */
250 static void ad714x_slider_cal_sensor_val(struct ad714x_chip *ad714x, int idx)
251 {
252         struct ad714x_slider_plat *hw = &ad714x->hw->slider[idx];
253         int i;
254
255         ad714x->read(ad714x, CDC_RESULT_S0 + hw->start_stage,
256                         &ad714x->adc_reg[hw->start_stage],
257                         hw->end_stage - hw->start_stage + 1);
258
259         for (i = hw->start_stage; i <= hw->end_stage; i++) {
260                 ad714x->read(ad714x, STAGE0_AMBIENT + i * PER_STAGE_REG_NUM,
261                                 &ad714x->amb_reg[i], 1);
262
263                 ad714x->sensor_val[i] =
264                         abs(ad714x->adc_reg[i] - ad714x->amb_reg[i]);
265         }
266 }
267
268 static void ad714x_slider_cal_highest_stage(struct ad714x_chip *ad714x, int idx)
269 {
270         struct ad714x_slider_plat *hw = &ad714x->hw->slider[idx];
271         struct ad714x_slider_drv *sw = &ad714x->sw->slider[idx];
272
273         sw->highest_stage = ad714x_cal_highest_stage(ad714x, hw->start_stage,
274                         hw->end_stage);
275
276         dev_dbg(ad714x->dev, "slider %d highest_stage:%d\n", idx,
277                 sw->highest_stage);
278 }
279
280 /*
281  * The formulae are very straight forward. It uses the sensor with the
282  * highest response and the 2 adjacent ones.
283  * When Sensor 0 has the highest response, only sensor 0 and sensor 1
284  * are used in the calculations. Similarly when the last sensor has the
285  * highest response, only the last sensor and the second last sensors
286  * are used in the calculations.
287  *
288  * For i= idx_of_peak_Sensor-1 to i= idx_of_peak_Sensor+1
289  *         v += Sensor response(i)*i
290  *         w += Sensor response(i)
291  * POS=(Number_of_Positions_Wanted/(Number_of_Sensors_Used-1)) *(v/w)
292  */
293 static void ad714x_slider_cal_abs_pos(struct ad714x_chip *ad714x, int idx)
294 {
295         struct ad714x_slider_plat *hw = &ad714x->hw->slider[idx];
296         struct ad714x_slider_drv *sw = &ad714x->sw->slider[idx];
297
298         sw->abs_pos = ad714x_cal_abs_pos(ad714x, hw->start_stage, hw->end_stage,
299                 sw->highest_stage, hw->max_coord);
300
301         dev_dbg(ad714x->dev, "slider %d absolute position:%d\n", idx,
302                 sw->abs_pos);
303 }
304
305 /*
306  * To minimise the Impact of the noise on the algorithm, ADI developed a
307  * routine that filters the CDC results after they have been read by the
308  * host processor.
309  * The filter used is an Infinite Input Response(IIR) filter implemented
310  * in firmware and attenuates the noise on the CDC results after they've
311  * been read by the host processor.
312  * Filtered_CDC_result = (Filtered_CDC_result * (10 - Coefficient) +
313  *                              Latest_CDC_result * Coefficient)/10
314  */
315 static void ad714x_slider_cal_flt_pos(struct ad714x_chip *ad714x, int idx)
316 {
317         struct ad714x_slider_drv *sw = &ad714x->sw->slider[idx];
318
319         sw->flt_pos = (sw->flt_pos * (10 - 4) +
320                         sw->abs_pos * 4)/10;
321
322         dev_dbg(ad714x->dev, "slider %d filter position:%d\n", idx,
323                 sw->flt_pos);
324 }
325
326 static void ad714x_slider_use_com_int(struct ad714x_chip *ad714x, int idx)
327 {
328         struct ad714x_slider_plat *hw = &ad714x->hw->slider[idx];
329
330         ad714x_use_com_int(ad714x, hw->start_stage, hw->end_stage);
331 }
332
333 static void ad714x_slider_use_thr_int(struct ad714x_chip *ad714x, int idx)
334 {
335         struct ad714x_slider_plat *hw = &ad714x->hw->slider[idx];
336
337         ad714x_use_thr_int(ad714x, hw->start_stage, hw->end_stage);
338 }
339
340 static void ad714x_slider_state_machine(struct ad714x_chip *ad714x, int idx)
341 {
342         struct ad714x_slider_plat *hw = &ad714x->hw->slider[idx];
343         struct ad714x_slider_drv *sw = &ad714x->sw->slider[idx];
344         unsigned short h_state, c_state;
345         unsigned short mask;
346
347         mask = ((1 << (hw->end_stage + 1)) - 1) - ((1 << hw->start_stage) - 1);
348
349         h_state = ad714x->h_state & mask;
350         c_state = ad714x->c_state & mask;
351
352         switch (sw->state) {
353         case IDLE:
354                 if (h_state) {
355                         sw->state = JITTER;
356                         /* In End of Conversion interrupt mode, the AD714X
357                          * continuously generates hardware interrupts.
358                          */
359                         ad714x_slider_use_com_int(ad714x, idx);
360                         dev_dbg(ad714x->dev, "slider %d touched\n", idx);
361                 }
362                 break;
363
364         case JITTER:
365                 if (c_state == mask) {
366                         ad714x_slider_cal_sensor_val(ad714x, idx);
367                         ad714x_slider_cal_highest_stage(ad714x, idx);
368                         ad714x_slider_cal_abs_pos(ad714x, idx);
369                         sw->flt_pos = sw->abs_pos;
370                         sw->state = ACTIVE;
371                 }
372                 break;
373
374         case ACTIVE:
375                 if (c_state == mask) {
376                         if (h_state) {
377                                 ad714x_slider_cal_sensor_val(ad714x, idx);
378                                 ad714x_slider_cal_highest_stage(ad714x, idx);
379                                 ad714x_slider_cal_abs_pos(ad714x, idx);
380                                 ad714x_slider_cal_flt_pos(ad714x, idx);
381                                 input_report_abs(sw->input, ABS_X, sw->flt_pos);
382                                 input_report_key(sw->input, BTN_TOUCH, 1);
383                         } else {
384                                 /* When the user lifts off the sensor, configure
385                                  * the AD714X back to threshold interrupt mode.
386                                  */
387                                 ad714x_slider_use_thr_int(ad714x, idx);
388                                 sw->state = IDLE;
389                                 input_report_key(sw->input, BTN_TOUCH, 0);
390                                 dev_dbg(ad714x->dev, "slider %d released\n",
391                                         idx);
392                         }
393                         input_sync(sw->input);
394                 }
395                 break;
396
397         default:
398                 break;
399         }
400 }
401
402 /*
403  * When the scroll wheel is activated, we compute the absolute position based
404  * on the sensor values. To calculate the position, we first determine the
405  * sensor that has the greatest response among the 8 sensors that constitutes
406  * the scrollwheel. Then we determined the 2 sensors on either sides of the
407  * sensor with the highest response and we apply weights to these sensors.
408  */
409 static void ad714x_wheel_cal_highest_stage(struct ad714x_chip *ad714x, int idx)
410 {
411         struct ad714x_wheel_plat *hw = &ad714x->hw->wheel[idx];
412         struct ad714x_wheel_drv *sw = &ad714x->sw->wheel[idx];
413
414         sw->pre_highest_stage = sw->highest_stage;
415         sw->highest_stage = ad714x_cal_highest_stage(ad714x, hw->start_stage,
416                         hw->end_stage);
417
418         dev_dbg(ad714x->dev, "wheel %d highest_stage:%d\n", idx,
419                 sw->highest_stage);
420 }
421
422 static void ad714x_wheel_cal_sensor_val(struct ad714x_chip *ad714x, int idx)
423 {
424         struct ad714x_wheel_plat *hw = &ad714x->hw->wheel[idx];
425         int i;
426
427         ad714x->read(ad714x, CDC_RESULT_S0 + hw->start_stage,
428                         &ad714x->adc_reg[hw->start_stage],
429                         hw->end_stage - hw->start_stage + 1);
430
431         for (i = hw->start_stage; i <= hw->end_stage; i++) {
432                 ad714x->read(ad714x, STAGE0_AMBIENT + i * PER_STAGE_REG_NUM,
433                                 &ad714x->amb_reg[i], 1);
434                 if (ad714x->adc_reg[i] > ad714x->amb_reg[i])
435                         ad714x->sensor_val[i] =
436                                 ad714x->adc_reg[i] - ad714x->amb_reg[i];
437                 else
438                         ad714x->sensor_val[i] = 0;
439         }
440 }
441
442 /*
443  * When the scroll wheel is activated, we compute the absolute position based
444  * on the sensor values. To calculate the position, we first determine the
445  * sensor that has the greatest response among the sensors that constitutes
446  * the scrollwheel. Then we determined the sensors on either sides of the
447  * sensor with the highest response and we apply weights to these sensors. The
448  * result of this computation gives us the mean value.
449  */
450
451 static void ad714x_wheel_cal_abs_pos(struct ad714x_chip *ad714x, int idx)
452 {
453         struct ad714x_wheel_plat *hw = &ad714x->hw->wheel[idx];
454         struct ad714x_wheel_drv *sw = &ad714x->sw->wheel[idx];
455         int stage_num = hw->end_stage - hw->start_stage + 1;
456         int first_before, highest, first_after;
457         int a_param, b_param;
458
459         first_before = (sw->highest_stage + stage_num - 1) % stage_num;
460         highest = sw->highest_stage;
461         first_after = (sw->highest_stage + stage_num + 1) % stage_num;
462
463         a_param = ad714x->sensor_val[highest] *
464                 (highest - hw->start_stage) +
465                 ad714x->sensor_val[first_before] *
466                 (highest - hw->start_stage - 1) +
467                 ad714x->sensor_val[first_after] *
468                 (highest - hw->start_stage + 1);
469         b_param = ad714x->sensor_val[highest] +
470                 ad714x->sensor_val[first_before] +
471                 ad714x->sensor_val[first_after];
472
473         sw->abs_pos = ((hw->max_coord / (hw->end_stage - hw->start_stage)) *
474                         a_param) / b_param;
475
476         if (sw->abs_pos > hw->max_coord)
477                 sw->abs_pos = hw->max_coord;
478         else if (sw->abs_pos < 0)
479                 sw->abs_pos = 0;
480 }
481
482 static void ad714x_wheel_cal_flt_pos(struct ad714x_chip *ad714x, int idx)
483 {
484         struct ad714x_wheel_plat *hw = &ad714x->hw->wheel[idx];
485         struct ad714x_wheel_drv *sw = &ad714x->sw->wheel[idx];
486         if (((sw->pre_highest_stage == hw->end_stage) &&
487                         (sw->highest_stage == hw->start_stage)) ||
488             ((sw->pre_highest_stage == hw->start_stage) &&
489                         (sw->highest_stage == hw->end_stage)))
490                 sw->flt_pos = sw->abs_pos;
491         else
492                 sw->flt_pos = ((sw->flt_pos * 30) + (sw->abs_pos * 71)) / 100;
493
494         if (sw->flt_pos > hw->max_coord)
495                 sw->flt_pos = hw->max_coord;
496 }
497
498 static void ad714x_wheel_use_com_int(struct ad714x_chip *ad714x, int idx)
499 {
500         struct ad714x_wheel_plat *hw = &ad714x->hw->wheel[idx];
501
502         ad714x_use_com_int(ad714x, hw->start_stage, hw->end_stage);
503 }
504
505 static void ad714x_wheel_use_thr_int(struct ad714x_chip *ad714x, int idx)
506 {
507         struct ad714x_wheel_plat *hw = &ad714x->hw->wheel[idx];
508
509         ad714x_use_thr_int(ad714x, hw->start_stage, hw->end_stage);
510 }
511
512 static void ad714x_wheel_state_machine(struct ad714x_chip *ad714x, int idx)
513 {
514         struct ad714x_wheel_plat *hw = &ad714x->hw->wheel[idx];
515         struct ad714x_wheel_drv *sw = &ad714x->sw->wheel[idx];
516         unsigned short h_state, c_state;
517         unsigned short mask;
518
519         mask = ((1 << (hw->end_stage + 1)) - 1) - ((1 << hw->start_stage) - 1);
520
521         h_state = ad714x->h_state & mask;
522         c_state = ad714x->c_state & mask;
523
524         switch (sw->state) {
525         case IDLE:
526                 if (h_state) {
527                         sw->state = JITTER;
528                         /* In End of Conversion interrupt mode, the AD714X
529                          * continuously generates hardware interrupts.
530                          */
531                         ad714x_wheel_use_com_int(ad714x, idx);
532                         dev_dbg(ad714x->dev, "wheel %d touched\n", idx);
533                 }
534                 break;
535
536         case JITTER:
537                 if (c_state == mask)    {
538                         ad714x_wheel_cal_sensor_val(ad714x, idx);
539                         ad714x_wheel_cal_highest_stage(ad714x, idx);
540                         ad714x_wheel_cal_abs_pos(ad714x, idx);
541                         sw->flt_pos = sw->abs_pos;
542                         sw->state = ACTIVE;
543                 }
544                 break;
545
546         case ACTIVE:
547                 if (c_state == mask) {
548                         if (h_state) {
549                                 ad714x_wheel_cal_sensor_val(ad714x, idx);
550                                 ad714x_wheel_cal_highest_stage(ad714x, idx);
551                                 ad714x_wheel_cal_abs_pos(ad714x, idx);
552                                 ad714x_wheel_cal_flt_pos(ad714x, idx);
553                                 input_report_abs(sw->input, ABS_WHEEL,
554                                         sw->flt_pos);
555                                 input_report_key(sw->input, BTN_TOUCH, 1);
556                         } else {
557                                 /* When the user lifts off the sensor, configure
558                                  * the AD714X back to threshold interrupt mode.
559                                  */
560                                 ad714x_wheel_use_thr_int(ad714x, idx);
561                                 sw->state = IDLE;
562                                 input_report_key(sw->input, BTN_TOUCH, 0);
563
564                                 dev_dbg(ad714x->dev, "wheel %d released\n",
565                                         idx);
566                         }
567                         input_sync(sw->input);
568                 }
569                 break;
570
571         default:
572                 break;
573         }
574 }
575
576 static void touchpad_cal_sensor_val(struct ad714x_chip *ad714x, int idx)
577 {
578         struct ad714x_touchpad_plat *hw = &ad714x->hw->touchpad[idx];
579         int i;
580
581         ad714x->read(ad714x, CDC_RESULT_S0 + hw->x_start_stage,
582                         &ad714x->adc_reg[hw->x_start_stage],
583                         hw->x_end_stage - hw->x_start_stage + 1);
584
585         for (i = hw->x_start_stage; i <= hw->x_end_stage; i++) {
586                 ad714x->read(ad714x, STAGE0_AMBIENT + i * PER_STAGE_REG_NUM,
587                                 &ad714x->amb_reg[i], 1);
588                 if (ad714x->adc_reg[i] > ad714x->amb_reg[i])
589                         ad714x->sensor_val[i] =
590                                 ad714x->adc_reg[i] - ad714x->amb_reg[i];
591                 else
592                         ad714x->sensor_val[i] = 0;
593         }
594 }
595
596 static void touchpad_cal_highest_stage(struct ad714x_chip *ad714x, int idx)
597 {
598         struct ad714x_touchpad_plat *hw = &ad714x->hw->touchpad[idx];
599         struct ad714x_touchpad_drv *sw = &ad714x->sw->touchpad[idx];
600
601         sw->x_highest_stage = ad714x_cal_highest_stage(ad714x,
602                 hw->x_start_stage, hw->x_end_stage);
603         sw->y_highest_stage = ad714x_cal_highest_stage(ad714x,
604                 hw->y_start_stage, hw->y_end_stage);
605
606         dev_dbg(ad714x->dev,
607                 "touchpad %d x_highest_stage:%d, y_highest_stage:%d\n",
608                 idx, sw->x_highest_stage, sw->y_highest_stage);
609 }
610
611 /*
612  * If 2 fingers are touching the sensor then 2 peaks can be observed in the
613  * distribution.
614  * The arithmetic doesn't support to get absolute coordinates for multi-touch
615  * yet.
616  */
617 static int touchpad_check_second_peak(struct ad714x_chip *ad714x, int idx)
618 {
619         struct ad714x_touchpad_plat *hw = &ad714x->hw->touchpad[idx];
620         struct ad714x_touchpad_drv *sw = &ad714x->sw->touchpad[idx];
621         int i;
622
623         for (i = hw->x_start_stage; i < sw->x_highest_stage; i++) {
624                 if ((ad714x->sensor_val[i] - ad714x->sensor_val[i + 1])
625                         > (ad714x->sensor_val[i + 1] / 10))
626                         return 1;
627         }
628
629         for (i = sw->x_highest_stage; i < hw->x_end_stage; i++) {
630                 if ((ad714x->sensor_val[i + 1] - ad714x->sensor_val[i])
631                         > (ad714x->sensor_val[i] / 10))
632                         return 1;
633         }
634
635         for (i = hw->y_start_stage; i < sw->y_highest_stage; i++) {
636                 if ((ad714x->sensor_val[i] - ad714x->sensor_val[i + 1])
637                         > (ad714x->sensor_val[i + 1] / 10))
638                         return 1;
639         }
640
641         for (i = sw->y_highest_stage; i < hw->y_end_stage; i++) {
642                 if ((ad714x->sensor_val[i + 1] - ad714x->sensor_val[i])
643                         > (ad714x->sensor_val[i] / 10))
644                         return 1;
645         }
646
647         return 0;
648 }
649
650 /*
651  * If only one finger is used to activate the touch pad then only 1 peak will be
652  * registered in the distribution. This peak and the 2 adjacent sensors will be
653  * used in the calculation of the absolute position. This will prevent hand
654  * shadows to affect the absolute position calculation.
655  */
656 static void touchpad_cal_abs_pos(struct ad714x_chip *ad714x, int idx)
657 {
658         struct ad714x_touchpad_plat *hw = &ad714x->hw->touchpad[idx];
659         struct ad714x_touchpad_drv *sw = &ad714x->sw->touchpad[idx];
660
661         sw->x_abs_pos = ad714x_cal_abs_pos(ad714x, hw->x_start_stage,
662                         hw->x_end_stage, sw->x_highest_stage, hw->x_max_coord);
663         sw->y_abs_pos = ad714x_cal_abs_pos(ad714x, hw->y_start_stage,
664                         hw->y_end_stage, sw->y_highest_stage, hw->y_max_coord);
665
666         dev_dbg(ad714x->dev, "touchpad %d absolute position:(%d, %d)\n", idx,
667                         sw->x_abs_pos, sw->y_abs_pos);
668 }
669
670 static void touchpad_cal_flt_pos(struct ad714x_chip *ad714x, int idx)
671 {
672         struct ad714x_touchpad_drv *sw = &ad714x->sw->touchpad[idx];
673
674         sw->x_flt_pos = (sw->x_flt_pos * (10 - 4) +
675                         sw->x_abs_pos * 4)/10;
676         sw->y_flt_pos = (sw->y_flt_pos * (10 - 4) +
677                         sw->y_abs_pos * 4)/10;
678
679         dev_dbg(ad714x->dev, "touchpad %d filter position:(%d, %d)\n",
680                         idx, sw->x_flt_pos, sw->y_flt_pos);
681 }
682
683 /*
684  * To prevent distortion from showing in the absolute position, it is
685  * necessary to detect the end points. When endpoints are detected, the
686  * driver stops updating the status variables with absolute positions.
687  * End points are detected on the 4 edges of the touchpad sensor. The
688  * method to detect them is the same for all 4.
689  * To detect the end points, the firmware computes the difference in
690  * percent between the sensor on the edge and the adjacent one. The
691  * difference is calculated in percent in order to make the end point
692  * detection independent of the pressure.
693  */
694
695 #define LEFT_END_POINT_DETECTION_LEVEL                  550
696 #define RIGHT_END_POINT_DETECTION_LEVEL                 750
697 #define LEFT_RIGHT_END_POINT_DEAVTIVALION_LEVEL         850
698 #define TOP_END_POINT_DETECTION_LEVEL                   550
699 #define BOTTOM_END_POINT_DETECTION_LEVEL                950
700 #define TOP_BOTTOM_END_POINT_DEAVTIVALION_LEVEL         700
701 static int touchpad_check_endpoint(struct ad714x_chip *ad714x, int idx)
702 {
703         struct ad714x_touchpad_plat *hw = &ad714x->hw->touchpad[idx];
704         struct ad714x_touchpad_drv *sw  = &ad714x->sw->touchpad[idx];
705         int percent_sensor_diff;
706
707         /* left endpoint detect */
708         percent_sensor_diff = (ad714x->sensor_val[hw->x_start_stage] -
709                         ad714x->sensor_val[hw->x_start_stage + 1]) * 100 /
710                         ad714x->sensor_val[hw->x_start_stage + 1];
711         if (!sw->left_ep) {
712                 if (percent_sensor_diff >= LEFT_END_POINT_DETECTION_LEVEL)  {
713                         sw->left_ep = 1;
714                         sw->left_ep_val =
715                                 ad714x->sensor_val[hw->x_start_stage + 1];
716                 }
717         } else {
718                 if ((percent_sensor_diff < LEFT_END_POINT_DETECTION_LEVEL) &&
719                     (ad714x->sensor_val[hw->x_start_stage + 1] >
720                      LEFT_RIGHT_END_POINT_DEAVTIVALION_LEVEL + sw->left_ep_val))
721                         sw->left_ep = 0;
722         }
723
724         /* right endpoint detect */
725         percent_sensor_diff = (ad714x->sensor_val[hw->x_end_stage] -
726                         ad714x->sensor_val[hw->x_end_stage - 1]) * 100 /
727                         ad714x->sensor_val[hw->x_end_stage - 1];
728         if (!sw->right_ep) {
729                 if (percent_sensor_diff >= RIGHT_END_POINT_DETECTION_LEVEL)  {
730                         sw->right_ep = 1;
731                         sw->right_ep_val =
732                                 ad714x->sensor_val[hw->x_end_stage - 1];
733                 }
734         } else {
735                 if ((percent_sensor_diff < RIGHT_END_POINT_DETECTION_LEVEL) &&
736                 (ad714x->sensor_val[hw->x_end_stage - 1] >
737                 LEFT_RIGHT_END_POINT_DEAVTIVALION_LEVEL + sw->right_ep_val))
738                         sw->right_ep = 0;
739         }
740
741         /* top endpoint detect */
742         percent_sensor_diff = (ad714x->sensor_val[hw->y_start_stage] -
743                         ad714x->sensor_val[hw->y_start_stage + 1]) * 100 /
744                         ad714x->sensor_val[hw->y_start_stage + 1];
745         if (!sw->top_ep) {
746                 if (percent_sensor_diff >= TOP_END_POINT_DETECTION_LEVEL)  {
747                         sw->top_ep = 1;
748                         sw->top_ep_val =
749                                 ad714x->sensor_val[hw->y_start_stage + 1];
750                 }
751         } else {
752                 if ((percent_sensor_diff < TOP_END_POINT_DETECTION_LEVEL) &&
753                 (ad714x->sensor_val[hw->y_start_stage + 1] >
754                 TOP_BOTTOM_END_POINT_DEAVTIVALION_LEVEL + sw->top_ep_val))
755                         sw->top_ep = 0;
756         }
757
758         /* bottom endpoint detect */
759         percent_sensor_diff = (ad714x->sensor_val[hw->y_end_stage] -
760                 ad714x->sensor_val[hw->y_end_stage - 1]) * 100 /
761                 ad714x->sensor_val[hw->y_end_stage - 1];
762         if (!sw->bottom_ep) {
763                 if (percent_sensor_diff >= BOTTOM_END_POINT_DETECTION_LEVEL)  {
764                         sw->bottom_ep = 1;
765                         sw->bottom_ep_val =
766                                 ad714x->sensor_val[hw->y_end_stage - 1];
767                 }
768         } else {
769                 if ((percent_sensor_diff < BOTTOM_END_POINT_DETECTION_LEVEL) &&
770                 (ad714x->sensor_val[hw->y_end_stage - 1] >
771                  TOP_BOTTOM_END_POINT_DEAVTIVALION_LEVEL + sw->bottom_ep_val))
772                         sw->bottom_ep = 0;
773         }
774
775         return sw->left_ep || sw->right_ep || sw->top_ep || sw->bottom_ep;
776 }
777
778 static void touchpad_use_com_int(struct ad714x_chip *ad714x, int idx)
779 {
780         struct ad714x_touchpad_plat *hw = &ad714x->hw->touchpad[idx];
781
782         ad714x_use_com_int(ad714x, hw->x_start_stage, hw->x_end_stage);
783 }
784
785 static void touchpad_use_thr_int(struct ad714x_chip *ad714x, int idx)
786 {
787         struct ad714x_touchpad_plat *hw = &ad714x->hw->touchpad[idx];
788
789         ad714x_use_thr_int(ad714x, hw->x_start_stage, hw->x_end_stage);
790         ad714x_use_thr_int(ad714x, hw->y_start_stage, hw->y_end_stage);
791 }
792
793 static void ad714x_touchpad_state_machine(struct ad714x_chip *ad714x, int idx)
794 {
795         struct ad714x_touchpad_plat *hw = &ad714x->hw->touchpad[idx];
796         struct ad714x_touchpad_drv *sw = &ad714x->sw->touchpad[idx];
797         unsigned short h_state, c_state;
798         unsigned short mask;
799
800         mask = (((1 << (hw->x_end_stage + 1)) - 1) -
801                 ((1 << hw->x_start_stage) - 1)) +
802                 (((1 << (hw->y_end_stage + 1)) - 1) -
803                 ((1 << hw->y_start_stage) - 1));
804
805         h_state = ad714x->h_state & mask;
806         c_state = ad714x->c_state & mask;
807
808         switch (sw->state) {
809         case IDLE:
810                 if (h_state) {
811                         sw->state = JITTER;
812                         /* In End of Conversion interrupt mode, the AD714X
813                          * continuously generates hardware interrupts.
814                          */
815                         touchpad_use_com_int(ad714x, idx);
816                         dev_dbg(ad714x->dev, "touchpad %d touched\n", idx);
817                 }
818                 break;
819
820         case JITTER:
821                 if (c_state == mask) {
822                         touchpad_cal_sensor_val(ad714x, idx);
823                         touchpad_cal_highest_stage(ad714x, idx);
824                         if ((!touchpad_check_second_peak(ad714x, idx)) &&
825                                 (!touchpad_check_endpoint(ad714x, idx))) {
826                                 dev_dbg(ad714x->dev,
827                                         "touchpad%d, 2 fingers or endpoint\n",
828                                         idx);
829                                 touchpad_cal_abs_pos(ad714x, idx);
830                                 sw->x_flt_pos = sw->x_abs_pos;
831                                 sw->y_flt_pos = sw->y_abs_pos;
832                                 sw->state = ACTIVE;
833                         }
834                 }
835                 break;
836
837         case ACTIVE:
838                 if (c_state == mask) {
839                         if (h_state) {
840                                 touchpad_cal_sensor_val(ad714x, idx);
841                                 touchpad_cal_highest_stage(ad714x, idx);
842                                 if ((!touchpad_check_second_peak(ad714x, idx))
843                                   && (!touchpad_check_endpoint(ad714x, idx))) {
844                                         touchpad_cal_abs_pos(ad714x, idx);
845                                         touchpad_cal_flt_pos(ad714x, idx);
846                                         input_report_abs(sw->input, ABS_X,
847                                                 sw->x_flt_pos);
848                                         input_report_abs(sw->input, ABS_Y,
849                                                 sw->y_flt_pos);
850                                         input_report_key(sw->input, BTN_TOUCH,
851                                                 1);
852                                 }
853                         } else {
854                                 /* When the user lifts off the sensor, configure
855                                  * the AD714X back to threshold interrupt mode.
856                                  */
857                                 touchpad_use_thr_int(ad714x, idx);
858                                 sw->state = IDLE;
859                                 input_report_key(sw->input, BTN_TOUCH, 0);
860                                 dev_dbg(ad714x->dev, "touchpad %d released\n",
861                                         idx);
862                         }
863                         input_sync(sw->input);
864                 }
865                 break;
866
867         default:
868                 break;
869         }
870 }
871
872 static int ad714x_hw_detect(struct ad714x_chip *ad714x)
873 {
874         unsigned short data;
875
876         ad714x->read(ad714x, AD714X_PARTID_REG, &data, 1);
877         switch (data & 0xFFF0) {
878         case AD7142_PARTID:
879                 ad714x->product = 0x7142;
880                 ad714x->version = data & 0xF;
881                 dev_info(ad714x->dev, "found AD7142 captouch, rev:%d\n",
882                                 ad714x->version);
883                 return 0;
884
885         case AD7143_PARTID:
886                 ad714x->product = 0x7143;
887                 ad714x->version = data & 0xF;
888                 dev_info(ad714x->dev, "found AD7143 captouch, rev:%d\n",
889                                 ad714x->version);
890                 return 0;
891
892         case AD7147_PARTID:
893                 ad714x->product = 0x7147;
894                 ad714x->version = data & 0xF;
895                 dev_info(ad714x->dev, "found AD7147(A) captouch, rev:%d\n",
896                                 ad714x->version);
897                 return 0;
898
899         case AD7148_PARTID:
900                 ad714x->product = 0x7148;
901                 ad714x->version = data & 0xF;
902                 dev_info(ad714x->dev, "found AD7148 captouch, rev:%d\n",
903                                 ad714x->version);
904                 return 0;
905
906         default:
907                 dev_err(ad714x->dev,
908                         "fail to detect AD714X captouch, read ID is %04x\n",
909                         data);
910                 return -ENODEV;
911         }
912 }
913
914 static void ad714x_hw_init(struct ad714x_chip *ad714x)
915 {
916         int i, j;
917         unsigned short reg_base;
918         unsigned short data;
919
920         /* configuration CDC and interrupts */
921
922         for (i = 0; i < STAGE_NUM; i++) {
923                 reg_base = AD714X_STAGECFG_REG + i * STAGE_CFGREG_NUM;
924                 for (j = 0; j < STAGE_CFGREG_NUM; j++)
925                         ad714x->write(ad714x, reg_base + j,
926                                         ad714x->hw->stage_cfg_reg[i][j]);
927         }
928
929         for (i = 0; i < SYS_CFGREG_NUM; i++)
930                 ad714x->write(ad714x, AD714X_SYSCFG_REG + i,
931                         ad714x->hw->sys_cfg_reg[i]);
932         for (i = 0; i < SYS_CFGREG_NUM; i++)
933                 ad714x->read(ad714x, AD714X_SYSCFG_REG + i, &data, 1);
934
935         ad714x->write(ad714x, AD714X_STG_CAL_EN_REG, 0xFFF);
936
937         /* clear all interrupts */
938         ad714x->read(ad714x, STG_LOW_INT_STA_REG, &ad714x->l_state, 3);
939 }
940
941 static irqreturn_t ad714x_interrupt_thread(int irq, void *data)
942 {
943         struct ad714x_chip *ad714x = data;
944         int i;
945
946         mutex_lock(&ad714x->mutex);
947
948         ad714x->read(ad714x, STG_LOW_INT_STA_REG, &ad714x->l_state, 3);
949
950         for (i = 0; i < ad714x->hw->button_num; i++)
951                 ad714x_button_state_machine(ad714x, i);
952         for (i = 0; i < ad714x->hw->slider_num; i++)
953                 ad714x_slider_state_machine(ad714x, i);
954         for (i = 0; i < ad714x->hw->wheel_num; i++)
955                 ad714x_wheel_state_machine(ad714x, i);
956         for (i = 0; i < ad714x->hw->touchpad_num; i++)
957                 ad714x_touchpad_state_machine(ad714x, i);
958
959         mutex_unlock(&ad714x->mutex);
960
961         return IRQ_HANDLED;
962 }
963
964 #define MAX_DEVICE_NUM 8
965 struct ad714x_chip *ad714x_probe(struct device *dev, u16 bus_type, int irq,
966                                  ad714x_read_t read, ad714x_write_t write)
967 {
968         int i, alloc_idx;
969         int error;
970         struct input_dev *input[MAX_DEVICE_NUM];
971
972         struct ad714x_platform_data *plat_data = dev->platform_data;
973         struct ad714x_chip *ad714x;
974         void *drv_mem;
975
976         struct ad714x_button_drv *bt_drv;
977         struct ad714x_slider_drv *sd_drv;
978         struct ad714x_wheel_drv *wl_drv;
979         struct ad714x_touchpad_drv *tp_drv;
980
981
982         if (irq <= 0) {
983                 dev_err(dev, "IRQ not configured!\n");
984                 error = -EINVAL;
985                 goto err_out;
986         }
987
988         if (dev->platform_data == NULL) {
989                 dev_err(dev, "platform data for ad714x doesn't exist\n");
990                 error = -EINVAL;
991                 goto err_out;
992         }
993
994         ad714x = kzalloc(sizeof(*ad714x) + sizeof(*ad714x->sw) +
995                          sizeof(*sd_drv) * plat_data->slider_num +
996                          sizeof(*wl_drv) * plat_data->wheel_num +
997                          sizeof(*tp_drv) * plat_data->touchpad_num +
998                          sizeof(*bt_drv) * plat_data->button_num, GFP_KERNEL);
999         if (!ad714x) {
1000                 error = -ENOMEM;
1001                 goto err_out;
1002         }
1003
1004         ad714x->hw = plat_data;
1005
1006         drv_mem = ad714x + 1;
1007         ad714x->sw = drv_mem;
1008         drv_mem += sizeof(*ad714x->sw);
1009         ad714x->sw->slider = sd_drv = drv_mem;
1010         drv_mem += sizeof(*sd_drv) * ad714x->hw->slider_num;
1011         ad714x->sw->wheel = wl_drv = drv_mem;
1012         drv_mem += sizeof(*wl_drv) * ad714x->hw->wheel_num;
1013         ad714x->sw->touchpad = tp_drv = drv_mem;
1014         drv_mem += sizeof(*tp_drv) * ad714x->hw->touchpad_num;
1015         ad714x->sw->button = bt_drv = drv_mem;
1016         drv_mem += sizeof(*bt_drv) * ad714x->hw->button_num;
1017
1018         ad714x->read = read;
1019         ad714x->write = write;
1020         ad714x->irq = irq;
1021         ad714x->dev = dev;
1022
1023         error = ad714x_hw_detect(ad714x);
1024         if (error)
1025                 goto err_free_mem;
1026
1027         /* initialize and request sw/hw resources */
1028
1029         ad714x_hw_init(ad714x);
1030         mutex_init(&ad714x->mutex);
1031
1032         /*
1033          * Allocate and register AD714X input device
1034          */
1035         alloc_idx = 0;
1036
1037         /* a slider uses one input_dev instance */
1038         if (ad714x->hw->slider_num > 0) {
1039                 struct ad714x_slider_plat *sd_plat = ad714x->hw->slider;
1040
1041                 for (i = 0; i < ad714x->hw->slider_num; i++) {
1042                         sd_drv[i].input = input[alloc_idx] = input_allocate_device();
1043                         if (!input[alloc_idx]) {
1044                                 error = -ENOMEM;
1045                                 goto err_free_dev;
1046                         }
1047
1048                         __set_bit(EV_ABS, input[alloc_idx]->evbit);
1049                         __set_bit(EV_KEY, input[alloc_idx]->evbit);
1050                         __set_bit(ABS_X, input[alloc_idx]->absbit);
1051                         __set_bit(BTN_TOUCH, input[alloc_idx]->keybit);
1052                         input_set_abs_params(input[alloc_idx],
1053                                 ABS_X, 0, sd_plat->max_coord, 0, 0);
1054
1055                         input[alloc_idx]->id.bustype = bus_type;
1056                         input[alloc_idx]->id.product = ad714x->product;
1057                         input[alloc_idx]->id.version = ad714x->version;
1058                         input[alloc_idx]->name = "ad714x_captouch_slider";
1059                         input[alloc_idx]->dev.parent = dev;
1060
1061                         error = input_register_device(input[alloc_idx]);
1062                         if (error)
1063                                 goto err_free_dev;
1064
1065                         alloc_idx++;
1066                 }
1067         }
1068
1069         /* a wheel uses one input_dev instance */
1070         if (ad714x->hw->wheel_num > 0) {
1071                 struct ad714x_wheel_plat *wl_plat = ad714x->hw->wheel;
1072
1073                 for (i = 0; i < ad714x->hw->wheel_num; i++) {
1074                         wl_drv[i].input = input[alloc_idx] = input_allocate_device();
1075                         if (!input[alloc_idx]) {
1076                                 error = -ENOMEM;
1077                                 goto err_free_dev;
1078                         }
1079
1080                         __set_bit(EV_KEY, input[alloc_idx]->evbit);
1081                         __set_bit(EV_ABS, input[alloc_idx]->evbit);
1082                         __set_bit(ABS_WHEEL, input[alloc_idx]->absbit);
1083                         __set_bit(BTN_TOUCH, input[alloc_idx]->keybit);
1084                         input_set_abs_params(input[alloc_idx],
1085                                 ABS_WHEEL, 0, wl_plat->max_coord, 0, 0);
1086
1087                         input[alloc_idx]->id.bustype = bus_type;
1088                         input[alloc_idx]->id.product = ad714x->product;
1089                         input[alloc_idx]->id.version = ad714x->version;
1090                         input[alloc_idx]->name = "ad714x_captouch_wheel";
1091                         input[alloc_idx]->dev.parent = dev;
1092
1093                         error = input_register_device(input[alloc_idx]);
1094                         if (error)
1095                                 goto err_free_dev;
1096
1097                         alloc_idx++;
1098                 }
1099         }
1100
1101         /* a touchpad uses one input_dev instance */
1102         if (ad714x->hw->touchpad_num > 0) {
1103                 struct ad714x_touchpad_plat *tp_plat = ad714x->hw->touchpad;
1104
1105                 for (i = 0; i < ad714x->hw->touchpad_num; i++) {
1106                         tp_drv[i].input = input[alloc_idx] = input_allocate_device();
1107                         if (!input[alloc_idx]) {
1108                                 error = -ENOMEM;
1109                                 goto err_free_dev;
1110                         }
1111
1112                         __set_bit(EV_ABS, input[alloc_idx]->evbit);
1113                         __set_bit(EV_KEY, input[alloc_idx]->evbit);
1114                         __set_bit(ABS_X, input[alloc_idx]->absbit);
1115                         __set_bit(ABS_Y, input[alloc_idx]->absbit);
1116                         __set_bit(BTN_TOUCH, input[alloc_idx]->keybit);
1117                         input_set_abs_params(input[alloc_idx],
1118                                 ABS_X, 0, tp_plat->x_max_coord, 0, 0);
1119                         input_set_abs_params(input[alloc_idx],
1120                                 ABS_Y, 0, tp_plat->y_max_coord, 0, 0);
1121
1122                         input[alloc_idx]->id.bustype = bus_type;
1123                         input[alloc_idx]->id.product = ad714x->product;
1124                         input[alloc_idx]->id.version = ad714x->version;
1125                         input[alloc_idx]->name = "ad714x_captouch_pad";
1126                         input[alloc_idx]->dev.parent = dev;
1127
1128                         error = input_register_device(input[alloc_idx]);
1129                         if (error)
1130                                 goto err_free_dev;
1131
1132                         alloc_idx++;
1133                 }
1134         }
1135
1136         /* all buttons use one input node */
1137         if (ad714x->hw->button_num > 0) {
1138                 struct ad714x_button_plat *bt_plat = ad714x->hw->button;
1139
1140                 input[alloc_idx] = input_allocate_device();
1141                 if (!input[alloc_idx]) {
1142                         error = -ENOMEM;
1143                         goto err_free_dev;
1144                 }
1145
1146                 __set_bit(EV_KEY, input[alloc_idx]->evbit);
1147                 for (i = 0; i < ad714x->hw->button_num; i++) {
1148                         bt_drv[i].input = input[alloc_idx];
1149                         __set_bit(bt_plat[i].keycode, input[alloc_idx]->keybit);
1150                 }
1151
1152                 input[alloc_idx]->id.bustype = bus_type;
1153                 input[alloc_idx]->id.product = ad714x->product;
1154                 input[alloc_idx]->id.version = ad714x->version;
1155                 input[alloc_idx]->name = "ad714x_captouch_button";
1156                 input[alloc_idx]->dev.parent = dev;
1157
1158                 error = input_register_device(input[alloc_idx]);
1159                 if (error)
1160                         goto err_free_dev;
1161
1162                 alloc_idx++;
1163         }
1164
1165         error = request_threaded_irq(ad714x->irq, NULL, ad714x_interrupt_thread,
1166                                 plat_data->irqflags ?
1167                                         plat_data->irqflags : IRQF_TRIGGER_FALLING,
1168                                 "ad714x_captouch", ad714x);
1169         if (error) {
1170                 dev_err(dev, "can't allocate irq %d\n", ad714x->irq);
1171                 goto err_unreg_dev;
1172         }
1173
1174         return ad714x;
1175
1176  err_free_dev:
1177         dev_err(dev, "failed to setup AD714x input device %i\n", alloc_idx);
1178         input_free_device(input[alloc_idx]);
1179  err_unreg_dev:
1180         while (--alloc_idx >= 0)
1181                 input_unregister_device(input[alloc_idx]);
1182  err_free_mem:
1183         kfree(ad714x);
1184  err_out:
1185         return ERR_PTR(error);
1186 }
1187 EXPORT_SYMBOL(ad714x_probe);
1188
1189 void ad714x_remove(struct ad714x_chip *ad714x)
1190 {
1191         struct ad714x_platform_data *hw = ad714x->hw;
1192         struct ad714x_driver_data *sw = ad714x->sw;
1193         int i;
1194
1195         free_irq(ad714x->irq, ad714x);
1196
1197         /* unregister and free all input devices */
1198
1199         for (i = 0; i < hw->slider_num; i++)
1200                 input_unregister_device(sw->slider[i].input);
1201
1202         for (i = 0; i < hw->wheel_num; i++)
1203                 input_unregister_device(sw->wheel[i].input);
1204
1205         for (i = 0; i < hw->touchpad_num; i++)
1206                 input_unregister_device(sw->touchpad[i].input);
1207
1208         if (hw->button_num)
1209                 input_unregister_device(sw->button[0].input);
1210
1211         kfree(ad714x);
1212 }
1213 EXPORT_SYMBOL(ad714x_remove);
1214
1215 #ifdef CONFIG_PM
1216 int ad714x_disable(struct ad714x_chip *ad714x)
1217 {
1218         unsigned short data;
1219
1220         dev_dbg(ad714x->dev, "%s enter\n", __func__);
1221
1222         mutex_lock(&ad714x->mutex);
1223
1224         data = ad714x->hw->sys_cfg_reg[AD714X_PWR_CTRL] | 0x3;
1225         ad714x->write(ad714x, AD714X_PWR_CTRL, data);
1226
1227         mutex_unlock(&ad714x->mutex);
1228
1229         return 0;
1230 }
1231 EXPORT_SYMBOL(ad714x_disable);
1232
1233 int ad714x_enable(struct ad714x_chip *ad714x)
1234 {
1235         dev_dbg(ad714x->dev, "%s enter\n", __func__);
1236
1237         mutex_lock(&ad714x->mutex);
1238
1239         /* resume to non-shutdown mode */
1240
1241         ad714x->write(ad714x, AD714X_PWR_CTRL,
1242                         ad714x->hw->sys_cfg_reg[AD714X_PWR_CTRL]);
1243
1244         /* make sure the interrupt output line is not low level after resume,
1245          * otherwise we will get no chance to enter falling-edge irq again
1246          */
1247
1248         ad714x->read(ad714x, STG_LOW_INT_STA_REG, &ad714x->l_state, 3);
1249
1250         mutex_unlock(&ad714x->mutex);
1251
1252         return 0;
1253 }
1254 EXPORT_SYMBOL(ad714x_enable);
1255 #endif
1256
1257 MODULE_DESCRIPTION("Analog Devices AD714X Capacitance Touch Sensor Driver");
1258 MODULE_AUTHOR("Barry Song <21cnbao@gmail.com>");
1259 MODULE_LICENSE("GPL");