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