Google Git
Sign in
coral / linux-imx / a0db1735f4df185f15e4dd6264c22ebdfca22bdb / . / drivers / input / touchscreen / sec_ts / sec_ts_main.c
blob: d9cbf5af6f1e17904022a1297e17257c1d56b6d2 [file] [log] [blame]
/* drivers/input/touchscreen/sec_ts.c
*
* Copyright (C) 2016 Samsung Electronics Co., Ltd.
* http://www.samsungsemi.com/
*
* Core file for Samsung TSC driver
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*/
#include <linux/delay.h>
#include <linux/delay.h>
#include <linux/firmware.h>
#include <linux/gpio.h>
#include <linux/i2c.h>
#include <linux/input.h>
#include <linux/input/mt.h>
#include <linux/interrupt.h>
#include <linux/io.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/regulator/consumer.h>
#include <linux/slab.h>
#include <linux/wakelock.h>
#ifdef SAMSUNG_PROJECT
#include <linux/sec_sysfs.h>
#endif
#include <linux/irq.h>
#include <linux/of_gpio.h>
#include <linux/time.h>
#if defined(CONFIG_FB)
#include <linux/fb.h>
#include <linux/notifier.h>
#elif defined(CONFIG_HAS_EARLYSUSPEND)
#include <linux/earlysuspend.h>
#endif
#include "sec_ts.h"
#ifdef CONFIG_INPUT_PRESSURE
#include "../../pressure/pressure_func.h"
#endif
//#define SEC_TS_WAKEUP_GESTURE
struct sec_ts_data *tsp_data;
#ifdef SEC_TS_WAKEUP_GESTURE
static u32 keycode;
extern unsigned int gesture_enable;
void (*handle_sec)(u8) = 0;
void sec_ts_gesture_state(u8 gesture_state) {
if (gesture_state != 0) {
gesture_enable = 1;
tsp_data->lowpower_status = TO_LOWPOWER_MODE;
} else {
gesture_enable = 0;
tsp_data->lowpower_status = TO_TOUCH_MODE;
}
printk("[sec_ts]gesture_enable is %d\n", gesture_enable);
}
const uint16_t wakeup_gesture_key[] = {
DOUBLE_TAP, // GESTURE_DOUBLE_CLICK
UNICODE_E, // GESTURE_WORD_e
UNICODE_O, // GESTURE_WORD_O
UNICODE_W, // GESTURE_WORD_W
UNICODE_M, // GESTURE_WORD_M
UNICODE_V_DOWN, // GESTURE_WORD_V
UNICODE_S, // GESTURE_WORD_S
UNICODE_Z, // GESTURE_WORD_Z
UNICODE_C, // GESTURE_WORD_C
SWIPE_Y_UP, // GESTURE_SLIDE_UP
SWIPE_Y_DOWN, // GESTURE_SLIDE_DOWN
SWIPE_X_RIGHT, // GESTURE_SLIDE_RIGHT
SWIPE_X_LEFT, // GESTURE_SLIDE_LEFT
};
#define GESTURE_DOUBLE_CLICK 0
#define GESTURE_WORD_e 1
#define GESTURE_WORD_O 2
#define GESTURE_WORD_W 3
#define GESTURE_WORD_M 4
#define GESTURE_WORD_V 6
#define GESTURE_WORD_S 7
#define GESTURE_WORD_Z 8
#define GESTURE_WORD_C 9
#define GESTURE_SLIDE_UP 10
#define GESTURE_SLIDE_DOWN 11
#define GESTURE_SLIDE_RIGHT 12
#define GESTURE_SLIDE_LEFT 13
static struct wake_lock gesture_wakelock;
#endif
static struct device *sec_ts_dev;
EXPORT_SYMBOL(sec_ts_dev);
#ifndef SAMSUNG_PROJECT
struct class *sec_class;
static int sec_class_create(void) {
sec_class = class_create(THIS_MODULE, "sec");
if (IS_ERR_OR_NULL(sec_class)) {
pr_err("%s:Failed to create class(sec) %ld\n", __func__,
PTR_ERR(sec_class));
return PTR_ERR(sec_class);
}
return 0;
}
#endif
extern int32_t sec_ts_test_proc_init(struct sec_ts_data *ts);
struct sec_ts_fw_file {
u8 *data;
u32 pos;
size_t size;
};
struct sec_ts_event_status {
u8 tchsta : 3;
u8 ttype : 3;
u8 eid : 2;
u8 sid;
u8 buff2;
u8 buff3;
u8 buff4;
u8 buff5;
u8 buff6;
u8 buff7;
} __packed;
struct sec_ts_gesture_status {
u8 stype : 6;
u8 eid : 2;
u8 gesture;
u8 y_4_2 : 3;
u8 x : 5;
u8 h_4 : 1;
u8 w : 5;
u8 y_1_0 : 2;
u8 reserved : 4;
u8 h_3_0 : 4;
} __packed;
struct sec_ts_exp_fn {
int (*func_init)(void *device_data);
void (*func_remove)(void);
};
#if defined(CONFIG_FB)
static int fb_notifier_callback(struct notifier_block *self,
unsigned long event, void *data);
#elif defined(CONFIG_HAS_EARLYSUSPEND)
static void sec_ts_early_suspend(struct early_suspend *h);
static void sec_ts_late_resume(struct early_suspend *h);
#endif
static struct workqueue_struct *sec_fwu_wq;
static int sec_ts_input_open(struct input_dev *dev);
static void sec_ts_input_close(struct input_dev *dev);
static void sec_ts_reset_work(struct work_struct *work);
static void sec_ts_fwupdate_work(struct work_struct *work);
static int sec_ts_stop_device(struct sec_ts_data *ts);
static int sec_ts_start_device(struct sec_ts_data *ts);
u8 lv1cmd;
u8 *read_lv1_buff;
static int lv1_readsize;
static int lv1_readremain;
static int lv1_readoffset;
static ssize_t sec_ts_reg_store(struct device *dev,
struct device_attribute *attr, const char *buf,
size_t size);
static ssize_t sec_ts_regreadsize_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size);
static inline ssize_t sec_ts_store_error(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count);
static ssize_t sec_ts_enter_recovery_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size);
static ssize_t sec_ts_regread_show(struct device *dev,
struct device_attribute *attr, char *buf);
static ssize_t sec_ts_gesture_status_show(struct device *dev,
struct device_attribute *attr,
char *buf);
static inline ssize_t
sec_ts_show_error(struct device *dev, struct device_attribute *attr, char *buf);
static DEVICE_ATTR(sec_ts_reg, 0660, NULL, sec_ts_reg_store);
static DEVICE_ATTR(sec_ts_regreadsize, 0660, NULL, sec_ts_regreadsize_store);
static DEVICE_ATTR(sec_ts_enter_recovery, 0660, NULL,
sec_ts_enter_recovery_store);
static DEVICE_ATTR(sec_ts_regread, 0660, sec_ts_regread_show, NULL);
static DEVICE_ATTR(sec_ts_gesture_status, 0660, sec_ts_gesture_status_show,
NULL);
static struct attribute *cmd_attributes[] = {
&dev_attr_sec_ts_reg.attr,
&dev_attr_sec_ts_regreadsize.attr,
&dev_attr_sec_ts_enter_recovery.attr,
&dev_attr_sec_ts_regread.attr,
&dev_attr_sec_ts_gesture_status.attr,
NULL,
};
static struct attribute_group cmd_attr_group = {
.attrs = cmd_attributes,
};
static inline ssize_t sec_ts_show_error(struct device *dev,
struct device_attribute *attr,
char *buf) {
struct sec_ts_data *ts = dev_get_drvdata(dev);
input_err(true, &ts->client->dev, "sec_ts :%s read only function, %s\n",
__func__, attr->attr.name);
return -EPERM;
}
static inline ssize_t sec_ts_store_error(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count) {
struct sec_ts_data *ts = dev_get_drvdata(dev);
input_err(true, &ts->client->dev, "sec_ts :%s write only function, %s\n",
__func__, attr->attr.name);
return -EPERM;
}
int sec_ts_i2c_write(struct sec_ts_data *ts, u8 reg, u8 *data, int len) {
u8 buf[I2C_WRITE_BUFFER_SIZE + 1];
int ret;
unsigned char retry;
#ifdef POR_AFTER_I2C_RETRY
int retry_cnt = 0;
#endif
struct i2c_msg msg;
// input_info(true, &ts->client->dev,"%s\n", __func__);
if (len > I2C_WRITE_BUFFER_SIZE) {
input_err(true, &ts->client->dev,
"sec_ts_i2c_write len is larger than buffer size\n");
return -1;
}
if (ts->power_status == SEC_TS_STATE_POWER_OFF) {
input_err(true, &ts->client->dev, "%s: fail to POWER_STATUS=OFF\n",
__func__);
goto err;
}
buf[0] = reg;
memcpy(buf + 1, data, len);
msg.addr = ts->client->addr;
msg.flags = 0;
msg.len = len + 1;
msg.buf = buf;
#ifdef POR_AFTER_I2C_RETRY
retry_fail:
#endif
mutex_lock(&ts->i2c_mutex);
for (retry = 0; retry < SEC_TS_I2C_RETRY_CNT; retry++) {
ret = i2c_transfer(ts->client->adapter, &msg, 1);
if (ret == 1)
break;
if (ts->power_status == SEC_TS_STATE_POWER_OFF) {
input_err(true, &ts->client->dev,
"%s: fail to POWER_STATUS=OFF ret = %d\n", __func__, ret);
mutex_unlock(&ts->i2c_mutex);
goto err;
}
if (retry > 0)
sec_ts_delay(10);
}
mutex_unlock(&ts->i2c_mutex);
if (retry == SEC_TS_I2C_RETRY_CNT) {
input_err(true, &ts->client->dev, "%s: I2C write over retry limit\n",
__func__);
#ifdef POR_AFTER_I2C_RETRY
schedule_delayed_work(&ts->reset_work,
msecs_to_jiffies(TOUCH_RESET_DWORK_TIME));
if (!retry_cnt++)
goto retry_fail;
#endif
ret = -EIO;
}
if (ret == 1)
return 0;
err:
return -EIO;
}
int sec_ts_i2c_read(struct sec_ts_data *ts, u8 reg, u8 *data, int len) {
u8 buf[4];
int ret;
unsigned char retry;
#ifdef POR_AFTER_I2C_RETRY
int retry_cnt = 0;
#endif
struct i2c_msg msg[2];
if (ts->power_status == SEC_TS_STATE_POWER_OFF) {
input_err(true, &ts->client->dev, "%s: fail to POWER_STATUS=OFF\n",
__func__);
return -EIO;
}
mutex_lock(&ts->i2c_mutex);
buf[0] = reg;
msg[0].addr = ts->client->addr;
msg[0].flags = 0;
msg[0].len = 1;
msg[0].buf = buf;
#ifdef POR_AFTER_I2C_RETRY
retry_fail_write:
#endif
for (retry = 0; retry < SEC_TS_I2C_RETRY_CNT; retry++) {
ret = i2c_transfer(ts->client->adapter, msg, 1);
if (ret == 1)
break;
if (ts->power_status == SEC_TS_STATE_POWER_OFF) {
input_err(true, &ts->client->dev,
"%s: fail to POWER_STATUS=OFF ret = %d\n", __func__, ret);
mutex_unlock(&ts->i2c_mutex);
goto err;
}
if (retry > 0)
sec_ts_delay(10);
}
if (retry == SEC_TS_I2C_RETRY_CNT) {
input_err(true, &ts->client->dev, "%s: I2C write over retry limit\n",
__func__);
#ifdef POR_AFTER_I2C_RETRY
schedule_delayed_work(&ts->reset_work,
msecs_to_jiffies(TOUCH_RESET_DWORK_TIME));
if (!retry_cnt++)
goto retry_fail_write;
#endif
}
if (ret != 1) {
mutex_unlock(&ts->i2c_mutex);
goto err;
}
udelay(100);
msg[0].addr = ts->client->addr;
msg[0].flags = I2C_M_RD;
msg[0].len = len;
msg[0].buf = data;
#ifdef POR_AFTER_I2C_RETRY
retry_cnt = 0;
#endif
for (retry = 0; retry < SEC_TS_I2C_RETRY_CNT; retry++) {
ret = i2c_transfer(ts->client->adapter, msg, 1);
if (ret == 1)
break;
if (ts->power_status == SEC_TS_STATE_POWER_OFF) {
input_err(true, &ts->client->dev,
"%s: fail to POWER_STATUS=OFF ret = %d\n", __func__, ret);
mutex_unlock(&ts->i2c_mutex);
goto err;
}
if (retry > 0)
sec_ts_delay(10);
}
if (retry == SEC_TS_I2C_RETRY_CNT) {
input_err(true, &ts->client->dev, "%s: I2C read over retry limit\n",
__func__);
#ifdef POR_AFTER_I2C_RETRY
schedule_delayed_work(&ts->reset_work,
msecs_to_jiffies(TOUCH_RESET_DWORK_TIME));
if (!retry_cnt++)
goto retry_fail_write;
#endif
ret = -EIO;
}
mutex_unlock(&ts->i2c_mutex);
return ret;
err:
return -EIO;
}
#if defined(CONFIG_SEC_DEBUG_TSP_LOG)
struct delayed_work *p_ghost_check;
static void sec_ts_check_rawdata(struct work_struct *work) {
struct sec_ts_data *ts =
container_of(work, struct sec_ts_data, ghost_check.work);
if (ts->tsp_dump_lock == 1) {
input_err(true, &ts->client->dev, "%s, ignored ## already checking..\n",
__func__);
return;
}
if (ts->power_status == SEC_TS_STATE_POWER_OFF) {
input_err(true, &ts->client->dev, "%s, ignored ## IC is power off\n",
__func__);
return;
}
ts->tsp_dump_lock = 1;
input_err(true, &ts->client->dev, "%s, start ##\n", __func__);
sec_ts_run_rawdata_all((void *)ts);
msleep(100);
input_err(true, &ts->client->dev, "%s, done ##\n", __func__);
ts->tsp_dump_lock = 0;
}
void tsp_dump_sec(void) {
pr_err("%s: sec_ts %s: start\n", SECLOG, __func__);
if (p_ghost_check == NULL) {
pr_err("sec_ts %s, ignored ## tsp probe fail!!\n", __func__);
return;
}
schedule_delayed_work(p_ghost_check, msecs_to_jiffies(100));
}
#else
void tsp_dump_sec(void) { pr_err("sec_ts %s: not support\n", __func__); }
#endif
static int sec_ts_i2c_read_bulk(struct sec_ts_data *ts, u8 *data, int len) {
int ret;
unsigned char retry;
struct i2c_msg msg;
#ifdef POR_AFTER_I2C_RETRY
int retry_cnt = 0;
#endif
msg.addr = ts->client->addr;
msg.flags = I2C_M_RD;
msg.len = len;
msg.buf = data;
mutex_lock(&ts->i2c_mutex);
#ifdef POR_AFTER_I2C_RETRY
retry_fail:
#endif
for (retry = 0; retry < SEC_TS_I2C_RETRY_CNT; retry++) {
ret = i2c_transfer(ts->client->adapter, &msg, 1);
if (ret == 1)
break;
if (ts->power_status == SEC_TS_STATE_POWER_OFF) {
input_err(true, &ts->client->dev,
"%s: fail to POWER_STATUS=OFF ret = %d\n", __func__, ret);
mutex_unlock(&ts->i2c_mutex);
goto err;
}
}
mutex_unlock(&ts->i2c_mutex);
if (retry == 10) {
input_err(true, &ts->client->dev, "%s: I2C read over retry limit\n",
__func__);
#ifdef POR_AFTER_I2C_RETRY
schedule_delayed_work(&ts->reset_work,
msecs_to_jiffies(TOUCH_RESET_DWORK_TIME));
if (!retry_cnt++)
goto retry_fail;
#endif
ret = -EIO;
}
if (ret == 1)
return 0;
err:
return -EIO;
}
void sec_ts_delay(unsigned int ms) {
if (ms < 20)
usleep_range(ms * 1000, ms * 1000);
else
msleep(ms);
}
int sec_ts_wait_for_ready(struct sec_ts_data *ts, unsigned int ack) {
int rc = -1;
int retry = 0;
u8 tBuff[SEC_TS_Event_Buff_Size];
while (sec_ts_i2c_read(ts, SEC_TS_READ_ONE_EVENT, tBuff,
SEC_TS_Event_Buff_Size) > 0) {
if (tBuff[0] == TYPE_STATUS_EVENT_ACK) {
if (tBuff[1] == ack) {
rc = 0;
break;
}
}
if (retry++ > SEC_TS_WAIT_RETRY_CNT) {
input_err(true, &ts->client->dev, "%s: Time Over\n", __func__);
break;
}
sec_ts_delay(20);
}
input_info(true, &ts->client->dev,
"%s: %02X, %02X, %02X, %02X, %02X, %02X, %02X, %02X [%d]\n",
__func__, tBuff[0], tBuff[1], tBuff[2], tBuff[3], tBuff[4],
tBuff[5], tBuff[6], tBuff[7], retry);
return rc;
}
int sec_ts_read_calibration_report(struct sec_ts_data *ts) {
int ret;
u8 buf[5] = {0};
buf[0] = SEC_TS_READ_CALIBRATION_REPORT;
ret = sec_ts_i2c_read(ts, buf[0], &buf[1], 4);
if (ret < 0) {
input_err(true, &ts->client->dev, "%s: failed to read, %d\n", __func__,
ret);
return ret;
}
input_info(true, &ts->client->dev,
"%s: count:%d, pass count:%d, fail count:%d, status:0x%X\n",
__func__, buf[1], buf[2], buf[3], buf[4]);
return buf[4];
}
#ifdef SEC_TS_WAKEUP_GESTURE
int sec_ts_wakeup_gesture_report(struct sec_ts_data *ts, uint8_t gesture_id) {
input_info(true, &ts->client->dev, "%s: gesture_id = %d\n", __func__,
gesture_id);
if (gesture_enable == 1) {
switch (gesture_id) {
case GESTURE_DOUBLE_CLICK:
keycode = wakeup_gesture_key[0];
input_info(true, &ts->client->dev,
"Gesture : Double Click, keycode=0x%x\n", keycode);
break;
case GESTURE_WORD_e:
keycode = wakeup_gesture_key[1];
input_info(true, &ts->client->dev, "Gesture : Word e, keycode=0x%x\n",
keycode);
break;
case GESTURE_WORD_O:
keycode = wakeup_gesture_key[2];
input_info(true, &ts->client->dev, "Gesture : Word O, keycode=0x%x\n",
keycode);
break;
case GESTURE_WORD_W:
keycode = wakeup_gesture_key[3];
input_info(true, &ts->client->dev, "Gesture : Word W, keycode=0x%x\n",
keycode);
break;
case GESTURE_WORD_M:
keycode = wakeup_gesture_key[4];
input_info(true, &ts->client->dev, "Gesture : Word M, keycode=0x%x\n",
keycode);
break;
case GESTURE_WORD_V:
keycode = wakeup_gesture_key[5];
input_info(true, &ts->client->dev, "Gesture : Word V, keycode=0x%x\n",
keycode);
break;
case GESTURE_WORD_S:
keycode = wakeup_gesture_key[6];
input_info(true, &ts->client->dev, "Gesture : Word S, keycode=0x%x\n",
keycode);
break;
case GESTURE_WORD_Z:
keycode = wakeup_gesture_key[7];
input_info(true, &ts->client->dev, "Gesture : Word Z, keycode=0x%x\n",
keycode);
break;
case GESTURE_WORD_C:
keycode = wakeup_gesture_key[8];
input_info(true, &ts->client->dev, "Gesture : Word C, keycode=0x%x\n",
keycode);
break;
case GESTURE_SLIDE_UP:
keycode = wakeup_gesture_key[9];
input_info(true, &ts->client->dev, "Gesture : Slide Up, keycode=0x%x\n",
keycode);
break;
case GESTURE_SLIDE_DOWN:
input_info(true, &ts->client->dev, "Gesture : Slide Down, keycode=0x%x\n",
keycode);
keycode = wakeup_gesture_key[10];
break;
case GESTURE_SLIDE_RIGHT:
keycode = wakeup_gesture_key[11];
input_info(true, &ts->client->dev,
"Gesture : Slide Right, keycode=0x%x\n", keycode);
break;
case GESTURE_SLIDE_LEFT:
keycode = wakeup_gesture_key[12];
input_info(true, &ts->client->dev, "Gesture : Slide Left, keycode=0x%x\n",
keycode);
break;
}
}
return keycode;
}
#endif
#define MAX_EVENT_COUNT 128
static void sec_ts_read_event(struct sec_ts_data *ts) {
int ret;
int is_event_remain;
int t_id;
int event_id;
int read_event_count;
u8 read_event_buff[SEC_TS_Event_Buff_Size];
#ifdef SEC_TS_WAKEUP_GESTURE
u32 wakeup_code;
struct sec_ts_event_status *p_event_status;
#endif
struct sec_ts_event_coordinate *p_event_coord;
struct sec_ts_coordinate coordinate;
is_event_remain = 0;
read_event_count = 0;
ret = t_id = event_id = 0;
memset(&coordinate, 0x00, sizeof(struct sec_ts_coordinate));
/* repeat READ_ONE_EVENT until buffer is empty(No event) */
do {
ret = sec_ts_i2c_read(ts, SEC_TS_READ_ONE_EVENT, read_event_buff,
SEC_TS_Event_Buff_Size);
if (ret < 0) {
ts->event_errcnt++;
if (ts->event_errcnt > 10) {
// disable_irq(ts->client->irq);
if (ts->probe_done && ts->fw_workdone)
sec_ts_release_all_finger(ts);
}
input_err(true, &ts->client->dev, "%s: i2c read one event failed\n",
__func__);
return;
}
ts->event_errcnt = 0;
read_event_count++;
if (read_event_count > MAX_EVENT_COUNT) {
input_err(true, &ts->client->dev, "%s : event buffer overflow\n",
__func__);
/* write clear event stack command when read_event_count > MAX_EVENT_COUNT
*/
ret = sec_ts_i2c_write(ts, SEC_TS_CMD_CLEAR_EVENT_STACK, NULL, 0);
if (ret < 0)
input_err(true, &ts->client->dev, "%s: i2c write clear event failed\n",
__func__);
return;
}
event_id = read_event_buff[0] >> 6;
switch (event_id) {
case SEC_TS_Status_Event:
if ((read_event_buff[0] == TYPE_STATUS_EVENT_ACK) &&
(read_event_buff[1] == SEC_TS_ACK_BOOT_COMPLETE)) {
if (ts->probe_done && ts->fw_workdone) {
sec_ts_release_all_finger(ts);
}
if (read_event_buff[2] == 0x20) { /* watchdog reset flag */
input_err(true, &ts->client->dev, "%s: watchdog reset\n", __func__);
}
input_err(true, &ts->client->dev, "%s: Ack&Boot Complete\n", __func__);
}
if (read_event_buff[0] > 0)
input_info(true, &ts->client->dev,
"%s: STATUS %x %x %x %x %x %x %x %x\n", __func__,
read_event_buff[0], read_event_buff[1], read_event_buff[2],
read_event_buff[3], read_event_buff[4], read_event_buff[5],
read_event_buff[6], read_event_buff[7]);
if ((read_event_buff[0] == TYPE_STATUS_EVENT_ERR) &&
(read_event_buff[1] == SEC_TS_ERR_ESD)) {
input_err(true, &ts->client->dev, "%s: ESD detected. run reset\n",
__func__);
schedule_work(&ts->reset_work.work);
}
coordinate.action = SEC_TS_Coordinate_Action_None;
is_event_remain = 0;
break;
case SEC_TS_Coordinate_Event:
p_event_coord = (struct sec_ts_event_coordinate *)read_event_buff;
t_id = (p_event_coord->tid - 1);
if (t_id < MAX_SUPPORT_TOUCH_COUNT) {
coordinate.id = t_id;
coordinate.action = p_event_coord->tchsta;
coordinate.x = (p_event_coord->x_11_4 << 4) | (p_event_coord->x_3_0);
coordinate.y = (p_event_coord->y_11_4 << 4) | (p_event_coord->y_3_0);
coordinate.touch_width = p_event_coord->z;
coordinate.ttype = p_event_coord->ttype & 0x7;
coordinate.major = p_event_coord->major;
coordinate.minor = p_event_coord->minor;
coordinate.mcount = ts->coord[t_id].mcount;
coordinate.palm = (coordinate.ttype == SEC_TS_TOUCHTYPE_PALM) ? 1 : 0;
if ((t_id == SEC_TS_EVENTID_HOVER) &&
(coordinate.ttype == SEC_TS_TOUCHTYPE_PROXIMITY) &&
(coordinate.action == SEC_TS_Coordinate_Action_Release)) {
input_mt_slot(ts->input_dev, 0);
input_mt_report_slot_state(ts->input_dev, MT_TOOL_FINGER, false);
input_dbg(true, &ts->client->dev,
"%s: Hover - Release - tid=%d, touch_count=%d\n", __func__,
t_id, ts->touch_count);
} else if ((t_id == SEC_TS_EVENTID_HOVER) &&
(coordinate.ttype == SEC_TS_TOUCHTYPE_PROXIMITY)) {
input_mt_slot(ts->input_dev, 0);
input_mt_report_slot_state(ts->input_dev, MT_TOOL_FINGER, true);
input_report_key(ts->input_dev, BTN_TOUCH, false);
input_report_key(ts->input_dev, BTN_TOOL_FINGER, true);
input_report_abs(ts->input_dev, ABS_MT_POSITION_X, coordinate.x);
input_report_abs(ts->input_dev, ABS_MT_POSITION_Y, coordinate.y);
input_report_abs(ts->input_dev, ABS_MT_DISTANCE,
coordinate.touch_width);
if (coordinate.action == SEC_TS_Coordinate_Action_Press)
input_dbg(true, &ts->client->dev,
"%s: Hover - Press - tid=%d, touch_count=%d\n", __func__,
t_id, ts->touch_count);
else if (coordinate.action == SEC_TS_Coordinate_Action_Move)
input_dbg(true, &ts->client->dev,
"%s: Hover - Move - tid=%d, touch_count=%d\n", __func__,
t_id, ts->touch_count);
} else if (coordinate.ttype == SEC_TS_TOUCHTYPE_NORMAL ||
coordinate.ttype == SEC_TS_TOUCHTYPE_PALM ||
coordinate.ttype == SEC_TS_TOUCHTYPE_GLOVE) {
if (coordinate.action == SEC_TS_Coordinate_Action_Release) {
coordinate.touch_width = 0;
/*coordinate.action = SEC_TS_Coordinate_Action_None;*/
input_mt_slot(ts->input_dev, t_id);
input_mt_report_slot_state(ts->input_dev, MT_TOOL_FINGER, 0);
if (ts->touch_count > 0)
ts->touch_count--;
if (ts->touch_count == 0) {
input_report_key(ts->input_dev, BTN_TOUCH, 0);
input_report_key(ts->input_dev, BTN_TOOL_FINGER, 0);
}
} else if (coordinate.action == SEC_TS_Coordinate_Action_Press) {
ts->touch_count++;
input_mt_slot(ts->input_dev, t_id);
input_mt_report_slot_state(ts->input_dev, MT_TOOL_FINGER,
1 + (coordinate.palm << 1));
input_report_key(ts->input_dev, BTN_TOUCH, 1);
input_report_key(ts->input_dev, BTN_TOOL_FINGER, 1);
input_report_abs(ts->input_dev, ABS_MT_POSITION_X, coordinate.x);
input_report_abs(ts->input_dev, ABS_MT_POSITION_Y, coordinate.y);
input_report_abs(ts->input_dev, ABS_MT_TOUCH_MAJOR,
coordinate.major);
input_report_abs(ts->input_dev, ABS_MT_TOUCH_MINOR,
coordinate.minor);
#ifdef SEC_TS_SUPPORT_SEC_SWIPE
input_report_abs(ts->input_dev, ABS_MT_PALM, coordinate.palm);
#endif
#ifdef CONFIG_SEC_FACTORY
input_report_abs(ts->input_dev, ABS_MT_PRESSURE,
coordinate.touch_width);
#endif
} else if (coordinate.action == SEC_TS_Coordinate_Action_Move) {
#ifdef CONFIG_TOUCHSCREN_SEC_TS_GLOVEMODE
if ((coordinate.ttype == SEC_TS_TOUCHTYPE_GLOVE) &&
!ts->touchkey_glove_mode_status) {
ts->touchkey_glove_mode_status = true;
input_report_switch(ts->input_dev, SW_GLOVE, 1);
}
#endif
input_mt_slot(ts->input_dev, t_id);
input_mt_report_slot_state(ts->input_dev, MT_TOOL_FINGER, 1);
input_report_key(ts->input_dev, BTN_TOUCH, 1);
input_report_key(ts->input_dev, BTN_TOOL_FINGER, 1);
input_report_abs(ts->input_dev, ABS_MT_POSITION_X, coordinate.x);
input_report_abs(ts->input_dev, ABS_MT_POSITION_Y, coordinate.y);
input_report_abs(ts->input_dev, ABS_MT_TOUCH_MAJOR,
coordinate.major);
input_report_abs(ts->input_dev, ABS_MT_TOUCH_MINOR,
coordinate.minor);
#ifdef SEC_TS_SUPPORT_SEC_SWIPE
input_report_abs(ts->input_dev, ABS_MT_PALM, coordinate.palm);
#endif
#ifdef CONFIG_SEC_FACTORY
input_report_abs(ts->input_dev, ABS_MT_PRESSURE,
coordinate.touch_width);
#endif
coordinate.mcount++;
}
memcpy(&ts->coord[t_id], &coordinate,
sizeof(struct sec_ts_coordinate));
}
} else {
input_err(true, &ts->client->dev, "%s: tid(%d) is out of range\n",
__func__, t_id);
}
is_event_remain = 1;
break;
case SEC_TS_Gesture_Event:
#ifdef SEC_TS_WAKEUP_GESTURE
p_event_status = (struct sec_ts_event_status *)read_event_buff;
if ((p_event_status->eid == 0x02) && (p_event_status->tchsta == 0x01)) {
struct sec_ts_gesture_status *p_gesture_status =
(struct sec_ts_gesture_status *)read_event_buff;
wakeup_code =
sec_ts_wakeup_gesture_report(ts, p_gesture_status->gesture);
input_info(true, &ts->client->dev, "%s: GESTURE wakeup_code=0x%x\n",
__func__, wakeup_code);
mz_gesture_report(ts->input_dev, keycode);
}
is_event_remain = 1;
break;
#endif
default:
input_err(true, &ts->client->dev,
"%s: unknown event %x %x %x %x %x %x\n", __func__,
read_event_buff[0], read_event_buff[1], read_event_buff[2],
read_event_buff[3], read_event_buff[4], read_event_buff[5]);
is_event_remain = 0;
break;
}
#if !defined(CONFIG_SAMSUNG_PRODUCT_SHIP)
if (coordinate.action == SEC_TS_Coordinate_Action_Press)
input_dbg(
true, &ts->client->dev,
"%s: [P] tID:%d, x:%d, y:%d, major:%d, minor:%d, tc:%d palm:%d\n",
__func__, t_id, coordinate.x, coordinate.y, coordinate.major,
coordinate.minor, ts->touch_count, coordinate.palm);
#else
if (coordinate.action == SEC_TS_Coordinate_Action_Press)
input_dbg(true, &ts->client->dev, "%s: [P] tID:%d, tc:%d\n", __func__,
t_id, ts->touch_count);
#endif
else if (coordinate.action == SEC_TS_Coordinate_Action_Release) {
#if !defined(CONFIG_SAMSUNG_PRODUCT_SHIP)
input_dbg(true, &ts->client->dev, "%s: [R] tID:%d mc:%d tc:%d lx:%d "
"ly:%d cal:0x%x(%X|%X), "
"[SE%02X%02X%02X]\n",
__func__, t_id, ts->coord[t_id].mcount, ts->touch_count,
ts->coord[t_id].x, ts->coord[t_id].y, ts->cal_status, ts->nv,
ts->cal_count, ts->plat_data->panel_revision,
ts->plat_data->img_version_of_ic[2],
ts->plat_data->img_version_of_ic[3]);
#else
input_dbg(
true, &ts->client->dev,
"%s: [R] tID:%d mc:%d tc:%d cal:0x%x(%X|%X) [SE%02X%02X%02X]\n",
__func__, t_id, ts->coord[t_id].mcount, ts->touch_count,
ts->cal_status, ts->nv, ts->cal_count, ts->plat_data->panel_revision,
ts->plat_data->img_version_of_ic[2],
ts->plat_data->img_version_of_ic[3]);
#endif
ts->coord[t_id].mcount = 0;
}
} while (is_event_remain);
input_sync(ts->input_dev);
}
static irqreturn_t sec_ts_irq_thread(int irq, void *ptr) {
struct sec_ts_data *ts;
ts = (struct sec_ts_data *)ptr;
#ifdef SEC_TS_WAKEUP_GESTURE
if (ts->lowpower_mode)
wake_lock_timeout(&gesture_wakelock, msecs_to_jiffies(5000));
#endif
sec_ts_read_event(ts);
return IRQ_HANDLED;
}
int get_tsp_status(void) { return 0; }
EXPORT_SYMBOL(get_tsp_status);
int sec_ts_glove_mode_enables(struct sec_ts_data *ts, int mode) {
int ret;
if (ts->power_status == SEC_TS_STATE_POWER_OFF) {
input_err(true, &ts->client->dev,
"%s: fail to enable glove status, POWER_STATUS=OFF\n", __func__);
goto glove_enable_err;
}
if (mode)
ts->touch_functions = (ts->touch_functions | SEC_TS_BIT_SETFUNC_GLOVE |
SEC_TS_BIT_SETFUNC_MUTUAL);
else
ts->touch_functions = ((ts->touch_functions & (~SEC_TS_BIT_SETFUNC_GLOVE)) |
SEC_TS_BIT_SETFUNC_MUTUAL);
ret = sec_ts_i2c_write(ts, SEC_TS_CMD_SET_TOUCHFUNCTION, &ts->touch_functions,
1);
if (ret < 0) {
input_err(true, &ts->client->dev, "%s: Failed to send command", __func__);
goto glove_enable_err;
}
input_err(true, &ts->client->dev, "%s: %s, status =%x\n", __func__,
(mode) ? "glove enable" : "glove disable", ts->touch_functions);
return 0;
glove_enable_err:
(mode)
? (ts->touch_functions = SEC_TS_BIT_SETFUNC_GLOVE) |
SEC_TS_BIT_SETFUNC_MUTUAL
: (ts->touch_functions =
(ts->touch_functions & (~SEC_TS_BIT_SETFUNC_GLOVE)) |
SEC_TS_BIT_SETFUNC_MUTUAL);
input_err(true, &ts->client->dev, "%s: %s, status =%x\n", __func__,
(mode) ? "glove enable" : "glove disable", ts->touch_functions);
return -EIO;
}
EXPORT_SYMBOL(sec_ts_glove_mode_enables);
int sec_ts_hover_enables(struct sec_ts_data *ts, int enables) {
int ret;
if (enables)
ts->touch_functions = (ts->touch_functions | SEC_TS_BIT_SETFUNC_HOVER |
SEC_TS_BIT_SETFUNC_MUTUAL);
else
ts->touch_functions = ((ts->touch_functions & (~SEC_TS_BIT_SETFUNC_HOVER)) |
SEC_TS_BIT_SETFUNC_MUTUAL);
ret = sec_ts_i2c_write(ts, SEC_TS_CMD_SET_TOUCHFUNCTION, &ts->touch_functions,
1);
if (ret < 0) {
input_err(true, &ts->client->dev, "%s: Failed to send command", __func__);
goto hover_enable_err;
}
input_err(true, &ts->client->dev, "%s: %s, status =%x\n", __func__,
(enables) ? "hover enable" : "hover disable", ts->touch_functions);
return 0;
hover_enable_err:
ts->touch_functions =
(enables) ? ((ts->touch_functions | SEC_TS_BIT_SETFUNC_HOVER) |
SEC_TS_BIT_SETFUNC_MUTUAL)
: ((ts->touch_functions & (~SEC_TS_BIT_SETFUNC_HOVER)) |
SEC_TS_BIT_SETFUNC_MUTUAL);
input_err(true, &ts->client->dev, "%s: %s, status =%x\n", __func__,
(enables) ? "hover enable" : "hover disable", ts->touch_functions);
return -EIO;
}
EXPORT_SYMBOL(sec_ts_hover_enables);
int sec_ts_i2c_write_burst(struct sec_ts_data *ts, u8 *data, int len) {
int ret;
int retry;
mutex_lock(&ts->i2c_mutex);
for (retry = 0; retry < SEC_TS_I2C_RETRY_CNT; retry++) {
ret = i2c_master_send(ts->client, data, len);
if (ret == len) {
input_info(true, &ts->client->dev, "%s: i2c_master_send %d = %d\n",
__func__, ret, len);
break;
}
if (ts->power_status == SEC_TS_STATE_POWER_OFF) {
input_err(true, &ts->client->dev,
"%s: fail to POWER_STATUS=OFF ret = %d\n", __func__, ret);
mutex_unlock(&ts->i2c_mutex);
goto err;
}
if (retry > 0)
sec_ts_delay(10);
}
mutex_unlock(&ts->i2c_mutex);
if (retry == 10) {
input_err(true, &ts->client->dev, "%s: I2C write over retry limit\n",
__func__);
ret = -EIO;
}
if (ret == len)
return 0;
err:
return -EIO;
}
/* for
* debugging--------------------------------------------------------------------------------------*/
static ssize_t sec_ts_reg_store(struct device *dev,
struct device_attribute *attr, const char *buf,
size_t size) {
struct sec_ts_data *ts = dev_get_drvdata(dev);
int length;
int remain;
int offset;
int ret;
if (ts->power_status == SEC_TS_STATE_POWER_OFF) {
input_info(true, &ts->client->dev, "%s: Power off state\n", __func__);
return -EIO;
}
mutex_lock(&ts->device_mutex);
disable_irq(ts->client->irq);
if (size > 0) {
remain = size;
offset = 0;
do {
if (remain >= ts->i2c_burstmax)
length = ts->i2c_burstmax;
else
length = remain;
ret = sec_ts_i2c_write_burst(ts, (u8 *)&buf[offset], length);
if (ret < 0) {
input_err(true, &ts->client->dev,
"%s: i2c write %x command, remain = %d\n", __func__,
buf[offset], remain);
goto i2c_err;
}
remain -= length;
offset += length;
} while (remain > 0);
}
i2c_err:
enable_irq(ts->client->irq);
input_info(true, &ts->client->dev, "%s: 0x%x, 0x%x, size %d\n", __func__,
buf[0], buf[1], (int)size);
mutex_unlock(&ts->device_mutex);
return size;
}
static ssize_t sec_ts_regread_show(struct device *dev,
struct device_attribute *attr, char *buf) {
struct sec_ts_data *ts = dev_get_drvdata(dev);
int ret;
int length;
int remain;
int offset;
if (ts->power_status == SEC_TS_STATE_POWER_OFF) {
input_info(true, &ts->client->dev, "%s: Power off state\n", __func__);
return -EIO;
}
disable_irq(ts->client->irq);
read_lv1_buff = kcalloc(lv1_readsize, sizeof(u8), GFP_KERNEL);
if (!read_lv1_buff)
goto malloc_err;
mutex_lock(&ts->device_mutex);
remain = lv1_readsize;
offset = 0;
do {
if (remain >= ts->i2c_burstmax)
length = ts->i2c_burstmax;
else
length = remain;
if (offset == 0)
ret = sec_ts_i2c_read(ts, lv1cmd, &read_lv1_buff[offset], length);
else
ret = sec_ts_i2c_read_bulk(ts, &read_lv1_buff[offset], length);
if (ret < 0) {
input_err(true, &ts->client->dev, "%s: i2c read %x command, remain =%d\n",
__func__, lv1cmd, remain);
goto i2c_err;
}
remain -= length;
offset += length;
} while (remain > 0);
input_info(true, &ts->client->dev, "%s: lv1_readsize = %d\n", __func__,
lv1_readsize);
memcpy(buf, read_lv1_buff + lv1_readoffset, lv1_readsize);
i2c_err:
kfree(read_lv1_buff);
malloc_err:
mutex_unlock(&ts->device_mutex);
lv1_readremain = 0;
enable_irq(ts->client->irq);
return lv1_readsize;
}
static ssize_t sec_ts_gesture_status_show(struct device *dev,
struct device_attribute *attr,
char *buf) {
struct sec_ts_data *ts = dev_get_drvdata(dev);
mutex_lock(&ts->device_mutex);
memcpy(buf, ts->gesture_status, sizeof(ts->gesture_status));
input_info(true, &ts->client->dev, "%s: GESTURE STATUS %x %x %x %x %x %x\n",
__func__, ts->gesture_status[0], ts->gesture_status[1],
ts->gesture_status[2], ts->gesture_status[3],
ts->gesture_status[4], ts->gesture_status[5]);
mutex_unlock(&ts->device_mutex);
return sizeof(ts->gesture_status);
}
static ssize_t sec_ts_regreadsize_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size) {
lv1cmd = buf[0];
lv1_readsize = ((unsigned int)buf[4] << 24) | ((unsigned int)buf[3] << 16) |
((unsigned int)buf[2] << 8) | ((unsigned int)buf[1] << 0);
lv1_readoffset = 0;
lv1_readremain = 0;
return size;
}
static ssize_t sec_ts_enter_recovery_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size) {
struct sec_ts_data *ts = dev_get_drvdata(dev);
struct sec_ts_plat_data *pdata = dev->platform_data;
int ret;
u8 on = (u8)buf[0];
if (on == 1) {
disable_irq(ts->client->irq);
gpio_free(pdata->gpio);
input_info(true, &ts->client->dev, "%s: gpio free\n", __func__);
if (gpio_is_valid(pdata->gpio)) {
ret = gpio_request_one(pdata->gpio, GPIOF_OUT_INIT_LOW, "sec,tsp_int");
input_info(true, &ts->client->dev, "%s: gpio request one\n", __func__);
if (ret) {
input_err(true, &ts->client->dev, "Unable to request tsp_int [%d]\n",
pdata->gpio);
return -EINVAL;
}
} else {
input_err(true, &ts->client->dev, "Failed to get irq gpio\n");
return -EINVAL;
}
pdata->power(ts, false);
sec_ts_delay(100);
pdata->power(ts, true);
} else {
gpio_free(pdata->gpio);
if (gpio_is_valid(pdata->gpio)) {
ret = gpio_request_one(pdata->gpio, GPIOF_DIR_IN, "sec,tsp_int");
if (ret) {
input_err(true, &ts->client->dev, "Unable to request tsp_int [%d]\n",
pdata->gpio);
return -EINVAL;
}
} else {
input_err(true, &ts->client->dev, "Failed to get irq gpio\n");
return -EINVAL;
}
pdata->power(ts, false);
sec_ts_delay(500);
pdata->power(ts, true);
sec_ts_delay(500);
/* AFE Calibration */
ret = sec_ts_i2c_write(ts, SEC_TS_CMD_CALIBRATION_AMBIENT, NULL, 0);
if (ret < 0)
input_err(true, &ts->client->dev, "%s: fail to write AFE_CAL\n",
__func__);
sec_ts_delay(1000);
enable_irq(ts->client->irq);
}
return size;
}
#ifdef SEC_TS_SUPPORT_TA_MODE
static void sec_ts_charger_config(struct sec_ts_data *ts, int status) {
int ret;
if (ts->power_status == SEC_TS_STATE_POWER_OFF) {
input_err(true, &ts->client->dev,
"%s: fail to enalbe charger status, POWER_STATUS=OFF\n",
__func__);
goto charger_config_err;
}
if (status == 0x01 || status == 0x03)
ts->touch_functions = ts->touch_functions | SEC_TS_BIT_SETFUNC_CHARGER |
SEC_TS_BIT_SETFUNC_MUTUAL;
else
ts->touch_functions =
((ts->touch_functions & (~SEC_TS_BIT_SETFUNC_CHARGER)) |
SEC_TS_BIT_SETFUNC_MUTUAL);
ret = sec_ts_i2c_write(ts, SEC_TS_CMD_SET_TOUCHFUNCTION, &ts->touch_functions,
1);
if (ret < 0) {
input_err(true, &ts->client->dev, "%s: Failed to send command\n", __func__);
goto charger_config_err;
}
input_err(true, &ts->client->dev, "%s: charger inform : read status = %x\n",
__func__, ts->touch_functions);
return;
charger_config_err:
if (status == 0x01 || status == 0x03)
ts->touch_functions = ts->touch_functions | SEC_TS_BIT_SETFUNC_CHARGER |
SEC_TS_BIT_SETFUNC_MUTUAL;
else
ts->touch_functions =
((ts->touch_functions & (~SEC_TS_BIT_SETFUNC_CHARGER)) |
SEC_TS_BIT_SETFUNC_MUTUAL);
input_err(true, &ts->client->dev,
"%s: charger inform : touch function status = %x\n", __func__,
ts->touch_functions);
}
static void sec_ts_ta_cb(struct sec_ts_callbacks *cb, int status) {
struct sec_ts_data *ts = container_of(cb, struct sec_ts_data, callbacks);
input_err(true, &ts->client->dev, "[TSP] %s: status : %x\n", __func__,
status);
ts->ta_status = status;
sec_ts_charger_config(ts, status);
}
#endif
static void sec_ts_raw_device_init(struct sec_ts_data *ts) {
int ret;
sec_ts_dev = device_create(sec_class, NULL, 0, ts, "sec_ts");
ret = IS_ERR(sec_ts_dev);
if (ret) {
input_err(true, &ts->client->dev, "%s: fail - device_create\n", __func__);
return;
}
ret = sysfs_create_group(&sec_ts_dev->kobj, &cmd_attr_group);
if (ret < 0) {
input_err(true, &ts->client->dev, "%s: fail - sysfs_create_group\n",
__func__);
goto err_sysfs;
}
return;
err_sysfs:
input_err(true, &ts->client->dev, "%s: fail\n", __func__);
}
/* for
* debugging--------------------------------------------------------------------------------------*/
static int sec_ts_power(void *data, bool on) {
int ret = 0;
return ret;
}
static int sec_ts_parse_dt(struct i2c_client *client) {
struct device *dev = &client->dev;
struct sec_ts_plat_data *pdata = dev->platform_data;
struct device_node *np = dev->of_node;
u32 coords[2], lines[2];
int ret = 0;
pdata->power = sec_ts_power;
pdata->gpio = of_get_named_gpio(np, "sec,irq_gpio", 0);
if (gpio_is_valid(pdata->gpio)) {
ret = gpio_request_one(pdata->gpio, GPIOF_DIR_IN, "sec,tsp_int");
if (ret) {
input_err(true, &client->dev, "Unable to request tsp_int [%d]\n",
pdata->gpio);
return -EINVAL;
}
} else {
input_err(true, &client->dev, "Failed to get irq gpio\n");
return -EINVAL;
}
client->irq = gpio_to_irq(pdata->gpio);
pdata->irq_type = IRQF_TRIGGER_LOW | IRQF_ONESHOT;
if (of_property_read_u32_array(np, "sec,max_coords", coords, 2)) {
input_err(true, &client->dev, "Failed to get max_coords property\n");
return -EINVAL;
}
pdata->max_x = coords[0];
pdata->max_y = coords[1];
if (of_property_read_u32_array(np, "sec,num_lines", lines, 2))
input_info(true, &client->dev, "skipped to get num_lines property\n");
else {
pdata->num_rx = lines[0];
pdata->num_tx = lines[1];
input_info(true, &client->dev, "num_of[rx,tx]: [%d,%d]\n", pdata->num_rx,
pdata->num_tx);
}
if (of_property_read_string_index(np, "sec,project_name", 0,
&pdata->project_name))
input_info(true, &client->dev, "skipped to get project_name property\n");
if (of_property_read_string_index(np, "sec,project_name", 1,
&pdata->model_name))
input_info(true, &client->dev, "skipped to get model_name property\n");
pdata->i2c_burstmax = SEC_TS_FW_MAX_BURSTSIZE;
input_info(true, &client->dev, "irq:%d,irq_type:0x%04x,max[x,y]:[%d,%d],"
"project/model_name:%s/%s,panel_revision:%d\n",
pdata->gpio, pdata->irq_type, pdata->max_x, pdata->max_y,
pdata->project_name, pdata->model_name, pdata->panel_revision);
return ret;
}
static int sec_ts_setup_drv_data(struct i2c_client *client) {
int ret = 0;
struct sec_ts_data *ts;
struct sec_ts_plat_data *pdata;
/* parse dt */
if (client->dev.of_node) {
pdata =
devm_kzalloc(&client->dev, sizeof(struct sec_ts_plat_data), GFP_KERNEL);
if (!pdata) {
input_err(true, &client->dev, "Failed to allocate platform data\n");
return -ENOMEM;
}
client->dev.platform_data = pdata;
ret = sec_ts_parse_dt(client);
if (ret) {
input_err(true, &client->dev, "Failed to parse dt\n");
return ret;
}
} else
pdata = client->dev.platform_data;
if (!pdata) {
input_err(true, &client->dev, "No platform data found\n");
return -EINVAL;
}
if (!pdata->power) {
input_err(true, &client->dev, "No power contorl found\n");
return -EINVAL;
}
pdata->pinctrl = devm_pinctrl_get(&client->dev);
if (IS_ERR(pdata->pinctrl)) {
input_err(true, &client->dev, "could not get pinctrl\n");
return PTR_ERR(pdata->pinctrl);
}
pdata->pins_default = pinctrl_lookup_state(pdata->pinctrl, "on_state");
if (IS_ERR(pdata->pins_default))
input_err(true, &client->dev, "could not get default pinstate\n");
pdata->pins_sleep = pinctrl_lookup_state(pdata->pinctrl, "off_state");
if (IS_ERR(pdata->pins_sleep))
input_err(true, &client->dev, "could not get sleep pinstate\n");
ts = kzalloc(sizeof(struct sec_ts_data), GFP_KERNEL);
if (!ts)
return -ENOMEM;
ts->client = client;
ts->plat_data = pdata;
ts->crc_addr = 0x0001FE00;
ts->fw_addr = 0x00002000;
ts->para_addr = 0x18000;
ts->sec_ts_i2c_read = sec_ts_i2c_read;
ts->sec_ts_i2c_write = sec_ts_i2c_write;
ts->sec_ts_i2c_read_bulk = sec_ts_i2c_read_bulk;
ts->sec_ts_i2c_write_burst = sec_ts_i2c_write_burst;
ts->i2c_burstmax = pdata->i2c_burstmax;
ts->fw_workdone = false;
ts->force_fwup = false;
INIT_DELAYED_WORK(&ts->reset_work, sec_ts_reset_work);
i2c_set_clientdata(client, ts);
return ret;
}
static int sec_ts_read_information(struct sec_ts_data *ts) {
unsigned char data[20] = {0};
unsigned char device_id[3] = {0};
int ret;
memset(data, 0x0, 3);
ret = sec_ts_i2c_read(ts, SEC_TS_READ_DEVICE_ID, device_id, 3);
if (ret < 0) {
input_err(true, &ts->client->dev, "%s: failed to read device id(%d)\n",
__func__, ret);
return ret;
}
input_info(true, &ts->client->dev, "%s: %X, %X, %X\n", __func__, device_id[0],
device_id[1], device_id[2]);
memset(data, 0x0, 20);
ret = sec_ts_i2c_read(ts, SEC_TS_READ_SUB_ID, data, 20);
if (ret < 0) {
input_err(true, &ts->client->dev, "%s: failed to read sub id(%d)\n",
__func__, ret);
return ret;
}
input_info(true, &ts->client->dev,
"%s: AP/BL(%X), DEV1:%X, DEV2:%X, nT:%X, nR:%X, rY:%d, rX:%d\n",
__func__, data[0], data[1], data[2], data[3], data[4],
(data[5] << 8) | data[6], (data[7] << 8) | data[8]);
data[0] = sec_ts_read_calibration_report(ts);
input_err(true, &ts->client->dev, "%s: cal info (%d)\n", __func__, data[0]);
data[0] = 0;
ret = sec_ts_i2c_read(ts, SEC_TS_READ_BOOT_STATUS, data, 1);
if (ret < 0) {
input_err(true, &ts->client->dev, "%s: failed to read sub id(%d)\n",
__func__, ret);
return ret;
}
input_info(true, &ts->client->dev, "%s: %X\n", __func__, data[0]);
if (device_id[0] == SEC_TS_ID_ON_FW)
ret = 1;
else {
input_err(true, &ts->client->dev, "%s: device id = %X\n", __func__,
device_id[0]);
ret = 0;
}
return ret;
}
int sec_ts_i2c_probe_read(struct sec_ts_data *ts, u8 reg, u8 *data, int len) {
u8 buf[4];
int ret;
unsigned char retry;
#ifdef POR_AFTER_I2C_RETRY
int retry_cnt = 0;
#endif
struct i2c_msg msg[2];
input_info(true, &ts->client->dev, "%s\n", __func__);
mutex_lock(&ts->i2c_mutex);
buf[0] = reg;
msg[0].addr = ts->client->addr;
msg[0].flags = 0;
msg[0].len = 1;
msg[0].buf = buf;
#ifdef POR_AFTER_I2C_RETRY
retry_fail_write:
#endif
for (retry = 0; retry < SEC_TS_I2C_RETRY_CNT; retry++) {
ret = i2c_transfer(ts->client->adapter, msg, 1);
if (ret == 1)
break;
if (ts->power_status == SEC_TS_STATE_POWER_OFF) {
input_err(true, &ts->client->dev,
"%s: fail to POWER_STATUS=OFF ret = %d\n", __func__, ret);
mutex_unlock(&ts->i2c_mutex);
goto err;
}
if (retry > 0)
sec_ts_delay(10);
}
if (retry == SEC_TS_I2C_RETRY_CNT) {
input_err(true, &ts->client->dev, "%s: I2C write over retry limit\n",
__func__);
#ifdef POR_AFTER_I2C_RETRY
schedule_delayed_work(&ts->reset_work,
msecs_to_jiffies(TOUCH_RESET_DWORK_TIME));
if (!retry_cnt++)
goto retry_fail_write;
#endif
}
if (ret != 1) {
mutex_unlock(&ts->i2c_mutex);
goto err;
}
udelay(100);
msg[0].addr = ts->client->addr;
msg[0].flags = I2C_M_RD;
msg[0].len = len;
msg[0].buf = data;
#ifdef POR_AFTER_I2C_RETRY
retry_cnt = 0;
#endif
for (retry = 0; retry < SEC_TS_I2C_RETRY_CNT; retry++) {
ret = i2c_transfer(ts->client->adapter, msg, 1);
if (ret == 1)
break;
if (ts->power_status == SEC_TS_STATE_POWER_OFF) {
input_err(true, &ts->client->dev,
"%s: fail to POWER_STATUS=OFF ret = %d\n", __func__, ret);
mutex_unlock(&ts->i2c_mutex);
goto err;
}
if (retry > 0)
sec_ts_delay(10);
}
if (retry == SEC_TS_I2C_RETRY_CNT) {
input_err(true, &ts->client->dev, "%s: I2C read over retry limit\n",
__func__);
#ifdef POR_AFTER_I2C_RETRY
schedule_delayed_work(&ts->reset_work,
msecs_to_jiffies(TOUCH_RESET_DWORK_TIME));
if (!retry_cnt++)
goto retry_fail_write;
#endif
ret = -EIO;
}
mutex_unlock(&ts->i2c_mutex);
return ret;
input_info(true, &ts->client->dev, "%s ret=%d\n", __func__, ret);
err:
return -EIO;
}
static int sec_ts_read_device_id(struct sec_ts_data *ts) {
unsigned char device_id[3] = {0};
int ret;
ret = sec_ts_i2c_probe_read(ts, SEC_TS_READ_DEVICE_ID, device_id, 3);
if (ret < 0) {
input_err(true, &ts->client->dev, "%s: failed to read device id(%d)\n",
__func__, ret);
return -EIO;
}
input_info(true, &ts->client->dev, "%s: %X, %X, %X ret=%d\n", __func__,
device_id[0], device_id[1], device_id[2], ret);
return ret;
}
#define T_BUFF_SIZE 5
static int sec_ts_probe(struct i2c_client *client,
const struct i2c_device_id *id) {
#ifdef SEC_TS_WAKEUP_GESTURE
int i;
#endif
struct sec_ts_data *ts;
static char sec_ts_phys[64] = {0};
int ret = 0;
input_info(true, &client->dev, "SEC_TS Driver [%s]\n", SEC_TS_DRV_VERSION);
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
input_err(true, &client->dev, "%s : EIO err!\n", __func__);
return -EIO;
}
ret = sec_ts_setup_drv_data(client);
if (ret < 0) {
input_err(true, &client->dev, "%s: Failed to set up driver data\n",
__func__);
goto err_setup_drv_data;
}
ts = (struct sec_ts_data *)i2c_get_clientdata(client);
if (!ts) {
input_err(true, &client->dev, "%s: Failed to get driver data\n", __func__);
ret = -ENODEV;
goto err_get_drv_data;
}
if (!(IS_ERR_OR_NULL(ts->plat_data->pins_default) ||
IS_ERR_OR_NULL(ts->plat_data->pinctrl))) {
ret = pinctrl_select_state(ts->plat_data->pinctrl,
ts->plat_data->pins_default);
if (ret < 0)
input_err(true, &ts->client->dev,
"%s: Failed to configure tsp_attn pin\n", __func__);
}
ts->input_dev = input_allocate_device();
if (!ts->input_dev) {
input_err(true, &ts->client->dev, "%s: allocate device err!\n", __func__);
ret = -ENOMEM;
goto err_allocate_device;
}
ts->input_dev->name = "Samsung Electronics Touchscreen 1223";
snprintf(sec_ts_phys, sizeof(sec_ts_phys), "%s/input1", ts->input_dev->name);
ts->input_dev->name = "Samsung Electronics Touchscreen 1223";
snprintf(sec_ts_phys, sizeof(sec_ts_phys), "%s/input1",
ts->input_dev->name);
ts->input_dev->phys = sec_ts_phys;
ts->input_dev->id.bustype = BUS_I2C;
ts->input_dev->dev.parent = &client->dev;
ts->touch_count = 0;
mutex_init(&ts->lock);
mutex_init(&ts->device_mutex);
mutex_init(&ts->i2c_mutex);
#ifdef CONFIG_TOUCHSCREN_SEC_TS_GLOVEMODE
input_set_capability(ts->input_dev, EV_SW, SW_GLOVE);
#endif
set_bit(EV_SYN, ts->input_dev->evbit);
set_bit(EV_KEY, ts->input_dev->evbit);
set_bit(EV_ABS, ts->input_dev->evbit);
set_bit(BTN_TOUCH, ts->input_dev->keybit);
set_bit(BTN_TOOL_FINGER, ts->input_dev->keybit);
#ifdef SEC_TS_SUPPORT_TOUCH_KEY
if (ts->plat_data->support_mskey) {
for (i = 0; i < ts->plat_data->num_touchkey; i++)
set_bit(ts->plat_data->touchkey[i].keycode, ts->input_dev->keybit);
set_bit(EV_LED, ts->input_dev->evbit);
set_bit(LED_MISC, ts->input_dev->ledbit);
}
#endif
#ifdef INPUT_PROP_DIRECT
set_bit(INPUT_PROP_DIRECT, ts->input_dev->propbit);
#endif
ts->input_dev->evbit[0] = BIT_MASK(EV_ABS) | BIT_MASK(EV_KEY);
set_bit(INPUT_PROP_DIRECT, ts->input_dev->propbit);
input_mt_init_slots(ts->input_dev, MAX_SUPPORT_TOUCH_COUNT, INPUT_MT_DIRECT);
input_set_abs_params(ts->input_dev, ABS_MT_POSITION_X, 0,
ts->plat_data->max_x, 0, 0);
input_set_abs_params(ts->input_dev, ABS_MT_POSITION_Y, 0,
ts->plat_data->max_y, 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_TOUCH_MINOR, 0, 255, 0, 0);
#ifdef SEC_TS_SUPPORT_SEC_SWIPE
input_set_abs_params(ts->input_dev, ABS_MT_PALM, 0, 1, 0, 0);
#endif
#if defined(SEC_TS_SUPPORT_GRIP_EVENT)
input_set_abs_params(ts->input_dev, ABS_MT_GRIP, 0, 1, 0, 0);
#endif
input_set_abs_params(ts->input_dev, ABS_MT_DISTANCE, 0, 255, 0, 0);
#ifdef CONFIG_SEC_FACTORY
input_set_abs_params(ts->input_dev, ABS_MT_PRESSURE, 0, 255, 0, 0);
#endif
#ifdef SEC_TS_WAKEUP_GESTURE
handle_sec = sec_ts_gesture_state;
for (i = 0; i < (sizeof(wakeup_gesture_key) / sizeof(wakeup_gesture_key[0]));
i++) {
input_set_capability(ts->input_dev, EV_KEY, wakeup_gesture_key[i]);
}
input_set_capability(ts->input_dev, EV_KEY, KEY_POWER);
mz_gesture_handle_register(handle_sec);
wake_lock_init(&gesture_wakelock, WAKE_LOCK_SUSPEND, "poll-wake-lock");
#endif
input_set_drvdata(ts->input_dev, ts);
i2c_set_clientdata(client, ts);
ret = sec_ts_read_device_id(ts);
if (ret < 0) {
input_err(true, &ts->client->dev, "%s: allocate device err!\n", __func__);
ret = -ENOMEM;
goto err_input_register_device;
}
ret = input_register_device(ts->input_dev);
if (ret) {
input_err(true, &ts->client->dev,
"%s: Unable to register %s input device\n", __func__,
ts->input_dev->name);
goto err_input_register_device;
}
ts->power_status = SEC_TS_STATE_POWER_ON;
input_info(true, &ts->client->dev, "sec_ts_probe request_irq = %d\n",
client->irq);
#ifdef SEC_TS_WAKEUP_GESTURE
ret = request_threaded_irq(client->irq, NULL, sec_ts_irq_thread,
ts->plat_data->irq_type | IRQF_ONESHOT |
IRQF_NO_SUSPEND,
SEC_TS_I2C_NAME, ts);
#else
ret = request_threaded_irq(client->irq, NULL, sec_ts_irq_thread,
ts->plat_data->irq_type | IRQF_ONESHOT,
SEC_TS_I2C_NAME, ts);
#endif
if (ret < 0) {
input_err(true, &ts->client->dev,
"sec_ts_probe: Unable to request threaded irq\n");
goto err_irq;
}
disable_irq(ts->client->irq);
ts->interrupt_enable = SEC_TS_INTERRUPT_EN;
input_info(true, &ts->client->dev, "sec_ts_probe request_irq done\n");
#ifdef SEC_TS_SUPPORT_TA_MODE
ts->callbacks.inform_charger = sec_ts_ta_cb;
if (ts->plat_data->register_cb)
ts->plat_data->register_cb(&ts->callbacks);
#endif
#ifndef SAMSUNG_PROJECT
ret = sec_class_create();
#endif
if (!IS_ERR_OR_NULL(sec_class)) {
sec_ts_raw_device_init(ts);
sec_ts_fn_init(ts);
}
ret = sec_ts_test_proc_init(ts);
if (ret != 0) {
input_err(true, &ts->client->dev, "sec_ts test proc init failed. ret=%d\n",
ret);
goto err_proc_init;
}
#if defined(CONFIG_FB)
ts->fb_notif.notifier_call = fb_notifier_callback;
ret = fb_register_client(&ts->fb_notif);
if (ret) {
input_err(true, &ts->client->dev, "register fb_notifier failed\n");
goto err_register_fb_notif;
}
#elif defined(CONFIG_HAS_EARLYSUSPEND)
ts->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
ts->early_suspend.suspend = sec_ts_early_suspend;
ts->early_suspend.resume = sec_ts_late_resume;
ret = register_early_suspend(&ts->early_suspend);
if (ret) {
input_err(true, &ts->client->dev, "register early suspend failed. ret=%d\n",
ret);
goto err_register_early_suspend;
}
#endif
sec_fwu_wq = create_singlethread_workqueue("sec_fwu_wq");
if (!sec_fwu_wq) {
input_err(true, &ts->client->dev, "sec_fwu_wq create workqueue failed\n");
ret = -ENOMEM;
goto err_create_sec_fwu_wq_failed;
}
INIT_DELAYED_WORK(&ts->fwupdate_work, sec_ts_fwupdate_work);
queue_delayed_work(sec_fwu_wq, &ts->fwupdate_work,
msecs_to_jiffies(TOUCH_FWUPDATE_DWORK_TIME));
ts->lowpower_mode = TO_TOUCH_MODE;
ts->probe_done = true;
tsp_data = ts;
device_init_wakeup(&client->dev, true);
input_info(true, &ts->client->dev, "sec_ts_probe done\n");
return 0;
#if defined(CONFIG_FB)
err_register_fb_notif:
#elif defined(CONFIG_HAS_EARLYSUSPEND)
err_register_early_suspend:
#endif
err_create_sec_fwu_wq_failed:
err_proc_init:
err_irq:
input_unregister_device(ts->input_dev);
ts->input_dev = NULL;
err_input_register_device:
if (ts->input_dev)
input_free_device(ts->input_dev);
err_allocate_device:
err_get_drv_data:
kfree(ts);
err_setup_drv_data:
return ret;
}
void sec_ts_release_all_finger(struct sec_ts_data *ts) {
int i;
for (i = 0; i < MAX_SUPPORT_TOUCH_COUNT; i++) {
input_mt_slot(ts->input_dev, i);
input_mt_report_slot_state(ts->input_dev, MT_TOOL_FINGER, false);
if ((ts->coord[i].action == SEC_TS_Coordinate_Action_Press) ||
(ts->coord[i].action == SEC_TS_Coordinate_Action_Move)) {
ts->touch_count--;
if (ts->touch_count < 0)
ts->touch_count = 0;
ts->coord[i].action = SEC_TS_Coordinate_Action_Release;
input_info(
true, &ts->client->dev,
"%s: [RA] tID:%d mc:%d tc:%d cal:0x%x(%X|%X) [SE%02X%02X%02X]\n",
__func__, i, ts->coord[i].mcount, ts->touch_count, ts->cal_status,
ts->nv, ts->cal_count, ts->plat_data->panel_revision,
ts->plat_data->img_version_of_ic[2],
ts->plat_data->img_version_of_ic[3]);
}
ts->coord[i].mcount = 0;
}
input_report_key(ts->input_dev, BTN_TOUCH, false);
input_report_key(ts->input_dev, BTN_TOOL_FINGER, false);
#ifdef CONFIG_TOUCHSCREN_SEC_TS_GLOVEMODE
input_report_switch(ts->input_dev, SW_GLOVE, false);
#endif
ts->touchkey_glove_mode_status = false;
ts->touch_count = 0;
input_sync(ts->input_dev);
}
static int sec_ts_set_lowpowermode(struct sec_ts_data *ts, u8 mode) {
int ret = -1;
input_err(true, &ts->client->dev, "%s: %s\n", __func__,
mode == TO_LOWPOWER_MODE ? "ENTER" : "EXIT");
ts->power_status = SEC_TS_STATE_POWER_ON;
if (mode) {
ret = sec_ts_i2c_write(ts, SEC_TS_CMD_SET_POWER_MODE, &mode, 1);
if (ret < 0)
input_err(true, &ts->client->dev, "%s: failed\n", __func__);
}
ts->lowpower_mode = mode;
sec_ts_release_all_finger(ts);
return ret;
}
static void sec_ts_reset_work(struct work_struct *work) {
struct sec_ts_data *ts =
container_of(work, struct sec_ts_data, reset_work.work);
if (!ts->probe_done)
return;
input_err(true, &ts->client->dev, "%s start\n", __func__);
sec_ts_delay(30);
input_info(true, &ts->client->dev, "%s done\n", __func__);
}
static void sec_ts_fwupdate_work(struct work_struct *work) {
u8 tBuff[T_BUFF_SIZE];
int ret = 0;
struct sec_ts_data *ts =
container_of(work, struct sec_ts_data, fwupdate_work.work);
if (!ts->probe_done)
return;
input_err(true, &ts->client->dev, "%s start\n", __func__);
mutex_lock(&ts->device_mutex);
/* Enable Power */
ts->plat_data->power(ts, true);
ts->power_status = SEC_TS_STATE_POWER_ON;
ts->sec_ts_i2c_write(ts, SEC_TS_CMD_SW_RESET, NULL, 0);
sec_ts_delay(500);
sec_ts_wait_for_ready(ts, SEC_TS_ACK_BOOT_COMPLETE);
#ifndef CONFIG_FW_UPDATE_ON_PROBE
input_info(true, &ts->client->dev, "%s: fw update on probe disabled!\n",
__func__);
sec_ts_check_firmware_version(ts, sec_get_fwdata());
ret = ts->sec_ts_i2c_write(ts, SEC_TS_CMD_CALIBRATION_OFFSET_SDC, NULL, 0);
if (ret < 0) {
input_err(true, &ts->client->dev, "%s: calibration fail\n", __func__);
}
sec_ts_delay(1000);
ts->sec_ts_i2c_write(ts, SEC_TS_CMD_SW_RESET, NULL, 0);
sec_ts_delay(500);
#endif
#ifdef CONFIG_FW_UPDATE_ON_PROBE
ret = sec_ts_firmwarei_update_on_probe(ts);
if (ret < 0) {
input_err(true, &ts->client->dev, "%s: fw update fail, ret = %d!\n",
__func__, ret);
goto err_init;
} else
input_err(true, &ts->client->dev, "%s: fw update success, ret = %d!\n",
__func__, ret);
#endif
ret = sec_ts_read_information(ts);
if ((ts->tx_count == 0) || (ts->rx_count == 0)) {
/* Read Raw Channel Info */
ret = sec_ts_i2c_read(ts, SEC_TS_READ_SUB_ID, tBuff, 5);
if (ret < 0) {
input_err(true, &ts->client->dev, "%s: fail to read raw channel info\n",
__func__);
goto err_init;
} else {
ts->tx_count = tBuff[3];
ts->rx_count = tBuff[4];
input_info(true, &ts->client->dev, "%s: S6SSEC_TS Tx : %d, Rx : %d\n",
__func__, ts->tx_count, ts->rx_count);
}
}
ts->pFrame = kzalloc(ts->tx_count * ts->rx_count * 2, GFP_KERNEL);
if (!ts->pFrame) {
ret = -ENOMEM;
goto err_allocate_frame;
}
ts->fw_workdone = true;
mutex_unlock(&ts->device_mutex);
enable_irq(ts->client->irq);
input_info(true, &ts->client->dev, "%s done\n", __func__);
return;
err_allocate_frame:
err_init:
mutex_unlock(&ts->device_mutex);
enable_irq(ts->client->irq);
input_info(true, &ts->client->dev, "%s failed\n", __func__);
}
static int sec_ts_input_open(struct input_dev *dev) {
struct sec_ts_data *ts = input_get_drvdata(dev);
int ret;
if (ts->fw_workdone) {
if (ts->lowpower_status) {
sec_ts_delay(200);
sec_ts_set_lowpowermode(ts, TO_TOUCH_MODE);
enable_irq(ts->client->irq);
} else {
ret = sec_ts_start_device(ts);
if (ret < 0)
input_err(true, &ts->client->dev, "%s: Failed to start device\n",
__func__);
}
}
input_err(true, &ts->client->dev, "%s : Done", __func__);
return 0;
}
static void sec_ts_input_close(struct input_dev *dev) {
struct sec_ts_data *ts = input_get_drvdata(dev);
input_err(true, &ts->client->dev, "%s\n", __func__);
cancel_delayed_work(&ts->reset_work);
if (ts->fw_workdone) {
if (ts->lowpower_status) {
sec_ts_set_lowpowermode(ts, TO_LOWPOWER_MODE);
enable_irq_wake(ts->client->irq);
} else
sec_ts_stop_device(ts);
}
}
static int sec_ts_remove(struct i2c_client *client) {
struct sec_ts_data *ts = i2c_get_clientdata(client);
pr_err("%s\n", __func__);
#if defined(CONFIG_FB)
if (fb_unregister_client(&ts->fb_notif))
input_err(true, &ts->client->dev, "unregistering fb_notifier err\n");
#elif defined(CONFIG_HAS_EARLYSUSPEND)
unregister_early_suspend(&ts->early_suspend);
#endif
free_irq(client->irq, ts);
input_mt_destroy_slots(ts->input_dev);
input_unregister_device(ts->input_dev);
ts->input_dev = NULL;
ts->plat_data->power(ts, false);
kfree(ts);
return 0;
}
static void sec_ts_shutdown(struct i2c_client *client) {
struct sec_ts_data *ts = i2c_get_clientdata(client);
pr_err("%s\n", __func__);
sec_ts_stop_device(ts);
}
static int sec_ts_stop_device(struct sec_ts_data *ts) {
input_info(true, &ts->client->dev, "%s\n", __func__);
mutex_lock(&ts->device_mutex);
if (ts->power_status == SEC_TS_STATE_POWER_OFF) {
input_err(true, &ts->client->dev, "%s: already power off\n", __func__);
goto out;
}
disable_irq(ts->client->irq);
sec_ts_release_all_finger(ts);
ts->plat_data->power(ts, false);
ts->power_status = SEC_TS_STATE_POWER_OFF;
if (ts->plat_data->enable_sync)
ts->plat_data->enable_sync(false);
out:
mutex_unlock(&ts->device_mutex);
input_info(true, &ts->client->dev, "%s: done\n", __func__);
return 0;
}
static int sec_ts_start_device(struct sec_ts_data *ts) {
input_info(true, &ts->client->dev, "%s\n", __func__);
mutex_lock(&ts->device_mutex);
if (ts->power_status == SEC_TS_STATE_POWER_ON) {
input_err(true, &ts->client->dev, "%s: already power on\n", __func__);
goto out;
}
sec_ts_release_all_finger(ts);
if (!ts->interrupt_enable) {
input_err(true, &ts->client->dev, "%s: interrupt work not finished\n",
__func__);
goto out;
}
ts->plat_data->power(ts, true);
sec_ts_delay(200);
ts->power_status = SEC_TS_STATE_POWER_ON;
input_err(true, &ts->client->dev, "%s: SEC_TS_STATE_POWER_ON\n", __func__);
if (ts->plat_data->enable_sync)
ts->plat_data->enable_sync(true);
#ifdef SEC_TS_SUPPORT_TA_MODE
if (ts->ta_status)
sec_ts_charger_config(ts, ts->ta_status);
#endif
enable_irq(ts->client->irq);
out:
mutex_unlock(&ts->device_mutex);
input_info(true, &ts->client->dev, "%s: done\n", __func__);
return 0;
}
#if defined(CONFIG_FB)
static int fb_notifier_callback(struct notifier_block *self,
unsigned long event, void *data) {
struct fb_event *evdata = data;
int *blank;
struct sec_ts_data *ts = container_of(self, struct sec_ts_data, fb_notif);
input_info(true, &ts->client->dev, "%s event = %ld\n", __func__, event);
if (evdata && evdata->data && event == FB_EARLY_EVENT_BLANK) {
blank = evdata->data;
input_info(true, &ts->client->dev,
"%s event = FB_EARLY_EVENT_BLANK, blank = %d\n", __func__,
*blank);
if (*blank == FB_BLANK_POWERDOWN) {
input_info(true, &ts->client->dev, "%s blank = FB_BLANK_POWERDOWN\n",
__func__);
sec_ts_input_close(ts->input_dev);
} else if (*blank == FB_BLANK_UNBLANK) {
input_info(true, &ts->client->dev, "%s blank = FB_BLANK_UNBLANK\n",
__func__);
if (ts->lowpower_status && ts->fw_workdone) {
disable_irq(ts->client->irq);
}
}
} else if (evdata && evdata->data && event == FB_EVENT_BLANK) {
blank = evdata->data;
input_info(true, &ts->client->dev,
"%s event = FB_EVENT_BLANK, blank = %d\n", __func__, *blank);
if (*blank == FB_BLANK_UNBLANK) {
input_info(true, &ts->client->dev, "%s blank = FB_BLANK_UNBLANK\n",
__func__);
sec_ts_input_open(ts->input_dev);
} else if (*blank == FB_BLANK_POWERDOWN) {
input_info(true, &ts->client->dev, "%s blank = FB_BLANK_POWERDOWN\n",
__func__);
}
}
return 0;
}
#elif defined(CONFIG_HAS_EARLYSUSPEND)
static void sec_ts_early_suspend(struct early_suspend *h) {
sec_ts_input_close(ts->input_dev);
}
static void sec_ts_late_resume(struct early_suspend *h) {
sec_ts_input_open(ts->input_dev);
}
#endif
static const struct i2c_device_id sec_ts_id[] = {
{SEC_TS_I2C_NAME, 0}, {},
};
MODULE_DEVICE_TABLE(i2c, sec_ts_id);
#ifdef CONFIG_OF
static const struct of_device_id sec_ts_match_table[] = {
{
.compatible = "sec,sec_ts",
},
{},
};
MODULE_DEVICE_TABLE(of, sec_ts_match_table);
#endif
static struct i2c_driver sec_ts_driver = {
.probe = sec_ts_probe,
.remove = sec_ts_remove,
.shutdown = sec_ts_shutdown,
.id_table = sec_ts_id,
.driver =
{
.owner = THIS_MODULE,
.name = SEC_TS_I2C_NAME,
.of_match_table = of_match_ptr(sec_ts_match_table),
},
};
static int __init sec_ts_init(void) {
int ret;
ret = i2c_add_driver(&sec_ts_driver);
if (ret)
pr_err("%s:fail to i2c_add_driver\n", __func__);
return ret;
}
static void __exit sec_ts_exit(void) {
i2c_del_driver(&sec_ts_driver);
if (sec_fwu_wq)
destroy_workqueue(sec_fwu_wq);
}
late_initcall_sync(sec_ts_init);
module_exit(sec_ts_exit);
MODULE_AUTHOR("Younghee, Won<younghee46.won@samsung.com>");
MODULE_DESCRIPTION("Samsung Electronics TouchScreen driver");
MODULE_LICENSE("GPL");