s32 gt1x_init_node(void)
{
#if GTP_GESTURE_WAKEUP
struct proc_dir_entry *proc_entry = NULL;
mutex_init(&gesture_data_mutex);
memset(gestures_flag, 0, sizeof(gestures_flag));
memset((u8 *) & gesture_data, 0, sizeof(st_gesture_data));
proc_entry = proc_create(GESTURE_NODE, 0666, NULL, >1x_fops);
if (proc_entry == NULL) {
GTP_ERROR("Couldn't create proc entry[GESTURE_NODE]!");
return -1;
} else {
GTP_INFO("Create proc entry[GESTURE_NODE] success!");
}
#endif
#if GTP_HOTKNOT
if (misc_register(&hotknot_misc_device)) {
GTP_ERROR("Couldn't create [HOTKNOT_NODE] device!");
return -1;
} else {
GTP_INFO("Create [HOTKNOT_NODE] device success!");
}
#endif
return 0;
}
static s32 tpd_enable_ps(s32 enable)
{
u8 state;
s32 ret = -1;
// u8 buffer[3] = {0x80,0x42};
mutex_lock(&i2c_access);
if (enable)
{
// buffer[2] = 1;
state = 1;
tpd_proximity_flag = 1;
GTP_INFO("TPD proximity function to be on.");
}
else
{
// buffer[2] = 0;
state = 0;
//tpd_proximity_detect = 1;
tpd_proximity_flag = 0;
GTP_INFO("TPD proximity function to be off.");
}
ret = i2c_write_bytes(i2c_client_point, TPD_PROXIMITY_ENABLE_REG, &state, 1);
//ret = gtp_i2c_write(i2c_client_point, buffer, sizeof(buffer));
mutex_unlock(&i2c_access);
if (ret < 0)
{
GTP_ERROR("TPD %s proximity cmd failed.", state ? "enable" : "disable");
//GTP_ERROR("TPD %s proximity cmd failed.", buffer[2] ? "enable" : "disable");
return ret;
}
GTP_INFO("TPD proximity function %s success.", state ? "enable" : "disable");
//GTP_INFO("TPD proximity function %s success.", buffer[2] ? "enable" : "disable");
return 0;
}
/*******************************************************
Function:
Send config.
Input:
client: i2c device.
Output:
result of i2c write operation.
1: succeed, otherwise: failed
*********************************************************/
s32 gtp_send_cfg(struct i2c_client *client)
{
s32 ret = 2;
#if GTP_DRIVER_SEND_CFG
s32 retry = 0;
struct goodix_ts_data *ts = i2c_get_clientdata(client);
if (ts->fixed_cfg)
{
GTP_INFO("Ic fixed config, no config sent!");
return 2;
}
GTP_INFO("driver send config");
for (retry = 0; retry < 5; retry++)
{
ret = gtp_i2c_write(client, config , GTP_CONFIG_MAX_LENGTH + GTP_ADDR_LENGTH);
if (ret > 0)
{
break;
}
}
#endif
return ret;
}
static s32 tpd_enable_ps(s32 enable)
{
u8 state;
s32 ret = -1;
if (enable)
{
state = 1;
tpd_proximity_flag = 1;
GTP_INFO("TPD proximity function to be on.");
}
else
{
state = 0;
tpd_proximity_flag = 0;
GTP_INFO("TPD proximity function to be off.");
}
ret = i2c_write_bytes(i2c_client_point, TPD_PROXIMITY_ENABLE_REG, &state, 1);
if (ret < 0)
{
GTP_ERROR("TPD %s proximity cmd failed.", state ? "enable" : "disable");
return ret;
}
GTP_INFO("TPD proximity function %s success.", state ? "enable" : "disable");
return 0;
}
s32 init_wr_node(struct i2c_client *client)
{
s32 i;
gt_client = i2c_client_point;
GTP_INFO("client %d.%d", (int)gt_client, (int)client);
memset(&cmd_head, 0, sizeof(cmd_head));
cmd_head.data = NULL;
i = 5;
while ((!cmd_head.data) && i)
{
cmd_head.data = kzalloc(i * DATA_LENGTH_UINT, GFP_KERNEL);
if (NULL != cmd_head.data)
{
break;
}
i--;
}
if (i)
{
DATA_LENGTH = i * DATA_LENGTH_UINT + GTP_ADDR_LENGTH;
GTP_INFO("Applied memory size:%d.", DATA_LENGTH);
}
else
{
GTP_ERROR("Apply for memory failed.");
return FAIL;
}
cmd_head.addr_len = 2;
cmd_head.retry = 5;
register_i2c_func();
goodix_proc_entry = create_proc_entry(GOODIX_ENTRY_NAME, 0664, NULL);
if (goodix_proc_entry == NULL)
{
GTP_ERROR("Couldn't create proc entry!");
return FAIL;
}
else
{
GTP_INFO("Create proc entry success!");
goodix_proc_entry->write_proc = goodix_tool_write;
goodix_proc_entry->read_proc = goodix_tool_read;
}
return SUCCESS;
}
s32 init_wr_node(struct i2c_client *client)
{
s32 i;
gt_client = i2c_client_point;
memset(&cmd_head, 0, sizeof(cmd_head));
cmd_head.data = NULL;
i = 5;
while ((!cmd_head.data) && i) {
cmd_head.data = kzalloc(i * DATA_LENGTH_UINT, GFP_KERNEL);
if (NULL != cmd_head.data) {
break;
}
i--;
}
if (i) {
DATA_LENGTH = i * DATA_LENGTH_UINT + GTP_ADDR_LENGTH;
GTP_INFO("Applied memory size:%d.", DATA_LENGTH);
} else {
GTP_ERROR("Apply for memory failed.");
return FAIL;
}
cmd_head.addr_len = 2;
cmd_head.retry = 5;
register_i2c_func();
tool_set_proc_name(procname);
#if 0 /* fix 3.10 */
goodix_proc_entry = create_proc_entry(gtp_tool_entry, 0664, NULL);
if (goodix_proc_entry == NULL) {
GTP_ERROR("Couldn't create proc entry!");
return FAIL;
} else {
GTP_INFO("Create proc entry success!");
goodix_proc_entry->write_proc = goodix_tool_write;
goodix_proc_entry->read_proc = goodix_tool_read;
}
#else
if (proc_create(procname, 0660, NULL, >_tool_fops) == NULL) {
GTP_ERROR("create_proc_entry %s failed", procname);
return -1;
}
#endif
return SUCCESS;
}
static void register_i2c_func(void)
{
if (strncmp(IC_TYPE, "GTxxx", 5)) {
tool_i2c_read = tool_i2c_read_with_extra;
tool_i2c_write = tool_i2c_write_with_extra;
GTP_INFO("I2C function: register with pre and end cmd!");
} else {
tool_i2c_read = tool_i2c_read_no_extra;
tool_i2c_write = tool_i2c_write_no_extra;
GTP_INFO("I2C function: register without pre and end cmd!");
}
}
static s32 hotknot_load_authentication_subsystem(void)
{
s32 ret = 0;
u8 buffer[5] = { 0 };
ret = gt1x_hold_ss51_dsp_no_reset();
if (ret < 0) {
GTP_ERROR("Hold ss51 fail!");
return ERROR;
}
if (gt1x_chip_type == CHIP_TYPE_GT1X) {
GTP_INFO("hotknot load jump code.");
ret = gt1x_load_patch(gt1x_patch_jump_fw, 4096, 0, 1024 * 8);
if (ret < 0) {
GTP_ERROR("Load jump code fail!");
return ret;
}
GTP_INFO("hotknot load auth code.");
ret = gt1x_load_patch(hotknot_auth_fw, 4096, 4096, 1024 * 8);
if (ret < 0) {
GTP_ERROR("Load auth system fail!");
return ret;
}
} else {
GTP_INFO("hotknot load auth code.");
ret = gt1x_load_patch(hotknot_auth_fw, 4096, 0, 1024 * 6);
if (ret < 0) {
GTP_ERROR("load auth system fail!");
return ret;
}
}
ret = gt1x_startup_patch();
if (ret < 0) {
GTP_ERROR("Startup auth system fail!");
return ret;
}
ret = gt1x_i2c_read(GTP_REG_VERSION, buffer, 4);
if (ret < 0) {
GTP_ERROR("i2c read error!");
return ERROR_IIC;
}
buffer[4] = 0;
GTP_INFO("Current System version: %s", buffer);
return 0;
}
int gt1x_init_tool_node(void)
{
memset(&cmd_head, 0, sizeof(cmd_head));
cmd_head.wr = 1; //if the first operation is read, will return fail.
cmd_head.data = kzalloc(DATA_LENGTH_UINT, GFP_KERNEL);
if (NULL == cmd_head.data) {
GTP_ERROR("Apply for memory failed.");
return -1;
}
GTP_INFO("Applied memory size:%d.", DATA_LENGTH_UINT);
DATA_LENGTH = DATA_LENGTH_UINT - GTP_ADDR_LENGTH;
set_tool_node_name(procname);
gt1x_tool_proc_entry = proc_create(procname, 0666, NULL, >1x_tool_fops);
if (gt1x_tool_proc_entry == NULL) {
GTP_ERROR("Couldn't create proc entry!");
return -1;
} else {
GTP_INFO("Create proc entry success!");
}
return 0;
}
int init_wr_node(struct i2c_client *client)
{
int i;
gt_client = client;
memset(&cmd_head, 0, sizeof(cmd_head));
cmd_head.data = NULL;
i = 5;
while ((!cmd_head.data) && i) {
cmd_head.data = kzalloc(i * DATA_LENGTH_UINT, GFP_KERNEL);
if (NULL != cmd_head.data)
break;
i--;
}
if (i) {
DATA_LENGTH = i * DATA_LENGTH_UINT + GTP_ADDR_LENGTH;
GTP_INFO("Applied memory size:%d.", DATA_LENGTH);
} else {
GTP_ERROR("Apply for memory failed.");
return -1;
}
cmd_head.addr_len = 2;
cmd_head.retry = 5;
register_i2c_func();
tool_set_proc_name(procname);
fops.read = NULL;
fops.write = NULL;
goodix_proc_entry =
proc_create_data(procname, 0666, NULL, &fops, NULL);
if (goodix_proc_entry == NULL) {
GTP_ERROR("Couldn't create proc entry!");
return -1;
}
/* else {
GTP_INFO("Create proc entry success!");
goodix_proc_entry->write_proc = goodix_tool_write;
goodix_proc_entry->read_proc = goodix_tool_read;
}
*/
return 0;
}
static void register_i2c_func(void)
{
/* if (!strncmp(IC_TYPE, "GT818", 5) || !strncmp(IC_TYPE, "GT816", 5) */
/* || !strncmp(IC_TYPE, "GT811", 5) || !strncmp(IC_TYPE, "GT818F", 6) */
/* || !strncmp(IC_TYPE, "GT827", 5) || !strncmp(IC_TYPE,"GT828", 5) */
/* || !strncmp(IC_TYPE, "GT813", 5)) */
if (strncmp(IC_TYPE, "GT8110", 6) && strncmp(IC_TYPE, "GT8105", 6)
&& strncmp(IC_TYPE, "GT801", 5) && strncmp(IC_TYPE, "GT800", 5)
&& strncmp(IC_TYPE, "GT801PLUS", 9) && strncmp(IC_TYPE, "GT811", 5)
&& strncmp(IC_TYPE, "GTxxx", 5) && strncmp(IC_TYPE, "GT9XX", 5)) {
tool_i2c_read = tool_i2c_read_with_extra;
tool_i2c_write = tool_i2c_write_with_extra;
GTP_DEBUG("I2C function: with pre and end cmd!");
} else {
tool_i2c_read = tool_i2c_read_no_extra;
tool_i2c_write = tool_i2c_write_no_extra;
GTP_INFO("I2C function: without pre and end cmd!");
}
}
static ssize_t show_tpd_vendor_name(struct device *dev,struct device_attribute *attr, char *buf)
{
u8 rd_vendor_buf[16];
s32 ret = -1;
rd_vendor_buf[0] = GTP_REG_SENSOR_ID >> 8;
rd_vendor_buf[1] = GTP_REG_SENSOR_ID & 0xff;
ret = gtp_i2c_read(i2c_client_point, rd_vendor_buf, 3);
if (ret < 0)
{
GTP_ERROR("gt9xx Read SENSOR ID failed");
rd_vendor_buf[GTP_ADDR_LENGTH] = 3;
return sprintf(buf, "%s", tpd_manufacturer_name[rd_vendor_buf[GTP_ADDR_LENGTH]]);
}
GTP_INFO("gt9xx vendor ID:%d", rd_vendor_buf[GTP_ADDR_LENGTH]);
rd_vendor_buf[GTP_ADDR_LENGTH] &= 0x03;
return sprintf(buf, "%s", tpd_manufacturer_name[rd_vendor_buf[GTP_ADDR_LENGTH]]);
}
static ssize_t show_read_reg(struct device *dev,struct device_attribute *attr, char *buf)
{
int ret, cnt, i;
u8 i2c_buf[GTP_ADDR_LENGTH+100] = {g_attr_read_reg>>8, g_attr_read_reg& 0xff};
if (g_attr_read_reg == 0xFFFF || g_attr_read_nbytes == 0)
{
return sprintf(buf, "0x%x,%d??\n"ATTR_READ_REAG_HINT, g_attr_read_reg, g_attr_read_nbytes);
}
ret = gtp_i2c_read(i2c_client_point, i2c_buf, g_attr_read_nbytes+GTP_ADDR_LENGTH);
if (ret < 0)
{
return sprintf(buf, "read failed\n"ATTR_READ_REAG_HINT);
}
cnt = sprintf(buf, "BASE:0x%x, bytes=%d\n", (i2c_buf[0]<<8 | i2c_buf[1]), g_attr_read_nbytes);
for (i = 0; i< g_attr_read_nbytes; i++)
{
cnt += sprintf(buf+cnt, "0x%02x,", i2c_buf[GTP_ADDR_LENGTH+i]);
if ((i+1)%10 == 0) cnt += sprintf(buf+cnt, "\n");
}
cnt += sprintf(buf+cnt, "\n");
g_attr_read_reg = 0xFFFF;
g_attr_read_nbytes = 0;
return cnt;
}
static ssize_t store_read_reg(struct device *dev,struct device_attribute *attr, const char *buf, size_t size)
{
char *p;
g_attr_read_reg = (u16)simple_strtol(buf, &p, 16);
g_attr_read_nbytes = simple_strtol(p+1, NULL, 10);
GTP_INFO("0x%x, %d", g_attr_read_reg, g_attr_read_nbytes);
return size;
}
static void unregister_i2c_func(void)
{
tool_i2c_read = NULL;
tool_i2c_write = NULL;
GTP_INFO("I2C function: unregister i2c transfer function!");
}
s32 init_wr_node(struct i2c_client *client)
{
s32 i;
gt_client = i2c_client_point;
memset(&cmd_head, 0, sizeof(cmd_head));
cmd_head.data = NULL;
i = 5;
while ((!cmd_head.data) && i)
{
cmd_head.data = kzalloc(i * DATA_LENGTH_UINT, GFP_KERNEL);
if (NULL != cmd_head.data)
{
break;
}
i--;
}
if (i)
{
DATA_LENGTH = i * DATA_LENGTH_UINT + GTP_ADDR_LENGTH;
GTP_INFO("Applied memory size:%d.", DATA_LENGTH);
}
else
{
GTP_ERROR("Apply for memory failed.");
return FAIL;
}
cmd_head.addr_len = 2;
cmd_head.retry = 5;
memset(&cmd_head2, 0, sizeof(cmd_head2));
cmd_head2.data = NULL;
i = 5;
while ((!cmd_head2.data) && i)
{
cmd_head2.data = kzalloc(i * DATA_LENGTH_UINT, GFP_KERNEL);
if (NULL != cmd_head2.data)
{
break;
}
i--;
}
if (i)
{
DATA_LENGTH = i * DATA_LENGTH_UINT + GTP_ADDR_LENGTH;
GTP_INFO("Applied memory size:%d.", DATA_LENGTH);
}
else
{
GTP_ERROR("Apply for memory failed.");
return FAIL;
}
cmd_head2.addr_len = 2;
cmd_head2.retry = 5;
register_i2c_func();
tool_set_proc_name(procname);
goodix_proc_entry = proc_create(procname, 0660, NULL, &tool_ops);
if (misc_register(&hotknot_misc_device))
{
printk("mtk_tpd: hotknot_device register failed\n");
return FAIL;
}
if (goodix_proc_entry == NULL)
{
GTP_ERROR("Couldn't create proc entry!");
return FAIL;
}
else
{
GTP_INFO("Create proc entry success!");
}
return SUCCESS;
}
/**
* ctp_detect - Device detection callback for automatic device creation
* return value:
* = 0; success;
* < 0; err
*/
static int ctp_detect(struct i2c_client *client, struct i2c_board_info *info)
{
struct i2c_adapter *adapter = client->adapter;
int ret;
u8 buf[8] = {GTP_REG_VERSION >> 8, GTP_REG_VERSION & 0xff};
if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)){
pr_err("i2c_check_functionality err\n======return=====\n");
return -ENODEV;
}
if(twi_id == adapter->nr){
pr_debug("%s: addr= %x\n",__func__,client->addr);
msleep(50);
ret = gtp_i2c_read(client, buf, 6);
gtp_i2c_end_cmd(client);
if(buf[3] != 0x18)
{
pr_debug("%s:IC is not gt818\n",__func__);
return -ENODEV;
}
GTP_INFO("IC VERSION:%02x%02x_%02x%02x", buf[3], buf[2], buf[5], buf[4]);
strlcpy(info->type, CTP_NAME, I2C_NAME_SIZE);
//printk("%s:I2C connection might be something wrong ! \n",__func__);
return 0;
}else{
return -ENODEV;
}
}
/**
* ctp_print_info - sysconfig print function
* return value:
*
*/
static void ctp_print_info(struct ctp_config_info info,int debug_level)
{
if(debug_level == DEBUG_INIT)
{
dprintk(DEBUG_INIT,"info.ctp_used:%d\n",info.ctp_used);
dprintk(DEBUG_INIT,"info.twi_id:%d\n",info.twi_id);
dprintk(DEBUG_INIT,"info.screen_max_x:%d\n",info.screen_max_x);
dprintk(DEBUG_INIT,"info.screen_max_y:%d\n",info.screen_max_y);
dprintk(DEBUG_INIT,"info.revert_x_flag:%d\n",info.revert_x_flag);
dprintk(DEBUG_INIT,"info.revert_y_flag:%d\n",info.revert_y_flag);
dprintk(DEBUG_INIT,"info.exchange_x_y_flag:%d\n",info.exchange_x_y_flag);
dprintk(DEBUG_INIT,"info.irq_gpio_number:%d\n",info.irq_gpio.gpio);
dprintk(DEBUG_INIT,"info.wakeup_gpio_number:%d\n",info.wakeup_gpio.gpio);
}
}
/**
* ctp_wakeup - function
*
*/
static int ctp_wakeup(int status,int ms)
{
dprintk(DEBUG_INIT,"***CTP*** %s:status:%d,ms = %d\n",__func__,status,ms);
if (status == 0) {
if(ms == 0) {
__gpio_set_value(config_info.wakeup_gpio.gpio, 0);
}else {
__gpio_set_value(config_info.wakeup_gpio.gpio, 0);
msleep(ms);
__gpio_set_value(config_info.wakeup_gpio.gpio, 1);
}
}
if (status == 1) {
if(ms == 0) {
__gpio_set_value(config_info.wakeup_gpio.gpio, 1);
}else {
__gpio_set_value(config_info.wakeup_gpio.gpio, 1);
msleep(ms);
__gpio_set_value(config_info.wakeup_gpio.gpio, 0);
}
}
msleep(5);
return 0;
}
//static s32 goodix_tool_write(struct file *filp, const char __user *buff, unsigned long len, void *data)
ssize_t goodix_tool_write(struct file *filp, const char __user *buff, size_t len, loff_t *off)
{
s32 ret = 0;
GTP_DEBUG_FUNC();
GTP_DEBUG_ARRAY((u8*)buff, len);
ret = copy_from_user(&cmd_head, buff, CMD_HEAD_LENGTH);
if(ret)
{
GTP_ERROR("copy_from_user failed.");
return -EPERM;
}
GTP_DEBUG("[Operation]wr: %02X", cmd_head.wr);
GTP_DEBUG("[Flag]flag: %02X, addr: %02X%02X, value: %02X, relation: %02X", cmd_head.flag, cmd_head.flag_addr[0],
cmd_head.flag_addr[1], cmd_head.flag_val, cmd_head.flag_relation);
GTP_DEBUG("[Retry]circle: %d, times: %d, retry: %d, delay: %d", (s32)cmd_head.circle, (s32)cmd_head.times,
(s32)cmd_head.retry, (s32)cmd_head.delay);
GTP_DEBUG("[Data]data len: %d, addr len: %d, addr: %02X%02X, buffer len: %d, data[0]: %02X", (s32)cmd_head.data_len,
(s32)cmd_head.addr_len, cmd_head.addr[0], cmd_head.addr[1], (s32)len, buff[CMD_HEAD_LENGTH]);
if (1 == cmd_head.wr)
{
ret = copy_from_user(&cmd_head.data[GTP_ADDR_LENGTH], &buff[CMD_HEAD_LENGTH], cmd_head.data_len);
if(ret)
{
GTP_ERROR("copy_from_user failed.");
return -EPERM;
}
memcpy(&cmd_head.data[GTP_ADDR_LENGTH - cmd_head.addr_len], cmd_head.addr, cmd_head.addr_len);
GTP_DEBUG_ARRAY(cmd_head.data, cmd_head.data_len + cmd_head.addr_len);
GTP_DEBUG_ARRAY((u8*)&buff[CMD_HEAD_LENGTH], cmd_head.data_len);
if (1 == cmd_head.flag)
{
if (FAIL == comfirm())
{
GTP_ERROR("[WRITE]Comfirm fail!");
return -EPERM;
}
}
else if (2 == cmd_head.flag)
{
//Need interrupt!
}
if (tool_i2c_write(&cmd_head.data[GTP_ADDR_LENGTH - cmd_head.addr_len],
cmd_head.data_len + cmd_head.addr_len) <= 0)
{
GTP_ERROR("[WRITE]Write data failed!");
return -EPERM;
}
GTP_DEBUG_ARRAY(&cmd_head.data[GTP_ADDR_LENGTH - cmd_head.addr_len],cmd_head.data_len + cmd_head.addr_len);
if (cmd_head.delay)
{
msleep(cmd_head.delay);
}
}
else if (3 == cmd_head.wr) //Write ic type
{
ret = copy_from_user(&cmd_head.data[0], &buff[CMD_HEAD_LENGTH], cmd_head.data_len);
if(ret)
{
GTP_ERROR("copy_from_user failed.");
return -EPERM;
}
memcpy(IC_TYPE, cmd_head.data, cmd_head.data_len);
register_i2c_func();
}
else if (5 == cmd_head.wr)
{
//memcpy(IC_TYPE, cmd_head.data, cmd_head.data_len);
}
else if (7 == cmd_head.wr)//disable irq!
{
gtp_irq_disable(i2c_get_clientdata(gt_client));
#if GTP_ESD_PROTECT
gtp_esd_switch(gt_client, SWITCH_OFF);
#endif
}
else if (9 == cmd_head.wr) //enable irq!
{
gtp_irq_enable(i2c_get_clientdata(gt_client));
#if GTP_ESD_PROTECT
gtp_esd_switch(gt_client, SWITCH_ON);
#endif
}
else if(17 == cmd_head.wr)
{
struct goodix_ts_data *ts = i2c_get_clientdata(gt_client);
ret = copy_from_user(&cmd_head.data[GTP_ADDR_LENGTH], &buff[CMD_HEAD_LENGTH], cmd_head.data_len);
if(ret)
{
GTP_DEBUG("copy_from_user failed.");
return -EPERM;
}
if(cmd_head.data[GTP_ADDR_LENGTH])
{
GTP_INFO("gtp enter rawdiff.");
ts->gtp_rawdiff_mode = true;
}
else
{
ts->gtp_rawdiff_mode = false;
GTP_INFO("gtp leave rawdiff.");
}
}
#ifdef UPDATE_FUNCTIONS
else if (11 == cmd_head.wr)//Enter update mode!
{
if (FAIL == gup_enter_update_mode(gt_client))
{
return -EPERM;
}
}
else if (13 == cmd_head.wr)//Leave update mode!
{
gup_leave_update_mode();
}
else if (15 == cmd_head.wr) //Update firmware!
{
show_len = 0;
total_len = 0;
memset(cmd_head.data, 0, cmd_head.data_len + 1);
memcpy(cmd_head.data, &buff[CMD_HEAD_LENGTH], cmd_head.data_len);
if (FAIL == gup_update_proc((void*)cmd_head.data))
{
return -EPERM;
}
}
#endif
return len;
}
s32 init_wr_node(struct i2c_client *client)
{
s32 i;
const s8 entry_prefix[] = "GMNode_";
s8 gtp_tool_entry[30];
gt_client = i2c_client_point;
GTP_INFO("client %d.%d", (int)gt_client, (int)client);
memset(&cmd_head, 0, sizeof(cmd_head));
cmd_head.data = NULL;
i = 5;
while ((!cmd_head.data) && i)
{
cmd_head.data = kzalloc(i * DATA_LENGTH_UINT, GFP_KERNEL);
if (NULL != cmd_head.data)
{
break;
}
i--;
}
if (i)
{
DATA_LENGTH = i * DATA_LENGTH_UINT + GTP_ADDR_LENGTH;
GTP_INFO("Applied memory size:%d.", DATA_LENGTH);
}
else
{
GTP_ERROR("Apply for memory failed.");
return FAIL;
}
cmd_head.addr_len = 2;
cmd_head.retry = 5;
register_i2c_func();
// goodix_proc_entry = create_proc_entry(GOODIX_ENTRY_NAME, 0664, NULL);
memset(gtp_tool_entry, 0, sizeof(gtp_tool_entry));
i = sizeof(entry_prefix)/sizeof(s8);
memcpy(gtp_tool_entry, entry_prefix, i-1);
memcpy(>p_tool_entry[i-1], __DATE__, sizeof(__DATE__)/sizeof(s8));
#if 0 // fix 3.10
goodix_proc_entry = create_proc_entry(gtp_tool_entry, 0664, NULL);
if (goodix_proc_entry == NULL)
{
GTP_ERROR("Couldn't create proc entry!");
return FAIL;
}
else
{
GTP_INFO("Create proc entry success!");
goodix_proc_entry->write_proc = goodix_tool_write;
goodix_proc_entry->read_proc = goodix_tool_read;
}
#else
if(proc_create(GOODIX_ENTRY_NAME, 0660, NULL, >_tool_fops)== NULL)
{
GTP_ERROR("create_proc_entry %s failed", gtp_tool_entry);
return -1;
}
#endif
return SUCCESS;
}
//@return, 0:operate successfully
// > 0: the length of memory size ioctl has accessed,
// error otherwise.
static long gt1x_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
u32 value = 0;
s32 ret = 0; //the initial value must be 0
u8 *data = NULL;
GTP_DEBUG("IOCTL CMD:%x", cmd);
GTP_DEBUG("command:%d, length:%d, rw:%s", _IOC_NR(cmd), _IOC_SIZE(cmd), (_IOC_DIR(cmd) & _IOC_READ) ? "read" : (_IOC_DIR(cmd) & _IOC_WRITE) ? "write" : "-");
if (_IOC_DIR(cmd)) {
s32 err = -1;
s32 data_length = _IOC_SIZE(cmd);
data = (u8 *) kzalloc(data_length, GFP_KERNEL);
memset(data, 0, data_length);
if (_IOC_DIR(cmd) & _IOC_WRITE) {
err = copy_from_user(data, (void __user *)arg, data_length);
if (err) {
GTP_DEBUG("Can't access the memory.");
kfree(data);
return -1;
}
}
} else {
value = (u32) arg;
}
switch (cmd & NEGLECT_SIZE_MASK) {
case IO_GET_VERISON:
if ((u8 __user *) arg) {
ret = copy_to_user(((u8 __user *) arg), IO_VERSION, sizeof(IO_VERSION));
if (!ret) {
ret = sizeof(IO_VERSION);
}
GTP_INFO("%s", IO_VERSION);
}
break;
case IO_IIC_READ:
ret = io_iic_read(data, (void __user *)arg);
break;
case IO_IIC_WRITE:
ret = io_iic_write(data);
break;
case IO_RESET_GUITAR:
gt1x_reset_guitar();
break;
case IO_DISABLE_IRQ:
gt1x_irq_disable();
#if GTP_ESD_PROTECT
gt1x_esd_switch(SWITCH_OFF);
#endif
break;
case IO_ENABLE_IRQ:
gt1x_irq_enable();
#if GTP_ESD_PROTECT
gt1x_esd_switch(SWITCH_ON);
#endif
break;
//print a string to syc log messages between application and kernel.
case IO_PRINT:
if (data)
GTP_INFO("%s", (char *)data);
break;
#if GTP_GESTURE_WAKEUP
case GESTURE_ENABLE_TOTALLY:
GTP_DEBUG("ENABLE_GESTURE_TOTALLY");
gesture_enabled = (is_all_dead(gestures_flag, sizeof(gestures_flag)) ? 0 : 1);
break;
case GESTURE_DISABLE_TOTALLY:
GTP_DEBUG("DISABLE_GESTURE_TOTALLY");
gesture_enabled = 0;
break;
case GESTURE_ENABLE_PARTLY:
SETBIT(gestures_flag, (u8) value);
gesture_enabled = 1;
GTP_DEBUG("ENABLE_GESTURE_PARTLY, gesture = 0x%02X, gesture_enabled = %d", value, gesture_enabled);
break;
case GESTURE_DISABLE_PARTLY:
ret = QUERYBIT(gestures_flag, (u8) value);
if (!ret) {
break;
}
CLEARBIT(gestures_flag, (u8) value);
if (is_all_dead(gestures_flag, sizeof(gestures_flag))) {
gesture_enabled = 0;
}
GTP_DEBUG("DISABLE_GESTURE_PARTLY, gesture = 0x%02X, gesture_enabled = %d", value, gesture_enabled);
break;
case GESTURE_DATA_OBTAIN:
GTP_DEBUG("OBTAIN_GESTURE_DATA");
mutex_lock(&gesture_data_mutex);
if (gesture_data.data[1] > GESTURE_MAX_POINT_COUNT) {
gesture_data.data[1] = GESTURE_MAX_POINT_COUNT;
}
if (gesture_data.data[3] > 80) {
gesture_data.data[3] = 80;
}
ret = copy_to_user(((u8 __user *) arg), &gesture_data.data, 4 + gesture_data.data[1] * 4 + gesture_data.data[3]);
mutex_unlock(&gesture_data_mutex);
if (ret) {
GTP_ERROR("ERROR when copy gesture data to user.");
ret = ERROR_MEM;
} else {
ret = 4 + gesture_data.data[1] * 4 + gesture_data.data[3];
}
break;
case GESTURE_DATA_ERASE:
GTP_DEBUG("ERASE_GESTURE_DATA");
gesture_clear_wakeup_data();
break;
#endif // GTP_GESTURE_WAKEUP
#if GTP_HOTKNOT
case HOTKNOT_LOAD_HOTKNOT:
ret = hotknot_load_hotknot_subsystem();
break;
case HOTKNOT_LOAD_AUTHENTICATION:
#if GTP_ESD_PROTECT
gt1x_esd_switch(SWITCH_ON);
#endif
ret = hotknot_load_authentication_subsystem();
break;
case HOTKNOT_RECOVERY_MAIN:
ret = hotknot_recovery_main_system();
break;
#if HOTKNOT_BLOCK_RW
case HOTKNOT_DEVICES_PAIRED:
hotknot_paired_flag = 0;
force_wake_flag = 0;
block_enable = 1;
ret = hotknot_block_rw(HN_DEVICE_PAIRED, (s32) value);
break;
case HOTKNOT_MASTER_SEND:
ret = hotknot_block_rw(HN_MASTER_SEND, (s32) value);
if (!ret)
ret = got_hotknot_extra_state;
break;
case HOTKNOT_SLAVE_RECEIVE:
ret = hotknot_block_rw(HN_SLAVE_RECEIVED, (s32) value);
if (!ret)
ret = got_hotknot_extra_state;
break;
case HOTKNOT_MASTER_DEPARTED:
ret = hotknot_block_rw(HN_MASTER_DEPARTED, (s32) value);
break;
case HOTKNOT_SLAVE_DEPARTED:
ret = hotknot_block_rw(HN_SLAVE_DEPARTED, (s32) value);
break;
case HOTKNOT_WAKEUP_BLOCK:
hotknot_wakeup_block();
break;
#endif //HOTKNOT_BLOCK_RW
#endif //GTP_HOTKNOT
default:
GTP_INFO("Unknown cmd.");
ret = -1;
break;
}
if (data != NULL) {
kfree(data);
}
return ret;
}
s32 gesture_event_handler(struct input_dev * dev)
{
u8 doze_buf[4] = { 0 };
s32 ret = -1;
int len, extra_len;
if (DOZE_ENABLED == gesture_doze_status) {
ret = gt1x_i2c_read(GTP_REG_WAKEUP_GESTURE, doze_buf, 4);
GTP_DEBUG("0x%x = 0x%02X,0x%02X,0x%02X,0x%02X", GTP_REG_WAKEUP_GESTURE, doze_buf[0], doze_buf[1], doze_buf[2], doze_buf[3]);
if (ret == 0 && doze_buf[0] != 0) {
if (!QUERYBIT(gestures_flag, doze_buf[0])) {
GTP_INFO("Sorry, this gesture has been disabled.");
doze_buf[0] = 0x00;
gt1x_i2c_write(GTP_REG_WAKEUP_GESTURE, doze_buf, 1);
return 0;
}
mutex_lock(&gesture_data_mutex);
len = doze_buf[1];
if (len > GESTURE_MAX_POINT_COUNT) {
GTP_ERROR("Gesture contain too many points!(%d)", len);
len = GESTURE_MAX_POINT_COUNT;
}
if (len > 0) {
ret = gt1x_i2c_read(GTP_REG_WAKEUP_GESTURE_DETAIL, &gesture_data.data[4], len * 4);
if (ret < 0) {
GTP_DEBUG("Read gesture data failed.");
mutex_unlock(&gesture_data_mutex);
return 0;
}
}
extra_len = doze_buf[3];
if (extra_len > 80) {
GTP_ERROR("Gesture contain too many extra data!(%d)", extra_len);
extra_len = 80;
}
if (extra_len > 0) {
ret = gt1x_i2c_read(GTP_REG_WAKEUP_GESTURE + 4, &gesture_data.data[4 + len * 4], extra_len);
if (ret < 0) {
GTP_DEBUG("Read extra gesture data failed.");
mutex_unlock(&gesture_data_mutex);
return 0;
}
}
gesture_data.data[0] = doze_buf[0]; // gesture type
gesture_data.data[1] = len; // gesture points number
gesture_data.data[2] = doze_buf[2];
gesture_data.data[3] = extra_len;
mutex_unlock(&gesture_data_mutex);
GTP_DEBUG("Gesture: 0x%02X, points: %d", doze_buf[0], doze_buf[1]);
doze_buf[0] = 0;
gt1x_i2c_write(GTP_REG_WAKEUP_GESTURE, doze_buf, 1);
input_report_key(dev, KEY_GESTURE, 1);
input_sync(dev);
input_report_key(dev, KEY_GESTURE, 0);
input_sync(dev);
return 1;
}
return 0;
}
return -1;
}
/*@return, 0:operate successfully
/ > 0: the length of memory size ioctl has accessed,
/ error otherwise.*/
static long gt1x_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
u32 value = 0;
s32 ret = 0; /*the initial value must be 0*/
u8 *data = NULL;
static struct ratelimit_state ratelimit = {
.lock = __RAW_SPIN_LOCK_UNLOCKED(ratelimit.lock),
.interval = HZ/2,
.burst = 1,
.begin = 1,
};
GTP_DEBUG("IOCTL CMD:%x", cmd);
/*GTP_DEBUG("command:%d, length:%d, rw:%s", _IOC_NR(cmd), _IOC_SIZE(cmd),
(_IOC_DIR(cmd) & _IOC_READ) ? "read" : (_IOC_DIR(cmd) & _IOC_WRITE) ? "write" : "-");*/
if (_IOC_DIR(cmd)) {
s32 err = -1;
s32 data_length = _IOC_SIZE(cmd);
data = kzalloc(data_length, GFP_KERNEL);
memset(data, 0, data_length);
if (_IOC_DIR(cmd) & _IOC_WRITE) {
err = copy_from_user(data, (void __user *)arg, data_length);
if (err) {
GTP_DEBUG("Can't access the memory.");
kfree(data);
return -1;
}
}
} else {
value = (u32) arg;
}
switch (cmd & NEGLECT_SIZE_MASK) {
case IO_GET_VERSION:
if ((u8 __user *) arg) {
ret = copy_to_user(((u8 __user *) arg), IO_VERSION, sizeof(IO_VERSION));
if (!ret)
ret = sizeof(IO_VERSION);
GTP_INFO("%s", IO_VERSION);
}
break;
case IO_IIC_READ:
if (1 == gt1x_is_tpd_halt()) {
if (__ratelimit(&ratelimit))
GTP_ERROR("touch is suspended.");
break;
}
ret = io_iic_read(data, (void __user *)arg);
break;
case IO_IIC_WRITE:
if (1 == gt1x_is_tpd_halt()) {
if (__ratelimit(&ratelimit))
GTP_ERROR("touch is suspended.");
break;
}
ret = io_iic_write(data);
break;
case IO_RESET_GUITAR:
gt1x_reset_guitar();
break;
case IO_DISABLE_IRQ:
gt1x_irq_disable();
#ifdef CONFIG_GTP_ESD_PROTECT
gt1x_esd_switch(SWITCH_OFF);
#endif
break;
case IO_ENABLE_IRQ:
gt1x_irq_enable();
#ifdef CONFIG_GTP_ESD_PROTECT
gt1x_esd_switch(SWITCH_ON);
#endif
break;
/*print a string to syc log messages between application and kernel.*/
case IO_PRINT:
if (data)
GTP_INFO("%s", (char *)data);
break;
#ifdef CONFIG_GTP_GESTURE_WAKEUP
case GESTURE_ENABLE_TOTALLY:
GTP_DEBUG("ENABLE_GESTURE_TOTALLY");
gesture_enabled = (is_all_dead(gestures_flag, sizeof(gestures_flag)) ? 0 : 1);
break;
case GESTURE_DISABLE_TOTALLY:
GTP_DEBUG("DISABLE_GESTURE_TOTALLY");
gesture_enabled = 0;
break;
case GESTURE_ENABLE_PARTLY:
SETBIT(gestures_flag, (u8) value);
gesture_enabled = 1;
GTP_DEBUG("ENABLE_GESTURE_PARTLY, gesture = 0x%02X, gesture_enabled = %d", value, gesture_enabled);
break;
case GESTURE_DISABLE_PARTLY:
ret = QUERYBIT(gestures_flag, (u8) value);
if (!ret)
break;
CLEARBIT(gestures_flag, (u8) value);
if (is_all_dead(gestures_flag, sizeof(gestures_flag)))
gesture_enabled = 0;
GTP_DEBUG("DISABLE_GESTURE_PARTLY, gesture = 0x%02X, gesture_enabled = %d", value, gesture_enabled);
break;
case GESTURE_DATA_OBTAIN:
GTP_DEBUG("OBTAIN_GESTURE_DATA");
mutex_lock(&gesture_data_mutex);
if (gesture_data.data[1] > GESTURE_MAX_POINT_COUNT)
gesture_data.data[1] = GESTURE_MAX_POINT_COUNT;
if (gesture_data.data[3] > 80)
gesture_data.data[3] = 80;
ret =
copy_to_user(((u8 __user *) arg), &gesture_data.data,
4 + gesture_data.data[1] * 4 + gesture_data.data[3]);
mutex_unlock(&gesture_data_mutex);
if (ret) {
GTP_ERROR("ERROR when copy gesture data to user.");
ret = ERROR_MEM;
} else {
ret = 4 + gesture_data.data[1] * 4 + gesture_data.data[3];
}
break;
case GESTURE_DATA_ERASE:
GTP_DEBUG("ERASE_GESTURE_DATA");
gesture_clear_wakeup_data();
break;
#endif /*CONFIG_GTP_GESTURE_WAKEUP*/
#ifdef CONFIG_GTP_HOTKNOT
case HOTKNOT_LOAD_HOTKNOT:
ret = hotknot_load_hotknot_subsystem();
break;
case HOTKNOT_LOAD_AUTHENTICATION:
if (1 == gt1x_is_tpd_halt()) {
GTP_ERROR("touch is suspended.");
break;
}
#ifdef CONFIG_GTP_ESD_PROTECT
gt1x_esd_switch(SWITCH_ON);
#endif
ret = hotknot_load_authentication_subsystem();
break;
case HOTKNOT_RECOVERY_MAIN:
if (1 == gt1x_is_tpd_halt()) {
GTP_ERROR("touch is suspended.");
break;
}
ret = hotknot_recovery_main_system();
break;
#ifdef CONFIG_HOTKNOT_BLOCK_RW
case HOTKNOT_DEVICES_PAIRED:
hotknot_paired_flag = 0;
force_wake_flag = 0;
block_enable = 1;
ret = hotknot_block_rw(HN_DEVICE_PAIRED, (s32) value);
break;
case HOTKNOT_MASTER_SEND:
ret = hotknot_block_rw(HN_MASTER_SEND, (s32) value);
if (!ret)
ret = got_hotknot_extra_state;
break;
case HOTKNOT_SLAVE_RECEIVE:
ret = hotknot_block_rw(HN_SLAVE_RECEIVED, (s32) value);
if (!ret)
ret = got_hotknot_extra_state;
break;
case HOTKNOT_MASTER_DEPARTED:
ret = hotknot_block_rw(HN_MASTER_DEPARTED, (s32) value);
break;
case HOTKNOT_SLAVE_DEPARTED:
ret = hotknot_block_rw(HN_SLAVE_DEPARTED, (s32) value);
break;
case HOTKNOT_WAKEUP_BLOCK:
hotknot_wakeup_block();
break;
#endif /*CONFIG_HOTKNOT_BLOCK_RW*/
#endif /*CONFIG_GTP_HOTKNOT*/
default:
GTP_INFO("Unknown cmd.");
ret = -1;
break;
}
if (data != NULL)
kfree(data);
return ret;
}
#ifdef CONFIG_GTP_HOTKNOT
#ifdef CONFIG_COMPAT
static long gt1x_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
long ret;
void __user *arg32 = NULL;
GTP_DEBUG("gt1x_compat_ioctl cmd = %x, arg: 0x%lx\n", cmd, arg);
arg32 = compat_ptr(arg);
if (!file->f_op || !file->f_op->unlocked_ioctl)
return -ENOTTY;
/*GTP_DEBUG("gt1x_compat_ioctl arg: 0x%lx, arg32: 0x%p\n",arg, arg32);*/
switch (cmd & NEGLECT_SIZE_MASK) {
case COMPAT_IO_GET_VERSION:
/*GTP_DEBUG("gt1x_compat_ioctl COMPAT_IO_GET_VERSION\n");*/
if (arg32 == NULL) {
GTP_ERROR("invalid argument.");
return -EINVAL;
}
ret = file->f_op->unlocked_ioctl(file, cmd, (unsigned long)arg32);
break;
case COMPAT_IO_IIC_READ:
/*GTP_DEBUG("gt1x_compat_ioctl COMPAT_IO_IIC_READ\n");*/
if (arg32 == NULL) {
GTP_ERROR("invalid argument.");
return -EINVAL;
}
ret = file->f_op->unlocked_ioctl(file, cmd, (unsigned long)arg32);
break;
case COMPAT_IO_IIC_WRITE:
/*GTP_DEBUG("gt1x_compat_ioctl COMPAT_IO_IIC_WRITE\n");*/
if (arg32 == NULL) {
GTP_ERROR("invalid argument.");
return -EINVAL;
}
ret = file->f_op->unlocked_ioctl(file, cmd, (unsigned long)arg32);
break;
case COMPAT_IO_RESET_GUITAR:
/*GTP_DEBUG("gt1x_compat_ioctl COMPAT_IO_RESET_GUITAR\n");*/
ret = file->f_op->unlocked_ioctl(file, cmd, (unsigned long)arg32);
break;
case COMPAT_IO_DISABLE_IRQ:
/*GTP_DEBUG("gt1x_compat_ioctl COMPAT_IO_DISABLE_IRQ\n");*/
ret = file->f_op->unlocked_ioctl(file, cmd, (unsigned long)arg32);
break;
case COMPAT_IO_ENABLE_IRQ:
/*GTP_DEBUG("gt1x_compat_ioctl COMPAT_IO_ENABLE_IRQ\n");*/
ret = file->f_op->unlocked_ioctl(file, cmd, (unsigned long)arg32);
break;
case COMPAT_IO_PRINT:
/*GTP_DEBUG("gt1x_compat_ioctl COMPAT_IO_PRINT\n");*/
ret = file->f_op->unlocked_ioctl(file, cmd, (unsigned long)arg32);
break;
case COMPAT_GESTURE_ENABLE_TOTALLY:
/*GTP_DEBUG("gt1x_compat_ioctl COMPAT_GESTURE_ENABLE_TOTALLY\n");*/
ret = file->f_op->unlocked_ioctl(file, cmd, (unsigned long)arg32);
break;
case COMPAT_GESTURE_DISABLE_TOTALLY:
/*GTP_DEBUG("gt1x_compat_ioctl COMPAT_GESTURE_DISABLE_TOTALLY\n");*/
ret = file->f_op->unlocked_ioctl(file, cmd, (unsigned long)arg32);
break;
case COMPAT_GESTURE_ENABLE_PARTLY:
/*GTP_DEBUG("gt1x_compat_ioctl COMPAT_GESTURE_ENABLE_PARTLY\n");*/
ret = file->f_op->unlocked_ioctl(file, cmd, (unsigned long)arg32);
break;
case COMPAT_GESTURE_DISABLE_PARTLY:
/*GTP_DEBUG("gt1x_compat_ioctl COMPAT_GESTURE_DISABLE_PARTLY\n");*/
ret = file->f_op->unlocked_ioctl(file, cmd, (unsigned long)arg32);
break;
case COMPAT_GESTURE_DATA_OBTAIN:
if (arg32 == NULL) {
GTP_ERROR("invalid argument.");
return -EINVAL;
}
/*GTP_DEBUG("gt1x_compat_ioctl COMPAT_GESTURE_DATA_OBTAIN\n");*/
ret = file->f_op->unlocked_ioctl(file, cmd, (unsigned long)arg32);
break;
case COMPAT_GESTURE_DATA_ERASE:
/*GTP_DEBUG("gt1x_compat_ioctl COMPAT_GESTURE_DATA_ERASE\n");*/
ret = file->f_op->unlocked_ioctl(file, cmd, (unsigned long)arg32);
break;
case COMPAT_HOTKNOT_LOAD_HOTKNOT:
/*GTP_DEBUG("gt1x_compat_ioctl COMPAT_HOTKNOT_LOAD_HOTKNOT\n");*/
ret = file->f_op->unlocked_ioctl(file, cmd, (unsigned long)arg32);
break;
case COMPAT_HOTKNOT_LOAD_AUTHENTICATION:
/*GTP_DEBUG("gt1x_compat_ioctl COMPAT_HOTKNOT_LOAD_AUTHENTICATION\n");*/
ret = file->f_op->unlocked_ioctl(file, cmd, (unsigned long)arg32);
break;
case COMPAT_HOTKNOT_RECOVERY_MAIN:
/*GTP_DEBUG("gt1x_compat_ioctl COMPAT_HOTKNOT_RECOVERY_MAIN\n");*/
ret = file->f_op->unlocked_ioctl(file, cmd, (unsigned long)arg32);
break;
case COMPAT_HOTKNOT_DEVICES_PAIRED:
/*GTP_DEBUG("gt1x_compat_ioctl COMPAT_HOTKNOT_DEVICES_PAIRED\n");*/
ret = file->f_op->unlocked_ioctl(file, cmd, (unsigned long)arg32);
break;
case COMPAT_HOTKNOT_MASTER_SEND:
/*GTP_DEBUG("gt1x_compat_ioctl COMPAT_HOTKNOT_MASTER_SEND\n");*/
ret = file->f_op->unlocked_ioctl(file, cmd, (unsigned long)arg32);
break;
case COMPAT_HOTKNOT_SLAVE_RECEIVE:
/*GTP_DEBUG("gt1x_compat_ioctl COMPAT_HOTKNOT_SLAVE_RECEIVE\n");*/
ret = file->f_op->unlocked_ioctl(file, cmd, (unsigned long)arg32);
break;
case COMPAT_HOTKNOT_MASTER_DEPARTED:
/*GTP_DEBUG("gt1x_compat_ioctl COMPAT_HOTKNOT_MASTER_DEPARTED\n");*/
ret = file->f_op->unlocked_ioctl(file, cmd, (unsigned long)arg32);
break;
case COMPAT_HOTKNOT_SLAVE_DEPARTED:
/*GTP_DEBUG("gt1x_compat_ioctl COMPAT_HOTKNOT_SLAVE_DEPARTED\n");*/
ret = file->f_op->unlocked_ioctl(file, cmd, (unsigned long)arg32);
break;
case COMPAT_HOTKNOT_WAKEUP_BLOCK:
/*GTP_DEBUG("gt1x_compat_ioctl COMPAT_HOTKNOT_WAKEUP_BLOCK\n");*/
ret = file->f_op->unlocked_ioctl(file, cmd, (unsigned long)arg32);
break;
default:
GTP_INFO("Unknown cmd.");
ret = -1;
break;
}
return ret;
}
static int gt927_diffdata_read_proc(char *page, char **start, off_t off, int count, int *eof, void *data)
{
int driving_num = 0;
int sensing_num = 0;
int i;
char *ptr = page;
u8 *buf;
mt65xx_eint_mask(CUST_EINT_TOUCH_PANEL_NUM);
driving_num += (config[27 + GTP_ADDR_LENGTH] & 0x1F);
driving_num += (config[28 + GTP_ADDR_LENGTH] & 0x1F);
sensing_num += (config[29 + GTP_ADDR_LENGTH] & 0x0F);
sensing_num += (config[29 + GTP_ADDR_LENGTH] & 0xF0) >> 4;
GTP_INFO("TPD driving_num %d", driving_num);
GTP_INFO("TPD sensing_num %d", sensing_num);
buf = (u8 *)kzalloc(driving_num * sensing_num, GFP_KERNEL);
//0x8040 write 1 for rawdata/diff access
buf[0] = 1;
i2c_write_bytes(i2c_client_point, GTP_REG_SLEEP, buf, 1);
// wait for normal INT finished
while (tpd_flag == 1)
{
msleep(20);
}
msleep(100);
//check for raw data ready
i2c_read_bytes(i2c_client_point, GTP_READ_COOR_ADDR, buf, 1);
while (buf[0] == 0)
{
//wait for data ready
GTP_INFO("Wati for raw data");
i2c_read_bytes(i2c_client_point, GTP_READ_COOR_ADDR, buf, 1);
GTP_INFO("0x814E : %2X", buf[0]);
buf[0] &= 0x80;
msleep(5);
}
i2c_read_bytes(i2c_client_point, GTP_DIFFDATA_REG, buf, driving_num * sensing_num);
for (i = 0 ; i < driving_num * sensing_num; i = i + 1)
{
ptr += sprintf(ptr, "%d\t", buf[i]);
if ((i % (sensing_num)) == (sensing_num - 1))
ptr += sprintf(ptr, "\n");
}
//clear data ready status
buf[0] = 0;
i2c_write_bytes(i2c_client_point, GTP_READ_COOR_ADDR, buf, 1);
//0x8040 write 0 for leaving rawdata/diff access mode
buf[0] = 0;
i2c_write_bytes(i2c_client_point, GTP_REG_SLEEP, buf, 1);
mt65xx_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM);
kfree(buf);
*eof = 1;
return (ptr - page);
}
static int gt91xx_config_write_proc(struct file *file, const char *buffer, unsigned long count, void *data)
{
s32 ret = 0;
char temp[16] = {0}; // for store special format cmd
char mode_str[8] = {0};
unsigned int mode;
u8 buf[1];
GTP_DEBUG("write count %ld", count);
if (count > GTP_CONFIG_MAX_LENGTH)
{
GTP_ERROR("size not match [%d:%ld]", GTP_CONFIG_MAX_LENGTH, count);
return -EFAULT;
}
/**********************************************/
/* for store special format cmd */
if (copy_from_user(temp, buffer, sizeof(temp)))
{
GTP_ERROR("copy from user fail 2");
return -EFAULT;
}
sscanf(temp, "%s %d", (char *)&mode_str, &mode);
if(strcmp(mode_str, "switch") == 0)
{
if(mode == 0)// turn off
tpd_off();
else if(mode == 1)//turn on
tpd_on();
else
GTP_ERROR("error mode :%d", mode);
return count;
}
//force clear config
if(strcmp(mode_str, "clear_config") == 0)
{
GTP_INFO("Force clear config");
buf[0] = 0x10;
ret = i2c_write_bytes(i2c_client_point, GTP_REG_SLEEP, buf, 1);
return count;
}
if (copy_from_user(&config[2], buffer, count))
{
GTP_ERROR("copy from user fail");
return -EFAULT;
}
/***********clk operate reseved****************/
/**********************************************/
ret = gtp_send_cfg(i2c_client_point);
abs_x_max = (config[RESOLUTION_LOC + 1] << 8) + config[RESOLUTION_LOC];
abs_y_max = (config[RESOLUTION_LOC + 3] << 8) + config[RESOLUTION_LOC + 2];
int_type = (config[TRIGGER_LOC]) & 0x03;
if (ret < 0)
{
GTP_ERROR("send config failed.");
}
return count;
}
