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