/*******************************************************
Function:
i2c read twice, compare the results
Input:
client: i2c device
addr: operate address
rxbuf: read data to store, if compare successful
len: bytes to read
Output:
FAIL: read failed
SUCCESS: read successful
*********************************************************/
s32 gtp_i2c_read_dbl_check(struct i2c_client *client, u16 addr, u8 *rxbuf, int len)
{
u8 buf[16] = {0};
u8 confirm_buf[16] = {0};
u8 retry = 0;
while (retry++ < 3)
{
memset(buf, 0xAA, 16);
buf[0] = (u8)(addr >> 8);
buf[1] = (u8)(addr & 0xFF);
gtp_i2c_read(client, buf, len + 2);
memset(confirm_buf, 0xAB, 16);
confirm_buf[0] = (u8)(addr >> 8);
confirm_buf[1] = (u8)(addr & 0xFF);
gtp_i2c_read(client, confirm_buf, len + 2);
if (!memcmp(buf, confirm_buf, len+2))
{
break;
}
}
if (retry < 3)
{
memcpy(rxbuf, confirm_buf+2, len);
return SUCCESS;
}
else
{
GTP_ERROR("i2c read 0x%04X, %d bytes, double check failed!", addr, len);
return FAIL;
}
}
static s32 tool_i2c_read_no_extra(u8 *buf, u16 len)
{
s32 ret = -1;
ret = gtp_i2c_read(gt_client, buf, len + GTP_ADDR_LENGTH);
return ret;
}
static s32 tool_i2c_read_no_extra(u8* buf, u16 len)
{
s32 ret = -1;
/* s32 i = 0;
struct i2c_msg msgs[2];
msgs[0].flags = !I2C_M_RD;
msgs[0].addr = gt_client->addr;
msgs[0].len = cmd_head.addr_len;
msgs[0].buf = &buf[0];
msgs[1].flags = I2C_M_RD;
msgs[1].addr = gt_client->addr;
msgs[1].len = len;
msgs[1].buf = &buf[GTP_ADDR_LENGTH];
for (i = 0; i < cmd_head.retry; i++)
{
ret=i2c_transfer(gt_client->adapter, msgs, 2);
if (ret > 0)
{
break;
}
}
return ret;
*/
ret = gtp_i2c_read(gt_client,buf,len + GTP_ADDR_LENGTH);
return ret;
}
static ssize_t show_tpd_vendor_version(struct device *dev,struct device_attribute *attr, char *buf)
{
if(true){
return 0;
}else{
#define GTP_REG_FW_VERSION 0x8144
u8 rd_buf[4] = {GTP_REG_FW_VERSION>>8, GTP_REG_FW_VERSION&0xff};
int ret;
ret = gtp_i2c_read(i2c_client_point, rd_buf, sizeof(rd_buf));
if (ret < 0)
{
GTP_ERROR("[FW] error\n");
return 0;
}
GTP_DEBUG("[FW] FM version = 0x%x\n", rd_buf[3]<<8 | rd_buf[2]&0xff);
return sprintf(buf, "%x", rd_buf[3]<<8 | rd_buf[2]&0xff);
}
}
static DEVICE_ATTR(tpd_vendor_version, S_IRUGO, show_tpd_vendor_version, NULL);
static struct device_attribute *gt9xx_attrs[] =
{
&dev_attr_tpd_refresh_rate,
&dev_attr_tpd_read_reg,
&dev_attr_tpd_device_name,
&dev_attr_tpd_vendor_name,
&dev_attr_tpd_vendor_version,
};
//=============================================================
static int tpd_i2c_detect(struct i2c_client *client, struct i2c_board_info *info)
{
strcpy(info->type, "mtk-tpd");
return 0;
}
static ssize_t show_tpd_vendor_name(struct device *dev,struct device_attribute *attr, char *buf)
{
u8 rd_vendor_buf[16];
s32 ret = -1;
rd_vendor_buf[0] = GTP_REG_SENSOR_ID >> 8;
rd_vendor_buf[1] = GTP_REG_SENSOR_ID & 0xff;
ret = gtp_i2c_read(i2c_client_point, rd_vendor_buf, 3);
if (ret < 0)
{
GTP_ERROR("gt9xx Read SENSOR ID failed");
rd_vendor_buf[GTP_ADDR_LENGTH] = 3;
return sprintf(buf, "%s", tpd_manufacturer_name[rd_vendor_buf[GTP_ADDR_LENGTH]]);
}
GTP_INFO("gt9xx vendor ID:%d", rd_vendor_buf[GTP_ADDR_LENGTH]);
rd_vendor_buf[GTP_ADDR_LENGTH] &= 0x03;
return sprintf(buf, "%s", tpd_manufacturer_name[rd_vendor_buf[GTP_ADDR_LENGTH]]);
}
static ssize_t show_read_reg(struct device *dev,struct device_attribute *attr, char *buf)
{
int ret, cnt, i;
u8 i2c_buf[GTP_ADDR_LENGTH+100] = {g_attr_read_reg>>8, g_attr_read_reg& 0xff};
if (g_attr_read_reg == 0xFFFF || g_attr_read_nbytes == 0)
{
return sprintf(buf, "0x%x,%d??\n"ATTR_READ_REAG_HINT, g_attr_read_reg, g_attr_read_nbytes);
}
ret = gtp_i2c_read(i2c_client_point, i2c_buf, g_attr_read_nbytes+GTP_ADDR_LENGTH);
if (ret < 0)
{
return sprintf(buf, "read failed\n"ATTR_READ_REAG_HINT);
}
cnt = sprintf(buf, "BASE:0x%x, bytes=%d\n", (i2c_buf[0]<<8 | i2c_buf[1]), g_attr_read_nbytes);
for (i = 0; i< g_attr_read_nbytes; i++)
{
cnt += sprintf(buf+cnt, "0x%02x,", i2c_buf[GTP_ADDR_LENGTH+i]);
if ((i+1)%10 == 0) cnt += sprintf(buf+cnt, "\n");
}
cnt += sprintf(buf+cnt, "\n");
g_attr_read_reg = 0xFFFF;
g_attr_read_nbytes = 0;
return cnt;
}
static ssize_t store_read_reg(struct device *dev,struct device_attribute *attr, const char *buf, size_t size)
{
char *p;
g_attr_read_reg = (u16)simple_strtol(buf, &p, 16);
g_attr_read_nbytes = simple_strtol(p+1, NULL, 10);
GTP_INFO("0x%x, %d", g_attr_read_reg, g_attr_read_nbytes);
return size;
}
GTP_ERROR("proxmy sensor operate function no this parameter %d!\n", command);
err = -1;
break;
}
return err;
}
#endif
void tpd_getfw_info()
{
#define GTP_REG_FW_VERSION 0x8144
u8 buf[4] = {GTP_REG_FW_VERSION>>8, GTP_REG_FW_VERSION&0xff};
int ret;
ret = gtp_i2c_read(i2c_client_point, buf, sizeof(buf));
if (ret < 0)
{
GTP_ERROR("[FW] error\n");
return;
}
GTP_DEBUG("[FW] FM version = 0x%x\n", buf[3]<<8 | buf[2]&0xff);
}
static int gt91xx_config_read_proc(char *page, char **start, off_t off, int count, int *eof, void *data)
{
char *ptr = page;
char temp_data[GTP_CONFIG_MAX_LENGTH + 2] = {0};
int i;
/*******************************************************
Function:
Read goodix touchscreen version function.
Input:
client: i2c client struct.
Output:
Executive outcomes.0---succeed.
*******************************************************/
s32 gtp_read_version(struct goodix_ts_data *ts)
{
s32 ret = -1;
s32 count = 0;
u8 version_data[6] = {(u8)(GTP_REG_VERSION>>8), (u8)GTP_REG_VERSION, 0, 0, 0, 0};
u8 version_comfirm[6] = {(u8)(GTP_REG_VERSION>>8), (u8)GTP_REG_VERSION, 0, 0, 0, 0};
ret = gtp_i2c_read(ts->client,version_data, 6);
if (ret <= 0)
{
GTP_ERROR("GTP read version failed");
return ret;
}
dprintk(DEBUG_INIT, "Read version:%02x%02x", version_data[4], version_data[5]);
while(count++ < 10)
{
gtp_i2c_read(ts->client, version_comfirm, 6);
if((version_data[4] !=version_comfirm[4])||(version_data[5] != version_comfirm[5]))
{
dprintk(DEBUG_INIT, "Comfirm version:%02x%02x", version_comfirm[4], version_comfirm[5]);
version_data[4] = version_comfirm[4];
version_data[5] = version_comfirm[5];
break;
}
msleep(5);
}
if(count == 11)
{
dprintk(DEBUG_INIT, "GTP chip version:%02x%02x_%02x%02x", version_data[3], version_data[2], version_data[4], version_data[5]);
ts->version = (version_data[4]<<8)+version_data[5];
ret = 0;
}
else
{
printk("GTP read version confirm error!");
ret = 1;
}
return ret;
}
/*******************************************************
Function:
Touch down report function.
Input:
ts:private data.
id:tracking id.
x:input x.
y:input y.
w:input weight.
Output:
None.
*******************************************************/
static void gtp_touch_down(struct goodix_ts_data* ts, s32 id, s32 x, s32 y, s32 w)
{
dprintk(DEBUG_X_Y_INFO, "source data:ID:%d, X:%d, Y:%d, W:%d\n", id, x, y, w);
if(1 == exchange_x_y_flag){
swap(x, y);
}
if(1 == revert_x_flag){
x = ts->abs_x_max - x;
}
if(1 == revert_y_flag){
y = ts->abs_y_max - y;
}
dprintk(DEBUG_X_Y_INFO,"report data:ID:%d, X:%d, Y:%d, W:%d\n", id, x, y, w);
input_report_abs(ts->input_dev, ABS_MT_POSITION_X, x);
input_report_abs(ts->input_dev, ABS_MT_POSITION_Y, y);
input_report_abs(ts->input_dev, ABS_MT_TOUCH_MAJOR, w);
input_report_abs(ts->input_dev, ABS_MT_WIDTH_MAJOR, w);
input_report_abs(ts->input_dev, ABS_MT_TRACKING_ID, id);
input_mt_sync(ts->input_dev);
}
/*******************************************************
Function:
Touch up report function.
Input:
ts:private data.
Output:
None.
*******************************************************/
static void gtp_touch_up(struct goodix_ts_data* ts)
{
input_report_abs(ts->input_dev, ABS_MT_TOUCH_MAJOR, 0);
input_report_abs(ts->input_dev, ABS_MT_WIDTH_MAJOR, 0);
input_mt_sync(ts->input_dev);
}
u8 point_index = 0;
u8 point_tmp = 0;
u8 touch_num = 0;
u8 input_w = 0;
u16 input_x = 0;
u16 input_y = 0;
u32 count = 0;
u32 position = 0;
s32 ret = -1;
struct goodix_ts_data *ts;
GTP_DEBUG_FUNC();
ts = container_of(work, struct goodix_ts_data, work);
ret = gtp_i2c_read(ts->client, point_data, sizeof(point_data)/sizeof(point_data[0]));
if (ret <= 0)
{
goto exit_work_func;
}
GTP_DEBUG_ARRAY(point_data, sizeof(point_data)/sizeof(point_data[0]));
if(point_data[GTP_ADDR_LENGTH]&0x20)
{
if(point_data[3]==0xF0)
{
GTP_DEBUG("Reload config!");
ret = gtp_send_cfg(ts->client);
if (ret)
{
GTP_ERROR("Send config error.");
}
/*******************************************************
Function:
GTP initialize function.
Input:
ts: i2c client private struct.
Output:
Executive outcomes.0---succeed.
*******************************************************/
s32 gtp_init_panel(struct goodix_ts_data *ts)
{
s32 ret = -1;
u8 rd_cfg_buf[4];
int index = -1;
u8 cfg_info_group1[] = CTP_CFG_GROUP_DPT1;//dpt yiju
u8 cfg_info_group2[] = CTP_CFG_GROUP;
u8 * send_cfg_buf[2] = {cfg_info_group1,cfg_info_group2};
#if 0
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])};
GTP_DEBUG("len1=%d,len2=%d,len3=%d",cfg_info_len[0],cfg_info_len[1],cfg_info_len[2]);
if ((!cfg_info_len[1])&&(!cfg_info_len[2]))
{
rd_cfg_buf[GTP_ADDR_LENGTH] = 0;
}
else
{
rd_cfg_buf[0] = (u8)(GTP_REG_SENSOR_ID>>8);
rd_cfg_buf[1] = (u8)GTP_REG_SENSOR_ID;
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] &= 0x03;
}
GTP_DEBUG("SENSOR ID:%d", rd_cfg_buf[GTP_ADDR_LENGTH]);
memcpy(config, send_cfg_buf[rd_cfg_buf[GTP_ADDR_LENGTH]], (GTP_CONFIG_LENGTH+GTP_ADDR_LENGTH));
#endif
rd_cfg_buf[0] = (u8)(GTP_REG_SENSOR_ID>>8);
rd_cfg_buf[1] = (u8)GTP_REG_SENSOR_ID;
ret=gtp_i2c_read(ts->client, rd_cfg_buf, 3);
if (ret <= 0)
{
printk("Read SENSOR ID failed,default use group1 config!");
rd_cfg_buf[GTP_ADDR_LENGTH] = 0;
}
rd_cfg_buf[GTP_ADDR_LENGTH] &= 0x03;
dprintk(DEBUG_INIT, "sensor ID =%d\n\n",rd_cfg_buf[GTP_ADDR_LENGTH]);
index = 0;
if(rd_cfg_buf[GTP_ADDR_LENGTH] == 2)
index = 6;
index = 0;//gandy
memcpy(config, send_cfg_buf[index], sizeof(cfg_info_group1));
#if GTP_CUSTOM_CFG
config[57] &= 0xf7;
if(GTP_INT_TRIGGER&0x01)
{
config[57] += 0x08;
}
config[59] = GTP_REFRESH;
config[60] = GTP_MAX_TOUCH>5 ? 5 : GTP_MAX_TOUCH;
config[61] = (u8)SCREEN_MAX_WIDTH;
config[62] = (u8)(SCREEN_MAX_WIDTH >> 8);
config[63] = (u8)SCREEN_MAX_X;
config[64] = (u8)(SCREEN_MAX_Y >> 8);
#endif
ts->abs_x_max = (config[62]<<8) + config[61];
ts->abs_y_max = (config[64]<<8) + config[63];
ts->max_touch_num = config[60];
ts->int_trigger_type = ((config[57]>>3)&0x01);
if ((!ts->abs_x_max)||(!ts->abs_y_max)||(!ts->max_touch_num))
{
GTP_ERROR("GTP resolution & max_touch_num invalid, use default value!");
ts->abs_x_max = SCREEN_MAX_X;
ts->abs_y_max = SCREEN_MAX_Y;
ts->max_touch_num = GTP_MAX_TOUCH;
}
ret = gtp_send_cfg(ts->client);
if (ret)
{
printk("Send config error.");
}
msleep(10);
return 0;
}
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;
}
GTP_MSLEEP(10);
return 0;
}
static s32 gtp_read_version(struct i2c_client *client, u16 *version)
{
u8 buf[8] = {
GTP_REG_VERSION >> 8,
GTP_REG_VERSION & 0xff
};
s32 i, ret;
GTP_DEBUG_FUNC();
ret = gtp_i2c_read(client, buf, sizeof(buf));
if (ret < 0) {
GTP_ERROR("GTP read version failed");
return ret;
}
if (version)
*version = (buf[7] << 8) | buf[6];
for (i = 2; i < 6; i++) {
if (!buf[i])
buf[i] = 0x30;
}
GTP_DEBUG("IC VERSION:%c%c%c%c_%02x%02x",
buf[2], buf[3], buf[4], buf[5], buf[7], buf[6]);
return ret;
/**
* ctp_detect - Device detection callback for automatic device creation
* return value:
* = 0; success;
* < 0; err
*/
static int ctp_detect(struct i2c_client *client, struct i2c_board_info *info)
{
struct i2c_adapter *adapter = client->adapter;
int ret;
u8 buf[8] = {GTP_REG_VERSION >> 8, GTP_REG_VERSION & 0xff};
if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)){
pr_err("i2c_check_functionality err\n======return=====\n");
return -ENODEV;
}
if(twi_id == adapter->nr){
pr_debug("%s: addr= %x\n",__func__,client->addr);
msleep(50);
ret = gtp_i2c_read(client, buf, 6);
gtp_i2c_end_cmd(client);
if(buf[3] != 0x18)
{
pr_debug("%s:IC is not gt818\n",__func__);
return -ENODEV;
}
GTP_INFO("IC VERSION:%02x%02x_%02x%02x", buf[3], buf[2], buf[5], buf[4]);
strlcpy(info->type, CTP_NAME, I2C_NAME_SIZE);
//printk("%s:I2C connection might be something wrong ! \n",__func__);
return 0;
}else{
return -ENODEV;
}
}
/**
* ctp_print_info - sysconfig print function
* return value:
*
*/
static void ctp_print_info(struct ctp_config_info info,int debug_level)
{
if(debug_level == DEBUG_INIT)
{
dprintk(DEBUG_INIT,"info.ctp_used:%d\n",info.ctp_used);
dprintk(DEBUG_INIT,"info.twi_id:%d\n",info.twi_id);
dprintk(DEBUG_INIT,"info.screen_max_x:%d\n",info.screen_max_x);
dprintk(DEBUG_INIT,"info.screen_max_y:%d\n",info.screen_max_y);
dprintk(DEBUG_INIT,"info.revert_x_flag:%d\n",info.revert_x_flag);
dprintk(DEBUG_INIT,"info.revert_y_flag:%d\n",info.revert_y_flag);
dprintk(DEBUG_INIT,"info.exchange_x_y_flag:%d\n",info.exchange_x_y_flag);
dprintk(DEBUG_INIT,"info.irq_gpio_number:%d\n",info.irq_gpio.gpio);
dprintk(DEBUG_INIT,"info.wakeup_gpio_number:%d\n",info.wakeup_gpio.gpio);
}
}
/**
* ctp_wakeup - function
*
*/
static int ctp_wakeup(int status,int ms)
{
dprintk(DEBUG_INIT,"***CTP*** %s:status:%d,ms = %d\n",__func__,status,ms);
if (status == 0) {
if(ms == 0) {
__gpio_set_value(config_info.wakeup_gpio.gpio, 0);
}else {
__gpio_set_value(config_info.wakeup_gpio.gpio, 0);
msleep(ms);
__gpio_set_value(config_info.wakeup_gpio.gpio, 1);
}
}
if (status == 1) {
if(ms == 0) {
__gpio_set_value(config_info.wakeup_gpio.gpio, 1);
}else {
__gpio_set_value(config_info.wakeup_gpio.gpio, 1);
msleep(ms);
__gpio_set_value(config_info.wakeup_gpio.gpio, 0);
}
}
msleep(5);
return 0;
}
