rk3588-game
/
android13
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
android13/kernel-5.10/drivers/input/touchscreen/gt9xx/gt9xx.c

3275 lines
79 KiB
C
Executable File
Raw Blame History

/*
* Goodix GT9xx touchscreen driver
*
* Copyright (C) 2010 - 2014 Goodix. Ltd.
*
* 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
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be a reference
* to you, when you are integrating the GOODiX's CTP IC into your system,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* Version: 2.4
* Release Date: 2014/11/28
*/
#include <linux/irq.h>
#include "gt9xx.h"
#if GTP_ICS_SLOT_REPORT
#include <linux/input/mt.h>
#endif
struct gtp_config_custom {
int gtp_resolution_x;
int gtp_resolution_y;
int gtp_change_x2y;
int gtp_overturn_x;
int gtp_overturn_y;
int gtp_send_cfgs;
int gtp_int_tarigger;
int gtp_touch_back;
int gtp_touch_wakeup;
};
struct gtp_config_custom *gtp_config;
static const char *goodix_ts_name = "goodix-ts";
static const char *goodix_input_phys = "input/ts";
static struct workqueue_struct *goodix_wq;
struct i2c_client *i2c_connect_client = NULL;
int gtp_rst_gpio;
int gtp_int_gpio;
//add by rpdzkj
static int point_0_x = -1; //first touch point x coordinate
static int point_1_x = -1; //second touch point x coordinate
//add end
u8 config[GTP_CONFIG_MAX_LENGTH + GTP_ADDR_LENGTH] = {
GTP_REG_CONFIG_DATA >> 8, GTP_REG_CONFIG_DATA & 0xff
};
#if GTP_HAVE_TOUCH_KEY
static const u16 touch_key_array[] = GTP_KEY_TAB;
#define GTP_MAX_KEY_NUM (sizeof(touch_key_array) / sizeof(touch_key_array[0]))
#if GTP_DEBUG_ON
static const int key_codes[] = { KEY_HOME, KEY_BACK, KEY_MENU, KEY_SEARCH };
static const char *key_names[] = { "Key_Home", "Key_Back", "Key_Menu",
"Key_Search" };
#endif
#endif
static s8 gtp_i2c_test(struct i2c_client *client);
void gtp_reset_guitar(struct i2c_client *client, s32 ms);
s32 gtp_send_cfg(struct i2c_client *client);
void gtp_int_sync(s32 ms);
static ssize_t gt91xx_config_read_proc(struct file *, char __user *, size_t,
loff_t *);
static ssize_t gt91xx_config_write_proc(struct file *, const char __user *,
size_t, loff_t *);
static ssize_t gt91xx_overturn_x_read_proc(struct file *file, char *buffer,size_t count, loff_t *data);
static ssize_t gt91xx_overturn_x_write_proc(struct file *file, const char *buffer,size_t count, loff_t *data);//add by rpdzkj
static ssize_t gt91xx_overturn_y_read_proc(struct file *file, char *buffer,size_t count, loff_t *data);
static ssize_t gt91xx_overturn_y_write_proc(struct file *file, const char *buffer,size_t count, loff_t *data);//add by rpdzkj
static struct proc_dir_entry *gt91xx_config_proc = NULL;
static const struct proc_ops config_proc_ops = {
.proc_read = gt91xx_config_read_proc,
.proc_write = gt91xx_config_write_proc,
};
static const struct proc_ops overturn_x_proc_ops = {
.proc_read = gt91xx_overturn_x_read_proc,
.proc_write = gt91xx_overturn_x_write_proc,
};//add by rpdzkj
static const struct proc_ops overturn_y_proc_ops = {
.proc_read = gt91xx_overturn_y_read_proc,
.proc_write = gt91xx_overturn_y_write_proc,
};//add by rpdzkj
static int gtp_register_powermanger(struct goodix_ts_data *ts);
static int gtp_unregister_powermanger(struct goodix_ts_data *ts);
#if GTP_CREATE_WR_NODE
extern s32 init_wr_node(struct i2c_client *);
extern void uninit_wr_node(void);
#endif
#if GTP_AUTO_UPDATE
extern u8 gup_init_update_proc(struct goodix_ts_data *);
#endif
#if GTP_ESD_PROTECT
static struct delayed_work gtp_esd_check_work;
static struct workqueue_struct *gtp_esd_check_workqueue = NULL;
static void gtp_esd_check_func(struct work_struct *);
static s32 gtp_init_ext_watchdog(struct i2c_client *client);
void gtp_esd_switch(struct i2c_client *, s32);
#endif
//*********** For GT9XXF Start **********//
#if GTP_COMPATIBLE_MODE
extern s32 i2c_read_bytes(struct i2c_client *client, u16 addr, u8 *buf,
s32 len);
extern s32 i2c_write_bytes(struct i2c_client *client, u16 addr, u8 *buf,
s32 len);
extern s32 gup_clk_calibration(void);
extern s32 gup_fw_download_proc(void *dir, u8 dwn_mode);
extern u8 gup_check_fs_mounted(char *path_name);
void gtp_recovery_reset(struct i2c_client *client);
static s32 gtp_esd_recovery(struct i2c_client *client);
s32 gtp_fw_startup(struct i2c_client *client);
static s32 gtp_main_clk_proc(struct goodix_ts_data *ts);
static s32 gtp_bak_ref_proc(struct goodix_ts_data *ts, u8 mode);
#endif
//********** For GT9XXF End **********//
#if GTP_GESTURE_WAKEUP
typedef enum {
DOZE_DISABLED = 0,
DOZE_ENABLED = 1,
DOZE_WAKEUP = 2,
} DOZE_T;
static DOZE_T doze_status = DOZE_DISABLED;
static s8 gtp_enter_doze(struct goodix_ts_data *ts);
#endif
#ifdef GTP_CONFIG_OF
int gtp_parse_dt_cfg(struct device *dev, u8 *cfg, int *cfg_len, u8 sid);
#endif
/*******************************************************
Function:
Read data from the i2c slave device.
Input:
client: i2c device.
buf[0~1]: read start address.
buf[2~len-1]: read data buffer.
len: GTP_ADDR_LENGTH + read bytes count
Output:
numbers of i2c_msgs to transfer:
2: succeed, otherwise: failed
*********************************************************/
s32 gtp_i2c_read(struct i2c_client *client, u8 *buf, s32 len)
{
struct i2c_msg msgs[2];
s32 ret = -1;
s32 retries = 0;
GTP_DEBUG_FUNC();
msgs[0].flags = !I2C_M_RD;
msgs[0].addr = client->addr;
msgs[0].len = GTP_ADDR_LENGTH;
msgs[0].buf = &buf[0];
// msgs[0].scl_rate = 300 * 1000; // for Rockchip, etc.
msgs[1].flags = I2C_M_RD;
msgs[1].addr = client->addr;
msgs[1].len = len - GTP_ADDR_LENGTH;
msgs[1].buf = &buf[GTP_ADDR_LENGTH];
// msgs[1].scl_rate = 300 * 1000;
while (retries < 5) {
ret = i2c_transfer(client->adapter, msgs, 2);
if (ret == 2)
break;
retries++;
}
if ((retries >= 5)) {
#if GTP_COMPATIBLE_MODE
struct goodix_ts_data *ts = i2c_get_clientdata(client);
#endif
#if GTP_GESTURE_WAKEUP
// reset chip would quit doze mode
if (DOZE_ENABLED == doze_status) {
return ret;
}
#endif
GTP_ERROR(
"I2C Read: 0x%04X, %d bytes failed, errcode: %d! Process reset.",
(((u16)(buf[0] << 8)) | buf[1]), len - 2, ret);
#if GTP_COMPATIBLE_MODE
if (CHIP_TYPE_GT9F == ts->chip_type) {
gtp_recovery_reset(client);
} else
#endif
{
gtp_reset_guitar(client, 10);
}
}
return ret;
}
/*******************************************************
Function:
Write data to the i2c slave device.
Input:
client: i2c device.
buf[0~1]: write start address.
buf[2~len-1]: data buffer
len: GTP_ADDR_LENGTH + write bytes count
Output:
numbers of i2c_msgs to transfer:
1: succeed, otherwise: failed
*********************************************************/
s32 gtp_i2c_write(struct i2c_client *client, u8 *buf, s32 len)
{
struct i2c_msg msg;
s32 ret = -1;
s32 retries = 0;
GTP_DEBUG_FUNC();
msg.flags = !I2C_M_RD;
msg.addr = client->addr;
msg.len = len;
msg.buf = buf;
// msg.scl_rate = 300 * 1000; // for Rockchip, etc
while (retries < 5) {
ret = i2c_transfer(client->adapter, &msg, 1);
if (ret == 1)
break;
retries++;
}
if ((retries >= 5)) {
#if GTP_COMPATIBLE_MODE
struct goodix_ts_data *ts = i2c_get_clientdata(client);
#endif
#if GTP_GESTURE_WAKEUP
if (DOZE_ENABLED == doze_status) {
return ret;
}
#endif
GTP_ERROR(
"I2C Write: 0x%04X, %d bytes failed, errcode: %d! Process reset.",
(((u16)(buf[0] << 8)) | buf[1]), len - 2, ret);
#if GTP_COMPATIBLE_MODE
if (CHIP_TYPE_GT9F == ts->chip_type) {
gtp_recovery_reset(client);
} else
#endif
{
gtp_reset_guitar(client, 10);
}
}
return ret;
}
/*******************************************************
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)) {
memcpy(rxbuf, confirm_buf + 2, len);
return SUCCESS;
}
}
GTP_ERROR("I2C read 0x%04X, %d bytes, double check failed!", addr, len);
return FAIL;
}
/*******************************************************
Function:
Send config.
Input:
client: i2c device.
Output:
result of i2c write operation.
1: succeed, otherwise: failed
*********************************************************/
s32 gtp_send_cfg(struct i2c_client *client)
{
s32 ret = 2;
if (gtp_config->gtp_send_cfgs == 1) {
s32 retry = 0;
struct goodix_ts_data *ts = i2c_get_clientdata(client);
if (ts->pnl_init_error) {
GTP_INFO("Error occured in init_panel, no config sent");
return 0;
}
GTP_INFO("Driver send config.");
for (retry = 0; retry < 5; retry++) {
ret = gtp_i2c_write(client, config,
GTP_CONFIG_MAX_LENGTH +
GTP_ADDR_LENGTH);
if (ret > 0) {
break;
}
}
}
return ret;
}
/*******************************************************
Function:
Disable irq function
Input:
ts: goodix i2c_client private data
Output:
None.
*********************************************************/
void gtp_irq_disable(struct goodix_ts_data *ts)
{
unsigned long irqflags;
GTP_DEBUG_FUNC();
spin_lock_irqsave(&ts->irq_lock, irqflags);
if (!ts->irq_is_disable) {
ts->irq_is_disable = 1;
disable_irq_nosync(ts->client->irq);
}
spin_unlock_irqrestore(&ts->irq_lock, irqflags);
}
/*******************************************************
Function:
Enable irq function
Input:
ts: goodix i2c_client private data
Output:
None.
*********************************************************/
void gtp_irq_enable(struct goodix_ts_data *ts)
{
unsigned long irqflags = 0;
GTP_DEBUG_FUNC();
spin_lock_irqsave(&ts->irq_lock, irqflags);
if (ts->irq_is_disable) {
enable_irq(ts->client->irq);
ts->irq_is_disable = 0;
}
spin_unlock_irqrestore(&ts->irq_lock, irqflags);
}
long int touch_wakeup_timeVal = 0;
long int touch_wakeup_time_gt9xx(void)
{
struct timespec64 tm;
ktime_get_coarse_real_ts64(&tm);
return tm.tv_sec;
}
/*******************************************************
Function:
kernel time difference absolut function
Input:
ts:Value
Output:
ts:kernel time difference absolut
*********************************************************/
long int time_difference_absolute_gt9xx(long int time_val)
{
long time_temp = 0;
time_temp = touch_wakeup_time_gt9xx() - time_val;
if (time_temp < 0)
time_temp = time_temp * (-1);
return time_temp;
}
static void touch_back(struct goodix_ts_data *ts, s32 id, s32 x, s32 y)
{
const char *rotation;
int min_touch_back = (ts->abs_x_max * 2) / 5;
int max_toch_back = (ts->abs_x_max * 3) / 5;
int x_abs = 0;
struct device_node *node;
node = of_find_node_by_path("/rpdzkj_config");
//for system rotation
if (of_property_read_string(node, "system_rotate", &rotation) == 0) {
if (strcmp("90", rotation) == 0 || strcmp("270", rotation) == 0) {
min_touch_back = (ts->abs_y_max * 2) / 5;
max_toch_back = (ts->abs_y_max * 3) / 5;
if (y < 30 || y > ts->abs_y_max - 30) {
point_0_x = y;
point_1_x = 0;
} else {
point_1_x = y;
}
} else {
if (x < 30 || x > ts->abs_x_max - 30) {
point_0_x = x;
point_1_x = 0;
} else {
point_1_x = x;
}
}
} else {
if (x < 30 || x > ts->abs_x_max - 30) {
point_0_x = x;
point_1_x = 0;
} else {
point_1_x = x;
}
}
//printk("rotation:%s, point_0_x:%d, point_1_x:%d\n", rotation, point_0_x, point_1_x);
//nothing todo
if (point_0_x == -1)
return;
x_abs = abs(point_0_x - point_1_x);
if ((x_abs > min_touch_back) && (x_abs < max_toch_back)) {
input_report_key(ts->input_dev, KEY_BACK, 1);
input_sync(ts->input_dev);
input_report_key(ts->input_dev, KEY_BACK, 0);
input_sync(ts->input_dev);
point_0_x = -1;
point_1_x = -1;
}
};
/*******************************************************
Function:
Report touch point event
Input:
ts: goodix i2c_client private data
id: trackId
x: input x coordinate
y: input y coordinate
w: input pressure
Output:
None.
*********************************************************/
static void gtp_touch_down(struct goodix_ts_data *ts, s32 id, s32 x, s32 y,
s32 w)
{
if (gtp_config->gtp_change_x2y == 1) {
GTP_SWAP(x, y);
//add else branch to deal change x/y and onverturn the same time
if (gtp_config->gtp_overturn_x == 1) {
x = gtp_config->gtp_resolution_y - x;
}
if (gtp_config->gtp_overturn_y == 1) {
y = gtp_config->gtp_resolution_x - y;
}
} else {
if (gtp_config->gtp_overturn_x == 1) {
x = gtp_config->gtp_resolution_x - x;
}
if (gtp_config->gtp_overturn_y == 1) {
y = gtp_config->gtp_resolution_y - y;
}
} //end add 20200422
//add by rpdzkj
if (gtp_config->gtp_touch_back == 1) {
touch_back(ts, id, x, y);
}
if (gtp_config->gtp_touch_wakeup == 1) {
if (ts->gtp_is_suspend != 0) {
touch_wakeup_timeVal =
touch_wakeup_time_gt9xx(); //touch lcd wakeup start time;
}
if ((0 == ts->gtp_is_suspend) &&
(time_difference_absolute_gt9xx(touch_wakeup_timeVal) >
1)) {
#if GTP_ICS_SLOT_REPORT
input_mt_slot(ts->input_dev, id);
input_report_abs(ts->input_dev, ABS_MT_TRACKING_ID, id);
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);
#else
input_report_key(ts->input_dev, BTN_TOUCH, 1);
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);
#endif
touch_wakeup_timeVal = 0;
} else if (1 == ts->gtp_is_suspend) {
input_event(ts->input_dev, EV_KEY, KEY_POWER, 1);
input_event(ts->input_dev, EV_KEY, KEY_POWER, 0);
input_sync(ts->input_dev);
ts->gtp_is_suspend = 2;
} else {
}
} else {
#if GTP_ICS_SLOT_REPORT
input_mt_slot(ts->input_dev, id);
input_report_abs(ts->input_dev, ABS_MT_TRACKING_ID, id);
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);
#else
input_report_key(ts->input_dev, BTN_TOUCH, 1);
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);
#endif
}
GTP_DEBUG("ID:%d, X:%d, Y:%d, W:%d", id, x, y, w);
// printk("ID:%d, X:%d, Y:%d, W:%d\n", id, x, y, w);
}
/*******************************************************
Function:
Report touch release event
Input:
ts: goodix i2c_client private data
Output:
None.
*********************************************************/
static void gtp_touch_up(struct goodix_ts_data *ts, s32 id)
{
#if GTP_ICS_SLOT_REPORT
input_mt_slot(ts->input_dev, id);
input_report_abs(ts->input_dev, ABS_MT_TRACKING_ID, -1);
GTP_DEBUG("Touch id[%2d] release!", id);
#else
input_report_key(ts->input_dev, BTN_TOUCH, 0);
#endif
}
#if GTP_WITH_PEN
static void gtp_pen_init(struct goodix_ts_data *ts)
{
s32 ret = 0;
GTP_INFO("Request input device for pen/stylus.");
ts->pen_dev = input_allocate_device();
if (ts->pen_dev == NULL) {
GTP_ERROR("Failed to allocate input device for pen/stylus.");
return;
}
ts->pen_dev->evbit[0] =
BIT_MASK(EV_SYN) | BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
#if GTP_ICS_SLOT_REPORT
input_mt_init_slots(ts->pen_dev, 16, 0); //
#else
ts->pen_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
#endif
set_bit(BTN_TOOL_PEN, ts->pen_dev->keybit);
set_bit(INPUT_PROP_DIRECT, ts->pen_dev->propbit);
//set_bit(INPUT_PROP_POINTER, ts->pen_dev->propbit);
#if GTP_PEN_HAVE_BUTTON
input_set_capability(ts->pen_dev, EV_KEY, BTN_STYLUS);
input_set_capability(ts->pen_dev, EV_KEY, BTN_STYLUS2);
#endif
input_set_abs_params(ts->pen_dev, ABS_MT_POSITION_X, 0, ts->abs_x_max,
0, 0);
input_set_abs_params(ts->pen_dev, ABS_MT_POSITION_Y, 0, ts->abs_y_max,
0, 0);
input_set_abs_params(ts->pen_dev, ABS_MT_PRESSURE, 0, 255, 0, 0);
input_set_abs_params(ts->pen_dev, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
input_set_abs_params(ts->pen_dev, ABS_MT_TRACKING_ID, 0, 255, 0, 0);
ts->pen_dev->name = "goodix-pen";
ts->pen_dev->id.bustype = BUS_I2C;
ret = input_register_device(ts->pen_dev);
if (ret) {
GTP_ERROR("Register %s input device failed", ts->pen_dev->name);
return;
}
}
static void gtp_pen_down(s32 x, s32 y, s32 w, s32 id)
{
struct goodix_ts_data *ts = i2c_get_clientdata(i2c_connect_client);
if (gtp_config->gtp_change_x2y == 1) {
GTP_SWAP(x, y);
}
input_report_key(ts->pen_dev, BTN_TOOL_PEN, 1);
#if GTP_ICS_SLOT_REPORT
input_mt_slot(ts->pen_dev, id);
input_report_abs(ts->pen_dev, ABS_MT_TRACKING_ID, id);
input_report_abs(ts->pen_dev, ABS_MT_POSITION_X, x);
input_report_abs(ts->pen_dev, ABS_MT_POSITION_Y, y);
input_report_abs(ts->pen_dev, ABS_MT_PRESSURE, w);
input_report_abs(ts->pen_dev, ABS_MT_TOUCH_MAJOR, w);
#else
input_report_key(ts->pen_dev, BTN_TOUCH, 1);
input_report_abs(ts->pen_dev, ABS_MT_POSITION_X, x);
input_report_abs(ts->pen_dev, ABS_MT_POSITION_Y, y);
input_report_abs(ts->pen_dev, ABS_MT_PRESSURE, w);
input_report_abs(ts->pen_dev, ABS_MT_TOUCH_MAJOR, w);
input_report_abs(ts->pen_dev, ABS_MT_TRACKING_ID, id);
input_mt_sync(ts->pen_dev);
#endif
GTP_DEBUG("(%d)(%d, %d)[%d]", id, x, y, w);
}
static void gtp_pen_up(s32 id)
{
struct goodix_ts_data *ts = i2c_get_clientdata(i2c_connect_client);
input_report_key(ts->pen_dev, BTN_TOOL_PEN, 0);
#if GTP_ICS_SLOT_REPORT
input_mt_slot(ts->pen_dev, id);
input_report_abs(ts->pen_dev, ABS_MT_TRACKING_ID, -1);
#else
input_report_key(ts->pen_dev, BTN_TOUCH, 0);
#endif
}
#endif
/*******************************************************
Function:
Goodix touchscreen work function
Input:
work: work struct of goodix_workqueue
Output:
None.
*********************************************************/
static void goodix_ts_work_func(struct work_struct *work)
{
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;
static u16 pre_touch = 0;
static u8 pre_key = 0;
#if GTP_WITH_PEN
u8 pen_active = 0;
static u8 pre_pen = 0;
#endif
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 = 0;
s32 ret = -1;
struct goodix_ts_data *ts = NULL;
#if GTP_COMPATIBLE_MODE
u8 rqst_buf[3] = { 0x80, 0x43 }; // for GT9XXF
#endif
#if GTP_GESTURE_WAKEUP
u8 doze_buf[3] = { 0x81, 0x4B };
#endif
GTP_DEBUG_FUNC();
ts = container_of(work, struct goodix_ts_data, work);
if (ts->enter_update) {
return;
}
#if GTP_GESTURE_WAKEUP
if (DOZE_ENABLED == doze_status) {
ret = gtp_i2c_read(i2c_connect_client, doze_buf, 3);
GTP_DEBUG("0x814B = 0x%02X", doze_buf[2]);
if (ret > 0) {
if ((doze_buf[2] == 'a') || (doze_buf[2] == 'b') ||
(doze_buf[2] == 'c') || (doze_buf[2] == 'd') ||
(doze_buf[2] == 'e') || (doze_buf[2] == 'g') ||
(doze_buf[2] == 'h') || (doze_buf[2] == 'm') ||
(doze_buf[2] == 'o') || (doze_buf[2] == 'q') ||
(doze_buf[2] == 's') || (doze_buf[2] == 'v') ||
(doze_buf[2] == 'w') || (doze_buf[2] == 'y') ||
(doze_buf[2] == 'z') ||
(doze_buf[2] == 0x5E) /* ^ */
) {
if (doze_buf[2] != 0x5E) {
GTP_INFO(
"Wakeup by gesture(%c), light up the screen!",
doze_buf[2]);
} else {
GTP_INFO(
"Wakeup by gesture(^), light up the screen!");
}
doze_status = DOZE_WAKEUP;
input_report_key(ts->input_dev, KEY_POWER, 1);
input_sync(ts->input_dev);
input_report_key(ts->input_dev, KEY_POWER, 0);
input_sync(ts->input_dev);
// clear 0x814B
doze_buf[2] = 0x00;
gtp_i2c_write(i2c_connect_client, doze_buf, 3);
} else if ((doze_buf[2] == 0xAA) ||
(doze_buf[2] == 0xBB) ||
(doze_buf[2] == 0xAB) ||
(doze_buf[2] == 0xBA)) {
char *direction[4] = { "Right", "Down", "Up",
"Left" };
u8 type = ((doze_buf[2] & 0x0F) - 0x0A) +
(((doze_buf[2] >> 4) & 0x0F) - 0x0A) *
2;
GTP_INFO("%s slide to light up the screen!",
direction[type]);
doze_status = DOZE_WAKEUP;
input_report_key(ts->input_dev, KEY_POWER, 1);
input_sync(ts->input_dev);
input_report_key(ts->input_dev, KEY_POWER, 0);
input_sync(ts->input_dev);
// clear 0x814B
doze_buf[2] = 0x00;
gtp_i2c_write(i2c_connect_client, doze_buf, 3);
} else if (0xCC == doze_buf[2]) {
GTP_INFO(
"Double click to light up the screen!");
doze_status = DOZE_WAKEUP;
input_report_key(ts->input_dev, KEY_POWER, 1);
input_sync(ts->input_dev);
input_report_key(ts->input_dev, KEY_POWER, 0);
input_sync(ts->input_dev);
// clear 0x814B
doze_buf[2] = 0x00;
gtp_i2c_write(i2c_connect_client, doze_buf, 3);
} else {
// clear 0x814B
doze_buf[2] = 0x00;
gtp_i2c_write(i2c_connect_client, doze_buf, 3);
gtp_enter_doze(ts);
}
}
if (ts->use_irq) {
gtp_irq_enable(ts);
}
return;
}
#endif
ret = gtp_i2c_read(ts->client, point_data, 12);
if (ret < 0) {
GTP_ERROR("I2C transfer error. errno:%d\n ", ret);
if (ts->use_irq) {
gtp_irq_enable(ts);
}
return;
}
finger = point_data[GTP_ADDR_LENGTH];
#if GTP_COMPATIBLE_MODE
// GT9XXF reques event
if ((finger == 0x00) &&
(CHIP_TYPE_GT9F == ts->chip_type)) // request arrived
{
ret = gtp_i2c_read(ts->client, rqst_buf, 3);
if (ret < 0) {
GTP_ERROR("Read request status error!");
goto exit_work_func;
}
switch (rqst_buf[2]) {
case GTP_RQST_CONFIG:
GTP_INFO("Request for config.");
ret = gtp_send_cfg(ts->client);
if (ret < 0) {
GTP_ERROR("Request for config unresponded!");
} else {
rqst_buf[2] = GTP_RQST_RESPONDED;
gtp_i2c_write(ts->client, rqst_buf, 3);
GTP_INFO("Request for config responded!");
}
break;
case GTP_RQST_BAK_REF:
GTP_INFO("Request for backup reference.");
ts->rqst_processing = 1;
ret = gtp_bak_ref_proc(ts, GTP_BAK_REF_SEND);
if (SUCCESS == ret) {
rqst_buf[2] = GTP_RQST_RESPONDED;
gtp_i2c_write(ts->client, rqst_buf, 3);
ts->rqst_processing = 0;
GTP_INFO(
"Request for backup reference responded!");
} else {
GTP_ERROR(
"Requeset for backup reference unresponed!");
}
break;
case GTP_RQST_RESET:
GTP_INFO("Request for reset.");
gtp_recovery_reset(ts->client);
break;
case GTP_RQST_MAIN_CLOCK:
GTP_INFO("Request for main clock.");
ts->rqst_processing = 1;
ret = gtp_main_clk_proc(ts);
if (FAIL == ret) {
GTP_ERROR(
"Request for main clock unresponded!");
} else {
GTP_INFO("Request for main clock responded!");
rqst_buf[2] = GTP_RQST_RESPONDED;
gtp_i2c_write(ts->client, rqst_buf, 3);
ts->rqst_processing = 0;
ts->clk_chk_fs_times = 0;
}
break;
default:
GTP_INFO("Undefined request: 0x%02X", rqst_buf[2]);
rqst_buf[2] = GTP_RQST_RESPONDED;
gtp_i2c_write(ts->client, rqst_buf, 3);
break;
}
}
#endif
if (finger == 0x00) {
if (ts->use_irq) {
gtp_irq_enable(ts);
}
return;
}
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 || GTP_PEN_HAVE_BUTTON)
key_value = point_data[3 + 8 * touch_num];
if (key_value || pre_key) {
#if GTP_PEN_HAVE_BUTTON
if (key_value == 0x40) {
GTP_DEBUG("BTN_STYLUS & BTN_STYLUS2 Down.");
input_report_key(ts->pen_dev, BTN_STYLUS, 1);
input_report_key(ts->pen_dev, BTN_STYLUS2, 1);
pen_active = 1;
} else if (key_value == 0x10) {
GTP_DEBUG("BTN_STYLUS Down, BTN_STYLUS2 Up.");
input_report_key(ts->pen_dev, BTN_STYLUS, 1);
input_report_key(ts->pen_dev, BTN_STYLUS2, 0);
pen_active = 1;
} else if (key_value == 0x20) {
GTP_DEBUG("BTN_STYLUS Up, BTN_STYLUS2 Down.");
input_report_key(ts->pen_dev, BTN_STYLUS, 0);
input_report_key(ts->pen_dev, BTN_STYLUS2, 1);
pen_active = 1;
} else {
GTP_DEBUG("BTN_STYLUS & BTN_STYLUS2 Up.");
input_report_key(ts->pen_dev, BTN_STYLUS, 0);
input_report_key(ts->pen_dev, BTN_STYLUS2, 0);
if ((pre_key == 0x40) || (pre_key == 0x20) ||
(pre_key == 0x10)) {
pen_active = 1;
}
}
if (pen_active) {
touch_num = 0; // shield pen point
//pre_touch = 0; // clear last pen status
}
#endif
#if GTP_HAVE_TOUCH_KEY
if (!pre_touch) {
for (i = 0; i < GTP_MAX_KEY_NUM; i++) {
#if GTP_DEBUG_ON
for (ret = 0; ret < 4; ++ret) {
if (key_codes[ret] ==
touch_key_array[i]) {
GTP_DEBUG("Key: %s %s",
key_names[ret],
(key_value &
(0x01 << i)) ?
"Down" :
"Up");
break;
}
}
#endif
input_report_key(ts->input_dev,
touch_key_array[i],
key_value & (0x01 << i));
}
touch_num = 0; // shield fingers
}
#endif
}
#endif
pre_key = key_value;
//GTP_DEBUG("pre_touch:%02x, finger:%02x.", pre_touch, finger);
#if GTP_ICS_SLOT_REPORT
#if GTP_WITH_PEN
if (pre_pen && (touch_num == 0)) {
GTP_DEBUG("Pen touch UP(Slot)!");
gtp_pen_up(0);
pen_active = 1;
pre_pen = 0;
}
#endif
if (pre_touch || touch_num) {
s32 pos = 0;
u16 touch_index = 0;
u8 report_num = 0;
coor_data = &point_data[3];
if (touch_num) {
id = coor_data[pos] & 0x0F;
#if GTP_WITH_PEN
id = coor_data[pos];
if ((id & 0x80)) {
GTP_DEBUG("Pen touch DOWN(Slot)!");
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_pen_down(input_x, input_y, input_w, 0);
pre_pen = 1;
pre_touch = 0;
pen_active = 1;
}
#endif
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 GTP_WITH_PEN
if (pre_pen == 1) {
break;
}
#endif
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;
report_num++;
if (report_num < touch_num) {
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);
#if GTP_WITH_PEN
id = coor_data[0];
if (id & 0x80) {
GTP_DEBUG("Pen touch DOWN!");
gtp_pen_down(input_x, input_y, input_w, 0);
pre_pen = 1;
pen_active = 1;
break;
} else
#endif
{
gtp_touch_down(ts, id, input_x, input_y,
input_w);
}
}
} else if (pre_touch) {
#if GTP_WITH_PEN
if (pre_pen == 1) {
GTP_DEBUG("Pen touch UP!");
gtp_pen_up(0);
pre_pen = 0;
pen_active = 1;
} else
#endif
{
GTP_DEBUG("Touch Release!");
gtp_touch_up(ts, 0);
}
}
pre_touch = touch_num;
#endif
#if GTP_WITH_PEN
if (pen_active) {
pen_active = 0;
input_sync(ts->pen_dev);
} else
#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_INFO("I2C write end_cmd error!");
}
}
if (ts->use_irq) {
gtp_irq_enable(ts);
}
}
/*******************************************************
Function:
Timer interrupt service routine for polling mode.
Input:
timer: timer struct pointer
Output:
Timer work mode.
HRTIMER_NORESTART: no restart mode
*********************************************************/
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;
}
/*******************************************************
Function:
External interrupt service routine for interrupt mode.
Input:
irq: interrupt number.
dev_id: private data pointer
Output:
Handle Result.
IRQ_HANDLED: interrupt handled successfully
*********************************************************/
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;
}
/*******************************************************
Function:
Synchronization.
Input:
ms: synchronization time in millisecond.
Output:
None.
*******************************************************/
void gtp_int_sync(s32 ms)
{
GTP_GPIO_OUTPUT(gtp_int_gpio, 0);
msleep(ms);
GTP_GPIO_AS_INT(gtp_int_gpio);
}
/*******************************************************
Function:
Reset chip.
Input:
ms: reset time in millisecond
Output:
None.
*******************************************************/
void gtp_reset_guitar(struct i2c_client *client, s32 ms)
{
#if GTP_COMPATIBLE_MODE
struct goodix_ts_data *ts = i2c_get_clientdata(client);
#endif
GTP_DEBUG_FUNC();
GTP_INFO("Guitar reset");
GTP_GPIO_OUTPUT(gtp_rst_gpio, 0); // begin select I2C slave addr
msleep(ms); // T2: > 10ms
// HIGH: 0x28/0x29, LOW: 0xBA/0xBB
GTP_GPIO_OUTPUT(gtp_int_gpio, client->addr == 0x14);
msleep(2); // T3: > 100us
GTP_GPIO_OUTPUT(gtp_rst_gpio, 1);
msleep(6); // T4: > 5ms
GTP_GPIO_AS_INPUT(gtp_rst_gpio); // end select I2C slave addr
#if GTP_COMPATIBLE_MODE
if (CHIP_TYPE_GT9F == ts->chip_type) {
return;
}
#endif
gtp_int_sync(50);
#if GTP_ESD_PROTECT
gtp_init_ext_watchdog(client);
#endif
}
#if GTP_GESTURE_WAKEUP
/*******************************************************
Function:
Enter doze mode for sliding wakeup.
Input:
ts: goodix tp private data
Output:
1: succeed, otherwise failed
*******************************************************/
static s8 gtp_enter_doze(struct goodix_ts_data *ts)
{
s8 ret = -1;
s8 retry = 0;
u8 i2c_control_buf[3] = { (u8)(GTP_REG_SLEEP >> 8), (u8)GTP_REG_SLEEP,
8 };
GTP_DEBUG_FUNC();
GTP_DEBUG("Entering gesture mode.");
while (retry++ < 5) {
i2c_control_buf[0] = 0x80;
i2c_control_buf[1] = 0x46;
ret = gtp_i2c_write(ts->client, i2c_control_buf, 3);
if (ret < 0) {
GTP_DEBUG("failed to set doze flag into 0x8046, %d",
retry);
continue;
}
i2c_control_buf[0] = 0x80;
i2c_control_buf[1] = 0x40;
ret = gtp_i2c_write(ts->client, i2c_control_buf, 3);
if (ret > 0) {
doze_status = DOZE_ENABLED;
GTP_INFO("Gesture mode enabled.");
return ret;
}
msleep(10);
}
GTP_ERROR("GTP send gesture cmd failed.");
return ret;
}
#else
/*******************************************************
Function:
Enter sleep mode.
Input:
ts: private data.
Output:
Executive outcomes.
1: succeed, otherwise failed.
*******************************************************/
static s8 gtp_enter_sleep(struct goodix_ts_data *ts)
{
s8 ret = -1;
s8 retry = 0;
u8 i2c_control_buf[3] = { (u8)(GTP_REG_SLEEP >> 8), (u8)GTP_REG_SLEEP,
5 };
#if GTP_COMPATIBLE_MODE
u8 status_buf[3] = { 0x80, 0x44 };
#endif
GTP_DEBUG_FUNC();
#if GTP_COMPATIBLE_MODE
if (CHIP_TYPE_GT9F == ts->chip_type) {
// GT9XXF: host interact with ic
ret = gtp_i2c_read(ts->client, status_buf, 3);
if (ret < 0) {
GTP_ERROR("failed to get backup-reference status");
}
if (status_buf[2] & 0x80) {
ret = gtp_bak_ref_proc(ts, GTP_BAK_REF_STORE);
if (FAIL == ret) {
GTP_ERROR("failed to store bak_ref");
}
}
}
#endif
GTP_GPIO_OUTPUT(gtp_int_gpio, 0);
msleep(5);
while (retry++ < 5) {
ret = gtp_i2c_write(ts->client, i2c_control_buf, 3);
if (ret > 0) {
GTP_INFO("GTP enter sleep!");
return ret;
}
msleep(10);
}
GTP_ERROR("GTP send sleep cmd failed.");
return ret;
}
#endif
/*******************************************************
Function:
Wakeup from sleep.
Input:
ts: private data.
Output:
Executive outcomes.
>0: succeed, otherwise: failed.
*******************************************************/
static s8 gtp_wakeup_sleep(struct goodix_ts_data *ts)
{
u8 retry = 0;
s8 ret = -1;
GTP_DEBUG_FUNC();
#if GTP_COMPATIBLE_MODE
if (CHIP_TYPE_GT9F == ts->chip_type) {
u8 opr_buf[3] = { 0x41, 0x80 };
GTP_GPIO_OUTPUT(gtp_int_gpio, 1);
msleep(5);
for (retry = 0; retry < 10; ++retry) {
// hold ss51 & dsp
opr_buf[2] = 0x0C;
ret = gtp_i2c_write(ts->client, opr_buf, 3);
if (FAIL == ret) {
GTP_ERROR("failed to hold ss51 & dsp!");
continue;
}
opr_buf[2] = 0x00;
ret = gtp_i2c_read(ts->client, opr_buf, 3);
if (FAIL == ret) {
GTP_ERROR("failed to get ss51 & dsp status!");
continue;
}
if (0x0C != opr_buf[2]) {
GTP_DEBUG("ss51 & dsp not been hold, %d",
retry + 1);
continue;
}
GTP_DEBUG("ss51 & dsp confirmed hold");
ret = gtp_fw_startup(ts->client);
if (FAIL == ret) {
GTP_ERROR(
"failed to startup GT9XXF, process recovery");
gtp_esd_recovery(ts->client);
}
break;
}
if (retry >= 10) {
GTP_ERROR("failed to wakeup, processing esd recovery");
gtp_esd_recovery(ts->client);
} else {
GTP_INFO("GT9XXF gtp wakeup success");
}
return ret;
}
#endif
#if GTP_POWER_CTRL_SLEEP
while (retry++ < 5) {
gtp_reset_guitar(ts->client, 20);
GTP_INFO("GTP wakeup sleep.");
return 1;
}
#else
while (retry++ < 10) {
#if GTP_GESTURE_WAKEUP
if (DOZE_WAKEUP != doze_status) {
GTP_INFO("Powerkey wakeup.");
} else {
GTP_INFO("Gesture wakeup.");
}
doze_status = DOZE_DISABLED;
gtp_irq_disable(ts);
gtp_reset_guitar(ts->client, 10);
gtp_irq_enable(ts);
#else
GTP_GPIO_OUTPUT(gtp_int_gpio, 1);
msleep(5);
#endif
ret = gtp_i2c_test(ts->client);
if (ret > 0) {
GTP_INFO("GTP wakeup sleep.");
#if (!GTP_GESTURE_WAKEUP)
{
gtp_int_sync(25);
#if GTP_ESD_PROTECT
gtp_init_ext_watchdog(ts->client);
#endif
}
#endif
return ret;
}
gtp_reset_guitar(ts->client, 20);
}
#endif
GTP_ERROR("GTP wakeup sleep failed.");
return ret;
}
/*******************************************************
Function:
Initialize gtp.
Input:
ts: goodix private data
Output:
Executive outcomes.
0: succeed, otherwise: failed
*******************************************************/
static s32 gtp_init_panel(struct goodix_ts_data *ts)
{
s32 ret = -1;
s32 i = 0;
u8 check_sum = 0;
u8 opr_buf[16] = { 0 };
u8 sensor_id = 0;
u8 drv_cfg_version;
u8 flash_cfg_version;
if (gtp_config->gtp_send_cfgs == 1) {
/* if defined CONFIG_OF, parse config data from dtsi
* else parse config data form header file.
*/
#ifndef GTP_CONFIG_OF
//#if (!GTP_CONFIG_OF)
u8 cfg_info_group0[] = CTP_CFG_GROUP0;
u8 cfg_info_group1[] = CTP_CFG_GROUP1;
u8 cfg_info_group2[] = CTP_CFG_GROUP2;
u8 cfg_info_group3[] = CTP_CFG_GROUP3;
u8 cfg_info_group4[] = CTP_CFG_GROUP4;
u8 cfg_info_group5[] = CTP_CFG_GROUP5;
u8 *send_cfg_buf[] = { cfg_info_group0, cfg_info_group1,
cfg_info_group2, cfg_info_group3,
cfg_info_group4, cfg_info_group5 };
u8 cfg_info_len[] = { CFG_GROUP_LEN(cfg_info_group0),
CFG_GROUP_LEN(cfg_info_group1),
CFG_GROUP_LEN(cfg_info_group2),
CFG_GROUP_LEN(cfg_info_group3),
CFG_GROUP_LEN(cfg_info_group4),
CFG_GROUP_LEN(cfg_info_group5) };
GTP_DEBUG("Config Groups\' Lengths: %d, %d, %d, %d, %d, %d",
cfg_info_len[0], cfg_info_len[1], cfg_info_len[2],
cfg_info_len[3], cfg_info_len[4], cfg_info_len[5]);
#endif
#if GTP_COMPATIBLE_MODE
if (CHIP_TYPE_GT9F == ts->chip_type) {
ts->fw_error = 0;
} else
#endif
{ /* check firmware */
ret = gtp_i2c_read_dbl_check(ts->client, 0x41E4,
opr_buf, 1);
if (SUCCESS == ret) {
if (opr_buf[0] != 0xBE) {
ts->fw_error = 1;
GTP_ERROR(
"Firmware error, no config sent!");
return -1;
}
}
}
/* read sensor id */
#if GTP_COMPATIBLE_MODE
msleep(50);
#endif
ret = gtp_i2c_read_dbl_check(ts->client, GTP_REG_SENSOR_ID,
&sensor_id, 1);
if (SUCCESS == ret) {
if (sensor_id >= 0x06) {
GTP_ERROR(
"Invalid sensor_id(0x%02X), No Config Sent!",
sensor_id);
ts->pnl_init_error = 1;
return -1;
}
} else {
GTP_ERROR("Failed to get sensor_id, No config sent!");
ts->pnl_init_error = 1;
return -1;
}
GTP_INFO("Sensor_ID: %d", sensor_id);
/* parse config data*/
#ifdef GTP_CONFIG_OF
//#if GTP_CONFIG_OF
GTP_DEBUG("Get config data from device tree.");
printk("sensor_id = %d\n", sensor_id);
ret = gtp_parse_dt_cfg(&ts->client->dev,
&config[GTP_ADDR_LENGTH],
&ts->gtp_cfg_len, sensor_id);
if (ret < 0) {
GTP_ERROR(
"Failed to parse config data form device tree.");
ts->pnl_init_error = 1;
return -1;
}
#else
GTP_DEBUG("Get config data from header file.");
if ((!cfg_info_len[1]) && (!cfg_info_len[2]) &&
(!cfg_info_len[3]) && (!cfg_info_len[4]) &&
(!cfg_info_len[5])) {
sensor_id = 0;
}
ts->gtp_cfg_len = cfg_info_len[sensor_id];
memset(&config[GTP_ADDR_LENGTH], 0, GTP_CONFIG_MAX_LENGTH);
memcpy(&config[GTP_ADDR_LENGTH], send_cfg_buf[sensor_id],
ts->gtp_cfg_len);
#endif
GTP_INFO("Config group%d used,length: %d", sensor_id,
ts->gtp_cfg_len);
if (ts->gtp_cfg_len < GTP_CONFIG_MIN_LENGTH) {
GTP_ERROR(
"Config Group%d is INVALID CONFIG GROUP(Len: %d)! NO Config Sent! You need to check you header file CFG_GROUP section!",
sensor_id, ts->gtp_cfg_len);
ts->pnl_init_error = 1;
return -1;
}
#if GTP_COMPATIBLE_MODE
if (ts->chip_type != CHIP_TYPE_GT9F)
#endif
{
ret = gtp_i2c_read_dbl_check(ts->client,
GTP_REG_CONFIG_DATA,
&opr_buf[0], 1);
if (ret == SUCCESS) {
GTP_DEBUG(
"Config Version: %d, 0x%02X; IC Config Version: %d, 0x%02X",
config[GTP_ADDR_LENGTH],
config[GTP_ADDR_LENGTH], opr_buf[0],
opr_buf[0]);
flash_cfg_version = opr_buf[0];
drv_cfg_version = config[GTP_ADDR_LENGTH];
config[GTP_ADDR_LENGTH] =
0x00; //modify by rpdzkj jeff
if (flash_cfg_version < 90 &&
flash_cfg_version > drv_cfg_version) {
config[GTP_ADDR_LENGTH] = 0x00;
}
} else {
GTP_ERROR(
"Failed to get ic config version!No config sent!");
return -1;
}
}
#if GTP_CUSTOM_CFG
config[RESOLUTION_LOC] = (u8)gtp_config->gtp_resolution_x;
config[RESOLUTION_LOC + 1] =
(u8)(gtp_config->gtp_resolution_x >> 8);
config[RESOLUTION_LOC + 2] = (u8)gtp_config->gtp_resolution_y;
config[RESOLUTION_LOC + 3] =
(u8)(gtp_config->gtp_resolution_y >> 8);
if (gtp_config->gtp_int_tarigger == 0) //RISING
{
config[TRIGGER_LOC] &= 0xfe;
} else if (gtp_config->gtp_int_tarigger == 1) //FALLING
{
config[TRIGGER_LOC] |= 0x01;
}
#endif // GTP_CUSTOM_CFG
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 {
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(
"Read Config Failed, Using Default Resolution & INT Trigger!");
ts->abs_x_max = gtp_config->gtp_resolution_x;
ts->abs_y_max = gtp_config->gtp_resolution_y;
ts->int_trigger_type = gtp_config->gtp_int_tarigger;
}
}
if ((ts->abs_x_max == 0) && (ts->abs_y_max == 0)) {
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 GTP_COMPATIBLE_MODE
if (CHIP_TYPE_GT9F == ts->chip_type) {
u8 sensor_num = 0;
u8 driver_num = 0;
u8 have_key = 0;
have_key = (config[GTP_REG_HAVE_KEY - GTP_REG_CONFIG_DATA + 2] &
0x01);
if (1 == ts->is_950) {
driver_num = config[GTP_REG_MATRIX_DRVNUM -
GTP_REG_CONFIG_DATA + 2];
sensor_num = config[GTP_REG_MATRIX_SENNUM -
GTP_REG_CONFIG_DATA + 2];
if (have_key) {
driver_num--;
}
ts->bak_ref_len =
(driver_num * (sensor_num - 1) + 2) * 2 * 6;
} else {
driver_num = (config[CFG_LOC_DRVA_NUM] & 0x1F) +
(config[CFG_LOC_DRVB_NUM] & 0x1F);
if (have_key) {
driver_num--;
}
sensor_num = (config[CFG_LOC_SENS_NUM] & 0x0F) +
((config[CFG_LOC_SENS_NUM] >> 4) & 0x0F);
ts->bak_ref_len =
(driver_num * (sensor_num - 2) + 2) * 2;
}
GTP_INFO(
"Drv * Sen: %d * %d(key: %d), X_MAX: %d, Y_MAX: %d, TRIGGER: 0x%02x",
driver_num, sensor_num, have_key, ts->abs_x_max,
ts->abs_y_max, ts->int_trigger_type);
return 0;
} else
#endif
{
if (gtp_config->gtp_send_cfgs == 1) {
ret = gtp_send_cfg(ts->client);
if (ret < 0) {
GTP_ERROR("Send config error.");
}
#if GTP_COMPATIBLE_MODE
if (ts->chip_type != CHIP_TYPE_GT9F)
#endif
{
if (flash_cfg_version < 90 &&
flash_cfg_version > drv_cfg_version) {
check_sum = 0;
config[GTP_ADDR_LENGTH] =
drv_cfg_version;
for (i = GTP_ADDR_LENGTH;
i < ts->gtp_cfg_len; i++) {
check_sum += config[i];
}
config[ts->gtp_cfg_len] =
(~check_sum) + 1;
}
}
}
GTP_INFO("X_MAX: %d, Y_MAX: %d, TRIGGER: 0x%02x", ts->abs_x_max,
ts->abs_y_max, ts->int_trigger_type);
}
msleep(10);
return 0;
}
static ssize_t gt91xx_config_read_proc(struct file *file, char __user *page,
size_t size, loff_t *ppos)
{
char *ptr = page;
char temp_data[GTP_CONFIG_MAX_LENGTH + 2] = { 0x80, 0x47 };
int i;
if (*ppos) {
return 0;
}
ptr += sprintf(ptr, "==== GT9XX config init value====\n");
for (i = 0; i < GTP_CONFIG_MAX_LENGTH; i++) {
ptr += sprintf(ptr, "0x%02X ", config[i + 2]);
if (i % 8 == 7)
ptr += sprintf(ptr, "\n");
}
ptr += sprintf(ptr, "\n");
ptr += sprintf(ptr, "==== GT9XX config real value====\n");
gtp_i2c_read(i2c_connect_client, temp_data, GTP_CONFIG_MAX_LENGTH + 2);
for (i = 0; i < GTP_CONFIG_MAX_LENGTH; i++) {
ptr += sprintf(ptr, "0x%02X ", temp_data[i + 2]);
if (i % 8 == 7)
ptr += sprintf(ptr, "\n");
}
*ppos += ptr - page;
return (ptr - page);
}
static ssize_t gt91xx_config_write_proc(struct file *filp,
const char __user *buffer, size_t count,
loff_t *off)
{
s32 ret = 0;
GTP_DEBUG("write count %lu\n", count);
if (count > GTP_CONFIG_MAX_LENGTH) {
GTP_ERROR("size not match [%d:%lu]\n", GTP_CONFIG_MAX_LENGTH,
count);
return -EFAULT;
}
if (copy_from_user(&config[2], buffer, count)) {
GTP_ERROR("copy from user fail\n");
return -EFAULT;
}
ret = gtp_send_cfg(i2c_connect_client);
if (ret < 0) {
GTP_ERROR("send config failed.");
}
return count;
}
static ssize_t gt91xx_overturn_x_read_proc(struct file *file, char *buffer,size_t count, loff_t *data)
{
int *touch_x2y = &(gtp_config->gtp_overturn_x);
char touch_str[10];
int len;
len = snprintf(touch_str, sizeof(touch_str), "%d\n", *touch_x2y);
touch_str[len] = '\0';
return simple_read_from_buffer(buffer, count, data, touch_str, len);
}
static ssize_t gt91xx_overturn_x_write_proc(struct file *file, const char *buffer,size_t count, loff_t *data)
{
char touch_str[20];
int ret;
ret = copy_from_user(touch_str, buffer, min(count, sizeof(touch_str) - 1));
if (ret < 0) {
return ret;
}
touch_str[count] = '\0';
ret = kstrtoint(touch_str, 10, &(gtp_config->gtp_overturn_x));
if (ret < 0) {
pr_err("Failed to convert input to integer\n");
return ret;
}
return count;
}
static ssize_t gt91xx_overturn_y_read_proc(struct file *file, char *buffer,size_t count, loff_t *data)
{
int *touch_x2y = &(gtp_config->gtp_overturn_y);
char touch_str[10];
int len;
len = snprintf(touch_str, sizeof(touch_str), "%d\n", *touch_x2y);
touch_str[len] = '\0';
return simple_read_from_buffer(buffer, count, data, touch_str, len);
}
static ssize_t gt91xx_overturn_y_write_proc(struct file *file, const char *buffer,size_t count, loff_t *data)
{
char touch_str[20];
int ret;
ret = copy_from_user(touch_str, buffer, min(count, sizeof(touch_str) - 1));
if (ret < 0) {
return ret;
}
touch_str[count] = '\0';
ret = kstrtoint(touch_str, 10, &(gtp_config->gtp_overturn_y));
if (ret < 0) {
pr_err("Failed to convert input to integer\n");
return ret;
}
return count;
}
//Function: get IC frimware.
void get_ICfrimware(void)
{
char tempt_data[GTP_CONFIG_MAX_LENGTH + 2] = { 0x80, 0x47 };
gtp_i2c_read(i2c_connect_client, tempt_data, GTP_CONFIG_MAX_LENGTH + 2);
}
/*******************************************************
Function:
Read chip version.
Input:
client: i2c device
version: buffer to keep ic firmware version
Output:
read operation return.
2: succeed, otherwise: failed
*******************************************************/
s32 gtp_read_version(struct i2c_client *client, u16 *version)
{
s32 ret = -1;
u8 buf[8] = { GTP_REG_VERSION >> 8, GTP_REG_VERSION & 0xff };
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];
}
if (buf[5] == 0x00) {
GTP_INFO("IC Version: %c%c%c_%02x%02x", buf[2], buf[3], buf[4],
buf[7], buf[6]);
} else {
GTP_INFO("IC Version: %c%c%c%c_%02x%02x", buf[2], buf[3],
buf[4], buf[5], buf[7], buf[6]);
}
return ret;
}
/*******************************************************
Function:
I2c test Function.
Input:
client:i2c client.
Output:
Executive outcomes.
2: succeed, otherwise failed.
*******************************************************/
static s8 gtp_i2c_test(struct i2c_client *client)
{
u8 test[3] = { GTP_REG_CONFIG_DATA >> 8, GTP_REG_CONFIG_DATA & 0xff };
u8 retry = 0;
s8 ret = -1;
GTP_DEBUG_FUNC();
while (retry++ < 5) {
ret = gtp_i2c_read(client, test, 3);
if (ret > 0) {
return ret;
}
GTP_ERROR("GTP i2c test failed time %d.", retry);
msleep(10);
}
return ret;
}
/*******************************************************
Function:
Request gpio(INT & RST) ports.
Input:
ts: private data.
Output:
Executive outcomes.
>= 0: succeed, < 0: failed
*******************************************************/
static s8 gtp_request_io_port(struct goodix_ts_data *ts)
{
s32 ret = 0;
GTP_DEBUG_FUNC();
ret = GTP_GPIO_REQUEST(gtp_int_gpio, "GTP INT IRQ");
if (ret < 0) {
GTP_ERROR("Failed to request GPIO:%d, ERRNO:%d",
(s32)gtp_int_gpio, ret);
ret = -ENODEV;
} else {
GTP_GPIO_AS_INT(gtp_int_gpio);
ts->client->irq = gpio_to_irq(gtp_int_gpio);
}
ret = GTP_GPIO_REQUEST(gtp_rst_gpio, "GTP RST PORT");
if (ret < 0) {
GTP_ERROR("Failed to request GPIO:%d, ERRNO:%d",
(s32)gtp_rst_gpio, ret);
ret = -ENODEV;
}
GTP_GPIO_AS_INPUT(gtp_rst_gpio);
gtp_reset_guitar(ts->client, 20);
if (ret < 0) {
GTP_GPIO_FREE(gtp_rst_gpio);
GTP_GPIO_FREE(gtp_int_gpio);
}
return ret;
}
/*******************************************************
Function:
Request interrupt.
Input:
ts: private data.
Output:
Executive outcomes.
0: succeed, -1: failed.
*******************************************************/
static s8 gtp_request_irq(struct goodix_ts_data *ts)
{
s32 ret = -1;
const u8 irq_table[] = GTP_IRQ_TAB;
GTP_DEBUG_FUNC();
GTP_DEBUG("INT trigger type:%x", ts->int_trigger_type);
ret = request_irq(ts->client->irq, goodix_ts_irq_handler,
irq_table[ts->int_trigger_type], ts->client->name,
ts);
if (ret) {
GTP_ERROR("Request IRQ failed!ERRNO:%d.", ret);
GTP_GPIO_AS_INPUT(gtp_int_gpio);
GTP_GPIO_FREE(gtp_int_gpio);
hrtimer_init(&ts->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
ts->timer.function = goodix_ts_timer_handler;
hrtimer_start(&ts->timer, ktime_set(1, 0), HRTIMER_MODE_REL);
return -1;
} else {
gtp_irq_disable(ts);
ts->use_irq = 1;
return 0;
}
}
/*******************************************************
Function:
Request input device Function.
Input:
ts:private data.
Output:
Executive outcomes.
0: succeed, otherwise: failed.
*******************************************************/
static s8 gtp_request_input_dev(struct goodix_ts_data *ts)
{
s8 ret = -1;
#if GTP_HAVE_TOUCH_KEY
u8 index = 0;
#endif
GTP_DEBUG_FUNC();
ts->input_dev = input_allocate_device();
if (ts->input_dev == NULL) {
GTP_ERROR("Failed to allocate input device.");
return -ENOMEM;
}
ts->input_dev->evbit[0] =
BIT_MASK(EV_SYN) | BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
#if GTP_ICS_SLOT_REPORT
input_mt_init_slots(ts->input_dev, 16, 0); // in case of "out of memory"
#else
ts->input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
#endif
__set_bit(INPUT_PROP_DIRECT, ts->input_dev->propbit);
#if GTP_HAVE_TOUCH_KEY
for (index = 0; index < GTP_MAX_KEY_NUM; index++) {
input_set_capability(ts->input_dev, EV_KEY,
touch_key_array[index]);
}
#endif
#if GTP_GESTURE_WAKEUP
input_set_capability(ts->input_dev, EV_KEY, KEY_POWER);
#endif
if (gtp_config->gtp_change_x2y == 1) {
GTP_SWAP(ts->abs_x_max, ts->abs_y_max);
}
input_set_abs_params(ts->input_dev, ABS_MT_POSITION_X, 0, ts->abs_x_max,
0, 0);
input_set_abs_params(ts->input_dev, ABS_MT_POSITION_Y, 0, ts->abs_y_max,
0, 0);
input_set_abs_params(ts->input_dev, ABS_MT_WIDTH_MAJOR, 0, 255, 0, 0);
input_set_abs_params(ts->input_dev, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
input_set_abs_params(ts->input_dev, ABS_MT_TRACKING_ID, 0, 255, 0, 0);
ts->input_dev->name = goodix_ts_name;
ts->input_dev->phys = goodix_input_phys;
ts->input_dev->id.bustype = BUS_I2C;
ts->input_dev->id.vendor = 0xDEAD;
ts->input_dev->id.product = 0xBEEF;
ts->input_dev->id.version = 10427;
ret = input_register_device(ts->input_dev);
if (ret) {
GTP_ERROR("Register %s input device failed",
ts->input_dev->name);
return -ENODEV;
}
#if GTP_WITH_PEN
gtp_pen_init(ts);
#endif
return 0;
}
//************** For GT9XXF Start *************//
#if GTP_COMPATIBLE_MODE
s32 gtp_fw_startup(struct i2c_client *client)
{
u8 opr_buf[4];
s32 ret = 0;
//init sw WDT
opr_buf[0] = 0xAA;
ret = i2c_write_bytes(client, 0x8041, opr_buf, 1);
if (ret < 0) {
return FAIL;
}
//release SS51 & DSP
opr_buf[0] = 0x00;
ret = i2c_write_bytes(client, 0x4180, opr_buf, 1);
if (ret < 0) {
return FAIL;
}
//int sync
gtp_int_sync(25);
//check fw run status
ret = i2c_read_bytes(client, 0x8041, opr_buf, 1);
if (ret < 0) {
return FAIL;
}
if (0xAA == opr_buf[0]) {
GTP_ERROR("IC works abnormally,startup failed.");
return FAIL;
} else {
GTP_INFO("IC works normally, Startup success.");
opr_buf[0] = 0xAA;
i2c_write_bytes(client, 0x8041, opr_buf, 1);
return SUCCESS;
}
}
static s32 gtp_esd_recovery(struct i2c_client *client)
{
s32 retry = 0;
s32 ret = 0;
struct goodix_ts_data *ts;
ts = i2c_get_clientdata(client);
gtp_irq_disable(ts);
GTP_INFO("GT9XXF esd recovery mode");
for (retry = 0; retry < 5; retry++) {
ret = gup_fw_download_proc(NULL, GTP_FL_ESD_RECOVERY);
if (FAIL == ret) {
GTP_ERROR("esd recovery failed %d", retry + 1);
continue;
}
ret = gtp_fw_startup(ts->client);
if (FAIL == ret) {
GTP_ERROR("GT9XXF start up failed %d", retry + 1);
continue;
}
break;
}
gtp_irq_enable(ts);
if (retry >= 5) {
GTP_ERROR("failed to esd recovery");
return FAIL;
}
GTP_INFO("Esd recovery successful");
return SUCCESS;
}
void gtp_recovery_reset(struct i2c_client *client)
{
#if GTP_ESD_PROTECT
gtp_esd_switch(client, SWITCH_OFF);
#endif
GTP_DEBUG_FUNC();
gtp_esd_recovery(client);
#if GTP_ESD_PROTECT
gtp_esd_switch(client, SWITCH_ON);
#endif
}
static s32 gtp_bak_ref_proc(struct goodix_ts_data *ts, u8 mode)
{
s32 ret = 0;
s32 i = 0;
s32 j = 0;
u16 ref_sum = 0;
u16 learn_cnt = 0;
u16 chksum = 0;
s32 ref_seg_len = 0;
s32 ref_grps = 0;
struct file *ref_filp = NULL;
u8 *p_bak_ref;
ret = gup_check_fs_mounted("/data");
if (FAIL == ret) {
ts->ref_chk_fs_times++;
GTP_DEBUG("Ref check /data times/MAX_TIMES: %d / %d",
ts->ref_chk_fs_times, GTP_CHK_FS_MNT_MAX);
if (ts->ref_chk_fs_times < GTP_CHK_FS_MNT_MAX) {
msleep(50);
GTP_INFO("/data not mounted.");
return FAIL;
}
GTP_INFO("check /data mount timeout...");
} else {
GTP_INFO("/data mounted!!!(%d/%d)", ts->ref_chk_fs_times,
GTP_CHK_FS_MNT_MAX);
}
p_bak_ref = (u8 *)kzalloc(ts->bak_ref_len, GFP_KERNEL);
if (NULL == p_bak_ref) {
GTP_ERROR("Allocate memory for p_bak_ref failed!");
return FAIL;
}
if (ts->is_950) {
ref_seg_len = ts->bak_ref_len / 6;
ref_grps = 6;
} else {
ref_seg_len = ts->bak_ref_len;
ref_grps = 1;
}
ref_filp = filp_open(GTP_BAK_REF_PATH, O_RDWR | O_CREAT, 0666);
if (IS_ERR(ref_filp)) {
GTP_ERROR("Failed to open/create %s.", GTP_BAK_REF_PATH);
if (GTP_BAK_REF_SEND == mode) {
goto bak_ref_default;
} else {
goto bak_ref_exit;
}
}
switch (mode) {
case GTP_BAK_REF_SEND:
GTP_INFO("Send backup-reference");
ref_filp->f_op->llseek(ref_filp, 0, SEEK_SET);
ret = ref_filp->f_op->read(ref_filp, (char *)p_bak_ref,
ts->bak_ref_len, &ref_filp->f_pos);
if (ret < 0) {
GTP_ERROR(
"failed to read bak_ref info from file, sending defualt bak_ref");
goto bak_ref_default;
}
for (j = 0; j < ref_grps; ++j) {
ref_sum = 0;
for (i = 0; i < (ref_seg_len); i += 2) {
ref_sum +=
(p_bak_ref[i + j * ref_seg_len] << 8) +
p_bak_ref[i + 1 + j * ref_seg_len];
}
learn_cnt =
(p_bak_ref[j * ref_seg_len + ref_seg_len - 4]
<< 8) +
(p_bak_ref[j * ref_seg_len + ref_seg_len - 3]);
chksum = (p_bak_ref[j * ref_seg_len + ref_seg_len - 2]
<< 8) +
(p_bak_ref[j * ref_seg_len + ref_seg_len - 1]);
GTP_DEBUG("learn count = %d", learn_cnt);
GTP_DEBUG("chksum = %d", chksum);
GTP_DEBUG("ref_sum = 0x%04X", ref_sum & 0xFFFF);
// Sum(1~ref_seg_len) == 1
if (1 != ref_sum) {
GTP_INFO(
"wrong chksum for bak_ref, reset to 0x00 bak_ref");
memset(&p_bak_ref[j * ref_seg_len], 0,
ref_seg_len);
p_bak_ref[ref_seg_len + j * ref_seg_len - 1] =
0x01;
} else {
if (j == (ref_grps - 1)) {
GTP_INFO(
"backup-reference data in %s used",
GTP_BAK_REF_PATH);
}
}
}
ret = i2c_write_bytes(ts->client, GTP_REG_BAK_REF, p_bak_ref,
ts->bak_ref_len);
if (FAIL == ret) {
GTP_ERROR(
"failed to send bak_ref because of iic comm error");
goto bak_ref_exit;
}
break;
case GTP_BAK_REF_STORE:
GTP_INFO("Store backup-reference");
ret = i2c_read_bytes(ts->client, GTP_REG_BAK_REF, p_bak_ref,
ts->bak_ref_len);
if (ret < 0) {
GTP_ERROR(
"failed to read bak_ref info, sending default back-reference");
goto bak_ref_default;
}
ref_filp->f_op->llseek(ref_filp, 0, SEEK_SET);
ref_filp->f_op->write(ref_filp, (char *)p_bak_ref,
ts->bak_ref_len, &ref_filp->f_pos);
break;
default:
GTP_ERROR("invalid backup-reference request");
break;
}
ret = SUCCESS;
goto bak_ref_exit;
bak_ref_default:
for (j = 0; j < ref_grps; ++j) {
memset(&p_bak_ref[j * ref_seg_len], 0, ref_seg_len);
p_bak_ref[j * ref_seg_len + ref_seg_len - 1] =
0x01; // checksum = 1
}
ret = i2c_write_bytes(ts->client, GTP_REG_BAK_REF, p_bak_ref,
ts->bak_ref_len);
if (!IS_ERR(ref_filp)) {
GTP_INFO("write backup-reference data into %s",
GTP_BAK_REF_PATH);
ref_filp->f_op->llseek(ref_filp, 0, SEEK_SET);
ref_filp->f_op->write(ref_filp, (char *)p_bak_ref,
ts->bak_ref_len, &ref_filp->f_pos);
}
if (ret == FAIL) {
GTP_ERROR("failed to load the default backup reference");
}
bak_ref_exit:
if (p_bak_ref) {
kfree(p_bak_ref);
}
if (ref_filp && !IS_ERR(ref_filp)) {
filp_close(ref_filp, NULL);
}
return ret;
}
static s32 gtp_verify_main_clk(u8 *p_main_clk)
{
u8 chksum = 0;
u8 main_clock = p_main_clk[0];
s32 i = 0;
if (main_clock < 50 || main_clock > 120) {
return FAIL;
}
for (i = 0; i < 5; ++i) {
if (main_clock != p_main_clk[i]) {
return FAIL;
}
chksum += p_main_clk[i];
}
chksum += p_main_clk[5];
if ((chksum) == 0) {
return SUCCESS;
} else {
return FAIL;
}
}
static s32 gtp_main_clk_proc(struct goodix_ts_data *ts)
{
s32 ret = 0;
s32 i = 0;
s32 clk_chksum = 0;
struct file *clk_filp = NULL;
u8 p_main_clk[6] = { 0 };
ret = gup_check_fs_mounted("/data");
if (FAIL == ret) {
ts->clk_chk_fs_times++;
GTP_DEBUG("Clock check /data times/MAX_TIMES: %d / %d",
ts->clk_chk_fs_times, GTP_CHK_FS_MNT_MAX);
if (ts->clk_chk_fs_times < GTP_CHK_FS_MNT_MAX) {
msleep(50);
GTP_INFO("/data not mounted.");
return FAIL;
}
GTP_INFO("Check /data mount timeout!");
} else {
GTP_INFO("/data mounted!!!(%d/%d)", ts->clk_chk_fs_times,
GTP_CHK_FS_MNT_MAX);
}
clk_filp = filp_open(GTP_MAIN_CLK_PATH, O_RDWR | O_CREAT, 0666);
if (IS_ERR(clk_filp)) {
GTP_ERROR("%s is unavailable, calculate main clock",
GTP_MAIN_CLK_PATH);
} else {
clk_filp->f_op->llseek(clk_filp, 0, SEEK_SET);
clk_filp->f_op->read(clk_filp, (char *)p_main_clk, 6,
&clk_filp->f_pos);
ret = gtp_verify_main_clk(p_main_clk);
if (FAIL == ret) {
// recalculate main clock & rewrite main clock data to file
GTP_ERROR(
"main clock data in %s is wrong, recalculate main clock",
GTP_MAIN_CLK_PATH);
} else {
GTP_INFO(
"main clock data in %s used, main clock freq: %d",
GTP_MAIN_CLK_PATH, p_main_clk[0]);
filp_close(clk_filp, NULL);
goto update_main_clk;
}
}
#if GTP_ESD_PROTECT
gtp_esd_switch(ts->client, SWITCH_OFF);
#endif
ret = gup_clk_calibration();
gtp_esd_recovery(ts->client);
#if GTP_ESD_PROTECT
gtp_esd_switch(ts->client, SWITCH_ON);
#endif
GTP_INFO("calibrate main clock: %d", ret);
if (ret < 50 || ret > 120) {
GTP_ERROR("wrong main clock: %d", ret);
goto exit_main_clk;
}
// Sum{0x8020~0x8025} = 0
for (i = 0; i < 5; ++i) {
p_main_clk[i] = ret;
clk_chksum += p_main_clk[i];
}
p_main_clk[5] = 0 - clk_chksum;
if (!IS_ERR(clk_filp)) {
GTP_DEBUG("write main clock data into %s", GTP_MAIN_CLK_PATH);
clk_filp->f_op->llseek(clk_filp, 0, SEEK_SET);
clk_filp->f_op->write(clk_filp, (char *)p_main_clk, 6,
&clk_filp->f_pos);
filp_close(clk_filp, NULL);
}
update_main_clk:
ret = i2c_write_bytes(ts->client, GTP_REG_MAIN_CLK, p_main_clk, 6);
if (FAIL == ret) {
GTP_ERROR("update main clock failed!");
return FAIL;
}
return SUCCESS;
exit_main_clk:
if (!IS_ERR(clk_filp)) {
filp_close(clk_filp, NULL);
}
return FAIL;
}
s32 gtp_gt9xxf_init(struct i2c_client *client)
{
s32 ret = 0;
ret = gup_fw_download_proc(NULL, GTP_FL_FW_BURN);
if (FAIL == ret) {
return FAIL;
}
ret = gtp_fw_startup(client);
if (FAIL == ret) {
return FAIL;
}
return SUCCESS;
}
void gtp_get_chip_type(struct goodix_ts_data *ts)
{
u8 opr_buf[10] = { 0x00 };
s32 ret = 0;
msleep(10);
ret = gtp_i2c_read_dbl_check(ts->client, GTP_REG_CHIP_TYPE, opr_buf,
10);
if (FAIL == ret) {
GTP_ERROR(
"Failed to get chip-type, set chip type default: GOODIX_GT9");
ts->chip_type = CHIP_TYPE_GT9;
return;
}
if (!memcmp(opr_buf, "GOODIX_GT9", 10)) {
ts->chip_type = CHIP_TYPE_GT9;
} else // GT9XXF
{
ts->chip_type = CHIP_TYPE_GT9F;
}
GTP_INFO("Chip Type: %s", (ts->chip_type == CHIP_TYPE_GT9) ?
"GOODIX_GT9" :
"GOODIX_GT9F");
}
#endif //For GT9XXF End//
/*
* Devices Tree support,
*/
#ifdef GTP_CONFIG_OF
/**
* gtp_parse_dt - parse platform infomation form devices tree.
*/
static void gtp_parse_dt(struct device *dev)
{
struct device_node *np = dev->of_node;
gtp_int_gpio = of_get_named_gpio(np, "goodix_irq_gpio", 0);
gtp_rst_gpio = of_get_named_gpio(np, "goodix_rst_gpio", 0);
of_property_read_u32(np, "gtp_resolution_x",
&(gtp_config->gtp_resolution_x));
of_property_read_u32(np, "gtp_resolution_y",
&(gtp_config->gtp_resolution_y));
of_property_read_u32(np, "gtp_change_x2y",
&(gtp_config->gtp_change_x2y));
of_property_read_u32(np, "gtp_overturn_x",
&(gtp_config->gtp_overturn_x));
of_property_read_u32(np, "gtp_overturn_y",
&(gtp_config->gtp_overturn_y));
of_property_read_u32(np, "gtp_send_cfg", &(gtp_config->gtp_send_cfgs));
of_property_read_u32(np, "gtp_int_tarigger",
&(gtp_config->gtp_int_tarigger));
of_property_read_u32(np, "gtp_touch_wakeup",
&(gtp_config->gtp_touch_wakeup));
of_property_read_u32(np, "gtp_touch_back",
&(gtp_config->gtp_touch_back));
}
/**
* gtp_parse_dt_cfg - parse config data from devices tree.
* @dev: device that this driver attached.
* @cfg: pointer of the config array.
* @cfg_len: pointer of the config length.
* @sid: sensor id.
* Return: 0-succeed, -1-faileds
*/
int gtp_parse_dt_cfg(struct device *dev, u8 *cfg, int *cfg_len, u8 sid)
{
struct device_node *np = dev->of_node;
struct property *prop;
char cfg_name[18];
//rdzkj add for compatible of different screen by sensor_id
snprintf(cfg_name, sizeof(cfg_name), "goodix,cfg-group%d", sid);
GTP_INFO("get %s", cfg_name);
prop = of_find_property(np, cfg_name, cfg_len);
//add end
if (!prop || !prop->value || *cfg_len == 0 ||
*cfg_len > GTP_CONFIG_MAX_LENGTH) {
return -1; /* failed */
} else {
memcpy(cfg, prop->value, *cfg_len);
return 0;
}
}
/**
* gtp_power_switch - power switch .
* @on: 1-switch on, 0-switch off.
* return: 0-succeed, -1-faileds
*/
static int gtp_power_switch(struct i2c_client *client, int on)
{
#if 0
if (!vdd_ana) {
vdd_ana = regulator_get(&client->dev, "vdd_ana");
if (IS_ERR(vdd_ana)) {
GTP_ERROR("regulator get of vdd_ana failed");
ret = PTR_ERR(vdd_ana);
vdd_ana = NULL;
return ret;
}
}
if (!vcc_i2c) {
vcc_i2c = regulator_get(&client->dev, "vcc_i2c");
if (IS_ERR(vcc_i2c)) {
GTP_ERROR("regulator get of vcc_i2c failed");
ret = PTR_ERR(vcc_i2c);
vcc_i2c = NULL;
goto ERR_GET_VCC;
}
}
if (on) {
GTP_DEBUG("GTP power on.");
ret = regulator_enable(vdd_ana);
udelay(2);
ret = regulator_enable(vcc_i2c);
} else {
GTP_DEBUG("GTP power off.");
ret = regulator_disable(vcc_i2c);
udelay(2);
ret = regulator_disable(vdd_ana);
}
return ret;
#endif
return 0;
}
#endif
/*******************************************************
Function:
I2c probe.
Input:
client: i2c device struct.
id: device id.
Output:
Executive outcomes.
0: succeed.
*******************************************************/
static int goodix_ts_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
s32 ret = -1;
struct goodix_ts_data *ts;
u16 version_info;
static struct proc_dir_entry *root_entry_overturn;
GTP_DEBUG_FUNC();
//do NOT remove these logs
GTP_INFO("GTP Driver Version: %s", GTP_DRIVER_VERSION);
// GTP_INFO("GTP Driver Built@%s, %s", __TIME__, __DATE__);
GTP_INFO("GTP I2C Address: 0x%02x", client->addr);
i2c_connect_client = client;
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
GTP_ERROR("I2C check functionality failed.");
return -ENODEV;
}
ts = kzalloc(sizeof(*ts), GFP_KERNEL);
if (ts == NULL) {
GTP_ERROR("Alloc GFP_KERNEL memory failed.");
return -ENOMEM;
}
gtp_config = kzalloc(sizeof(*gtp_config), GFP_KERNEL);
if (gtp_config == NULL) {
GTP_ERROR("Alloc GFP_KERNEL memory failed.");
return -ENOMEM;
}
#ifdef GTP_CONFIG_OF /* device tree support */
if (client->dev.of_node) {
gtp_parse_dt(&client->dev);
}
ret = gtp_power_switch(client, 1);
if (ret) {
GTP_ERROR("GTP power on failed.");
return -EINVAL;
}
#else /* use gpio defined in gt9xx.h */
gtp_rst_gpio = GTP_RST_PORT;
gtp_int_gpio = GTP_INT_PORT;
#endif
INIT_WORK(&ts->work, goodix_ts_work_func);
ts->client = client;
spin_lock_init(&ts->irq_lock); // 2.6.39 later
// ts->irq_lock = SPIN_LOCK_UNLOCKED; // 2.6.39 & before
#if GTP_ESD_PROTECT
ts->clk_tick_cnt =
2 * HZ; // HZ: clock ticks in 1 second generated by system
GTP_DEBUG("Clock ticks for an esd cycle: %d", ts->clk_tick_cnt);
spin_lock_init(&ts->esd_lock);
// ts->esd_lock = SPIN_LOCK_UNLOCKED;
#endif
i2c_set_clientdata(client, ts);
ts->gtp_rawdiff_mode = 0;
ret = gtp_request_io_port(ts);
if (ret < 0) {
GTP_ERROR("GTP request IO port failed.");
kfree(ts);
return ret;
}
#if GTP_COMPATIBLE_MODE
gtp_get_chip_type(ts);
if (CHIP_TYPE_GT9F == ts->chip_type) {
ret = gtp_gt9xxf_init(ts->client);
if (FAIL == ret) {
GTP_INFO("Failed to init GT9XXF.");
}
}
#endif
ret = gtp_i2c_test(client);
if (ret < 0) {
GTP_ERROR("I2C communication ERROR!");
return 0; //add by rpdzkj
}
ret = gtp_read_version(client, &version_info);
if (ret < 0) {
GTP_ERROR("Read version failed.");
}
get_ICfrimware();
ret = gtp_init_panel(ts);
if (ret < 0) {
GTP_ERROR("GTP init panel failed.");
ts->abs_x_max = gtp_config->gtp_resolution_x;
ts->abs_y_max = gtp_config->gtp_resolution_y;
ts->int_trigger_type = gtp_config->gtp_int_tarigger;
}
// Create proc file system
root_entry_overturn = proc_mkdir("rp_touch_overturn", NULL);//add by rpdzkj
proc_create("overturn_x", 0666 , root_entry_overturn , &overturn_x_proc_ops);//add by rpdzkj
proc_create("overturn_y", 0666 , root_entry_overturn , &overturn_y_proc_ops);//add by rpdzkj
gt91xx_config_proc = proc_create(GT91XX_CONFIG_PROC_FILE, 0666, NULL,
&config_proc_ops);
if (gt91xx_config_proc == NULL) {
GTP_ERROR("create_proc_entry %s failed\n",
GT91XX_CONFIG_PROC_FILE);
} else {
GTP_INFO("create proc entry %s success",
GT91XX_CONFIG_PROC_FILE);
}
#if GTP_ESD_PROTECT
gtp_esd_switch(client, SWITCH_ON);
#endif
#if GTP_AUTO_UPDATE
ret = gup_init_update_proc(ts);
if (ret < 0) {
GTP_ERROR("Create update thread error.");
}
#endif
ret = gtp_request_input_dev(ts);
if (ret < 0) {
GTP_ERROR("GTP request input dev failed");
}
ret = gtp_request_irq(ts);
if (ret < 0) {
GTP_INFO("GTP works in polling mode.");
} else {
GTP_INFO("GTP works in interrupt mode.");
}
if (ts->use_irq) {
gtp_irq_enable(ts);
#if GTP_GESTURE_WAKEUP
enable_irq_wake(client->irq);
#endif
}
/* register suspend and resume fucntion*/
gtp_register_powermanger(ts);
#if GTP_CREATE_WR_NODE
init_wr_node(client);
#endif
return 0;
}
/*******************************************************
Function:
Goodix touchscreen driver release function.
Input:
client: i2c device struct.
Output:
Executive outcomes. 0---succeed.
*******************************************************/
static int goodix_ts_remove(struct i2c_client *client)
{
struct goodix_ts_data *ts = i2c_get_clientdata(client);
GTP_DEBUG_FUNC();
gtp_unregister_powermanger(ts);
#if GTP_CREATE_WR_NODE
uninit_wr_node();
#endif
#if GTP_ESD_PROTECT
destroy_workqueue(gtp_esd_check_workqueue);
#endif
if (ts) {
if (ts->use_irq) {
GTP_GPIO_AS_INPUT(gtp_int_gpio);
GTP_GPIO_FREE(gtp_int_gpio);
free_irq(client->irq, ts);
} else {
hrtimer_cancel(&ts->timer);
}
}
GTP_INFO("GTP driver removing...");
i2c_set_clientdata(client, NULL);
input_unregister_device(ts->input_dev);
kfree(ts);
return 0;
}
/*******************************************************
Function:
Early suspend function.
Input:
h: early_suspend struct.
Output:
None.
*******************************************************/
static void goodix_ts_suspend(struct goodix_ts_data *ts)
{
s8 ret = -1;
GTP_DEBUG_FUNC();
if (gtp_config->gtp_touch_wakeup == 1) {
ts->gtp_is_suspend = 1;
} else {
if (ts->enter_update) {
return;
}
GTP_INFO("System suspend.");
ts->gtp_is_suspend = 1;
#if GTP_ESD_PROTECT
gtp_esd_switch(ts->client, SWITCH_OFF);
#endif
#if GTP_GESTURE_WAKEUP
ret = gtp_enter_doze(ts);
#else
if (ts->use_irq) {
gtp_irq_disable(ts);
} else {
hrtimer_cancel(&ts->timer);
}
ret = gtp_enter_sleep(ts);
#endif
if (ret < 0) {
GTP_ERROR("GTP early suspend failed.");
}
// to avoid waking up while not sleeping
// delay 48 + 10ms to ensure reliability
msleep(58);
}
}
/*******************************************************
Function:
Late resume function.
Input:
h: early_suspend struct.
Output:
None.
*******************************************************/
static void goodix_ts_resume(struct goodix_ts_data *ts)
{
s8 ret = -1;
GTP_DEBUG_FUNC();
if (ts->enter_update) {
return;
}
GTP_INFO("System resume.");
ret = gtp_wakeup_sleep(ts);
#if GTP_GESTURE_WAKEUP
doze_status = DOZE_DISABLED;
#endif
if (ret < 0) {
GTP_ERROR("GTP later resume failed.");
}
#if (GTP_COMPATIBLE_MODE)
if (CHIP_TYPE_GT9F == ts->chip_type) {
// do nothing
} else
#endif
{
gtp_send_cfg(ts->client);
}
if (ts->use_irq) {
gtp_irq_enable(ts);
} else {
hrtimer_start(&ts->timer, ktime_set(1, 0), HRTIMER_MODE_REL);
}
ts->gtp_is_suspend = 0;
#if GTP_ESD_PROTECT
gtp_esd_switch(ts->client, SWITCH_ON);
#endif
}
#if defined(CONFIG_FB)
/* frame buffer notifier block control the suspend/resume procedure */
static int gtp_fb_notifier_callback(struct notifier_block *noti,
unsigned long event, void *data)
{
struct fb_event *ev_data = data;
struct goodix_ts_data *ts =
container_of(noti, struct goodix_ts_data, notifier);
int *blank;
if (ev_data && ev_data->data && event == FB_EVENT_BLANK && ts) {
blank = ev_data->data;
if (*blank == FB_BLANK_UNBLANK) {
GTP_DEBUG("Resume by fb notifier.");
goodix_ts_resume(ts);
} else if (*blank == FB_BLANK_POWERDOWN) {
GTP_DEBUG("Suspend by fb notifier.");
goodix_ts_suspend(ts);
}
}
return 0;
}
#elif defined(CONFIG_PM)
/* bus control the suspend/resume procedure */
static int gtp_pm_suspend(struct device *dev)
{
struct i2c_client *client = to_i2c_client(dev);
struct goodix_ts_data *ts = i2c_get_clientdata(client);
if (ts) {
GTP_DEBUG("Suspend by i2c pm.");
goodix_ts_suspend(ts);
}
return 0;
}
static int gtp_pm_resume(struct device *dev)
{
struct i2c_client *client = to_i2c_client(dev);
struct goodix_ts_data *ts = i2c_get_clientdata(client);
if (ts) {
GTP_DEBUG("Resume by i2c pm.");
goodix_ts_resume(ts);
}
return 0;
}
static struct dev_pm_ops gtp_pm_ops = {
.suspend = gtp_pm_suspend,
.resume = gtp_pm_resume,
};
#elif defined(CONFIG_HAS_EARLYSUSPEND)
/* earlysuspend module the suspend/resume procedure */
static void gtp_early_suspend(struct early_suspend *h)
{
struct goodix_ts_data *ts =
container_of(h, struct goodix_ts_data, early_suspend);
if (ts) {
GTP_DEBUG("Suspend by earlysuspend module.");
goodix_ts_suspend(ts);
}
}
static void gtp_early_resume(struct early_suspend *h)
{
struct goodix_ts_data *ts =
container_of(h, struct goodix_ts_data, early_suspend);
if (ts) {
GTP_DEBUG("Resume by earlysuspend module.");
goodix_ts_resume(ts);
}
}
#endif
static int gtp_register_powermanger(struct goodix_ts_data *ts)
{
#if defined(CONFIG_FB)
ts->notifier.notifier_call = gtp_fb_notifier_callback;
fb_register_client(&ts->notifier);
#elif defined(CONFIG_HAS_EARLYSUSPEND)
ts->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
ts->early_suspend.suspend = goodix_ts_early_suspend;
ts->early_suspend.resume = goodix_ts_late_resume;
register_early_suspend(&ts->early_suspend);
#endif
return 0;
}
static int gtp_unregister_powermanger(struct goodix_ts_data *ts)
{
#if defined(CONFIG_FB)
fb_unregister_client(&ts->notifier);
#elif defined(CONFIG_HAS_EARLYSUSPEND)
unregister_early_suspend(&ts->early_suspend);
#endif
return 0;
}
/* end */
#if GTP_ESD_PROTECT
s32 gtp_i2c_read_no_rst(struct i2c_client *client, u8 *buf, s32 len)
{
struct i2c_msg msgs[2];
s32 ret = -1;
s32 retries = 0;
GTP_DEBUG_FUNC();
msgs[0].flags = !I2C_M_RD;
msgs[0].addr = client->addr;
msgs[0].len = GTP_ADDR_LENGTH;
msgs[0].buf = &buf[0];
// msgs[0].scl_rate = 300 * 1000; // for Rockchip, etc.
msgs[1].flags = I2C_M_RD;
msgs[1].addr = client->addr;
msgs[1].len = len - GTP_ADDR_LENGTH;
msgs[1].buf = &buf[GTP_ADDR_LENGTH];
// msgs[1].scl_rate = 300 * 1000;
while (retries < 5) {
ret = i2c_transfer(client->adapter, msgs, 2);
if (ret == 2)
break;
retries++;
}
if ((retries >= 5)) {
GTP_ERROR("I2C Read: 0x%04X, %d bytes failed, errcode: %d!",
(((u16)(buf[0] << 8)) | buf[1]), len - 2, ret);
}
return ret;
}
s32 gtp_i2c_write_no_rst(struct i2c_client *client, u8 *buf, s32 len)
{
struct i2c_msg msg;
s32 ret = -1;
s32 retries = 0;
GTP_DEBUG_FUNC();
msg.flags = !I2C_M_RD;
msg.addr = client->addr;
msg.len = len;
msg.buf = buf;
// msg.scl_rate = 300 * 1000; // for Rockchip, etc
while (retries < 5) {
ret = i2c_transfer(client->adapter, &msg, 1);
if (ret == 1)
break;
retries++;
}
if ((retries >= 5)) {
GTP_ERROR("I2C Write: 0x%04X, %d bytes failed, errcode: %d!",
(((u16)(buf[0] << 8)) | buf[1]), len - 2, ret);
}
return ret;
}
/*******************************************************
Function:
switch on & off esd delayed work
Input:
client: i2c device
on: SWITCH_ON / SWITCH_OFF
Output:
void
*********************************************************/
void gtp_esd_switch(struct i2c_client *client, s32 on)
{
struct goodix_ts_data *ts;
ts = i2c_get_clientdata(client);
spin_lock(&ts->esd_lock);
if (SWITCH_ON == on) // switch on esd
{
if (!ts->esd_running) {
ts->esd_running = 1;
spin_unlock(&ts->esd_lock);
GTP_INFO("Esd started");
queue_delayed_work(gtp_esd_check_workqueue,
&gtp_esd_check_work,
ts->clk_tick_cnt);
} else {
spin_unlock(&ts->esd_lock);
}
} else // switch off esd
{
if (ts->esd_running) {
ts->esd_running = 0;
spin_unlock(&ts->esd_lock);
GTP_INFO("Esd cancelled");
cancel_delayed_work_sync(&gtp_esd_check_work);
} else {
spin_unlock(&ts->esd_lock);
}
}
}
/*******************************************************
Function:
Initialize external watchdog for esd protect
Input:
client: i2c device.
Output:
result of i2c write operation.
1: succeed, otherwise: failed
*********************************************************/
static s32 gtp_init_ext_watchdog(struct i2c_client *client)
{
u8 opr_buffer[3] = { 0x80, 0x41, 0xAA };
GTP_DEBUG("[Esd]Init external watchdog");
return gtp_i2c_write_no_rst(client, opr_buffer, 3);
}
/*******************************************************
Function:
Esd protect function.
External watchdog added by meta, 2013/03/07
Input:
work: delayed work
Output:
None.
*******************************************************/
static void gtp_esd_check_func(struct work_struct *work)
{
s32 i;
s32 ret = -1;
struct goodix_ts_data *ts = NULL;
u8 esd_buf[5] = { 0x80, 0x40 };
GTP_DEBUG_FUNC();
ts = i2c_get_clientdata(i2c_connect_client);
if (ts->gtp_is_suspend || ts->enter_update) {
GTP_INFO("Esd suspended!");
return;
}
for (i = 0; i < 3; i++) {
ret = gtp_i2c_read_no_rst(ts->client, esd_buf, 4);
GTP_DEBUG("[Esd]0x8040 = 0x%02X, 0x8041 = 0x%02X", esd_buf[2],
esd_buf[3]);
if ((ret < 0)) {
// IIC communication problem
continue;
} else {
if ((esd_buf[2] == 0xAA) || (esd_buf[3] != 0xAA)) {
// IC works abnormally..
u8 chk_buf[4] = { 0x80, 0x40 };
gtp_i2c_read_no_rst(ts->client, chk_buf, 4);
GTP_DEBUG(
"[Check]0x8040 = 0x%02X, 0x8041 = 0x%02X",
chk_buf[2], chk_buf[3]);
if ((chk_buf[2] == 0xAA) ||
(chk_buf[3] != 0xAA)) {
i = 3;
break;
} else {
continue;
}
} else {
// IC works normally, Write 0x8040 0xAA, feed the dog
esd_buf[2] = 0xAA;
gtp_i2c_write_no_rst(ts->client, esd_buf, 3);
break;
}
}
}
if (i >= 3) {
#if GTP_COMPATIBLE_MODE
if (CHIP_TYPE_GT9F == ts->chip_type) {
if (ts->rqst_processing) {
GTP_INFO("Request processing, no esd recovery");
} else {
GTP_ERROR(
"IC working abnormally! Process esd recovery.");
esd_buf[0] = 0x42;
esd_buf[1] = 0x26;
esd_buf[2] = 0x01;
esd_buf[3] = 0x01;
esd_buf[4] = 0x01;
gtp_i2c_write_no_rst(ts->client, esd_buf, 5);
msleep(50);
#ifdef GTP_CONFIG_OF
gtp_power_switch(ts->client, 0);
msleep(20);
gtp_power_switch(ts->client, 1);
msleep(20);
#endif
gtp_esd_recovery(ts->client);
}
} else
#endif
{
GTP_ERROR(
"IC working abnormally! Process reset guitar.");
esd_buf[0] = 0x42;
esd_buf[1] = 0x26;
esd_buf[2] = 0x01;
esd_buf[3] = 0x01;
esd_buf[4] = 0x01;
gtp_i2c_write_no_rst(ts->client, esd_buf, 5);
msleep(50);
#ifdef GTP_CONFIG_OF
gtp_power_switch(ts->client, 0);
msleep(20);
gtp_power_switch(ts->client, 1);
msleep(20);
#endif
gtp_reset_guitar(ts->client, 50);
msleep(50);
gtp_send_cfg(ts->client);
}
}
if (!ts->gtp_is_suspend) {
queue_delayed_work(gtp_esd_check_workqueue, &gtp_esd_check_work,
ts->clk_tick_cnt);
} else {
GTP_INFO("Esd suspended!");
}
return;
}
#endif
#ifdef GTP_CONFIG_OF
static const struct of_device_id goodix_match_table[] = {
{
.compatible = "goodix,gt9xx",
},
{},
};
#endif
static const struct i2c_device_id goodix_ts_id[] = { { GTP_I2C_NAME, 0 }, {} };
static struct i2c_driver goodix_ts_driver = {
.probe = goodix_ts_probe,
.remove = goodix_ts_remove,
.id_table = goodix_ts_id,
.driver = {
.name = GTP_I2C_NAME,
.owner = THIS_MODULE,
#ifdef GTP_CONFIG_OF
.of_match_table = goodix_match_table,
#endif
#if !defined(CONFIG_FB) && defined(CONFIG_PM)
.pm = &gtp_pm_ops,
#endif
},
};
/*******************************************************
Function:
Driver Install function.
Input:
None.
Output:
Executive Outcomes. 0---succeed.
********************************************************/
static int __init goodix_ts_init(void)
{
s32 ret;
GTP_DEBUG_FUNC();
GTP_INFO("GTP driver installing...");
goodix_wq = create_singlethread_workqueue("goodix_wq");
if (!goodix_wq) {
GTP_ERROR("Creat workqueue failed.");
return -ENOMEM;
}
#if GTP_ESD_PROTECT
INIT_DELAYED_WORK(&gtp_esd_check_work, gtp_esd_check_func);
gtp_esd_check_workqueue = create_workqueue("gtp_esd_check");
#endif
ret = i2c_add_driver(&goodix_ts_driver);
return ret;
}
/*******************************************************
Function:
Driver uninstall function.
Input:
None.
Output:
Executive Outcomes. 0---succeed.
********************************************************/
static void __exit goodix_ts_exit(void)
{
GTP_DEBUG_FUNC();
GTP_INFO("GTP driver exited.");
i2c_del_driver(&goodix_ts_driver);
if (goodix_wq) {
destroy_workqueue(goodix_wq);
}
}
module_init(goodix_ts_init);
module_exit(goodix_ts_exit);
MODULE_DESCRIPTION("GTP Series Driver");
MODULE_LICENSE("GPL");
Reference in New Issue View Git Blame Copy Permalink