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

source code of linux/drivers/input/misc/ad714x.c