static u8 comfirm(void)
{
s32 i = 0;
u8 buf[32];
// memcpy(&buf[ADDR_MAX_LENGTH - cmd_head.addr_len], &cmd_head.flag_addr, cmd_head.addr_len);
memcpy(buf, &cmd_head.flag_addr, cmd_head.addr_len);
for (i = 0; i < cmd_head.times; i++)
{
if (tool_i2c_read(buf, 1) <= 0)
{
WARNING("Read flag data failed!\n");
return fail;
}
if (true == relation(buf[ADDR_MAX_LENGTH], cmd_head.flag_val, cmd_head.flag_relation))
{
DEBUG("value at flag addr:0x%02x\n", buf[ADDR_MAX_LENGTH]);
DEBUG("flag value:0x%02x\n", cmd_head.flag_val);
break;
}
msleep(cmd_head.circle);
}
if (i >= cmd_head.times)
{
WARNING("Didn't get the flag to continue!\n");
return fail;
}
return success;
}
/*******************************************************
Function:
Comfirm function.
Input:
None.
Output:
Return write length.
********************************************************/
static u8 comfirm(void)
{
s32 i = 0;
u8 buf[32];
// memcpy(&buf[GTP_ADDR_LENGTH - cmd_head.addr_len], &cmd_head.flag_addr, cmd_head.addr_len);
// memcpy(buf, &cmd_head.flag_addr, cmd_head.addr_len);//Modified by Scott, 2012-02-17
memcpy(buf, cmd_head.flag_addr, cmd_head.addr_len);
for (i = 0; i < cmd_head.times; i++)
{
if (tool_i2c_read(buf, 1) <= 0)
{
GTP_ERROR("Read flag data failed!");
return FAIL;
}
if (true == relation(buf[GTP_ADDR_LENGTH], cmd_head.flag_val, cmd_head.flag_relation))
{
GTP_DEBUG("value at flag addr:0x%02x.", buf[GTP_ADDR_LENGTH]);
GTP_DEBUG("flag value:0x%02x.", cmd_head.flag_val);
break;
}
msleep(cmd_head.circle);
}
if (i >= cmd_head.times)
{
GTP_ERROR("Didn't get the flag to continue!");
return FAIL;
}
return SUCCESS;
}
/*******************************************************
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 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;
}
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)
static s32 goodix_tool_read( char *page, char **start, off_t off, int count, int *eof, void *data )
{
if (2 == cmd_head.wr)
{
//memcpy(page, IC_TYPE, cmd_head.data_len);
memcpy(page, IC_TYPE, sizeof(IC_TYPE_NAME));
page[sizeof(IC_TYPE_NAME)] = 0;
DEBUG("Return ic type:%s len:%d\n", page, (s32)cmd_head.data_len);
return cmd_head.data_len;
//return sizeof(IC_TYPE_NAME);
}
else 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())
{
WARNING("[READ]Comfirm fail!\n");
return fail;
}
}
else if (2 == cmd_head.flag)
{
//Need interrupt!
}
memcpy(cmd_head.data, cmd_head.addr, cmd_head.addr_len);
DEBUG("[CMD HEAD DATA] ADDR:0x%02x%02x\n", cmd_head.data[0], cmd_head.data[1]);
DEBUG("[CMD HEAD ADDR] ADDR:0x%02x%02x\n", 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)
{
WARNING("[READ]Read data failed!\n");
return fail;
}
memcpy(&page[loc], &cmd_head.data[ADDR_MAX_LENGTH], len);
loc += len;
//DEBUG_ARRAY(&cmd_head.data[ADDR_MAX_LENGTH], len);
DEBUG_ARRAY(page, len);
}
}
return cmd_head.data_len;
}
