661 lines
22 KiB
C
Executable File
661 lines
22 KiB
C
Executable File
/**
|
|
*Name : cst0xx_getsure.c
|
|
*Author : gary
|
|
*Version : V1.0
|
|
*Create : 2018-1-23
|
|
*Copyright : zxzz
|
|
*/
|
|
|
|
#include "hynitron_core.h"
|
|
#include "hynitron_config.h"
|
|
|
|
|
|
#if HYN_GESTURE_EN
|
|
|
|
#define HYN_GESTURE_CAP_CST8XX 0
|
|
/******************************************************************************
|
|
* Private constant and macro definitions using #define
|
|
*****************************************************************************/
|
|
#define KEY_GESTURE_U KEY_U
|
|
#define KEY_GESTURE_UP KEY_UP
|
|
#define KEY_GESTURE_DOWN KEY_DOWN
|
|
#define KEY_GESTURE_LEFT KEY_LEFT
|
|
#define KEY_GESTURE_RIGHT KEY_RIGHT
|
|
#define KEY_GESTURE_O KEY_O
|
|
#define KEY_GESTURE_E KEY_E
|
|
#define KEY_GESTURE_M KEY_M
|
|
#define KEY_GESTURE_L KEY_L
|
|
#define KEY_GESTURE_W KEY_W
|
|
#define KEY_GESTURE_S KEY_S
|
|
#define KEY_GESTURE_V KEY_V
|
|
#define KEY_GESTURE_C KEY_C
|
|
#define KEY_GESTURE_Z KEY_Z
|
|
#define KEY_GESTURE_DOUBLECLICK KEY_POWER
|
|
|
|
#if HYN_GESTURE_CAP_CST8XX
|
|
//cap
|
|
#define GESTURE_LEFT 0x20
|
|
#define GESTURE_RIGHT 0x21
|
|
#define GESTURE_UP 0x22
|
|
#define GESTURE_DOWN 0x23
|
|
#define GESTURE_DOUBLECLICK 0x24
|
|
#define GESTURE_O 0x30
|
|
#define GESTURE_W 0x31
|
|
#define GESTURE_M 0x32
|
|
#define GESTURE_E 0x33
|
|
#define GESTURE_S 0x46
|
|
#define GESTURE_V 0x54
|
|
#define GESTURE_Z 0x65
|
|
#define GESTURE_C 0x34
|
|
#else
|
|
//mut
|
|
#define GESTURE_LEFT 3
|
|
#define GESTURE_RIGHT 1
|
|
#define GESTURE_UP 2
|
|
#define GESTURE_DOWN 4
|
|
#define GESTURE_DOUBLECLICK 32
|
|
#define GESTURE_TIPCLICK 31
|
|
#define GESTURE_O 5
|
|
#define GESTURE_O_1 20
|
|
#define GESTURE_W 10
|
|
#define GESTURE_M 8
|
|
#define GESTURE_M_1 9
|
|
#define GESTURE_M_2 15
|
|
#define GESTURE_M_3 16
|
|
#define GESTURE_E 7
|
|
#define GESTURE_E_1 17
|
|
#define GESTURE_E_2 19
|
|
#define GESTURE_S 12
|
|
#define GESTURE_S_1 18
|
|
#define GESTURE_V 11
|
|
#define GESTURE_Z 13
|
|
#define GESTURE_C 6
|
|
#define GESTURE_C_1 14
|
|
#endif
|
|
|
|
#define HYN_GESTRUE_POINTS 255
|
|
#define HYN_GESTRUE_POINTS_HEADER 8
|
|
#define HYN_GESTURE_OUTPUT_ADRESS 0xD3
|
|
/*****************************************************************************
|
|
* Private enumerations, structures and unions using typedef
|
|
*****************************************************************************/
|
|
struct hyn_gesture_st
|
|
{
|
|
u8 header[HYN_GESTRUE_POINTS_HEADER];
|
|
u16 coordinate_x[HYN_GESTRUE_POINTS];
|
|
u16 coordinate_y[HYN_GESTRUE_POINTS];
|
|
u16 report_key;
|
|
u8 gestrue_id;
|
|
u8 mode;
|
|
u8 active; /* 1-enter into gesture(suspend) 0-gesture disable or LCD on */
|
|
};
|
|
|
|
/*****************************************************************************
|
|
* Static variables
|
|
*****************************************************************************/
|
|
struct hyn_gesture_st hyn_gesture_data;
|
|
|
|
/*****************************************************************************
|
|
* Global variable or extern global variabls/functions
|
|
*****************************************************************************/
|
|
|
|
/*****************************************************************************
|
|
* Static function prototypes
|
|
*****************************************************************************/
|
|
static ssize_t hyn_gesture_show(struct device *dev, struct device_attribute *attr, char *buf);
|
|
static ssize_t hyn_gesture_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count);
|
|
static ssize_t hyn_gesture_buf_show(struct device *dev, struct device_attribute *attr, char *buf);
|
|
static ssize_t hyn_gesture_buf_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count);
|
|
|
|
/* sysfs gesture node
|
|
* read example: cat hyn_gesture_mode ---read gesture mode
|
|
* write example:echo 01 > hyn_gesture_mode ---write gesture mode to 01
|
|
*
|
|
*/
|
|
static DEVICE_ATTR (hyn_gesture_mode, S_IRUGO|S_IWUSR, hyn_gesture_show, hyn_gesture_store);
|
|
/*
|
|
* read example: cat hyn_gesture_buf ---read gesture buf
|
|
*/
|
|
static DEVICE_ATTR (hyn_gesture_buf, S_IRUGO|S_IWUSR, hyn_gesture_buf_show, hyn_gesture_buf_store);
|
|
static struct attribute *hyn_gesture_mode_attrs[] =
|
|
{
|
|
|
|
&dev_attr_hyn_gesture_mode.attr,
|
|
&dev_attr_hyn_gesture_buf.attr,
|
|
NULL,
|
|
};
|
|
|
|
static struct attribute_group hyn_gesture_group =
|
|
{
|
|
.attrs = hyn_gesture_mode_attrs,
|
|
};
|
|
|
|
|
|
/************************************************************************
|
|
* Name: hyn_gesture_show
|
|
* Brief: no
|
|
* Input: device, device attribute, char buf
|
|
* Output: no
|
|
* Return:
|
|
***********************************************************************/
|
|
static ssize_t hyn_gesture_show(struct device *dev, struct device_attribute *attr, char *buf)
|
|
{
|
|
int count;
|
|
//struct i2c_client *client = container_of(dev, struct i2c_client, dev);
|
|
HYN_FUNC_ENTER();
|
|
mutex_lock(&hyn_ts_data->input_dev->mutex);
|
|
count = sprintf(buf, "Gesture Mode: %s\n", hyn_gesture_data.mode ? "On" : "Off");
|
|
count += sprintf(buf + count, "Reg = %d\n", hyn_gesture_data.gestrue_id);
|
|
mutex_unlock(&hyn_ts_data->input_dev->mutex);
|
|
HYN_FUNC_EXIT();
|
|
return count;
|
|
}
|
|
|
|
/************************************************************************
|
|
* Name: hyn_gesture_store
|
|
* Brief: no
|
|
* Input: device, device attribute, char buf, char count
|
|
* Output: no
|
|
* Return:
|
|
***********************************************************************/
|
|
static ssize_t hyn_gesture_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
|
|
{
|
|
HYN_FUNC_ENTER();
|
|
mutex_lock(&hyn_ts_data->input_dev->mutex);
|
|
|
|
if (buf[0]==1){
|
|
HYN_INFO("[GESTURE]enable gesture");
|
|
hyn_gesture_data.mode = ENABLE;
|
|
}else if (buf[0]==0){
|
|
HYN_INFO("[GESTURE]disable gesture");
|
|
hyn_gesture_data.mode = DISABLE;
|
|
}
|
|
mutex_unlock(&hyn_ts_data->input_dev->mutex);
|
|
|
|
HYN_FUNC_EXIT();
|
|
return count;
|
|
}
|
|
|
|
/************************************************************************
|
|
* Name: hyn_gesture_buf_show
|
|
* Brief: no
|
|
* Input: device, device attribute, char buf
|
|
* Output: no
|
|
* Return:
|
|
***********************************************************************/
|
|
static ssize_t hyn_gesture_buf_show(struct device *dev, struct device_attribute *attr, char *buf)
|
|
{
|
|
int count;
|
|
int i = 0;
|
|
HYN_FUNC_ENTER();
|
|
|
|
mutex_lock(&hyn_ts_data->input_dev->mutex);
|
|
count = snprintf(buf, PAGE_SIZE, "Gesture ID: 0x%x\n", hyn_gesture_data.header[0]);
|
|
count += snprintf(buf + count, PAGE_SIZE, "Gesture PointNum: %d\n", hyn_gesture_data.header[1]);
|
|
count += snprintf(buf + count, PAGE_SIZE, "Gesture Point Buf:\n");
|
|
for (i = 0; i < hyn_gesture_data.header[1]; i++)
|
|
{
|
|
count += snprintf(buf + count, PAGE_SIZE, "%3d(%4d,%4d) ", i, hyn_gesture_data.coordinate_x[i], hyn_gesture_data.coordinate_y[i]);
|
|
if ((i + 1)%4 == 0)
|
|
count += snprintf(buf + count, PAGE_SIZE, "\n");
|
|
}
|
|
count += snprintf(buf + count, PAGE_SIZE, "\n");
|
|
mutex_unlock(&hyn_ts_data->input_dev->mutex);
|
|
|
|
HYN_FUNC_EXIT();
|
|
return count;
|
|
}
|
|
|
|
/************************************************************************
|
|
* Name: hyn_gesture_buf_store
|
|
* Brief: no
|
|
* Input: device, device attribute, char buf, char count
|
|
* Output: no
|
|
* Return:
|
|
***********************************************************************/
|
|
static ssize_t hyn_gesture_buf_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
|
|
{
|
|
/* place holder for future use */
|
|
return -EPERM;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
* Name: hyn_create_gesture_sysfs
|
|
* Brief:
|
|
* Input:
|
|
* Output: None
|
|
* Return: 0-success or error
|
|
*****************************************************************************/
|
|
int hyn_create_gesture_sysfs(struct i2c_client *client)
|
|
{
|
|
int ret = 0;
|
|
HYN_FUNC_ENTER();
|
|
|
|
if(!hyn_ts_data->k_obj)
|
|
return 0;
|
|
|
|
ret = sysfs_create_group(hyn_ts_data->k_obj, &hyn_gesture_group);
|
|
if ( ret != 0){
|
|
HYN_ERROR( "[GESTURE]hyn_gesture_mode_group(sysfs) create failed!");
|
|
sysfs_remove_group(hyn_ts_data->k_obj, &hyn_gesture_group);
|
|
return ret;
|
|
}
|
|
HYN_FUNC_EXIT();
|
|
return 0;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
* Name: hyn_gesture_recovery
|
|
* Brief: recovery gesture state when reset
|
|
* Input:
|
|
* Output: None
|
|
* Return:
|
|
*****************************************************************************/
|
|
void hyn_gesture_recovery(struct i2c_client *client)
|
|
{
|
|
HYN_FUNC_ENTER();
|
|
if (hyn_gesture_data.mode && hyn_gesture_data.active)
|
|
{
|
|
if(hyn_ts_data->config_chip_product_line==HYN_CHIP_PRODUCT_LINE_MUT_CAP){
|
|
u8 buf[3];
|
|
buf[0]=HYN_REG_MUT_GESTURE_EN>>8;
|
|
buf[1]=HYN_REG_MUT_GESTURE_EN&0xff;
|
|
buf[2]=0x80;
|
|
cst3xx_i2c_write(client, buf, 3);
|
|
}else{
|
|
hyn_i2c_write_byte(client, HYN_REG_CAP_GESTURE_EN, ENABLE);
|
|
}
|
|
}
|
|
HYN_FUNC_EXIT();
|
|
}
|
|
|
|
/*****************************************************************************
|
|
* Name: hyn_check_gesture
|
|
* Brief:
|
|
* Input:
|
|
* Output: None
|
|
* Return: None
|
|
*****************************************************************************/
|
|
static void hyn_check_gesture(struct input_dev *input_dev,int gesture_id)
|
|
{
|
|
unsigned int report_key = 0;
|
|
|
|
HYN_INFO("check_gesture ======================gesture_id==0x%x ================\n ",gesture_id);
|
|
HYN_FUNC_ENTER();
|
|
switch (gesture_id)
|
|
{
|
|
|
|
case GESTURE_O:
|
|
#if (!HYN_GESTURE_CAP_CST8XX)
|
|
case GESTURE_O_1:
|
|
#endif
|
|
report_key = KEY_GESTURE_O;
|
|
break;
|
|
case GESTURE_W:
|
|
report_key = KEY_GESTURE_W;
|
|
break;
|
|
case GESTURE_M:
|
|
#if (!HYN_GESTURE_CAP_CST8XX)
|
|
case GESTURE_M_1:
|
|
case GESTURE_M_2:
|
|
case GESTURE_M_3:
|
|
#endif
|
|
report_key = KEY_GESTURE_M;
|
|
break;
|
|
case GESTURE_E:
|
|
#if (!HYN_GESTURE_CAP_CST8XX)
|
|
case GESTURE_E_1:
|
|
case GESTURE_E_2:
|
|
#endif
|
|
report_key = KEY_GESTURE_E;
|
|
break;
|
|
case GESTURE_C:
|
|
#if (!HYN_GESTURE_CAP_CST8XX)
|
|
case GESTURE_C_1:
|
|
#endif
|
|
report_key = KEY_GESTURE_C;
|
|
break;
|
|
case GESTURE_S:
|
|
#if (!HYN_GESTURE_CAP_CST8XX)
|
|
case GESTURE_S_1:
|
|
#endif
|
|
report_key = KEY_GESTURE_S;
|
|
break ;
|
|
case GESTURE_V:
|
|
report_key = KEY_GESTURE_V;
|
|
break;
|
|
case GESTURE_Z:
|
|
report_key = KEY_GESTURE_Z;
|
|
break;
|
|
case GESTURE_RIGHT:
|
|
report_key = KEY_GESTURE_RIGHT;
|
|
break ;
|
|
case GESTURE_DOWN:
|
|
report_key = KEY_GESTURE_DOWN;
|
|
break ;
|
|
case GESTURE_UP:
|
|
report_key = KEY_GESTURE_UP;
|
|
break ;
|
|
case GESTURE_LEFT:
|
|
report_key = KEY_GESTURE_LEFT;
|
|
break ;
|
|
case GESTURE_DOUBLECLICK:
|
|
report_key = KEY_GESTURE_DOUBLECLICK;
|
|
break ;
|
|
case GESTURE_TIPCLICK:
|
|
report_key = KEY_GESTURE_DOUBLECLICK;
|
|
break ;
|
|
default:
|
|
break ;
|
|
}
|
|
HYN_INFO("check_gesture ======================report_key==0x%x ================\n ",report_key);
|
|
HYN_INFO("check_gesture ======================last report_key==0x%x ================\n ",hyn_gesture_data.report_key);
|
|
|
|
if(hyn_gesture_data.report_key!=report_key){
|
|
|
|
hyn_gesture_data.report_key=report_key;
|
|
/* report event key */
|
|
if (report_key != -1){
|
|
|
|
// input_report_key(input_dev, KEY_POWER, 1);
|
|
// input_sync(input_dev);
|
|
// input_report_key(input_dev, KEY_POWER, 0);
|
|
// input_sync(input_dev);
|
|
input_report_key(input_dev, report_key, 1);
|
|
input_sync(input_dev);
|
|
input_report_key(input_dev, report_key, 0);
|
|
input_sync(input_dev);
|
|
|
|
HYN_INFO("input_report_key---done==0x%x ================\n ",report_key);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
HYN_FUNC_EXIT();
|
|
|
|
|
|
}
|
|
|
|
/************************************************************************
|
|
* Name: hyn_gesture_readdata
|
|
* Brief: read data from TP register
|
|
* Input: no
|
|
* Output: no
|
|
* Return: fail <0
|
|
***********************************************************************/
|
|
int hyn_gesture_readdata(void)
|
|
{
|
|
u8 buf[HYN_GESTRUE_POINTS * 4] = { 0 };
|
|
int ret = -1;
|
|
int i = 0;
|
|
int gestrue_id = 0;
|
|
//int read_bytes = 0;
|
|
u8 pointnum=1;
|
|
if(hyn_gesture_data.active){
|
|
HYN_FUNC_ENTER();
|
|
if (hyn_gesture_data.mode)
|
|
{
|
|
u8 state;
|
|
if(hyn_ts_data->config_chip_product_line==HYN_CHIP_PRODUCT_LINE_MUT_CAP){
|
|
|
|
u8 buf[3];
|
|
buf[0]=HYN_REG_MUT_GESTURE_EN>>8;
|
|
buf[1]=HYN_REG_MUT_GESTURE_EN&0xff;
|
|
ret=cst3xx_i2c_read_register(hyn_ts_data->client, buf, 1);
|
|
state=buf[0]>>7;
|
|
gestrue_id = buf[0]&0x7f;
|
|
}else{
|
|
ret = hyn_i2c_read_byte(hyn_ts_data->client, HYN_REG_CAP_GESTURE_EN, &state);
|
|
}
|
|
|
|
if (ret<0) HYN_ERROR("[HYN][Touch] read value fail");
|
|
if (state !=1) return -1;
|
|
|
|
|
|
if(hyn_ts_data->config_chip_product_line==HYN_CHIP_PRODUCT_LINE_SEL_CAP){
|
|
/* init variable before read gesture point */
|
|
memset(hyn_gesture_data.header, 0, HYN_GESTRUE_POINTS_HEADER);
|
|
memset(hyn_gesture_data.coordinate_x, 0, HYN_GESTRUE_POINTS * sizeof(u16));
|
|
memset(hyn_gesture_data.coordinate_y, 0, HYN_GESTRUE_POINTS * sizeof(u16));
|
|
|
|
buf[0] = HYN_REG_CAP_GESTURE_OUTPUT_ADDRESS;
|
|
ret = hyn_i2c_read(hyn_ts_data->client, buf, 1, buf, HYN_GESTRUE_POINTS_HEADER);
|
|
if (ret < 0){
|
|
HYN_ERROR("[GESTURE]Read gesture header data failed!!");
|
|
return ret;
|
|
}
|
|
|
|
gestrue_id = buf[0];
|
|
for (i = 0; i < pointnum; i++){
|
|
hyn_gesture_data.coordinate_x[i] = (((s16) buf[0 + (4 * i+8)]) & 0x0F) << 8
|
|
| (((s16) buf[1 + (4 * i+8)])& 0xFF);
|
|
hyn_gesture_data.coordinate_y[i] = (((s16) buf[2 + (4 * i+8)]) & 0x0F) << 8
|
|
| (((s16) buf[3 + (4 * i+8)]) & 0xFF);
|
|
}
|
|
}
|
|
hyn_gesture_data.gestrue_id=gestrue_id;
|
|
hyn_check_gesture(hyn_ts_data->input_dev, gestrue_id);
|
|
HYN_DEBUG("[GESTURE]gestrue_id:%d,report_key:%d", hyn_gesture_data.gestrue_id,hyn_gesture_data.report_key);
|
|
HYN_FUNC_EXIT();
|
|
return 0;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
/*****************************************************************************
|
|
* Name: hyn_irq_set_low_trig
|
|
* Brief:
|
|
* Input:
|
|
* Output:
|
|
* Return:
|
|
*****************************************************************************/
|
|
void hyn_irq_gesture_mode(void)
|
|
{
|
|
int ret=0;
|
|
hyn_irq_disable();
|
|
ret = enable_irq_wake(hyn_ts_data->client->irq);
|
|
if(ret<0){
|
|
HYN_ERROR("[GESTURE]enable_irq_wake fail:%d",ret);
|
|
}
|
|
ret=irq_set_irq_type(hyn_ts_data->client->irq,IRQF_TRIGGER_LOW|IRQF_NO_SUSPEND);
|
|
if(ret<0){
|
|
HYN_ERROR("[GESTURE]irq_set_irq_type fail:%d",ret);
|
|
}
|
|
hyn_irq_enable();
|
|
|
|
}
|
|
void hyn_irq_normal_mode(void)
|
|
{
|
|
int ret=0;
|
|
hyn_irq_disable();
|
|
ret =disable_irq_wake(hyn_ts_data->client->irq);
|
|
if(ret<0){
|
|
HYN_ERROR("[GESTURE]disable_irq_wake fail:%d",ret);
|
|
}
|
|
ret=irq_set_irq_type(hyn_ts_data->client->irq,hyn_ts_data->pdata->irq_gpio_flags);
|
|
if(ret<0){
|
|
HYN_ERROR("[GESTURE]irq_set_irq_type fail:%d",ret);
|
|
}
|
|
hyn_irq_enable();
|
|
|
|
}
|
|
/*****************************************************************************
|
|
* Name: hyn_gesture_suspend
|
|
* Brief:
|
|
* Input:
|
|
* Output: None
|
|
* Return: None
|
|
*****************************************************************************/
|
|
int hyn_gesture_suspend(void)
|
|
{
|
|
u8 state = 0, i;
|
|
|
|
HYN_FUNC_ENTER();
|
|
//enter gesture scan
|
|
if(hyn_gesture_data.mode==0) return -1;
|
|
|
|
if(hyn_ts_data->config_chip_product_line==HYN_CHIP_PRODUCT_LINE_MUT_CAP){
|
|
|
|
u8 buf[3];
|
|
buf[0]=HYN_REG_MUT_GESTURE_EN>>8;
|
|
buf[1]=HYN_REG_MUT_GESTURE_EN&0xff;
|
|
buf[2]=0x80;
|
|
cst3xx_i2c_write(hyn_ts_data->client, buf, 3);
|
|
msleep(10);
|
|
for(i = 0; i < 3; i++)
|
|
{
|
|
buf[0]=HYN_REG_MUT_GESTURE_EN>>8;
|
|
buf[1]=HYN_REG_MUT_GESTURE_EN&0xff;
|
|
cst3xx_i2c_read_register(hyn_ts_data->client, buf, 1);
|
|
state=buf[0]>>7;
|
|
if(state == 1){
|
|
HYN_DEBUG("gesture state= 0x01.\n");
|
|
break;
|
|
}else{
|
|
buf[0]=HYN_REG_MUT_GESTURE_EN>>8;
|
|
buf[1]=HYN_REG_MUT_GESTURE_EN&0xff;
|
|
buf[2]=0x80;
|
|
cst3xx_i2c_write(hyn_ts_data->client, buf, 3);
|
|
msleep(10);
|
|
}
|
|
}
|
|
|
|
|
|
}else if(hyn_ts_data->config_chip_product_line==HYN_CHIP_PRODUCT_LINE_SEL_CAP){
|
|
|
|
hyn_i2c_write_byte(hyn_ts_data->client, HYN_REG_CAP_GESTURE_EN, ENABLE);
|
|
msleep(10);
|
|
for(i = 0; i < 3; i++)
|
|
{
|
|
hyn_i2c_read_byte(hyn_ts_data->client, HYN_REG_CAP_GESTURE_EN, &state);
|
|
if(state == 1){
|
|
HYN_DEBUG("gesture state= 0x01.\n");
|
|
break;
|
|
}else{
|
|
hyn_i2c_write_byte(hyn_ts_data->client, HYN_REG_CAP_GESTURE_EN, ENABLE);
|
|
msleep(10);
|
|
}
|
|
}
|
|
}
|
|
hyn_gesture_data.active = 1;
|
|
hyn_gesture_data.report_key = 0;
|
|
hyn_gesture_data.gestrue_id = 0;
|
|
hyn_irq_gesture_mode();
|
|
|
|
HYN_DEBUG("[GESTURE]Enter into gesture(suspend) successfully!");
|
|
HYN_FUNC_EXIT();
|
|
return 0;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
* Name: hyn_gesture_resume
|
|
* Brief:
|
|
* Input:
|
|
* Output: None
|
|
* Return: None
|
|
*****************************************************************************/
|
|
int hyn_gesture_resume(void)
|
|
{
|
|
|
|
HYN_FUNC_ENTER();
|
|
|
|
if (hyn_gesture_data.mode == 0){
|
|
HYN_DEBUG("gesture is disabled");
|
|
HYN_FUNC_EXIT();
|
|
return -1;
|
|
}
|
|
|
|
hyn_gesture_data.active = 0;
|
|
hyn_gesture_data.report_key=0;
|
|
hyn_gesture_data.gestrue_id=0;
|
|
|
|
hyn_irq_normal_mode();
|
|
//stop gesture scan
|
|
if(hyn_ts_data->config_chip_product_line==HYN_CHIP_PRODUCT_LINE_MUT_CAP){
|
|
u8 buf[3];
|
|
buf[0]=HYN_REG_MUT_GESTURE_EN>>8;
|
|
buf[1]=HYN_REG_MUT_GESTURE_EN&0xff;
|
|
buf[2]=0;
|
|
cst3xx_i2c_write(hyn_ts_data->client, buf, 3);
|
|
|
|
}else{
|
|
hyn_i2c_write_byte(hyn_ts_data->client, HYN_REG_CAP_GESTURE_EN, DISABLE);
|
|
}
|
|
HYN_FUNC_EXIT();
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*****************************************************************************
|
|
* Name: hyn_gesture_init
|
|
* Brief:
|
|
* Input:
|
|
* Output: None
|
|
* Return: None
|
|
*****************************************************************************/
|
|
int hyn_gesture_init(struct input_dev *input_dev, struct i2c_client *client)
|
|
{
|
|
HYN_FUNC_ENTER();
|
|
input_set_capability(input_dev, EV_KEY, KEY_POWER);
|
|
input_set_capability(input_dev, EV_KEY, KEY_GESTURE_U);
|
|
input_set_capability(input_dev, EV_KEY, KEY_GESTURE_UP);
|
|
input_set_capability(input_dev, EV_KEY, KEY_GESTURE_DOWN);
|
|
input_set_capability(input_dev, EV_KEY, KEY_GESTURE_LEFT);
|
|
input_set_capability(input_dev, EV_KEY, KEY_GESTURE_RIGHT);
|
|
input_set_capability(input_dev, EV_KEY, KEY_GESTURE_O);
|
|
input_set_capability(input_dev, EV_KEY, KEY_GESTURE_E);
|
|
input_set_capability(input_dev, EV_KEY, KEY_GESTURE_M);
|
|
input_set_capability(input_dev, EV_KEY, KEY_GESTURE_L);
|
|
input_set_capability(input_dev, EV_KEY, KEY_GESTURE_W);
|
|
input_set_capability(input_dev, EV_KEY, KEY_GESTURE_S);
|
|
input_set_capability(input_dev, EV_KEY, KEY_GESTURE_V);
|
|
input_set_capability(input_dev, EV_KEY, KEY_GESTURE_Z);
|
|
input_set_capability(input_dev, EV_KEY, KEY_GESTURE_C);
|
|
|
|
__set_bit(KEY_GESTURE_RIGHT, input_dev->keybit);
|
|
__set_bit(KEY_GESTURE_LEFT, input_dev->keybit);
|
|
__set_bit(KEY_GESTURE_UP, input_dev->keybit);
|
|
__set_bit(KEY_GESTURE_DOWN, input_dev->keybit);
|
|
__set_bit(KEY_GESTURE_U, input_dev->keybit);
|
|
__set_bit(KEY_GESTURE_O, input_dev->keybit);
|
|
__set_bit(KEY_GESTURE_E, input_dev->keybit);
|
|
__set_bit(KEY_GESTURE_M, input_dev->keybit);
|
|
__set_bit(KEY_GESTURE_W, input_dev->keybit);
|
|
__set_bit(KEY_GESTURE_L, input_dev->keybit);
|
|
__set_bit(KEY_GESTURE_S, input_dev->keybit);
|
|
__set_bit(KEY_GESTURE_V, input_dev->keybit);
|
|
__set_bit(KEY_GESTURE_C, input_dev->keybit);
|
|
__set_bit(KEY_GESTURE_Z, input_dev->keybit);
|
|
|
|
hyn_create_gesture_sysfs(client);
|
|
hyn_gesture_data.mode = 1;
|
|
hyn_gesture_data.active = 0;
|
|
hyn_gesture_data.report_key = 0;
|
|
hyn_gesture_data.gestrue_id = 0;
|
|
HYN_FUNC_EXIT();
|
|
return 0;
|
|
}
|
|
|
|
/************************************************************************
|
|
* Name: hyn_gesture_exit
|
|
* Brief: remove sys
|
|
* Input: i2c info
|
|
* Output: no
|
|
* Return: no
|
|
***********************************************************************/
|
|
int hyn_gesture_exit(void)
|
|
{
|
|
HYN_FUNC_ENTER();
|
|
if(!hyn_ts_data->k_obj) return -1;
|
|
sysfs_remove_group(hyn_ts_data->k_obj, &hyn_gesture_group);
|
|
HYN_FUNC_EXIT();
|
|
return 0;
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|