int cq_item_1_func(void* data) { int i; ktime_t start_time, stop_time,delta; long long delta_us, delta_ms; struct ts_cmd_node cmd; cmd.command = TS_TEST_CMD; cmd.cmd_param.prv_params = data; TS_LOG_INFO("called paras:%d\n", (int)cmd.cmd_param.prv_params); for(i=0; i<100; i++) { init_completion(&cq_test_sync_1); start_time = ktime_get(); if (NO_ERR == put_one_cmd(&cmd)) { if(wait_for_completion_timeout(&cq_test_sync_1, 5*HZ)){ stop_time = ktime_get(); delta = ktime_sub(stop_time, start_time); delta_us = (long long)ktime_to_us(delta); delta_ms = (long long)ktime_to_ms(delta); TS_LOG_INFO("CMD PROCESS ELAPSED TIME: %lldms%lldus\n", delta_ms, delta_us); } else TS_LOG_ERR("ts thread process TEST CMD expire 5 sec\n"); }else TS_LOG_ERR("put cmd error\n"); } return 0; }
int synaptics_fw_configid(struct synaptics_rmi4_data *rmi4_data, u8 *buf) { int rc = 0; unsigned char config_id[4]; unsigned char f34_ctrl_base_addr = 0; TS_LOG_INFO("called\n"); rc = synaptics_get_f34_addr(rmi4_data, &f34_ctrl_base_addr); if (rc < 0){ TS_LOG_ERR("failed to scan pdt\n"); } rc = rmi4_data->i2c_read(rmi4_data, f34_ctrl_base_addr, config_id, sizeof(config_id)); if (rc < 0) { TS_LOG_ERR("Could not read configid\n"); return rc; } TS_LOG_INFO("config ID 0x%02X, 0x%02X, 0x%02X, 0x%02X,addr = 0x%02x\n", config_id[0], config_id[1], config_id[2], config_id[3], f34_ctrl_base_addr); snprintf(buf, PAGE_SIZE, "%02x %02x %02x %02x\n", config_id[0], config_id[1], config_id[2], config_id[3]); TS_LOG_INFO("buf = %s\n", buf); return 0; }
void cyttsp5_holster_mode_work_function(struct work_struct *work) { struct cyttsp5_core_data *cd = container_of(work, struct cyttsp5_core_data, holster_work); int rc = -1; int flag_mode = -1; struct device *dev = cd->dev; TS_LOG_DEBUG("Enter %s.\n", __func__); atomic_set(&cd->holster_work_status, 1); flag_mode = cd->window_info.holster_switch; rc = cyttsp5_set_holster_mode(dev,flag_mode); if (rc < 0) { TS_LOG_INFO("%s:set tp holster mode %s failed!\n", __func__, (flag_mode == 0 ? "OFF" : "ON")); if(cd->check_holster > 0) { cd->check_holster -= 1; mod_timer(&cd->holster_timer, jiffies + msecs_to_jiffies(CY_COVER_MODE_TIMEOUT)); } } else { cd->check_holster = 0; } atomic_set(&cd->holster_work_status, 0); TS_LOG_INFO("Exit %s.\n", __func__); }
/* Used to read configid */ int synaptics_get_configid(u8 *buf, size_t buf_size) { int rc = 0; TS_LOG_INFO("%s called\n",__func__); snprintf(buf, buf_size, "%02x %02x %02x %02x\n", s3320_config_id[0], s3320_config_id[1], s3320_config_id[2], s3320_config_id[3]); TS_LOG_INFO("buf = %s\n", buf); return 0; }
void cyttsp5_holster_mode_timer(unsigned long handle) { struct cyttsp5_core_data *cd = (struct cyttsp5_core_data *)handle; TS_LOG_DEBUG("Enter %s.\n", __func__); if(atomic_read(&cd->holster_work_status)) { TS_LOG_INFO("%s: work_is_busy = %d.\n", __func__,atomic_read(&cd->holster_work_status)); mod_timer(&cd->holster_timer, jiffies + msecs_to_jiffies(CY_COVER_MODE_TIMEOUT)); } else { TS_LOG_INFO("%s: work_is_busy = %d.\n", __func__, atomic_read(&cd->holster_work_status)); schedule_work(&cd->holster_work); } TS_LOG_INFO("Exit %s.\n", __func__); }
int test_dbg_cmd_test(struct ts_cmd_node *in_cmd,struct ts_cmd_node *out_cmd) { enum ts_test_item_enum test_item = (enum ts_test_item_enum)in_cmd->cmd_param.prv_params; int error = NO_ERR; int rec_v, cal_v; struct ts_fingers test_pos; switch(test_item){ case TEST_CMDQ_ITEM_1: complete(&cq_test_sync_1); break; case TEST_CMDQ_ITEM_2: TS_LOG_INFO("cpu id:%d\n", smp_processor_id()); complete(&cq_test_sync_1); break; case TEST_CMDQ_ITEM_3: if(!cq_test_buff_index){ wait_for_completion(&cq_test_sync_1); //wait for send finish smp_mb(); } cal_v = cq_test_buff[cq_test_buff_index]; rec_v = in_cmd->cmd_param.pub_params.algo_param.algo_order; TS_LOG_INFO("index :%d, rec data:%d, cal data:%d, result: %s\n", cq_test_buff_index, rec_v, cal_v, (rec_v==cal_v)?"pass":"******"); cq_test_buff_index++; if(cq_test_buff[cq_test_buff_index] == -1){//whether reach the end of buffer TS_LOG_INFO("REACH TEST BUFF END, index :%d\n", cq_test_buff_index); cq_test_buff_index = 0; complete(&cq_test_sync_2); } break; case TEST_INPUT_ITEM_1: test_pos.fingers[0].x = 0; test_pos.fingers[0].y = 0; test_pos.fingers[0].area = 0; test_pos.fingers[0].pressure = 0; test_pos.fingers[0].status= 0; memcpy(&out_cmd->cmd_param.pub_params.report_info, &test_pos, sizeof(struct ts_fingers)); out_cmd->command = TS_REPORT_INPUT; break; default: TS_LOG_ERR("unsupport item :%d \n", test_item); break; } TS_LOG_INFO("test item :%d result :%d\n", test_item, error); return error; }
static int ts_test_thread(void *p) { int i = 0; int ret; while(atomic_read(&g_ts_data.state) != TS_WORK && i < WAIT_MAX_COUNT){ TS_LOG_INFO("touchscreen module init not finish\n"); msleep(1000); i++; } TS_LOG_INFO("touchscreen test init\n"); if(test_create_debugfs()){ TS_LOG_ERR("touchscreen test create debugfs failed\n"); goto out; } TS_LOG_INFO("touchscreen test start polling\n"); wake_lock_init(&ts_test_wake_lock, WAKE_LOCK_IDLE, "ts_test"); repeat: msleep(1000); for(i = 0, ret = -99; i<ARRAY_SIZE(g_test_items); i++){ if(!g_test_items[i].item_switch) continue; wake_lock(&ts_test_wake_lock); TS_LOG_INFO("touchscreen test :%s begin\n", g_test_items[i].item_name); if(g_test_items[i].test_func) ret = g_test_items[i].test_func(g_test_items[i].item_data); TS_LOG_INFO("touchscreen test :%s end, ret:%d\n", g_test_items[i].item_name, ret); g_test_items[i].item_switch = 0; wake_unlock(&ts_test_wake_lock); } goto repeat; out: return 0; }
/* Use to record configid */ int synaptics_fw_configid(struct synaptics_rmi4_data *rmi4_data) { int rc = 0; unsigned char f34_ctrl_base_addr = 0; TS_LOG_INFO("synaptics_fw_configid called\n"); rc = synaptics_get_f34_addr(rmi4_data, &f34_ctrl_base_addr); if (rc < 0) { TS_LOG_ERR("failed to scan pdt\n"); } rc = rmi4_data->i2c_read(rmi4_data, f34_ctrl_base_addr, s3320_config_id, sizeof(s3320_config_id)); if (rc < 0) { TS_LOG_ERR("Could not read configid\n"); return rc; } TS_LOG_INFO("config ID 0x%02X, 0x%02X, 0x%02X, 0x%02X,addr = 0x%02x\n", s3320_config_id[0], s3320_config_id[1], s3320_config_id[2], s3320_config_id[3], f34_ctrl_base_addr); return 0; }
int input_item_1_func(void* data) { struct ts_cmd_node cmd; cmd.command = TS_TEST_CMD; cmd.cmd_param.prv_params = data; TS_LOG_INFO("called paras:%d\n", (int)cmd.cmd_param.prv_params); if (NO_ERR != put_one_cmd(&cmd)) { TS_LOG_ERR("put cmd failed\n"); } return 0; }
int cq_item_2_func(void* data) { int i; struct ts_cmd_node cmd; cmd.command = TS_TEST_CMD; cmd.cmd_param.prv_params = data; TS_LOG_INFO("called paras:%d\n", (int)cmd.cmd_param.prv_params); for (i=0; i<100; i++) { init_completion(&cq_test_sync_1); if (NO_ERR == put_one_cmd(&cmd)) { if(wait_for_completion_timeout(&cq_test_sync_1, 5*HZ)){ TS_LOG_INFO("CMD PROCESS %d FINISH - cpu id:%d\n", i, smp_processor_id()); } else TS_LOG_ERR("ts thread process TEST CMD expire 5 sec\n"); }else TS_LOG_ERR("put cmd error\n"); } return 0; }
static int __init ts_test_init(void) { struct task_struct *test_task; TS_LOG_INFO("ts_test_init called here\n"); return 0; test_task = kthread_create_on_node(ts_test_thread, NULL, cpu_to_node(2), "ts_test_thread"); if (IS_ERR(test_task)) TS_LOG_ERR("create ts_thread failed\n"); else wake_up_process(test_task); return 0; }
int cq_item_3_func(void* data) { int i; struct ts_cmd_node cmd; cmd.command = TS_TEST_CMD; cmd.cmd_param.prv_params = data; TS_LOG_INFO("called paras:%d\n", (int)cmd.cmd_param.prv_params); memset(cq_test_buff, -1, sizeof(cq_test_buff)); init_completion(&cq_test_sync_1); init_completion(&cq_test_sync_2); for(i=0; i<TS_CMD_QUEUE_SIZE+5; i++){ cmd.cmd_param.pub_params.algo_param.algo_order = i; cq_test_buff[i] = i; if(put_one_cmd(&cmd)){ TS_LOG_INFO("SEND COMPLETE i:%d\n", i); if(!i) goto out;//unput any cmd, just break; cq_test_buff[i] = -1; smp_mb(); complete(&cq_test_sync_1); if(try_wait_for_completion(&cq_test_sync_2) || wait_for_completion_timeout(&cq_test_sync_2, 10*HZ)) { TS_LOG_INFO("CMD PROCESS FINISH\n"); } else TS_LOG_ERR("ts thread process TEST CMD expire 10 sec\n"); goto out;//finish 1 test break form internal loop } } out: return 0; }
static int synaptics_get_f34_addr(struct synaptics_rmi4_data *rmi4_data, unsigned char*f34_address) { int retval; unsigned short addr; struct synaptics_rmi4_fn_desc rmi_fd; for (addr = PDT_START; addr > PDT_END; addr -= PDT_ENTRY_SIZE) { retval = rmi4_data->i2c_read(rmi4_data, addr, (unsigned char *)&rmi_fd, sizeof(rmi_fd)); if (retval < 0) { TS_LOG_ERR("Failed to read map register\n"); return retval; } if (SYNAPTICS_RMI4_F34 == rmi_fd.fn_number) { TS_LOG_INFO("Found F%02x\n", rmi_fd.fn_number); *f34_address = rmi_fd.ctrl_base_addr; return NO_ERR; } } TS_LOG_ERR("Failed to get f34 addr\n"); return -EINVAL; }
static int fwu_read_f34_queries(void) { int retval; unsigned char count; unsigned char buf[10]; retval = fwu->fn_ptr->read(fwu->rmi4_data, fwu->f34_fd.query_base_addr + BOOTLOADER_ID_OFFSET, fwu->bootloader_id, sizeof(fwu->bootloader_id)); if (retval < 0) { TS_LOG_ERR("Failed to read bootloader ID\n"); return retval; } TS_LOG_INFO("bootloader_id[1] = %c", fwu->bootloader_id[1]); if (fwu->bootloader_id[1] == '5') { fwu->bl_version = V5; } else if (fwu->bootloader_id[1] == '6') { fwu->bl_version = V6; } else { TS_LOG_ERR("Unrecognized bootloader version\n"); return -EINVAL; } if (fwu->bl_version == V5) { fwu->properties_off = V5_PROPERTIES_OFFSET; fwu->blk_size_off = V5_BLOCK_SIZE_OFFSET; fwu->blk_count_off = V5_BLOCK_COUNT_OFFSET; fwu->blk_data_off = V5_BLOCK_DATA_OFFSET; } else if (fwu->bl_version == V6) { fwu->properties_off = V6_PROPERTIES_OFFSET; fwu->blk_size_off = V6_BLOCK_SIZE_OFFSET; fwu->blk_count_off = V6_BLOCK_COUNT_OFFSET; fwu->blk_data_off = V6_BLOCK_DATA_OFFSET; } retval = fwu->fn_ptr->read(fwu->rmi4_data, fwu->f34_fd.query_base_addr + fwu->properties_off, &fwu->flash_properties, sizeof(fwu->flash_properties)); if (retval < 0) { TS_LOG_ERR("Failed to read flash properties\n"); return retval; } count = 4; if (fwu->flash_properties & HAS_PERM_CONFIG) { fwu->has_perm_config = 1; count += 2; } if (fwu->flash_properties & HAS_BL_CONFIG) { fwu->has_bl_config = 1; count += 2; } if (fwu->flash_properties & HAS_DISP_CONFIG) { fwu->has_disp_config = 1; count += 2; } retval = fwu->fn_ptr->read(fwu->rmi4_data, fwu->f34_fd.query_base_addr + fwu->blk_size_off, buf, 2); if (retval < 0) { TS_LOG_ERR("Failed to read block size info\n"); return retval; } batohs(&fwu->block_size, &(buf[0])); if (fwu->bl_version == V5) { fwu->flash_cmd_off = fwu->blk_data_off + fwu->block_size; fwu->flash_status_off = fwu->flash_cmd_off; } else if (fwu->bl_version == V6) { fwu->flash_cmd_off = V6_FLASH_COMMAND_OFFSET; fwu->flash_status_off = V6_FLASH_STATUS_OFFSET; } retval = fwu->fn_ptr->read(fwu->rmi4_data, fwu->f34_fd.query_base_addr + fwu->blk_count_off, buf, count); if (retval < 0) { TS_LOG_ERR("Failed to read block count info\n"); return retval; } batohs(&fwu->fw_block_count, &(buf[0])); batohs(&fwu->config_block_count, &(buf[2])); count = 4; if (fwu->has_perm_config) { batohs(&fwu->perm_config_block_count, &(buf[count])); count += 2; } if (fwu->has_bl_config) { batohs(&fwu->bl_config_block_count, &(buf[count])); count += 2; } if (fwu->has_disp_config) batohs(&fwu->disp_config_block_count, &(buf[count])); return 0; }
int cyttsp5_set_holster_mode(struct device *dev,int holster_switch) { u8 response_buf[CY_MAX_BUF_SIZE] = {0}; char response_str[COVER_RESPONSE_MAX_LEN] = {0}; int i =0; int num_read = 0; int index = 0; int rc = -1; int flag = 0; int length = 0; TS_LOG_DEBUG("Enter %s,holster_switch = %d.\n", __func__,holster_switch); memset(response_buf, 0, sizeof(response_buf)); flag = cyttsp5_get_holster_mode(dev); if(flag < 0) { TS_LOG_ERR("%s,get Touch holster mode failed.\n",__func__); return -1; } if (holster_switch == flag) { TS_LOG_INFO("%s,Touch is already in %s mode.\n",__func__,(flag == 1) ? "holster ON" : "holster OFF"); return 0; } TS_LOG_DEBUG("%s,Begin to switch holster mode.\n", __func__); if (holster_switch) { rc = cyttsp5_send_command(dev,holster_command[SET_HOLSTER_ON]); if (rc || !cyttsp5_command_status(dev)) { TS_LOG_ERR("%s: Send read TP holster mode command failed!\n", __func__); goto exit; } } else { rc = cyttsp5_send_command(dev,holster_command[SET_HOLSTER_OFF]); if (rc || !cyttsp5_command_status(dev)) { TS_LOG_ERR("%s: Send read TP holster mode command failed!\n", __func__); goto exit; } } msleep(50); num_read = cyttsp5_command_response(dev,response_buf); if (!cyttsp5_command_status(dev) || num_read < 0) { TS_LOG_ERR("%s: Get command response failed\n", __func__); goto exit; } for (i = 0; i < num_read; i++) { index += scnprintf(response_str + index, COVER_RESPONSE_MAX_LEN, "%02X ", response_buf[i]); } TS_LOG_DEBUG("%s,response_str=%s.\n",__func__,response_str); length = strlen(holster_response_state[SET_HOLSTER_SUCCESSFUL_ONE]); for(i = SET_HOLSTER_SUCCESSFUL_ONE; i <= SET_HOLSTER_SUCCESSFUL_TWO; i++) { if (strncmp(holster_response_state[i], response_str, length) == 0) { TS_LOG_INFO("%s,Set TP holster mode successful!\n",__func__); return 0; } } rc = -1; exit: TS_LOG_ERR("%s,Set TP holster mode failed.\n",__func__); return rc; }