/******************************************************* Function: Goodix tool write function. Input: standard proc write function param. Output: Return write length. ********************************************************/ static s32 goodix_tool_write(struct file *filp, const char __user *buff, unsigned long len, void *data) { 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."); } GTP_DEBUG("wr :0x%02x.", cmd_head.wr); GTP_DEBUG("flag:0x%02x.", cmd_head.flag); GTP_DEBUG("flag addr:0x%02x%02x.", cmd_head.flag_addr[0], cmd_head.flag_addr[1]); GTP_DEBUG("flag val:0x%02x.", cmd_head.flag_val); GTP_DEBUG("flag rel:0x%02x.", cmd_head.flag_relation); GTP_DEBUG("circle :%d.", (s32)cmd_head.circle); GTP_DEBUG("times :%d.", (s32)cmd_head.times); GTP_DEBUG("retry :%d.", (s32)cmd_head.retry); GTP_DEBUG("delay :%d.", (s32)cmd_head.delay); GTP_DEBUG("data len:%d.", (s32)cmd_head.data_len); GTP_DEBUG("addr len:%d.", (s32)cmd_head.addr_len); GTP_DEBUG("addr:0x%02x%02x.", cmd_head.addr[0], cmd_head.addr[1]); GTP_DEBUG("len:%d.", (s32)len); GTP_DEBUG("buf[20]:0x%02x.", buff[CMD_HEAD_LENGTH]); if (1 == cmd_head.wr) { // copy_from_user(&cmd_head.data[cmd_head.addr_len], &buff[CMD_HEAD_LENGTH], cmd_head.data_len); 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."); } 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 FAIL; } } 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 FAIL; } 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); } return cmd_head.data_len + CMD_HEAD_LENGTH; } 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."); } memcpy(IC_TYPE, cmd_head.data, cmd_head.data_len); register_i2c_func(); return cmd_head.data_len + CMD_HEAD_LENGTH; } else if (5 == cmd_head.wr) { //memcpy(IC_TYPE, cmd_head.data, cmd_head.data_len); return cmd_head.data_len + CMD_HEAD_LENGTH; } else if (7 == cmd_head.wr)//disable irq! { gtp_irq_disable(i2c_get_clientdata(gt_client)); return CMD_HEAD_LENGTH; } else if (9 == cmd_head.wr) //enable irq! { gtp_irq_enable(i2c_get_clientdata(gt_client)); return CMD_HEAD_LENGTH; } else if(17 == cmd_head.wr) { struct goodix_platform_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."); } if(cmd_head.data[GTP_ADDR_LENGTH]) { GTP_DEBUG("gtp enter rawdiff."); ts->gtp_rawdiff_mode = true; } else { ts->gtp_rawdiff_mode = false; GTP_DEBUG("gtp leave rawdiff."); } return CMD_HEAD_LENGTH; } #ifdef UPDATE_FUNCTIONS else if (11 == cmd_head.wr)//Enter update mode! { if (FAIL == gup_enter_update_mode(gt_client)) { return FAIL; } } 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 FAIL; } } #endif return CMD_HEAD_LENGTH; }
//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; }
static int goodix_tool_write(struct file *filp, const char __user *buff, unsigned long len, void *data) { int 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."); GTP_DEBUG("wr :0x%02x.", cmd_head.wr); GTP_DEBUG("flag:0x%02x.", cmd_head.flag); GTP_DEBUG("flag addr:0x%02x%02x.", cmd_head.flag_addr[0], cmd_head.flag_addr[1]); GTP_DEBUG("flag val:0x%02x.", cmd_head.flag_val); GTP_DEBUG("flag rel:0x%02x.", cmd_head.flag_relation); GTP_DEBUG("circle :%d.", (int)cmd_head.circle); GTP_DEBUG("times :%d.", (int)cmd_head.times); GTP_DEBUG("retry :%d.", (int)cmd_head.retry); GTP_DEBUG("delay :%d.", (int)cmd_head.delay); GTP_DEBUG("data len:%d.", (int)cmd_head.data_len); GTP_DEBUG("addr len:%d.", (int)cmd_head.addr_len); GTP_DEBUG("addr:0x%02x%02x.", cmd_head.addr[0], cmd_head.addr[1]); GTP_DEBUG("len:%d.", (int)len); GTP_DEBUG("buf[20]:0x%02x.", buff[CMD_HEAD_LENGTH]); if (1 == cmd_head.wr) { /* copy_from_user(&cmd_head.data[cmd_head.addr_len], &buff[CMD_HEAD_LENGTH], cmd_head.data_len); */ 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."); 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 (comfirm() < 0) { GTP_ERROR("[WRITE]Comfirm fail!"); return -1; } } 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 -1; } 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); return cmd_head.data_len + CMD_HEAD_LENGTH; } 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."); memcpy(IC_TYPE, cmd_head.data, cmd_head.data_len); register_i2c_func(); return cmd_head.data_len + CMD_HEAD_LENGTH; } else if (5 == cmd_head.wr) { /* memcpy(IC_TYPE, cmd_head.data, cmd_head.data_len); */ return cmd_head.data_len + CMD_HEAD_LENGTH; } 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 return CMD_HEAD_LENGTH; } 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 return CMD_HEAD_LENGTH; } 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."); if (cmd_head.data[GTP_ADDR_LENGTH]) { GTP_DEBUG("gtp enter rawdiff."); ts->gtp_rawdiff_mode = true; } else { ts->gtp_rawdiff_mode = false; GTP_DEBUG("gtp leave rawdiff."); } return CMD_HEAD_LENGTH; } #ifdef UPDATE_FUNCTIONS else if (11 == cmd_head.wr) { /* Enter update mode! */ if (gup_enter_update_mode(gt_client) < 0) return -1; } 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 (gup_update_proc((void*)cmd_head.data) < 0) return -1; } #endif return CMD_HEAD_LENGTH; }
static void goodix_ts_work_func(struct work_struct *work) { struct goodix_ts_data *ts = NULL; static u16 pre_touch; static u8 pre_key; u8 end_cmd[3] = { GTP_READ_COOR_ADDR >> 8, GTP_READ_COOR_ADDR & 0xFF, 0 }; u8 point_data[2 + 1 + 8 * GTP_MAX_TOUCH + 1] = { GTP_READ_COOR_ADDR >> 8, GTP_READ_COOR_ADDR & 0xFF }; u8 touch_num = 0; u8 finger = 0; u8 key_value = 0; u8 *coor_data = NULL; s32 input_x = 0; s32 input_y = 0; s32 input_w = 0; s32 id = 0; s32 i, ret; GTP_DEBUG_FUNC(); ts = container_of(work, struct goodix_ts_data, work); if (ts->enter_update) return; ret = gtp_i2c_read(ts->client, point_data, 12); if (ret < 0) { GTP_ERROR("I2C transfer error. errno:%d\n ", ret); goto exit_work_func; } finger = point_data[GTP_ADDR_LENGTH]; if ((finger & 0x80) == 0) goto exit_work_func; touch_num = finger & 0x0f; if (touch_num > GTP_MAX_TOUCH) goto exit_work_func; if (touch_num > 1) { u8 buf[8 * GTP_MAX_TOUCH] = { (GTP_READ_COOR_ADDR + 10) >> 8, (GTP_READ_COOR_ADDR + 10) & 0xff }; ret = gtp_i2c_read(ts->client, buf, 2 + 8 * (touch_num - 1)); memcpy(&point_data[12], &buf[2], 8 * (touch_num - 1)); } #if GTP_HAVE_TOUCH_KEY key_value = point_data[3 + 8 * touch_num]; if (key_value || pre_key) { for (i = 0; i < GTP_MAX_KEY_NUM; i++) input_report_key(ts->input_dev, touch_key_array[i], key_value & (0x01 << i)); touch_num = 0; pre_touch = 0; } #endif pre_key = key_value; GTP_DEBUG("pre_touch:%02x, finger:%02x.", pre_touch, finger); #if GTP_ICS_SLOT_REPORT if (pre_touch || touch_num) { s32 pos = 0; u16 touch_index = 0; coor_data = &point_data[3]; if (touch_num) { id = coor_data[pos] & 0x0F; touch_index |= (0x01 << id); } GTP_DEBUG("id=%d, touch_index=0x%x, pre_touch=0x%x\n",\ id, touch_index, pre_touch); for (i = 0; i < GTP_MAX_TOUCH; i++) { if (touch_index & (0x01<<i)) { input_x = coor_data[pos + 1] | coor_data[pos + 2] << 8; input_y = coor_data[pos + 3] | coor_data[pos + 4] << 8; input_w = coor_data[pos + 5] | coor_data[pos + 6] << 8; gtp_touch_down(ts, id, input_x, input_y, input_w); pre_touch |= 0x01 << i; pos += 8; id = coor_data[pos] & 0x0F; touch_index |= (0x01<<id); } else { gtp_touch_up(ts, i); pre_touch &= ~(0x01 << i); } } } #else if (touch_num) { for (i = 0; i < touch_num; i++) { coor_data = &point_data[i * 8 + 3]; id = coor_data[0] & 0x0F; input_x = coor_data[1] | coor_data[2] << 8; input_y = coor_data[3] | coor_data[4] << 8; input_w = coor_data[5] | coor_data[6] << 8; gtp_touch_down(ts, id, input_x, input_y, input_w); } } else if (pre_touch) { GTP_DEBUG("Touch Release!"); gtp_touch_up(ts, 0); } pre_touch = touch_num; input_report_key(ts->input_dev, BTN_TOUCH, (touch_num || key_value)); #endif input_sync(ts->input_dev); exit_work_func: if (!ts->gtp_rawdiff_mode) { ret = gtp_i2c_write(ts->client, end_cmd, 3); if (ret < 0) GTP_ERROR("I2C write end_cmd error!"); } if (ts->use_irq) gtp_irq_enable(ts); } static enum hrtimer_restart goodix_ts_timer_handler(struct hrtimer *timer) { struct goodix_ts_data *ts = container_of(timer, struct goodix_ts_data, timer); GTP_DEBUG_FUNC(); queue_work(goodix_wq, &ts->work); hrtimer_start(&ts->timer, ktime_set(0, (GTP_POLL_TIME + 6) * 1000000), HRTIMER_MODE_REL); return HRTIMER_NORESTART; } static irqreturn_t goodix_ts_irq_handler(int irq, void *dev_id) { struct goodix_ts_data *ts = dev_id; GTP_DEBUG_FUNC(); gtp_irq_disable(ts); queue_work(goodix_wq, &ts->work); return IRQ_HANDLED; } static void gtp_int_sync(struct i2c_client *client, s32 ms) { struct gtp_platform_data *gtp_data = client->dev.platform_data; GTP_GPIO_OUTPUT(gtp_data->irq, 0); GTP_MSLEEP(ms); GTP_GPIO_AS_INT(gtp_data->irq); } void gtp_reset_guitar(struct i2c_client *client, s32 ms) { struct gtp_platform_data *gtp_data = client->dev.platform_data; GTP_DEBUG_FUNC(); /* begin select I2C slave addr */ GTP_GPIO_OUTPUT(gtp_data->reset, 0); GTP_MSLEEP(ms); GTP_GPIO_OUTPUT(gtp_data->irq, client->addr == 0x14); GTP_MSLEEP(2); GTP_GPIO_OUTPUT(gtp_data->reset, 1); /* must > 3ms */ GTP_MSLEEP(6); GTP_GPIO_AS_INPUT(gtp_data->reset); /* end select I2C slave addr */ gtp_int_sync(client, 50); } static s32 gtp_init_panel(struct goodix_ts_data *ts) { s32 ret; #if GTP_DRIVER_SEND_CFG s32 i; u8 check_sum = 0; u8 rd_cfg_buf[16]; u8 cfg_info_group1[] = CTP_CFG_GROUP1; u8 cfg_info_group2[] = CTP_CFG_GROUP2; u8 cfg_info_group3[] = CTP_CFG_GROUP3; u8 *send_cfg_buf[3] = { cfg_info_group1, cfg_info_group2, cfg_info_group3 }; u8 cfg_info_len[3] = { sizeof(cfg_info_group1) / sizeof(cfg_info_group1[0]), sizeof(cfg_info_group2) / sizeof(cfg_info_group2[0]), sizeof(cfg_info_group3) / sizeof(cfg_info_group3[0]) }; for (i = 0; i < 3; i++) { if (cfg_info_len[i] > ts->gtp_cfg_len) ts->gtp_cfg_len = cfg_info_len[i]; } GTP_DEBUG("len1=%d, len2=%d, len3=%d, send_len:%d", cfg_info_len[0], \ cfg_info_len[1], cfg_info_len[2], ts->gtp_cfg_len); if ((!cfg_info_len[1]) && (!cfg_info_len[2])) rd_cfg_buf[GTP_ADDR_LENGTH] = 0; else { rd_cfg_buf[0] = GTP_REG_SENSOR_ID >> 8; rd_cfg_buf[1] = GTP_REG_SENSOR_ID & 0xff; ret = gtp_i2c_read(ts->client, rd_cfg_buf, 3); if (ret < 0) { GTP_ERROR("Read SENSOR ID failed, " \ "default use group1 config!"); rd_cfg_buf[GTP_ADDR_LENGTH] = 0; } rd_cfg_buf[GTP_ADDR_LENGTH] &= 0x07; } GTP_DEBUG("SENSOR ID:%d", rd_cfg_buf[GTP_ADDR_LENGTH]); memset(&config[GTP_ADDR_LENGTH], 0, GTP_CONFIG_MAX_LENGTH); memcpy(&config[GTP_ADDR_LENGTH], send_cfg_buf[rd_cfg_buf[GTP_ADDR_LENGTH]], ts->gtp_cfg_len); #if GTP_CUSTOM_CFG config[RESOLUTION_LOC] = (u8)ts->data->gtp_max_width; config[RESOLUTION_LOC + 1] = (u8)(ts->data->gtp_max_width>>8); config[RESOLUTION_LOC + 2] = (u8)ts->data->gtp_max_height; config[RESOLUTION_LOC + 3] = (u8)(ts->data->gtp_max_height>>8); if (GTP_INT_TRIGGER == 0) /* RISING */ config[TRIGGER_LOC] &= 0xfe; else if (GTP_INT_TRIGGER == 1) /* FALLING */ config[TRIGGER_LOC] |= 0x01; #endif check_sum = 0; for (i = GTP_ADDR_LENGTH; i < ts->gtp_cfg_len; i++) check_sum += config[i]; config[ts->gtp_cfg_len] = (~check_sum) + 1; #else if (ts->gtp_cfg_len == 0) ts->gtp_cfg_len = GTP_CONFIG_MAX_LENGTH; ret = gtp_i2c_read(ts->client, config, ts->gtp_cfg_len + GTP_ADDR_LENGTH); if (ret < 0) { GTP_ERROR("GTP read resolution & max_touch_num failed, " \ "use default value!"); ts->abs_x_max = ts->data->gtp_max_width; ts->abs_y_max = ts->data->gtp_max_height; ts->int_trigger_type = GTP_INT_TRIGGER; return ret; } #endif GTP_DEBUG_FUNC(); ts->abs_x_max = (config[RESOLUTION_LOC + 1] << 8) + config[RESOLUTION_LOC]; ts->abs_y_max = (config[RESOLUTION_LOC + 3] << 8) + config[RESOLUTION_LOC + 2]; ts->int_trigger_type = (config[TRIGGER_LOC]) & 0x03; if ((!ts->abs_x_max) || (!ts->abs_y_max)) { GTP_ERROR("GTP resolution & max_touch_num invalid, " \ "use default value!"); ts->abs_x_max = ts->data->gtp_max_width; ts->abs_y_max = ts->data->gtp_max_height; } /* MUST delay >20ms before send cfg */ GTP_MSLEEP(20); ret = gtp_send_cfg(ts->client); if (ret < 0) { GTP_ERROR("Send config error."); return ret; } GTP_DEBUG("X_MAX = %d,Y_MAX = %d,TRIGGER = 0x%02x", ts->abs_x_max, ts->abs_y_max, ts->int_trigger_type); GTP_MSLEEP(10); return 0; }