Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 9ccc3ab1 authored by Shantanu Jain's avatar Shantanu Jain Committed by Sudhakar Manapati
Browse files

input: touchscreen: Goodix gt915 driver cleanup 



Cleanup the gt915 goodix driver from checkpatch failures.
Also have cleared the checkpatch errors on 3.18

  This patch is propagated from 3.4 kernel
    commit: 930d66c61cf5bd49bbfbd064b1e51955fdef1eb9
    input: touchscreen: Goodix gt915 driver cleanup

Change-Id: Id841423f229b6abc674cc1e3c6441d55062b6ab4
Signed-off-by: default avatarShantanu Jain <shjain@codeaurora.org>
Signed-off-by: default avatarBingzhe Cai <bingzhec@codeaurora.org>
Signed-off-by: default avatarSudhakar Manapati <smanap@codeaurora.org>
parent 69150946

drivers/input/touchscreen/gt9xx/goodix_tool.c

+548 −615
Original line number Diff line number Diff line 
/* drivers/input/touchscreen/goodix_tool.c

 *

 * 2010 - 2012 Goodix Technology.

 * Copyright (c) 2013-2015, The Linux Foundation. All rights reserved.

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by
@@ -28,48 +29,38 @@ static char procname[20] = {0}; 


#define UPDATE_FUNCTIONS



#ifdef UPDATE_FUNCTIONS

extern s32 gup_enter_update_mode(struct i2c_client *client);

extern void gup_leave_update_mode(void);

extern s32 gup_update_proc(void *dir);

#endif



extern void gtp_irq_disable(struct goodix_ts_data *);

extern void gtp_irq_enable(struct goodix_ts_data *);



#pragma pack(1)

typedef struct{

    u8  wr;         //write read flag0:R  1:W  2:PID 3:

    u8  flag;       //0:no need flag/int 1: need flag  2:need int

    u8 flag_addr[2];  //flag address

    u8  flag_val;   //flag val

    u8  flag_relation;  //flag_val:flag 0:not equal 1:equal 2:> 3:<

    u16 circle;     //polling cycle 

    u8  times;      //plling times

    u8  retry;      //I2C retry times

    u16 delay;      //delay befor read or after write

    u16 data_len;   //data length

    u8  addr_len;   //address length

    u8  addr[2];    //address

    u8  res[3];     //reserved

    u8* data;       //data pointer

struct {

	u8  wr;		/* write read flag0:R  1:W  2:PID 3: */

	u8  flag;	/* 0:no need flag/int 1: need flag  2:need int */

	u8 flag_addr[2];/* flag address */

	u8  flag_val;	/* flag val */

	u8  flag_relation; /* flag_val:flag 0:not equal 1:equal 2:> 3:< */

	u16 circle;	/* polling cycle */

	u8  times;	/* plling times */

	u8  retry;	/* I2C retry times */

	u16 delay;	/* delay before read or after write */

	u16 data_len;	/* data length */

	u8  addr_len;	/* address length */

	u8  addr[2];	/* address */

	u8  res[3];	/* reserved */

	u8  *data;	/* data pointer */

} st_cmd_head;

#pragma pack()

st_cmd_head cmd_head;



static struct i2c_client *gt_client = NULL;

static struct i2c_client *gt_client;



static struct proc_dir_entry *goodix_proc_entry;



static s32 goodix_tool_write(struct file *filp, const char __user *buff, unsigned long len, void *data);

static s32 goodix_tool_read( char *page, char **start, off_t off, int count, int *eof, void *data );

static s32 goodix_tool_write(struct file *filp, const char __user *buff,

						unsigned long len, void *data);

static s32 goodix_tool_read(char *page, char **start, off_t off, int count,

							int *eof, void *data);

static s32 (*tool_i2c_read)(u8 *, u16);

static s32 (*tool_i2c_write)(u8 *, u16);



#if GTP_ESD_PROTECT

extern void gtp_esd_switch(struct i2c_client *, s32);

#endif

s32 DATA_LENGTH = 0;

s32 DATA_LENGTH;

s8 IC_TYPE[16] = {0};



static void tool_set_proc_name(char *procname)
@@ -78,29 +69,26 @@ static void tool_set_proc_name(char * procname) 
	"Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};

	char date[20] = {0};

	char month[4] = {0};

    int i = 0, n_month = 1, n_day = 0, n_year = 0;

	int i = 0, n_month = 1, n_day = 0, n_year = 0, ret;



    sprintf(date, "%s", __DATE__);

	snprintf(date, 20, "%s", __DATE__);



    //GTP_DEBUG("compile date: %s", date);

	/* GTP_DEBUG("compile date: %s", date); */



    sscanf(date, "%s %d %d", month, &n_day, &n_year);

    

    for (i = 0; i < 12; ++i)

    {

        if (!memcmp(months[i], month, 3))

        {

	ret = sscanf(date, "%s %d %d", month, &n_day, &n_year);

	if (!ret)

		return;

	for (i = 0; i < 12; ++i) {

		if (!memcmp(months[i], month, 3)) {

			n_month = i+1;

			break;

		}

	}



    sprintf(procname, "gmnode%04d%02d%02d", n_year, n_month, n_day);    

    

    //GTP_DEBUG("procname = %s", procname);

	snprintf(procname, 20, "gmnode%04d%02d%02d", n_year, n_month, n_day);

	/* GTP_DEBUG("procname = %s", procname); */

}





static s32 tool_i2c_read_no_extra(u8 *buf, u16 len)

{

	s32 ret = -1;
@@ -117,14 +105,12 @@ static s32 tool_i2c_read_no_extra(u8* buf, u16 len) 
	msgs[1].len   = len;

	msgs[1].buf   = &buf[GTP_ADDR_LENGTH];



    for (i = 0; i < cmd_head.retry; i++)

    {

	for (i = 0; i < cmd_head.retry; i++) {

		ret = i2c_transfer(gt_client->adapter, msgs, 2);

		if (ret > 0)

        {

			break;

	}

    }



	return ret;

}
@@ -139,14 +125,12 @@ static s32 tool_i2c_write_no_extra(u8* buf, u16 len) 
	msg.len   = len;

	msg.buf   = buf;



    for (i = 0; i < cmd_head.retry; i++)

    {

	for (i = 0; i < cmd_head.retry; i++) {

		ret = i2c_transfer(gt_client->adapter, &msg, 1);

		if (ret > 0)

        {

			break;

		}

    }



	return ret;

}
@@ -178,21 +162,14 @@ static s32 tool_i2c_write_with_extra(u8* buf, u16 len) 


static void register_i2c_func(void)

{

//    if (!strncmp(IC_TYPE, "GT818", 5) || !strncmp(IC_TYPE, "GT816", 5) 

//        || !strncmp(IC_TYPE, "GT811", 5) || !strncmp(IC_TYPE, "GT818F", 6) 

//        || !strncmp(IC_TYPE, "GT827", 5) || !strncmp(IC_TYPE,"GT828", 5)

//        || !strncmp(IC_TYPE, "GT813", 5))

    if (strncmp(IC_TYPE, "GT8110", 6) && strncmp(IC_TYPE, "GT8105", 6)

        && strncmp(IC_TYPE, "GT801", 5) && strncmp(IC_TYPE, "GT800", 5)

        && strncmp(IC_TYPE, "GT801PLUS", 9) && strncmp(IC_TYPE, "GT811", 5)

        && strncmp(IC_TYPE, "GTxxx", 5))

    {

	if (strcmp(IC_TYPE, "GT8110") && strcmp(IC_TYPE, "GT8105")

	&& strcmp(IC_TYPE, "GT801") && strcmp(IC_TYPE, "GT800")

	&& strcmp(IC_TYPE, "GT801PLUS") && strcmp(IC_TYPE, "GT811")

	&& strcmp(IC_TYPE, "GTxxx")) {

		tool_i2c_read = tool_i2c_read_with_extra;

		tool_i2c_write = tool_i2c_write_with_extra;

		GTP_DEBUG("I2C function: with pre and end cmd!");

    }

    else

    {

	} else {

		tool_i2c_read = tool_i2c_read_no_extra;

		tool_i2c_write = tool_i2c_write_no_extra;

		GTP_INFO("I2C function: without pre and end cmd!");
@@ -206,7 +183,6 @@ static void unregister_i2c_func(void) 
	GTP_INFO("I2C function: unregister i2c transfer function!");

}





s32 init_wr_node(struct i2c_client *client)

{

	s32 i;
@@ -216,22 +192,16 @@ s32 init_wr_node(struct i2c_client *client) 
	cmd_head.data = NULL;



	i = 5;

    while ((!cmd_head.data) && i)

    {

	while ((!cmd_head.data) && i) {

		cmd_head.data = kzalloc(i * DATA_LENGTH_UINT, GFP_KERNEL);

		if (NULL != cmd_head.data)

        {

			break;

        }

		i--;

	}

    if (i)

    {

	if (i) {

		DATA_LENGTH = i * DATA_LENGTH_UINT + GTP_ADDR_LENGTH;

		GTP_INFO("Applied memory size:%d.", DATA_LENGTH);

    }

    else

    {

	} else {

		GTP_ERROR("Apply for memory failed.");

		return FAIL;

	}
@@ -243,17 +213,13 @@ s32 init_wr_node(struct i2c_client *client) 


	tool_set_proc_name(procname);

	goodix_proc_entry = create_proc_entry(procname, 0666, NULL);

    if (goodix_proc_entry == 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;

    }

	dix_proc_entry->read_proc = goodix_tool_read;



	return SUCCESS;

}
@@ -270,15 +236,16 @@ static u8 relation(u8 src, u8 dst, u8 rlt) 
{

	u8 ret = 0;



    switch (rlt)

    {

	switch (rlt) {



	case 0:

		ret = (src != dst) ? true : false;

		break;



	case 1:

		ret = (src == dst) ? true : false;

        GTP_DEBUG("equal:src:0x%02x   dst:0x%02x   ret:%d.", src, dst, (s32)ret);

		GTP_DEBUG("equal:src:0x%02x   dst:0x%02x  ret:%d.",

					src, dst, (s32)ret);

		break;



	case 2:
@@ -318,20 +285,21 @@ 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[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)

        {

	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]);

		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;

		}
@@ -339,8 +307,7 @@ static u8 comfirm(void) 
		msleep(cmd_head.circle);

	}



    if (i >= cmd_head.times)

    {

	if (i >= cmd_head.times) {

		GTP_ERROR("Didn't get the flag to continue!");

		return FAIL;

	}
@@ -348,29 +315,30 @@ static u8 comfirm(void) 
	return SUCCESS;

}



/*******************************************************    

/********************************************************

Function:

    Goodix tool write function.

Input:

nput:

  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)

static s32 goodix_tool_write(struct file *filp, const char __user *buff,

						unsigned long len, void *data)

{

	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.");

    }



	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 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);
@@ -383,127 +351,107 @@ static s32 goodix_tool_write(struct file *filp, const char __user *buff, unsigne 
	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 (cmd_head.wr == 1) {

		/*  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);

		memcpy(&cmd_head.data[GTP_ADDR_LENGTH - cmd_head.addr_len],

					cmd_head.addr, cmd_head.addr_len);



        if (1 == cmd_head.flag)

        {

            if (FAIL == comfirm())

            {

		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 (cmd_head.flag == 1) {

			if (FAIL == comfirm()) {

				GTP_ERROR("[WRITE]Comfirm fail!");

				return FAIL;

			}

		} else if (cmd_head.flag == 2) {

			/* Need interrupt! */

		}

        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)

        {

		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);

		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);

	} else if (cmd_head.wr == 3) {  /* 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);

	} else if (cmd_head.wr == 3) {



		/* 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!

    {

	} else if (cmd_head.wr == 7) { /* 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!

    {

	} else if (cmd_head.wr == 9) { /* 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)

    {

	} else if (cmd_head.wr == 17) {

		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);



		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])

        {

		if (cmd_head.data[GTP_ADDR_LENGTH]) {

			GTP_DEBUG("gtp enter rawdiff.");

			ts->gtp_rawdiff_mode = true;

        }

        else

        {

		} 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!

    {

	else if (cmd_head.wr == 11) { /* Enter update mode! */

		if (FAIL == gup_enter_update_mode(gt_client))

        {

			return FAIL;

        }

    }

    else if (13 == cmd_head.wr)//Leave update mode!

    {

	} else if (cmd_head.wr == 13) { /* Leave update mode! */

		gup_leave_update_mode();

    }

    else if (15 == cmd_head.wr) //Update firmware!

    {

	} else if (cmd_head.wr == 15) { /* 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);

		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;
@@ -517,95 +465,80 @@ Input: 
Output:

    Return read length.

********************************************************/

static s32 goodix_tool_read( char *page, char **start, off_t off, int count, int *eof, void *data )

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)

    {

	if (cmd_head.wr % 2) {

		return FAIL;

    }

    else if (!cmd_head.wr)

    {

	} else if (!cmd_head.wr) {

		u16 len = 0;

		s16 data_len = 0;

		u16 loc = 0;



        if (1 == cmd_head.flag)

        {

            if (FAIL == comfirm())

            {

		if (cmd_head.flag == 1) {

			if (FAIL == comfirm()) {

				GTP_ERROR("[READ]Comfirm fail!");

				return FAIL;

			}

        }

        else if (2 == cmd_head.flag)

        {

            //Need interrupt!

		} else if (cmd_head.flag == 2) {

			/* 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]);

		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)

        {

		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)

            {

			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);

			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;

	} else if (cmd_head.wr == 2) {

		/* 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);

		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)

    {

		/* return sizeof(IC_TYPE_NAME); */

	} else if (cmd_head.wr == 4) {

		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)

    {

        //Read error code!

    }

    else if (8 == cmd_head.wr)  //Read driver version

    {

       // memcpy(page, GTP_DRIVER_VERSION, strlen(GTP_DRIVER_VERSION));

	} else if (6 == cmd_head.wr) {

		/* Read error code! */

	} else if (8 == cmd_head.wr) { /*Read driver version */

		/* memcpy(page, GTP_DRIVER_VERSION,

				strlen(GTP_DRIVER_VERSION)); */

		s32 tmp_len;



		tmp_len = strlen(GTP_DRIVER_VERSION);

		memcpy(page, GTP_DRIVER_VERSION, tmp_len);

		page[tmp_len] = 0;

drivers/input/touchscreen/gt9xx/gt9xx_firmware.h

+6 −6
Original line number Diff line number Diff line 
// make sense only when GTP_HEADER_FW_UPDATE & GTP_AUTO_UPDATE are enabled

// define your own firmware array here

const unsigned char header_fw_array[] = 

{

    

/*

 * make sense only when GTP_HEADER_FW_UPDATE & GTP_AUTO_UPDATE are enabled

 * define your own firmware array here

*/

const unsigned char header_fw_array[] = {

};