?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
x86/xen: resume timer irqs early
[linux/fpc-iii.git] / drivers / input / misc / ad714x.c
blob2e5d5e1de64787f17c2349e1a3c575144411518f
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 unsigned long irqflags;
976
977 struct ad714x_button_drv *bt_drv;
978 struct ad714x_slider_drv *sd_drv;
979 struct ad714x_wheel_drv *wl_drv;
980 struct ad714x_touchpad_drv *tp_drv;
981
982
983 if (irq <= 0) {
984 dev_err(dev, "IRQ not configured!\n");
985 error = -EINVAL;
986 goto err_out;
987 }
988
989 if (dev->platform_data == NULL) {
990 dev_err(dev, "platform data for ad714x doesn't exist\n");
991 error = -EINVAL;
992 goto err_out;
993 }
994
995 ad714x = kzalloc(sizeof(*ad714x) + sizeof(*ad714x->sw) +
996 sizeof(*sd_drv) * plat_data->slider_num +
997 sizeof(*wl_drv) * plat_data->wheel_num +
998 sizeof(*tp_drv) * plat_data->touchpad_num +
999 sizeof(*bt_drv) * plat_data->button_num, GFP_KERNEL);
1000 if (!ad714x) {
1001 error = -ENOMEM;
1002 goto err_out;
1003 }
1004
1005 ad714x->hw = plat_data;
1006
1007 drv_mem = ad714x + 1;
1008 ad714x->sw = drv_mem;
1009 drv_mem += sizeof(*ad714x->sw);
1010 ad714x->sw->slider = sd_drv = drv_mem;
1011 drv_mem += sizeof(*sd_drv) * ad714x->hw->slider_num;
1012 ad714x->sw->wheel = wl_drv = drv_mem;
1013 drv_mem += sizeof(*wl_drv) * ad714x->hw->wheel_num;
1014 ad714x->sw->touchpad = tp_drv = drv_mem;
1015 drv_mem += sizeof(*tp_drv) * ad714x->hw->touchpad_num;
1016 ad714x->sw->button = bt_drv = drv_mem;
1017 drv_mem += sizeof(*bt_drv) * ad714x->hw->button_num;
1018
1019 ad714x->read = read;
1020 ad714x->write = write;
1021 ad714x->irq = irq;
1022 ad714x->dev = dev;
1023
1024 error = ad714x_hw_detect(ad714x);
1025 if (error)
1026 goto err_free_mem;
1027
1028 /* initialize and request sw/hw resources */
1029
1030 ad714x_hw_init(ad714x);
1031 mutex_init(&ad714x->mutex);
1032
1033 /*
1034 * Allocate and register AD714X input device
1035 */
1036 alloc_idx = 0;
1037
1038 /* a slider uses one input_dev instance */
1039 if (ad714x->hw->slider_num > 0) {
1040 struct ad714x_slider_plat *sd_plat = ad714x->hw->slider;
1041
1042 for (i = 0; i < ad714x->hw->slider_num; i++) {
1043 sd_drv[i].input = input[alloc_idx] = input_allocate_device();
1044 if (!input[alloc_idx]) {
1045 error = -ENOMEM;
1046 goto err_free_dev;
1047 }
1048
1049 __set_bit(EV_ABS, input[alloc_idx]->evbit);
1050 __set_bit(EV_KEY, input[alloc_idx]->evbit);
1051 __set_bit(ABS_X, input[alloc_idx]->absbit);
1052 __set_bit(BTN_TOUCH, input[alloc_idx]->keybit);
1053 input_set_abs_params(input[alloc_idx],
1054 ABS_X, 0, sd_plat->max_coord, 0, 0);
1055
1056 input[alloc_idx]->id.bustype = bus_type;
1057 input[alloc_idx]->id.product = ad714x->product;
1058 input[alloc_idx]->id.version = ad714x->version;
1059 input[alloc_idx]->name = "ad714x_captouch_slider";
1060 input[alloc_idx]->dev.parent = dev;
1061
1062 error = input_register_device(input[alloc_idx]);
1063 if (error)
1064 goto err_free_dev;
1065
1066 alloc_idx++;
1067 }
1068 }
1069
1070 /* a wheel uses one input_dev instance */
1071 if (ad714x->hw->wheel_num > 0) {
1072 struct ad714x_wheel_plat *wl_plat = ad714x->hw->wheel;
1073
1074 for (i = 0; i < ad714x->hw->wheel_num; i++) {
1075 wl_drv[i].input = input[alloc_idx] = input_allocate_device();
1076 if (!input[alloc_idx]) {
1077 error = -ENOMEM;
1078 goto err_free_dev;
1079 }
1080
1081 __set_bit(EV_KEY, input[alloc_idx]->evbit);
1082 __set_bit(EV_ABS, input[alloc_idx]->evbit);
1083 __set_bit(ABS_WHEEL, input[alloc_idx]->absbit);
1084 __set_bit(BTN_TOUCH, input[alloc_idx]->keybit);
1085 input_set_abs_params(input[alloc_idx],
1086 ABS_WHEEL, 0, wl_plat->max_coord, 0, 0);
1087
1088 input[alloc_idx]->id.bustype = bus_type;
1089 input[alloc_idx]->id.product = ad714x->product;
1090 input[alloc_idx]->id.version = ad714x->version;
1091 input[alloc_idx]->name = "ad714x_captouch_wheel";
1092 input[alloc_idx]->dev.parent = dev;
1093
1094 error = input_register_device(input[alloc_idx]);
1095 if (error)
1096 goto err_free_dev;
1097
1098 alloc_idx++;
1099 }
1100 }
1101
1102 /* a touchpad uses one input_dev instance */
1103 if (ad714x->hw->touchpad_num > 0) {
1104 struct ad714x_touchpad_plat *tp_plat = ad714x->hw->touchpad;
1105
1106 for (i = 0; i < ad714x->hw->touchpad_num; i++) {
1107 tp_drv[i].input = input[alloc_idx] = input_allocate_device();
1108 if (!input[alloc_idx]) {
1109 error = -ENOMEM;
1110 goto err_free_dev;
1111 }
1112
1113 __set_bit(EV_ABS, input[alloc_idx]->evbit);
1114 __set_bit(EV_KEY, input[alloc_idx]->evbit);
1115 __set_bit(ABS_X, input[alloc_idx]->absbit);
1116 __set_bit(ABS_Y, input[alloc_idx]->absbit);
1117 __set_bit(BTN_TOUCH, input[alloc_idx]->keybit);
1118 input_set_abs_params(input[alloc_idx],
1119 ABS_X, 0, tp_plat->x_max_coord, 0, 0);
1120 input_set_abs_params(input[alloc_idx],
1121 ABS_Y, 0, tp_plat->y_max_coord, 0, 0);
1122
1123 input[alloc_idx]->id.bustype = bus_type;
1124 input[alloc_idx]->id.product = ad714x->product;
1125 input[alloc_idx]->id.version = ad714x->version;
1126 input[alloc_idx]->name = "ad714x_captouch_pad";
1127 input[alloc_idx]->dev.parent = dev;
1128
1129 error = input_register_device(input[alloc_idx]);
1130 if (error)
1131 goto err_free_dev;
1132
1133 alloc_idx++;
1134 }
1135 }
1136
1137 /* all buttons use one input node */
1138 if (ad714x->hw->button_num > 0) {
1139 struct ad714x_button_plat *bt_plat = ad714x->hw->button;
1140
1141 input[alloc_idx] = input_allocate_device();
1142 if (!input[alloc_idx]) {
1143 error = -ENOMEM;
1144 goto err_free_dev;
1145 }
1146
1147 __set_bit(EV_KEY, input[alloc_idx]->evbit);
1148 for (i = 0; i < ad714x->hw->button_num; i++) {
1149 bt_drv[i].input = input[alloc_idx];
1150 __set_bit(bt_plat[i].keycode, input[alloc_idx]->keybit);
1151 }
1152
1153 input[alloc_idx]->id.bustype = bus_type;
1154 input[alloc_idx]->id.product = ad714x->product;
1155 input[alloc_idx]->id.version = ad714x->version;
1156 input[alloc_idx]->name = "ad714x_captouch_button";
1157 input[alloc_idx]->dev.parent = dev;
1158
1159 error = input_register_device(input[alloc_idx]);
1160 if (error)
1161 goto err_free_dev;
1162
1163 alloc_idx++;
1164 }
1165
1166 irqflags = plat_data->irqflags ?: IRQF_TRIGGER_FALLING;
1167 irqflags |= IRQF_ONESHOT;
1168
1169 error = request_threaded_irq(ad714x->irq, NULL, ad714x_interrupt_thread,
1170 irqflags, "ad714x_captouch", ad714x);
1171 if (error) {
1172 dev_err(dev, "can't allocate irq %d\n", ad714x->irq);
1173 goto err_unreg_dev;
1174 }
1175
1176 return ad714x;
1177
1178 err_free_dev:
1179 dev_err(dev, "failed to setup AD714x input device %i\n", alloc_idx);
1180 input_free_device(input[alloc_idx]);
1181 err_unreg_dev:
1182 while (--alloc_idx >= 0)
1183 input_unregister_device(input[alloc_idx]);
1184 err_free_mem:
1185 kfree(ad714x);
1186 err_out:
1187 return ERR_PTR(error);
1188 }
1189 EXPORT_SYMBOL(ad714x_probe);
1190
1191 void ad714x_remove(struct ad714x_chip *ad714x)
1192 {
1193 struct ad714x_platform_data *hw = ad714x->hw;
1194 struct ad714x_driver_data *sw = ad714x->sw;
1195 int i;
1196
1197 free_irq(ad714x->irq, ad714x);
1198
1199 /* unregister and free all input devices */
1200
1201 for (i = 0; i < hw->slider_num; i++)
1202 input_unregister_device(sw->slider[i].input);
1203
1204 for (i = 0; i < hw->wheel_num; i++)
1205 input_unregister_device(sw->wheel[i].input);
1206
1207 for (i = 0; i < hw->touchpad_num; i++)
1208 input_unregister_device(sw->touchpad[i].input);
1209
1210 if (hw->button_num)
1211 input_unregister_device(sw->button[0].input);
1212
1213 kfree(ad714x);
1214 }
1215 EXPORT_SYMBOL(ad714x_remove);
1216
1217 #ifdef CONFIG_PM
1218 int ad714x_disable(struct ad714x_chip *ad714x)
1219 {
1220 unsigned short data;
1221
1222 dev_dbg(ad714x->dev, "%s enter\n", __func__);
1223
1224 mutex_lock(&ad714x->mutex);
1225
1226 data = ad714x->hw->sys_cfg_reg[AD714X_PWR_CTRL] | 0x3;
1227 ad714x->write(ad714x, AD714X_PWR_CTRL, data);
1228
1229 mutex_unlock(&ad714x->mutex);
1230
1231 return 0;
1232 }
1233 EXPORT_SYMBOL(ad714x_disable);
1234
1235 int ad714x_enable(struct ad714x_chip *ad714x)
1236 {
1237 dev_dbg(ad714x->dev, "%s enter\n", __func__);
1238
1239 mutex_lock(&ad714x->mutex);
1240
1241 /* resume to non-shutdown mode */
1242
1243 ad714x->write(ad714x, AD714X_PWR_CTRL,
1244 ad714x->hw->sys_cfg_reg[AD714X_PWR_CTRL]);
1245
1246 /* make sure the interrupt output line is not low level after resume,
1247 * otherwise we will get no chance to enter falling-edge irq again
1248 */
1249
1250 ad714x->read(ad714x, STG_LOW_INT_STA_REG, &ad714x->l_state, 3);
1251
1252 mutex_unlock(&ad714x->mutex);
1253
1254 return 0;
1255 }
1256 EXPORT_SYMBOL(ad714x_enable);
1257 #endif
1258
1259 MODULE_DESCRIPTION("Analog Devices AD714X Capacitance Touch Sensor Driver");
1260 MODULE_AUTHOR("Barry Song <21cnbao@gmail.com>");
1261 MODULE_LICENSE("GPL");
Linux with added FPC-III support