Something went wrong. Try again.
(I'm so sorry!) Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
Something went wrong. Try again.
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201// 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/export.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 700static 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;
guard(mutex)(&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);
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";
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";
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";
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";
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);
static int ad714x_suspend(struct device *dev){ struct ad714x_chip *ad714x = dev_get_drvdata(dev); unsigned short data;
dev_dbg(ad714x->dev, "%s enter\n", __func__);
guard(mutex)(&ad714x->mutex);
data = ad714x->hw->sys_cfg_reg[AD714X_PWR_CTRL] | 0x3; ad714x->write(ad714x, AD714X_PWR_CTRL, data);
return 0;}
static int ad714x_resume(struct device *dev){ struct ad714x_chip *ad714x = dev_get_drvdata(dev); dev_dbg(ad714x->dev, "%s enter\n", __func__);
guard(mutex)(&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);
return 0;}
EXPORT_SIMPLE_DEV_PM_OPS(ad714x_pm, ad714x_suspend, ad714x_resume);
MODULE_DESCRIPTION("Analog Devices AD714X Capacitance Touch Sensor Driver");MODULE_AUTHOR("Barry Song <21cnbao@gmail.com>");MODULE_LICENSE("GPL");