Minki/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2024-12-15 15:41:58 +00:00
Code Issues Packages Projects Releases Wiki Activity
9dc75e79c0
linux/drivers/input/misc/ad714x.c
Thomas Gleixner 80503b23b2 treewide: Replace GPLv2 boilerplate/reference with SPDX - rule 149 
Based on 1 normalized pattern(s):

  licensed under the gpl 2 or later

extracted by the scancode license scanner the SPDX license identifier

  GPL-2.0-or-later

has been chosen to replace the boilerplate/reference in 82 file(s).

Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Reviewed-by: Allison Randal <allison@lohutok.net>
Reviewed-by: Kate Stewart <kstewart@linuxfoundation.org>
Reviewed-by: Richard Fontana <rfontana@redhat.com>
Cc: linux-spdx@vger.kernel.org
Link: https://lkml.kernel.org/r/20190524100845.150836982@linutronix.de
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2019-05-30 11:25:18 -07:00

1210 lines
34 KiB
C
Raw Blame History

// SPDX-License-Identifier: GPL-2.0-or-later
/*
* AD714X CapTouch Programmable Controller driver supporting AD7142/3/7/8/7A
*
* Copyright 2009-2011 Analog Devices Inc.
*/
#include <linux/device.h>
#include <linux/input.h>
#include <linux/interrupt.h>
#include <linux/slab.h>
#include <linux/input/ad714x.h>
#include <linux/module.h>
#include "ad714x.h"
#define AD714X_PWR_CTRL 0x0
#define AD714X_STG_CAL_EN_REG 0x1
#define AD714X_AMB_COMP_CTRL0_REG 0x2
#define AD714X_PARTID_REG 0x17
#define AD7142_PARTID 0xE620
#define AD7143_PARTID 0xE630
#define AD7147_PARTID 0x1470
#define AD7148_PARTID 0x1480
#define AD714X_STAGECFG_REG 0x80
#define AD714X_SYSCFG_REG 0x0
#define STG_LOW_INT_EN_REG 0x5
#define STG_HIGH_INT_EN_REG 0x6
#define STG_COM_INT_EN_REG 0x7
#define STG_LOW_INT_STA_REG 0x8
#define STG_HIGH_INT_STA_REG 0x9
#define STG_COM_INT_STA_REG 0xA
#define CDC_RESULT_S0 0xB
#define CDC_RESULT_S1 0xC
#define CDC_RESULT_S2 0xD
#define CDC_RESULT_S3 0xE
#define CDC_RESULT_S4 0xF
#define CDC_RESULT_S5 0x10
#define CDC_RESULT_S6 0x11
#define CDC_RESULT_S7 0x12
#define CDC_RESULT_S8 0x13
#define CDC_RESULT_S9 0x14
#define CDC_RESULT_S10 0x15
#define CDC_RESULT_S11 0x16
#define STAGE0_AMBIENT 0xF1
#define STAGE1_AMBIENT 0x115
#define STAGE2_AMBIENT 0x139
#define STAGE3_AMBIENT 0x15D
#define STAGE4_AMBIENT 0x181
#define STAGE5_AMBIENT 0x1A5
#define STAGE6_AMBIENT 0x1C9
#define STAGE7_AMBIENT 0x1ED
#define STAGE8_AMBIENT 0x211
#define STAGE9_AMBIENT 0x234
#define STAGE10_AMBIENT 0x259
#define STAGE11_AMBIENT 0x27D
#define PER_STAGE_REG_NUM 36
#define STAGE_CFGREG_NUM 8
#define SYS_CFGREG_NUM 8
/*
* driver information which will be used to maintain the software flow
*/
enum ad714x_device_state { IDLE, JITTER, ACTIVE, SPACE };
struct ad714x_slider_drv {
int highest_stage;
int abs_pos;
int flt_pos;
enum ad714x_device_state state;
struct input_dev *input;
};
struct ad714x_wheel_drv {
int abs_pos;
int flt_pos;
int pre_highest_stage;
int highest_stage;
enum ad714x_device_state state;
struct input_dev *input;
};
struct ad714x_touchpad_drv {
int x_highest_stage;
int x_flt_pos;
int x_abs_pos;
int y_highest_stage;
int y_flt_pos;
int y_abs_pos;
int left_ep;
int left_ep_val;
int right_ep;
int right_ep_val;
int top_ep;
int top_ep_val;
int bottom_ep;
int bottom_ep_val;
enum ad714x_device_state state;
struct input_dev *input;
};
struct ad714x_button_drv {
enum ad714x_device_state state;
/*
* Unlike slider/wheel/touchpad, all buttons point to
* same input_dev instance
*/
struct input_dev *input;
};
struct ad714x_driver_data {
struct ad714x_slider_drv *slider;
struct ad714x_wheel_drv *wheel;
struct ad714x_touchpad_drv *touchpad;
struct ad714x_button_drv *button;
};
/*
* information to integrate all things which will be private data
* of spi/i2c device
*/
static void ad714x_use_com_int(struct ad714x_chip *ad714x,
int start_stage, int end_stage)
{
unsigned short data;
unsigned short mask;
mask = ((1 << (end_stage + 1)) - 1) - ((1 << start_stage) - 1);
ad714x->read(ad714x, STG_COM_INT_EN_REG, &data, 1);
data |= 1 << end_stage;
ad714x->write(ad714x, STG_COM_INT_EN_REG, data);
ad714x->read(ad714x, STG_HIGH_INT_EN_REG, &data, 1);
data &= ~mask;
ad714x->write(ad714x, STG_HIGH_INT_EN_REG, data);
}
static void ad714x_use_thr_int(struct ad714x_chip *ad714x,
int start_stage, int end_stage)
{
unsigned short data;
unsigned short mask;
mask = ((1 << (end_stage + 1)) - 1) - ((1 << start_stage) - 1);
ad714x->read(ad714x, STG_COM_INT_EN_REG, &data, 1);
data &= ~(1 << end_stage);
ad714x->write(ad714x, STG_COM_INT_EN_REG, data);
ad714x->read(ad714x, STG_HIGH_INT_EN_REG, &data, 1);
data |= mask;
ad714x->write(ad714x, STG_HIGH_INT_EN_REG, data);
}
static int ad714x_cal_highest_stage(struct ad714x_chip *ad714x,
int start_stage, int end_stage)
{
int max_res = 0;
int max_idx = 0;
int i;
for (i = start_stage; i <= end_stage; i++) {
if (ad714x->sensor_val[i] > max_res) {
max_res = ad714x->sensor_val[i];
max_idx = i;
}
}
return max_idx;
}
static int ad714x_cal_abs_pos(struct ad714x_chip *ad714x,
int start_stage, int end_stage,
int highest_stage, int max_coord)
{
int a_param, b_param;
if (highest_stage == start_stage) {
a_param = ad714x->sensor_val[start_stage + 1];
b_param = ad714x->sensor_val[start_stage] +
ad714x->sensor_val[start_stage + 1];
} else if (highest_stage == end_stage) {
a_param = ad714x->sensor_val[end_stage] *
(end_stage - start_stage) +
ad714x->sensor_val[end_stage - 1] *
(end_stage - start_stage - 1);
b_param = ad714x->sensor_val[end_stage] +
ad714x->sensor_val[end_stage - 1];
} else {
a_param = ad714x->sensor_val[highest_stage] *
(highest_stage - start_stage) +
ad714x->sensor_val[highest_stage - 1] *
(highest_stage - start_stage - 1) +
ad714x->sensor_val[highest_stage + 1] *
(highest_stage - start_stage + 1);
b_param = ad714x->sensor_val[highest_stage] +
ad714x->sensor_val[highest_stage - 1] +
ad714x->sensor_val[highest_stage + 1];
}
return (max_coord / (end_stage - start_stage)) * a_param / b_param;
}
/*
* One button can connect to multi positive and negative of CDCs
* Multi-buttons can connect to same positive/negative of one CDC
*/
static void ad714x_button_state_machine(struct ad714x_chip *ad714x, int idx)
{
struct ad714x_button_plat *hw = &ad714x->hw->button[idx];
struct ad714x_button_drv *sw = &ad714x->sw->button[idx];
switch (sw->state) {
case IDLE:
if (((ad714x->h_state & hw->h_mask) == hw->h_mask) &&
((ad714x->l_state & hw->l_mask) == hw->l_mask)) {
dev_dbg(ad714x->dev, "button %d touched\n", idx);
input_report_key(sw->input, hw->keycode, 1);
input_sync(sw->input);
sw->state = ACTIVE;
}
break;
case ACTIVE:
if (((ad714x->h_state & hw->h_mask) != hw->h_mask) ||
((ad714x->l_state & hw->l_mask) != hw->l_mask)) {
dev_dbg(ad714x->dev, "button %d released\n", idx);
input_report_key(sw->input, hw->keycode, 0);
input_sync(sw->input);
sw->state = IDLE;
}
break;
default:
break;
}
}
/*
* The response of a sensor is defined by the absolute number of codes
* between the current CDC value and the ambient value.
*/
static void ad714x_slider_cal_sensor_val(struct ad714x_chip *ad714x, int idx)
{
struct ad714x_slider_plat *hw = &ad714x->hw->slider[idx];
int i;
ad714x->read(ad714x, CDC_RESULT_S0 + hw->start_stage,
&ad714x->adc_reg[hw->start_stage],
hw->end_stage - hw->start_stage + 1);
for (i = hw->start_stage; i <= hw->end_stage; i++) {
ad714x->read(ad714x, STAGE0_AMBIENT + i * PER_STAGE_REG_NUM,
&ad714x->amb_reg[i], 1);
ad714x->sensor_val[i] =
abs(ad714x->adc_reg[i] - ad714x->amb_reg[i]);
}
}
static void ad714x_slider_cal_highest_stage(struct ad714x_chip *ad714x, int idx)
{
struct ad714x_slider_plat *hw = &ad714x->hw->slider[idx];
struct ad714x_slider_drv *sw = &ad714x->sw->slider[idx];
sw->highest_stage = ad714x_cal_highest_stage(ad714x, hw->start_stage,
hw->end_stage);
dev_dbg(ad714x->dev, "slider %d highest_stage:%d\n", idx,
sw->highest_stage);
}
/*
* The formulae are very straight forward. It uses the sensor with the
* highest response and the 2 adjacent ones.
* When Sensor 0 has the highest response, only sensor 0 and sensor 1
* are used in the calculations. Similarly when the last sensor has the
* highest response, only the last sensor and the second last sensors
* are used in the calculations.
*
* For i= idx_of_peak_Sensor-1 to i= idx_of_peak_Sensor+1
* v += Sensor response(i)*i
* w += Sensor response(i)
* POS=(Number_of_Positions_Wanted/(Number_of_Sensors_Used-1)) *(v/w)
*/
static void ad714x_slider_cal_abs_pos(struct ad714x_chip *ad714x, int idx)
{
struct ad714x_slider_plat *hw = &ad714x->hw->slider[idx];
struct ad714x_slider_drv *sw = &ad714x->sw->slider[idx];
sw->abs_pos = ad714x_cal_abs_pos(ad714x, hw->start_stage, hw->end_stage,
sw->highest_stage, hw->max_coord);
dev_dbg(ad714x->dev, "slider %d absolute position:%d\n", idx,
sw->abs_pos);
}
/*
* To minimise the Impact of the noise on the algorithm, ADI developed a
* routine that filters the CDC results after they have been read by the
* host processor.
* The filter used is an Infinite Input Response(IIR) filter implemented
* in firmware and attenuates the noise on the CDC results after they've
* been read by the host processor.
* Filtered_CDC_result = (Filtered_CDC_result * (10 - Coefficient) +
* Latest_CDC_result * Coefficient)/10
*/
static void ad714x_slider_cal_flt_pos(struct ad714x_chip *ad714x, int idx)
{
struct ad714x_slider_drv *sw = &ad714x->sw->slider[idx];
sw->flt_pos = (sw->flt_pos * (10 - 4) +
sw->abs_pos * 4)/10;
dev_dbg(ad714x->dev, "slider %d filter position:%d\n", idx,
sw->flt_pos);
}
static void ad714x_slider_use_com_int(struct ad714x_chip *ad714x, int idx)
{
struct ad714x_slider_plat *hw = &ad714x->hw->slider[idx];
ad714x_use_com_int(ad714x, hw->start_stage, hw->end_stage);
}
static void ad714x_slider_use_thr_int(struct ad714x_chip *ad714x, int idx)
{
struct ad714x_slider_plat *hw = &ad714x->hw->slider[idx];
ad714x_use_thr_int(ad714x, hw->start_stage, hw->end_stage);
}
static void ad714x_slider_state_machine(struct ad714x_chip *ad714x, int idx)
{
struct ad714x_slider_plat *hw = &ad714x->hw->slider[idx];
struct ad714x_slider_drv *sw = &ad714x->sw->slider[idx];
unsigned short h_state, c_state;
unsigned short mask;
mask = ((1 << (hw->end_stage + 1)) - 1) - ((1 << hw->start_stage) - 1);
h_state = ad714x->h_state & mask;
c_state = ad714x->c_state & mask;
switch (sw->state) {
case IDLE:
if (h_state) {
sw->state = JITTER;
/* In End of Conversion interrupt mode, the AD714X
* continuously generates hardware interrupts.
*/
ad714x_slider_use_com_int(ad714x, idx);
dev_dbg(ad714x->dev, "slider %d touched\n", idx);
}
break;
case JITTER:
if (c_state == mask) {
ad714x_slider_cal_sensor_val(ad714x, idx);
ad714x_slider_cal_highest_stage(ad714x, idx);
ad714x_slider_cal_abs_pos(ad714x, idx);
sw->flt_pos = sw->abs_pos;
sw->state = ACTIVE;
}
break;
case ACTIVE:
if (c_state == mask) {
if (h_state) {
ad714x_slider_cal_sensor_val(ad714x, idx);
ad714x_slider_cal_highest_stage(ad714x, idx);
ad714x_slider_cal_abs_pos(ad714x, idx);
ad714x_slider_cal_flt_pos(ad714x, idx);
input_report_abs(sw->input, ABS_X, sw->flt_pos);
input_report_key(sw->input, BTN_TOUCH, 1);
} else {
/* When the user lifts off the sensor, configure
* the AD714X back to threshold interrupt mode.
*/
ad714x_slider_use_thr_int(ad714x, idx);
sw->state = IDLE;
input_report_key(sw->input, BTN_TOUCH, 0);
dev_dbg(ad714x->dev, "slider %d released\n",
idx);
}
input_sync(sw->input);
}
break;
default:
break;
}
}
/*
* When the scroll wheel is activated, we compute the absolute position based
* on the sensor values. To calculate the position, we first determine the
* sensor that has the greatest response among the 8 sensors that constitutes
* the scrollwheel. Then we determined the 2 sensors on either sides of the
* sensor with the highest response and we apply weights to these sensors.
*/
static void ad714x_wheel_cal_highest_stage(struct ad714x_chip *ad714x, int idx)
{
struct ad714x_wheel_plat *hw = &ad714x->hw->wheel[idx];
struct ad714x_wheel_drv *sw = &ad714x->sw->wheel[idx];
sw->pre_highest_stage = sw->highest_stage;
sw->highest_stage = ad714x_cal_highest_stage(ad714x, hw->start_stage,
hw->end_stage);
dev_dbg(ad714x->dev, "wheel %d highest_stage:%d\n", idx,
sw->highest_stage);
}
static void ad714x_wheel_cal_sensor_val(struct ad714x_chip *ad714x, int idx)
{
struct ad714x_wheel_plat *hw = &ad714x->hw->wheel[idx];
int i;
ad714x->read(ad714x, CDC_RESULT_S0 + hw->start_stage,
&ad714x->adc_reg[hw->start_stage],
hw->end_stage - hw->start_stage + 1);
for (i = hw->start_stage; i <= hw->end_stage; i++) {
ad714x->read(ad714x, STAGE0_AMBIENT + i * PER_STAGE_REG_NUM,
&ad714x->amb_reg[i], 1);
if (ad714x->adc_reg[i] > ad714x->amb_reg[i])
ad714x->sensor_val[i] =
ad714x->adc_reg[i] - ad714x->amb_reg[i];
else
ad714x->sensor_val[i] = 0;
}
}
/*
* When the scroll wheel is activated, we compute the absolute position based
* on the sensor values. To calculate the position, we first determine the
* sensor that has the greatest response among the sensors that constitutes
* the scrollwheel. Then we determined the sensors on either sides of the
* sensor with the highest response and we apply weights to these sensors. The
* result of this computation gives us the mean value.
*/
static void ad714x_wheel_cal_abs_pos(struct ad714x_chip *ad714x, int idx)
{
struct ad714x_wheel_plat *hw = &ad714x->hw->wheel[idx];
struct ad714x_wheel_drv *sw = &ad714x->sw->wheel[idx];
int stage_num = hw->end_stage - hw->start_stage + 1;
int first_before, highest, first_after;
int a_param, b_param;
first_before = (sw->highest_stage + stage_num - 1) % stage_num;
highest = sw->highest_stage;
first_after = (sw->highest_stage + stage_num + 1) % stage_num;
a_param = ad714x->sensor_val[highest] *
(highest - hw->start_stage) +
ad714x->sensor_val[first_before] *
(highest - hw->start_stage - 1) +
ad714x->sensor_val[first_after] *
(highest - hw->start_stage + 1);
b_param = ad714x->sensor_val[highest] +
ad714x->sensor_val[first_before] +
ad714x->sensor_val[first_after];
sw->abs_pos = ((hw->max_coord / (hw->end_stage - hw->start_stage)) *
a_param) / b_param;
if (sw->abs_pos > hw->max_coord)
sw->abs_pos = hw->max_coord;
else if (sw->abs_pos < 0)
sw->abs_pos = 0;
}
static void ad714x_wheel_cal_flt_pos(struct ad714x_chip *ad714x, int idx)
{
struct ad714x_wheel_plat *hw = &ad714x->hw->wheel[idx];
struct ad714x_wheel_drv *sw = &ad714x->sw->wheel[idx];
if (((sw->pre_highest_stage == hw->end_stage) &&
(sw->highest_stage == hw->start_stage)) ||
((sw->pre_highest_stage == hw->start_stage) &&
(sw->highest_stage == hw->end_stage)))
sw->flt_pos = sw->abs_pos;
else
sw->flt_pos = ((sw->flt_pos * 30) + (sw->abs_pos * 71)) / 100;
if (sw->flt_pos > hw->max_coord)
sw->flt_pos = hw->max_coord;
}
static void ad714x_wheel_use_com_int(struct ad714x_chip *ad714x, int idx)
{
struct ad714x_wheel_plat *hw = &ad714x->hw->wheel[idx];
ad714x_use_com_int(ad714x, hw->start_stage, hw->end_stage);
}
static void ad714x_wheel_use_thr_int(struct ad714x_chip *ad714x, int idx)
{
struct ad714x_wheel_plat *hw = &ad714x->hw->wheel[idx];
ad714x_use_thr_int(ad714x, hw->start_stage, hw->end_stage);
}
static void ad714x_wheel_state_machine(struct ad714x_chip *ad714x, int idx)
{
struct ad714x_wheel_plat *hw = &ad714x->hw->wheel[idx];
struct ad714x_wheel_drv *sw = &ad714x->sw->wheel[idx];
unsigned short h_state, c_state;
unsigned short mask;
mask = ((1 << (hw->end_stage + 1)) - 1) - ((1 << hw->start_stage) - 1);
h_state = ad714x->h_state & mask;
c_state = ad714x->c_state & mask;
switch (sw->state) {
case IDLE:
if (h_state) {
sw->state = JITTER;
/* In End of Conversion interrupt mode, the AD714X
* continuously generates hardware interrupts.
*/
ad714x_wheel_use_com_int(ad714x, idx);
dev_dbg(ad714x->dev, "wheel %d touched\n", idx);
}
break;
case JITTER:
if (c_state == mask) {
ad714x_wheel_cal_sensor_val(ad714x, idx);
ad714x_wheel_cal_highest_stage(ad714x, idx);
ad714x_wheel_cal_abs_pos(ad714x, idx);
sw->flt_pos = sw->abs_pos;
sw->state = ACTIVE;
}
break;
case ACTIVE:
if (c_state == mask) {
if (h_state) {
ad714x_wheel_cal_sensor_val(ad714x, idx);
ad714x_wheel_cal_highest_stage(ad714x, idx);
ad714x_wheel_cal_abs_pos(ad714x, idx);
ad714x_wheel_cal_flt_pos(ad714x, idx);
input_report_abs(sw->input, ABS_WHEEL,
sw->flt_pos);
input_report_key(sw->input, BTN_TOUCH, 1);
} else {
/* When the user lifts off the sensor, configure
* the AD714X back to threshold interrupt mode.
*/
ad714x_wheel_use_thr_int(ad714x, idx);
sw->state = IDLE;
input_report_key(sw->input, BTN_TOUCH, 0);
dev_dbg(ad714x->dev, "wheel %d released\n",
idx);
}
input_sync(sw->input);
}
break;
default:
break;
}
}
static void touchpad_cal_sensor_val(struct ad714x_chip *ad714x, int idx)
{
struct ad714x_touchpad_plat *hw = &ad714x->hw->touchpad[idx];
int i;
ad714x->read(ad714x, CDC_RESULT_S0 + hw->x_start_stage,
&ad714x->adc_reg[hw->x_start_stage],
hw->x_end_stage - hw->x_start_stage + 1);
for (i = hw->x_start_stage; i <= hw->x_end_stage; i++) {
ad714x->read(ad714x, STAGE0_AMBIENT + i * PER_STAGE_REG_NUM,
&ad714x->amb_reg[i], 1);
if (ad714x->adc_reg[i] > ad714x->amb_reg[i])
ad714x->sensor_val[i] =
ad714x->adc_reg[i] - ad714x->amb_reg[i];
else
ad714x->sensor_val[i] = 0;
}
}
static void touchpad_cal_highest_stage(struct ad714x_chip *ad714x, int idx)
{
struct ad714x_touchpad_plat *hw = &ad714x->hw->touchpad[idx];
struct ad714x_touchpad_drv *sw = &ad714x->sw->touchpad[idx];
sw->x_highest_stage = ad714x_cal_highest_stage(ad714x,
hw->x_start_stage, hw->x_end_stage);
sw->y_highest_stage = ad714x_cal_highest_stage(ad714x,
hw->y_start_stage, hw->y_end_stage);
dev_dbg(ad714x->dev,
"touchpad %d x_highest_stage:%d, y_highest_stage:%d\n",
idx, sw->x_highest_stage, sw->y_highest_stage);
}
/*
* If 2 fingers are touching the sensor then 2 peaks can be observed in the
* distribution.
* The arithmetic doesn't support to get absolute coordinates for multi-touch
* yet.
*/
static int touchpad_check_second_peak(struct ad714x_chip *ad714x, int idx)
{
struct ad714x_touchpad_plat *hw = &ad714x->hw->touchpad[idx];
struct ad714x_touchpad_drv *sw = &ad714x->sw->touchpad[idx];
int i;
for (i = hw->x_start_stage; i < sw->x_highest_stage; i++) {
if ((ad714x->sensor_val[i] - ad714x->sensor_val[i + 1])
> (ad714x->sensor_val[i + 1] / 10))
return 1;
}
for (i = sw->x_highest_stage; i < hw->x_end_stage; i++) {
if ((ad714x->sensor_val[i + 1] - ad714x->sensor_val[i])
> (ad714x->sensor_val[i] / 10))
return 1;
}
for (i = hw->y_start_stage; i < sw->y_highest_stage; i++) {
if ((ad714x->sensor_val[i] - ad714x->sensor_val[i + 1])
> (ad714x->sensor_val[i + 1] / 10))
return 1;
}
for (i = sw->y_highest_stage; i < hw->y_end_stage; i++) {
if ((ad714x->sensor_val[i + 1] - ad714x->sensor_val[i])
> (ad714x->sensor_val[i] / 10))
return 1;
}
return 0;
}
/*
* If only one finger is used to activate the touch pad then only 1 peak will be
* registered in the distribution. This peak and the 2 adjacent sensors will be
* used in the calculation of the absolute position. This will prevent hand
* shadows to affect the absolute position calculation.
*/
static void touchpad_cal_abs_pos(struct ad714x_chip *ad714x, int idx)
{
struct ad714x_touchpad_plat *hw = &ad714x->hw->touchpad[idx];
struct ad714x_touchpad_drv *sw = &ad714x->sw->touchpad[idx];
sw->x_abs_pos = ad714x_cal_abs_pos(ad714x, hw->x_start_stage,
hw->x_end_stage, sw->x_highest_stage, hw->x_max_coord);
sw->y_abs_pos = ad714x_cal_abs_pos(ad714x, hw->y_start_stage,
hw->y_end_stage, sw->y_highest_stage, hw->y_max_coord);
dev_dbg(ad714x->dev, "touchpad %d absolute position:(%d, %d)\n", idx,
sw->x_abs_pos, sw->y_abs_pos);
}
static void touchpad_cal_flt_pos(struct ad714x_chip *ad714x, int idx)
{
struct ad714x_touchpad_drv *sw = &ad714x->sw->touchpad[idx];
sw->x_flt_pos = (sw->x_flt_pos * (10 - 4) +
sw->x_abs_pos * 4)/10;
sw->y_flt_pos = (sw->y_flt_pos * (10 - 4) +
sw->y_abs_pos * 4)/10;
dev_dbg(ad714x->dev, "touchpad %d filter position:(%d, %d)\n",
idx, sw->x_flt_pos, sw->y_flt_pos);
}
/*
* To prevent distortion from showing in the absolute position, it is
* necessary to detect the end points. When endpoints are detected, the
* driver stops updating the status variables with absolute positions.
* End points are detected on the 4 edges of the touchpad sensor. The
* method to detect them is the same for all 4.
* To detect the end points, the firmware computes the difference in
* percent between the sensor on the edge and the adjacent one. The
* difference is calculated in percent in order to make the end point
* detection independent of the pressure.
*/
#define LEFT_END_POINT_DETECTION_LEVEL 550
#define RIGHT_END_POINT_DETECTION_LEVEL 750
#define LEFT_RIGHT_END_POINT_DEAVTIVALION_LEVEL 850
#define TOP_END_POINT_DETECTION_LEVEL 550
#define BOTTOM_END_POINT_DETECTION_LEVEL 950
#define TOP_BOTTOM_END_POINT_DEAVTIVALION_LEVEL 700
static int touchpad_check_endpoint(struct ad714x_chip *ad714x, int idx)
{
struct ad714x_touchpad_plat *hw = &ad714x->hw->touchpad[idx];
struct ad714x_touchpad_drv *sw = &ad714x->sw->touchpad[idx];
int percent_sensor_diff;
/* left endpoint detect */
percent_sensor_diff = (ad714x->sensor_val[hw->x_start_stage] -
ad714x->sensor_val[hw->x_start_stage + 1]) * 100 /
ad714x->sensor_val[hw->x_start_stage + 1];
if (!sw->left_ep) {
if (percent_sensor_diff >= LEFT_END_POINT_DETECTION_LEVEL) {
sw->left_ep = 1;
sw->left_ep_val =
ad714x->sensor_val[hw->x_start_stage + 1];
}
} else {
if ((percent_sensor_diff < LEFT_END_POINT_DETECTION_LEVEL) &&
(ad714x->sensor_val[hw->x_start_stage + 1] >
LEFT_RIGHT_END_POINT_DEAVTIVALION_LEVEL + sw->left_ep_val))
sw->left_ep = 0;
}
/* right endpoint detect */
percent_sensor_diff = (ad714x->sensor_val[hw->x_end_stage] -
ad714x->sensor_val[hw->x_end_stage - 1]) * 100 /
ad714x->sensor_val[hw->x_end_stage - 1];
if (!sw->right_ep) {
if (percent_sensor_diff >= RIGHT_END_POINT_DETECTION_LEVEL) {
sw->right_ep = 1;
sw->right_ep_val =
ad714x->sensor_val[hw->x_end_stage - 1];
}
} else {
if ((percent_sensor_diff < RIGHT_END_POINT_DETECTION_LEVEL) &&
(ad714x->sensor_val[hw->x_end_stage - 1] >
LEFT_RIGHT_END_POINT_DEAVTIVALION_LEVEL + sw->right_ep_val))
sw->right_ep = 0;
}
/* top endpoint detect */
percent_sensor_diff = (ad714x->sensor_val[hw->y_start_stage] -
ad714x->sensor_val[hw->y_start_stage + 1]) * 100 /
ad714x->sensor_val[hw->y_start_stage + 1];
if (!sw->top_ep) {
if (percent_sensor_diff >= TOP_END_POINT_DETECTION_LEVEL) {
sw->top_ep = 1;
sw->top_ep_val =
ad714x->sensor_val[hw->y_start_stage + 1];
}
} else {
if ((percent_sensor_diff < TOP_END_POINT_DETECTION_LEVEL) &&
(ad714x->sensor_val[hw->y_start_stage + 1] >
TOP_BOTTOM_END_POINT_DEAVTIVALION_LEVEL + sw->top_ep_val))
sw->top_ep = 0;
}
/* bottom endpoint detect */
percent_sensor_diff = (ad714x->sensor_val[hw->y_end_stage] -
ad714x->sensor_val[hw->y_end_stage - 1]) * 100 /
ad714x->sensor_val[hw->y_end_stage - 1];
if (!sw->bottom_ep) {
if (percent_sensor_diff >= BOTTOM_END_POINT_DETECTION_LEVEL) {
sw->bottom_ep = 1;
sw->bottom_ep_val =
ad714x->sensor_val[hw->y_end_stage - 1];
}
} else {
if ((percent_sensor_diff < BOTTOM_END_POINT_DETECTION_LEVEL) &&
(ad714x->sensor_val[hw->y_end_stage - 1] >
TOP_BOTTOM_END_POINT_DEAVTIVALION_LEVEL + sw->bottom_ep_val))
sw->bottom_ep = 0;
}
return sw->left_ep || sw->right_ep || sw->top_ep || sw->bottom_ep;
}
static void touchpad_use_com_int(struct ad714x_chip *ad714x, int idx)
{
struct ad714x_touchpad_plat *hw = &ad714x->hw->touchpad[idx];
ad714x_use_com_int(ad714x, hw->x_start_stage, hw->x_end_stage);
}
static void touchpad_use_thr_int(struct ad714x_chip *ad714x, int idx)
{
struct ad714x_touchpad_plat *hw = &ad714x->hw->touchpad[idx];
ad714x_use_thr_int(ad714x, hw->x_start_stage, hw->x_end_stage);
ad714x_use_thr_int(ad714x, hw->y_start_stage, hw->y_end_stage);
}
static void ad714x_touchpad_state_machine(struct ad714x_chip *ad714x, int idx)
{
struct ad714x_touchpad_plat *hw = &ad714x->hw->touchpad[idx];
struct ad714x_touchpad_drv *sw = &ad714x->sw->touchpad[idx];
unsigned short h_state, c_state;
unsigned short mask;
mask = (((1 << (hw->x_end_stage + 1)) - 1) -
((1 << hw->x_start_stage) - 1)) +
(((1 << (hw->y_end_stage + 1)) - 1) -
((1 << hw->y_start_stage) - 1));
h_state = ad714x->h_state & mask;
c_state = ad714x->c_state & mask;
switch (sw->state) {
case IDLE:
if (h_state) {
sw->state = JITTER;
/* In End of Conversion interrupt mode, the AD714X
* continuously generates hardware interrupts.
*/
touchpad_use_com_int(ad714x, idx);
dev_dbg(ad714x->dev, "touchpad %d touched\n", idx);
}
break;
case JITTER:
if (c_state == mask) {
touchpad_cal_sensor_val(ad714x, idx);
touchpad_cal_highest_stage(ad714x, idx);
if ((!touchpad_check_second_peak(ad714x, idx)) &&
(!touchpad_check_endpoint(ad714x, idx))) {
dev_dbg(ad714x->dev,
"touchpad%d, 2 fingers or endpoint\n",
idx);
touchpad_cal_abs_pos(ad714x, idx);
sw->x_flt_pos = sw->x_abs_pos;
sw->y_flt_pos = sw->y_abs_pos;
sw->state = ACTIVE;
}
}
break;
case ACTIVE:
if (c_state == mask) {
if (h_state) {
touchpad_cal_sensor_val(ad714x, idx);
touchpad_cal_highest_stage(ad714x, idx);
if ((!touchpad_check_second_peak(ad714x, idx))
&& (!touchpad_check_endpoint(ad714x, idx))) {
touchpad_cal_abs_pos(ad714x, idx);
touchpad_cal_flt_pos(ad714x, idx);
input_report_abs(sw->input, ABS_X,
sw->x_flt_pos);
input_report_abs(sw->input, ABS_Y,
sw->y_flt_pos);
input_report_key(sw->input, BTN_TOUCH,
1);
}
} else {
/* When the user lifts off the sensor, configure
* the AD714X back to threshold interrupt mode.
*/
touchpad_use_thr_int(ad714x, idx);
sw->state = IDLE;
input_report_key(sw->input, BTN_TOUCH, 0);
dev_dbg(ad714x->dev, "touchpad %d released\n",
idx);
}
input_sync(sw->input);
}
break;
default:
break;
}
}
static int ad714x_hw_detect(struct ad714x_chip *ad714x)
{
unsigned short data;
ad714x->read(ad714x, AD714X_PARTID_REG, &data, 1);
switch (data & 0xFFF0) {
case AD7142_PARTID:
ad714x->product = 0x7142;
ad714x->version = data & 0xF;
dev_info(ad714x->dev, "found AD7142 captouch, rev:%d\n",
ad714x->version);
return 0;
case AD7143_PARTID:
ad714x->product = 0x7143;
ad714x->version = data & 0xF;
dev_info(ad714x->dev, "found AD7143 captouch, rev:%d\n",
ad714x->version);
return 0;
case AD7147_PARTID:
ad714x->product = 0x7147;
ad714x->version = data & 0xF;
dev_info(ad714x->dev, "found AD7147(A) captouch, rev:%d\n",
ad714x->version);
return 0;
case AD7148_PARTID:
ad714x->product = 0x7148;
ad714x->version = data & 0xF;
dev_info(ad714x->dev, "found AD7148 captouch, rev:%d\n",
ad714x->version);
return 0;
default:
dev_err(ad714x->dev,
"fail to detect AD714X captouch, read ID is %04x\n",
data);
return -ENODEV;
}
}
static void ad714x_hw_init(struct ad714x_chip *ad714x)
{
int i, j;
unsigned short reg_base;
unsigned short data;
/* configuration CDC and interrupts */
for (i = 0; i < STAGE_NUM; i++) {
reg_base = AD714X_STAGECFG_REG + i * STAGE_CFGREG_NUM;
for (j = 0; j < STAGE_CFGREG_NUM; j++)
ad714x->write(ad714x, reg_base + j,
ad714x->hw->stage_cfg_reg[i][j]);
}
for (i = 0; i < SYS_CFGREG_NUM; i++)
ad714x->write(ad714x, AD714X_SYSCFG_REG + i,
ad714x->hw->sys_cfg_reg[i]);
for (i = 0; i < SYS_CFGREG_NUM; i++)
ad714x->read(ad714x, AD714X_SYSCFG_REG + i, &data, 1);
ad714x->write(ad714x, AD714X_STG_CAL_EN_REG, 0xFFF);
/* clear all interrupts */
ad714x->read(ad714x, STG_LOW_INT_STA_REG, &ad714x->l_state, 3);
}
static irqreturn_t ad714x_interrupt_thread(int irq, void *data)
{
struct ad714x_chip *ad714x = data;
int i;
mutex_lock(&ad714x->mutex);
ad714x->read(ad714x, STG_LOW_INT_STA_REG, &ad714x->l_state, 3);
for (i = 0; i < ad714x->hw->button_num; i++)
ad714x_button_state_machine(ad714x, i);
for (i = 0; i < ad714x->hw->slider_num; i++)
ad714x_slider_state_machine(ad714x, i);
for (i = 0; i < ad714x->hw->wheel_num; i++)
ad714x_wheel_state_machine(ad714x, i);
for (i = 0; i < ad714x->hw->touchpad_num; i++)
ad714x_touchpad_state_machine(ad714x, i);
mutex_unlock(&ad714x->mutex);
return IRQ_HANDLED;
}
struct ad714x_chip *ad714x_probe(struct device *dev, u16 bus_type, int irq,
ad714x_read_t read, ad714x_write_t write)
{
int i;
int error;
struct input_dev *input;
struct ad714x_platform_data *plat_data = dev_get_platdata(dev);
struct ad714x_chip *ad714x;
void *drv_mem;
unsigned long irqflags;
struct ad714x_button_drv *bt_drv;
struct ad714x_slider_drv *sd_drv;
struct ad714x_wheel_drv *wl_drv;
struct ad714x_touchpad_drv *tp_drv;
if (irq <= 0) {
dev_err(dev, "IRQ not configured!\n");
error = -EINVAL;
return ERR_PTR(error);
}
if (dev_get_platdata(dev) == NULL) {
dev_err(dev, "platform data for ad714x doesn't exist\n");
error = -EINVAL;
return ERR_PTR(error);
}
ad714x = devm_kzalloc(dev, sizeof(*ad714x) + sizeof(*ad714x->sw) +
sizeof(*sd_drv) * plat_data->slider_num +
sizeof(*wl_drv) * plat_data->wheel_num +
sizeof(*tp_drv) * plat_data->touchpad_num +
sizeof(*bt_drv) * plat_data->button_num,
GFP_KERNEL);
if (!ad714x) {
error = -ENOMEM;
return ERR_PTR(error);
}
ad714x->hw = plat_data;
drv_mem = ad714x + 1;
ad714x->sw = drv_mem;
drv_mem += sizeof(*ad714x->sw);
ad714x->sw->slider = sd_drv = drv_mem;
drv_mem += sizeof(*sd_drv) * ad714x->hw->slider_num;
ad714x->sw->wheel = wl_drv = drv_mem;
drv_mem += sizeof(*wl_drv) * ad714x->hw->wheel_num;
ad714x->sw->touchpad = tp_drv = drv_mem;
drv_mem += sizeof(*tp_drv) * ad714x->hw->touchpad_num;
ad714x->sw->button = bt_drv = drv_mem;
drv_mem += sizeof(*bt_drv) * ad714x->hw->button_num;
ad714x->read = read;
ad714x->write = write;
ad714x->irq = irq;
ad714x->dev = dev;
error = ad714x_hw_detect(ad714x);
if (error)
return ERR_PTR(error);
/* initialize and request sw/hw resources */
ad714x_hw_init(ad714x);
mutex_init(&ad714x->mutex);
/* a slider uses one input_dev instance */
if (ad714x->hw->slider_num > 0) {
struct ad714x_slider_plat *sd_plat = ad714x->hw->slider;
for (i = 0; i < ad714x->hw->slider_num; i++) {
input = devm_input_allocate_device(dev);
if (!input)
return ERR_PTR(-ENOMEM);
__set_bit(EV_ABS, input->evbit);
__set_bit(EV_KEY, input->evbit);
__set_bit(ABS_X, input->absbit);
__set_bit(BTN_TOUCH, input->keybit);
input_set_abs_params(input,
ABS_X, 0, sd_plat->max_coord, 0, 0);
input->id.bustype = bus_type;
input->id.product = ad714x->product;
input->id.version = ad714x->version;
input->name = "ad714x_captouch_slider";
input->dev.parent = dev;
error = input_register_device(input);
if (error)
return ERR_PTR(error);
sd_drv[i].input = input;
}
}
/* a wheel uses one input_dev instance */
if (ad714x->hw->wheel_num > 0) {
struct ad714x_wheel_plat *wl_plat = ad714x->hw->wheel;
for (i = 0; i < ad714x->hw->wheel_num; i++) {
input = devm_input_allocate_device(dev);
if (!input)
return ERR_PTR(-ENOMEM);
__set_bit(EV_KEY, input->evbit);
__set_bit(EV_ABS, input->evbit);
__set_bit(ABS_WHEEL, input->absbit);
__set_bit(BTN_TOUCH, input->keybit);
input_set_abs_params(input,
ABS_WHEEL, 0, wl_plat->max_coord, 0, 0);
input->id.bustype = bus_type;
input->id.product = ad714x->product;
input->id.version = ad714x->version;
input->name = "ad714x_captouch_wheel";
input->dev.parent = dev;
error = input_register_device(input);
if (error)
return ERR_PTR(error);
wl_drv[i].input = input;
}
}
/* a touchpad uses one input_dev instance */
if (ad714x->hw->touchpad_num > 0) {
struct ad714x_touchpad_plat *tp_plat = ad714x->hw->touchpad;
for (i = 0; i < ad714x->hw->touchpad_num; i++) {
input = devm_input_allocate_device(dev);
if (!input)
return ERR_PTR(-ENOMEM);
__set_bit(EV_ABS, input->evbit);
__set_bit(EV_KEY, input->evbit);
__set_bit(ABS_X, input->absbit);
__set_bit(ABS_Y, input->absbit);
__set_bit(BTN_TOUCH, input->keybit);
input_set_abs_params(input,
ABS_X, 0, tp_plat->x_max_coord, 0, 0);
input_set_abs_params(input,
ABS_Y, 0, tp_plat->y_max_coord, 0, 0);
input->id.bustype = bus_type;
input->id.product = ad714x->product;
input->id.version = ad714x->version;
input->name = "ad714x_captouch_pad";
input->dev.parent = dev;
error = input_register_device(input);
if (error)
return ERR_PTR(error);
tp_drv[i].input = input;
}
}
/* all buttons use one input node */
if (ad714x->hw->button_num > 0) {
struct ad714x_button_plat *bt_plat = ad714x->hw->button;
input = devm_input_allocate_device(dev);
if (!input) {
error = -ENOMEM;
return ERR_PTR(error);
}
__set_bit(EV_KEY, input->evbit);
for (i = 0; i < ad714x->hw->button_num; i++) {
bt_drv[i].input = input;
__set_bit(bt_plat[i].keycode, input->keybit);
}
input->id.bustype = bus_type;
input->id.product = ad714x->product;
input->id.version = ad714x->version;
input->name = "ad714x_captouch_button";
input->dev.parent = dev;
error = input_register_device(input);
if (error)
return ERR_PTR(error);
}
irqflags = plat_data->irqflags ?: IRQF_TRIGGER_FALLING;
irqflags |= IRQF_ONESHOT;
error = devm_request_threaded_irq(dev, ad714x->irq, NULL,
ad714x_interrupt_thread,
irqflags, "ad714x_captouch", ad714x);
if (error) {
dev_err(dev, "can't allocate irq %d\n", ad714x->irq);
return ERR_PTR(error);
}
return ad714x;
}
EXPORT_SYMBOL(ad714x_probe);
#ifdef CONFIG_PM
int ad714x_disable(struct ad714x_chip *ad714x)
{
unsigned short data;
dev_dbg(ad714x->dev, "%s enter\n", __func__);
mutex_lock(&ad714x->mutex);
data = ad714x->hw->sys_cfg_reg[AD714X_PWR_CTRL] | 0x3;
ad714x->write(ad714x, AD714X_PWR_CTRL, data);
mutex_unlock(&ad714x->mutex);
return 0;
}
EXPORT_SYMBOL(ad714x_disable);
int ad714x_enable(struct ad714x_chip *ad714x)
{
dev_dbg(ad714x->dev, "%s enter\n", __func__);
mutex_lock(&ad714x->mutex);
/* resume to non-shutdown mode */
ad714x->write(ad714x, AD714X_PWR_CTRL,
ad714x->hw->sys_cfg_reg[AD714X_PWR_CTRL]);
/* make sure the interrupt output line is not low level after resume,
* otherwise we will get no chance to enter falling-edge irq again
*/
ad714x->read(ad714x, STG_LOW_INT_STA_REG, &ad714x->l_state, 3);
mutex_unlock(&ad714x->mutex);
return 0;
}
EXPORT_SYMBOL(ad714x_enable);
#endif
MODULE_DESCRIPTION("Analog Devices AD714X Capacitance Touch Sensor Driver");
MODULE_AUTHOR("Barry Song <21cnbao@gmail.com>");
MODULE_LICENSE("GPL");
Reference in New Issue View Git Blame Copy Permalink