Merge "input: touchscreen: Goodix gt915 driver cleanup" (ade09300) · Commits · e / devices / android_kernel_xiaomi_markw

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.c

+1378 −1378

File changed.

Preview size limit exceeded, changes collapsed.

drivers/input/touchscreen/gt9xx/gt9xx.h

+229 −198

Original line number	Diff line number	Diff line
		/* drivers/input/touchscreen/gt9xx.h
		*
		* Copyright (c) 2013, The Linux Foundation. All rights reserved.
		*
		* Linux Foundation chooses to take subject only to the GPLv2 license
		* terms, and distributes only under these terms.
		*
		* 2010 - 2013 Goodix Technology.
		*
		@@ -19,29 +24,54 @@
		#define _GOODIX_GT9XX_H_

		#include <linux/kernel.h>
		#include <linux/hrtimer.h>
		#include <linux/i2c.h>
		#include <linux/irq.h>
		#include <linux/input.h>
		#include <linux/module.h>
		#include <linux/delay.h>
		#include <linux/i2c.h>
		#include <linux/proc_fs.h>
		#include <linux/string.h>
		#include <asm/uaccess.h>
		#include <linux/vmalloc.h>
		#include <linux/slab.h>
		#include <linux/interrupt.h>
		#include <linux/io.h>
		#include <mach/gpio.h>
		#include <linux/delay.h>
		#include <linux/kernel.h>
		#include <linux/module.h>
		#include <linux/gpio.h>
		#include <linux/regulator/consumer.h>
		#include <linux/firmware.h>
		#include <linux/debugfs.h>
		#if defined(CONFIG_HAS_EARLYSUSPEND)
		#include <linux/earlysuspend.h>
		#define GOODIX_SUSPEND_LEVEL 1
		#endif

		struct goodix_ts_platform_data {
		int irq_gpio;
		u32 irq_gpio_flags;
		int reset_gpio;
		u32 reset_gpio_flags;
		int ldo_en_gpio;
		u32 ldo_en_gpio_flags;
		u32 family_id;
		u32 x_max;
		u32 y_max;
		u32 x_min;
		u32 y_min;
		u32 panel_minx;
		u32 panel_miny;
		u32 panel_maxx;
		u32 panel_maxy;
		bool no_force_update;
		bool i2c_pull_up;
		};
		struct goodix_ts_data {
		spinlock_t irq_lock;
		struct i2c_client *client;
		struct input_dev *input_dev;
		struct goodix_ts_platform_data *pdata;
		struct hrtimer timer;
		struct workqueue_struct *goodix_wq;
		struct work_struct work;
		#if defined(CONFIG_HAS_EARLYSUSPEND)
		struct early_suspend early_suspend;
		s32 irq_is_disable;
		#endif
		s32 irq_is_disabled;
		s32 use_irq;
		u16 abs_x_max;
		u16 abs_y_max;
		@@ -49,6 +79,7 @@ struct goodix_ts_data {
		u8 int_trigger_type;
		u8 green_wake_mode;
		u8 chip_type;
		u8 *config_data;
		u8 enter_update;
		u8 gtp_is_suspend;
		u8 gtp_rawdiff_mode;
		@@ -61,41 +92,46 @@ struct goodix_ts_data {
		extern u16 show_len;
		extern u16 total_len;

		//*************************PART1:ON/OFF define*****************************
		/*************************PART1:ON/OFF define*****************************/
		#define GTP_CUSTOM_CFG 0
		#define GTP_CHANGE_X2Y 0
		#define GTP_DRIVER_SEND_CFG 1
		#define GTP_HAVE_TOUCH_KEY 0
		#define GTP_POWER_CTRL_SLEEP 0
		#define GTP_HAVE_TOUCH_KEY 1
		#define GTP_POWER_CTRL_SLEEP 1
		#define GTP_ICS_SLOT_REPORT 0

		#define GTP_AUTO_UPDATE 1 // auto updated by .bin file as default
		#define GTP_HEADER_FW_UPDATE 0 // auto updated by head_fw_array in gt9xx_firmware.h, function together with GTP_AUTO_UPDATE
		/* auto updated by .bin file as default */
		#define GTP_AUTO_UPDATE 0
		/* auto updated by head_fw_array in gt9xx_firmware.h,
		* function together with GTP_AUTO_UPDATE */
		#define GTP_HEADER_FW_UPDATE 0

		#define GTP_CREATE_WR_NODE 1
		#define GTP_CREATE_WR_NODE 0
		#define GTP_ESD_PROTECT 0
		#define GTP_WITH_PEN 0

		#define GTP_SLIDE_WAKEUP 0
		#define GTP_DBL_CLK_WAKEUP 0 // double-click wakeup, function together with GTP_SLIDE_WAKEUP
		/* double-click wakeup, function together with GTP_SLIDE_WAKEUP */
		#define GTP_DBL_CLK_WAKEUP 0

		#define GTP_DEBUG_ON 1
		#define GTP_DEBUG_ARRAY_ON 0
		#define GTP_DEBUG_FUNC_ON 0

		//************************* PART2:TODO define ********************************
		// STEP_1(REQUIRED): Define Configuration Information Group(s)
		// Sensor_ID Map:
		/************************* PART2:TODO define *****************************/
		/* STEP_1(REQUIRED): Define Configuration Information Group(s) */
		/* Sensor_ID Map: */
		/* sensor_opt1 sensor_opt2 Sensor_ID
		GND GND 0
		VDDIO GND 1
		NC GND 2
		GND NC/300K 3
		VDDIO NC/300K 4
		NC NC/300K 5
		* GND GND 0
		* VDDIO GND 1
		* NC GND 2
		* GND NC/300K 3
		* VDDIO NC/300K 4
		* NC NC/300K 5
		*/
		// TODO: define your own default or for Sensor_ID == 0 config here.
		// The predefined one is just a sample config, which is not suitable for your tp in most cases.
		/* Define your own default or for Sensor_ID == 0 config here */
		/* The predefined one is just a sample config,
		* which is not suitable for your tp in most cases. */
		#define CTP_CFG_GROUP1 {\
		0x41, 0x1C, 0x02, 0xC0, 0x03, 0x0A, 0x05, 0x01, 0x01, 0x0F,\
		0x23, 0x0F, 0x5F, 0x41, 0x03, 0x05, 0x00, 0x00, 0x00, 0x00,\
		@@ -122,67 +158,53 @@ extern u16 total_len;
		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x91, 0x01\
		}

		// TODO: define your config for Sensor_ID == 1 here, if needed
		/* Define your config for Sensor_ID == 1 here, if needed */
		#define CTP_CFG_GROUP2 {\
		}
		// TODO: define your config for Sensor_ID == 2 here, if needed

		/* Define your config for Sensor_ID == 2 here, if needed */
		#define CTP_CFG_GROUP3 {\
		}

		// TODO: define your config for Sensor_ID == 3 here, if needed
		/* Define your config for Sensor_ID == 3 here, if needed */
		#define CTP_CFG_GROUP4 {\
		}

		// TODO: define your config for Sensor_ID == 4 here, if needed
		/* Define your config for Sensor_ID == 4 here, if needed */
		#define CTP_CFG_GROUP5 {\
		}

		// TODO: define your config for Sensor_ID == 5 here, if needed
		/* Define your config for Sensor_ID == 5 here, if needed */
		#define CTP_CFG_GROUP6 {\
		}

		// STEP_2(REQUIRED): Customize your I/O ports & I/O operations
		#define GTP_RST_PORT S5PV210_GPJ3(6)
		#define GTP_INT_PORT S5PV210_GPH1(3)
		#define GTP_INT_IRQ gpio_to_irq(GTP_INT_PORT)
		#define GTP_INT_CFG S3C_GPIO_SFN(0xF)

		#define GTP_GPIO_AS_INPUT(pin) do{\
		gpio_direction_input(pin);\
		s3c_gpio_setpull(pin, S3C_GPIO_PULL_NONE);\
		}while(0)
		#define GTP_GPIO_AS_INT(pin) do{\
		GTP_GPIO_AS_INPUT(pin);\
		s3c_gpio_cfgpin(pin, GTP_INT_CFG);\
		}while(0)
		#define GTP_GPIO_GET_VALUE(pin) gpio_get_value(pin)
		#define GTP_GPIO_OUTPUT(pin,level) gpio_direction_output(pin,level)
		#define GTP_GPIO_REQUEST(pin, label) gpio_request(pin, label)
		#define GTP_GPIO_FREE(pin) gpio_free(pin)
		#define GTP_IRQ_TAB {IRQ_TYPE_EDGE_RISING, IRQ_TYPE_EDGE_FALLING, IRQ_TYPE_LEVEL_LOW, IRQ_TYPE_LEVEL_HIGH}
		#define GTP_IRQ_TAB {\
		IRQ_TYPE_EDGE_RISING,\
		IRQ_TYPE_EDGE_FALLING,\
		IRQ_TYPE_LEVEL_LOW,\
		IRQ_TYPE_LEVEL_HIGH\
		}

		// STEP_3(optional): Specify your special config info if needed
		/* STEP_3(optional): Specify your special config info if needed */
		#define GTP_IRQ_TAB_RISING 0
		#define GTP_IRQ_TAB_FALLING 1
		#if GTP_CUSTOM_CFG
		#define GTP_MAX_HEIGHT 800
		#define GTP_MAX_WIDTH 480
		#define GTP_INT_TRIGGER 0 // 0: Rising 1: Falling
		#define GTP_INT_TRIGGER GTP_IRQ_TAB_RISING
		#else
		#define GTP_MAX_HEIGHT 4096
		#define GTP_MAX_WIDTH 4096
		#define GTP_INT_TRIGGER 1
		#define GTP_INT_TRIGGER GTP_IRQ_TAB_FALLING
		#endif
		#define GTP_MAX_TOUCH 5
		#define GTP_ESD_CHECK_CIRCLE 2000 // jiffy: ms

		// STEP_4(optional): If keys are available and reported as keys, config your key info here
		#if GTP_HAVE_TOUCH_KEY
		#define GTP_KEY_TAB {KEY_MENU, KEY_HOME, KEY_BACK}
		#endif
		#define GTP_MAX_TOUCH 5
		#define GTP_ESD_CHECK_CIRCLE 2000 /* jiffy: ms */

		//*************************PART3:OTHER define*******************************
		/*************************PART3:OTHER define*******************************/
		#define GTP_DRIVER_VERSION "V1.8<2013/06/08>"
		#define GTP_I2C_NAME "Goodix-TS"
		#define GTP_POLL_TIME 10 // jiffy: ms
		#define GTP_POLL_TIME 10 /* jiffy: ms*/
		#define GTP_ADDR_LENGTH 2
		#define GTP_CONFIG_MIN_LENGTH 186
		#define GTP_CONFIG_MAX_LENGTH 240
		@@ -191,7 +213,7 @@ extern u16 total_len;
		#define SWITCH_OFF 0
		#define SWITCH_ON 1

		// Registers define
		/* Registers define */
		#define GTP_READ_COOR_ADDR 0x814E
		#define GTP_REG_SLEEP 0x8040
		#define GTP_REG_SENSOR_ID 0x814A
		@@ -202,40 +224,49 @@ extern u16 total_len;
		#define TRIGGER_LOC 8

		#define CFG_GROUP_LEN(p_cfg_grp) (sizeof(p_cfg_grp) / sizeof(p_cfg_grp[0]))
		// Log define
		#define GTP_INFO(fmt,arg...) printk("<<-GTP-INFO->> "fmt"\n",##arg)
		#define GTP_ERROR(fmt,arg...) printk("<<-GTP-ERROR->> "fmt"\n",##arg)
		/* Log define */
		#define GTP_DEBUG(fmt, arg...) do {\
		if(GTP_DEBUG_ON)\
		printk("<<-GTP-DEBUG->> [%d]"fmt"\n",__LINE__, ##arg);\
		if (GTP_DEBUG_ON) {\
		pr_debug("<<-GTP-DEBUG->> [%d]"fmt"\n",\
		__LINE__, ##arg); } \
		} while (0)

		#define GTP_DEBUG_ARRAY(array, num) do {\
		s32 i; \
		u8 *a = array; \
		if(GTP_DEBUG_ARRAY_ON)\
		{\
		printk("<<-GTP-DEBUG-ARRAY->>\n");\
		for (i = 0; i < (num); i++)\
		{\
		printk("%02x ", (a)[i]);\
		if ((i + 1 ) %10 == 0)\
		{\
		printk("\n");\
		if (GTP_DEBUG_ARRAY_ON) {\
		pr_debug("<<-GTP-DEBUG-ARRAY->>\n");\
		for (i = 0; i < (num); i++) { \
		pr_debug("%02x ", (a)[i]);\
		if ((i + 1) % 10 == 0) { \
		pr_debug("\n");\
		} \
		} \
		printk("\n");\
		pr_debug("\n");\
		} \
		} while (0)

		#define GTP_DEBUG_FUNC() do {\
		if (GTP_DEBUG_FUNC_ON)\
		printk("<<-GTP-FUNC->> Func:%s@Line:%d\n",__func__,__LINE__);\
		pr_debug("<<-GTP-FUNC->> Func:%s@Line:%d\n",\
		__func__, __LINE__);\
		} while (0)

		#define GTP_SWAP(x, y) do {\
		typeof(x) z = x;\
		x = y;\
		y = z;\
		} while (0)
		/***************************End of Part III******************************/

		//***************************End of Part III******************************
		void gtp_esd_switch(struct i2c_client *client, int on);

		#if GTP_CREATE_WR_NODE
		extern s32 init_wr_node(struct i2c_client *client);
		extern void uninit_wr_node(void);
		#endif

		#if GTP_AUTO_UPDATE
		extern u8 gup_init_update_proc(struct goodix_ts_data *ts);
		#endif
		#endif /* _GOODIX_GT9XX_H_ */

drivers/input/touchscreen/gt9xx/gt9xx_firmware.h

+6 −6

File changed.

Preview size limit exceeded, changes collapsed.

drivers/input/touchscreen/gt9xx/gt9xx_update.c

+1572 −1723

File changed.

Preview size limit exceeded, changes collapsed.