aubrey/kernel_samsung_a34x-permissive
1
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity
kernel_samsung_a34x-permissive/drivers/input/touchscreen/mediatek/hxchipset/himax_common.c

2298 lines
59 KiB
C
Raw Normal View History

Import A346BXXU1AWB9 kernel source Android 13
2024-04-28 06:49:01 -07:00
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include "himax_ic.h"
#define SUPPORT_FINGER_DATA_CHECKSUM 0x0F
#define TS_WAKE_LOCK_TIMEOUT (2 * HZ)
#define FRAME_COUNT 5
#if defined(HX_AUTO_UPDATE_FW)
unsigned char i_CTPM_FW[] = {
#include "HX83100_Firmware_Version_FF23.i"
};
#endif
struct himax_ts_data *private_ts;
struct himax_ic_data *ic_data;
struct himax_report_data *hx_touch_data;
static int HX_TOUCH_INFO_POINT_CNT;
unsigned long FW_VER_MAJ_FLASH_ADDR;
unsigned long FW_VER_MIN_FLASH_ADDR;
unsigned long CFG_VER_MAJ_FLASH_ADDR;
unsigned long CFG_VER_MIN_FLASH_ADDR;
unsigned long CID_VER_MAJ_FLASH_ADDR;
unsigned long CID_VER_MIN_FLASH_ADDR;
/* unsigned long PANEL_VERSION_ADDR; */
unsigned long FW_VER_MAJ_FLASH_LENG;
unsigned long FW_VER_MIN_FLASH_LENG;
unsigned long CFG_VER_MAJ_FLASH_LENG;
unsigned long CFG_VER_MIN_FLASH_LENG;
unsigned long CID_VER_MAJ_FLASH_LENG;
unsigned long CID_VER_MIN_FLASH_LENG;
/* unsigned long PANEL_VERSION_LENG; */
unsigned long FW_CFG_VER_FLASH_ADDR;
#ifdef HX_AUTO_UPDATE_FW
int g_i_FW_VER;
int g_i_CFG_VER;
int g_i_CID_MAJ; /* GUEST ID */
int g_i_CID_MIN; /* VER for GUEST */
#endif
unsigned char IC_TYPE = 11;
unsigned char IC_CHECKSUM;
#ifdef HX_ESD_RECOVERY
u8 HX_ESD_RESET_ACTIVATE;
int hx_EB_event_flag;
int hx_EC_event_flag;
int hx_ED_event_flag;
#endif
u8 HX_HW_RESET_ACTIVATE;
#if defined(HX_EN_SEL_BUTTON) || defined(HX_EN_MUT_BUTTON)
static uint8_t vk_press;
#endif
static uint8_t AA_press;
static uint8_t EN_NoiseFilter;
static uint8_t Last_EN_NoiseFilter;
static int hx_point_num; /* for himax_ts_work_func use */
static int p_point_num = 0xFFFF;
static int tpd_key;
static int tpd_key_old;
static int probe_fail_flag;
#ifdef HX_USB_DETECT_GLOBAL
bool USB_detect_flag;
#endif
#if defined(CONFIG_FB)
int fb_notifier_callback(struct notifier_block *self, unsigned long event,
void *data);
#elif defined(CONFIG_HAS_EARLYSUSPEND)
static void himax_ts_early_suspend(struct early_suspend *h);
static void himax_ts_late_resume(struct early_suspend *h);
#endif
#ifdef HX_GESTURE_TRACK
static int gest_pt_cnt;
static int gest_pt_x[GEST_PT_MAX_NUM];
static int gest_pt_y[GEST_PT_MAX_NUM];
static int gest_start_x = 0, gest_start_y = 0, gest_end_x = 0, gest_end_y;
static int gest_width = 0, gest_height = 0, gest_mid_x = 0, gest_mid_y;
static int gn_gesture_coor[16];
#endif
#ifdef HX_CHIP_STATUS_MONITOR
struct chip_monitor_data *g_chip_monitor_data;
#endif
int himax_input_register(struct himax_ts_data *ts)
{
int ret = 0;
ret = himax_dev_set(ts);
if (ret < 0)
goto input_device_fail;
set_bit(EV_SYN, ts->input_dev->evbit);
set_bit(EV_ABS, ts->input_dev->evbit);
set_bit(EV_KEY, ts->input_dev->evbit);
#if defined(HX_EN_SEL_BUTTON) || defined(HX_EN_MUT_BUTTON)
#if defined(HX_PLATFOME_DEFINE_KEY)
himax_platform_key();
#else
set_bit(KEY_BACK, ts->input_dev->keybit);
set_bit(KEY_HOME, ts->input_dev->keybit);
set_bit(KEY_MENU, ts->input_dev->keybit);
set_bit(KEY_SEARCH, ts->input_dev->keybit);
set_bit(KEY_APP_SWITCH, ts->input_dev->keybit);
#endif
#endif
#if defined(HX_SMART_WAKEUP) || defined(HX_PALM_REPORT) || \
defined(HX_INSPECT_LPWUG_TEST)
set_bit(KEY_POWER, ts->input_dev->keybit);
#endif
#if defined(HX_SMART_WAKEUP)
set_bit(KEY_CUST_01, ts->input_dev->keybit);
set_bit(KEY_CUST_02, ts->input_dev->keybit);
set_bit(KEY_CUST_03, ts->input_dev->keybit);
set_bit(KEY_CUST_04, ts->input_dev->keybit);
set_bit(KEY_CUST_05, ts->input_dev->keybit);
set_bit(KEY_CUST_06, ts->input_dev->keybit);
set_bit(KEY_CUST_07, ts->input_dev->keybit);
set_bit(KEY_CUST_08, ts->input_dev->keybit);
set_bit(KEY_CUST_09, ts->input_dev->keybit);
set_bit(KEY_CUST_10, ts->input_dev->keybit);
set_bit(KEY_CUST_11, ts->input_dev->keybit);
set_bit(KEY_CUST_12, ts->input_dev->keybit);
set_bit(KEY_CUST_13, ts->input_dev->keybit);
set_bit(KEY_CUST_14, ts->input_dev->keybit);
set_bit(KEY_CUST_15, ts->input_dev->keybit);
#endif
set_bit(BTN_TOUCH, ts->input_dev->keybit);
set_bit(INPUT_PROP_DIRECT, ts->input_dev->propbit);
#ifdef HX_PROTOCOL_A
/* ts->input_dev->mtsize = ts->nFinger_support; */
input_set_abs_params(ts->input_dev, ABS_MT_TRACKING_ID, 0, 3, 0, 0);
#else
set_bit(MT_TOOL_FINGER, ts->input_dev->keybit);
#if defined(HX_PROTOCOL_B_3PA)
input_mt_init_slots(ts->input_dev, ts->nFinger_support,
INPUT_MT_DIRECT);
#else
input_mt_init_slots(ts->input_dev, ts->nFinger_support);
#endif
#endif
I("input_set_abs_params: mix_x %d, max_x %d, min_y %d, max_y %d\n",
ts->pdata->abs_x_min, ts->pdata->abs_x_max, ts->pdata->abs_y_min,
ts->pdata->abs_y_max);
input_set_abs_params(ts->input_dev, ABS_MT_POSITION_X,
ts->pdata->abs_x_min, ts->pdata->abs_x_max,
ts->pdata->abs_x_fuzz, 0);
input_set_abs_params(ts->input_dev, ABS_MT_POSITION_Y,
ts->pdata->abs_y_min, ts->pdata->abs_y_max,
ts->pdata->abs_y_fuzz, 0);
input_set_abs_params(
ts->input_dev, ABS_MT_TOUCH_MAJOR, ts->pdata->abs_pressure_min,
ts->pdata->abs_pressure_max, ts->pdata->abs_pressure_fuzz, 0);
#ifndef HX_PROTOCOL_A
input_set_abs_params(
ts->input_dev, ABS_MT_PRESSURE, ts->pdata->abs_pressure_min,
ts->pdata->abs_pressure_max, ts->pdata->abs_pressure_fuzz, 0);
input_set_abs_params(ts->input_dev, ABS_MT_WIDTH_MAJOR,
ts->pdata->abs_width_min, ts->pdata->abs_width_max,
ts->pdata->abs_pressure_fuzz, 0);
#endif
/* input_set_abs_params(ts->input_dev, ABS_MT_AMPLITUDE, 0, */
/* ((ts->pdata->abs_pressure_max << 16) | ts->pdata->abs_width_max), 0,
*/
/* 0); */
/* input_set_abs_params(ts->input_dev, ABS_MT_POSITION, 0, (BIT(31) */
/* | (ts->pdata->abs_x_max << 16) | ts->pdata->abs_y_max), 0, 0); */
if (himax_input_register_device(ts->input_dev) == 0)
return NO_ERR;
ret = INPUT_REGISTER_FAIL;
input_device_fail:
I("%s, input device register fail!\n", __func__);
return ret;
}
static void calcDataSize(uint8_t finger_num)
{
struct himax_ts_data *ts_data = private_ts;
ts_data->coord_data_size = 4 * finger_num;
ts_data->area_data_size =
((finger_num / 4) + (finger_num % 4 ? 1 : 0)) * 4;
ts_data->coordInfoSize =
ts_data->coord_data_size + ts_data->area_data_size + 4;
ts_data->raw_data_frame_size = 128 - ts_data->coord_data_size -
ts_data->area_data_size - 4 - 4 - 1;
if (ts_data->raw_data_frame_size == 0) {
E("%s: could NOT calculate!\n", __func__);
return;
}
ts_data->raw_data_nframes =
((uint32_t)ts_data->x_channel * ts_data->y_channel +
ts_data->x_channel + ts_data->y_channel) /
ts_data->raw_data_frame_size +
(((uint32_t)ts_data->x_channel *
ts_data->y_channel +
ts_data->x_channel + ts_data->y_channel) %
ts_data->raw_data_frame_size)
? 1
: 0;
I("%s: coord: %d, area:%d, raw:%d, raw:%d",
__func__, ts_data->coord_data_size, ts_data->area_data_size,
ts_data->raw_data_frame_size, ts_data->raw_data_nframes);
}
void calculate_point_number(void)
{
HX_TOUCH_INFO_POINT_CNT = ic_data->HX_MAX_PT * 4;
if ((ic_data->HX_MAX_PT % 4) == 0)
HX_TOUCH_INFO_POINT_CNT += (ic_data->HX_MAX_PT / 4) * 4;
else
HX_TOUCH_INFO_POINT_CNT += ((ic_data->HX_MAX_PT / 4) + 1) * 4;
}
#ifdef HX_AUTO_UPDATE_FW
static int i_update_FW(void)
{
int upgrade_times = 0;
unsigned char *ImageBuffer = i_CTPM_FW;
int fullFileLength = sizeof(i_CTPM_FW);
uint8_t ret = 0, result = 0;
I("%s: i_fullFileLength = %d\n", __func__, fullFileLength);
himax_int_enable(private_ts->client->irq, 0);
update_retry:
if (fullFileLength == FW_SIZE_32k) {
ret = fts_ctpm_fw_upgrade_with_sys_fs_32k(
private_ts->client, ImageBuffer, fullFileLength, false);
} else if (fullFileLength == FW_SIZE_60k) {
ret = fts_ctpm_fw_upgrade_with_sys_fs_60k(
private_ts->client, ImageBuffer, fullFileLength, false);
} else if (fullFileLength == FW_SIZE_64k) {
ret = fts_ctpm_fw_upgrade_with_sys_fs_64k(
private_ts->client, ImageBuffer, fullFileLength, false);
} else if (fullFileLength == FW_SIZE_124k) {
ret = fts_ctpm_fw_upgrade_with_sys_fs_124k(
private_ts->client, ImageBuffer, fullFileLength, false);
} else if (fullFileLength == FW_SIZE_128k) {
ret = fts_ctpm_fw_upgrade_with_sys_fs_128k(
private_ts->client, ImageBuffer, fullFileLength, false);
}
if (ret == 0) {
upgrade_times++;
E("%s: TP upgrade error, upgrade_times = %d\n", __func__,
upgrade_times);
if (upgrade_times < 3)
goto update_retry;
else
result = -1; /* upgrade fail */
} else {
himax_read_FW_ver(private_ts->client);
himax_touch_information(private_ts->client);
result = 1; /* upgrade success */
I("%s: TP upgrade OK\n", __func__);
}
#ifdef HX_RST_PIN_FUNC
himax_ic_reset(true, false);
#else
himax_sense_on(private_ts->client, 0);
#endif
himax_int_enable(private_ts->client->irq, 1);
return result;
}
#endif
int himax_loadSensorConfig(struct i2c_client *client,
struct himax_i2c_platform_data *pdata)
{
if (!client) {
E("%s: Necessary parameters client are null!\n", __func__);
return -1;
}
I("%s: initialization complete\n", __func__);
return NO_ERR;
}
#ifdef HX_ESD_RECOVERY
void himax_esd_hw_reset(void)
{
I("START_Himax TP: ESD - Reset\n");
#if defined(HX_TP_PROC_SELF_TEST) || defined(CONFIG_TOUCHSCREEN_HIMAX_ITO_TEST)
if (g_self_test_entered == 1) {
I("In self test ,not TP: ESD - Reset\n");
return;
}
#endif
#if defined(HX_CHIP_STATUS_MONITOR)
g_chip_monitor_data->HX_CHIP_POLLING_COUNT = 0;
#endif
himax_esd_ic_reset();
I("END_Himax TP: ESD - Reset\n");
}
#endif
#ifdef HX_CHIP_STATUS_MONITOR
static void
himax_chip_monitor_function(struct work_struct *work) /* for ESD solution */
{
int ret = 0;
I(" %s: POLLING_COUNT=%x, STATUS=%x\n", __func__,
g_chip_monitor_data->HX_CHIP_POLLING_COUNT, ret);
if (g_chip_monitor_data->HX_CHIP_POLLING_COUNT >=
(g_chip_monitor_data->HX_POLLING_TIMES - 1)) { /* POLLING TIME */
g_chip_monitor_data->HX_ON_HAND_SHAKING = 1;
ret = himax_hand_shaking(
private_ts->client); /* 0:Running, 1:Stop, 2:I2C Fail */
g_chip_monitor_data->HX_ON_HAND_SHAKING = 0;
if (ret == 2) {
I(" %s: I2C Fail\n", __func__);
himax_esd_hw_reset();
} else if (ret == 1) {
I(" %s: MCU Stop\n", __func__);
himax_esd_hw_reset();
}
g_chip_monitor_data->HX_CHIP_POLLING_COUNT =
0; /* clear polling counter */
} else
g_chip_monitor_data->HX_CHIP_POLLING_COUNT++;
g_chip_monitor_data->HX_CHIP_MONITOR_EN = 1;
queue_delayed_work(private_ts->himax_chip_monitor_wq,
&private_ts->himax_chip_monitor,
g_chip_monitor_data->HX_POLLING_TIMER * HZ);
}
#endif
#ifdef HX_SMART_WAKEUP
#ifdef HX_GESTURE_TRACK
static void gest_pt_log_coordinate(int rx, int tx)
{
/* driver report x y with range 0 - 255 , we scale it up to x/y pixel */
gest_pt_x[gest_pt_cnt] = rx * (ic_data->HX_X_RES) / 255;
gest_pt_y[gest_pt_cnt] = tx * (ic_data->HX_Y_RES) / 255;
}
#endif
static int himax_parse_wake_event(struct himax_ts_data *ts)
{
uint8_t *buf;
#ifdef HX_GESTURE_TRACK
int tmp_max_x = 0x00, tmp_min_x = 0xFFFF, tmp_max_y = 0x00,
tmp_min_y = 0xFFFF;
int gest_len;
#endif
int i = 0, check_FC = 0, gesture_flag = 0;
buf = kcalloc(hx_touch_data->event_size, sizeof(uint8_t), GFP_KERNEL);
memcpy(buf, hx_touch_data->hx_event_buf, hx_touch_data->event_size);
for (i = 0; i < GEST_PTLG_ID_LEN; i++) {
if (check_FC == 0) {
if ((buf[0] != 0x00) &&
((buf[0] <= 0x0F) || (buf[0] == 0x80))) {
check_FC = 1;
gesture_flag = buf[i];
} else {
check_FC = 0;
I("ID START at %x , value = %x skip\n",
i, buf[i]);
break;
}
} else {
if (buf[i] != gesture_flag) {
check_FC = 0;
I("ID NOT the same %x != %x So STOP\n",
buf[i], gesture_flag);
break;
}
}
I("0x%2.2X ", buf[i]);
if (i % 8 == 7)
I("\n");
}
I("Himax gesture_flag= %x\n", gesture_flag);
I("Himax check_FC is %d\n", check_FC);
if (check_FC == 0)
return 0;
if (buf[GEST_PTLG_ID_LEN] != GEST_PTLG_HDR_ID1 ||
buf[GEST_PTLG_ID_LEN + 1] != GEST_PTLG_HDR_ID2)
return 0;
#ifdef HX_GESTURE_TRACK
if (buf[GEST_PTLG_ID_LEN] == GEST_PTLG_HDR_ID1 &&
buf[GEST_PTLG_ID_LEN + 1] == GEST_PTLG_HDR_ID2) {
gest_len = buf[GEST_PTLG_ID_LEN + 2];
I("gest_len = %d ", gest_len);
i = 0;
gest_pt_cnt = 0;
I("gest doornidate start\n %s", __func__);
while (i < (gest_len + 1) / 2) {
gest_pt_log_coordinate(
buf[GEST_PTLG_ID_LEN + 4 + i * 2],
buf[GEST_PTLG_ID_LEN + 4 + i * 2 + 1]);
i++;
I("gest_pt_x[%d]=%d\n", gest_pt_cnt,
gest_pt_x[gest_pt_cnt]);
I("gest_pt_y[%d]=%d\n", gest_pt_cnt,
gest_pt_y[gest_pt_cnt]);
gest_pt_cnt += 1;
}
if (gest_pt_cnt) {
for (i = 0; i < gest_pt_cnt; i++) {
if (tmp_max_x < gest_pt_x[i])
tmp_max_x = gest_pt_x[i];
if (tmp_min_x > gest_pt_x[i])
tmp_min_x = gest_pt_x[i];
if (tmp_max_y < gest_pt_y[i])
tmp_max_y = gest_pt_y[i];
if (tmp_min_y > gest_pt_y[i])
tmp_min_y = gest_pt_y[i];
}
I("x_min=%d, x_max=%d, y_min=%d, y_max=%d\n",
tmp_min_x, tmp_max_x, tmp_min_y, tmp_max_y);
gest_start_x = gest_pt_x[0];
gn_gesture_coor[0] = gest_start_x;
gest_start_y = gest_pt_y[0];
gn_gesture_coor[1] = gest_start_y;
gest_end_x = gest_pt_x[gest_pt_cnt - 1];
gn_gesture_coor[2] = gest_end_x;
gest_end_y = gest_pt_y[gest_pt_cnt - 1];
gn_gesture_coor[3] = gest_end_y;
gest_width = tmp_max_x - tmp_min_x;
gn_gesture_coor[4] = gest_width;
gest_height = tmp_max_y - tmp_min_y;
gn_gesture_coor[5] = gest_height;
gest_mid_x = (tmp_max_x + tmp_min_x) / 2;
gn_gesture_coor[6] = gest_mid_x;
gest_mid_y = (tmp_max_y + tmp_min_y) / 2;
gn_gesture_coor[7] = gest_mid_y;
gn_gesture_coor[8] = gest_mid_x; /* gest_up_x */
gn_gesture_coor[9] =
gest_mid_y - gest_height / 2; /* gest_up_y */
gn_gesture_coor[10] = gest_mid_x; /* gest_down_x */
gn_gesture_coor[11] =
gest_mid_y + gest_height / 2; /* gest_down_y */
gn_gesture_coor[12] =
gest_mid_x - gest_width / 2; /* gest_left_x */
gn_gesture_coor[13] = gest_mid_y; /* gest_left_y */
gn_gesture_coor[14] =
gest_mid_x + gest_width / 2; /* gest_right_x */
gn_gesture_coor[15] = gest_mid_y; /* gest_right_y */
}
}
#endif
if (gesture_flag != 0x80) {
if (!ts->gesture_cust_en[gesture_flag]) {
I("%s NOT report customer key\n ", __func__);
return 0; /* NOT report customer key */
}
} else {
if (!ts->gesture_cust_en[0]) {
I("%s NOT report report double click\n", __func__);
return 0; /* NOT report power key */
}
}
if (gesture_flag == 0x80)
return EV_GESTURE_PWR;
else
return gesture_flag;
}
void himax_wake_check_func(void)
{
int ret_event = 0, KEY_EVENT = 0;
ret_event = himax_parse_wake_event(private_ts);
switch (ret_event) {
case EV_GESTURE_PWR:
KEY_EVENT = KEY_POWER;
break;
case EV_GESTURE_01:
KEY_EVENT = KEY_CUST_01;
break;
case EV_GESTURE_02:
KEY_EVENT = KEY_CUST_02;
break;
case EV_GESTURE_03:
KEY_EVENT = KEY_CUST_03;
break;
case EV_GESTURE_04:
KEY_EVENT = KEY_CUST_04;
break;
case EV_GESTURE_05:
KEY_EVENT = KEY_CUST_05;
break;
case EV_GESTURE_06:
KEY_EVENT = KEY_CUST_06;
break;
case EV_GESTURE_07:
KEY_EVENT = KEY_CUST_07;
break;
case EV_GESTURE_08:
KEY_EVENT = KEY_CUST_08;
break;
case EV_GESTURE_09:
KEY_EVENT = KEY_CUST_09;
break;
case EV_GESTURE_10:
KEY_EVENT = KEY_CUST_10;
break;
case EV_GESTURE_11:
KEY_EVENT = KEY_CUST_11;
break;
case EV_GESTURE_12:
KEY_EVENT = KEY_CUST_12;
break;
case EV_GESTURE_13:
KEY_EVENT = KEY_CUST_13;
break;
case EV_GESTURE_14:
KEY_EVENT = KEY_CUST_14;
break;
case EV_GESTURE_15:
KEY_EVENT = KEY_CUST_15;
break;
}
if (ret_event) {
I(" %s SMART WAKEUP KEY event %x press\n", __func__, KEY_EVENT);
input_report_key(private_ts->input_dev, KEY_EVENT, 1);
input_sync(private_ts->input_dev);
/* msleep(100); */
I(" %s SMART WAKEUP KEY event %x release\n", __func__,
KEY_EVENT);
input_report_key(private_ts->input_dev, KEY_EVENT, 0);
input_sync(private_ts->input_dev);
FAKE_POWER_KEY_SEND = true;
#ifdef HX_GESTURE_TRACK
I("start_x= %d, start_y= %d, end_x= %d, end_y= %d\n",
gest_start_x, gest_start_y, gest_end_x, gest_end_y);
I("width= %d, height= %d, mid_x= %d, mid_y= %d\n",
gest_width, gest_height, gest_mid_x, gest_mid_y);
I("up_x= %d, up_y= %d, down_x= %d, down_y= %d\n",
gn_gesture_coor[8], gn_gesture_coor[9], gn_gesture_coor[10],
gn_gesture_coor[11]);
I("left_x= %d, left_y= %d, right_x= %d, right_y= %d\n",
gn_gesture_coor[12], gn_gesture_coor[13], gn_gesture_coor[14],
gn_gesture_coor[15]);
#endif
}
}
#endif
#if defined(HX_EN_SEL_BUTTON) || defined(HX_EN_MUT_BUTTON)
static void himax_ts_button_func(int tp_key_index, struct himax_ts_data *ts)
{
uint16_t x_position = 0, y_position = 0;
if (tp_key_index != 0x00) {
I("virtual key index =%x\n", tp_key_index);
if (tp_key_index == 0x01) {
vk_press = 1;
I("back key pressed\n");
if (ts->pdata->virtual_key) {
if (ts->button[0].index) {
x_position =
(ts->button[0].x_range_min +
ts->button[0].x_range_max) /
2;
y_position =
(ts->button[0].y_range_min +
ts->button[0].y_range_max) /
2;
}
#ifdef HX_PROTOCOL_A
input_report_abs(ts->input_dev,
ABS_MT_TOUCH_MAJOR, 100);
input_report_abs(ts->input_dev,
ABS_MT_TRACKING_ID, 0);
input_report_abs(ts->input_dev,
ABS_MT_POSITION_X, x_position);
input_report_abs(ts->input_dev,
ABS_MT_POSITION_Y, y_position);
input_mt_sync(ts->input_dev);
#else
input_mt_slot(ts->input_dev, 0);
input_mt_report_slot_state(ts->input_dev,
MT_TOOL_FINGER, 1);
input_report_abs(ts->input_dev,
ABS_MT_TOUCH_MAJOR, 100);
input_report_abs(ts->input_dev,
ABS_MT_WIDTH_MAJOR, 100);
input_report_abs(ts->input_dev, ABS_MT_PRESSURE,
100);
input_report_abs(ts->input_dev,
ABS_MT_POSITION_X, x_position);
input_report_abs(ts->input_dev,
ABS_MT_POSITION_Y, y_position);
#endif
} else
input_report_key(ts->input_dev, KEY_BACK, 1);
} else if (tp_key_index == 0x02) {
vk_press = 1;
I("home key pressed\n");
if (ts->pdata->virtual_key) {
if (ts->button[1].index) {
x_position =
(ts->button[1].x_range_min +
ts->button[1].x_range_max) /
2;
y_position =
(ts->button[1].y_range_min +
ts->button[1].y_range_max) /
2;
}
#ifdef HX_PROTOCOL_A
input_report_abs(ts->input_dev,
ABS_MT_TRACKING_ID, 0);
input_report_abs(ts->input_dev,
ABS_MT_TOUCH_MAJOR, 100);
input_report_abs(ts->input_dev,
ABS_MT_POSITION_X, x_position);
input_report_abs(ts->input_dev,
ABS_MT_POSITION_Y, y_position);
input_mt_sync(ts->input_dev);
#else
input_mt_slot(ts->input_dev, 0);
input_mt_report_slot_state(ts->input_dev,
MT_TOOL_FINGER, 1);
input_report_abs(ts->input_dev,
ABS_MT_TOUCH_MAJOR, 100);
input_report_abs(ts->input_dev,
ABS_MT_WIDTH_MAJOR, 100);
input_report_abs(ts->input_dev, ABS_MT_PRESSURE,
100);
input_report_abs(ts->input_dev,
ABS_MT_POSITION_X, x_position);
input_report_abs(ts->input_dev,
ABS_MT_POSITION_Y, y_position);
#endif
} else
input_report_key(ts->input_dev, KEY_HOME, 1);
} else if (tp_key_index == 0x04) {
vk_press = 1;
I("APP_switch key pressed\n");
if (ts->pdata->virtual_key) {
if (ts->button[2].index) {
x_position =
(ts->button[2].x_range_min +
ts->button[2].x_range_max) /
2;
y_position =
(ts->button[2].y_range_min +
ts->button[2].y_range_max) /
2;
}
#ifdef HX_PROTOCOL_A
input_report_abs(ts->input_dev,
ABS_MT_TRACKING_ID, 0);
input_report_abs(ts->input_dev, ABS_MT_PRESSURE,
100);
input_report_abs(ts->input_dev,
ABS_MT_POSITION_X, x_position);
input_report_abs(ts->input_dev,
ABS_MT_POSITION_Y, y_position);
input_mt_sync(ts->input_dev);
#else
input_mt_slot(ts->input_dev, 0);
input_mt_report_slot_state(ts->input_dev,
MT_TOOL_FINGER, 1);
input_report_abs(ts->input_dev,
ABS_MT_TOUCH_MAJOR, 100);
input_report_abs(ts->input_dev,
ABS_MT_WIDTH_MAJOR, 100);
input_report_abs(ts->input_dev, ABS_MT_PRESSURE,
100);
input_report_abs(ts->input_dev,
ABS_MT_POSITION_X, x_position);
input_report_abs(ts->input_dev,
ABS_MT_POSITION_Y, y_position);
#endif
} else
input_report_key(ts->input_dev, KEY_APP_SWITCH,
1);
}
input_sync(ts->input_dev);
} else { /*tp_key_index =0x00*/
I("virtual key released\n");
vk_press = 0;
#ifndef HX_PROTOCOL_A
input_mt_slot(ts->input_dev, 0);
input_mt_report_slot_state(ts->input_dev, MT_TOOL_FINGER, 0);
#else
input_mt_sync(ts->input_dev);
#endif
input_report_key(ts->input_dev, KEY_BACK, 0);
input_report_key(ts->input_dev, KEY_HOME, 0);
input_report_key(ts->input_dev, KEY_APP_SWITCH, 0);
#ifndef HX_PROTOCOL_A
input_sync(ts->input_dev);
#endif
}
}
void himax_report_key(struct himax_ts_data *ts)
{
if (hx_point_num != 0) {
/* Touch KEY */
if ((tpd_key_old != 0x00) && (tpd_key == 0x00)) {
/* temp_x[0] = 0xFFFF; */
/* temp_y[0] = 0xFFFF; */
/* temp_x[1] = 0xFFFF; */
/* temp_y[1] = 0xFFFF; */
hx_touch_data->finger_on = 0;
#ifdef HX_PROTOCOL_A
input_report_key(ts->input_dev, BTN_TOUCH,
hx_touch_data->finger_on);
#endif
himax_ts_button_func(tpd_key, ts);
}
#ifndef HX_PROTOCOL_A
input_report_key(ts->input_dev, BTN_TOUCH,
hx_touch_data->finger_on);
#endif
input_sync(ts->input_dev);
} else {
if (tpd_key != 0x00) {
hx_touch_data->finger_on = 1;
#ifdef HX_PROTOCOL_A
input_report_key(ts->input_dev, BTN_TOUCH,
hx_touch_data->finger_on);
#endif
himax_ts_button_func(tpd_key, ts);
} else if ((tpd_key_old != 0x00) && (tpd_key == 0x00)) {
hx_touch_data->finger_on = 0;
#ifdef HX_PROTOCOL_A
input_report_key(ts->input_dev, BTN_TOUCH,
hx_touch_data->finger_on);
#endif
himax_ts_button_func(tpd_key, ts);
}
#ifndef HX_PROTOCOL_A
input_report_key(ts->input_dev, BTN_TOUCH,
hx_touch_data->finger_on);
#endif
input_sync(ts->input_dev);
}
tpd_key_old = tpd_key;
Last_EN_NoiseFilter = EN_NoiseFilter;
}
#endif
int himax_report_data_init(void)
{
if (hx_touch_data->hx_coord_buf != NULL)
kfree(hx_touch_data->hx_coord_buf);
#ifdef HX_TP_PROC_DIAG
if (hx_touch_data->hx_rawdata_buf != NULL)
kfree(hx_touch_data->hx_rawdata_buf);
#endif
#if defined(HX_SMART_WAKEUP)
hx_touch_data->event_size = himax_get_touch_data_size();
if (hx_touch_data->hx_event_buf != NULL)
kfree(hx_touch_data->hx_event_buf);
#endif
hx_touch_data->touch_all_size = himax_get_touch_data_size();
hx_touch_data->raw_cnt_max = ic_data->HX_MAX_PT / 4;
hx_touch_data->raw_cnt_rmd = ic_data->HX_MAX_PT % 4;
if (hx_touch_data->raw_cnt_rmd != 0x00) { /* more than 4 fingers */
hx_touch_data->rawdata_size = cal_data_len(
hx_touch_data->raw_cnt_rmd, ic_data->HX_MAX_PT,
hx_touch_data->raw_cnt_max);
hx_touch_data->touch_info_size =
(ic_data->HX_MAX_PT + hx_touch_data->raw_cnt_max + 2) *
4;
} else { /* less than 4 fingers */
hx_touch_data->rawdata_size = cal_data_len(
hx_touch_data->raw_cnt_rmd, ic_data->HX_MAX_PT,
hx_touch_data->raw_cnt_max);
hx_touch_data->touch_info_size =
(ic_data->HX_MAX_PT + hx_touch_data->raw_cnt_max + 1) *
4;
}
if ((ic_data->HX_TX_NUM * ic_data->HX_RX_NUM + ic_data->HX_TX_NUM +
ic_data->HX_RX_NUM) %
hx_touch_data->rawdata_size ==
0)
hx_touch_data->rawdata_frame_size =
(ic_data->HX_TX_NUM * ic_data->HX_RX_NUM +
ic_data->HX_TX_NUM + ic_data->HX_RX_NUM) /
hx_touch_data->rawdata_size;
else
hx_touch_data->rawdata_frame_size =
(ic_data->HX_TX_NUM * ic_data->HX_RX_NUM +
ic_data->HX_TX_NUM + ic_data->HX_RX_NUM) /
hx_touch_data->rawdata_size +
1;
I("%s: rawdata_frame_size = %d ", __func__,
hx_touch_data->rawdata_frame_size);
I("%s: ic_data->HX_MAX_PT:%d,hx_raw_cnt_max:%d,hx_raw_cnt_rmd:%d,",
__func__, ic_data->HX_MAX_PT, hx_touch_data->raw_cnt_max,
hx_touch_data->raw_cnt_rmd);
I("g_hx_rawdata_size:%d,hx_touch_data->touch_info_size:%d\n",
hx_touch_data->rawdata_size, hx_touch_data->touch_info_size);
hx_touch_data->hx_coord_buf = kzalloc(
sizeof(uint8_t) * (hx_touch_data->touch_info_size), GFP_KERNEL);
if (hx_touch_data->hx_coord_buf == NULL)
goto mem_alloc_fail;
#ifdef HX_TP_PROC_DIAG
hx_touch_data->hx_rawdata_buf =
kzalloc(sizeof(uint8_t) * (hx_touch_data->touch_all_size -
hx_touch_data->touch_info_size),
GFP_KERNEL);
if (hx_touch_data->hx_rawdata_buf == NULL)
goto mem_alloc_fail;
#endif
#if defined(HX_SMART_WAKEUP)
hx_touch_data->hx_event_buf = kzalloc(
sizeof(uint8_t) * (hx_touch_data->event_size), GFP_KERNEL);
if (hx_touch_data->hx_event_buf == NULL)
goto mem_alloc_fail;
#endif
return NO_ERR;
mem_alloc_fail:
kfree(hx_touch_data->hx_coord_buf);
#if defined(HX_TP_PROC_DIAG)
kfree(hx_touch_data->hx_rawdata_buf);
#endif
#if defined(HX_SMART_WAKEUP)
kfree(hx_touch_data->hx_event_buf);
#endif
I("%s: Memory allocate fail!\n", __func__);
return MEM_ALLOC_FAIL;
}
#if defined(HX_USB_DETECT_GLOBAL)
void himax_cable_detect_func(bool force_renew)
{
struct himax_ts_data *ts;
u32 connect_status = 0;
connect_status = USB_detect_flag; /* upmu_is_chr_det(); */
ts = private_ts;
/* I("Touch: cable status=%d, cable_config=%p, usb_connected=%d\n", */
/* connect_status,ts->cable_config, ts->usb_connected); */
if (ts->cable_config) {
if (((!!connect_status) != ts->usb_connected) || force_renew) {
if (!!connect_status) {
ts->cable_config[1] = 0x01;
ts->usb_connected = 0x01;
} else {
ts->cable_config[1] = 0x00;
ts->usb_connected = 0x00;
}
himax_usb_detect_set(ts->client, ts->cable_config);
I("%s: Cable status change: 0x%2.2X\n", __func__,
ts->usb_connected);
}
/* else */
/* I("%s: Cable status is the same as previous one, */
/* ignore.\n", __func__); */
}
}
#endif
static void himax_report_points(struct himax_ts_data *ts)
{
int x = 0;
int y = 0;
int w = 0;
int base = 0;
int32_t loop_i = 0;
uint16_t old_finger = 0;
/* I("%s:Entering\n",__func__); */
/* finger on/press */
if (hx_point_num != 0) {
old_finger = ts->pre_finger_mask;
ts->pre_finger_mask = 0;
hx_touch_data->finger_num =
hx_touch_data->hx_coord_buf[ts->coordInfoSize - 4] &
0x0F;
hx_touch_data->finger_on = 1;
AA_press = 1;
for (loop_i = 0; loop_i < ts->nFinger_support; loop_i++) {
base = loop_i * 4;
x = hx_touch_data->hx_coord_buf[base] << 8 |
hx_touch_data->hx_coord_buf[base + 1];
y = (hx_touch_data->hx_coord_buf[base + 2] << 8 |
hx_touch_data->hx_coord_buf[base + 3]);
w = hx_touch_data
->hx_coord_buf[(ts->nFinger_support * 4) +
loop_i];
/* x = ic_data->HX_X_RES - x; */
/* y = ic_data->HX_Y_RES - y; */
if (x >= 0 && x <= ts->pdata->abs_x_max && y >= 0 &&
y <= ts->pdata->abs_y_max) {
hx_touch_data->finger_num--;
if ((ts->debug_log_level & BIT(3)) > 0) {
himax_log_touch_event_detail(
ts, x, y, w, loop_i,
EN_NoiseFilter, HX_FINGER_ON,
old_finger);
}
#ifndef HX_PROTOCOL_A
input_mt_slot(ts->input_dev, loop_i);
#endif
input_report_key(ts->input_dev, BTN_TOUCH,
hx_touch_data->finger_on);
input_report_abs(ts->input_dev,
ABS_MT_TOUCH_MAJOR, w);
input_report_abs(ts->input_dev,
ABS_MT_TRACKING_ID, loop_i);
#ifndef HX_PROTOCOL_A
input_report_abs(ts->input_dev,
ABS_MT_WIDTH_MAJOR, w);
input_report_abs(ts->input_dev, ABS_MT_PRESSURE,
w);
#endif
input_report_abs(ts->input_dev,
ABS_MT_POSITION_X, x);
input_report_abs(ts->input_dev,
ABS_MT_POSITION_Y, y);
#ifndef HX_PROTOCOL_A
ts->last_slot = loop_i;
input_mt_report_slot_state(ts->input_dev,
MT_TOOL_FINGER, 1);
#else
input_mt_sync(ts->input_dev);
#endif
if (!ts->first_pressed) {
ts->first_pressed = 1;
I("S1@%d, %d\n", x, y);
}
ts->pre_finger_data[loop_i][0] = x;
ts->pre_finger_data[loop_i][1] = y;
if (ts->debug_log_level & BIT(1))
himax_log_touch_event(x, y, w, loop_i,
EN_NoiseFilter,
HX_FINGER_ON);
ts->pre_finger_mask =
ts->pre_finger_mask + (1 << loop_i);
}
/* report coordinates */
else {
#ifndef HX_PROTOCOL_A
input_mt_slot(ts->input_dev, loop_i);
input_mt_report_slot_state(ts->input_dev,
MT_TOOL_FINGER, 0);
#endif
if (loop_i == 0 && ts->first_pressed == 1) {
ts->first_pressed = 2;
I("E1@%d, %d\n",
ts->pre_finger_data[0][0],
ts->pre_finger_data[0][1]);
}
if ((ts->debug_log_level & BIT(3)) > 0) {
himax_log_touch_event_detail(
ts, x, y, w, loop_i,
Last_EN_NoiseFilter,
HX_FINGER_LEAVE, old_finger);
}
}
}
#ifndef HX_PROTOCOL_A
input_report_key(ts->input_dev, BTN_TOUCH,
hx_touch_data->finger_on);
#endif
input_sync(ts->input_dev);
}
/* finger leave/release */
else {
#if defined(HX_PALM_REPORT)
if (himax_palm_detect(hx_touch_data->hx_coord_buf) == NO_ERR) {
I(" %s HX_PALM_REPORT KEY power event press\n",
__func__);
input_report_key(ts->input_dev, KEY_POWER, 1);
input_sync(ts->input_dev);
msleep(100);
I(" %s HX_PALM_REPORT KEY power event release\n",
__func__);
input_report_key(ts->input_dev, KEY_POWER, 0);
input_sync(ts->input_dev);
return;
}
#endif
hx_touch_data->finger_on = 0;
AA_press = 0;
#ifdef HX_PROTOCOL_A
input_mt_sync(ts->input_dev);
#endif
for (loop_i = 0; loop_i < ts->nFinger_support; loop_i++) {
if (((ts->pre_finger_mask >> loop_i) & 1) == 1) {
#ifndef HX_PROTOCOL_A
input_mt_slot(ts->input_dev, loop_i);
input_mt_report_slot_state(ts->input_dev,
MT_TOOL_FINGER, 0);
#endif
}
if (ts->pre_finger_mask > 0 &&
(ts->debug_log_level & BIT(3)) > 0) {
if (((ts->pre_finger_mask >> loop_i) & 1) ==
1) {
if (ts->useScreenRes) {
I("%X,%02d,%d,%d,%d\n",
0, loop_i + 1,
ts->pre_finger_data[loop_i]
[0] *
ts->widthFactor >>
SHIFTBITS,
ts->pre_finger_data[loop_i]
[1] *
ts->heightFactor >>
SHIFTBITS,
Last_EN_NoiseFilter);
} else {
I("%X,%02d,%d,%d,%d\n",
0, loop_i + 1,
ts->pre_finger_data[loop_i]
[0],
ts->pre_finger_data[loop_i]
[1],
Last_EN_NoiseFilter);
}
}
}
}
if (ts->pre_finger_mask > 0)
ts->pre_finger_mask = 0;
if (ts->first_pressed == 1) {
ts->first_pressed = 2;
I("E1@%d, %d\n", ts->pre_finger_data[0][0],
ts->pre_finger_data[0][1]);
}
if (ts->debug_log_level & BIT(1))
himax_log_touch_event(x, y, w, loop_i, EN_NoiseFilter,
HX_FINGER_LEAVE);
input_report_key(ts->input_dev, BTN_TOUCH,
hx_touch_data->finger_on);
input_sync(ts->input_dev);
}
Last_EN_NoiseFilter = EN_NoiseFilter;
/* I("%s:End\n",__func__); */
}
static void himax_report_all_leave(struct himax_ts_data *ts)
{
int loop_i = 0;
for (loop_i = 0; loop_i < ts->nFinger_support; loop_i++) {
#ifndef HX_PROTOCOL_A
input_mt_slot(ts->input_dev, loop_i);
input_mt_report_slot_state(ts->input_dev, MT_TOOL_FINGER, 0);
#endif
}
input_report_key(ts->input_dev, BTN_TOUCH, 0);
input_sync(ts->input_dev);
}
int himax_touch_get(struct himax_ts_data *ts, uint8_t *buf, int ts_status)
{
int ret = 0;
switch (ts_status) {
/*normal*/
case 1:
#ifdef HX_TP_PROC_DIAG
hx_touch_data->diag_cmd = getDiagCommand();
if ((hx_touch_data->diag_cmd) || (HX_HW_RESET_ACTIVATE)
#ifdef HX_ESD_RECOVERY
|| (HX_ESD_RESET_ACTIVATE)
#endif
) {
ret = himax_read_event_stack(ts->client, buf, 128);
} else {
ret = himax_read_event_stack(
ts->client, buf,
hx_touch_data->touch_info_size);
}
if (!ret)
#else
if (!himax_read_event_stack(ts->client, buf,
hx_touch_data->touch_info_size))
#endif
{
E("%s: can't read data from chip!\n", __func__);
goto err_workqueue_out;
}
break;
#if defined(HX_SMART_WAKEUP)
/*SMWP*/
case 2:
himax_burst_enable(ts->client, 0);
if (!himax_read_event_stack(ts->client, buf,
hx_touch_data->event_size)) {
E("%s: can't read data from chip!\n", __func__);
goto err_workqueue_out;
}
break;
#endif
default:
break;
}
return NO_ERR;
err_workqueue_out:
return I2C_FAIL;
}
int himax_checksum_cal(struct himax_ts_data *ts, uint8_t *buf, int ts_status)
{
#if defined(HX_ESD_RECOVERY)
int hx_EB_event = 0;
int hx_EC_event = 0;
int hx_ED_event = 0;
int hx_esd_event = 0;
int hx_zero_event = 0;
int shaking_ret = 0;
#endif
uint16_t check_sum_cal = 0;
int32_t loop_i = 0;
int length = 0;
/* Normal */
if (ts_status == HX_REPORT_COORD)
length = hx_touch_data->touch_info_size;
#if defined(HX_SMART_WAKEUP)
/* SMWP */
else if (ts_status == HX_REPORT_SMWP_EVENT)
length = (GEST_PTLG_ID_LEN + GEST_PTLG_HDR_LEN);
#endif
else
I("%s, Neither Normal Nor SMWP error!\n", __func__);
/* I("Now status=%d,length=%d\n",ts_status,length); */
for (loop_i = 0; loop_i < length; loop_i++) {
check_sum_cal += buf[loop_i];
#ifdef HX_ESD_RECOVERY
if (ts_status == HX_REPORT_COORD) {
/* case 1 ESD recovery flow */
if (buf[loop_i] == 0xEB)
hx_EB_event++;
else if (buf[loop_i] == 0xEC)
hx_EC_event++;
else if (buf[loop_i] == 0xED)
hx_ED_event++;
/* case 2 ESD recovery flow-Disable */
else if (buf[loop_i] == 0x00)
hx_zero_event++;
else {
hx_EB_event = 0;
hx_EC_event = 0;
hx_ED_event = 0;
hx_zero_event = 0;
g_zero_event_count = 0;
}
if (hx_EB_event == length) {
hx_esd_event = length;
hx_EB_event_flag++;
I("[HIMAX TP MSG]: ALL 0xEB.\n");
} else if (hx_EC_event == length) {
hx_esd_event = length;
hx_EC_event_flag++;
I("[HIMAX TP MSG]: ALL 0xEC.\n");
} else if (hx_ED_event == length) {
hx_esd_event = length;
hx_ED_event_flag++;
I("[HIMAX TP MSG]: ALL 0xED.\n");
} else {
hx_esd_event = 0;
}
}
#endif
}
if (ts_status == HX_REPORT_COORD) {
#ifdef HX_ESD_RECOVERY
if ((hx_esd_event == length || hx_zero_event == length) &&
(HX_HW_RESET_ACTIVATE == 0) && (HX_ESD_RESET_ACTIVATE == 0)
#if defined(HX_TP_PROC_DIAG)
&& (hx_touch_data->diag_cmd == 0)
#endif
#if defined(HX_TP_PROC_SELF_TEST) || defined(CONFIG_TOUCHSCREEN_HIMAX_ITO_TEST)
&& (g_self_test_entered == 0)
#endif
) {
shaking_ret = himax_ic_esd_recovery(
hx_esd_event, hx_zero_event, length);
if (shaking_ret == CHECKSUM_FAIL) {
himax_esd_hw_reset();
goto checksum_fail;
} else if (shaking_ret == ERR_WORK_OUT)
goto err_workqueue_out;
else {
/* I("I2C running. Nothing to be done!\n"); */
goto workqueue_out;
}
} else if (HX_ESD_RESET_ACTIVATE) {
#if defined(HX_SMART_WAKEUP) || defined(HX_HIGH_SENSE) || \
defined(HX_USB_DETECT_GLOBAL)
#ifdef HX_RESUME_SEND_CMD
himax_rst_cmd_recovery_func(ts->suspended);
#endif
#endif
/* drop 1st interrupts after chip reset */
HX_ESD_RESET_ACTIVATE = 0;
I("[HX_ESD_RESET_ACTIVATE]:%s:\n",
/* Back from reset, ready to serve */
__func__);
goto checksum_fail;
}
else if (HX_HW_RESET_ACTIVATE)
#else
if (HX_HW_RESET_ACTIVATE)
#endif
{
#if defined(HX_SMART_WAKEUP) || defined(HX_HIGH_SENSE) || \
defined(HX_USB_DETECT_GLOBAL)
#ifdef HX_RESUME_SEND_CMD
himax_rst_cmd_recovery_func(ts->suspended);
#endif
#endif
/* drop 1st interrupts after chip reset */
HX_HW_RESET_ACTIVATE = 0;
I("[HX_HW_RESET_ACTIVATE]:%s:\n",
/* Back from reset, ready to serve */
__func__);
goto ready_to_serve;
}
}
if ((check_sum_cal % 0x100 != 0)) {
I("[HIMAX TP MSG] checksum fail : check_sum_cal: 0x%02X\n",
check_sum_cal);
goto checksum_fail;
}
/* I("%s:End\n",__func__); */
return NO_ERR;
ready_to_serve:
return READY_TO_SERVE;
checksum_fail:
return CHECKSUM_FAIL;
#ifdef HX_ESD_RECOVERY
err_workqueue_out:
return ERR_WORK_OUT;
workqueue_out:
return WORK_OUT;
#endif
}
int himax_ts_work_status(struct himax_ts_data *ts)
{
/* 1: normal, 2:SMWP */
int result = HX_REPORT_COORD;
uint8_t diag_cmd = 0;
#ifdef HX_TP_PROC_DIAG
diag_cmd = getDiagCommand();
#endif
#ifdef HX_SMART_WAKEUP
if (atomic_read(&ts->suspend_mode) && (!FAKE_POWER_KEY_SEND) &&
(ts->SMWP_enable) && (!diag_cmd)) {
result = HX_REPORT_SMWP_EVENT;
}
#endif
/* I("Now Status is %d\n",result); */
return result;
}
void himax_assign_touch_data(uint8_t *buf, int ts_status)
{
uint8_t hx_state_info_pos = hx_touch_data->touch_info_size - 3;
if (ts_status == HX_REPORT_COORD) {
memcpy(hx_touch_data->hx_coord_buf, &buf[0],
hx_touch_data->touch_info_size);
if (buf[hx_state_info_pos] != 0xFF &&
buf[hx_state_info_pos + 1] != 0xFF)
memcpy(hx_touch_data->hx_state_info,
&buf[hx_state_info_pos], 2);
else
memset(hx_touch_data->hx_state_info, 0x00,
sizeof(hx_touch_data->hx_state_info));
}
#if defined(HX_SMART_WAKEUP)
else
memcpy(hx_touch_data->hx_event_buf, buf,
hx_touch_data->event_size);
#endif
#ifdef HX_TP_PROC_DIAG
if ((hx_touch_data->diag_cmd) || (HX_HW_RESET_ACTIVATE)
#ifdef HX_ESD_RECOVERY
|| (HX_ESD_RESET_ACTIVATE)
#endif
) {
memcpy(hx_touch_data->hx_rawdata_buf,
&buf[hx_touch_data->touch_info_size],
hx_touch_data->touch_all_size -
hx_touch_data->touch_info_size);
}
#endif
}
void himax_coord_report(struct himax_ts_data *ts)
{
#if defined(HX_TP_PROC_DIAG)
/* touch monitor raw data fetch */
if (himax_set_diag_cmd(ic_data, hx_touch_data))
I("%s: coordinate dump fail and bypass with checksum err\n",
__func__);
#endif
EN_NoiseFilter =
(hx_touch_data->hx_coord_buf[HX_TOUCH_INFO_POINT_CNT + 2] >> 3);
/* I("EN_NoiseFilter=%d\n",EN_NoiseFilter); */
EN_NoiseFilter = EN_NoiseFilter & 0x01;
/* I("EN_NoiseFilter2=%d\n",EN_NoiseFilter); */
#if defined(HX_EN_SEL_BUTTON) || defined(HX_EN_MUT_BUTTON)
tpd_key =
(hx_touch_data->hx_coord_buf[HX_TOUCH_INFO_POINT_CNT + 2] >> 4);
/* All (VK+AA)leave */
if (tpd_key == 0x0F)
tpd_key = 0x00;
/* I("[DEBUG] tpd_key: %x\r\n", tpd_key); */
#else
tpd_key = 0x00;
#endif
p_point_num = hx_point_num;
if (hx_touch_data->hx_coord_buf[HX_TOUCH_INFO_POINT_CNT] == 0xff)
hx_point_num = 0;
else
hx_point_num =
hx_touch_data->hx_coord_buf[HX_TOUCH_INFO_POINT_CNT] &
0x0f;
/* Touch Point information */
if (!tpd_key && !tpd_key_old)
himax_report_points(ts);
#if defined(HX_EN_SEL_BUTTON) || defined(HX_EN_MUT_BUTTON)
else
himax_report_key(ts);
#endif
/* I("%s:END\n",__func__); */
}
void himax_ts_work(struct himax_ts_data *ts)
{
uint8_t hw_reset_check[2];
uint8_t buf[128];
int check_sum_cal = 0;
/* int loop_i = 0; */
int ts_status = 0;
#ifdef HX_CHIP_STATUS_MONITOR
int j = 0;
#endif
#if defined(HX_USB_DETECT_GLOBAL)
himax_cable_detect_func(false);
#endif
#if defined(HX_CHIP_STATUS_MONITOR)
g_chip_monitor_data->HX_CHIP_POLLING_COUNT = 0;
if (g_chip_monitor_data->HX_ON_HAND_SHAKING) /* chip on hand */
/* shaking,wait hand */
/* shaking */
{
for (j = 0; j < 100; j++) {
if (g_chip_monitor_data->HX_ON_HAND_SHAKING ==
0) { /* chip on hand shaking end */
I("%s:HX_ON_HAND_SHAKING OK check %d times\n",
__func__, j);
break;
}
msleep(20);
}
if (j == 100) {
E("%s:HX_ON_HAND_SHAKING timeout reject interrupt\n",
__func__);
return;
}
}
#endif
ts_status = himax_ts_work_status(ts);
if (ts_status > HX_REPORT_SMWP_EVENT || ts_status < HX_REPORT_COORD)
goto neither_normal_nor_smwp;
memset(buf, 0x00, sizeof(buf));
memset(hw_reset_check, 0x00, sizeof(hw_reset_check));
/* I("New Method for ts_work\n"); */
if (himax_touch_get(ts, buf, ts_status))
goto err_workqueue_out;
if (ts->debug_log_level & BIT(0))
himax_log_touch_data(buf, hx_touch_data);
check_sum_cal = himax_checksum_cal(ts, buf, ts_status);
if (check_sum_cal == CHECKSUM_FAIL)
goto checksum_fail;
else if (check_sum_cal == READY_TO_SERVE)
goto ready_to_serve;
else if (check_sum_cal == ERR_WORK_OUT)
goto err_workqueue_out;
else if (check_sum_cal == WORK_OUT)
goto workqueue_out;
/* checksum calculate pass and assign data to global touch data*/
else
himax_assign_touch_data(buf, ts_status);
if (ts_status == HX_REPORT_COORD)
himax_coord_report(ts);
#if defined(HX_SMART_WAKEUP)
else {
wake_lock_timeout(&ts->ts_SMWP_wake_lock, TS_WAKE_LOCK_TIMEOUT);
himax_wake_check_func();
}
#endif
checksum_fail:
workqueue_out:
ready_to_serve:
neither_normal_nor_smwp:
return;
err_workqueue_out:
I("%s: Now reset the Touch chip.\n", __func__);
#ifdef HX_RST_PIN_FUNC
himax_ic_reset(false, true);
#endif
goto workqueue_out;
}
enum hrtimer_restart himax_ts_timer_func(struct hrtimer *timer)
{
struct himax_ts_data *ts;
ts = container_of(timer, struct himax_ts_data, timer);
queue_work(ts->himax_wq, &ts->work);
hrtimer_start(&ts->timer, ktime_set(0, 12500000), HRTIMER_MODE_REL);
return HRTIMER_NORESTART;
}
#if defined(HX_USB_DETECT_CALLBACK)
static void himax_cable_tp_status_handler_func(int connect_status)
{
struct himax_ts_data *ts;
I("Touch: cable change to %d\n", connect_status);
ts = private_ts;
if (ts->cable_config) {
if (!atomic_read(&ts->suspend_mode)) {
if ((!!connect_status) != ts->usb_connected) {
if (!!connect_status) {
ts->cable_config[1] = 0x01;
ts->usb_connected = 0x01;
} else {
ts->cable_config[1] = 0x00;
ts->usb_connected = 0x00;
}
i2c_himax_master_write(ts->client,
ts->cable_config,
sizeof(ts->cable_config),
DEFAULT_RETRY_CNT);
I("%s:change: 0x%2.2X\n",
__func__, ts->cable_config[1]);
} else
I("%s:same as previous one, ignore.\n",
__func__);
} else {
if (connect_status)
ts->usb_connected = 0x01;
else
ts->usb_connected = 0x00;
I("%s: Cable status remembered: 0x%2.2X\n", __func__,
ts->usb_connected);
}
}
}
static struct t_cable_status_notifier himax_cable_status_handler = {
.name = "usb_tp_connected", .func = himax_cable_tp_status_handler_func,
};
#endif
#ifdef HX_AUTO_UPDATE_FW
static void himax_update_register(struct work_struct *work)
{
I(" %s in", __func__);
#if defined(HX_CHIP_STATUS_MONITOR)
I("Cancel Chip monitor during auto-updating!\n");
g_chip_monitor_data->HX_CHIP_POLLING_COUNT = 0;
g_chip_monitor_data->HX_CHIP_MONITOR_EN = 0;
cancel_delayed_work_sync(&private_ts->himax_chip_monitor);
#endif
if (i_update_FW() == false)
I("NOT Have new FW=NOT UPDATE=\n");
else
I("Have new FW=UPDATE=\n");
#ifdef HX_CHIP_STATUS_MONITOR
I("Auto-updating over, now chip monitor working!\n");
g_chip_monitor_data->HX_CHIP_POLLING_COUNT = 0;
g_chip_monitor_data->HX_CHIP_MONITOR_EN = 1;
queue_delayed_work(private_ts->himax_chip_monitor_wq,
&private_ts->himax_chip_monitor,
g_chip_monitor_data->HX_POLLING_TIMER * HZ);
#endif
}
#endif
#ifdef CONFIG_FB
static void himax_fb_register(struct work_struct *work)
{
int ret = 0;
struct himax_ts_data *ts =
container_of(work, struct himax_ts_data, work_att.work);
I(" %s in\n", __func__);
ts->fb_notif.notifier_call = fb_notifier_callback;
ret = fb_register_client(&ts->fb_notif);
if (ret)
E(" Unable to register fb_notifier: %d\n", ret);
}
#endif
#if defined(CONFIG_TOUCHSCREEN_HIMAX_ITO_TEST)
static void himax_ito_test_work(struct work_struct *work)
{
I(" %s in\n", __func__);
himax_ito_test();
}
#endif
#ifdef HX_TP_PROC_FLASH_DUMP
static void himax_ts_flash_work_func(struct work_struct *work)
{
himax_ts_flash_func();
}
#endif
#ifdef HX_TP_PROC_GUEST_INFO
static void himax_ts_guest_info_work_func(struct work_struct *work)
{
himax_read_project_id();
}
#endif
#ifdef HX_TP_PROC_DIAG
static void himax_ts_diag_work_func(struct work_struct *work)
{
himax_ts_diag_func();
}
#endif
int himax_chip_common_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
#ifdef HX_AUTO_UPDATE_FW
bool auto_update_flag = false;
#endif
int ret = 0, err = 0;
struct himax_ts_data *ts;
struct himax_i2c_platform_data *pdata;
/* Check I2C functionality */
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
E("%s: i2c check functionality error\n", __func__);
err = -ENODEV;
goto err_check_functionality_failed;
}
ts = kzalloc(sizeof(struct himax_ts_data), GFP_KERNEL);
if (ts == NULL) {
E("%s: allocate himax_ts_data failed\n", __func__);
err = -ENOMEM;
goto err_alloc_data_failed;
}
i2c_set_clientdata(client, ts);
ts->client = client;
ts->dev = &client->dev;
mutex_init(&ts->rw_lock);
pdata = kzalloc(sizeof(*pdata), GFP_KERNEL);
if (pdata == NULL) { /*Allocate Platform data space*/
err = -ENOMEM;
goto err_dt_platform_data_fail;
}
ic_data = kzalloc(sizeof(*ic_data), GFP_KERNEL);
if (ic_data == NULL) { /*Allocate IC data space*/
err = -ENOMEM;
goto err_dt_ic_data_fail;
}
/* allocate report data */
hx_touch_data = kzalloc(sizeof(struct himax_report_data), GFP_KERNEL);
if (hx_touch_data == NULL) {
err = -ENOMEM;
goto err_alloc_touch_data_failed;
}
if (himax_parse_dt(ts, pdata) < 0) {
I(" pdata is NULL for DT\n");
goto err_alloc_dt_pdata_failed;
}
#ifdef HX_RST_PIN_FUNC
ts->rst_gpio = pdata->gpio_reset;
#endif
himax_gpio_power_config(ts->client, pdata);
#ifndef CONFIG_OF
if (pdata->power) {
ret = pdata->power(1);
if (ret < 0) {
E("%s: power on failed\n", __func__);
goto err_power_failed;
}
}
#endif
private_ts = ts;
if (himax_ic_package_check(ts->client) == false) {
E("Himax chip doesn NOT EXIST");
goto err_ic_package_failed;
}
if (pdata->virtual_key)
ts->button = pdata->virtual_key;
#ifdef HX_TP_PROC_FLASH_DUMP
ts->flash_wq = create_singlethread_workqueue("himax_flash_wq");
if (!ts->flash_wq) {
E("%s: create flash workqueue failed\n", __func__);
err = -ENOMEM;
goto err_create_flash_dump_wq_failed;
}
INIT_WORK(&ts->flash_work, himax_ts_flash_work_func);
setSysOperation(0);
setFlashBuffer();
#endif
#ifdef HX_TP_PROC_GUEST_INFO
ts->guest_info_wq =
create_singlethread_workqueue("himax_guest_info_wq");
if (!ts->guest_info_wq) {
E("%s: create guest info workqueue failed\n", __func__);
err = -ENOMEM;
goto err_create_guest_info_wq_failed;
}
INIT_WORK(&ts->guest_info_work, himax_ts_guest_info_work_func);
#endif
#ifdef HX_TP_PROC_DIAG
ts->himax_diag_wq = create_singlethread_workqueue("himax_diag");
if (!ts->himax_diag_wq) {
E("%s: create diag workqueue failed\n", __func__);
err = -ENOMEM;
goto err_create_diag_wq_failed;
}
INIT_DELAYED_WORK(&ts->himax_diag_delay_wrok, himax_ts_diag_work_func);
#endif
#ifdef HX_AUTO_UPDATE_FW
auto_update_flag = himax_calculateChecksum(client, false);
auto_update_flag |= himax_flash_lastdata_check(client);
if (auto_update_flag)
goto FW_force_upgrade;
#endif
himax_read_FW_ver(client);
#ifdef HX_AUTO_UPDATE_FW
FW_force_upgrade:
auto_update_flag |= ((ic_data->vendor_fw_ver < g_i_FW_VER) ||
(ic_data->vendor_config_ver < g_i_CFG_VER));
/* Not sure to do */
/* auto_update_flag |= ((ic_data->vendor_cid_maj_ver != g_i_CID_MAJ) ||
*/
/* (ic_data->vendor_cid_min_ver < g_i_CID_MIN)); */
if (auto_update_flag) {
ts->himax_update_wq =
create_singlethread_workqueue("HMX_update_request");
if (!ts->himax_update_wq) {
E(" allocate syn_update_wq failed\n");
err = -ENOMEM;
goto err_update_wq_failed;
}
INIT_DELAYED_WORK(&ts->work_update, himax_update_register);
queue_delayed_work(ts->himax_update_wq, &ts->work_update,
msecs_to_jiffies(2000));
}
#endif
#ifdef HX_ZERO_FLASH
ts->himax_0f_update_wq =
create_singlethread_workqueue("HMX_0f_update_request");
if (!ts->himax_0f_update_wq) {
E(" allocate himax_0f_update_wq failed\n");
err = -ENOMEM;
goto err_0f_update_wq_failed;
}
INIT_DELAYED_WORK(&ts->work_0f_update, himax_0f_operation);
queue_delayed_work(ts->himax_0f_update_wq, &ts->work_0f_update,
msecs_to_jiffies(2000));
#endif
/* Himax Power On and Load Config */
if (himax_loadSensorConfig(client, pdata)) {
E("%s: Load Sesnsor configuration failed, unload driver.\n",
__func__);
goto err_detect_failed;
}
himax_power_on_init(client);
calculate_point_number();
#ifdef HX_TP_PROC_DIAG
setXChannel(ic_data->HX_RX_NUM); /* X channel */
setYChannel(ic_data->HX_TX_NUM); /* Y channel */
setMutualBuffer();
setMutualNewBuffer();
setMutualOldBuffer();
if (getMutualBuffer() == NULL) {
E("%s: mutual buffer allocate fail failed\n", __func__);
return -1;
}
#ifdef HX_TP_PROC_2T2R
if (Is_2T2R) {
setXChannel_2(ic_data->HX_RX_NUM_2); /* X channel */
setYChannel_2(ic_data->HX_TX_NUM_2); /* Y channel */
setMutualBuffer_2();
if (getMutualBuffer_2() == NULL) {
E("%s: mutual buffer 2 allocate fail failed\n",
__func__);
return -1;
}
}
#endif
#endif
#ifdef CONFIG_OF
ts->power = pdata->power;
#endif
ts->pdata = pdata;
ts->x_channel = ic_data->HX_RX_NUM;
ts->y_channel = ic_data->HX_TX_NUM;
ts->nFinger_support = ic_data->HX_MAX_PT;
/* calculate the i2c data size */
calcDataSize(ts->nFinger_support);
I("%s: calcDataSize complete\n", __func__);
#ifdef CONFIG_OF
ts->pdata->abs_pressure_min = 0;
ts->pdata->abs_pressure_max = 200;
ts->pdata->abs_width_min = 0;
ts->pdata->abs_width_max = 200;
pdata->cable_config[0] = 0xF0;
pdata->cable_config[1] = 0x00;
#endif
ts->suspended = false;
#if defined(HX_USB_DETECT_CALLBACK) || defined(HX_USB_DETECT_GLOBAL)
ts->usb_connected = 0x00;
ts->cable_config = pdata->cable_config;
#endif
#ifdef HX_PROTOCOL_A
ts->protocol_type = PROTOCOL_TYPE_A;
#else
ts->protocol_type = PROTOCOL_TYPE_B;
#endif
I("%s: Use Protocol Type %c\n", __func__,
ts->protocol_type == PROTOCOL_TYPE_A ? 'A' : 'B');
ret = himax_input_register(ts);
if (ret) {
E("%s: Unable to register %s input device\n", __func__,
ts->input_dev->name);
goto err_input_register_device_failed;
}
#ifdef CONFIG_FB
ts->himax_att_wq = create_singlethread_workqueue("HMX_ATT_request");
if (!ts->himax_att_wq) {
E(" allocate syn_att_wq failed\n");
err = -ENOMEM;
goto err_get_intr_bit_failed;
}
INIT_DELAYED_WORK(&ts->work_att, himax_fb_register);
queue_delayed_work(ts->himax_att_wq, &ts->work_att,
msecs_to_jiffies(15000));
#endif
#if defined(HX_CHIP_STATUS_MONITOR) /* for ESD solution */
I("Enter HX_CHIP_STATUS_MONITOR!\n");
g_chip_monitor_data =
kzalloc(sizeof(struct chip_monitor_data), GFP_KERNEL);
if (g_chip_monitor_data == NULL) {
err = -ENOMEM;
goto err_alloc_monitor_data;
}
g_chip_monitor_data->HX_CHIP_POLLING_COUNT = 0;
g_chip_monitor_data->HX_POLLING_TIMER = 5; /* unit:sec */
g_chip_monitor_data->HX_POLLING_TIMES =
2; /* ex:5(timer)x2(times)=10sec(polling time) */
g_chip_monitor_data->HX_ON_HAND_SHAKING = 0; /* */
g_chip_monitor_data->HX_CHIP_MONITOR_EN = 1;
ts->himax_chip_monitor_wq =
create_singlethread_workqueue("himax_chip_monitor_wq");
if (!ts->himax_chip_monitor_wq) {
E(" %s: create workqueue failed\n", __func__);
err = -ENOMEM;
goto err_create_chip_monitor_wq_failed;
}
g_chip_monitor_data->HX_CHIP_MONITOR_EN = 1;
INIT_DELAYED_WORK(&ts->himax_chip_monitor, himax_chip_monitor_function);
queue_delayed_work(ts->himax_chip_monitor_wq, &ts->himax_chip_monitor,
g_chip_monitor_data->HX_POLLING_TIMER * HZ);
#endif
#ifdef HX_SMART_WAKEUP
ts->SMWP_enable = 0;
wake_lock_init(&ts->ts_SMWP_wake_lock, WAKE_LOCK_SUSPEND,
HIMAX_common_NAME);
#endif
#ifdef HX_HIGH_SENSE
ts->HSEN_enable = 0;
#endif
#if defined(CONFIG_TOUCHSCREEN_HIMAX_ITO_TEST)
ts->ito_test_wq = create_singlethread_workqueue("himax_ito_test_wq");
if (!ts->ito_test_wq) {
E("%s: ito test workqueue failed\n", __func__);
err = -ENOMEM;
goto err_ito_test_wq_failed;
}
INIT_WORK(&ts->ito_test_work, himax_ito_test_work);
#endif
/* touch data init */
err = himax_report_data_init();
if (err)
goto err_report_data_init_failed;
#if defined(CONFIG_TOUCHSCREEN_HIMAX_DEBUG)
himax_touch_proc_init();
#endif
#if defined(HX_USB_DETECT_CALLBACK)
if (ts->cable_config)
cable_detect_register_notifier(&himax_cable_status_handler);
#endif
err = himax_ts_register_interrupt(ts->client);
if (err)
goto err_register_interrupt_failed;
#if defined(HX_AUTO_UPDATE_FW) || defined(HX_ZERO_FLASH)
if (auto_update_flag)
himax_int_enable(client->irq, 0);
#endif
return 0;
err_register_interrupt_failed:
#if defined(CONFIG_TOUCHSCREEN_HIMAX_DEBUG)
himax_touch_proc_deinit();
#endif
err_report_data_init_failed:
#if defined(CONFIG_TOUCHSCREEN_HIMAX_ITO_TEST)
destroy_workqueue(ts->ito_test_wq);
err_ito_test_wq_failed:
#endif
#ifdef HX_SMART_WAKEUP
wake_lock_destroy(&ts->ts_SMWP_wake_lock);
#endif
#ifdef HX_CHIP_STATUS_MONITOR
g_chip_monitor_data->HX_CHIP_MONITOR_EN = 0;
cancel_delayed_work_sync(&ts->himax_chip_monitor);
destroy_workqueue(ts->himax_chip_monitor_wq);
err_create_chip_monitor_wq_failed:
kfree(g_chip_monitor_data);
err_alloc_monitor_data:
#endif
#ifdef CONFIG_FB
cancel_delayed_work_sync(&ts->work_att);
destroy_workqueue(ts->himax_att_wq);
err_get_intr_bit_failed:
#endif
err_input_register_device_failed:
input_free_device(ts->input_dev);
err_detect_failed:
#ifdef HX_ZERO_FLASH
cancel_delayed_work_sync(&ts->work_0f_update);
destroy_workqueue(ts->himax_0f_update_wq);
err_0f_update_wq_failed:
#endif
#ifdef HX_AUTO_UPDATE_FW
if (auto_update_flag) {
cancel_delayed_work_sync(&ts->work_update);
destroy_workqueue(ts->himax_update_wq);
}
err_update_wq_failed:
#endif
#ifdef HX_TP_PROC_DIAG
cancel_delayed_work_sync(&ts->himax_diag_delay_wrok);
destroy_workqueue(ts->himax_diag_wq);
err_create_diag_wq_failed:
#endif
#ifdef HX_TP_PROC_GUEST_INFO
destroy_workqueue(ts->guest_info_wq);
err_create_guest_info_wq_failed:
#endif
#ifdef HX_TP_PROC_FLASH_DUMP
destroy_workqueue(ts->flash_wq);
err_create_flash_dump_wq_failed:
#endif
err_ic_package_failed:
if (gpio_is_valid(pdata->gpio_irq))
gpio_free(pdata->gpio_irq);
#ifdef HX_RST_PIN_FUNC
if (gpio_is_valid(pdata->gpio_reset))
gpio_free(pdata->gpio_reset);
#endif
#ifndef CONFIG_OF
err_power_failed:
#endif
err_alloc_dt_pdata_failed:
kfree(hx_touch_data);
err_alloc_touch_data_failed:
kfree(ic_data);
err_dt_ic_data_fail:
kfree(pdata);
err_dt_platform_data_fail:
kfree(ts);
err_alloc_data_failed:
err_check_functionality_failed:
probe_fail_flag = 1;
return err;
}
int himax_chip_common_remove(struct i2c_client *client)
{
struct himax_ts_data *ts = i2c_get_clientdata(client);
if (!ts->use_irq) {
hrtimer_cancel(&ts->timer);
destroy_workqueue(ts->himax_wq);
}
#if defined(CONFIG_TOUCHSCREEN_HIMAX_DEBUG)
himax_touch_proc_deinit();
#endif
#if defined(CONFIG_TOUCHSCREEN_HIMAX_ITO_TEST)
destroy_workqueue(ts->ito_test_wq);
#endif
#ifdef HX_SMART_WAKEUP
wake_lock_destroy(&ts->ts_SMWP_wake_lock);
#endif
#ifdef HX_CHIP_STATUS_MONITOR
g_chip_monitor_data->HX_CHIP_MONITOR_EN = 0;
cancel_delayed_work_sync(&ts->himax_chip_monitor);
destroy_workqueue(ts->himax_chip_monitor_wq);
kfree(g_chip_monitor_data);
#endif
#ifdef CONFIG_FB
if (fb_unregister_client(&ts->fb_notif))
E("Error occurred while unregistering fb_notifier.\n");
cancel_delayed_work_sync(&ts->work_att);
destroy_workqueue(ts->himax_att_wq);
#endif
input_free_device(ts->input_dev);
#ifdef HX_ZERO_FLASH
cancel_delayed_work_sync(&ts->work_0f_update);
destroy_workqueue(ts->himax_0f_update_wq);
#endif
#ifdef HX_AUTO_UPDATE_FW
cancel_delayed_work_sync(&ts->work_update);
destroy_workqueue(ts->himax_update_wq);
#endif
#ifdef HX_TP_PROC_DIAG
cancel_delayed_work_sync(&ts->himax_diag_delay_wrok);
destroy_workqueue(ts->himax_diag_wq);
#endif
#ifdef HX_TP_PROC_GUEST_INFO
destroy_workqueue(ts->guest_info_wq);
#endif
#ifdef HX_TP_PROC_FLASH_DUMP
destroy_workqueue(ts->flash_wq);
#endif
if (gpio_is_valid(ts->pdata->gpio_irq))
gpio_free(ts->pdata->gpio_irq);
#ifdef HX_RST_PIN_FUNC
if (gpio_is_valid(ts->pdata->gpio_reset))
gpio_free(ts->pdata->gpio_reset);
#endif
kfree(hx_touch_data);
kfree(ic_data);
kfree(ts->pdata);
kfree(ts);
probe_fail_flag = 0;
return 0;
}
#ifdef HX_INSPECT_LPWUG_TEST
void himax_press_powerkey(bool key_status)
{
if (key_status == FAKE_POWER_KEY_SEND) {
if (key_status == false)
I("Already suspend!\n");
else
I("Already resume!\n");
return;
}
I(" %s POWER KEY event %x press\n", __func__, KEY_POWER);
input_report_key(private_ts->input_dev, KEY_POWER, 1);
input_sync(private_ts->input_dev);
I(" %s POWER KEY event %x release\n", __func__, KEY_POWER);
input_report_key(private_ts->input_dev, KEY_POWER, 0);
input_sync(private_ts->input_dev);
FAKE_POWER_KEY_SEND = key_status;
}
#endif
int himax_chip_common_suspend(struct himax_ts_data *ts)
{
int ret;
#ifdef HX_CHIP_STATUS_MONITOR
int t = 0;
#endif
if (ts->suspended) {
I("%s: Already suspended. Skipped.\n", __func__);
return 0;
}
ts->suspended = true;
I("%s: enter\n", __func__);
#ifdef HX_TP_PROC_FLASH_DUMP
if (getFlashDumpGoing()) {
I("[himax] %s: Flash dump is going, reject suspend\n",
__func__);
return 0;
}
#endif
#ifdef HX_TP_PROC_GUEST_INFO
if (himax_guest_info_get_status()) {
I("[himax] %s: GUEST INFO dump is going, reject suspend\n",
__func__);
return 0;
}
#endif
#ifdef HX_CHIP_STATUS_MONITOR
if (g_chip_monitor_data->HX_ON_HAND_SHAKING) /* chip on hand */
/* shaking,wait hand */
/* shaking */
{
for (t = 0; t < 100; t++) {
if (g_chip_monitor_data->HX_ON_HAND_SHAKING ==
0) { /* chip on hand shaking end */
I("%s:HX_ON_HAND_SHAKING OK check %d times\n",
__func__, t);
break;
}
msleep(20);
}
if (t == 100) {
E("%s:HX_ON_HAND_SHAKING timeout reject suspend\n",
__func__);
return 0;
}
}
g_chip_monitor_data->HX_CHIP_MONITOR_EN = 0;
g_chip_monitor_data->HX_CHIP_POLLING_COUNT = 0;
cancel_delayed_work_sync(&ts->himax_chip_monitor);
#endif
#if defined(HX_SMART_WAKEUP) || defined(HX_HIGH_SENSE) || \
defined(HX_USB_DETECT_GLOBAL)
#ifndef HX_RESUME_SEND_CMD
himax_resend_cmd_func(ts->suspended);
#endif
#endif
#ifdef HX_INSPECT_LPWUG_TEST
FAKE_POWER_KEY_SEND = false;
#endif
#ifdef HX_SMART_WAKEUP
if (ts->SMWP_enable) {
atomic_set(&ts->suspend_mode, 1);
ts->pre_finger_mask = 0;
FAKE_POWER_KEY_SEND = false;
I("[himax] %s: SMART_WAKEUP enable, reject suspend\n",
__func__);
return 0;
}
#endif
himax_int_enable(ts->client->irq, 0);
himax_suspend_ic_action(ts->client);
if (!ts->use_irq) {
ret = cancel_work_sync(&ts->work);
if (ret)
himax_int_enable(ts->client->irq, 1);
}
/* ts->first_pressed = 0; */
atomic_set(&ts->suspend_mode, 1);
ts->pre_finger_mask = 0;
if (ts->pdata->powerOff3V3 && ts->pdata->power)
ts->pdata->power(0);
I("%s: END\n", __func__);
return 0;
}
int himax_chip_common_resume(struct himax_ts_data *ts)
{
#ifdef HX_CHIP_STATUS_MONITOR
int t = 0;
#endif
I("%s: enter\n", __func__);
if (ts->suspended == false) {
I("%s: It had entered resume,skip this step\n", __func__);
return 0;
}
ts->suspended = false;
atomic_set(&ts->suspend_mode, 0);
if (ts->pdata->powerOff3V3 && ts->pdata->power)
ts->pdata->power(1);
#ifdef HX_CHIP_STATUS_MONITOR
if (g_chip_monitor_data->HX_ON_HAND_SHAKING) /* chip on hand */
/* shaking,wait hand */
/* shaking */
{
for (t = 0; t < 100; t++) {
if (g_chip_monitor_data->HX_ON_HAND_SHAKING ==
0) { /* chip on hand shaking end */
I("%s:HX_ON_HAND_SHAKING OK check %d times\n",
__func__, t);
break;
}
msleep(20);
}
if (t == 100) {
E("%s:HX_ON_HAND_SHAKING timeout reject resume\n",
__func__);
return 0;
}
}
#endif
#if defined(HX_SMART_WAKEUP) || defined(HX_HIGH_SENSE) || \
defined(HX_USB_DETECT_GLOBAL)
himax_resend_cmd_func(ts->suspended);
#elif defined(HX_RESUME_HW_RESET)
himax_ic_reset(false, false);
#endif
#ifdef HX_INSPECT_LPWUG_TEST
FAKE_POWER_KEY_SEND = true;
#endif
himax_report_all_leave(ts);
himax_resume_ic_action(ts->client);
himax_int_enable(ts->client->irq, 1);
#ifdef HX_CHIP_STATUS_MONITOR
g_chip_monitor_data->HX_CHIP_POLLING_COUNT = 0;
g_chip_monitor_data->HX_CHIP_MONITOR_EN = 1;
queue_delayed_work(ts->himax_chip_monitor_wq, &ts->himax_chip_monitor,
g_chip_monitor_data->HX_POLLING_TIMER *
HZ); /* for ESD solution */
#endif
I("%s: END\n", __func__);
return 0;
}
Reference in a new issue Copy permalink