/******************************************************* Function: Read data from the i2c slave device. Input: client: i2c device. buf[0]:operate address. buf[1]~buf[len]:read data buffer. len:operate length. Output: numbers of i2c_msgs to transfer *********************************************************/ s32 gtp_i2c_read(struct i2c_client *client, u8 *buf, s32 len) { struct i2c_msg msgs[2]; s32 ret=-1; s32 retries = 0; GTP_DEBUG_FUNC(); msgs[0].flags = !I2C_M_RD; msgs[0].addr = client->addr; msgs[0].len = GTP_ADDR_LENGTH; msgs[0].buf = &buf[0]; msgs[0].scl_rate=GT811_I2C_SPEED; //msgs[0].udelay=2000; msgs[1].flags = I2C_M_RD; msgs[1].addr = client->addr; msgs[1].len = len - GTP_ADDR_LENGTH; msgs[1].buf = &buf[GTP_ADDR_LENGTH]; msgs[1].scl_rate=GT811_I2C_SPEED; //msgs[1].udelay=2000; while(retries < 5) { ret = i2c_transfer(client->adapter, msgs, 2); if (ret == 2)break; retries++; } return ret; }
/******************************************************* Function: write data to the i2c slave device. Input: client: i2c device. buf[0]:operate address. buf[1]~buf[len]:write data buffer. len:operate length. Output: numbers of i2c_msgs to transfer. *********************************************************/ s32 gtp_i2c_write(struct i2c_client *client,u8 *buf,s32 len) { struct i2c_msg msg; s32 ret=-1; s32 retries = 0; GTP_DEBUG_FUNC(); msg.flags = !I2C_M_RD; msg.addr = client->addr; msg.len = len; msg.buf = buf; while(retries < 5) { ret = i2c_transfer(client->adapter, &msg, 1); if (ret == 1)break; retries++; } if(retries >= 5) { GTP_DEBUG("I2C retry timeout, reset chip."); gtp_reset_guitar(client, 10); } return ret; }
/******************************************************* Function: Read data from the i2c slave device. Input: client: i2c device. buf[0]:operate address. buf[1]~buf[len]:read data buffer. len:operate length. Output: numbers of i2c_msgs to transfer *********************************************************/ s32 gtp_i2c_read(struct i2c_client *client, u8 *buf, s32 len) { struct i2c_msg msgs[2]; s32 ret=-1; s32 retries = 0; GTP_DEBUG_FUNC(); msgs[0].flags = !I2C_M_RD; msgs[0].addr = client->addr; msgs[0].len = GTP_ADDR_LENGTH; msgs[0].buf = &buf[0]; msgs[1].flags = I2C_M_RD; msgs[1].addr = client->addr; msgs[1].len = len - GTP_ADDR_LENGTH; msgs[1].buf = &buf[GTP_ADDR_LENGTH]; while(retries < 5) { ret = i2c_transfer(client->adapter, msgs, 2); if(ret == 2)break; retries++; } if(retries >= 5) { GTP_DEBUG("I2C retry timeout, reset chip."); gtp_reset_guitar(client, 10); } return ret; }
/******************************************************* Function: Write data to the i2c slave device. Input: client: i2c device. buf[0~1]: write start address. buf[2~len-1]: data buffer len: GTP_ADDR_LENGTH + write bytes count Output: numbers of i2c_msgs to transfer: 1: succeed, otherwise: failed *********************************************************/ s32 gtp_i2c_write(struct i2c_client *client,u8 *buf,s32 len) { struct i2c_msg msg; s32 ret = -1; s32 retries = 0; GTP_DEBUG_FUNC(); msg.flags = !I2C_M_RD; msg.addr = client->addr; msg.len = len; msg.buf = buf; msg.scl_rate = 300 * 1000; // for Rockchip while(retries < 5) { ret = i2c_transfer(client->adapter, &msg, 1); if (ret == 1)break; retries++; } if((retries >= 5)) { #if GTP_SLIDE_WAKEUP if (DOZE_ENABLED == doze_status) { return ret; } #endif GTP_DEBUG("I2C communication timeout, resetting chip..."); gtp_reset_guitar(client, 10); } return ret; }
/******************************************************* Function: write i2c end cmd. Input: client: i2c device. Output: numbers of i2c_msgs to transfer. *********************************************************/ s32 gtp_i2c_end_cmd(struct i2c_client *client) { s32 ret = -1; u8 end_cmd_data[2]={0x80, 0x00}; GTP_DEBUG_FUNC(); ret = gtp_i2c_write(client, end_cmd_data, 2); return ret; }
void gtp_irq_enable(struct goodix_ts_data *ts) { unsigned long irqflags; GTP_DEBUG_FUNC(); spin_lock_irqsave(&ts->irq_lock, irqflags); if (ts->irq_is_disable) { enable_irq(ts->client->irq); ts->irq_is_disable = 0; } spin_unlock_irqrestore(&ts->irq_lock, irqflags); }
/******************************************************* Function: Enable IRQ Function. Input: ts: i2c client private struct. Output: None. *******************************************************/ void gtp_irq_disable(struct goodix_platform_data *ts) { unsigned long irqflags; GTP_DEBUG_FUNC(); spin_lock_irqsave(&ts->irq_lock, irqflags); if (!ts->irq_is_disable) { ts->irq_is_disable = 1; disable_irq_nosync(ts->client->irq); } spin_unlock_irqrestore(&ts->irq_lock, irqflags); }
static ssize_t gt1x_gesture_data_write(struct file *filp, const char __user * buff, size_t len, loff_t * off) { s32 ret = 0; GTP_DEBUG_FUNC(); ret = copy_from_user(&gesture_enabled, buff, 1); if (ret) { GTP_ERROR("copy_from_user failed."); return -EPERM; } GTP_DEBUG("gesture enabled:%x, ret:%d", gesture_enabled, ret); return len; }
int gesture_enter_doze(void) { int retry = 0; GTP_DEBUG_FUNC(); GTP_DEBUG("entering doze mode..."); while (retry++ < 5) { if (!gt1x_send_cmd(0x08, 0)) { gesture_doze_status = DOZE_ENABLED; GTP_DEBUG("GTP has been working in doze mode!"); return 0; } msleep(10); } GTP_ERROR("GTP send doze cmd failed."); return -1; }
/******************************************************* Function: write data to the i2c slave device. Input: client: i2c device. buf[0]:operate address. buf[1]~buf[len]:write data buffer. len:operate length. Output: numbers of i2c_msgs to transfer. *********************************************************/ s32 gtp_i2c_write(struct i2c_client *client,u8 *buf,s32 len) { struct i2c_msg msg; s32 ret=-1; s32 retries = 0; GTP_DEBUG_FUNC(); msg.flags = !I2C_M_RD; msg.addr = client->addr; msg.len = len; msg.buf = buf; while(retries < 5) { ret = i2c_transfer(client->adapter, &msg, 1); if (ret == 1)break; retries++; } return ret; }
/******************************************************* Function: Read data from the i2c slave device. Input: client: i2c device. buf[0~1]: read start address. buf[2~len-1]: read data buffer. len: GTP_ADDR_LENGTH + read bytes count Output: numbers of i2c_msgs to transfer: 2: succeed, otherwise: failed *********************************************************/ s32 gtp_i2c_read(struct i2c_client *client, u8 *buf, s32 len) { struct i2c_msg msgs[2]; s32 ret=-1; s32 retries = 0; GTP_DEBUG_FUNC(); msgs[0].flags = !I2C_M_RD; msgs[0].addr = client->addr; msgs[0].len = GTP_ADDR_LENGTH; msgs[0].buf = &buf[0]; msgs[0].scl_rate = 300 * 1000; // for Rockchip msgs[1].flags = I2C_M_RD; msgs[1].addr = client->addr; msgs[1].len = len - GTP_ADDR_LENGTH; msgs[1].buf = &buf[GTP_ADDR_LENGTH]; msgs[1].scl_rate = 300 * 1000; while(retries < 5) { ret = i2c_transfer(client->adapter, msgs, 2); if(ret == 2)break; retries++; } if((retries >= 5)) { #if GTP_SLIDE_WAKEUP // reset chip would quit doze mode if (DOZE_ENABLED == doze_status) { return ret; } #endif GTP_DEBUG("I2C communication timeout, resetting chip..."); gtp_reset_guitar(client, 10); } return ret; }
/******************************************************* Function: Goodix tool read function. Input: standard proc read function param. Output: Return read length. ********************************************************/ static s32 goodix_tool_read(char *page, char **start, off_t off, int count, int *eof, void *data) { GTP_DEBUG_FUNC(); if (cmd_head.wr % 2) { return FAIL; } else if (!cmd_head.wr) { u16 len = 0; s16 data_len = 0; u16 loc = 0; if (1 == cmd_head.flag) { if (FAIL == comfirm()) { GTP_ERROR("[READ]Comfirm fail!"); return FAIL; } } else if (2 == cmd_head.flag) { //Need interrupt! } memcpy(cmd_head.data, cmd_head.addr, cmd_head.addr_len); GTP_DEBUG("[CMD HEAD DATA] ADDR:0x%02x%02x.", cmd_head.data[0], cmd_head.data[1]); GTP_DEBUG("[CMD HEAD ADDR] ADDR:0x%02x%02x.", cmd_head.addr[0], cmd_head.addr[1]); if (cmd_head.delay) { msleep(cmd_head.delay); } data_len = cmd_head.data_len; while (data_len > 0) { if (data_len > DATA_LENGTH) { len = DATA_LENGTH; } else { len = data_len; } data_len -= DATA_LENGTH; if (tool_i2c_read(cmd_head.data, len) <= 0) { GTP_ERROR("[READ]Read data failed!"); return FAIL; } memcpy(&page[loc], &cmd_head.data[GTP_ADDR_LENGTH], len); loc += len; GTP_DEBUG_ARRAY(&cmd_head.data[GTP_ADDR_LENGTH], len); GTP_DEBUG_ARRAY(page, len); } } else if (2 == cmd_head.wr) { // memcpy(page, "gt8", cmd_head.data_len); // memcpy(page, "GT818", 5); // page[5] = 0; GTP_DEBUG("Return ic type:%s len:%d.", page, (s32)cmd_head.data_len); return cmd_head.data_len; //return sizeof(IC_TYPE_NAME); } else if (4 == cmd_head.wr) { page[0] = show_len >> 8; page[1] = show_len & 0xff; page[2] = total_len >> 8; page[3] = total_len & 0xff; return cmd_head.data_len; }
/******************************************************* 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) { u64 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 { 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_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."); gtp_rawdiff_mode = true; } else { 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; }
/******************************************************* Function: Goodix tool read function. Input: standard proc read function param. Output: Return read length. ********************************************************/ static ssize_t goodix_tool_read(struct file *flie, char __user *page, size_t size, loff_t *ppos) { s32 ret; GTP_DEBUG_FUNC(); if(gtp_resetting == 1) return FAIL; if (*ppos) { *ppos = 0; return 0; } if (cmd_head.wr % 2) { GTP_ERROR("[READ] invaild operator fail!"); return FAIL; } else if (!cmd_head.wr) { u16 len = 0; s16 data_len = 0; u16 loc = 0; if (1 == cmd_head.flag) { if (FAIL == comfirm()) { GTP_ERROR("[READ]Comfirm fail!"); return FAIL; } } else if (2 == cmd_head.flag) { //Need interrupt! } memcpy(cmd_head.data, cmd_head.addr, cmd_head.addr_len); GTP_DEBUG("[CMD HEAD DATA] ADDR:0x%02x%02x.", cmd_head.data[0], cmd_head.data[1]); GTP_DEBUG("[CMD HEAD ADDR] ADDR:0x%02x%02x.", cmd_head.addr[0], cmd_head.addr[1]); if (cmd_head.delay) { msleep(cmd_head.delay); } data_len = cmd_head.data_len; while (data_len > 0) { if (data_len > DATA_LENGTH) { len = DATA_LENGTH; } else { len = data_len; } data_len -= len; if (tool_i2c_read(cmd_head.data, len) <= 0) { GTP_ERROR("[READ]Read data failed!"); return FAIL; } //memcpy(&page[loc], &cmd_head.data[GTP_ADDR_LENGTH], len); ret = simple_read_from_buffer(&page[loc], size, ppos, &cmd_head.data[GTP_ADDR_LENGTH], len); if (ret < 0) { return ret; } loc += len; GTP_DEBUG_ARRAY(&cmd_head.data[GTP_ADDR_LENGTH], len); GTP_DEBUG_ARRAY(page, len); } return cmd_head.data_len; } else if (2 == cmd_head.wr) { ret = simple_read_from_buffer(page, size, ppos, IC_TYPE, sizeof(IC_TYPE)); return ret; } else if (4 == cmd_head.wr) { u8 progress_buf[4]; progress_buf[0] = show_len >> 8; progress_buf[1] = show_len & 0xff; progress_buf[2] = total_len >> 8; progress_buf[3] = total_len & 0xff; ret = simple_read_from_buffer(page, size, ppos, progress_buf, 4); return ret; }
/******************************************************* Function: Goodix tool write function. Input: standard proc write function param. Output: Return write length. ********************************************************/ static 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); if(gtp_resetting == 1) { //GTP_ERROR("[Write]tpd_halt =1 fail!"); return FAIL; } 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); 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 { 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! { mt_eint_mask(CUST_EINT_TOUCH_PANEL_NUM); #if GTP_ESD_PROTECT gtp_esd_switch(i2c_client_point, SWITCH_OFF); #endif return CMD_HEAD_LENGTH; } else if (9 == cmd_head.wr) //enable irq! { mt_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM); #if GTP_ESD_PROTECT gtp_esd_switch(i2c_client_point, SWITCH_ON); #endif return CMD_HEAD_LENGTH; } else if (17 == cmd_head.wr) { 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."); gtp_rawdiff_mode = true; } else { 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); GTP_DEBUG("update firmware, filename: %s", cmd_head.data); if (FAIL == gup_update_proc((void *)cmd_head.data)) { return FAIL; } } #endif else if (19 == cmd_head.wr) //load subsystem { ret = copy_from_user(&cmd_head.data[0], &buff[CMD_HEAD_LENGTH], cmd_head.data_len); if(0 == cmd_head.data[0]) { if (FAIL == gup_load_calibration1()) { return FAIL; } } else if(1 == cmd_head.data[0]) { if (FAIL == gup_load_calibration2()) { return FAIL; } } else if(2 == cmd_head.data[0]) { if (FAIL == gup_recovery_calibration0()) { return FAIL; } } else if(3 == cmd_head.data[0]) { if (FAIL == gup_load_calibration0(NULL)) { return FAIL; } } } #if HOTKNOT_BLOCK_RW else if (21 == cmd_head.wr) { u16 wait_hotknot_timeout = 0; u8 rqst_hotknot_state; 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."); } rqst_hotknot_state = cmd_head.data[GTP_ADDR_LENGTH]; wait_hotknot_state |= rqst_hotknot_state; wait_hotknot_timeout = (cmd_head.data[GTP_ADDR_LENGTH + 1]<<8) + cmd_head.data[GTP_ADDR_LENGTH + 2]; GTP_DEBUG("Goodix tool received wait polling state:0x%x,timeout:%d, all wait state:0x%x", rqst_hotknot_state, wait_hotknot_timeout, wait_hotknot_state); got_hotknot_state &= (~rqst_hotknot_state); //got_hotknot_extra_state = 0; switch(rqst_hotknot_state) { set_current_state(TASK_INTERRUPTIBLE); case HN_DEVICE_PAIRED: hotknot_paired_flag = 0; wait_event_interruptible(bp_waiter, force_wake_flag || rqst_hotknot_state == (got_hotknot_state&rqst_hotknot_state)); wait_hotknot_state &= (~rqst_hotknot_state); if(rqst_hotknot_state != (got_hotknot_state&rqst_hotknot_state)) { GTP_ERROR("Wait 0x%x block polling waiter failed.", rqst_hotknot_state); force_wake_flag = 0; return FAIL; } break; case HN_MASTER_SEND: case HN_SLAVE_RECEIVED: wait_event_interruptible_timeout(bp_waiter, force_wake_flag || rqst_hotknot_state == (got_hotknot_state&rqst_hotknot_state), wait_hotknot_timeout); wait_hotknot_state &= (~rqst_hotknot_state); if(rqst_hotknot_state == (got_hotknot_state&rqst_hotknot_state)) { return got_hotknot_extra_state; } else { GTP_ERROR("Wait 0x%x block polling waiter timeout.", rqst_hotknot_state); force_wake_flag = 0; return FAIL; } break; case HN_MASTER_DEPARTED: case HN_SLAVE_DEPARTED: wait_event_interruptible_timeout(bp_waiter, force_wake_flag || rqst_hotknot_state == (got_hotknot_state&rqst_hotknot_state), wait_hotknot_timeout); wait_hotknot_state &= (~rqst_hotknot_state); if(rqst_hotknot_state != (got_hotknot_state&rqst_hotknot_state)) { GTP_ERROR("Wait 0x%x block polling waitor timeout.", rqst_hotknot_state); force_wake_flag = 0; return FAIL; } break; default: GTP_ERROR("Invalid rqst_hotknot_state in goodix_tool."); break; } force_wake_flag = 0; } else if(23 == cmd_head.wr) { GTP_DEBUG("Manual wakeup all block polling waiter!"); got_hotknot_state = 0; wait_hotknot_state = 0; force_wake_flag = 1; hotknot_paired_flag = 0; wake_up_interruptible(&bp_waiter); } #endif return CMD_HEAD_LENGTH; }
/******************************************************* 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) { u64 ret = 0; GTP_DEBUG_FUNC(); GTP_DEBUG_ARRAY((u8 *) buff, len); if(len < CMD_HEAD_LENGTH){ GTP_ERROR("copy_from_user out of range, failed."); return -1; } 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) { if((cmd_head.data == NULL) || (cmd_head.data_len > (DATA_LENGTH - GTP_ADDR_LENGTH)) || (cmd_head.data_len > (len - CMD_HEAD_LENGTH)) ) { GTP_ERROR("copy_from_user data out of range."); return -1; } 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."); } if((cmd_head.addr_len > sizeof(cmd_head.addr))) { GTP_ERROR("copy_from_user data out of range."); return -1; } 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 */ { if((cmd_head.data == NULL) || (cmd_head.data_len > sizeof(IC_TYPE[16])) || (cmd_head.data_len > (len - CMD_HEAD_LENGTH)) ) { GTP_ERROR("copy_from_user data out of range."); return -1; } 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! */ { mt_eint_mask(CUST_EINT_TOUCH_PANEL_NUM); #if GTP_ESD_PROTECT gtp_esd_switch(i2c_client_point, SWITCH_OFF); #endif return CMD_HEAD_LENGTH; } else if (9 == cmd_head.wr) /* enable irq! */ { mt_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM); #if GTP_ESD_PROTECT gtp_esd_switch(i2c_client_point, SWITCH_ON); #endif return CMD_HEAD_LENGTH; } else if (17 == cmd_head.wr) { if((cmd_head.data == NULL) || (cmd_head.data_len > (DATA_LENGTH - GTP_ADDR_LENGTH)) || (cmd_head.data_len > (len - CMD_HEAD_LENGTH)) ) { GTP_ERROR("copy_from_user data out of range."); return -1; } 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."); gtp_rawdiff_mode = true; } else { 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); if((cmd_head.data == NULL) || (cmd_head.data_len > DATA_LENGTH) || (cmd_head.data_len > (len - CMD_HEAD_LENGTH)) ) { GTP_ERROR("copy_from_user data out of range."); return -1; } copy_from_user(cmd_head.data, &buff[CMD_HEAD_LENGTH], cmd_head.data_len); GTP_DEBUG("update firmware, filename: %s", cmd_head.data); 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 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; }
static s32 goodix_tool_read(char *page, char **start, off_t off, int count, int *eof, void *data) { GTP_DEBUG_FUNC(); if (cmd_head.wr % 2) return FAIL; else if (!cmd_head.wr) { u16 len = 0; s16 data_len = 0; u16 loc = 0; if (1 == cmd_head.flag) { if (FAIL == goodix_confirm()) { GTP_ERROR("[READ]goodix_confirm fail!"); return FAIL; } } else if (2 == cmd_head.flag) GTP_DEBUG("[READ]need interrupt."); memcpy(cmd_head.data, cmd_head.addr, cmd_head.addr_len); GTP_DEBUG("[CMD HEAD DATA] ADDR:0x%02x%02x.", \ cmd_head.data[0], cmd_head.data[1]); GTP_DEBUG("[CMD HEAD ADDR] ADDR:0x%02x%02x.", \ cmd_head.addr[0], cmd_head.addr[1]); if (cmd_head.delay) msleep(cmd_head.delay); data_len = cmd_head.data_len; while (data_len > 0) { if (data_len > DATA_LENGTH) len = DATA_LENGTH; else len = data_len; data_len -= DATA_LENGTH; if (tool_i2c_read(cmd_head.data, len) <= 0) { GTP_ERROR("[READ]Read data failed!"); return FAIL; } memcpy(&page[loc], &cmd_head.data[GTP_ADDR_LENGTH], len); loc += len; GTP_DEBUG_ARRAY(&cmd_head.data[GTP_ADDR_LENGTH], len); GTP_DEBUG_ARRAY(page, len); } } else if (2 == cmd_head.wr) { GTP_DEBUG("Return ic type:%s len:%d.", \ page, (s32)cmd_head.data_len); return cmd_head.data_len; } else if (4 == cmd_head.wr) { page[0] = show_len >> 8; page[1] = show_len & 0xff; page[2] = total_len >> 8; page[3] = total_len & 0xff; return cmd_head.data_len; } else if (6 == cmd_head.wr)
/******************************************************* Function: Goodix tool write function. Input: standard proc write function param. Output: Return write length. ********************************************************/ static s32 gt1x_tool_write(struct file *filp, const char __user * buff, size_t len, loff_t * data) { u64 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) { u16 addr, data_len, pos; if (1 == cmd_head.flag) { if (comfirm()) { GTP_ERROR("[WRITE]Comfirm fail!"); return -1; } } else if (2 == cmd_head.flag) { //Need interrupt! } addr = (cmd_head.addr[0] << 8) + cmd_head.addr[1]; data_len = cmd_head.data_len; pos = 0; while (data_len > 0) { len = data_len > DATA_LENGTH ? DATA_LENGTH : data_len; ret = copy_from_user(&cmd_head.data[GTP_ADDR_LENGTH], &buff[CMD_HEAD_LENGTH + pos], len); if (ret) { GTP_ERROR("[WRITE]copy_from_user failed."); return -1; } cmd_head.data[0] = ((addr >> 8) & 0xFF); cmd_head.data[1] = (addr & 0xFF); GTP_DEBUG_ARRAY(cmd_head.data, len + GTP_ADDR_LENGTH); if (tool_i2c_write(cmd_head.data, len + GTP_ADDR_LENGTH) <= 0) { GTP_ERROR("[WRITE]Write data failed!"); return -1; } addr += len; pos += len; data_len -= len; } if (cmd_head.delay) { msleep(cmd_head.delay); } return cmd_head.data_len + CMD_HEAD_LENGTH; } else if (3 == cmd_head.wr) { //gt1x unused
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; }