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