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; }
s32 init_wr_node(struct i2c_client *client) { s32 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 + ADDR_MAX_LENGTH; NOTICE("Applied memory size:%d.\n", DATA_LENGTH); } else { WARNING("Apply for memory failed.\n"); return fail; } cmd_head.addr_len = 2; cmd_head.retry = 5; register_i2c_func(); goodix_proc_entry = create_proc_entry(GOODIX_ENTRY_NAME, 0666, NULL); if (goodix_proc_entry == NULL) { WARNING("Couldn't create proc entry!\n"); return fail; } else { NOTICE("Create proc entry success!\n"); goodix_proc_entry->write_proc = goodix_tool_write; goodix_proc_entry->read_proc = goodix_tool_read; //goodix_proc_entry->owner =THIS_MODULE; } return success; }
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; }
/******************************************************* 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 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; }
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; }
/******************************************************* 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 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; }
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; }
//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 s32 goodix_tool_write(struct file *filp, const char __user *buff, unsigned long len, void *data) { DEBUG_ARRAY((u8*)buff, len); copy_from_user(&cmd_head, buff, CMD_HEAD_LENGTH); DEBUG("wr :0x%02x\n", cmd_head.wr); DEBUG("flag:0x%02x\n", cmd_head.flag); DEBUG("flag addr:0x%02x%02x\n", cmd_head.flag_addr[0], cmd_head.flag_addr[1]); DEBUG("flag val:0x%02x\n", cmd_head.flag_val); DEBUG("flag rel:0x%02x\n", cmd_head.flag_relation); DEBUG("circle :%d\n", (s32)cmd_head.circle); DEBUG("times :%d\n", (s32)cmd_head.times); DEBUG("retry :%d\n", (s32)cmd_head.retry); DEBUG("delay :%d\n", (s32)cmd_head.delay); DEBUG("data len:%d\n", (s32)cmd_head.data_len); DEBUG("addr len:%d\n", (s32)cmd_head.addr_len); DEBUG("addr:0x%02x%02x\n", cmd_head.addr[0], cmd_head.addr[1]); DEBUG("len:%d\n", (s32)len); DEBUG("buf[20]:0x%02x\n", 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); copy_from_user(&cmd_head.data[ADDR_MAX_LENGTH], &buff[CMD_HEAD_LENGTH], cmd_head.data_len); memcpy(&cmd_head.data[ADDR_MAX_LENGTH - cmd_head.addr_len], cmd_head.addr, cmd_head.addr_len); DEBUG_ARRAY(cmd_head.data, cmd_head.data_len + cmd_head.addr_len); DEBUG_ARRAY((u8*)&buff[CMD_HEAD_LENGTH], cmd_head.data_len); if (1 == cmd_head.flag) { if (fail == comfirm()) { WARNING("[WRITE]Comfirm fail!\n"); return fail; } } else if (2 == cmd_head.flag) { //Need interrupt! } if (tool_i2c_write(&cmd_head.data[ADDR_MAX_LENGTH - cmd_head.addr_len], cmd_head.data_len + cmd_head.addr_len) <= 0) { WARNING("[WRITE]Write data failed!\n"); return fail; } DEBUG_ARRAY(&cmd_head.data[ADDR_MAX_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) { 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; } return CMD_HEAD_LENGTH; }