diff options
| author | Super Liu <supercjliu@google.com> | 2020-04-13 09:46:55 +0800 |
|---|---|---|
| committer | Super Liu <supercjliu@google.com> | 2020-04-14 12:46:48 +0800 |
| commit | 408003f18439ff07599b083cf64b2aefd698da10 (patch) | |
| tree | f524ab3b4fe44ae08dc73a5c349ee19aaa565489 | |
| parent | d7b038d47f4d52488757b8ad960ed7701a80e5e9 (diff) | |
| download | sec_touch-408003f18439ff07599b083cf64b2aefd698da10.tar.gz | |
sec_touch: clean up error and warning by checkpatch.pl
Bug: 153829763
Change-Id: I3010d41c2526332f7ae209d15612c3eb823ba604
Signed-off-by: Super Liu <supercjliu@google.com>
| -rw-r--r-- | sec_cmd.c | 84 | ||||
| -rw-r--r-- | sec_cmd.h | 111 | ||||
| -rw-r--r-- | sec_ts.c | 1061 | ||||
| -rw-r--r-- | sec_ts.h | 154 | ||||
| -rw-r--r-- | sec_ts_fn.c | 1113 | ||||
| -rw-r--r-- | sec_ts_fw.c | 583 | ||||
| -rw-r--r-- | sec_ts_only_vendor.c | 87 |
7 files changed, 2027 insertions, 1166 deletions
@@ -23,7 +23,8 @@ void sec_cmd_set_cmd_exit(struct sec_cmd_data *data) mutex_lock(&data->fifo_lock); if (kfifo_len(&data->cmd_queue)) { pr_info("%s %s: do next cmd, left cmd[%d]\n", SECLOG, __func__, - (int)(kfifo_len(&data->cmd_queue) / sizeof(struct command))); + (int)(kfifo_len(&data->cmd_queue) / + sizeof(struct command))); mutex_unlock(&data->fifo_lock); atomic_set(&data->cmd_is_running, 1); @@ -40,6 +41,7 @@ void sec_cmd_set_cmd_exit(struct sec_cmd_data *data) void sec_cmd_set_default_result(struct sec_cmd_data *data) { char delim = ':'; + memset(data->cmd_result, 0x00, SEC_CMD_RESULT_STR_LEN); memcpy(data->cmd_result, data->cmd, SEC_CMD_STR_LEN); strncat(data->cmd_result, &delim, 1); @@ -51,7 +53,7 @@ void sec_cmd_set_cmd_result(struct sec_cmd_data *data, char *buff, int len) } #ifndef USE_SEC_CMD_QUEUE -static ssize_t sec_cmd_store(struct device *dev, +static ssize_t cmd_store(struct device *dev, struct device_attribute *devattr, const char *buf, size_t count) { struct sec_cmd_data *data = dev_get_drvdata(dev); @@ -74,7 +76,7 @@ static ssize_t sec_cmd_store(struct device *dev, return -EINVAL; } - if (atomic_cmpxchg(&data->cmd_is_running, 0 , 1)) { + if (atomic_cmpxchg(&data->cmd_is_running, 0, 1)) { pr_err("%s %s: other cmd is running.\n", SECLOG, __func__); return -EBUSY; } @@ -125,8 +127,10 @@ static ssize_t sec_cmd_store(struct device *dev, if (*cur == delim || cur - buf == len) { end = cur; memcpy(buff, start, end - start); - *(buff + strnlen(buff, ARRAY_SIZE(buff))) = '\0'; - if (kstrtoint(buff, 10, data->cmd_param + param_cnt) < 0) + *(buff + + strnlen(buff, ARRAY_SIZE(buff))) = '\0'; + if (kstrtoint(buff, 10, + data->cmd_param + param_cnt) < 0) goto err_out; start = cur + 1; memset(buff, 0x00, ARRAY_SIZE(buff)); @@ -137,7 +141,8 @@ static ssize_t sec_cmd_store(struct device *dev, } if (cmd_found) { - pr_info("%s %s: cmd = %s", SECLOG, __func__, sec_cmd_ptr->cmd_name); + pr_info("%s %s: cmd = %s", + SECLOG, __func__, sec_cmd_ptr->cmd_name); for (i = 0; i < param_cnt; i++) { if (i == 0) pr_cont(" param ="); @@ -145,7 +150,8 @@ static ssize_t sec_cmd_store(struct device *dev, } pr_cont("\n"); } else { - pr_info("%s %s: cmd = %s(%s)\n", SECLOG, __func__, buff, sec_cmd_ptr->cmd_name); + pr_info("%s %s: cmd = %s(%s)\n", + SECLOG, __func__, buff, sec_cmd_ptr->cmd_name); } sec_cmd_ptr->cmd_func(data); @@ -168,7 +174,7 @@ static void sec_cmd_store_function(struct sec_cmd_data *data) int ret; const char *buf; size_t count; - struct command cmd = {{0}}; + struct command cmd = { {0} }; if (!data) { pr_err("%s %s: No platform data found\n", SECLOG, __func__); @@ -179,7 +185,8 @@ static void sec_cmd_store_function(struct sec_cmd_data *data) if (kfifo_len(&data->cmd_queue)) { ret = kfifo_out(&data->cmd_queue, &cmd, sizeof(struct command)); if (!ret) { - pr_err("%s %s: kfifo_out failed, it seems empty, ret=%d\n", SECLOG, __func__, ret); + pr_err("%s %s: kfifo_out failed, it seems empty, ret=%d\n", + SECLOG, __func__, ret); mutex_unlock(&data->fifo_lock); return; } @@ -238,8 +245,10 @@ static void sec_cmd_store_function(struct sec_cmd_data *data) if (*cur == delim || cur - buf == len) { end = cur; memcpy(buff, start, end - start); - *(buff + strnlen(buff, ARRAY_SIZE(buff))) = '\0'; - if (kstrtoint(buff, 10, data->cmd_param + param_cnt) < 0) + *(buff + + strnlen(buff, ARRAY_SIZE(buff))) = '\0'; + if (kstrtoint(buff, 10, + data->cmd_param + param_cnt) < 0) return; start = cur + 1; memset(buff, 0x00, ARRAY_SIZE(buff)); @@ -250,7 +259,8 @@ static void sec_cmd_store_function(struct sec_cmd_data *data) } if (cmd_found) { - pr_info("%s %s: cmd = %s", SECLOG, __func__, sec_cmd_ptr->cmd_name); + pr_info("%s %s: cmd = %s", + SECLOG, __func__, sec_cmd_ptr->cmd_name); for (i = 0; i < param_cnt; i++) { if (i == 0) pr_cont(" param ="); @@ -258,18 +268,20 @@ static void sec_cmd_store_function(struct sec_cmd_data *data) } pr_cont("\n"); } else { - pr_info("%s %s: cmd = %s(%s)\n", SECLOG, __func__, buff, sec_cmd_ptr->cmd_name); + pr_info("%s %s: cmd = %s(%s)\n", + SECLOG, __func__, buff, sec_cmd_ptr->cmd_name); } sec_cmd_ptr->cmd_func(data); } -static ssize_t sec_cmd_store(struct device *dev, struct device_attribute *devattr, - const char *buf, size_t count) +static ssize_t cmd_store(struct device *dev, + struct device_attribute *devattr, + const char *buf, size_t count) { struct sec_cmd_data *data = dev_get_drvdata(dev); - struct command cmd = {{0}}; + struct command cmd = { {0} }; int queue_size; if (!data) { @@ -303,9 +315,11 @@ static ssize_t sec_cmd_store(struct device *dev, struct device_attribute *devatt return -ENOSPC; } - if (atomic_cmpxchg(&data->cmd_is_running, 0 , 1)) { + if (atomic_cmpxchg(&data->cmd_is_running, 0, 1)) { pr_err("%s %s: other cmd is running. Wait until previous cmd is done[%d]\n", - SECLOG, __func__, (int)(kfifo_len(&data->cmd_queue) / sizeof(struct command))); + SECLOG, __func__, + (int)(kfifo_len(&data->cmd_queue) / + sizeof(struct command))); mutex_unlock(&data->fifo_lock); return -EBUSY; @@ -320,7 +334,7 @@ static ssize_t sec_cmd_store(struct device *dev, struct device_attribute *devatt } #endif -static ssize_t sec_cmd_show_status(struct device *dev, +static ssize_t cmd_status_show(struct device *dev, struct device_attribute *devattr, char *buf) { struct sec_cmd_data *data = dev_get_drvdata(dev); @@ -351,7 +365,7 @@ static ssize_t sec_cmd_show_status(struct device *dev, return snprintf(buf, SEC_CMD_BUF_SIZE, "%s\n", buff); } -static ssize_t sec_cmd_show_result(struct device *dev, +static ssize_t cmd_result_show(struct device *dev, struct device_attribute *devattr, char *buf) { struct sec_cmd_data *data = dev_get_drvdata(dev); @@ -371,7 +385,7 @@ static ssize_t sec_cmd_show_result(struct device *dev, return size; } -static ssize_t sec_cmd_list_show(struct device *dev, +static ssize_t cmd_list_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sec_cmd_data *data = dev_get_drvdata(dev); @@ -390,7 +404,8 @@ static ssize_t sec_cmd_list_show(struct device *dev, list_for_each_entry(sec_cmd_ptr, &data->cmd_list_head, list) { if (strncmp(sec_cmd_ptr->cmd_name, "not_support_cmd", 15)) { - snprintf(buffer_name, SEC_CMD_STR_LEN, "%s\n", sec_cmd_ptr->cmd_name); + snprintf(buffer_name, SEC_CMD_STR_LEN, "%s\n", + sec_cmd_ptr->cmd_name); strncat(buffer, buffer_name, SEC_CMD_STR_LEN); } } @@ -401,10 +416,10 @@ static ssize_t sec_cmd_list_show(struct device *dev, return ret; } -static DEVICE_ATTR(cmd, S_IWUSR | S_IWGRP, NULL, sec_cmd_store); -static DEVICE_ATTR(cmd_status, S_IRUGO, sec_cmd_show_status, NULL); -static DEVICE_ATTR(cmd_result, S_IRUGO, sec_cmd_show_result, NULL); -static DEVICE_ATTR(cmd_list, S_IRUGO, sec_cmd_list_show, NULL); +static DEVICE_ATTR_WO(cmd); +static DEVICE_ATTR_RO(cmd_status); +static DEVICE_ATTR_RO(cmd_result); +static DEVICE_ATTR_RO(cmd_list); static struct attribute *sec_fac_attrs[] = { &dev_attr_cmd.attr, @@ -439,7 +454,8 @@ int sec_cmd_init(struct sec_cmd_data *data, struct sec_cmd *cmds, #ifdef USE_SEC_CMD_QUEUE if (kfifo_alloc(&data->cmd_queue, SEC_CMD_MAX_QUEUE * sizeof(struct command), GFP_KERNEL)) { - pr_err("%s %s: failed to alloc queue for cmd\n", SECLOG, __func__); + pr_err("%s %s: failed to alloc queue for cmd\n", + SECLOG, __func__); goto err_alloc_queue; } mutex_init(&data->fifo_lock); @@ -465,7 +481,8 @@ int sec_cmd_init(struct sec_cmd_data *data, struct sec_cmd *cmds, data->fac_dev = device_create(sec_class, NULL, devt, data, dev_name); #endif if (IS_ERR(data->fac_dev)) { - pr_err("%s %s: failed to create device for the sysfs\n", SECLOG, __func__); + pr_err("%s %s: failed to create device for the sysfs\n", + SECLOG, __func__); goto err_sysfs_device; } @@ -473,7 +490,8 @@ int sec_cmd_init(struct sec_cmd_data *data, struct sec_cmd *cmds, ret = sysfs_create_group(&data->fac_dev->kobj, &sec_fac_attr_group); if (ret < 0) { - pr_err("%s %s: failed to create sysfs group\n", SECLOG, __func__); + pr_err("%s %s: failed to create sysfs group\n", + SECLOG, __func__); goto err_sysfs_group; } @@ -500,7 +518,7 @@ err_alloc_queue: void sec_cmd_exit(struct sec_cmd_data *data, int devt) { #ifdef USE_SEC_CMD_QUEUE - struct command cmd = {{0}}; + struct command cmd = { {0} }; int ret; #endif @@ -517,9 +535,11 @@ void sec_cmd_exit(struct sec_cmd_data *data, int devt) while (kfifo_len(&data->cmd_queue)) { ret = kfifo_out(&data->cmd_queue, &cmd, sizeof(struct command)); if (!ret) { - pr_err("%s %s: kfifo_out failed, it seems empty, ret=%d\n", SECLOG, __func__, ret); + pr_err("%s %s: kfifo_out failed, it seems empty, ret=%d\n", + SECLOG, __func__, ret); } - pr_info("%s %s: remove pending commands: %s", SECLOG, __func__, cmd.cmd); + pr_info("%s %s: remove pending commands: %s", + SECLOG, __func__, cmd.cmd); } mutex_unlock(&data->fifo_lock); mutex_destroy(&data->fifo_lock); @@ -76,7 +76,8 @@ struct sec_cmd_data { extern void sec_cmd_set_cmd_exit(struct sec_cmd_data *data); extern void sec_cmd_set_default_result(struct sec_cmd_data *data); -extern void sec_cmd_set_cmd_result(struct sec_cmd_data *data, char *buff, int len); +extern void sec_cmd_set_cmd_result(struct sec_cmd_data *data, char *buff, + int len); extern int sec_cmd_init(struct sec_cmd_data *data, struct sec_cmd *cmds, int len, int devt); extern void sec_cmd_exit(struct sec_cmd_data *data, int devt); @@ -90,67 +91,67 @@ extern void sec_cmd_exit(struct sec_cmd_data *data, int devt); #ifdef CONFIG_SEC_DEBUG_TSP_LOG #include <linux/sec_debug.h> -#define input_dbg(mode, dev, fmt, ...) \ -({ \ - static char input_log_buf[INPUT_LOG_BUF_SIZE]; \ - snprintf(input_log_buf, sizeof(input_log_buf), "%s %s", SECLOG, fmt); \ - dev_dbg(dev, input_log_buf, ## __VA_ARGS__); \ - if (mode) { \ - if (dev) \ - snprintf(input_log_buf, sizeof(input_log_buf), "%s %s", \ - dev_driver_string(dev), dev_name(dev)); \ - else \ - snprintf(input_log_buf, sizeof(input_log_buf), "NULL"); \ - sec_debug_tsp_log_msg(input_log_buf, fmt, ## __VA_ARGS__); \ - } \ +#define input_dbg(mode, dev, fmt, ...) \ +({ \ + static char input_log_buf[INPUT_LOG_BUF_SIZE]; \ + snprintf(input_log_buf, sizeof(input_log_buf), "%s %s", SECLOG, fmt); \ + dev_dbg(dev, input_log_buf, ## __VA_ARGS__); \ + if (mode) { \ + if (dev) \ + snprintf(input_log_buf, sizeof(input_log_buf), "%s %s",\ + dev_driver_string(dev), dev_name(dev));\ + else \ + snprintf(input_log_buf, sizeof(input_log_buf), "NULL");\ + sec_debug_tsp_log_msg(input_log_buf, fmt, ## __VA_ARGS__); \ + } \ }) -#define input_info(mode, dev, fmt, ...) \ -({ \ - static char input_log_buf[INPUT_LOG_BUF_SIZE]; \ - snprintf(input_log_buf, sizeof(input_log_buf), "%s %s", SECLOG, fmt); \ - dev_info(dev, input_log_buf, ## __VA_ARGS__); \ - if (mode) { \ - if (dev) \ - snprintf(input_log_buf, sizeof(input_log_buf), "%s %s", \ - dev_driver_string(dev), dev_name(dev)); \ - else \ - snprintf(input_log_buf, sizeof(input_log_buf), "NULL"); \ - sec_debug_tsp_log_msg(input_log_buf, fmt, ## __VA_ARGS__); \ - } \ +#define input_info(mode, dev, fmt, ...) \ +({ \ + static char input_log_buf[INPUT_LOG_BUF_SIZE]; \ + snprintf(input_log_buf, sizeof(input_log_buf), "%s %s", SECLOG, fmt); \ + dev_info(dev, input_log_buf, ## __VA_ARGS__); \ + if (mode) { \ + if (dev) \ + snprintf(input_log_buf, sizeof(input_log_buf), "%s %s",\ + dev_driver_string(dev), dev_name(dev));\ + else \ + snprintf(input_log_buf, sizeof(input_log_buf), "NULL");\ + sec_debug_tsp_log_msg(input_log_buf, fmt, ## __VA_ARGS__); \ + } \ }) -#define input_err(mode, dev, fmt, ...) \ -({ \ - static char input_log_buf[INPUT_LOG_BUF_SIZE]; \ - snprintf(input_log_buf, sizeof(input_log_buf), "%s %s", SECLOG, fmt); \ - dev_err(dev, input_log_buf, ## __VA_ARGS__); \ - if (mode) { \ - if (dev) \ - snprintf(input_log_buf, sizeof(input_log_buf), "%s %s", \ - dev_driver_string(dev), dev_name(dev)); \ - else \ - snprintf(input_log_buf, sizeof(input_log_buf), "NULL"); \ - sec_debug_tsp_log_msg(input_log_buf, fmt, ## __VA_ARGS__); \ - } \ +#define input_err(mode, dev, fmt, ...) \ +({ \ + static char input_log_buf[INPUT_LOG_BUF_SIZE]; \ + snprintf(input_log_buf, sizeof(input_log_buf), "%s %s", SECLOG, fmt); \ + dev_err(dev, input_log_buf, ## __VA_ARGS__); \ + if (mode) { \ + if (dev) \ + snprintf(input_log_buf, sizeof(input_log_buf), "%s %s",\ + dev_driver_string(dev), dev_name(dev));\ + else \ + snprintf(input_log_buf, sizeof(input_log_buf), "NULL");\ + sec_debug_tsp_log_msg(input_log_buf, fmt, ## __VA_ARGS__); \ + } \ }) #define input_log_fix() {} #else -#define input_dbg(mode, dev, fmt, ...) \ -({ \ - static char input_log_buf[INPUT_LOG_BUF_SIZE]; \ - snprintf(input_log_buf, sizeof(input_log_buf), "%s %s", SECLOG, fmt); \ - dev_dbg(dev, input_log_buf, ## __VA_ARGS__); \ +#define input_dbg(mode, dev, fmt, ...) \ +({ \ + static char input_log_buf[INPUT_LOG_BUF_SIZE]; \ + snprintf(input_log_buf, sizeof(input_log_buf), "%s %s", SECLOG, fmt); \ + dev_dbg(dev, input_log_buf, ## __VA_ARGS__); \ }) -#define input_info(mode, dev, fmt, ...) \ -({ \ - static char input_log_buf[INPUT_LOG_BUF_SIZE]; \ - snprintf(input_log_buf, sizeof(input_log_buf), "%s %s", SECLOG, fmt); \ - dev_info(dev, input_log_buf, ## __VA_ARGS__); \ +#define input_info(mode, dev, fmt, ...) \ +({ \ + static char input_log_buf[INPUT_LOG_BUF_SIZE]; \ + snprintf(input_log_buf, sizeof(input_log_buf), "%s %s", SECLOG, fmt); \ + dev_info(dev, input_log_buf, ## __VA_ARGS__); \ }) -#define input_err(mode, dev, fmt, ...) \ -({ \ - static char input_log_buf[INPUT_LOG_BUF_SIZE]; \ - snprintf(input_log_buf, sizeof(input_log_buf), "%s %s", SECLOG, fmt); \ - dev_err(dev, input_log_buf, ## __VA_ARGS__); \ +#define input_err(mode, dev, fmt, ...) \ +({ \ + static char input_log_buf[INPUT_LOG_BUF_SIZE]; \ + snprintf(input_log_buf, sizeof(input_log_buf), "%s %s", SECLOG, fmt); \ + dev_err(dev, input_log_buf, ## __VA_ARGS__); \ }) #define input_log_fix() {} #endif @@ -15,8 +15,8 @@ struct sec_ts_data *tsp_info; #include "sec_ts.h" /* Switch GPIO values */ -#define SEC_SWITCH_GPIO_VALUE_SLPI_MASTER 1 -#define SEC_SWITCH_GPIO_VALUE_AP_MASTER 0 +#define SEC_SWITCH_GPIO_VALUE_SLPI_MASTER 1 +#define SEC_SWITCH_GPIO_VALUE_AP_MASTER 0 struct sec_ts_data *ts_dup; @@ -112,7 +112,9 @@ int sec_ts_write(struct sec_ts_data *ts, u8 reg, u8 *data, int len) /* add 3 zero stuffing tx bytes at last */ memset(ts->io_write_buf + spi_len, 0x00, 3); - spi_len = (spi_len + 3) & ~3; //spi transfer size should be multiple of 4 + /* spi transfer size should be multiple of 4 + **/ + spi_len = (spi_len + 3) & ~3; transfer[0].len = spi_len; transfer[0].tx_buf = buf; transfer[0].rx_buf = NULL; @@ -138,7 +140,9 @@ int sec_ts_write(struct sec_ts_data *ts, u8 reg, u8 *data, int len) #endif if (ts->power_status == SEC_TS_STATE_POWER_OFF) { - input_err(true, &ts->client->dev, "%s: POWER_STATUS : OFF, retry:%d\n", __func__, retry); + input_err(true, &ts->client->dev, + "%s: POWER_STATUS : OFF, retry:%d\n", + __func__, retry); mutex_unlock(&ts->io_mutex); goto err; } @@ -146,7 +150,8 @@ int sec_ts_write(struct sec_ts_data *ts, u8 reg, u8 *data, int len) usleep_range(1 * 1000, 1 * 1000); if (retry > 1) { - input_err(true, &ts->client->dev, "%s: retry %d\n", __func__, retry + 1); + input_err(true, &ts->client->dev, + "%s: retry %d\n", __func__, retry + 1); ts->comm_err_count++; } } @@ -154,11 +159,13 @@ int sec_ts_write(struct sec_ts_data *ts, u8 reg, u8 *data, int len) mutex_unlock(&ts->io_mutex); if (retry == SEC_TS_IO_RETRY_CNT) { - input_err(true, &ts->client->dev, "%s: write over retry limit\n", __func__); + input_err(true, &ts->client->dev, + "%s: write over retry limit\n", __func__); ret = -EIO; #ifdef USE_POR_AFTER_I2C_RETRY if (ts->probe_done && !ts->reset_is_on_going) - schedule_delayed_work(&ts->reset_work, msecs_to_jiffies(TOUCH_RESET_DWORK_TIME)); + schedule_delayed_work(&ts->reset_work, + msecs_to_jiffies(TOUCH_RESET_DWORK_TIME)); #endif } @@ -262,18 +269,23 @@ static int sec_ts_read_internal(struct sec_ts_data *ts, u8 reg, usleep_range(1 * 1000, 1 * 1000); if (ts->power_status == SEC_TS_STATE_POWER_OFF) { - input_err(true, &ts->client->dev, "%s: POWER_STATUS : OFF, retry:%d\n", __func__, retry); + input_err(true, &ts->client->dev, + "%s: POWER_STATUS : OFF, retry:%d\n", + __func__, retry); mutex_unlock(&ts->io_mutex); goto err; } if (retry > 1) { - input_err(true, &ts->client->dev, "%s: retry %d\n", __func__, retry + 1); + input_err(true, &ts->client->dev, + "%s: retry %d\n", __func__, retry + 1); ts->comm_err_count++; } } if (ret == 2 && dma_safe == false) - memcpy(data, ts->io_read_buf[SEC_TS_SPI_READ_HEADER_SIZE], len); + memcpy(data, + ts->io_read_buf[SEC_TS_SPI_READ_HEADER_SIZE], + len); #else for (retry = 0; retry < SEC_TS_IO_RETRY_CNT; retry++) { spi_message_init(&msg); @@ -378,13 +390,14 @@ static int sec_ts_read_internal(struct sec_ts_data *ts, u8 reg, break; } if (ret == 0) - memcpy(data, ts->io_read_buf + SEC_TS_SPI_READ_HEADER_SIZE, len); + memcpy(data, ts->io_read_buf + + SEC_TS_SPI_READ_HEADER_SIZE, len); #endif //I2C_INTERFACE } else { /* - * read buffer is 256 byte. do not support long buffer over than 256. - * So, try to seperate reading data about 256 bytes. - */ + * read buffer is 256 byte. do not support long buffer over + * than 256. So, try to separate reading data about 256 bytes. + **/ #ifdef I2C_INTERFACE for (retry = 0; retry < SEC_TS_IO_RETRY_CNT; retry++) { ret = i2c_transfer(ts->client->adapter, msg, 1); @@ -417,11 +430,13 @@ static int sec_ts_read_internal(struct sec_ts_data *ts, u8 reg, remain -= ts->io_burstmax; for (retry = 0; retry < SEC_TS_IO_RETRY_CNT; retry++) { - ret = i2c_transfer(ts->client->adapter, &msg[1], 1); + ret = i2c_transfer(ts->client->adapter, + &msg[1], 1); if (ret == 1) break; usleep_range(1 * 1000, 1 * 1000); - if (ts->power_status == SEC_TS_STATE_POWER_OFF) { + if (ts->power_status == + SEC_TS_STATE_POWER_OFF) { input_err(true, &ts->client->dev, "%s: POWER_STATUS : OFF, retry:%d\n", __func__, retry); @@ -600,7 +615,8 @@ skip_spi_read: ts->io_err_count++; #ifdef USE_POR_AFTER_I2C_RETRY if (ts->probe_done && !ts->reset_is_on_going) - schedule_delayed_work(&ts->reset_work, msecs_to_jiffies(TOUCH_RESET_DWORK_TIME)); + schedule_delayed_work(&ts->reset_work, + msecs_to_jiffies(TOUCH_RESET_DWORK_TIME)); #endif } else @@ -683,8 +699,8 @@ static int sec_ts_write_burst_internal(struct sec_ts_data *ts, spi_message_add_tail(&transfer[0], &msg); #ifdef SEC_TS_DEBUG_IO - input_info(true, &ts->client->dev, "%s: \n", __func__); - for (i = 0; i < spi_len; i++) + input_info(true, &ts->client->dev, "%s:\n", __func__); + for (i = 0; i < spi_len; i++) input_info(true, &ts->client->dev, "%X ", ts->io_write_buf[i]); input_info(true, &ts->client->dev, "\n"); #endif @@ -703,14 +719,16 @@ static int sec_ts_write_burst_internal(struct sec_ts_data *ts, usleep_range(1 * 1000, 1 * 1000); if (retry > 1) { - input_err(true, &ts->client->dev, "%s: retry %d\n", __func__, retry + 1); + input_err(true, &ts->client->dev, + "%s: retry %d\n", __func__, retry + 1); ts->comm_err_count++; } } mutex_unlock(&ts->io_mutex); if (retry == SEC_TS_IO_RETRY_CNT) { - input_err(true, &ts->client->dev, "%s: write over retry limit\n", __func__); + input_err(true, &ts->client->dev, + "%s: write over retry limit\n", __func__); ret = -EIO; } @@ -768,7 +786,9 @@ static int sec_ts_read_bulk_internal(struct sec_ts_data *ts, usleep_range(1 * 1000, 1 * 1000); if (retry > 1) { - input_err(true, &ts->client->dev, "%s: retry %d\n", __func__, retry + 1); + input_err(true, &ts->client->dev, + "%s: retry %d\n", + __func__, retry + 1); ts->comm_err_count++; } } @@ -788,7 +808,8 @@ static int sec_ts_read_bulk_internal(struct sec_ts_data *ts, memcpy(data, ts->io_read_buf, len); #else retry_message: - remain = spi_len = (SEC_TS_SPI_READ_HEADER_SIZE + len + SEC_TS_SPI_CHECKSUM_SIZE + 3) & ~3; + remain = spi_len = (SEC_TS_SPI_READ_HEADER_SIZE + len + + SEC_TS_SPI_CHECKSUM_SIZE + 3) & ~3; do { if (remain > ts->io_burstmax) copy_cur = ts->io_burstmax; @@ -796,10 +817,12 @@ retry_message: copy_cur = remain; spi_message_init(&msg); - transfer[0].len = copy_cur;; + transfer[0].len = copy_cur; transfer[0].tx_buf = NULL; transfer[0].rx_buf = &ts->io_read_buf[copy_size]; - transfer[0].cs_change = (remain > ts->io_burstmax) ? 1 : 0; // CS needs to stay low until read seq. is done + /* CS needs to stay low until read seq. is done + */ + transfer[0].cs_change = (remain > ts->io_burstmax) ? 1 : 0; spi_message_add_tail(&transfer[0], &msg); @@ -813,13 +836,16 @@ retry_message: usleep_range(1 * 1000, 1 * 1000); if (ts->power_status == SEC_TS_STATE_POWER_OFF) { - input_err(true, &ts->client->dev, "%s: POWER_STATUS : OFF, retry:%d\n", __func__, retry); + input_err(true, &ts->client->dev, + "%s: POWER_STATUS : OFF, retry:%d\n", + __func__, retry); mutex_unlock(&ts->io_mutex); goto err; } if (retry > 1) { - input_err(true, &ts->client->dev, "%s: retry %d\n", __func__, retry + 1); + input_err(true, &ts->client->dev, + "%s: retry %d\n", __func__, retry + 1); ts->comm_err_count++; } } @@ -830,11 +856,14 @@ retry_message: if (ret == 0 && ts->io_read_buf[0] == SEC_TS_SPI_SYNC_CODE && checksum == ts->io_read_buf[SEC_TS_SPI_READ_HEADER_SIZE + len]) - memcpy(data, ts->io_read_buf + SEC_TS_SPI_READ_HEADER_SIZE, len); + memcpy(data, ts->io_read_buf + SEC_TS_SPI_READ_HEADER_SIZE, + len); else { - input_info(true, &ts->client->dev, "%s: spi fail, ret %d, sync code %X, reg(S) %X, chksum(M) %X, chksum(S) %X\n", + input_info(true, &ts->client->dev, + "%s: spi fail, ret %d, sync code %X, reg(S) %X, chksum(M) %X, chksum(S) %X\n", __func__, ret, ts->io_read_buf[0], ts->io_read_buf[5], - checksum, ts->io_read_buf[SEC_TS_SPI_READ_HEADER_SIZE + len]); + checksum, + ts->io_read_buf[SEC_TS_SPI_READ_HEADER_SIZE + len]); if (retry_msg++ < SEC_TS_IO_RETRY_CNT) goto retry_message; } @@ -913,11 +942,13 @@ static int sec_ts_read_from_customlib(struct sec_ts_data *ts, u8 *data, int len) ret = sec_ts_write(ts, SEC_TS_CMD_CUSTOMLIB_READ_PARAM, data, 2); if (ret < 0) - input_err(true, &ts->client->dev, "%s: fail to read custom library command\n", __func__); + input_err(true, &ts->client->dev, + "%s: fail to read custom library command\n", __func__); ret = sec_ts_read(ts, SEC_TS_CMD_CUSTOMLIB_READ_PARAM, (u8 *)data, len); if (ret < 0) - input_err(true, &ts->client->dev, "%s: fail to read custom library command\n", __func__); + input_err(true, &ts->client->dev, + "%s: fail to read custom library command\n", __func__); return ret; } @@ -929,14 +960,17 @@ static 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); + 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__); + 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__); + input_err(true, &ts->client->dev, + "%s: ignored ## IC is power off\n", __func__); return; } @@ -956,13 +990,15 @@ static void dump_tsp_log(void) #ifdef CONFIG_BATTERY_SAMSUNG if (lpcharge == 1) { - pr_err("%s: %s %s: ignored ## lpm charging Mode!!\n", SEC_TS_NAME, SECLOG, __func__); + pr_err("%s: %s %s: ignored ## lpm charging Mode!!\n", + SEC_TS_NAME, SECLOG, __func__); return; } #endif if (p_ghost_check == NULL) { - pr_err("%s: %s %s: ignored ## tsp probe fail!!\n", SEC_TS_NAME, SECLOG, __func__); + pr_err("%s: %s %s: ignored ## tsp probe fail!!\n", + SEC_TS_NAME, SECLOG, __func__); return; } schedule_delayed_work(p_ghost_check, msecs_to_jiffies(100)); @@ -999,7 +1035,8 @@ int sec_ts_wait_for_ready_with_count(struct sec_ts_data *ts, unsigned int ack, rc = 0; break; } - } else if (((tBuff[0] >> 2) & 0xF) == TYPE_STATUS_EVENT_VENDOR_INFO) { + } else if (((tBuff[0] >> 2) & 0xF) == + TYPE_STATUS_EVENT_VENDOR_INFO) { if (tBuff[1] == ack) { rc = 0; break; @@ -1029,7 +1066,8 @@ int sec_ts_read_calibration_report(struct sec_ts_data *ts) ret = sec_ts_read(ts, SEC_TS_READ_CALIBRATION_REPORT, ts->cali_report, sizeof(ts->cali_report)); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: failed to read, %d\n", __func__, ret); + input_err(true, &ts->client->dev, + "%s: failed to read, %d\n", __func__, ret); return ret; } @@ -1049,30 +1087,37 @@ static void sec_ts_reinit(struct sec_ts_data *ts) int ret = 0; input_info(true, &ts->client->dev, - "%s : charger=0x%x, Cover=0x%x, Power mode=0x%x\n", - __func__, ts->charger_mode, ts->touch_functions, ts->lowpower_status); + "%s : charger=0x%x, Cover=0x%x, Power mode=0x%x\n", + __func__, ts->charger_mode, ts->touch_functions, + ts->lowpower_status); /* charger mode */ if (ts->charger_mode != SEC_TS_BIT_CHARGER_MODE_NO) { w_data[0] = ts->charger_mode; - ret = ts->sec_ts_write(ts, SET_TS_CMD_SET_CHARGER_MODE, (u8 *)&w_data[0], 1); + ret = ts->sec_ts_write(ts, SET_TS_CMD_SET_CHARGER_MODE, + (u8 *)&w_data[0], 1); if (ret < 0) - input_err(true, &ts->client->dev, "%s: Failed to send command(0x%x)", - __func__, SET_TS_CMD_SET_CHARGER_MODE); + input_err(true, &ts->client->dev, + "%s: Failed to send command(0x%x)", + __func__, SET_TS_CMD_SET_CHARGER_MODE); } /* Cover mode */ if (ts->touch_functions & SEC_TS_BIT_SETFUNC_COVER) { w_data[0] = ts->cover_cmd; - ret = sec_ts_write(ts, SEC_TS_CMD_SET_COVERTYPE, (u8 *)&w_data[0], 1); + ret = sec_ts_write(ts, SEC_TS_CMD_SET_COVERTYPE, + (u8 *)&w_data[0], 1); if (ret < 0) - input_err(true, &ts->client->dev, "%s: Failed to send command(0x%x)", - __func__, SEC_TS_CMD_SET_COVERTYPE); + input_err(true, &ts->client->dev, + "%s: Failed to send command(0x%x)", + __func__, SEC_TS_CMD_SET_COVERTYPE); - ret = sec_ts_write(ts, SEC_TS_CMD_SET_TOUCHFUNCTION, (u8 *)&(ts->touch_functions), 2); + ret = sec_ts_write(ts, SEC_TS_CMD_SET_TOUCHFUNCTION, + (u8 *)&(ts->touch_functions), 2); if (ret < 0) - input_err(true, &ts->client->dev, "%s: Failed to send command(0x%x)", - __func__, SEC_TS_CMD_SET_TOUCHFUNCTION); + input_err(true, &ts->client->dev, + "%s: Failed to send command(0x%x)", + __func__, SEC_TS_CMD_SET_TOUCHFUNCTION); } #ifdef SEC_TS_SUPPORT_CUSTOMLIB @@ -1082,17 +1127,22 @@ static void sec_ts_reinit(struct sec_ts_data *ts) /* Power mode */ if (ts->lowpower_status == TO_LOWPOWER_MODE) { - w_data[0] = (ts->lowpower_mode & SEC_TS_MODE_LOWPOWER_FLAG) >> 1; - ret = sec_ts_write(ts, SEC_TS_CMD_WAKEUP_GESTURE_MODE, (u8 *)&w_data[0], 1); + w_data[0] = (ts->lowpower_mode & + SEC_TS_MODE_LOWPOWER_FLAG) >> 1; + ret = sec_ts_write(ts, SEC_TS_CMD_WAKEUP_GESTURE_MODE, + (u8 *)&w_data[0], 1); if (ret < 0) - input_err(true, &ts->client->dev, "%s: Failed to send command(0x%x)", - __func__, SEC_TS_CMD_WAKEUP_GESTURE_MODE); + input_err(true, &ts->client->dev, + "%s: Failed to send command(0x%x)", + __func__, SEC_TS_CMD_WAKEUP_GESTURE_MODE); w_data[0] = TO_LOWPOWER_MODE; - ret = sec_ts_write(ts, SEC_TS_CMD_SET_POWER_MODE, (u8 *)&w_data[0], 1); + ret = sec_ts_write(ts, SEC_TS_CMD_SET_POWER_MODE, + (u8 *)&w_data[0], 1); if (ret < 0) - input_err(true, &ts->client->dev, "%s: Failed to send command(0x%x)", - __func__, SEC_TS_CMD_SET_POWER_MODE); + input_err(true, &ts->client->dev, + "%s: Failed to send command(0x%x)", + __func__, SEC_TS_CMD_SET_POWER_MODE); sec_ts_delay(50); @@ -1102,16 +1152,24 @@ static void sec_ts_reinit(struct sec_ts_data *ts) for (i = 0; i < 4; i++) { data[i * 2 + 2] = ts->rect_data[i] & 0xFF; - data[i * 2 + 3] = (ts->rect_data[i] >> 8) & 0xFF; + data[i * 2 + 3] = + (ts->rect_data[i] >> 8) & 0xFF; } - ret = ts->sec_ts_write(ts, SEC_TS_CMD_CUSTOMLIB_WRITE_PARAM, &data[0], 10); + ret = ts->sec_ts_write(ts, + SEC_TS_CMD_CUSTOMLIB_WRITE_PARAM, + &data[0], 10); if (ret < 0) - input_err(true, &ts->client->dev, "%s: Failed to write offset\n", __func__); + input_err(true, &ts->client->dev, + "%s: Failed to write offset\n", + __func__); - ret = ts->sec_ts_write(ts, SEC_TS_CMD_CUSTOMLIB_NOTIFY_PACKET, NULL, 0); + ret = ts->sec_ts_write(ts, + SEC_TS_CMD_CUSTOMLIB_NOTIFY_PACKET, NULL, 0); if (ret < 0) - input_err(true, &ts->client->dev, "%s: Failed to send notify\n", __func__); + input_err(true, &ts->client->dev, + "%s: Failed to send notify\n", + __func__); } @@ -1120,31 +1178,40 @@ static void sec_ts_reinit(struct sec_ts_data *ts) sec_ts_set_grip_type(ts, ONLY_EDGE_HANDLER); if (ts->dex_mode) { - input_info(true, &ts->client->dev, "%s: set dex mode\n", __func__); - ret = ts->sec_ts_write(ts, SEC_TS_CMD_SET_DEX_MODE, &ts->dex_mode, 1); + input_info(true, &ts->client->dev, + "%s: set dex mode\n", __func__); + ret = ts->sec_ts_write(ts, SEC_TS_CMD_SET_DEX_MODE, + &ts->dex_mode, 1); if (ret < 0) input_err(true, &ts->client->dev, - "%s: failed to set dex mode %x\n", __func__, ts->dex_mode); + "%s: failed to set dex mode %x\n", + __func__, ts->dex_mode); } if (ts->brush_mode) { - input_info(true, &ts->client->dev, "%s: set brush mode\n", __func__); - ret = ts->sec_ts_write(ts, SEC_TS_CMD_SET_BRUSH_MODE, &ts->brush_mode, 1); + input_info(true, &ts->client->dev, + "%s: set brush mode\n", __func__); + ret = ts->sec_ts_write(ts, SEC_TS_CMD_SET_BRUSH_MODE, + &ts->brush_mode, 1); if (ret < 0) input_err(true, &ts->client->dev, - "%s: failed to set brush mode\n", __func__); + "%s: failed to set brush mode\n", + __func__); } if (ts->touchable_area) { - input_info(true, &ts->client->dev, "%s: set 16:9 mode\n", __func__); - ret = ts->sec_ts_write(ts, SEC_TS_CMD_SET_TOUCHABLE_AREA, &ts->touchable_area, 1); + input_info(true, &ts->client->dev, + "%s: set 16:9 mode\n", __func__); + ret = ts->sec_ts_write(ts, + SEC_TS_CMD_SET_TOUCHABLE_AREA, + &ts->touchable_area, 1); if (ret < 0) input_err(true, &ts->client->dev, - "%s: failed to set 16:9 mode\n", __func__); + "%s: failed to set 16:9 mode\n", + __func__); } } - return; } #if defined(CONFIG_TOUCHSCREEN_HEATMAP) || \ @@ -1336,6 +1403,72 @@ static bool read_heatmap_raw(struct v4l2_heatmap *v4l2) } #endif +#ifdef SEC_TS_SUPPORT_CUSTOMLIB +static void sec_ts_handle_lib_status_event(struct sec_ts_data *ts, + struct sec_ts_event_status *p_event_status) +{ + if ((p_event_status->stype == TYPE_STATUS_EVENT_CUSTOMLIB_INFO) && + (p_event_status->status_id == SEC_TS_EVENT_CUSTOMLIB_FORCE_KEY)) { + if (ts->power_status == SEC_TS_STATE_POWER_ON) { + if (p_event_status->status_data_1 & + SEC_TS_CUSTOMLIB_EVENT_PRESSURE_TOUCHED) { + ts->all_force_count++; + ts->scrub_id = + CUSTOMLIB_EVENT_TYPE_PRESSURE_TOUCHED; + } else { + if (ts->scrub_id == + CUSTOMLIB_EVENT_TYPE_AOD_HOMEKEY_PRESS) { + input_report_key(ts->input_dev, + KEY_HOMEPAGE, + 0); + ts->scrub_id = + CUSTOMLIB_EVENT_TYPE_AOD_HOMEKEY_RELEASE; + } else { + ts->scrub_id = + CUSTOMLIB_EVENT_TYPE_PRESSURE_RELEASED; + } + } + + input_report_key(ts->input_dev, + KEY_BLACK_UI_GESTURE, 1); + } else { + if (p_event_status->status_data_1 & + SEC_TS_CUSTOMLIB_EVENT_PRESSURE_RELEASED) { + input_report_key(ts->input_dev, + KEY_HOMEPAGE, 0); + input_report_key(ts->input_dev, + KEY_BLACK_UI_GESTURE, 1); + ts->scrub_id = + CUSTOMLIB_EVENT_TYPE_AOD_HOMEKEY_RLS_NO_HAPTIC; + input_sync(ts->input_dev); + haptic_homekey_release(); + } else { + input_report_key(ts->input_dev, + KEY_HOMEPAGE, 1); + input_sync(ts->input_dev); + ts->scrub_id = + CUSTOMLIB_EVENT_TYPE_AOD_HOMEKEY_PRESS; + haptic_homekey_press(); + ts->all_force_count++; + } + } + + ts->scrub_x = + ((p_event_status->status_data_4 >> 4) & 0xF) << 8 | + (p_event_status->status_data_3 & 0xFF); + ts->scrub_y = + ((p_event_status->status_data_4 >> 0) & 0xF) << 8 | + (p_event_status->status_data_2 & 0xFF); + + input_info(true, &ts->client->dev, "%s: PRESSURE[%d]\n", + __func__, ts->scrub_id); + + input_sync(ts->input_dev); + input_report_key(ts->input_dev, KEY_BLACK_UI_GESTURE, 0); + } +} +#endif + static void sec_ts_handle_coord_event(struct sec_ts_data *ts, struct sec_ts_event_coordinate *p_event_coord) { @@ -1533,6 +1666,66 @@ static void sec_ts_handle_coord_event(struct sec_ts_data *ts, __func__, t_id); } +#ifdef SEC_TS_SUPPORT_CUSTOMLIB +static void sec_ts_handle_gesture_event(struct sec_ts_data *ts, + struct sec_ts_gesture_status *p_gesture_status) +{ + if ((p_gesture_status->eid == 0x02) && + (p_gesture_status->stype == 0x00)) { + u8 customlib[3] = { 0 }; + + ret = sec_ts_read_from_customlib(ts, customlib, 3); + if (ret < 0) + input_err(true, &ts->client->dev, + "%s: fail to read custom library data\n", + __func__); + + input_info(true, &ts->client->dev, + "%s: Custom Library, %x, %x, %x\n", + __func__, customlib[0], customlib[1], customlib[2]); + + if (p_gesture_status->gesture_id == SEC_TS_GESTURE_CODE_SPAY || + p_gesture_status->gesture_id == + SEC_TS_GESTURE_CODE_DOUBLE_TAP) { + /* will be fixed to data structure */ + if (customlib[1] & SEC_TS_MODE_CUSTOMLIB_AOD) { + u8 data[5] = { 0x0A, 0x00, 0x00, 0x00, 0x00 }; + + ret = sec_ts_read_from_customlib(ts, data, 5); + if (ret < 0) + input_err(true, &ts->client->dev, + "%s: fail to read custom library data\n", + __func__); + + if (data[4] & SEC_TS_AOD_GESTURE_DOUBLETAB) + ts->scrub_id = + CUSTOMLIB_EVENT_TYPE_AOD_DOUBLETAB; + + ts->scrub_x = (data[1] & 0xFF) << 8 | + (data[0] & 0xFF); + ts->scrub_y = (data[3] & 0xFF) << 8 | + (data[2] & 0xFF); + input_info(true, &ts->client->dev, + "%s: aod: %d\n", + __func__, ts->scrub_id); + ts->all_aod_tap_count++; + } + if (customlib[1] & SEC_TS_MODE_CUSTOMLIB_SPAY) { + ts->scrub_id = CUSTOMLIB_EVENT_TYPE_SPAY; + input_info(true, &ts->client->dev, + "%s: SPAY: %d\n", + __func__, ts->scrub_id); + ts->all_spay_count++; + } + input_report_key(ts->input_dev, + KEY_BLACK_UI_GESTURE, 1); + input_sync(ts->input_dev); + input_report_key(ts->input_dev, + KEY_BLACK_UI_GESTURE, 0); + } + } +} +#endif #define MAX_EVENT_COUNT 32 static void sec_ts_read_event(struct sec_ts_data *ts) @@ -1553,36 +1746,49 @@ static void sec_ts_read_event(struct sec_ts_data *ts) pm_wakeup_event(&ts->client->dev, 3 * MSEC_PER_SEC); /* waiting for blsp block resuming, if not occurs error */ - ret = wait_for_completion_interruptible_timeout(&ts->resume_done, msecs_to_jiffies(3 * MSEC_PER_SEC)); + ret = wait_for_completion_interruptible_timeout( + &ts->resume_done, + msecs_to_jiffies(3 * MSEC_PER_SEC)); if (ret == 0) { - input_err(true, &ts->client->dev, "%s: LPM: pm resume is not handled\n", __func__); + input_err(true, &ts->client->dev, + "%s: LPM: pm resume is not handled\n", + __func__); return; } if (ret < 0) { - input_err(true, &ts->client->dev, "%s: LPM: -ERESTARTSYS if interrupted, %d\n", __func__, ret); + input_err(true, &ts->client->dev, + "%s: LPM: -ERESTARTSYS if interrupted, %d\n", + __func__, ret); return; } - input_info(true, &ts->client->dev, "%s: run LPM interrupt handler, %d\n", __func__, ret); + input_info(true, &ts->client->dev, + "%s: run LPM interrupt handler, %d\n", __func__, ret); /* run lpm interrupt handler */ } ret = t_id = event_id = curr_pos = remain_event_count = 0; /* repeat READ_ONE_EVENT until buffer is empty(No event) */ - ret = sec_ts_read(ts, SEC_TS_READ_ONE_EVENT, (u8 *)read_event_buff[0], SEC_TS_EVENT_BUFF_SIZE); + ret = sec_ts_read(ts, SEC_TS_READ_ONE_EVENT, + (u8 *)read_event_buff[0], SEC_TS_EVENT_BUFF_SIZE); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: read one event failed\n", __func__); + input_err(true, &ts->client->dev, + "%s: read one event failed\n", __func__); return; } if (ts->temp == 0x01) - input_info(true, &ts->client->dev, "ONE: %02X %02X %02X %02X %02X %02X %02X %02X\n", - read_event_buff[0][0], read_event_buff[0][1], read_event_buff[0][2], read_event_buff[0][3], - read_event_buff[0][4], read_event_buff[0][5], read_event_buff[0][6], read_event_buff[0][7]); + input_info(true, &ts->client->dev, + "ONE: %02X %02X %02X %02X %02X %02X %02X %02X\n", + read_event_buff[0][0], read_event_buff[0][1], + read_event_buff[0][2], read_event_buff[0][3], + read_event_buff[0][4], read_event_buff[0][5], + read_event_buff[0][6], read_event_buff[0][7]); if (read_event_buff[0][0] == 0) { - input_info(true, &ts->client->dev, "%s: event buffer is empty\n", __func__); + input_info(true, &ts->client->dev, + "%s: event buffer is empty\n", __func__); return; } @@ -1595,37 +1801,48 @@ static void sec_ts_read_event(struct sec_ts_data *ts) "%s: event buffer overflow %d\n", __func__, left_event_count); - /* write clear event stack command when read_event_count > MAX_EVENT_COUNT */ + /* write clear event stack command + * when read_event_count > MAX_EVENT_COUNT + **/ ret = sec_ts_write(ts, SEC_TS_CMD_CLEAR_EVENT_STACK, NULL, 0); if (ret < 0) - input_err(true, &ts->client->dev, "%s: write clear event failed\n", __func__); + input_err(true, &ts->client->dev, + "%s: write clear event failed\n", __func__); return; } if (left_event_count > 0) { - ret = sec_ts_read(ts, SEC_TS_READ_ALL_EVENT, (u8 *)read_event_buff[1], - sizeof(u8) * (SEC_TS_EVENT_BUFF_SIZE) * (left_event_count)); + ret = sec_ts_read(ts, SEC_TS_READ_ALL_EVENT, + (u8 *)read_event_buff[1], + sizeof(u8) * (SEC_TS_EVENT_BUFF_SIZE) * + (left_event_count)); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: read one event failed\n", __func__); + input_err(true, &ts->client->dev, + "%s: read one event failed\n", __func__); return; } } do { s16 max_force_p = 0; + event_buff = read_event_buff[curr_pos]; event_id = event_buff[0] & 0x3; if (ts->temp == 0x01) - input_info(true, &ts->client->dev, "ALL: %02X %02X %02X %02X %02X %02X %02X %02X\n", - event_buff[0], event_buff[1], event_buff[2], event_buff[3], - event_buff[4], event_buff[5], event_buff[6], event_buff[7]); + input_info(true, &ts->client->dev, + "ALL: %02X %02X %02X %02X %02X %02X %02X %02X\n", + event_buff[0], event_buff[1], event_buff[2], + event_buff[3], event_buff[4], event_buff[5], + event_buff[6], event_buff[7]); switch (event_id) { case SEC_TS_STATUS_EVENT: - p_event_status = (struct sec_ts_event_status *)event_buff; + p_event_status = + (struct sec_ts_event_status *)event_buff; - /* tchsta == 0 && ttype == 0 && eid == 0 : buffer empty */ + /* tchsta == 0 && ttype == 0 && eid == 0 : buffer empty + **/ if (p_event_status->stype > 0) { /* Demote 'vendor' messages */ if (p_event_status->stype == @@ -1723,23 +1940,33 @@ static void sec_ts_read_event(struct sec_ts_data *ts) /* event queue full-> all finger release */ if ((p_event_status->stype == TYPE_STATUS_EVENT_ERR) && - (p_event_status->status_id == SEC_TS_ERR_EVENT_QUEUE_FULL)) { - input_err(true, &ts->client->dev, "%s: IC Event Queue is full\n", __func__); + (p_event_status->status_id == + SEC_TS_ERR_EVENT_QUEUE_FULL)) { + input_err(true, &ts->client->dev, + "%s: IC Event Queue is full\n", + __func__); sec_ts_unlocked_release_all_finger(ts); } - if ((p_event_status->stype == TYPE_STATUS_EVENT_ERR) && - (p_event_status->status_id == SEC_TS_ERR_EVENT_ESD)) { - input_err(true, &ts->client->dev, "%s: ESD detected. run reset\n", __func__); + if ((p_event_status->stype == + TYPE_STATUS_EVENT_ERR) && + (p_event_status->status_id == + SEC_TS_ERR_EVENT_ESD)) { + input_err(true, &ts->client->dev, + "%s: ESD detected. run reset\n", + __func__); #ifdef USE_RESET_DURING_POWER_ON schedule_work(&ts->reset_work.work); #endif } - if ((p_event_status->stype == TYPE_STATUS_EVENT_INFO) && - (p_event_status->status_id == SEC_TS_ACK_WET_MODE)) { + if ((p_event_status->stype == + TYPE_STATUS_EVENT_INFO) && + (p_event_status->status_id == + SEC_TS_ACK_WET_MODE)) { ts->wet_mode = p_event_status->status_data_1; - input_info(true, &ts->client->dev, "%s: water wet mode %d\n", + input_info(true, &ts->client->dev, + "%s: water wet mode %d\n", __func__, ts->wet_mode); if (ts->wet_mode) ts->wet_count++; @@ -1747,48 +1974,7 @@ static void sec_ts_read_event(struct sec_ts_data *ts) } #ifdef SEC_TS_SUPPORT_CUSTOMLIB - if ((p_event_status->stype == TYPE_STATUS_EVENT_CUSTOMLIB_INFO) && - (p_event_status->status_id == SEC_TS_EVENT_CUSTOMLIB_FORCE_KEY)) { - if (ts->power_status == SEC_TS_STATE_POWER_ON) { - if (p_event_status->status_data_1 & SEC_TS_CUSTOMLIB_EVENT_PRESSURE_TOUCHED) { - ts->all_force_count++; - ts->scrub_id = CUSTOMLIB_EVENT_TYPE_PRESSURE_TOUCHED; - } else { - if (ts->scrub_id == CUSTOMLIB_EVENT_TYPE_AOD_HOMEKEY_PRESS) { - input_report_key(ts->input_dev, KEY_HOMEPAGE, 0); - ts->scrub_id = CUSTOMLIB_EVENT_TYPE_AOD_HOMEKEY_RELEASE; - } else { - ts->scrub_id = CUSTOMLIB_EVENT_TYPE_PRESSURE_RELEASED; - } - } - - input_report_key(ts->input_dev, KEY_BLACK_UI_GESTURE, 1); - } else { - if (p_event_status->status_data_1 & SEC_TS_CUSTOMLIB_EVENT_PRESSURE_RELEASED) { - input_report_key(ts->input_dev, KEY_HOMEPAGE, 0); - input_report_key(ts->input_dev, KEY_BLACK_UI_GESTURE, 1); - ts->scrub_id = CUSTOMLIB_EVENT_TYPE_AOD_HOMEKEY_RELEASE_NO_HAPTIC; - input_sync(ts->input_dev); - - haptic_homekey_release(); - } else { - input_report_key(ts->input_dev, KEY_HOMEPAGE, 1); - input_sync(ts->input_dev); - - ts->scrub_id = CUSTOMLIB_EVENT_TYPE_AOD_HOMEKEY_PRESS; - haptic_homekey_press(); - ts->all_force_count++; - } - } - - ts->scrub_x = ((p_event_status->status_data_4 >> 4) & 0xF) << 8 | (p_event_status->status_data_3 & 0xFF); - ts->scrub_y = ((p_event_status->status_data_4 >> 0) & 0xF) << 8 | (p_event_status->status_data_2 & 0xFF); - - input_info(true, &ts->client->dev, "%s: PRESSURE[%d]\n", __func__, ts->scrub_id); - - input_sync(ts->input_dev); - input_report_key(ts->input_dev, KEY_BLACK_UI_GESTURE, 0); - } + sec_ts_handle_lib_status_event(ts, p_event_status); #endif break; @@ -1800,79 +1986,53 @@ static void sec_ts_read_event(struct sec_ts_data *ts) case SEC_TS_GESTURE_EVENT: - p_gesture_status = (struct sec_ts_gesture_status *)event_buff; + p_gesture_status = + (struct sec_ts_gesture_status *)event_buff; #ifdef SEC_TS_SUPPORT_CUSTOMLIB - if ((p_gesture_status->eid == 0x02) && (p_gesture_status->stype == 0x00)) { - u8 customlib[3] = { 0 }; - - ret = sec_ts_read_from_customlib(ts, customlib, 3); - if (ret < 0) - input_err(true, &ts->client->dev, "%s: fail to read custom library data\n", __func__); - - input_info(true, &ts->client->dev, "%s: Custom Library, %x, %x, %x\n", - __func__, customlib[0], customlib[1], customlib[2]); - - if (p_gesture_status->gesture_id == SEC_TS_GESTURE_CODE_SPAY || - p_gesture_status->gesture_id == SEC_TS_GESTURE_CODE_DOUBLE_TAP) { - /* will be fixed to data structure */ - if (customlib[1] & SEC_TS_MODE_CUSTOMLIB_AOD) { - u8 data[5] = { 0x0A, 0x00, 0x00, 0x00, 0x00 }; - - ret = sec_ts_read_from_customlib(ts, data, 5); - if (ret < 0) - input_err(true, &ts->client->dev, "%s: fail to read custom library data\n", __func__); - - if (data[4] & SEC_TS_AOD_GESTURE_DOUBLETAB) - ts->scrub_id = CUSTOMLIB_EVENT_TYPE_AOD_DOUBLETAB; - - ts->scrub_x = (data[1] & 0xFF) << 8 | (data[0] & 0xFF); - ts->scrub_y = (data[3] & 0xFF) << 8 | (data[2] & 0xFF); - input_info(true, &ts->client->dev, "%s: aod: %d\n", - __func__, ts->scrub_id); - ts->all_aod_tap_count++; - } - if (customlib[1] & SEC_TS_MODE_CUSTOMLIB_SPAY) { - ts->scrub_id = CUSTOMLIB_EVENT_TYPE_SPAY; - input_info(true, &ts->client->dev, "%s: SPAY: %d\n", - __func__, ts->scrub_id); - ts->all_spay_count++; - } - input_report_key(ts->input_dev, KEY_BLACK_UI_GESTURE, 1); - input_sync(ts->input_dev); - input_report_key(ts->input_dev, KEY_BLACK_UI_GESTURE, 0); - } - } - break; + sec_ts_handle_gesture_event(ts, p_gesture_status); #endif + break; + default: - input_err(true, &ts->client->dev, "%s: unknown event %x %x %x %x %x %x\n", __func__, - event_buff[0], event_buff[1], event_buff[2], - event_buff[3], event_buff[4], event_buff[5]); + input_err(true, &ts->client->dev, + "%s: unknown event %x %x %x %x %x %x\n", + __func__, + event_buff[0], event_buff[1], event_buff[2], + event_buff[3], event_buff[4], event_buff[5]); break; } if (t_id < MAX_SUPPORT_TOUCH_COUNT + MAX_SUPPORT_HOVER_COUNT) { - if (ts->coord[t_id].action == SEC_TS_COORDINATE_ACTION_PRESS) { + if (ts->coord[t_id].action == + SEC_TS_COORDINATE_ACTION_PRESS) { input_dbg(false, &ts->client->dev, "%s[P] tID:%d x:%d y:%d z:%d major:%d minor:%d tc:%d type:%X\n", ts->dex_name, - t_id, ts->coord[t_id].x, ts->coord[t_id].y, ts->coord[t_id].z, - ts->coord[t_id].major, ts->coord[t_id].minor, ts->touch_count, + t_id, ts->coord[t_id].x, + ts->coord[t_id].y, ts->coord[t_id].z, + ts->coord[t_id].major, + ts->coord[t_id].minor, + ts->touch_count, ts->coord[t_id].ttype); - } else if (ts->coord[t_id].action == SEC_TS_COORDINATE_ACTION_RELEASE) { + } else if (ts->coord[t_id].action == + SEC_TS_COORDINATE_ACTION_RELEASE) { input_dbg(false, &ts->client->dev, "%s[R] tID:%d mc:%d tc:%d lx:%d ly:%d f:%d v:%02X%02X cal:%02X(%02X) id(%d,%d) p:%d P%02XT%04X\n", ts->dex_name, - t_id, ts->coord[t_id].mcount, ts->touch_count, - ts->coord[t_id].x, ts->coord[t_id].y, max_force_p, + t_id, ts->coord[t_id].mcount, + ts->touch_count, + ts->coord[t_id].x, ts->coord[t_id].y, + max_force_p, ts->plat_data->img_version_of_ic[2], ts->plat_data->img_version_of_ic[3], ts->cal_status, ts->nv, ts->tspid_val, - ts->tspicid_val, ts->coord[t_id].palm_count, - ts->cal_count, ts->tune_fix_ver ); + ts->tspicid_val, + ts->coord[t_id].palm_count, + ts->cal_count, ts->tune_fix_ver); - ts->coord[t_id].action = SEC_TS_COORDINATE_ACTION_NONE; + ts->coord[t_id].action = + SEC_TS_COORDINATE_ACTION_NONE; ts->coord[t_id].mcount = 0; ts->coord[t_id].palm_count = 0; max_force_p = 0; @@ -1908,8 +2068,8 @@ static irqreturn_t sec_ts_irq_thread(int irq, void *ptr) if (sec_ts_set_bus_ref(ts, SEC_TS_BUS_REF_IRQ, true) < 0) { /* Interrupt during bus suspend */ input_info(true, &ts->client->dev, - "%s: Skipping stray interrupt since bus is suspended(power_status: %d)\n", - __func__, ts->power_status); + "%s: Skipping stray interrupt since bus is suspended(power_status: %d)\n", + __func__, ts->power_status); return IRQ_HANDLED; } @@ -1940,22 +2100,28 @@ void sec_ts_set_charger(bool enable) { return; /* - int ret; - u8 noise_mode_on[] = {0x01}; - u8 noise_mode_off[] = {0x00}; - - if (enable) { - input_info(true, &ts->client->dev, "sec_ts_set_charger : charger CONNECTED!!\n"); - ret = sec_ts_write(ts, SEC_TS_CMD_NOISE_MODE, noise_mode_on, sizeof(noise_mode_on)); - if (ret < 0) - input_err(true, &ts->client->dev, "sec_ts_set_charger: fail to write NOISE_ON\n"); - } else { - input_info(true, &ts->client->dev, "sec_ts_set_charger : charger DISCONNECTED!!\n"); - ret = sec_ts_write(ts, SEC_TS_CMD_NOISE_MODE, noise_mode_off, sizeof(noise_mode_off)); - if (ret < 0) - input_err(true, &ts->client->dev, "sec_ts_set_charger: fail to write NOISE_OFF\n"); - } - */ + * int ret; + * u8 noise_mode_on[] = {0x01}; + * u8 noise_mode_off[] = {0x00}; + * + * if (enable) { + * input_info(true, &ts->client->dev, + * "sec_ts_set_charger : charger CONNECTED!!\n"); + * ret = sec_ts_write(ts, SEC_TS_CMD_NOISE_MODE, noise_mode_on, + * sizeof(noise_mode_on)); + * if (ret < 0) + * input_err(true, &ts->client->dev, + * "sec_ts_set_charger: fail to write NOISE_ON\n"); + * } else { + * input_info(true, &ts->client->dev, + * "sec_ts_set_charger : charger DISCONNECTED!!\n"); + * ret = sec_ts_write(ts, SEC_TS_CMD_NOISE_MODE, noise_mode_off, + * sizeof(noise_mode_off)); + * if (ret < 0) + * input_err(true, &ts->client->dev, + * "%s: fail to write NOISE_OFF\n", __func__); + * } + **/ } EXPORT_SYMBOL(sec_ts_set_charger); @@ -1964,23 +2130,31 @@ int sec_ts_glove_mode_enables(struct sec_ts_data *ts, int mode) int ret; if (mode) - ts->touch_functions = (ts->touch_functions | SEC_TS_BIT_SETFUNC_GLOVE | SEC_TS_DEFAULT_ENABLE_BIT_SETFUNC); + ts->touch_functions = (ts->touch_functions | + SEC_TS_BIT_SETFUNC_GLOVE | + SEC_TS_DEFAULT_ENABLE_BIT_SETFUNC); else - ts->touch_functions = ((ts->touch_functions & (~SEC_TS_BIT_SETFUNC_GLOVE)) | SEC_TS_DEFAULT_ENABLE_BIT_SETFUNC); + ts->touch_functions = ((ts->touch_functions & + (~SEC_TS_BIT_SETFUNC_GLOVE)) | + SEC_TS_DEFAULT_ENABLE_BIT_SETFUNC); if (ts->power_status == SEC_TS_STATE_POWER_OFF) { - input_err(true, &ts->client->dev, "%s: pwr off, glove:%d, status:%x\n", __func__, - mode, ts->touch_functions); + input_err(true, &ts->client->dev, + "%s: pwr off, glove:%d, status:%x\n", __func__, + mode, ts->touch_functions); goto glove_enable_err; } - ret = sec_ts_write(ts, SEC_TS_CMD_SET_TOUCHFUNCTION, (u8 *)&ts->touch_functions, 2); + ret = sec_ts_write(ts, SEC_TS_CMD_SET_TOUCHFUNCTION, + (u8 *)&ts->touch_functions, 2); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: Failed to send command", __func__); + input_err(true, &ts->client->dev, + "%s: Failed to send command", __func__); goto glove_enable_err; } - input_info(true, &ts->client->dev, "%s: glove:%d, status:%x\n", __func__, + input_info(true, &ts->client->dev, + "%s: glove:%d, status:%x\n", __func__, mode, ts->touch_functions); return 0; @@ -1994,7 +2168,8 @@ int sec_ts_set_cover_type(struct sec_ts_data *ts, bool enable) { int ret; - input_info(true, &ts->client->dev, "%s: %d\n", __func__, ts->cover_type); + input_info(true, &ts->client->dev, "%s: %d\n", + __func__, ts->cover_type); switch (ts->cover_type) { @@ -2014,37 +2189,49 @@ int sec_ts_set_cover_type(struct sec_ts_data *ts, bool enable) case SEC_TS_COVER_NOTHING2: default: ts->cover_cmd = 0; - input_err(true, &ts->client->dev, "%s: not chage touch state, %d\n", - __func__, ts->cover_type); + input_err(true, &ts->client->dev, + "%s: not chage touch state, %d\n", + __func__, ts->cover_type); break; } if (enable) - ts->touch_functions = (ts->touch_functions | SEC_TS_BIT_SETFUNC_COVER | SEC_TS_DEFAULT_ENABLE_BIT_SETFUNC); + ts->touch_functions = (ts->touch_functions | + SEC_TS_BIT_SETFUNC_COVER | + SEC_TS_DEFAULT_ENABLE_BIT_SETFUNC); else - ts->touch_functions = ((ts->touch_functions & (~SEC_TS_BIT_SETFUNC_COVER)) | SEC_TS_DEFAULT_ENABLE_BIT_SETFUNC); + ts->touch_functions = ((ts->touch_functions & + (~SEC_TS_BIT_SETFUNC_COVER)) | + SEC_TS_DEFAULT_ENABLE_BIT_SETFUNC); if (ts->power_status == SEC_TS_STATE_POWER_OFF) { - input_err(true, &ts->client->dev, "%s: pwr off, close:%d, status:%x\n", __func__, - enable, ts->touch_functions); + input_err(true, &ts->client->dev, + "%s: pwr off, close:%d, status:%x\n", __func__, + enable, ts->touch_functions); goto cover_enable_err; } if (enable) { - ret = sec_ts_write(ts, SEC_TS_CMD_SET_COVERTYPE, &ts->cover_cmd, 1); + ret = sec_ts_write(ts, SEC_TS_CMD_SET_COVERTYPE, + &ts->cover_cmd, 1); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: Failed to send covertype command: %d", __func__, ts->cover_cmd); + input_err(true, &ts->client->dev, + "%s: Failed to send covertype command: %d", + __func__, ts->cover_cmd); goto cover_enable_err; } } - ret = sec_ts_write(ts, SEC_TS_CMD_SET_TOUCHFUNCTION, (u8 *)&(ts->touch_functions), 2); + ret = sec_ts_write(ts, SEC_TS_CMD_SET_TOUCHFUNCTION, + (u8 *)&(ts->touch_functions), 2); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: Failed to send command", __func__); + input_err(true, &ts->client->dev, + "%s: Failed to send command", __func__); goto cover_enable_err; } - input_info(true, &ts->client->dev, "%s: close:%d, status:%x\n", __func__, + input_info(true, &ts->client->dev, + "%s: close:%d, status:%x\n", __func__, enable, ts->touch_functions); return 0; @@ -2060,8 +2247,10 @@ void sec_ts_set_grip_type(struct sec_ts_data *ts, u8 set_type) { u8 mode = G_NONE; - input_info(true, &ts->client->dev, "%s: re-init grip(%d), edh:%d, edg:%d, lan:%d\n", __func__, - set_type, ts->grip_edgehandler_direction, ts->grip_edge_range, ts->grip_landscape_mode); + input_info(true, &ts->client->dev, + "%s: re-init grip(%d), edh:%d, edg:%d, lan:%d\n", __func__, + set_type, ts->grip_edgehandler_direction, ts->grip_edge_range, + ts->grip_landscape_mode); /* edge handler */ if (ts->grip_edgehandler_direction != 0) @@ -2084,22 +2273,29 @@ void sec_ts_set_grip_type(struct sec_ts_data *ts, u8 set_type) } -/* for debugging--------------------------------------------------------------------------------------*/ +/* for debugging--------------------------------------------------------------*/ static int sec_ts_pinctrl_configure(struct sec_ts_data *ts, bool enable) { struct pinctrl_state *state; - input_info(true, &ts->client->dev, "%s: %s\n", __func__, enable ? "ACTIVE" : "SUSPEND"); + input_info(true, &ts->client->dev, "%s: %s\n", + __func__, enable ? "ACTIVE" : "SUSPEND"); if (enable) { - state = pinctrl_lookup_state(ts->plat_data->pinctrl, "on_state"); + state = pinctrl_lookup_state(ts->plat_data->pinctrl, + "on_state"); if (IS_ERR(ts->plat_data->pinctrl)) - input_err(true, &ts->client->dev, "%s: could not get active pinstate\n", __func__); + input_err(true, &ts->client->dev, + "%s: could not get active pinstate\n", + __func__); } else { - state = pinctrl_lookup_state(ts->plat_data->pinctrl, "off_state"); + state = pinctrl_lookup_state(ts->plat_data->pinctrl, + "off_state"); if (IS_ERR(ts->plat_data->pinctrl)) - input_err(true, &ts->client->dev, "%s: could not get suspend pinstate\n", __func__); + input_err(true, &ts->client->dev, + "%s: could not get suspend pinstate\n", + __func__); } if (!IS_ERR_OR_NULL(state)) @@ -2219,46 +2415,59 @@ static int sec_ts_parse_dt(struct spi_device *client) pdata->tsp_icid = of_get_named_gpio(np, "sec,tsp-icid_gpio", 0); if (gpio_is_valid(pdata->tsp_icid)) { - input_info(true, dev, "%s: TSP_ICID : %d\n", __func__, gpio_get_value(pdata->tsp_icid)); - if (of_property_read_u32(np, "sec,icid_match_value", &ic_match_value)) { - input_err(true, dev, "%s: Failed to get icid match value\n", __func__); + input_info(true, dev, "%s: TSP_ICID : %d\n", + __func__, gpio_get_value(pdata->tsp_icid)); + if (of_property_read_u32(np, "sec,icid_match_value", + &ic_match_value)) { + input_err(true, dev, + "%s: Failed to get icid match value\n", + __func__); return -EINVAL; } if (gpio_get_value(pdata->tsp_icid) != ic_match_value) { - input_err(true, dev, "%s: Do not match TSP_ICID\n", __func__); + input_err(true, dev, + "%s: Do not match TSP_ICID\n", __func__); return -EINVAL; } } else { - input_err(true, dev, "%s: Failed to get tsp-icid gpio\n", __func__); + input_err(true, dev, + "%s: Failed to get tsp-icid gpio\n", __func__); } pdata->tsp_vsync = of_get_named_gpio(np, "sec,tsp_vsync_gpio", 0); if (gpio_is_valid(pdata->tsp_vsync)) input_info(true, &client->dev, "%s: vsync %s\n", __func__, - gpio_get_value(pdata->tsp_vsync) ? "disable" : "enable"); + gpio_get_value(pdata->tsp_vsync) ? + "disable" : "enable"); pdata->irq_gpio = of_get_named_gpio(np, "sec,irq_gpio", 0); if (gpio_is_valid(pdata->irq_gpio)) { - ret = gpio_request_one(pdata->irq_gpio, GPIOF_DIR_IN, "sec,tsp_int"); + ret = gpio_request_one(pdata->irq_gpio, GPIOF_DIR_IN, + "sec,tsp_int"); if (ret) { - input_err(true, &client->dev, "%s: Unable to request tsp_int [%d]\n", __func__, pdata->irq_gpio); + input_err(true, &client->dev, + "%s: Unable to request tsp_int [%d]\n", + __func__, pdata->irq_gpio); return -EINVAL; } } else { - input_err(true, &client->dev, "%s: Failed to get irq gpio\n", __func__); + input_err(true, &client->dev, + "%s: Failed to get irq gpio\n", __func__); return -EINVAL; } client->irq = gpio_to_irq(pdata->irq_gpio); if (of_property_read_u32(np, "sec,irq_type", &pdata->irq_type)) { - input_err(true, dev, "%s: Failed to get irq_type property\n", __func__); + input_err(true, dev, + "%s: Failed to get irq_type property\n", __func__); pdata->irq_type = IRQF_TRIGGER_LOW | IRQF_ONESHOT; } if (of_property_read_u32(np, "sec,i2c-burstmax", &pdata->io_burstmax)) { - input_dbg(false, &client->dev, "%s: Failed to get io_burstmax property\n", __func__); + input_dbg(false, &client->dev, + "%s: Failed to get io_burstmax property\n", __func__); pdata->io_burstmax = 1024; //TODO: check this } if (pdata->io_burstmax > IO_PREALLOC_READ_BUF_SZ || @@ -2271,29 +2480,35 @@ static int sec_ts_parse_dt(struct spi_device *client) } if (of_property_read_u32_array(np, "sec,max_coords", coords, 2)) { - input_err(true, &client->dev, "%s: Failed to get max_coords property\n", __func__); + input_err(true, &client->dev, + "%s: Failed to get max_coords property\n", __func__); return -EINVAL; } pdata->max_x = coords[0] - 1; pdata->max_y = coords[1] - 1; #ifdef PAT_CONTROL - if (of_property_read_u32(np, "sec,pat_function", &pdata->pat_function) < 0) { + if (of_property_read_u32(np, "sec,pat_function", + &pdata->pat_function) < 0) { pdata->pat_function = 0; - input_err(true, dev, "%s: Failed to get pat_function property\n", __func__); + input_err(true, dev, + "%s: Failed to get pat_function property\n", __func__); } if (of_property_read_u32(np, "sec,afe_base", &pdata->afe_base) < 0) { pdata->afe_base = 0; - input_err(true, dev, "%s: Failed to get afe_base property\n", __func__); + input_err(true, dev, + "%s: Failed to get afe_base property\n", __func__); } #endif pdata->tsp_id = of_get_named_gpio(np, "sec,tsp-id_gpio", 0); if (gpio_is_valid(pdata->tsp_id)) - input_info(true, dev, "%s: TSP_ID : %d\n", __func__, gpio_get_value(pdata->tsp_id)); + input_info(true, dev, "%s: TSP_ID : %d\n", __func__, + gpio_get_value(pdata->tsp_id)); else - input_err(true, dev, "%s: Failed to get tsp-id gpio\n", __func__); + input_err(true, dev, + "%s: Failed to get tsp-id gpio\n", __func__); pdata->switch_gpio = of_get_named_gpio(np, "sec,switch_gpio", 0); @@ -2308,7 +2523,8 @@ static int sec_ts_parse_dt(struct spi_device *client) return -EINVAL; } - ret = gpio_direction_output(pdata->switch_gpio, SEC_SWITCH_GPIO_VALUE_AP_MASTER); + ret = gpio_direction_output(pdata->switch_gpio, + SEC_SWITCH_GPIO_VALUE_AP_MASTER); if (ret) { input_err(true, dev, "%s: Failed to set gpio %d direction\n", @@ -2331,11 +2547,11 @@ static int sec_ts_parse_dt(struct spi_device *client) __func__, pdata->reset_gpio, ret); pdata->reset_gpio = -1; } - //TODO: check this + //TODO: check this ret = gpio_direction_output(pdata->reset_gpio, 1); - mdelay(10); + mdelay(10); ret = gpio_direction_output(pdata->reset_gpio, 0); - mdelay(10); + mdelay(10); ret = gpio_direction_output(pdata->reset_gpio, 1); } else @@ -2347,20 +2563,28 @@ static int sec_ts_parse_dt(struct spi_device *client) pdata->firmware_name = NULL; } else { if (gpio_is_valid(pdata->tsp_id)) - of_property_read_string_index(np, "sec,firmware_name", gpio_get_value(pdata->tsp_id), &pdata->firmware_name); + of_property_read_string_index(np, "sec,firmware_name", + gpio_get_value(pdata->tsp_id), + &pdata->firmware_name); else - of_property_read_string_index(np, "sec,firmware_name", 0, &pdata->firmware_name); + of_property_read_string_index(np, "sec,firmware_name", + 0, &pdata->firmware_name); } - if (of_property_read_string_index(np, "sec,project_name", 0, &pdata->project_name)) - input_err(true, &client->dev, "%s: skipped to get project_name property\n", __func__); - if (of_property_read_string_index(np, "sec,project_name", 1, &pdata->model_name)) - input_err(true, &client->dev, "%s: skipped to get model_name property\n", __func__); + if (of_property_read_string_index(np, "sec,project_name", 0, + &pdata->project_name)) + input_err(true, &client->dev, + "%s: skipped to get project_name property\n", __func__); + if (of_property_read_string_index(np, "sec,project_name", + 1, &pdata->model_name)) + input_err(true, &client->dev, + "%s: skipped to get model_name property\n", __func__); #if defined(CONFIG_FB_MSM_MDSS_SAMSUNG) lcdtype = get_lcd_attached("GET"); if (lcdtype < 0) { - input_err(true, &client->dev, "%s: lcd is not attached\n", __func__); + input_err(true, &client->dev, + "%s: lcd is not attached\n", __func__); return -ENODEV; } #endif @@ -2373,7 +2597,8 @@ static int sec_ts_parse_dt(struct spi_device *client) } if (!connected) { - input_err(true, &client->dev, "%s: lcd is disconnected\n", __func__); + input_err(true, &client->dev, + "%s: lcd is disconnected\n", __func__); return -ENODEV; } @@ -2386,7 +2611,8 @@ static int sec_ts_parse_dt(struct spi_device *client) } #endif - input_info(true, &client->dev, "%s: lcdtype 0x%08X\n", __func__, lcdtype); + input_info(true, &client->dev, + "%s: lcdtype 0x%08X\n", __func__, lcdtype); if (pdata->model_name && strncmp(pdata->model_name, "G950", 4) == 0) pdata->panel_revision = 0; @@ -2407,34 +2633,42 @@ static int sec_ts_parse_dt(struct spi_device *client) pdata->power = sec_ts_power; - if (of_property_read_u32(np, "sec,always_lpmode", &pdata->always_lpmode) < 0) + if (of_property_read_u32(np, "sec,always_lpmode", + &pdata->always_lpmode) < 0) pdata->always_lpmode = 0; if (of_property_read_u32(np, "sec,bringup", &pdata->bringup) < 0) pdata->bringup = 0; - if (of_property_read_u32(np, "sec,mis_cal_check", &pdata->mis_cal_check) < 0) + if (of_property_read_u32(np, "sec,mis_cal_check", + &pdata->mis_cal_check) < 0) pdata->mis_cal_check = 0; if (of_property_read_u32(np, "sec,heatmap_mode", &pdata->heatmap_mode) < 0) pdata->heatmap_mode = 0; - pdata->regulator_boot_on = of_property_read_bool(np, "sec,regulator_boot_on"); - pdata->support_sidegesture = of_property_read_bool(np, "sec,support_sidegesture"); + pdata->regulator_boot_on = of_property_read_bool(np, + "sec,regulator_boot_on"); + pdata->support_sidegesture = of_property_read_bool(np, + "sec,support_sidegesture"); pdata->support_dex = of_property_read_bool(np, "support_dex_mode"); pdata->support_mt_pressure = true; #ifdef PAT_CONTROL - input_err(true, &client->dev, "%s: buffer limit: %d, lcd_id:%06X, bringup:%d, FW:%s(%d), id:%d,%d, pat_function:%d mis_cal:%d dex:%d, gesture:%d\n", - __func__, pdata->io_burstmax, lcdtype, pdata->bringup, pdata->firmware_name, - count, pdata->tsp_id, pdata->tsp_icid, pdata->pat_function, - pdata->mis_cal_check, pdata->support_dex, pdata->support_sidegesture); + input_err(true, &client->dev, + "%s: buffer limit: %d, lcd_id:%06X, bringup:%d, FW:%s(%d), id:%d,%d, pat_function:%d mis_cal:%d dex:%d, gesture:%d\n", + __func__, pdata->io_burstmax, lcdtype, pdata->bringup, + pdata->firmware_name, count, pdata->tsp_id, pdata->tsp_icid, + pdata->pat_function, pdata->mis_cal_check, pdata->support_dex, + pdata->support_sidegesture); #else - input_err(true, &client->dev, "%s: buffer limit: %d, lcd_id:%06X, bringup:%d, FW:%s(%d), id:%d,%d, dex:%d, gesture:%d\n", - __func__, pdata->io_burstmax, lcdtype, pdata->bringup, pdata->firmware_name, - count, pdata->tsp_id, pdata->tsp_icid, pdata->support_dex, pdata->support_sidegesture); + input_err(true, &client->dev, + "%s: buffer limit: %d, lcd_id:%06X, bringup:%d, FW:%s(%d), id:%d,%d, dex:%d, gesture:%d\n", + __func__, pdata->io_burstmax, lcdtype, pdata->bringup, + pdata->firmware_name, count, pdata->tsp_id, pdata->tsp_icid, + pdata->support_dex, pdata->support_sidegesture); #endif return ret; } @@ -2468,9 +2702,9 @@ int sec_ts_read_information(struct sec_ts_data *ts) } input_info(true, &ts->client->dev, - "%s: nTX:%X, nRX:%X, rY:%d, rX:%d\n", - __func__, data[8], data[9], - (data[2] << 8) | data[3], (data[0] << 8) | data[1]); + "%s: nTX:%X, nRX:%X, rY:%d, rX:%d\n", + __func__, data[8], data[9], + (data[2] << 8) | data[3], (data[0] << 8) | data[1]); /* Set X,Y Resolution from IC information. */ if (((data[0] << 8) | data[1]) > 0) @@ -2505,13 +2739,14 @@ int sec_ts_read_information(struct sec_ts_data *ts) } input_info(true, &ts->client->dev, - "%s: TOUCH STATUS : %02X, %02X, %02X, %02X\n", - __func__, data[0], data[1], data[2], data[3]); - ret = sec_ts_read(ts, SEC_TS_CMD_SET_TOUCHFUNCTION, (u8 *)&(ts->touch_functions), 2); + "%s: TOUCH STATUS : %02X, %02X, %02X, %02X\n", + __func__, data[0], data[1], data[2], data[3]); + ret = sec_ts_read(ts, SEC_TS_CMD_SET_TOUCHFUNCTION, + (u8 *)&(ts->touch_functions), 2); if (ret < 0) { input_err(true, &ts->client->dev, - "%s: failed to read touch functions(%d)\n", - __func__, ret); + "%s: failed to read touch functions(%d)\n", + __func__, ret); goto out; } @@ -2537,11 +2772,13 @@ int sec_ts_set_custom_library(struct sec_ts_data *ts) ret = sec_ts_write(ts, SEC_TS_CMD_CUSTOMLIB_WRITE_PARAM, &data[0], 3); if (ret < 0) - input_err(true, &ts->client->dev, "%s: Failed to Custom Library\n", __func__); + input_err(true, &ts->client->dev, + "%s: Failed to Custom Library\n", __func__); ret = sec_ts_write(ts, SEC_TS_CMD_CUSTOMLIB_NOTIFY_PACKET, NULL, 0); if (ret < 0) - input_err(true, &ts->client->dev, "%s: Failed to send NOTIFY Custom Library\n", __func__); + input_err(true, &ts->client->dev, + "%s: Failed to send NOTIFY Custom Library\n", __func__); return ret; } @@ -2554,27 +2791,28 @@ int sec_ts_check_custom_library(struct sec_ts_data *ts) ret = ts->sec_ts_read(ts, SEC_TS_CMD_CUSTOMLIB_GET_INFO, &data[0], 10); input_info(true, &ts->client->dev, - "%s: (%d) %c%c%c%c, || %02X, %02X, %02X, %02X, || %02X, %02X\n", - __func__, ret, data[0], data[1], data[2], data[3], data[4], - data[5], data[6], data[7], data[8], data[9]); + "%s: (%d) %c%c%c%c, || %02X, %02X, %02X, %02X, || %02X, %02X\n", + __func__, ret, data[0], data[1], data[2], data[3], data[4], + data[5], data[6], data[7], data[8], data[9]); /* compare model name with device tree */ if (ts->plat_data->model_name) ret = strncmp(data, ts->plat_data->model_name, 4); if (ret == 0) - ts->use_customlib= true; + ts->use_customlib = true; else - ts->use_customlib= false; + ts->use_customlib = false; input_err(true, &ts->client->dev, "%s: use %s\n", - __func__, ts->use_customlib? "CUSTOMLIB" : "VENDOR"); + __func__, ts->use_customlib ? "CUSTOMLIB" : "VENDOR"); return ret; } #endif -static void sec_ts_set_input_prop(struct sec_ts_data *ts, struct input_dev *dev, u8 propbit) +static void sec_ts_set_input_prop(struct sec_ts_data *ts, + struct input_dev *dev, u8 propbit) { static char sec_ts_phys[64] = { 0 }; @@ -2602,7 +2840,8 @@ static void sec_ts_set_input_prop(struct sec_ts_data *ts, struct input_dev *dev, int i; for (i = 0 ; i < ts->plat_data->num_touchkey ; i++) - set_bit(ts->plat_data->touchkey[i].keycode, dev->keybit); + set_bit(ts->plat_data->touchkey[i].keycode, + dev->keybit); set_bit(EV_LED, dev->evbit); set_bit(LED_MISC, dev->ledbit); @@ -2621,8 +2860,10 @@ static void sec_ts_set_input_prop(struct sec_ts_data *ts, struct input_dev *dev, #ifdef SW_GLOVE input_set_capability(dev, EV_SW, SW_GLOVE); #endif - input_set_abs_params(dev, ABS_MT_POSITION_X, 0, ts->plat_data->max_x, 0, 0); - input_set_abs_params(dev, ABS_MT_POSITION_Y, 0, ts->plat_data->max_y, 0, 0); + input_set_abs_params(dev, ABS_MT_POSITION_X, 0, ts->plat_data->max_x, + 0, 0); + input_set_abs_params(dev, ABS_MT_POSITION_Y, 0, ts->plat_data->max_y, + 0, 0); input_set_abs_params(dev, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0); input_set_abs_params(dev, ABS_MT_TOUCH_MINOR, 0, 255, 0, 0); #ifdef ABS_MT_CUSTOM @@ -2633,9 +2874,11 @@ static void sec_ts_set_input_prop(struct sec_ts_data *ts, struct input_dev *dev, SEC_TS_PRESSURE_MAX, 0, 0); if (propbit == INPUT_PROP_POINTER) - input_mt_init_slots(dev, MAX_SUPPORT_TOUCH_COUNT, INPUT_MT_POINTER); + input_mt_init_slots(dev, MAX_SUPPORT_TOUCH_COUNT, + INPUT_MT_POINTER); else - input_mt_init_slots(dev, MAX_SUPPORT_TOUCH_COUNT, INPUT_MT_DIRECT); + input_mt_init_slots(dev, MAX_SUPPORT_TOUCH_COUNT, + INPUT_MT_DIRECT); input_set_drvdata(dev, ts); } @@ -2651,7 +2894,8 @@ static int sec_ts_fw_init(struct sec_ts_data *ts) ret = sec_ts_read(ts, SEC_TS_READ_DEVICE_ID, deviceID, 5); if (ret < 0) - input_err(true, &ts->client->dev, "%s: failed to read device ID(%d)\n", + input_err(true, &ts->client->dev, + "%s: failed to read device ID(%d)\n", __func__, ret); else input_info(true, &ts->client->dev, @@ -2661,13 +2905,15 @@ static int sec_ts_fw_init(struct sec_ts_data *ts) ret = sec_ts_read(ts, SEC_TS_READ_FIRMWARE_INTEGRITY, &result, 1); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: failed to integrity check (%d)\n", + input_err(true, &ts->client->dev, + "%s: failed to integrity check (%d)\n", __func__, ret); } else { if (result & 0x80) valid_firmware_integrity = true; else - input_err(true, &ts->client->dev, "%s: invalid integrity result (0x%x)\n", + input_err(true, &ts->client->dev, + "%s: invalid integrity result (0x%x)\n", __func__, result); } @@ -2696,7 +2942,8 @@ static int sec_ts_fw_init(struct sec_ts_data *ts) ret = sec_ts_read_information(ts); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: fail to read information 0x%x\n", + input_err(true, &ts->client->dev, + "%s: fail to read information 0x%x\n", __func__, ret); return SEC_TS_ERR_INIT; } @@ -2705,13 +2952,15 @@ static int sec_ts_fw_init(struct sec_ts_data *ts) ret = sec_ts_write(ts, SEC_TS_CMD_SET_TOUCHFUNCTION, (u8 *)&ts->touch_functions, 2); if (ret < 0) - input_err(true, &ts->client->dev, "%s: Failed to send touch func_mode command", + input_err(true, &ts->client->dev, + "%s: Failed to send touch func_mode command", __func__); /* Sense_on */ ret = sec_ts_write(ts, SEC_TS_CMD_SENSE_ON, NULL, 0); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: fail to write Sense_on 0x%x\n", + input_err(true, &ts->client->dev, + "%s: fail to write Sense_on 0x%x\n", __func__, ret); return SEC_TS_ERR_INIT; } @@ -2744,7 +2993,8 @@ static int sec_ts_fw_init(struct sec_ts_data *ts) ret = input_register_device(ts->input_dev); if (ret) { - input_err(true, &ts->client->dev, "%s: Unable to register %s input device 0x%x\n", + input_err(true, &ts->client->dev, + "%s: Unable to register %s input device 0x%x\n", __func__, ts->input_dev->name, ret); return SEC_TS_ERR_REG_INPUT_DEV; } @@ -2752,7 +3002,8 @@ static int sec_ts_fw_init(struct sec_ts_data *ts) if (ts->plat_data->support_dex) { ret = input_register_device(ts->input_dev_pad); if (ret) { - input_err(true, &ts->client->dev, "%s: Unable to register %s input device 0x%x\n", + input_err(true, &ts->client->dev, + "%s: Unable to register %s input device 0x%x\n", __func__, ts->input_dev_pad->name, ret); return SEC_TS_ERR_REG_INPUT_PAD_DEV; } @@ -2805,7 +3056,9 @@ static int sec_ts_probe(struct spi_device *client) sizeof(struct sec_ts_plat_data), GFP_KERNEL); if (!pdata) { - input_err(true, &client->dev, "%s: Failed to allocate platform data\n", __func__); + input_err(true, &client->dev, + "%s: Failed to allocate platform data\n", + __func__); goto error_allocate_pdata; } @@ -2813,25 +3066,29 @@ static int sec_ts_probe(struct spi_device *client) ret = sec_ts_parse_dt(client); if (ret) { - input_err(true, &client->dev, "%s: Failed to parse dt\n", __func__); + input_err(true, &client->dev, + "%s: Failed to parse dt\n", __func__); goto error_allocate_mem; } } else { pdata = client->dev.platform_data; if (!pdata) { - input_err(true, &client->dev, "%s: No platform data found\n", __func__); + input_err(true, &client->dev, + "%s: No platform data found\n", __func__); goto error_allocate_pdata; } } if (!pdata->power) { - input_err(true, &client->dev, "%s: No power contorl found\n", __func__); + input_err(true, &client->dev, "%s: No power contorl found\n", + __func__); goto error_allocate_mem; } pdata->pinctrl = devm_pinctrl_get(&client->dev); if (IS_ERR(pdata->pinctrl)) - input_err(true, &client->dev, "%s: could not get pinctrl\n", __func__); + input_err(true, &client->dev, "%s: could not get pinctrl\n", + __func__); ts = kzalloc(sizeof(struct sec_ts_data), GFP_KERNEL); if (!ts) @@ -2914,7 +3171,8 @@ static int sec_ts_probe(struct spi_device *client) ts->input_dev = input_allocate_device(); if (!ts->input_dev) { - input_err(true, &ts->client->dev, "%s: allocate device err!\n", __func__); + input_err(true, &ts->client->dev, + "%s: allocate device err!\n", __func__); ret = -ENOMEM; goto err_allocate_input_dev; } @@ -2922,7 +3180,8 @@ static int sec_ts_probe(struct spi_device *client) if (ts->plat_data->support_dex) { ts->input_dev_pad = input_allocate_device(); if (!ts->input_dev_pad) { - input_err(true, &ts->client->dev, "%s: allocate device err!\n", __func__); + input_err(true, &ts->client->dev, + "%s: allocate device err!\n", __func__); ret = -ENOMEM; goto err_allocate_input_dev_pad; } @@ -3087,9 +3346,9 @@ static int sec_ts_probe(struct spi_device *client) /* need to be enabled when new goto statement is added */ /* - sec_ts_fn_remove(ts); - free_irq(client->irq, ts); -*/ + * sec_ts_fn_remove(ts); + * free_irq(client->irq, ts); + **/ err_register_drm_client: free_irq(client->irq, ts); err_heatmap: @@ -3170,24 +3429,31 @@ void sec_ts_unlocked_release_all_finger(struct sec_ts_data *ts) 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); + 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->coord[i].action == + SEC_TS_COORDINATE_ACTION_MOVE)) { ts->coord[i].action = SEC_TS_COORDINATE_ACTION_RELEASE; input_info(true, &ts->client->dev, - "%s: [RA] tID:%d mc:%d tc:%d v:%02X%02X cal:%02X(%02X) id(%d,%d) p:%d\n", - __func__, i, ts->coord[i].mcount, ts->touch_count, - ts->plat_data->img_version_of_ic[2], - ts->plat_data->img_version_of_ic[3], - ts->cal_status, ts->nv, ts->tspid_val, - ts->tspicid_val, ts->coord[i].palm_count); + "%s: [RA] tID:%d mc:%d tc:%d v:%02X%02X cal:%02X(%02X) id(%d,%d) p:%d\n", + __func__, i, + ts->coord[i].mcount, ts->touch_count, + ts->plat_data->img_version_of_ic[2], + ts->plat_data->img_version_of_ic[3], + ts->cal_status, ts->nv, ts->tspid_val, + ts->tspicid_val, ts->coord[i].palm_count); do_gettimeofday(&ts->time_released[i]); - - if (ts->time_longest < (ts->time_released[i].tv_sec - ts->time_pressed[i].tv_sec)) - ts->time_longest = (ts->time_released[i].tv_sec - ts->time_pressed[i].tv_sec); + + if (ts->time_longest < + (ts->time_released[i].tv_sec - + ts->time_pressed[i].tv_sec)) + ts->time_longest = + (ts->time_released[i].tv_sec - + ts->time_pressed[i].tv_sec); } ts->coord[i].mcount = 0; @@ -3225,24 +3491,32 @@ void sec_ts_locked_release_all_finger(struct sec_ts_data *ts) 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); + 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->coord[i].action == + SEC_TS_COORDINATE_ACTION_MOVE)) { ts->coord[i].action = SEC_TS_COORDINATE_ACTION_RELEASE; input_info(true, &ts->client->dev, - "%s: [RA] tID:%d mc: %d tc:%d, v:%02X%02X, cal:%X(%X|%X), id(%d,%d), p:%d\n", - __func__, i, ts->coord[i].mcount, ts->touch_count, - ts->plat_data->img_version_of_ic[2], - ts->plat_data->img_version_of_ic[3], - ts->cal_status, ts->nv, ts->cal_count, ts->tspid_val, - ts->tspicid_val, ts->coord[i].palm_count); + "%s: [RA] tID:%d mc: %d tc:%d, v:%02X%02X, cal:%X(%X|%X), id(%d,%d), p:%d\n", + __func__, i, ts->coord[i].mcount, + ts->touch_count, + ts->plat_data->img_version_of_ic[2], + ts->plat_data->img_version_of_ic[3], + ts->cal_status, ts->nv, ts->cal_count, + ts->tspid_val, ts->tspicid_val, + ts->coord[i].palm_count); do_gettimeofday(&ts->time_released[i]); - if (ts->time_longest < (ts->time_released[i].tv_sec - ts->time_pressed[i].tv_sec)) - ts->time_longest = (ts->time_released[i].tv_sec - ts->time_pressed[i].tv_sec); + if (ts->time_longest < + (ts->time_released[i].tv_sec - + ts->time_pressed[i].tv_sec)) + ts->time_longest = + (ts->time_released[i].tv_sec - + ts->time_pressed[i].tv_sec); } ts->coord[i].mcount = 0; @@ -3293,27 +3567,36 @@ static void sec_ts_reset_work(struct work_struct *work) sec_ts_start_device(ts); if (ts->input_dev_touch->disabled) { - input_err(true, &ts->client->dev , "%s: call input_close\n", __func__); + input_err(true, &ts->client->dev, + "%s: call input_close\n", __func__); sec_ts_input_close(ts->input_dev); - if ((ts->lowpower_mode & SEC_TS_MODE_CUSTOMLIB_AOD) && ts->use_customlib) { + if ((ts->lowpower_mode & SEC_TS_MODE_CUSTOMLIB_AOD) && + ts->use_customlib) { int i, ret; u8 data[10] = {0x02, 0}; for (i = 0; i < 4; i++) { data[i * 2 + 2] = ts->rect_data[i] & 0xFF; - data[i * 2 + 3] = (ts->rect_data[i] >> 8) & 0xFF; + data[i * 2 + 3] = + (ts->rect_data[i] >> 8) & 0xFF; } disable_irq(ts->client->irq); - ret = ts->sec_ts_write(ts, SEC_TS_CMD_CUSTOMLIB_WRITE_PARAM, &data[0], 10); + ret = ts->sec_ts_write(ts, + SEC_TS_CMD_CUSTOMLIB_WRITE_PARAM, &data[0], 10); if (ret < 0) - input_err(true, &ts->client->dev, "%s: Failed to write offset\n", __func__); + input_err(true, &ts->client->dev, + "%s: Failed to write offset\n", + __func__); - ret = ts->sec_ts_write(ts, SEC_TS_CMD_CUSTOMLIB_NOTIFY_PACKET, NULL, 0); + ret = ts->sec_ts_write(ts, + SEC_TS_CMD_CUSTOMLIB_NOTIFY_PACKET, NULL, 0); if (ret < 0) - input_err(true, &ts->client->dev, "%s: Failed to send notify\n", __func__); + input_err(true, &ts->client->dev, + "%s: Failed to send notify\n", + __func__); enable_irq(ts->client->irq); } } @@ -3446,7 +3729,8 @@ int sec_ts_set_lowpowermode(struct sec_ts_data *ts, u8 mode) char para = 0; input_err(true, &ts->client->dev, "%s: %s(%X)\n", __func__, - mode == TO_LOWPOWER_MODE ? "ENTER" : "EXIT", ts->lowpower_mode); + mode == TO_LOWPOWER_MODE ? "ENTER" : "EXIT", + ts->lowpower_mode); if (mode) { #ifdef SEC_TS_SUPPORT_CUSTOMLIB @@ -3455,9 +3739,11 @@ int sec_ts_set_lowpowermode(struct sec_ts_data *ts, u8 mode) #endif data = (ts->lowpower_mode & SEC_TS_MODE_LOWPOWER_FLAG) >> 1; - ret = sec_ts_write(ts, SEC_TS_CMD_WAKEUP_GESTURE_MODE, &data, 1); + ret = sec_ts_write(ts, SEC_TS_CMD_WAKEUP_GESTURE_MODE, + &data, 1); if (ret < 0) - input_err(true, &ts->client->dev, "%s: Failed to set\n", __func__); + input_err(true, &ts->client->dev, + "%s: Failed to set\n", __func__); } retry_pmode: @@ -3471,9 +3757,12 @@ retry_pmode: ret = sec_ts_read(ts, SEC_TS_CMD_SET_POWER_MODE, ¶, 1); if (ret < 0) - input_err(true, &ts->client->dev, "%s: read power mode failed!\n", __func__); + input_err(true, &ts->client->dev, + "%s: read power mode failed!\n", __func__); else - input_info(true, &ts->client->dev, "%s: power mode - write(%d) read(%d)\n", __func__, mode, para); + input_info(true, &ts->client->dev, + "%s: power mode - write(%d) read(%d)\n", + __func__, mode, para); if (mode != para) { retrycnt++; @@ -3483,7 +3772,8 @@ retry_pmode: ret = sec_ts_write(ts, SEC_TS_CMD_CLEAR_EVENT_STACK, NULL, 0); if (ret < 0) - input_err(true, &ts->client->dev, "%s: write clear event failed\n", __func__); + input_err(true, &ts->client->dev, + "%s: write clear event failed\n", __func__); sec_ts_locked_release_all_finger(ts); @@ -3515,7 +3805,8 @@ static int sec_ts_input_open(struct input_dev *dev) if (ts->lowpower_status) { #ifdef USE_RESET_EXIT_LPM - schedule_delayed_work(&ts->reset_work, msecs_to_jiffies(TOUCH_RESET_DWORK_TIME)); + schedule_delayed_work(&ts->reset_work, + msecs_to_jiffies(TOUCH_RESET_DWORK_TIME)); #else sec_ts_set_lowpowermode(ts, TO_TOUCH_MODE); #endif @@ -3523,7 +3814,8 @@ static int sec_ts_input_open(struct input_dev *dev) } 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: Failed to start device\n", __func__); } /* because edge and dead zone will recover soon */ @@ -3697,7 +3989,8 @@ int sec_ts_stop_device(struct sec_ts_data *ts) 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__); + input_err(true, &ts->client->dev, + "%s: already power off\n", __func__); goto out; } @@ -3729,7 +4022,8 @@ int sec_ts_start_device(struct sec_ts_data *ts) 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__); + input_err(true, &ts->client->dev, + "%s: already power on\n", __func__); goto out; } @@ -3744,19 +4038,26 @@ int sec_ts_start_device(struct sec_ts_data *ts) ts->plat_data->enable_sync(true); if (ts->flip_enable) { - ret = sec_ts_write(ts, SEC_TS_CMD_SET_COVERTYPE, &ts->cover_cmd, 1); + ret = sec_ts_write(ts, SEC_TS_CMD_SET_COVERTYPE, + &ts->cover_cmd, 1); - ts->touch_functions = ts->touch_functions | SEC_TS_BIT_SETFUNC_COVER; + ts->touch_functions = ts->touch_functions | + SEC_TS_BIT_SETFUNC_COVER; input_info(true, &ts->client->dev, - "%s: cover cmd write type:%d, mode:%x, ret:%d", __func__, ts->touch_functions, ts->cover_cmd, ret); + "%s: cover cmd write type:%d, mode:%x, ret:%d", + __func__, ts->touch_functions, + ts->cover_cmd, ret); } else { - ts->touch_functions = (ts->touch_functions & (~SEC_TS_BIT_SETFUNC_COVER)); + ts->touch_functions = (ts->touch_functions & + (~SEC_TS_BIT_SETFUNC_COVER)); input_info(true, &ts->client->dev, "%s: cover open, not send cmd", __func__); } - ts->touch_functions = ts->touch_functions | SEC_TS_DEFAULT_ENABLE_BIT_SETFUNC; - ret = sec_ts_write(ts, SEC_TS_CMD_SET_TOUCHFUNCTION, (u8 *)&ts->touch_functions, 2); + ts->touch_functions = ts->touch_functions | + SEC_TS_DEFAULT_ENABLE_BIT_SETFUNC; + ret = sec_ts_write(ts, SEC_TS_CMD_SET_TOUCHFUNCTION, + (u8 *)&ts->touch_functions, 2); if (ret < 0) input_err(true, &ts->client->dev, "%s: Failed to send touch function command", __func__); @@ -3769,33 +4070,41 @@ int sec_ts_start_device(struct sec_ts_data *ts) sec_ts_set_grip_type(ts, ONLY_EDGE_HANDLER); if (ts->dex_mode) { - input_info(true, &ts->client->dev, "%s: set dex mode\n", __func__); - ret = ts->sec_ts_write(ts, SEC_TS_CMD_SET_DEX_MODE, &ts->dex_mode, 1); + input_info(true, &ts->client->dev, + "%s: set dex mode\n", __func__); + ret = ts->sec_ts_write(ts, SEC_TS_CMD_SET_DEX_MODE, + &ts->dex_mode, 1); if (ret < 0) input_err(true, &ts->client->dev, - "%s: failed to set dex mode %x\n", __func__, ts->dex_mode); + "%s: failed to set dex mode %x\n", + __func__, ts->dex_mode); } if (ts->brush_mode) { - input_info(true, &ts->client->dev, "%s: set brush mode\n", __func__); - ret = ts->sec_ts_write(ts, SEC_TS_CMD_SET_BRUSH_MODE, &ts->brush_mode, 1); + input_info(true, &ts->client->dev, + "%s: set brush mode\n", __func__); + ret = ts->sec_ts_write(ts, SEC_TS_CMD_SET_BRUSH_MODE, + &ts->brush_mode, 1); if (ret < 0) input_err(true, &ts->client->dev, - "%s: failed to set brush mode\n", __func__); + "%s: failed to set brush mode\n", __func__); } if (ts->touchable_area) { - input_info(true, &ts->client->dev, "%s: set 16:9 mode\n", __func__); - ret = ts->sec_ts_write(ts, SEC_TS_CMD_SET_TOUCHABLE_AREA, &ts->touchable_area, 1); + input_info(true, &ts->client->dev, + "%s: set 16:9 mode\n", __func__); + ret = ts->sec_ts_write(ts, SEC_TS_CMD_SET_TOUCHABLE_AREA, + &ts->touchable_area, 1); if (ret < 0) input_err(true, &ts->client->dev, - "%s: failed to set 16:9 mode\n", __func__); + "%s: failed to set 16:9 mode\n", __func__); } /* Sense_on */ ret = sec_ts_write(ts, SEC_TS_CMD_SENSE_ON, NULL, 0); if (ret < 0) - input_err(true, &ts->client->dev, "%s: fail to write Sense_on\n", __func__); + input_err(true, &ts->client->dev, + "%s: fail to write Sense_on\n", __func__); enable_irq(ts->client->irq); @@ -68,7 +68,8 @@ #undef USE_PRESSURE_SENSOR //TODO: check this #undef PAT_CONTROL //TODO: check this -#if defined(USE_RESET_DURING_POWER_ON) || defined(USE_POR_AFTER_I2C_RETRY) || defined(USE_RESET_EXIT_LPM) +#if defined(USE_RESET_DURING_POWER_ON) ||\ + defined(USE_POR_AFTER_I2C_RETRY) || defined(USE_RESET_EXIT_LPM) #define USE_POWER_RESET_WORK #endif @@ -141,7 +142,8 @@ /* max read size: from sec_ts_read_event() at sec_ts.c */ #define IO_PREALLOC_READ_BUF_SZ (32 * SEC_TS_EVENT_BUFF_SIZE) /* max write size: from sec_ts_flashpagewrite() at sec_ts_fw.c */ -#define IO_PREALLOC_WRITE_BUF_SZ (SEC_TS_SPI_HEADER_SIZE + 1 + 2 + SEC_TS_FW_BLK_SIZE_MAX + 1) +#define IO_PREALLOC_WRITE_BUF_SZ (SEC_TS_SPI_HEADER_SIZE + 1 + 2 +\ + SEC_TS_FW_BLK_SIZE_MAX + 1) #else #define IO_PREALLOC_READ_BUF_SZ 2048 #define IO_PREALLOC_WRITE_BUF_SZ 1024 @@ -185,16 +187,21 @@ #define SEC_TS_NVM_OFFSET_PRESSURE_DELTA_CAL_COUNT 55 #define SEC_TS_NVM_SIZE_PRESSURE_CAL_BLOCK 1 -#define SEC_TS_NVM_LAST_BLOCK_OFFSET SEC_TS_NVM_OFFSET_PRESSURE_DELTA_CAL_COUNT -#define SEC_TS_NVM_LAST_BLOCK_SIZE SEC_TS_NVM_SIZE_PRESSURE_CAL_BLOCK +#define SEC_TS_NVM_LAST_BLOCK_OFFSET \ + SEC_TS_NVM_OFFSET_PRESSURE_DELTA_CAL_COUNT +#define SEC_TS_NVM_LAST_BLOCK_SIZE SEC_TS_NVM_SIZE_PRESSURE_CAL_BLOCK -#define SEC_TS_NVM_OFFSET_LENGTH (SEC_TS_NVM_LAST_BLOCK_OFFSET + SEC_TS_NVM_LAST_BLOCK_SIZE + 1) +#define SEC_TS_NVM_OFFSET_LENGTH (SEC_TS_NVM_LAST_BLOCK_OFFSET +\ + SEC_TS_NVM_LAST_BLOCK_SIZE + 1) /* SEC_TS READ REGISTER ADDRESS */ #define SEC_TS_CMD_SENSE_ON 0x10 #define SEC_TS_CMD_SENSE_OFF 0x11 #define SEC_TS_CMD_SW_RESET 0x12 -#define SEC_TS_CMD_CALIBRATION_SEC 0x13 // send it to touch ic, but toucu ic works nothing. +#define SEC_TS_CMD_CALIBRATION_SEC 0x13 /* send it to touch ic, + * but touch ic works + * nothing. + **/ #define SEC_TS_CMD_FACTORY_PANELCALIBRATION 0x14 #define SEC_TS_READ_GPIO_STATUS 0x20 // not support @@ -380,7 +387,9 @@ #define SEC_TS_BIT_SETFUNC_WET (1 << 6) #define SEC_TS_BIT_SETFUNC_PROXIMITY (1 << 7) -#define SEC_TS_DEFAULT_ENABLE_BIT_SETFUNC (SEC_TS_BIT_SETFUNC_TOUCH | SEC_TS_BIT_SETFUNC_PALM | SEC_TS_BIT_SETFUNC_WET) +#define SEC_TS_DEFAULT_ENABLE_BIT_SETFUNC (SEC_TS_BIT_SETFUNC_TOUCH |\ + SEC_TS_BIT_SETFUNC_PALM |\ + SEC_TS_BIT_SETFUNC_WET) #define SEC_TS_BIT_CHARGER_MODE_NO (0x1 << 0) #define SEC_TS_BIT_CHARGER_MODE_WIRE_CHARGER (0x1 << 1) @@ -389,16 +398,16 @@ #ifdef PAT_CONTROL /* - * <<< apply to server >>> - * 0x00 : no action - * 0x01 : clear nv - * 0x02 : pat magic - * 0x03 : rfu + * <<< apply to server >>> + * 0x00 : no action + * 0x01 : clear nv + * 0x02 : pat magic + * 0x03 : rfu * - * <<< use for temp bin >>> - * 0x05 : forced clear nv & f/w update before pat magic, eventhough same f/w - * 0x06 : rfu - */ + * <<< use for temp bin >>> + * 0x05 : forced clear nv & f/w update before pat magic, eventhough same f/w + * 0x06 : rfu + **/ #define PAT_CONTROL_NONE 0x00 #define PAT_CONTROL_CLEAR_NV 0x01 #define PAT_CONTROL_PAT_MAGIC 0x02 @@ -409,7 +418,7 @@ #define PAT_MAGIC_NUMBER 0x83 #define PAT_MAX_MAGIC 0xC5 #define PAT_EXT_FACT 0xE0 -#define PAT_MAX_EXT 0xF5 +#define PAT_MAX_EXT 0xF5 #endif #define STATE_MANAGE_ON 1 @@ -455,14 +464,14 @@ enum grip_set_data { GRIP_ALL_DATA = 1, }; -typedef enum { +enum TOUCH_POWER_MODE { SEC_TS_STATE_POWER_OFF = 0, SEC_TS_STATE_SUSPEND, SEC_TS_STATE_LPM, SEC_TS_STATE_POWER_ON -} TOUCH_POWER_MODE; +}; -typedef enum { +enum TOUCH_SYSTEM_MODE { TOUCH_SYSTEM_MODE_BOOT = 0, TOUCH_SYSTEM_MODE_CALIBRATION = 1, TOUCH_SYSTEM_MODE_TOUCH = 2, @@ -470,9 +479,9 @@ typedef enum { TOUCH_SYSTEM_MODE_FLASH = 4, TOUCH_SYSTEM_MODE_LOWPOWER = 5, TOUCH_SYSTEM_MODE_SLEEP = 6 -} TOUCH_SYSTEM_MODE; +}; -typedef enum { +enum TOUCH_MODE_STATE { TOUCH_MODE_STATE_IDLE = 0, TOUCH_MODE_STATE_HOVER = 1, TOUCH_MODE_STATE_STOP = 1, @@ -481,7 +490,7 @@ typedef enum { TOUCH_MODE_STATE_CAL = 4, TOUCH_MODE_STATE_CAL2 = 5, TOUCH_MODE_STATE_WAKEUP = 10 -} TOUCH_MODE_STATE; +}; enum { TEST_OPEN = (0x1 << 0), @@ -500,35 +509,51 @@ enum switch_system_mode { }; enum { - TYPE_RAW_DATA = 0, /* Total - Offset : delta data */ - TYPE_SIGNAL_DATA = 1, /* Signal - Filtering & Normalization */ - TYPE_AMBIENT_BASELINE = 2, /* Cap Baseline */ - TYPE_AMBIENT_DATA = 3, /* Cap Ambient */ - TYPE_REMV_BASELINE_DATA = 4, + TYPE_RAW_DATA = 0, /* Total - Offset : delta data + **/ + TYPE_SIGNAL_DATA = 1, /* Signal - Filtering & + * Normalization + **/ + TYPE_AMBIENT_BASELINE = 2, /* Cap Baseline + **/ + TYPE_AMBIENT_DATA = 3, /* Cap Ambient + **/ + TYPE_REMV_BASELINE_DATA = 4, TYPE_DECODED_DATA = 5, /* Raw */ - TYPE_REMV_AMB_DATA = 6, /* TYPE_RAW_DATA - TYPE_AMBIENT_DATA */ - TYPE_NORM2_DATA = 15, /* After fs norm. data */ - TYPE_OFFSET_DATA_SEC = 19, /* Cap Offset in SEC Manufacturing Line */ - TYPE_OFFSET_DATA_SDC = 29, /* Cap Offset in SDC Manufacturing Line */ - TYPE_NOI_P2P_MIN = 30, /* Peak-to-peak noise Min */ - TYPE_NOI_P2P_MAX = 31, /* Peak-to-peak noise Max */ + TYPE_REMV_AMB_DATA = 6, /* TYPE_RAW_DATA - + * TYPE_AMBIENT_DATA + **/ + TYPE_NORM2_DATA = 15, /* After fs norm. data + **/ + TYPE_OFFSET_DATA_SEC = 19, /* Cap Offset in SEC + * Manufacturing Line + **/ + TYPE_OFFSET_DATA_SDC = 29, /* Cap Offset in SDC + * Manufacturing Line + **/ + TYPE_NOI_P2P_MIN = 30, /* Peak-to-peak noise Min + **/ + TYPE_NOI_P2P_MAX = 31, /* Peak-to-peak noise Max + **/ TYPE_OFFSET_DATA_SDC_CM2 = 129, TYPE_OFFSET_DATA_SDC_NOT_SAVE = 229, - TYPE_INVALID_DATA = 0xFF, /* Invalid data type for release factory mode */ + TYPE_INVALID_DATA = 0xFF, /* Invalid data type for + * release factory mode + **/ }; -typedef enum { +enum CUSTOMLIB_EVENT_TYPE { CUSTOMLIB_EVENT_TYPE_SPAY = 0x04, - CUSTOMLIB_EVENT_TYPE_PRESSURE_TOUCHED = 0x05, - CUSTOMLIB_EVENT_TYPE_PRESSURE_RELEASED = 0x06, + CUSTOMLIB_EVENT_TYPE_PRESSURE_TOUCHED = 0x05, + CUSTOMLIB_EVENT_TYPE_PRESSURE_RELEASED = 0x06, CUSTOMLIB_EVENT_TYPE_AOD = 0x08, - CUSTOMLIB_EVENT_TYPE_AOD_PRESS = 0x09, + CUSTOMLIB_EVENT_TYPE_AOD_PRESS = 0x09, CUSTOMLIB_EVENT_TYPE_AOD_LONGPRESS = 0x0A, CUSTOMLIB_EVENT_TYPE_AOD_DOUBLETAB = 0x0B, - CUSTOMLIB_EVENT_TYPE_AOD_HOMEKEY_PRESS = 0x0C, + CUSTOMLIB_EVENT_TYPE_AOD_HOMEKEY_PRESS = 0x0C, CUSTOMLIB_EVENT_TYPE_AOD_HOMEKEY_RELEASE = 0x0D, - CUSTOMLIB_EVENT_TYPE_AOD_HOMEKEY_RELEASE_NO_HAPTIC = 0x0E -} CUSTOMLIB_EVENT_TYPE; + CUSTOMLIB_EVENT_TYPE_AOD_HOMEKEY_RLS_NO_HAPTIC = 0x0E +}; enum { SEC_TS_BUS_REF_SCREEN_ON = 0x01, @@ -560,8 +585,9 @@ enum { #define SEC_TS_MODE_CUSTOMLIB_AOD (1 << 2) #define SEC_TS_MODE_CUSTOMLIB_FORCE_KEY (1 << 6) -#define SEC_TS_MODE_LOWPOWER_FLAG (SEC_TS_MODE_CUSTOMLIB_SPAY | SEC_TS_MODE_CUSTOMLIB_AOD \ - | SEC_TS_MODE_CUSTOMLIB_FORCE_KEY) +#define SEC_TS_MODE_LOWPOWER_FLAG (SEC_TS_MODE_CUSTOMLIB_SPAY |\ + SEC_TS_MODE_CUSTOMLIB_AOD |\ + SEC_TS_MODE_CUSTOMLIB_FORCE_KEY) #define SEC_TS_AOD_GESTURE_PRESS (1 << 7) #define SEC_TS_AOD_GESTURE_LONGPRESS (1 << 6) @@ -620,7 +646,7 @@ struct heatmap_report { uint8_t size_y; /* data is in BE order; order should be enforced after data is read */ strength_t data[LOCAL_HEATMAP_WIDTH * LOCAL_HEATMAP_HEIGHT]; -} __attribute__((packed)); +} __packed; #endif #define TEST_MODE_MIN_MAX false @@ -670,7 +696,7 @@ struct sec_ts_test_result { u8 assy_result:2; u8 module_count:2; u8 module_result:2; - } __attribute__ ((packed)); + } __packed; unsigned char data[1]; }; }; @@ -688,7 +714,7 @@ struct sec_ts_gesture_status { u8 reserved_1; u8 left_event_5_0:6; u8 reserved_2:2; -} __attribute__ ((packed)); +} __packed; /* status id for sec_ts event */ @@ -709,7 +735,7 @@ struct sec_ts_event_status { u8 status_data_5; u8 left_event_5_0:6; u8 reserved_2:2; -} __attribute__ ((packed)); +} __packed; /* 8 byte */ struct sec_ts_event_coordinate { @@ -726,7 +752,7 @@ struct sec_ts_event_coordinate { u8 ttype_3_2:2; u8 left_event:6; u8 ttype_1_0:2; -} __attribute__ ((packed)); +} __packed; /* not fixed */ struct sec_ts_coordinate { @@ -766,13 +792,18 @@ struct sec_ts_data { struct input_dev *input_dev_pad; struct input_dev *input_dev_touch; struct sec_ts_plat_data *plat_data; - struct sec_ts_coordinate coord[MAX_SUPPORT_TOUCH_COUNT + MAX_SUPPORT_HOVER_COUNT]; - - ktime_t timestamp; /* time that the event was first received from the - touch IC, acquired during hard interrupt, in CLOCK_MONOTONIC */ - - struct timeval time_pressed[MAX_SUPPORT_TOUCH_COUNT + MAX_SUPPORT_HOVER_COUNT]; - struct timeval time_released[MAX_SUPPORT_TOUCH_COUNT + MAX_SUPPORT_HOVER_COUNT]; + struct sec_ts_coordinate coord[MAX_SUPPORT_TOUCH_COUNT + + MAX_SUPPORT_HOVER_COUNT]; + + ktime_t timestamp; /* time that the event was first received from + * the touch IC, acquired during hard interrupt, + * in CLOCK_MONOTONIC + **/ + + struct timeval time_pressed[MAX_SUPPORT_TOUCH_COUNT + + MAX_SUPPORT_HOVER_COUNT]; + struct timeval time_released[MAX_SUPPORT_TOUCH_COUNT + + MAX_SUPPORT_HOVER_COUNT]; long time_longest; u8 lowpower_mode; @@ -832,7 +863,8 @@ struct sec_ts_data { struct work_struct suspend_work; struct work_struct resume_work; struct workqueue_struct *event_wq; /* Used for event handler, - * suspend, resume threads */ + * suspend, resume threads + **/ struct completion resume_done; struct sec_cmd_data sec; short *pFrame; @@ -951,7 +983,7 @@ struct sec_ts_data { struct sec_ts_plat_data { int max_x; int max_y; - unsigned irq_gpio; + unsigned int irq_gpio; int irq_type; int io_burstmax; int always_lpmode; @@ -1002,7 +1034,8 @@ int sec_ts_sw_reset(struct sec_ts_data *ts); int sec_ts_system_reset(struct sec_ts_data *ts); int sec_ts_set_lowpowermode(struct sec_ts_data *ts, u8 mode); int sec_ts_firmware_update_on_probe(struct sec_ts_data *ts, bool force_update); -int sec_ts_firmware_update_on_hidden_menu(struct sec_ts_data *ts, int update_type); +int sec_ts_firmware_update_on_hidden_menu(struct sec_ts_data *ts, + int update_type); int sec_ts_glove_mode_enables(struct sec_ts_data *ts, int mode); int sec_ts_set_cover_type(struct sec_ts_data *ts, bool enable); int sec_ts_wait_for_ready(struct sec_ts_data *ts, unsigned int ack); @@ -1011,7 +1044,8 @@ int sec_ts_wait_for_ready_with_count(struct sec_ts_data *ts, unsigned int ack, int sec_ts_try_wake(struct sec_ts_data *ts, bool wake_setting); int sec_ts_set_bus_ref(struct sec_ts_data *ts, u16 ref, bool enable); -int sec_ts_function(int (*func_init)(void *device_data), void (*func_remove)(void)); +int sec_ts_function(int (*func_init)(void *device_data), + void (*func_remove)(void)); int sec_ts_fn_init(struct sec_ts_data *ts); int sec_ts_read_calibration_report(struct sec_ts_data *ts); int sec_ts_execute_force_calibration(struct sec_ts_data *ts, int cal_mode); diff --git a/sec_ts_fn.c b/sec_ts_fn.c index 4dedf16..95ba891 100644 --- a/sec_ts_fn.c +++ b/sec_ts_fn.c @@ -161,12 +161,17 @@ static struct sec_cmd sec_cmds[] = { {SEC_CMD("run_force_calibration", run_force_calibration),}, {SEC_CMD("get_force_calibration", get_force_calibration),}, #ifdef USE_PRESSURE_SENSOR - {SEC_CMD("run_force_pressure_calibration", run_force_pressure_calibration),}, + {SEC_CMD("run_force_pressure_calibration", + run_force_pressure_calibration),}, {SEC_CMD("set_pressure_test_mode", set_pressure_test_mode),}, - {SEC_CMD("run_pressure_filtered_strength_read_all", run_pressure_filtered_strength_read_all),}, - {SEC_CMD("run_pressure_strength_read_all", run_pressure_strength_read_all),}, - {SEC_CMD("run_pressure_rawdata_read_all", run_pressure_rawdata_read_all),}, - {SEC_CMD("run_pressure_offset_read_all", run_pressure_offset_read_all),}, + {SEC_CMD("run_pressure_filtered_strength_read_all", + run_pressure_filtered_strength_read_all),}, + {SEC_CMD("run_pressure_strength_read_all", + run_pressure_strength_read_all),}, + {SEC_CMD("run_pressure_rawdata_read_all", + run_pressure_rawdata_read_all),}, + {SEC_CMD("run_pressure_offset_read_all", + run_pressure_offset_read_all),}, {SEC_CMD("set_pressure_strength", set_pressure_strength),}, {SEC_CMD("set_pressure_rawdata", set_pressure_rawdata),}, {SEC_CMD("set_pressure_data_index", set_pressure_data_index),}, @@ -447,7 +452,7 @@ err_out: sec_ts_set_bus_ref(ts, SEC_TS_BUS_REF_SYSFS, false); } -static ssize_t scrub_position_show(struct device *dev, +static ssize_t scrub_pos_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sec_cmd_data *sec = dev_get_drvdata(dev); @@ -462,7 +467,8 @@ static ssize_t scrub_position_show(struct device *dev, "%s: scrub_id: %d, X:%d, Y:%d\n", __func__, ts->scrub_id, ts->scrub_x, ts->scrub_y); #endif - snprintf(buff, sizeof(buff), "%d %d %d", ts->scrub_id, ts->scrub_x, ts->scrub_y); + snprintf(buff, sizeof(buff), "%d %d %d", + ts->scrub_id, ts->scrub_x, ts->scrub_y); ts->scrub_x = 0; ts->scrub_y = 0; @@ -470,9 +476,9 @@ static ssize_t scrub_position_show(struct device *dev, return snprintf(buf, PAGE_SIZE, "%s", buff); } -static DEVICE_ATTR(scrub_pos, S_IRUGO, scrub_position_show, NULL); +static DEVICE_ATTR_RO(scrub_pos); -static ssize_t read_ito_check_show(struct device *dev, +static ssize_t ito_check_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sec_cmd_data *sec = dev_get_drvdata(dev); @@ -490,7 +496,7 @@ static ssize_t read_ito_check_show(struct device *dev, return snprintf(buf, SEC_CMD_BUF_SIZE, "%s", buff); } -static ssize_t read_raw_check_show(struct device *dev, +static ssize_t raw_check_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sec_cmd_data *sec = dev_get_drvdata(dev); @@ -526,7 +532,7 @@ static ssize_t read_raw_check_show(struct device *dev, return ret; } -static ssize_t read_multi_count_show(struct device *dev, +static ssize_t multi_count_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sec_cmd_data *sec = dev_get_drvdata(dev); @@ -538,7 +544,7 @@ static ssize_t read_multi_count_show(struct device *dev, return snprintf(buf, SEC_CMD_BUF_SIZE, "%d", ts->multi_count); } -static ssize_t clear_multi_count_store(struct device *dev, +static ssize_t multi_count_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { @@ -552,7 +558,7 @@ static ssize_t clear_multi_count_store(struct device *dev, return count; } -static ssize_t read_wet_mode_show(struct device *dev, +static ssize_t wet_mode_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sec_cmd_data *sec = dev_get_drvdata(dev); @@ -564,7 +570,7 @@ static ssize_t read_wet_mode_show(struct device *dev, return snprintf(buf, SEC_CMD_BUF_SIZE, "%d", ts->wet_count); } -static ssize_t clear_wet_mode_store(struct device *dev, +static ssize_t wet_mode_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { @@ -572,14 +578,14 @@ static ssize_t clear_wet_mode_store(struct device *dev, struct sec_ts_data *ts = container_of(sec, struct sec_ts_data, sec); ts->wet_count = 0; - ts->dive_count= 0; + ts->dive_count = 0; input_info(true, &ts->client->dev, "%s: clear\n", __func__); return count; } -static ssize_t read_comm_err_count_show(struct device *dev, +static ssize_t comm_err_count_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sec_cmd_data *sec = dev_get_drvdata(dev); @@ -591,7 +597,7 @@ static ssize_t read_comm_err_count_show(struct device *dev, return snprintf(buf, SEC_CMD_BUF_SIZE, "%d", ts->comm_err_count); } -static ssize_t clear_comm_err_count_store(struct device *dev, +static ssize_t comm_err_count_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { @@ -605,7 +611,7 @@ static ssize_t clear_comm_err_count_store(struct device *dev, return count; } -static ssize_t read_module_id_show(struct device *dev, +static ssize_t module_id_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sec_cmd_data *sec = dev_get_drvdata(dev); @@ -616,14 +622,15 @@ static ssize_t read_module_id_show(struct device *dev, ts->multi_count); snprintf(buff, sizeof(buff), "SE%02X%02X%02X%02X%02X%02X%02X", - ts->plat_data->panel_revision, ts->plat_data->img_version_of_bin[2], + ts->plat_data->panel_revision, + ts->plat_data->img_version_of_bin[2], ts->plat_data->img_version_of_bin[3], ts->nv, ts->cal_count, ts->pressure_cal_base, ts->pressure_cal_delta); return snprintf(buf, SEC_CMD_BUF_SIZE, "%s", buff); } -static ssize_t read_vendor_show(struct device *dev, +static ssize_t vendor_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sec_cmd_data *sec = dev_get_drvdata(dev); @@ -635,7 +642,7 @@ static ssize_t read_vendor_show(struct device *dev, return snprintf(buf, SEC_CMD_BUF_SIZE, "LSI_%s", buffer); } -static ssize_t clear_checksum_store(struct device *dev, +static ssize_t checksum_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { @@ -649,7 +656,7 @@ static ssize_t clear_checksum_store(struct device *dev, return count; } -static ssize_t read_checksum_show(struct device *dev, +static ssize_t checksum_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sec_cmd_data *sec = dev_get_drvdata(dev); @@ -661,7 +668,7 @@ static ssize_t read_checksum_show(struct device *dev, return snprintf(buf, SEC_CMD_BUF_SIZE, "%d", ts->checksum_result); } -static ssize_t clear_holding_time_store(struct device *dev, +static ssize_t holding_time_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { @@ -675,7 +682,7 @@ static ssize_t clear_holding_time_store(struct device *dev, return count; } -static ssize_t read_holding_time_show(struct device *dev, +static ssize_t holding_time_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sec_cmd_data *sec = dev_get_drvdata(dev); @@ -687,15 +694,16 @@ static ssize_t read_holding_time_show(struct device *dev, return snprintf(buf, SEC_CMD_BUF_SIZE, "%ld", ts->time_longest); } -static ssize_t read_all_touch_count_show(struct device *dev, +static ssize_t all_touch_count_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sec_cmd_data *sec = dev_get_drvdata(dev); struct sec_ts_data *ts = container_of(sec, struct sec_ts_data, sec); - input_info(true, &ts->client->dev, "%s: touch:%d, force:%d, aod:%d, spay:%d\n", __func__, - ts->all_finger_count, ts->all_force_count, - ts->all_aod_tap_count, ts->all_spay_count); + input_info(true, &ts->client->dev, + "%s: touch:%d, force:%d, aod:%d, spay:%d\n", __func__, + ts->all_finger_count, ts->all_force_count, + ts->all_aod_tap_count, ts->all_spay_count); return snprintf(buf, SEC_CMD_BUF_SIZE, "\"TTCN\":\"%d\",\"TFCN\":\"%d\",\"TACN\":\"%d\",\"TSCN\":\"%d\"", @@ -703,7 +711,7 @@ static ssize_t read_all_touch_count_show(struct device *dev, ts->all_aod_tap_count, ts->all_spay_count); } -static ssize_t clear_all_touch_count_store(struct device *dev, +static ssize_t all_touch_count_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { @@ -719,15 +727,14 @@ static ssize_t clear_all_touch_count_store(struct device *dev, return count; } -static ssize_t read_z_value_show(struct device *dev, +static ssize_t z_value_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sec_cmd_data *sec = dev_get_drvdata(dev); struct sec_ts_data *ts = container_of(sec, struct sec_ts_data, sec); - input_info(true, &ts->client->dev, "%s: max:%d, min:%d, avg:%d\n", __func__, - ts->max_z_value, ts->min_z_value, - ts->sum_z_value); + input_info(true, &ts->client->dev, "%s: max:%d, min:%d, avg:%d\n", + __func__, ts->max_z_value, ts->min_z_value, ts->sum_z_value); if (ts->all_finger_count) return snprintf(buf, SEC_CMD_BUF_SIZE, @@ -741,16 +748,16 @@ static ssize_t read_z_value_show(struct device *dev, } -static ssize_t clear_z_value_store(struct device *dev, +static ssize_t z_value_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct sec_cmd_data *sec = dev_get_drvdata(dev); struct sec_ts_data *ts = container_of(sec, struct sec_ts_data, sec); - ts->max_z_value= 0; - ts->min_z_value= 0xFFFFFFFF; - ts->sum_z_value= 0; + ts->max_z_value = 0; + ts->min_z_value = 0xFFFFFFFF; + ts->sum_z_value = 0; ts->all_finger_count = 0; input_info(true, &ts->client->dev, "%s: clear\n", __func__); @@ -773,7 +780,7 @@ static ssize_t pressure_enable_show(struct device *dev, return snprintf(buf, SEC_CMD_BUF_SIZE, "%s\n", buff); } -static ssize_t pressure_enable_strore(struct device *dev, +static ssize_t pressure_enable_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { @@ -806,7 +813,9 @@ static ssize_t pressure_enable_strore(struct device *dev, return count; } -static ssize_t get_lp_dump(struct device *dev, struct device_attribute *attr, char *buf) +static ssize_t get_lp_dump_show(struct device *dev, + struct device_attribute *attr, + char *buf) { struct sec_cmd_data *sec = dev_get_drvdata(dev); struct sec_ts_data *ts = container_of(sec, struct sec_ts_data, sec); @@ -817,7 +826,8 @@ static ssize_t get_lp_dump(struct device *dev, struct device_attribute *attr, ch sec_ts_set_bus_ref(ts, SEC_TS_BUS_REF_SYSFS, true); if (ts->power_status == SEC_TS_STATE_POWER_OFF) { - input_err(true, &ts->client->dev, "%s: Touch is stopped!\n", __func__); + input_err(true, &ts->client->dev, "%s: Touch is stopped!\n", + __func__); sec_ts_set_bus_ref(ts, SEC_TS_BUS_REF_SYSFS, false); return snprintf(buf, SEC_CMD_BUF_SIZE, "TSP turned off"); } @@ -829,7 +839,8 @@ static ssize_t get_lp_dump(struct device *dev, struct device_attribute *attr, ch ret = ts->sec_ts_read_customlib(ts, string_data, 2); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: Failed to read rect\n", __func__); + input_err(true, &ts->client->dev, "%s: Failed to read rect\n", + __func__); snprintf(buf, SEC_CMD_BUF_SIZE, "NG, Failed to read rect"); goto out; } @@ -837,15 +848,15 @@ static ssize_t get_lp_dump(struct device *dev, struct device_attribute *attr, ch current_index = (string_data[1] & 0xFF) << 8 | (string_data[0] & 0xFF); if (current_index > 1000 || current_index < 500) { input_err(true, &ts->client->dev, - "Failed to Custom Library LP log %d\n", current_index); + "Failed to Custom Library LP log %d\n", current_index); snprintf(buf, SEC_CMD_BUF_SIZE, - "NG, Failed to Custom Library LP log, current_index=%d", - current_index); + "NG, Failed to Custom Library LP log, current_index=%d", + current_index); goto out; } input_info(true, &ts->client->dev, - "%s: DEBUG current_index = %d\n", __func__, current_index); + "%s: DEBUG current_index = %d\n", __func__, current_index); /* Custom Library has 62 stacks for LP dump */ for (i = 61; i >= 0; i--) { @@ -875,8 +886,8 @@ static ssize_t get_lp_dump(struct device *dev, struct device_attribute *attr, ch data3 = (string_data[7] & 0xFF) << 8 | (string_data[6] & 0xFF); if (data0 || data1 || data2 || data3) { snprintf(buff, sizeof(buff), - "%d: %04x%04x%04x%04x\n", - string_addr, data0, data1, data2, data3); + "%d: %04x%04x%04x%04x\n", + string_addr, data0, data1, data2, data3); strncat(buf, buff, SEC_CMD_BUF_SIZE); } } @@ -887,8 +898,8 @@ out: return strlen(buf); } -static ssize_t get_force_recal_count(struct device *dev, - struct device_attribute *attr, char *buf) +static ssize_t force_recal_count_show(struct device *dev, + struct device_attribute *attr, char *buf) { struct sec_cmd_data *sec = dev_get_drvdata(dev); struct sec_ts_data *ts = container_of(sec, struct sec_ts_data, sec); @@ -899,7 +910,8 @@ static ssize_t get_force_recal_count(struct device *dev, sec_ts_set_bus_ref(ts, SEC_TS_BUS_REF_SYSFS, true); if (ts->power_status == SEC_TS_STATE_POWER_OFF) { - input_err(true, &ts->client->dev, "%s: Touch is stopped!\n", __func__); + input_err(true, &ts->client->dev, + "%s: Touch is stopped!\n", __func__); sec_ts_set_bus_ref(ts, SEC_TS_BUS_REF_SYSFS, false); return snprintf(buf, SEC_CMD_BUF_SIZE, "%d", -ENODEV); } @@ -1002,7 +1014,7 @@ static ssize_t fw_version_show(struct device *dev, */ if (ts->plat_data->panel_revision == 0 && ts->plat_data->img_version_of_bin[2] == 0 && - ts->plat_data->img_version_of_bin[3] == 0 ) { + ts->plat_data->img_version_of_bin[3] == 0) { u8 fw_ver[4]; ret = ts->sec_ts_read(ts, SEC_TS_READ_IMG_VERSION, fw_ver, 4); @@ -1030,7 +1042,7 @@ static ssize_t fw_version_show(struct device *dev, } written += scnprintf(buf + written, PAGE_SIZE - written, - "Cal: %02X %02X %02X %02X %02X %02X %02X %02X \n", + "Cal: %02X %02X %02X %02X %02X %02X %02X %02X\n", ts->cali_report[0], ts->cali_report[1], ts->cali_report[2], ts->cali_report[3], ts->cali_report[4], ts->cali_report[5], ts->cali_report[6], ts->cali_report[7]); @@ -1089,8 +1101,8 @@ static ssize_t status_show(struct device *dev, ret = ts->sec_ts_read(ts, SEC_TS_CMD_SET_TOUCHFUNCTION, data, 2); if (ret < 0) { input_err(true, &ts->client->dev, - "%s: failed to read touch functions(%d)\n", - __func__, ret); + "%s: failed to read touch functions(%d)\n", + __func__, ret); goto out; } written += scnprintf(buf + written, PAGE_SIZE - written, @@ -1102,23 +1114,23 @@ out: return written; } -static DEVICE_ATTR(ito_check, S_IRUGO, read_ito_check_show, NULL); -static DEVICE_ATTR(raw_check, S_IRUGO, read_raw_check_show, NULL); -static DEVICE_ATTR(multi_count, S_IRUGO | S_IWUSR | S_IWGRP, read_multi_count_show, clear_multi_count_store); -static DEVICE_ATTR(wet_mode, S_IRUGO | S_IWUSR | S_IWGRP, read_wet_mode_show, clear_wet_mode_store); -static DEVICE_ATTR(comm_err_count, S_IRUGO | S_IWUSR | S_IWGRP, read_comm_err_count_show, clear_comm_err_count_store); -static DEVICE_ATTR(checksum, S_IRUGO | S_IWUSR | S_IWGRP, read_checksum_show, clear_checksum_store); -static DEVICE_ATTR(holding_time, S_IRUGO | S_IWUSR | S_IWGRP, read_holding_time_show, clear_holding_time_store); -static DEVICE_ATTR(all_touch_count, S_IRUGO | S_IWUSR | S_IWGRP, read_all_touch_count_show, clear_all_touch_count_store); -static DEVICE_ATTR(z_value, S_IRUGO | S_IWUSR | S_IWGRP, read_z_value_show, clear_z_value_store); -static DEVICE_ATTR(module_id, S_IRUGO, read_module_id_show, NULL); -static DEVICE_ATTR(vendor, S_IRUGO, read_vendor_show, NULL); -static DEVICE_ATTR(pressure_enable, S_IRUGO | S_IWUSR | S_IWGRP, pressure_enable_show, pressure_enable_strore); -static DEVICE_ATTR(get_lp_dump, S_IRUGO, get_lp_dump, NULL); -static DEVICE_ATTR(force_recal_count, S_IRUGO, get_force_recal_count, NULL); +static DEVICE_ATTR_RO(ito_check); +static DEVICE_ATTR_RO(raw_check); +static DEVICE_ATTR_RW(multi_count); +static DEVICE_ATTR_RW(wet_mode); +static DEVICE_ATTR_RW(comm_err_count); +static DEVICE_ATTR_RW(checksum); +static DEVICE_ATTR_RW(holding_time); +static DEVICE_ATTR_RW(all_touch_count); +static DEVICE_ATTR_RW(z_value); +static DEVICE_ATTR_RO(module_id); +static DEVICE_ATTR_RO(vendor); +static DEVICE_ATTR_RW(pressure_enable); +static DEVICE_ATTR_RO(get_lp_dump); +static DEVICE_ATTR_RO(force_recal_count); static DEVICE_ATTR_RW(heatmap_mode); -static DEVICE_ATTR(fw_version, 0444, fw_version_show, NULL); -static DEVICE_ATTR(status, 0444, status_show, NULL); +static DEVICE_ATTR_RO(fw_version); +static DEVICE_ATTR_RO(status); static struct attribute *cmd_attributes[] = { @@ -1159,8 +1171,9 @@ static int sec_ts_check_index(struct sec_ts_data *ts) snprintf(buff, sizeof(buff), "%s", "NG"); sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff))); sec->cmd_state = SEC_CMD_STATUS_FAIL; - input_info(true, &ts->client->dev, "%s: parameter error: %u, %u\n", - __func__, sec->cmd_param[0], sec->cmd_param[0]); + input_info(true, &ts->client->dev, + "%s: parameter error: %u, %u\n", + __func__, sec->cmd_param[0], sec->cmd_param[0]); node = -1; return node; } @@ -1180,8 +1193,8 @@ static void fw_update(void *device_data) sec_cmd_set_default_result(sec); if (ts->power_status == SEC_TS_STATE_POWER_OFF) { - input_err(true, &ts->client->dev, "%s: [ERROR] Touch is stopped\n", - __func__); + input_err(true, &ts->client->dev, + "%s: [ERROR] Touch is stopped\n", __func__); snprintf(buff, sizeof(buff), "%s", "TSP turned off"); sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff))); sec->cmd_state = SEC_CMD_STATUS_NOT_APPLICABLE; @@ -1195,12 +1208,14 @@ static void fw_update(void *device_data) snprintf(buff, sizeof(buff), "%s", "NA"); sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff))); sec->cmd_state = SEC_CMD_STATUS_FAIL; - input_err(true, &ts->client->dev, "%s: failed [%d]\n", __func__, retval); + input_err(true, &ts->client->dev, "%s: failed [%d]\n", + __func__, retval); } else { snprintf(buff, sizeof(buff), "%s", "OK"); sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff))); sec->cmd_state = SEC_CMD_STATUS_OK; - input_info(true, &ts->client->dev, "%s: success [%d]\n", __func__, retval); + input_info(true, &ts->client->dev, "%s: success [%d]\n", + __func__, retval); } sec_ts_set_bus_ref(ts, SEC_TS_BUS_REF_SYSFS, false); @@ -1218,7 +1233,8 @@ int sec_ts_fix_tmode(struct sec_ts_data *ts, u8 mode, u8 state) ret = ts->sec_ts_write(ts, SEC_TS_CMD_STATEMANAGE_ON, onoff, 1); sec_ts_delay(20); - ret = ts->sec_ts_write(ts, SEC_TS_CMD_CHG_SYSMODE, tBuff, sizeof(tBuff)); + ret = ts->sec_ts_write(ts, SEC_TS_CMD_CHG_SYSMODE, tBuff, + sizeof(tBuff)); sec_ts_delay(20); return ret; @@ -1591,10 +1607,12 @@ static void sec_ts_print_frame(struct sec_ts_data *ts, short *min, short *max) if (i > 0) { if (ts->pFrame[(j * ts->rx_count) + i] < *min) - *min = ts->pFrame[(j * ts->rx_count) + i]; + *min = ts->pFrame[(j * ts->rx_count) + + i]; if (ts->pFrame[(j * ts->rx_count) + i] > *max) - *max = ts->pFrame[(j * ts->rx_count) + i]; + *max = ts->pFrame[(j * ts->rx_count) + + i]; } } input_info(true, &ts->client->dev, "%s\n", pStr); @@ -1651,7 +1669,8 @@ static int sec_ts_read_frame(struct sec_ts_data *ts, u8 type, short *min, ret = ts->sec_ts_write(ts, SEC_TS_CMD_MUTU_RAW_TYPE, &w_type, 1); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: Set rawdata type failed\n", __func__); + input_err(true, &ts->client->dev, + "%s: Set rawdata type failed\n", __func__); goto ErrorExit; } ts->frame_type = w_type; @@ -1660,7 +1679,9 @@ static int sec_ts_read_frame(struct sec_ts_data *ts, u8 type, short *min, if (type == TYPE_OFFSET_DATA_SDC || type == TYPE_OFFSET_DATA_SDC_CM2 || type == TYPE_OFFSET_DATA_SDC_NOT_SAVE) { - /* excute selftest for real cap offset data, because real cap data is not memory data in normal touch. */ + /* excute selftest for real cap offset data, because real cap + * data is not memory data in normal touch. + **/ char para = TO_TOUCH_MODE; disable_irq(ts->client->irq); @@ -1707,8 +1728,9 @@ static int sec_ts_read_frame(struct sec_ts_data *ts, u8 type, short *min, ts->pFrame[i / 2] = pRead[i + 1] + (pRead[i] << 8); #ifdef DEBUG_MSG - input_info(true, &ts->client->dev, "%s: 02X%02X%02X readbytes=%d\n", __func__, - pRead[0], pRead[1], pRead[2], readbytes); + input_info(true, &ts->client->dev, + "%s: 02X%02X%02X readbytes=%d\n", __func__, + pRead[0], pRead[1], pRead[2], readbytes); #endif sec_ts_print_frame(ts, min, max); @@ -1721,7 +1743,8 @@ static int sec_ts_read_frame(struct sec_ts_data *ts, u8 type, short *min, for (i = 0; i < ts->tx_count; i++) { for (j = 0; j < ts->rx_count; j++) - ts->pFrame[(j * ts->tx_count) + i] = temp[(i * ts->rx_count) + j]; + ts->pFrame[(j * ts->tx_count) + i] = + temp[(i * ts->rx_count) + j]; } /* spec check */ @@ -1753,8 +1776,9 @@ static int sec_ts_read_frame(struct sec_ts_data *ts, u8 type, short *min, specover_count++; } } - input_info(true, &ts->client->dev, "%s: type = %d, specover = %d\n", - __func__, type, specover_count); + input_info(true, &ts->client->dev, + "%s: type = %d, specover = %d\n", + __func__, type, specover_count); if (specover_count == 0 && (max[REGION_NORMAL] - min[REGION_NORMAL] < @@ -1775,8 +1799,9 @@ static int sec_ts_read_frame(struct sec_ts_data *ts, u8 type, short *min, specover_count++; } } - input_info(true, &ts->client->dev, "%s: type = %d, specover = %d\n", - __func__, type, specover_count); + input_info(true, &ts->client->dev, + "%s: type = %d, specover = %d\n", + __func__, type, specover_count); if (specover_count == 0) *spec_check = SPEC_PASS; @@ -1791,8 +1816,9 @@ static int sec_ts_read_frame(struct sec_ts_data *ts, u8 type, short *min, specover_count++; } } - input_info(true, &ts->client->dev, "%s: type = %d, specover = %d\n", - __func__, type, specover_count); + input_info(true, &ts->client->dev, + "%s: type = %d, specover = %d\n", + __func__, type, specover_count); if (specover_count == 0) *spec_check = SPEC_PASS; @@ -1807,7 +1833,8 @@ ErrorRelease: /* release data monitory (unprepare AFE data memory) */ ret = ts->sec_ts_write(ts, SEC_TS_CMD_MUTU_RAW_TYPE, &mode, 1); if (ret < 0) - input_err(true, &ts->client->dev, "%s: Set rawdata type failed\n", __func__); + input_err(true, &ts->client->dev, + "%s: Set rawdata type failed\n", __func__); else ts->frame_type = mode; @@ -1920,8 +1947,11 @@ static int sec_ts_read_channel(struct sec_ts_data *ts, u8 type, short *min, if (type == TYPE_OFFSET_DATA_SDC || type == TYPE_OFFSET_DATA_SDC_NOT_SAVE) { - /* excute selftest for real cap offset data, because real cap data is not memory data in normal touch. */ + /* excute selftest for real cap offset data, because real cap + * data is not memory data in normal touch. + **/ char para = TO_TOUCH_MODE; + disable_irq(ts->client->irq); if (type == TYPE_OFFSET_DATA_SDC) execute_selftest(ts, TEST_SELF_NODE); @@ -1929,7 +1959,8 @@ static int sec_ts_read_channel(struct sec_ts_data *ts, u8 type, short *min, execute_selftest(ts, TEST_SELF_NODE | TEST_NOT_SAVE); ret = ts->sec_ts_write(ts, SEC_TS_CMD_SET_POWER_MODE, ¶, 1); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: set rawdata type failed!\n", __func__); + input_err(true, &ts->client->dev, + "%s: set rawdata type failed!\n", __func__); enable_irq(ts->client->irq); goto err_read_data; } @@ -1994,8 +2025,9 @@ static int sec_ts_read_channel(struct sec_ts_data *ts, u8 type, short *min, } } - input_info(true, &ts->client->dev, "%s: type : %d, specover = %d\n", - __func__, type, specover_count); + input_info(true, &ts->client->dev, + "%s: type : %d, specover = %d\n", + __func__, type, specover_count); if (specover_count == 0 && (max[0] - min[0]) < cs_tx_mm && @@ -2009,7 +2041,8 @@ err_read_data: /* release data monitory (unprepare AFE data memory) */ ret = ts->sec_ts_write(ts, SEC_TS_CMD_SELF_RAW_TYPE, &mode, 1); if (ret < 0) - input_err(true, &ts->client->dev, "%s: Set rawdata type failed\n", __func__); + input_err(true, &ts->client->dev, + "%s: Set rawdata type failed\n", __func__); out_read_channel: kfree(pRead); @@ -2214,7 +2247,8 @@ static void get_fw_ver_bin(void *device_data) sec_cmd_set_default_result(sec); snprintf(buff, sizeof(buff), "SE-V%02X.%02X.%02X", - ts->plat_data->panel_revision, ts->plat_data->img_version_of_bin[2], + ts->plat_data->panel_revision, + ts->plat_data->img_version_of_bin[2], ts->plat_data->img_version_of_bin[3]); sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff))); @@ -2235,8 +2269,8 @@ static void get_fw_ver_ic(void *device_data) sec_cmd_set_default_result(sec); if (ts->power_status == SEC_TS_STATE_POWER_OFF) { - input_err(true, &ts->client->dev, "%s: [ERROR] Touch is stopped\n", - __func__); + input_err(true, &ts->client->dev, + "%s: [ERROR] Touch is stopped\n", __func__); snprintf(buff, sizeof(buff), "%s", "TSP turned off"); sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff))); sec->cmd_state = SEC_CMD_STATUS_NOT_APPLICABLE; @@ -2246,7 +2280,8 @@ static void get_fw_ver_ic(void *device_data) ret = ts->sec_ts_read(ts, SEC_TS_READ_IMG_VERSION, fw_ver, 4); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: firmware version read error\n", __func__); + input_err(true, &ts->client->dev, + "%s: firmware version read error\n", __func__); snprintf(buff, sizeof(buff), "%s", "NG"); sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff))); sec->cmd_state = SEC_CMD_STATUS_FAIL; @@ -2274,7 +2309,8 @@ static void get_config_ver(void *device_data) snprintf(buff, sizeof(buff), "%s_SE_%02X%02X", ts->plat_data->model_name, - ts->plat_data->config_version_of_ic[2], ts->plat_data->config_version_of_ic[3]); + ts->plat_data->config_version_of_ic[2], + ts->plat_data->config_version_of_ic[3]); sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff))); sec->cmd_state = SEC_CMD_STATUS_OK; @@ -2329,21 +2365,26 @@ static void get_threshold(void *device_data) sec_cmd_set_default_result(sec); if (ts->power_status == SEC_TS_STATE_POWER_OFF) { - input_err(true, &ts->client->dev, "%s: [ERROR] Touch is stopped\n", __func__); + input_err(true, &ts->client->dev, + "%s: [ERROR] Touch is stopped\n", __func__); snprintf(buff, sizeof(buff), "%s", "TSP turned off"); goto err; } - ret = ts->sec_ts_write(ts, SEC_TS_CMD_TOUCH_MODE_FOR_THRESHOLD, threshold, 1); + ret = ts->sec_ts_write(ts, SEC_TS_CMD_TOUCH_MODE_FOR_THRESHOLD, + threshold, 1); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: threshold write type failed. ret: %d\n", __func__, ret); + input_err(true, &ts->client->dev, + "%s: threshold write type failed. ret: %d\n", + __func__, ret); snprintf(buff, sizeof(buff), "%s", "NG"); goto err; } ret = ts->sec_ts_read(ts, SEC_TS_CMD_TOUCH_THRESHOLD, threshold, 2); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: read threshold fail!\n", __func__); + input_err(true, &ts->client->dev, + "%s: read threshold fail!\n", __func__); snprintf(buff, sizeof(buff), "%s", "NG"); goto err; } @@ -2364,7 +2405,6 @@ err: sec->cmd_state = SEC_CMD_STATUS_NOT_APPLICABLE; sec_ts_set_bus_ref(ts, SEC_TS_BUS_REF_SYSFS, false); - return; } static void module_off_master(void *device_data) @@ -2405,12 +2445,12 @@ static void module_on_master(void *device_data) ret = sec_ts_start_device(ts); -#if 0 //TODO: check this for SPI case - if (ts->input_dev->disabled) { - sec_ts_set_lowpowermode(ts, TO_LOWPOWER_MODE); - ts->power_status = SEC_TS_STATE_LPM; - } -#endif +/* TODO: check this for SPI case + * if (ts->input_dev->disabled) { + * sec_ts_set_lowpowermode(ts, TO_LOWPOWER_MODE); + * ts->power_status = SEC_TS_STATE_LPM; + * } + **/ if (ret == 0) snprintf(buff, sizeof(buff), "%s", "OK"); @@ -2477,10 +2517,12 @@ static void set_mis_cal_spec(void *device_data) sec_cmd_set_default_result(sec); if (ts->plat_data->mis_cal_check == 0) { - input_err(true, &ts->client->dev, "%s: [ERROR] not support, %d\n", __func__); + input_err(true, &ts->client->dev, + "%s: [ERROR] not support, %d\n", __func__); goto NG; } else if (ts->power_status == SEC_TS_STATE_POWER_OFF) { - input_err(true, &ts->client->dev, "%s: [ERROR] Touch is stopped\n", __func__); + input_err(true, &ts->client->dev, + "%s: [ERROR] Touch is stopped\n", __func__); goto NG; } else { if ((sec->cmd_param[0] < 0 || sec->cmd_param[0] > 255) || @@ -2493,12 +2535,17 @@ static void set_mis_cal_spec(void *device_data) wreg[1] = sec->cmd_param[1]; wreg[2] = sec->cmd_param[2]; - ret = ts->sec_ts_write(ts, SEC_TS_CMD_MIS_CAL_SPEC, wreg, 3); + ret = ts->sec_ts_write(ts, SEC_TS_CMD_MIS_CAL_SPEC, + wreg, 3); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: nvm write failed. ret: %d\n", __func__, ret); + input_err(true, &ts->client->dev, + "%s: nvm write failed. ret: %d\n", + __func__, ret); goto NG; } else { - input_info(true, &ts->client->dev, "%s: tx gap=%d, rx gap=%d, peak=%d\n", __func__, wreg[0], wreg[1], wreg[2]); + input_info(true, &ts->client->dev, + "%s: tx gap=%d, rx gap=%d, peak=%d\n", + __func__, wreg[0], wreg[1], wreg[2]); sec_ts_delay(20); } } @@ -2532,11 +2579,13 @@ NG: * F1 : not support mis cal concept * F0 : initial value in fucntion * 08 : Ambient Ambient condition check(PEAK) result 0 (PASS), 1(FAIL) - * 04 : Ambient Ambient condition check(DIFF MAX TX) result 0 (PASS), 1(FAIL) - * 02 : Ambient Ambient condition check(DIFF MAX RX) result 0 (PASS), 1(FAIL) + * 04 : Ambient Ambient condition check(DIFF MAX TX) + * result 0 (PASS), 1(FAIL) + * 02 : Ambient Ambient condition check(DIFF MAX RX) + * result 0 (PASS), 1(FAIL) * 01 : Wet Wet mode result 0 (PASS), 1(FAIL) * 00 : Pass - */ + **/ static void get_mis_cal_info(void *device_data) { struct sec_cmd_data *sec = (struct sec_cmd_data *)device_data; @@ -2551,35 +2600,44 @@ static void get_mis_cal_info(void *device_data) sec_cmd_set_default_result(sec); if (ts->plat_data->mis_cal_check == 0) { - input_err(true, &ts->client->dev, "%s: [ERROR] not support, %d\n", __func__); + input_err(true, &ts->client->dev, + "%s: [ERROR] not support, %d\n", __func__); mis_cal_data = 0xF1; goto NG; } else if (ts->power_status == SEC_TS_STATE_POWER_OFF) { - input_err(true, &ts->client->dev, "%s: [ERROR] Touch is stopped\n", __func__); + input_err(true, &ts->client->dev, + "%s: [ERROR] Touch is stopped\n", __func__); mis_cal_data = 0xF2; goto NG; } else { - ret = ts->sec_ts_read(ts, SEC_TS_CMD_MIS_CAL_READ, &mis_cal_data, 1); + ret = ts->sec_ts_read(ts, SEC_TS_CMD_MIS_CAL_READ, + &mis_cal_data, 1); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: fail!, %d\n", __func__, ret); + input_err(true, &ts->client->dev, + "%s: fail!, %d\n", __func__, ret); mis_cal_data = 0xF3; goto NG; } else { - input_info(true, &ts->client->dev, "%s: miss cal data : %d\n", __func__, mis_cal_data); + input_info(true, &ts->client->dev, + "%s: miss cal data : %d\n", + __func__, mis_cal_data); } ret = ts->sec_ts_read(ts, SEC_TS_CMD_MIS_CAL_SPEC, wreg, 3); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: fail!, %d\n", __func__, ret); + input_err(true, &ts->client->dev, + "%s: fail!, %d\n", __func__, ret); mis_cal_data = 0xF4; goto NG; } else { - input_info(true, &ts->client->dev, "%s: miss cal spec : %d,%d,%d\n", __func__, + input_info(true, &ts->client->dev, + "%s: miss cal spec : %d,%d,%d\n", __func__, wreg[0], wreg[1], wreg[2]); } } - snprintf(buff, sizeof(buff), "%d,%d,%d,%d", mis_cal_data, wreg[0], wreg[1], wreg[2]); + snprintf(buff, sizeof(buff), "%d,%d,%d,%d", + mis_cal_data, wreg[0], wreg[1], wreg[2]); sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff))); sec->cmd_state = SEC_CMD_STATUS_OK; @@ -2609,7 +2667,8 @@ static void get_wet_mode(void *device_data) ret = ts->sec_ts_read(ts, SEC_TS_CMD_WET_MODE, &wet_mode_info, 1); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: fail!, %d\n", __func__, ret); + input_err(true, &ts->client->dev, + "%s: fail!, %d\n", __func__, ret); goto NG; } @@ -2703,7 +2762,8 @@ static void get_checksum_data(void *device_data) sec_cmd_set_default_result(sec); if (ts->power_status == SEC_TS_STATE_POWER_OFF) { - input_err(true, &ts->client->dev, "%s: [ERROR] Touch is stopped\n", __func__); + input_err(true, &ts->client->dev, + "%s: [ERROR] Touch is stopped\n", __func__); snprintf(buff, sizeof(buff), "%s", "TSP turned off"); goto err; } @@ -2711,7 +2771,8 @@ static void get_checksum_data(void *device_data) temp = DO_FW_CHECKSUM | DO_PARA_CHECKSUM; ret = ts->sec_ts_write(ts, SEC_TS_CMD_GET_CHECKSUM, &temp, 1); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: send get_checksum_cmd fail!\n", __func__); + input_err(true, &ts->client->dev, + "%s: send get_checksum_cmd fail!\n", __func__); snprintf(buff, sizeof(buff), "%s", "SendCMDfail"); goto err; } @@ -2723,8 +2784,9 @@ static void get_checksum_data(void *device_data) #else ret = ts->sec_ts_read(ts, SEC_TS_CMD_GET_CHECKSUM, csum_result, 4); #endif - if (ret < 0) { - input_err(true, &ts->client->dev, "%s: read get_checksum result fail!\n", __func__); + if (ret < 0) { + input_err(true, &ts->client->dev, + "%s: read get_checksum result fail!\n", __func__); snprintf(buff, sizeof(buff), "%s", "ReadCSUMfail"); goto err; } @@ -2742,7 +2804,8 @@ static void get_checksum_data(void *device_data) csum = ~csum; - input_info(true, &ts->client->dev, "%s: checksum = %02X\n", __func__, csum); + input_info(true, &ts->client->dev, + "%s: checksum = %02X\n", __func__, csum); snprintf(buff, sizeof(buff), "%02X", csum); sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff))); sec->cmd_state = SEC_CMD_STATUS_OK; @@ -2806,8 +2869,8 @@ static void get_reference(void *device_data) sec_cmd_set_default_result(sec); if (ts->power_status == SEC_TS_STATE_POWER_OFF) { - input_err(true, &ts->client->dev, "%s: [ERROR] Touch is stopped\n", - __func__); + input_err(true, &ts->client->dev, + "%s: [ERROR] Touch is stopped\n", __func__); snprintf(buff, sizeof(buff), "%s", "TSP turned off"); sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff))); sec->cmd_state = SEC_CMD_STATUS_NOT_APPLICABLE; @@ -2882,8 +2945,8 @@ static void get_rawcap(void *device_data) sec_cmd_set_default_result(sec); if (ts->power_status == SEC_TS_STATE_POWER_OFF) { - input_err(true, &ts->client->dev, "%s: [ERROR] Touch is stopped\n", - __func__); + input_err(true, &ts->client->dev, + "%s: [ERROR] Touch is stopped\n", __func__); snprintf(buff, sizeof(buff), "%s", "TSP turned off"); sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff))); sec->cmd_state = SEC_CMD_STATUS_NOT_APPLICABLE; @@ -3052,8 +3115,8 @@ static void get_delta(void *device_data) sec_cmd_set_default_result(sec); if (ts->power_status == SEC_TS_STATE_POWER_OFF) { - input_err(true, &ts->client->dev, "%s: [ERROR] Touch is stopped\n", - __func__); + input_err(true, &ts->client->dev, + "%s: [ERROR] Touch is stopped\n", __func__); snprintf(buff, sizeof(buff), "%s", "TSP turned off"); sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff))); sec->cmd_state = SEC_CMD_STATUS_NOT_APPLICABLE; @@ -3322,8 +3385,9 @@ ErrorDataType: /* release mode fix */ ret = sec_ts_release_tmode(ts); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: failed to release tmode\n", - __func__); + input_err(true, + &ts->client->dev, "%s: failed to release tmode\n", + __func__); } ErrorAlloc: @@ -3684,7 +3748,8 @@ void set_tsp_nvm_data_clear(struct sec_ts_data *ts, u8 offset) ret = ts->sec_ts_write(ts, SEC_TS_CMD_NVM, buff, 3); if (ret < 0) - input_err(true, &ts->client->dev, "%s: nvm write failed. ret: %d\n", __func__, ret); + input_err(true, &ts->client->dev, + "%s: nvm write failed. ret: %d\n", __func__, ret); sec_ts_delay(20); } @@ -3697,7 +3762,8 @@ int get_tsp_nvm_data(struct sec_ts_data *ts, u8 offset) /* SENSE OFF -> CELAR EVENT STACK -> READ NV -> SENSE ON */ ret = ts->sec_ts_write(ts, SEC_TS_CMD_SENSE_OFF, NULL, 0); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: fail to write Sense_off\n", __func__); + input_err(true, &ts->client->dev, + "%s: fail to write Sense_off\n", __func__); goto out_nvm; } @@ -3707,7 +3773,8 @@ int get_tsp_nvm_data(struct sec_ts_data *ts, u8 offset) ret = ts->sec_ts_write(ts, SEC_TS_CMD_CLEAR_EVENT_STACK, NULL, 0); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: write clear event failed\n", __func__); + input_err(true, &ts->client->dev, + "%s: write clear event failed\n", __func__); goto out_nvm; } @@ -3720,13 +3787,16 @@ int get_tsp_nvm_data(struct sec_ts_data *ts, u8 offset) /* send NV data using command * Use TSP NV area : in this model, use only one byte * buff[0] : offset from user NVM storage - * buff[1] : length of stroed data - 1 (ex. using 1byte, value is 1 - 1 = 0) - */ + * buff[1] : length of stroed data - 1 (ex. using 1byte, + * value is 1 - 1 = 0) + **/ memset(buff, 0x00, 2); buff[0] = offset; ret = ts->sec_ts_write(ts, SEC_TS_CMD_NVM, buff, 2); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: nvm send command failed. ret: %d\n", __func__, ret); + input_err(true, &ts->client->dev, + "%s: nvm send command failed. ret: %d\n", + __func__, ret); goto out_nvm; } @@ -3741,23 +3811,28 @@ int get_tsp_nvm_data(struct sec_ts_data *ts, u8 offset) ret = ts->sec_ts_read(ts, SEC_TS_CMD_NVM, buff, 1); #endif if (ret < 0) { - input_err(true, &ts->client->dev, "%s: nvm send command failed. ret: %d\n", __func__, ret); + input_err(true, &ts->client->dev, + "%s: nvm send command failed. ret: %d\n", + __func__, ret); goto out_nvm; } - input_info(true, &ts->client->dev, "%s: offset:%u data:%02X\n", __func__,offset, buff[0]); + input_info(true, &ts->client->dev, + "%s: offset:%u data:%02X\n", __func__, offset, buff[0]); out_nvm: ret = ts->sec_ts_write(ts, SEC_TS_CMD_SENSE_ON, NULL, 0); if (ret < 0) - input_err(true, &ts->client->dev, "%s: fail to write Sense_on\n", __func__); + input_err(true, &ts->client->dev, + "%s: fail to write Sense_on\n", __func__); input_dbg(true, &ts->client->dev, "%s: SENSE ON\n", __func__); return buff[0]; } -int get_tsp_nvm_data_by_size(struct sec_ts_data *ts, u8 offset, int length, u8 *data) +int get_tsp_nvm_data_by_size(struct sec_ts_data *ts, u8 offset, + int length, u8 *data) { char *buff = NULL; int ret; @@ -3766,12 +3841,15 @@ int get_tsp_nvm_data_by_size(struct sec_ts_data *ts, u8 offset, int length, u8 * if (!buff) return -ENOMEM; - input_info(true, &ts->client->dev, "%s: offset:%u, length:%d, size:%d\n", __func__, offset, length, sizeof(data)); + input_info(true, &ts->client->dev, + "%s: offset:%u, length:%d, size:%d\n", + __func__, offset, length, sizeof(data)); /* SENSE OFF -> CELAR EVENT STACK -> READ NV -> SENSE ON */ ret = ts->sec_ts_write(ts, SEC_TS_CMD_SENSE_OFF, NULL, 0); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: fail to write Sense_off\n", __func__); + input_err(true, &ts->client->dev, + "%s: fail to write Sense_off\n", __func__); goto out_nvm; } @@ -3781,7 +3859,8 @@ int get_tsp_nvm_data_by_size(struct sec_ts_data *ts, u8 offset, int length, u8 * ret = ts->sec_ts_write(ts, SEC_TS_CMD_CLEAR_EVENT_STACK, NULL, 0); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: write clear event failed\n", __func__); + input_err(true, &ts->client->dev, + "%s: write clear event failed\n", __func__); goto out_nvm; } @@ -3794,14 +3873,17 @@ int get_tsp_nvm_data_by_size(struct sec_ts_data *ts, u8 offset, int length, u8 * /* send NV data using command * Use TSP NV area : in this model, use only one byte * buff[0] : offset from user NVM storage - * buff[1] : length of stroed data - 1 (ex. using 1byte, value is 1 - 1 = 0) - */ + * buff[1] : length of stroed data - 1 (ex. using 1byte, + * value is 1 - 1 = 0) + **/ memset(buff, 0x00, 2); buff[0] = offset; buff[1] = length - 1; ret = ts->sec_ts_write(ts, SEC_TS_CMD_NVM, buff, 2); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: nvm send command failed. ret: %d\n", __func__, ret); + input_err(true, &ts->client->dev, + "%s: nvm send command failed. ret: %d\n", + __func__, ret); goto out_nvm; } @@ -3815,8 +3897,10 @@ int get_tsp_nvm_data_by_size(struct sec_ts_data *ts, u8 offset, int length, u8 * #else ret = ts->sec_ts_read(ts, SEC_TS_CMD_NVM, buff, length); #endif - if (ret < 0) { - input_err(true, &ts->client->dev, "%s: nvm send command failed. ret: %d\n", __func__, ret); + if (ret < 0) { + input_err(true, &ts->client->dev, + "%s: nvm send command failed. ret: %d\n", + __func__, ret); goto out_nvm; } @@ -3825,7 +3909,8 @@ int get_tsp_nvm_data_by_size(struct sec_ts_data *ts, u8 offset, int length, u8 * out_nvm: ret = ts->sec_ts_write(ts, SEC_TS_CMD_SENSE_ON, NULL, 0); if (ret < 0) - input_err(true, &ts->client->dev, "%s: fail to write Sense_on\n", __func__); + input_err(true, &ts->client->dev, + "%s: fail to write Sense_on\n", __func__); input_dbg(true, &ts->client->dev, "%s: SENSE ON\n", __func__); @@ -3891,8 +3976,8 @@ static void set_tsp_test_result(void *device_data) sec_cmd_set_default_result(sec); if (ts->power_status == SEC_TS_STATE_POWER_OFF) { - input_err(true, &ts->client->dev, "%s: [ERROR] Touch is stopped\n", - __func__); + input_err(true, &ts->client->dev, + "%s: [ERROR] Touch is stopped\n", __func__); snprintf(buff, sizeof(buff), "%s", "TSP_truned off"); sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff))); sec->cmd_state = SEC_CMD_STATUS_NOT_APPLICABLE; @@ -3918,24 +4003,27 @@ static void set_tsp_test_result(void *device_data) result->module_count++; } - input_info(true, &ts->client->dev, "%s: %d, %d, %d, %d, 0x%X\n", __func__, - result->module_result, result->module_count, - result->assy_result, result->assy_count, result->data[0]); + input_info(true, &ts->client->dev, + "%s: %d, %d, %d, %d, 0x%X\n", __func__, + result->module_result, result->module_count, + result->assy_result, result->assy_count, result->data[0]); /* Use TSP NV area : in this model, use only one byte * buff[0] : offset from user NVM storage - * buff[1] : length of stroed data - 1 (ex. using 1byte, value is 1 - 1 = 0) + * buff[1] : length of stroed data - 1 (ex. using 1byte, + * value is 1 - 1 = 0) * buff[2] : write data - */ + **/ memset(buff, 0x00, SEC_CMD_STR_LEN); buff[2] = *result->data; input_info(true, &ts->client->dev, "%s: command (1)%X, (2)%X: %X\n", - __func__, sec->cmd_param[0], sec->cmd_param[1], buff[2]); + __func__, sec->cmd_param[0], sec->cmd_param[1], buff[2]); ret = ts->sec_ts_write(ts, SEC_TS_CMD_NVM, buff, 3); if (ret < 0) - input_err(true, &ts->client->dev, "%s: nvm write failed. ret: %d\n", __func__, ret); + input_err(true, &ts->client->dev, + "%s: nvm write failed. ret: %d\n", __func__, ret); sec_ts_delay(20); @@ -3983,16 +4071,19 @@ static void get_tsp_test_result(void *device_data) result = (struct sec_ts_test_result *)buff; - input_info(true, &ts->client->dev, "%s: [0x%X][0x%X] M:%d, M:%d, A:%d, A:%d\n", + input_info(true, &ts->client->dev, + "%s: [0x%X][0x%X] M:%d, M:%d, A:%d, A:%d\n", __func__, *result->data, buff[0], result->module_result, result->module_count, result->assy_result, result->assy_count); snprintf(buff, sizeof(buff), "M:%s, M:%d, A:%s, A:%d", result->module_result == 0 ? "NONE" : - result->module_result == 1 ? "FAIL" : "PASS", result->module_count, + result->module_result == 1 ? "FAIL" : "PASS", + result->module_count, result->assy_result == 0 ? "NONE" : - result->assy_result == 1 ? "FAIL" : "PASS", result->assy_count); + result->assy_result == 1 ? "FAIL" : "PASS", + result->assy_count); sec_cmd_set_cmd_result(sec, buff, strlen(buff)); sec->cmd_state = SEC_CMD_STATUS_OK; @@ -4014,8 +4105,8 @@ static void increase_disassemble_count(void *device_data) sec_cmd_set_default_result(sec); if (ts->power_status == SEC_TS_STATE_POWER_OFF) { - input_err(true, &ts->client->dev, "%s: [ERROR] Touch is stopped\n", - __func__); + input_err(true, &ts->client->dev, + "%s: [ERROR] Touch is stopped\n", __func__); snprintf(buff, sizeof(buff), "%s", "TSP_truned off"); sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff))); sec->cmd_state = SEC_CMD_STATUS_NOT_APPLICABLE; @@ -4026,7 +4117,8 @@ static void increase_disassemble_count(void *device_data) buff[2] = get_tsp_nvm_data(ts, SEC_TS_NVM_OFFSET_DISASSEMBLE_COUNT); - input_info(true, &ts->client->dev, "%s: disassemble count is #1 %d\n", __func__, buff[2]); + input_info(true, &ts->client->dev, + "%s: disassemble count is #1 %d\n", __func__, buff[2]); if (buff[2] == 0xFF) buff[2] = 0; @@ -4036,21 +4128,24 @@ static void increase_disassemble_count(void *device_data) /* Use TSP NV area : in this model, use only one byte * buff[0] : offset from user NVM storage - * buff[1] : length of stroed data - 1 (ex. using 1byte, value is 1 - 1 = 0) + * buff[1] : length of stroed data - 1 (ex. using 1byte, + * value is 1 - 1 = 0) * buff[2] : write data - */ + **/ buff[0] = SEC_TS_NVM_OFFSET_DISASSEMBLE_COUNT; buff[1] = 0; ret = ts->sec_ts_write(ts, SEC_TS_CMD_NVM, buff, 3); if (ret < 0) - input_err(true, &ts->client->dev, "%s: nvm write failed. ret: %d\n", __func__, ret); + input_err(true, &ts->client->dev, + "%s: nvm write failed. ret: %d\n", __func__, ret); sec_ts_delay(20); memset(buff, 0x00, 3); buff[0] = get_tsp_nvm_data(ts, SEC_TS_NVM_OFFSET_DISASSEMBLE_COUNT); - input_info(true, &ts->client->dev, "%s: check disassemble count: %d\n", __func__, buff[0]); + input_info(true, &ts->client->dev, + "%s: check disassemble count: %d\n", __func__, buff[0]); snprintf(buff, sizeof(buff), "OK"); sec_cmd_set_cmd_result(sec, buff, strlen(buff)); @@ -4072,8 +4167,8 @@ static void get_disassemble_count(void *device_data) sec_cmd_set_default_result(sec); if (ts->power_status == SEC_TS_STATE_POWER_OFF) { - input_err(true, &ts->client->dev, "%s: [ERROR] Touch is stopped\n", - __func__); + input_err(true, &ts->client->dev, + "%s: [ERROR] Touch is stopped\n", __func__); snprintf(buff, sizeof(buff), "%s", "TSP_truned off"); sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff))); sec->cmd_state = SEC_CMD_STATUS_NOT_APPLICABLE; @@ -4089,7 +4184,8 @@ static void get_disassemble_count(void *device_data) buff[0] = 0; } - input_info(true, &ts->client->dev, "%s: read disassemble count: %d\n", __func__, buff[0]); + input_info(true, &ts->client->dev, + "%s: read disassemble count: %d\n", __func__, buff[0]); snprintf(buff, sizeof(buff), "%d", buff[0]); @@ -4127,7 +4223,8 @@ static void glove_mode(void *device_data) retval = sec_ts_glove_mode_enables(ts, glove_mode_enables); if (retval < 0) { - input_err(true, &ts->client->dev, "%s: failed, retval = %d\n", __func__, retval); + input_err(true, &ts->client->dev, + "%s: failed, retval = %d\n", __func__, retval); snprintf(buff, sizeof(buff), "NG"); sec->cmd_state = SEC_CMD_STATUS_FAIL; } else { @@ -4149,7 +4246,8 @@ static void clear_cover_mode(void *device_data) struct sec_ts_data *ts = container_of(sec, struct sec_ts_data, sec); char buff[SEC_CMD_STR_LEN] = { 0 }; - input_info(true, &ts->client->dev, "%s: start clear_cover_mode %s\n", __func__, buff); + input_info(true, &ts->client->dev, + "%s...\n", __func__, buff); sec_ts_set_bus_ref(ts, SEC_TS_BUS_REF_SYSFS, true); @@ -4167,7 +4265,8 @@ static void clear_cover_mode(void *device_data) ts->flip_enable = false; } - if (!(ts->power_status == SEC_TS_STATE_POWER_OFF) && ts->reinit_done) { + if (!(ts->power_status == SEC_TS_STATE_POWER_OFF) && + ts->reinit_done) { if (ts->flip_enable) sec_ts_set_cover_type(ts, true); else @@ -4206,7 +4305,7 @@ static void dead_zone_enable(void *device_data) ret = ts->sec_ts_write(ts, SEC_TS_CMD_EDGE_DEADZONE, &data, 1); if (ret < 0) { input_err(true, &ts->client->dev, - "%s: failed to set deadzone\n", __func__); + "%s: failed to set deadzone\n", __func__); snprintf(buff, sizeof(buff), "%s", "NG"); sec->cmd_state = SEC_CMD_STATUS_FAIL; goto err_set_dead_zone; @@ -4241,9 +4340,11 @@ static void drawing_test_enable(void *device_data) } else { if (ts->use_customlib) { if (sec->cmd_param[0]) - ts->lowpower_mode &= ~SEC_TS_MODE_CUSTOMLIB_FORCE_KEY; + ts->lowpower_mode &= + ~SEC_TS_MODE_CUSTOMLIB_FORCE_KEY; else - ts->lowpower_mode |= SEC_TS_MODE_CUSTOMLIB_FORCE_KEY; + ts->lowpower_mode |= + SEC_TS_MODE_CUSTOMLIB_FORCE_KEY; #ifdef SEC_TS_SUPPORT_CUSTOMLIB ret = sec_ts_set_custom_library(ts); @@ -4281,7 +4382,7 @@ static void rearrange_sft_result(u8 *data, int length) { int i; - for(i = 0; i < length; i += 4) { + for (i = 0; i < length; i += 4) { sec_ts_swap(&data[i], &data[i + 3]); sec_ts_swap(&data[i + 1], &data[i + 2]); } @@ -4349,7 +4450,8 @@ int execute_selftest(struct sec_ts_data *ts, u32 option) u8 tpara[2] = {(u8)(option & 0xff), (u8)((option & 0xff00) >> 8)}; u8 *rBuff; int i; - int result_size = SEC_TS_SELFTEST_REPORT_SIZE + ts->tx_count * ts->rx_count * 2; + int result_size = SEC_TS_SELFTEST_REPORT_SIZE + + ts->tx_count * ts->rx_count * 2; rBuff = kzalloc(result_size, GFP_KERNEL); if (!rBuff) @@ -4358,7 +4460,8 @@ int execute_selftest(struct sec_ts_data *ts, u32 option) input_info(true, &ts->client->dev, "%s: Self test start!\n", __func__); rc = ts->sec_ts_write(ts, SEC_TS_CMD_SELFTEST, tpara, 2); if (rc < 0) { - input_err(true, &ts->client->dev, "%s: Send selftest cmd failed!\n", __func__); + input_err(true, &ts->client->dev, + "%s: Send selftest cmd failed!\n", __func__); goto err_exit; } @@ -4366,7 +4469,8 @@ int execute_selftest(struct sec_ts_data *ts, u32 option) rc = sec_ts_wait_for_ready(ts, SEC_TS_VENDOR_ACK_SELF_TEST_DONE); if (rc < 0) { - input_err(true, &ts->client->dev, "%s: Selftest execution time out!\n", __func__); + input_err(true, &ts->client->dev, + "%s: Selftest execution time out!\n", __func__); goto err_exit; } @@ -4375,7 +4479,8 @@ int execute_selftest(struct sec_ts_data *ts, u32 option) rc = ts->sec_ts_read_heap(ts, SEC_TS_READ_SELFTEST_RESULT, rBuff, result_size); if (rc < 0) { - input_err(true, &ts->client->dev, "%s: Selftest execution time out!\n", __func__); + input_err(true, &ts->client->dev, + "%s: Selftest execution time out!\n", __func__); goto err_exit; } rearrange_sft_result(rBuff, result_size); @@ -4405,7 +4510,8 @@ int execute_selftest(struct sec_ts_data *ts, u32 option) else if (i / 4 == 18) pr_cont("RXT"); else if (i / 4 == 19) pr_cont("TXR"); - pr_cont(" %2X, %2X, %2X, %2X ", rBuff[i], rBuff[i + 1], rBuff[i + 2], rBuff[i + 3]); + pr_cont(" %2X, %2X, %2X, %2X ", + rBuff[i], rBuff[i + 1], rBuff[i + 2], rBuff[i + 3]); if (i / 4 == 4) { @@ -4971,7 +5077,8 @@ static void run_trx_short_test(void *device_data) sec_cmd_set_default_result(sec); if (ts->power_status == SEC_TS_STATE_POWER_OFF) { - input_err(true, &ts->client->dev, "%s: Touch is stopped!\n", __func__); + input_err(true, &ts->client->dev, + "%s: Touch is stopped!\n", __func__); snprintf(buff, sizeof(buff), "%s", "TSP turned off"); sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff))); sec->cmd_state = SEC_CMD_STATUS_NOT_APPLICABLE; @@ -5025,7 +5132,8 @@ int sec_ts_execute_force_calibration(struct sec_ts_data *ts, int cal_mode) return rc; if (ts->sec_ts_write(ts, cmd, NULL, 0) < 0) { - input_err(true, &ts->client->dev, "%s: Write Cal commend failed!\n", __func__); + input_err(true, &ts->client->dev, + "%s: Write Cal commend failed!\n", __func__); return rc; } @@ -5053,7 +5161,8 @@ static void run_force_calibration(void *device_data) sec_cmd_set_default_result(sec); if (ts->power_status == SEC_TS_STATE_POWER_OFF) { - input_err(true, &ts->client->dev, "%s: Touch is stopped!\n", __func__); + input_err(true, &ts->client->dev, + "%s: Touch is stopped!\n", __func__); snprintf(buff, sizeof(buff), "%s", "TSP turned off"); sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff))); sec->cmd_state = SEC_CMD_STATUS_NOT_APPLICABLE; @@ -5080,50 +5189,65 @@ static void run_force_calibration(void *device_data) #ifdef USE_PRESSURE_SENSOR rc = sec_ts_execute_force_calibration(ts, PRESSURE_CAL); if (rc < 0) - input_err(true, &ts->client->dev, "%s: fail to write PRESSURE CAL!\n", __func__); + input_err(true, &ts->client->dev, + "%s: fail to write PRESSURE CAL!\n", __func__); #endif if (ts->plat_data->mis_cal_check) { buff[0] = 0; - rc = ts->sec_ts_write(ts, SEC_TS_CMD_STATEMANAGE_ON, buff, 1); + rc = ts->sec_ts_write(ts, SEC_TS_CMD_STATEMANAGE_ON, + buff, 1); if (rc < 0) { input_err(true, &ts->client->dev, - "%s: mis_cal_check error[1] ret: %d\n", __func__, rc); + "%s: mis_cal_check error[1] ret: %d\n", + __func__, rc); } buff[0] = 0x2; buff[1] = 0x2; - rc = ts->sec_ts_write(ts, SEC_TS_CMD_CHG_SYSMODE, buff, 2); + rc = ts->sec_ts_write(ts, SEC_TS_CMD_CHG_SYSMODE, + buff, 2); if (rc < 0) { input_err(true, &ts->client->dev, - "%s: mis_cal_check error[2] ret: %d\n", __func__, rc); + "%s: mis_cal_check error[2] ret: %d\n", + __func__, rc); } - input_err(true, &ts->client->dev, "%s: try mis Cal. check\n", __func__); - rc = ts->sec_ts_write(ts, SEC_TS_CMD_MIS_CAL_CHECK, NULL, 0); + input_err(true, &ts->client->dev, + "%s: try mis Cal. check\n", __func__); + rc = ts->sec_ts_write(ts, SEC_TS_CMD_MIS_CAL_CHECK, + NULL, 0); if (rc < 0) { input_err(true, &ts->client->dev, - "%s: mis_cal_check error[3] ret: %d\n", __func__, rc); + "%s: mis_cal_check error[3] ret: %d\n", + __func__, rc); } sec_ts_delay(200); - rc = ts->sec_ts_read(ts, SEC_TS_CMD_MIS_CAL_READ, &mis_cal_data, 1); + rc = ts->sec_ts_read(ts, SEC_TS_CMD_MIS_CAL_READ, + &mis_cal_data, 1); if (rc < 0) { - input_err(true, &ts->client->dev, "%s: fail!, %d\n", __func__, rc); + input_err(true, &ts->client->dev, + "%s: fail!, %d\n", __func__, rc); mis_cal_data = 0xF3; } else { - input_info(true, &ts->client->dev, "%s: miss cal data : %d\n", __func__, mis_cal_data); + input_info(true, &ts->client->dev, + "%s: miss cal data : %d\n", + __func__, mis_cal_data); } buff[0] = 1; - rc = ts->sec_ts_write(ts, SEC_TS_CMD_STATEMANAGE_ON, buff, 1); + rc = ts->sec_ts_write(ts, SEC_TS_CMD_STATEMANAGE_ON, + buff, 1); if (rc < 0) { input_err(true, &ts->client->dev, - "%s: mis_cal_check error[4] ret: %d\n", __func__, rc); + "%s: mis_cal_check error[4] ret: %d\n", + __func__, rc); } - if (mis_cal_data) { - memset(&mode, 0x00, sizeof(struct sec_ts_test_mode)); + if (mis_cal_data) { + memset(&mode, 0x00, + sizeof(struct sec_ts_test_mode)); mode.type = TYPE_AMBIENT_DATA; mode.allnode = TEST_MODE_ALL_NODE; @@ -5138,21 +5262,27 @@ static void run_force_calibration(void *device_data) } #ifdef PAT_CONTROL - ts->cal_count = get_tsp_nvm_data(ts, SEC_TS_NVM_OFFSET_CAL_COUNT); + ts->cal_count = get_tsp_nvm_data(ts, + SEC_TS_NVM_OFFSET_CAL_COUNT); - if(ts->external_factory == true) { + if (ts->external_factory == true) { /* for external factory mode */ if (ts->cal_count == PAT_MAX_EXT) ts->cal_count = PAT_MAX_EXT; - else if (PAT_EXT_FACT <= ts->cal_count && ts->cal_count < PAT_MAX_EXT) + else if (ts->cal_count >= PAT_EXT_FACT && + ts->cal_count < PAT_MAX_EXT) ts->cal_count++; else ts->cal_count = PAT_EXT_FACT; - /* not to enter external factory mode without setting everytime */ + /* not to enter external factory mode without setting + * everytime + **/ ts->external_factory = false; } else { - /*change from ( virtual pat or vpat by external fatory ) to real pat by forced calibarion by LCIA */ + /* change from (virtual pat or vpat by external fatory) + * to real pat by forced calibarion by LCIA + **/ if (ts->cal_count >= PAT_MAGIC_NUMBER) ts->cal_count = 1; else if (ts->cal_count == PAT_MAX_LCIA) @@ -5163,34 +5293,42 @@ static void run_force_calibration(void *device_data) /* Use TSP NV area : in this model, use only one byte * buff[0] : offset from user NVM storage - * buff[1] : length of stroed data - 1 (ex. using 1byte, value is 1 - 1 = 0) + * buff[1] : length of stroed data - 1 (ex. using 1byte, + value is 1 - 1 = 0) * buff[2] : write data - */ + **/ buff[0] = SEC_TS_NVM_OFFSET_CAL_COUNT; buff[1] = 0; buff[2] = ts->cal_count; - input_info(true, &ts->client->dev, "%s: write to nvm cal_count(%2X)\n", - __func__, buff[2]); + input_info(true, &ts->client->dev, + "%s: write to nvm cal_count(%2X)\n", + __func__, buff[2]); rc = ts->sec_ts_write(ts, SEC_TS_CMD_NVM, buff, 3); if (rc < 0) { input_err(true, &ts->client->dev, - "%s: nvm write failed. ret: %d\n", __func__, rc); + "%s: nvm write failed. ret: %d\n", + __func__, rc); } sec_ts_delay(20); - ts->cal_count = get_tsp_nvm_data(ts, SEC_TS_NVM_OFFSET_CAL_COUNT); + ts->cal_count = get_tsp_nvm_data(ts, + SEC_TS_NVM_OFFSET_CAL_COUNT); rc = ts->sec_ts_read(ts, SEC_TS_READ_IMG_VERSION, img_ver, 4); if (rc < 0) { - input_err(true, &ts->client->dev, "%s: Image version read error\n", __func__); + input_err(true, &ts->client->dev, + "%s: Image version read error\n", __func__); } else { memset(buff, 0x00, SEC_CMD_STR_LEN); - buff[0] = get_tsp_nvm_data(ts, SEC_TS_NVM_OFFSET_TUNE_VERSION); + buff[0] = get_tsp_nvm_data(ts, + SEC_TS_NVM_OFFSET_TUNE_VERSION); if (buff[0] == 0xFF) { - set_tsp_nvm_data_clear(ts, SEC_TS_NVM_OFFSET_TUNE_VERSION); - set_tsp_nvm_data_clear(ts, SEC_TS_NVM_OFFSET_TUNE_VERSION+1); + set_tsp_nvm_data_clear(ts, + SEC_TS_NVM_OFFSET_TUNE_VERSION); + set_tsp_nvm_data_clear(ts, + SEC_TS_NVM_OFFSET_TUNE_VERSION + 1); } ts->tune_fix_ver = (img_ver[2]<<8 | img_ver[3]); @@ -5198,20 +5336,26 @@ static void run_force_calibration(void *device_data) buff[1] = 1;// 2bytes buff[2] = img_ver[2]; buff[3] = img_ver[3]; - input_info(true, &ts->client->dev, "%s: write tune_ver to nvm (%2X %2X)\n", __func__, buff[2], buff[3]); + input_info(true, &ts->client->dev, + "%s: write tune_ver to nvm (%2X %2X)\n", + __func__, buff[2], buff[3]); rc = ts->sec_ts_write(ts, SEC_TS_CMD_NVM, buff, 4); if (rc < 0) { input_err(true, &ts->client->dev, - "%s: nvm write failed. ret: %d\n", __func__, rc); + "%s: nvm write failed. ret: %d\n", + __func__, rc); } sec_ts_delay(20); - buff[0] = get_tsp_nvm_data(ts, SEC_TS_NVM_OFFSET_TUNE_VERSION); - buff[1] = get_tsp_nvm_data(ts, SEC_TS_NVM_OFFSET_TUNE_VERSION+1); + buff[0] = get_tsp_nvm_data(ts, + SEC_TS_NVM_OFFSET_TUNE_VERSION); + buff[1] = get_tsp_nvm_data(ts, + SEC_TS_NVM_OFFSET_TUNE_VERSION + 1); ts->tune_fix_ver = buff[0]<<8 | buff[1]; input_info(true, &ts->client->dev, - "%s: cal_count [%2X] tune_fix_ver [%04X]\n", __func__, ts->cal_count, ts->tune_fix_ver); + "%s: cal_count [%2X] tune_fix_ver [%04X]\n", + __func__, ts->cal_count, ts->tune_fix_ver); } #endif snprintf(buff, sizeof(buff), "%s", "OK"); @@ -5241,7 +5385,8 @@ static void get_force_calibration(void *device_data) sec_cmd_set_default_result(sec); if (ts->power_status == SEC_TS_STATE_POWER_OFF) { - input_err(true, &ts->client->dev, "%s: Touch is stopped!\n", __func__); + input_err(true, &ts->client->dev, "%s: Touch is stopped!\n", + __func__); written += scnprintf(buff + written, buff_len - written, "%s", "TSP turned off"); sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff))); @@ -5295,7 +5440,8 @@ static void run_force_pressure_calibration(void *device_data) sec_cmd_set_default_result(sec); if (ts->power_status == SEC_TS_STATE_POWER_OFF) { - input_err(true, &ts->client->dev, "%s: Touch is stopped!\n", __func__); + input_err(true, &ts->client->dev, "%s: Touch is stopped!\n", + __func__); snprintf(buff, sizeof(buff), "%s", "TSP turned off"); sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff))); sec->cmd_state = SEC_CMD_STATUS_NOT_APPLICABLE; @@ -5321,7 +5467,8 @@ static void run_force_pressure_calibration(void *device_data) sec->cmd_state = SEC_CMD_STATUS_OK; } - ts->pressure_cal_base = get_tsp_nvm_data(ts, SEC_TS_NVM_OFFSET_PRESSURE_BASE_CAL_COUNT); + ts->pressure_cal_base = get_tsp_nvm_data(ts, + SEC_TS_NVM_OFFSET_PRESSURE_BASE_CAL_COUNT); if (ts->pressure_cal_base == 0xFF) ts->pressure_cal_base = 0; if (ts->pressure_cal_base > 0xFD) @@ -5329,9 +5476,10 @@ static void run_force_pressure_calibration(void *device_data) /* Use TSP NV area : in this model, use only one byte * data[0] : offset from user NVM storage - * data[1] : length of stroed data - 1 (ex. using 1byte, value is 1 - 1 = 0) + * data[1] : length of stroed data - 1 (ex. using 1byte, + * value is 1 - 1 = 0) * data[2] : write data - */ + **/ data[0] = SEC_TS_NVM_OFFSET_PRESSURE_BASE_CAL_COUNT; data[1] = 0; data[2] = ts->pressure_cal_base + 1; @@ -5341,9 +5489,11 @@ static void run_force_pressure_calibration(void *device_data) input_err(true, &ts->client->dev, "%s: nvm write failed. ret: %d\n", __func__, rc); - ts->pressure_cal_base = get_tsp_nvm_data(ts, SEC_TS_NVM_OFFSET_PRESSURE_BASE_CAL_COUNT); + ts->pressure_cal_base = get_tsp_nvm_data(ts, + SEC_TS_NVM_OFFSET_PRESSURE_BASE_CAL_COUNT); - input_info(true, &ts->client->dev, "%s: count:%d\n", __func__, ts->pressure_cal_base); + input_info(true, &ts->client->dev, "%s: count:%d\n", + __func__, ts->pressure_cal_base); enable_irq(ts->client->irq); @@ -5368,7 +5518,8 @@ static void set_pressure_test_mode(void *device_data) sec_cmd_set_default_result(sec); if (ts->power_status == SEC_TS_STATE_POWER_OFF) { - input_err(true, &ts->client->dev, "%s: Touch is stopped!\n", __func__); + input_err(true, &ts->client->dev, "%s: Touch is stopped!\n", + __func__); snprintf(buff, sizeof(buff), "%s", "TSP turned off"); sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff))); sec->cmd_state = SEC_CMD_STATUS_NOT_APPLICABLE; @@ -5379,14 +5530,16 @@ static void set_pressure_test_mode(void *device_data) if (sec->cmd_param[0] == 1) { enable = 0x1; - ret = ts->sec_ts_write(ts, SEC_TS_CMD_SET_TEMPERATURE_COMP_MODE, &enable, 1); + ret = ts->sec_ts_write(ts, SEC_TS_CMD_SET_TEMPERATURE_COMP_MODE, + &enable, 1); if (ret < 0) { snprintf(buff, sizeof(buff), "%s", "NG"); sec->cmd_state = SEC_CMD_STATUS_FAIL; goto out_test_mode; } - ret = sec_ts_fix_tmode(ts, TOUCH_SYSTEM_MODE_TOUCH, TOUCH_MODE_STATE_TOUCH); + ret = sec_ts_fix_tmode(ts, TOUCH_SYSTEM_MODE_TOUCH, + TOUCH_MODE_STATE_TOUCH); if (ret < 0) { snprintf(buff, sizeof(buff), "%s", "NG"); sec->cmd_state = SEC_CMD_STATUS_FAIL; @@ -5394,7 +5547,8 @@ static void set_pressure_test_mode(void *device_data) } } else { - ret = ts->sec_ts_write(ts, SEC_TS_CMD_SELECT_PRESSURE_TYPE, &data, 1); + ret = ts->sec_ts_write(ts, SEC_TS_CMD_SELECT_PRESSURE_TYPE, + &data, 1); if (ret < 0) { snprintf(buff, sizeof(buff), "%s", "NG"); sec->cmd_state = SEC_CMD_STATUS_FAIL; @@ -5409,7 +5563,8 @@ static void set_pressure_test_mode(void *device_data) } enable = 0x0; - ret = ts->sec_ts_write(ts, SEC_TS_CMD_SET_TEMPERATURE_COMP_MODE, &enable, 1); + ret = ts->sec_ts_write(ts, SEC_TS_CMD_SET_TEMPERATURE_COMP_MODE, + &enable, 1); if (ret < 0) { snprintf(buff, sizeof(buff), "%s", "NG"); sec->cmd_state = SEC_CMD_STATUS_FAIL; @@ -5441,11 +5596,13 @@ static int read_pressure_data(struct sec_ts_data *ts, u8 type, short *value) return -EIO; if (data[0] != type) { - input_info(true, &ts->client->dev, "%s: type change to %02X\n", __func__, type); + input_info(true, &ts->client->dev, "%s: type change to %02X\n", + __func__, type); data[1] = type; - ret = ts->sec_ts_write(ts, SEC_TS_CMD_SELECT_PRESSURE_TYPE, &data[1], 1); + ret = ts->sec_ts_write(ts, SEC_TS_CMD_SELECT_PRESSURE_TYPE, + &data[1], 1); if (ret < 0) return -EIO; @@ -5462,8 +5619,9 @@ static int read_pressure_data(struct sec_ts_data *ts, u8 type, short *value) pressure[1] = (data[2] << 8 | data[3]); pressure[2] = (data[4] << 8 | data[5]); - input_info(true, &ts->client->dev, "%s: Left: %d, Center: %d, Rignt: %d\n", - __func__, pressure[2], pressure[1], pressure[0]); + input_info(true, &ts->client->dev, + "%s: Left: %d, Center: %d, Rignt: %d\n", + __func__, pressure[2], pressure[1], pressure[0]); memcpy(value, pressure, 3 * 2); @@ -5488,7 +5646,8 @@ static void run_pressure_filtered_strength_read_all(void *device_data) goto error_read_str; } - snprintf(buff, sizeof(buff), "%d,%d,%d", pressure[2], pressure[1], pressure[0]); + snprintf(buff, sizeof(buff), "%d,%d,%d", + pressure[2], pressure[1], pressure[0]); sec->cmd_state = SEC_CMD_STATUS_OK; @@ -5523,7 +5682,8 @@ static void run_pressure_strength_read_all(void *device_data) goto error_read_str; } - snprintf(buff, sizeof(buff), "%d,%d,%d", pressure[2], pressure[1], pressure[0]); + snprintf(buff, sizeof(buff), "%d,%d,%d", + pressure[2], pressure[1], pressure[0]); sec->cmd_state = SEC_CMD_STATUS_OK; @@ -5558,7 +5718,8 @@ static void run_pressure_rawdata_read_all(void *device_data) goto error_read_rawdata; } - snprintf(buff, sizeof(buff), "%d,%d,%d", pressure[2], pressure[1], pressure[0]); + snprintf(buff, sizeof(buff), "%d,%d,%d", + pressure[2], pressure[1], pressure[0]); sec->cmd_state = SEC_CMD_STATUS_OK; @@ -5593,7 +5754,8 @@ static void run_pressure_offset_read_all(void *device_data) goto error_read_str; } - snprintf(buff, sizeof(buff), "%d,%d,%d", pressure[2], pressure[1], pressure[0]); + snprintf(buff, sizeof(buff), "%d,%d,%d", + pressure[2], pressure[1], pressure[0]); sec->cmd_state = SEC_CMD_STATUS_OK; @@ -5642,7 +5804,8 @@ static void set_pressure_strength(void *device_data) ret = ts->sec_ts_write(ts, SEC_TS_CMD_SET_GET_PRESSURE, cal_data, 18); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: cmd write failed. ret: %d\n", __func__, ret); + input_err(true, &ts->client->dev, + "%s: cmd write failed. ret: %d\n", __func__, ret); goto err_comm_str; } @@ -5651,7 +5814,8 @@ static void set_pressure_strength(void *device_data) memset(cal_data, 0x00, 18); ret = ts->sec_ts_read(ts, SEC_TS_CMD_SET_GET_PRESSURE, cal_data, 18); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: cmd write failed. ret: %d\n", __func__, ret); + input_err(true, &ts->client->dev, + "%s: cmd write failed. ret: %d\n", __func__, ret); goto err_comm_str; } @@ -5659,14 +5823,17 @@ static void set_pressure_strength(void *device_data) pressure[1] = ((cal_data[8] << 8) | cal_data[9]); pressure[2] = ((cal_data[0] << 8) | cal_data[1]); - input_info(true, &ts->client->dev, "%s: [%d] : %d, %d, %d\n", __func__, pressure[0], pressure[1], pressure[2]); + input_info(true, &ts->client->dev, "%s: [%d] : %d, %d, %d\n", + __func__, pressure[0], pressure[1], pressure[2]); /* Use TSP NV area : in this model, use only one byte * buff[0] : offset from user NVM storage - * buff[1] : [n] length of stroed data - 1 (ex. using 1byte, value is 1 - 1 = 0) + * buff[1] : [n] length of stroed data - 1 (ex. using 1byte, + * value is 1 - 1 = 0) * buff[2] ... [n] : write data ... - */ - data[0] = SEC_TS_NVM_OFFSET_PRESSURE_STRENGTH + (index * SEC_TS_NVM_SIZE_PRESSURE_BLOCK); + **/ + data[0] = SEC_TS_NVM_OFFSET_PRESSURE_STRENGTH + + (index * SEC_TS_NVM_SIZE_PRESSURE_BLOCK); data[1] = SEC_TS_NVM_SIZE_PRESSURE_BLOCK - 1; /* RIGHT */ data[2] = (sec->cmd_param[3] >> 8); @@ -5680,14 +5847,18 @@ static void set_pressure_strength(void *device_data) ret = ts->sec_ts_write(ts, SEC_TS_CMD_NVM, data, 8); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: nvm write failed. ret: %d\n", __func__, ret); + input_err(true, &ts->client->dev, + "%s: nvm write failed. ret: %d\n", __func__, ret); goto err_comm_str; } sec_ts_delay(20); input_info(true, &ts->client->dev, "%s: [%d] : %d, %d, %d\n", - __func__, index, (data[6] << 8) + data[7], (data[4] << 8) + data[5], (data[0] << 8) + data[1]); + __func__, index, + (data[6] << 8) + data[7], + (data[4] << 8) + data[5], + (data[0] << 8) + data[1]); memset(data, 0x00, 8); @@ -5697,7 +5868,8 @@ static void set_pressure_strength(void *device_data) ret = ts->sec_ts_write(ts, SEC_TS_CMD_NVM, data, 3); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: nvm write failed. ret: %d\n", __func__, ret); + input_err(true, &ts->client->dev, + "%s: nvm write failed. ret: %d\n", __func__, ret); goto err_comm_str; } @@ -5708,7 +5880,8 @@ static void set_pressure_strength(void *device_data) sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff))); sec->cmd_state = SEC_CMD_STATUS_OK; - ts->pressure_cal_delta = get_tsp_nvm_data(ts, SEC_TS_NVM_OFFSET_PRESSURE_DELTA_CAL_COUNT); + ts->pressure_cal_delta = get_tsp_nvm_data(ts, + SEC_TS_NVM_OFFSET_PRESSURE_DELTA_CAL_COUNT); if (ts->pressure_cal_delta == 0xFF) ts->pressure_cal_delta = 0; @@ -5717,21 +5890,24 @@ static void set_pressure_strength(void *device_data) /* Use TSP NV area : in this model, use only one byte * data[0] : offset from user NVM storage - * data[1] : length of stroed data - 1 (ex. using 1byte, value is 1 - 1 = 0) + * data[1] : length of stroed data - 1 (ex. using 1byte, + * value is 1 - 1 = 0) * data[2] : write data - */ + **/ data[0] = SEC_TS_NVM_OFFSET_PRESSURE_DELTA_CAL_COUNT; data[1] = 0; data[2] = ts->pressure_cal_delta + 1; - - ret= ts->sec_ts_write(ts, SEC_TS_CMD_NVM, data, 3); + + ret = ts->sec_ts_write(ts, SEC_TS_CMD_NVM, data, 3); if (ret < 0) input_err(true, &ts->client->dev, "%s: nvm write failed. ret: %d\n", __func__, ret); - ts->pressure_cal_delta = get_tsp_nvm_data(ts, SEC_TS_NVM_OFFSET_PRESSURE_DELTA_CAL_COUNT); + ts->pressure_cal_delta = get_tsp_nvm_data(ts, + SEC_TS_NVM_OFFSET_PRESSURE_DELTA_CAL_COUNT); - input_info(true, &ts->client->dev, "%s: count:%d\n", __func__, ts->pressure_cal_delta); + input_info(true, &ts->client->dev, + "%s: count:%d\n", __func__, ts->pressure_cal_delta); sec_ts_set_bus_ref(ts, SEC_TS_BUS_REF_SYSFS, false); return; @@ -5767,10 +5943,12 @@ static void set_pressure_rawdata(void *device_data) /* Use TSP NV area : in this model, use only one byte * buff[0] : offset from user NVM storage - * buff[1] : [n] length of stroed data - 1 (ex. using 1byte, value is 1 - 1 = 0) + * buff[1] : [n] length of stroed data - 1 (ex. using 1byte, + * value is 1 - 1 = 0) * buff[2] ... [n] : write data ... - */ - data[0] = SEC_TS_NVM_OFFSET_PRESSURE_RAWDATA + (index * SEC_TS_NVM_SIZE_PRESSURE_BLOCK); + **/ + data[0] = SEC_TS_NVM_OFFSET_PRESSURE_RAWDATA + + (index * SEC_TS_NVM_SIZE_PRESSURE_BLOCK); data[1] = SEC_TS_NVM_SIZE_PRESSURE_BLOCK - 1; data[2] = (sec->cmd_param[3] >> 8); data[3] = (sec->cmd_param[3] & 0xFF); @@ -5781,16 +5959,20 @@ static void set_pressure_rawdata(void *device_data) ret = ts->sec_ts_write(ts, SEC_TS_CMD_NVM, data, 8); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: nvm write failed. ret: %d\n", __func__, ret); + input_err(true, &ts->client->dev, + "%s: nvm write failed. ret: %d\n", __func__, ret); goto err_comm_raw; } sec_ts_delay(20); memset(data, 0x00, 8); - ret = get_tsp_nvm_data_by_size(ts, SEC_TS_NVM_OFFSET_PRESSURE_RAWDATA + (index * SEC_TS_NVM_SIZE_PRESSURE_BLOCK), SEC_TS_NVM_SIZE_PRESSURE_BLOCK, data); + ret = get_tsp_nvm_data_by_size(ts, SEC_TS_NVM_OFFSET_PRESSURE_RAWDATA + + (index * SEC_TS_NVM_SIZE_PRESSURE_BLOCK), + SEC_TS_NVM_SIZE_PRESSURE_BLOCK, data); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: nvm read failed. ret: %d\n", __func__, ret); + input_err(true, &ts->client->dev, + "%s: nvm read failed. ret: %d\n", __func__, ret); goto err_comm_raw; } @@ -5800,7 +5982,10 @@ static void set_pressure_rawdata(void *device_data) sec->cmd_state = SEC_CMD_STATUS_OK; input_info(true, &ts->client->dev, "%s: [%d] : %d, %d, %d\n", - __func__, index, (data[4] << 8) + data[5], (data[2] << 8) + data[3], (data[1] << 8) + data[0]); + __func__, index, + (data[4] << 8) + data[5], + (data[2] << 8) + data[3], + (data[1] << 8) + data[0]); sec_ts_set_bus_ref(ts, SEC_TS_BUS_REF_SYSFS, false); return; @@ -5835,14 +6020,18 @@ static void set_pressure_data_index(void *device_data) goto err_set_cmd_param_index; if (sec->cmd_param[0] == 0) { - input_info(true, &ts->client->dev, "%s: clear calibration result\n", __func__); + input_info(true, &ts->client->dev, + "%s: clear calibration result\n", __func__); /* clear pressure calibrated data */ - ret = ts->sec_ts_write(ts, SEC_TS_CMD_SET_GET_PRESSURE, cal_data, 18); + ret = ts->sec_ts_write(ts, SEC_TS_CMD_SET_GET_PRESSURE, + cal_data, 18); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: cmd write failed. ret: %d\n", __func__, ret); + input_err(true, &ts->client->dev, + "%s: cmd write failed. ret: %d\n", + __func__, ret); goto err_set_comm_index; } - + sec_ts_delay(30); goto clear_index; @@ -5850,9 +6039,11 @@ static void set_pressure_data_index(void *device_data) index = sec->cmd_param[0] - 1; - ret = get_tsp_nvm_data_by_size(ts, SEC_TS_NVM_OFFSET_PRESSURE_STRENGTH, 24, data); + ret = get_tsp_nvm_data_by_size(ts, SEC_TS_NVM_OFFSET_PRESSURE_STRENGTH, + 24, data); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: nvm read failed. ret: %d\n", __func__, ret); + input_err(true, &ts->client->dev, + "%s: nvm read failed. ret: %d\n", __func__, ret); goto err_set_comm_index; } @@ -5867,7 +6058,8 @@ static void set_pressure_data_index(void *device_data) ret = ts->sec_ts_write(ts, SEC_TS_CMD_SET_GET_PRESSURE, cal_data, 18); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: cmd write failed. ret: %d\n", __func__, ret); + input_err(true, &ts->client->dev, + "%s: cmd write failed. ret: %d\n", __func__, ret); goto err_set_comm_index; } @@ -5875,9 +6067,10 @@ static void set_pressure_data_index(void *device_data) /* Use TSP NV area : in this model, use only one byte * buff[0] : offset from user NVM storage - * buff[1] : length of stroed data - 1 (ex. using 1byte, value is 1 - 1 = 0) + * buff[1] : length of stroed data - 1 (ex. using 1byte, + * value is 1 - 1 = 0) * buff[2] : write data - */ + **/ memset(data, 0x00, 8); data[0] = SEC_TS_NVM_OFFSET_PRESSURE_INDEX; data[1] = 0; @@ -5885,7 +6078,8 @@ static void set_pressure_data_index(void *device_data) ret = ts->sec_ts_write(ts, SEC_TS_CMD_NVM, data, 3); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: nvm write failed. ret: %d\n", __func__, ret); + input_err(true, &ts->client->dev, + "%s: nvm write failed. ret: %d\n", __func__, ret); goto err_set_comm_index; } @@ -5932,9 +6126,11 @@ static void get_pressure_strength(void *device_data) index = sec->cmd_param[0] - 1; - ret = get_tsp_nvm_data_by_size(ts, SEC_TS_NVM_OFFSET_PRESSURE_STRENGTH, 24, data); + ret = get_tsp_nvm_data_by_size(ts, SEC_TS_NVM_OFFSET_PRESSURE_STRENGTH, + 24, data); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: nvm read failed. ret: %d\n", __func__, ret); + input_err(true, &ts->client->dev, + "%s: nvm read failed. ret: %d\n", __func__, ret); goto err_get_comm_str; } @@ -5942,7 +6138,8 @@ static void get_pressure_strength(void *device_data) pressure[1] = ((data[6 * index + 2] << 8) + data[6 * index + 3]); pressure[2] = ((data[6 * index + 0] << 8) + data[6 * index + 1]); - snprintf(buff, sizeof(buff), "%d,%d,%d", pressure[0], pressure[1], pressure[2]); + snprintf(buff, sizeof(buff), "%d,%d,%d", + pressure[0], pressure[1], pressure[2]); sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff))); sec->cmd_state = SEC_CMD_STATUS_OK; @@ -5984,9 +6181,11 @@ static void get_pressure_rawdata(void *device_data) index = sec->cmd_param[0] - 1; - ret = get_tsp_nvm_data_by_size(ts, SEC_TS_NVM_OFFSET_PRESSURE_RAWDATA, 24, data); + ret = get_tsp_nvm_data_by_size(ts, SEC_TS_NVM_OFFSET_PRESSURE_RAWDATA, + 24, data); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: nvm read failed. ret: %d\n", __func__, ret); + input_err(true, &ts->client->dev, + "%s: nvm read failed. ret: %d\n", __func__, ret); goto err_get_comm_raw; } @@ -5994,7 +6193,8 @@ static void get_pressure_rawdata(void *device_data) pressure[1] = ((data[6 * index + 2] << 8) + data[6 * index + 3]); pressure[2] = ((data[6 * index + 0] << 8) + data[6 * index + 1]); - snprintf(buff, sizeof(buff), "%d,%d,%d", pressure[0], pressure[1], pressure[2]); + snprintf(buff, sizeof(buff), "%d,%d,%d", + pressure[0], pressure[1], pressure[2]); sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff))); sec->cmd_state = SEC_CMD_STATUS_OK; @@ -6053,7 +6253,6 @@ err_get_index: sec->cmd_state = SEC_CMD_STATUS_FAIL; sec_ts_set_bus_ref(ts, SEC_TS_BUS_REF_SYSFS, false); - return; } static void set_pressure_strength_clear(void *device_data) { @@ -6071,7 +6270,8 @@ static void set_pressure_strength_clear(void *device_data) /* clear pressure calibrated data */ ret = ts->sec_ts_write(ts, SEC_TS_CMD_SET_GET_PRESSURE, cal_data, 18); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: cmd write failed. ret: %d\n", __func__, ret); + input_err(true, &ts->client->dev, + "%s: cmd write failed. ret: %d\n", __func__, ret); goto err_comm_str; } @@ -6079,14 +6279,17 @@ static void set_pressure_strength_clear(void *device_data) /* Use TSP NV area : in this model, use only one byte * buff[0] : offset from user NVM storage - * buff[1] : length of stroed data - 1 (ex. using 1byte, value is 1 - 1 = 0) + * buff[1] : length of stroed data - 1 (ex. using 1byte, + * value is 1 - 1 = 0) * buff[2] : write data - */ + **/ /* strength 6 * 4, rawdata 6 * 4, buff[0], buff[1] */ data = kzalloc(50, GFP_KERNEL); if (!data) { - input_err(true, &ts->client->dev, "%s failed to allocate memory. ret: %d\n", __func__, ret); + input_err(true, &ts->client->dev, + "%s failed to allocate memory. ret: %d\n", + __func__, ret); goto err_comm_str; } @@ -6096,7 +6299,8 @@ static void set_pressure_strength_clear(void *device_data) /* remove calicated strength, rawdata in NVM */ ret = ts->sec_ts_write(ts, SEC_TS_CMD_NVM, data, 50); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: nvm write failed. ret: %d\n", __func__, ret); + input_err(true, &ts->client->dev, + "%s: nvm write failed. ret: %d\n", __func__, ret); goto err_mem_str; } @@ -6150,7 +6354,8 @@ static void set_pressure_user_level(void *device_data) sec_cmd_set_default_result(sec); if (ts->power_status == SEC_TS_STATE_POWER_OFF) { - input_err(true, &ts->client->dev, "%s: Touch is stopped!\n", __func__); + input_err(true, &ts->client->dev, "%s: Touch is stopped!\n", + __func__); snprintf(buff, sizeof(buff), "%s", "TSP turned off"); sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff))); sec->cmd_state = SEC_CMD_STATUS_NOT_APPLICABLE; @@ -6167,7 +6372,7 @@ static void set_pressure_user_level(void *device_data) * byte[1]: m_customlib_ifpacket_addr[15:8] * byte[n] : user data (max 32 bytes) */ - addr[0] = SEC_TS_CMD_CUSTOMLIB_OFFSET_PRESSURE_LEVEL; + addr[0] = SEC_TS_CMD_CUSTOMLIB_OFFSET_PRESSURE_LEVEL; addr[1] = 0x00; addr[2] = sec->cmd_param[0]; @@ -6187,7 +6392,8 @@ static void set_pressure_user_level(void *device_data) if (ret < 0) goto out_set_user_level; - input_info(true, &ts->client->dev, "%s: set user level: %d\n", __func__, data[0]); + input_info(true, &ts->client->dev, "%s: set user level: %d\n", + __func__, data[0]); ts->pressure_user_level = data[0]; @@ -6200,7 +6406,8 @@ static void set_pressure_user_level(void *device_data) if (ret < 0) goto out_set_user_level; - input_info(true, &ts->client->dev, "%s: HIGH THD: %d\n", __func__, data[0]); + input_info(true, &ts->client->dev, "%s: HIGH THD: %d\n", + __func__, data[0]); addr[0] = SEC_TS_CMD_CUSTOMLIB_OFFSET_PRESSURE_THD_LOW; @@ -6212,7 +6419,8 @@ static void set_pressure_user_level(void *device_data) if (ret < 0) goto out_set_user_level; - input_info(true, &ts->client->dev, "%s: LOW THD: %d\n", __func__, data[0]); + input_info(true, &ts->client->dev, "%s: LOW THD: %d\n", + __func__, data[0]); snprintf(buff, sizeof(buff), "%s", "OK"); @@ -6245,7 +6453,7 @@ static void get_pressure_user_level(void *device_data) sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff))); - addr[0] = SEC_TS_CMD_CUSTOMLIB_OFFSET_PRESSURE_LEVEL; + addr[0] = SEC_TS_CMD_CUSTOMLIB_OFFSET_PRESSURE_LEVEL; addr[1] = 0x00; ret = ts->sec_ts_write(ts, SEC_TS_CMD_CUSTOMLIB_READ_PARAM, addr, 2); @@ -6256,7 +6464,8 @@ static void get_pressure_user_level(void *device_data) if (ret < 0) goto out_get_user_level; - input_err(true, &ts->client->dev, "%s: set user level: %d\n", __func__, data[0]); + input_err(true, &ts->client->dev, "%s: set user level: %d\n", + __func__, data[0]); ts->pressure_user_level = data[0]; snprintf(buff, sizeof(buff), "%s", "OK"); @@ -6293,8 +6502,8 @@ static void set_lowpower_mode(void *device_data) } /* set lowpower mode by spay, edge_swipe function. - ts->lowpower_mode = sec->cmd_param[0]; -*/ + * ts->lowpower_mode = sec->cmd_param[0]; + **/ sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff))); sec_cmd_set_cmd_exit(sec); @@ -6327,26 +6536,34 @@ static void set_wirelesscharger_mode(void *device_data) } if (ts->power_status == SEC_TS_STATE_POWER_OFF) { - input_err(true, &ts->client->dev, "%s: fail to enable w-charger status, POWER_STATUS=OFF\n", __func__); + input_err(true, &ts->client->dev, + "%s: fail to enable w-charger status, POWER_STATUS=OFF\n", + __func__); goto NG; } if (sec->cmd_param[0] == 1) - ts->charger_mode = ts->charger_mode | SEC_TS_BIT_CHARGER_MODE_WIRELESS_CHARGER; + ts->charger_mode = ts->charger_mode | + SEC_TS_BIT_CHARGER_MODE_WIRELESS_CHARGER; else if (sec->cmd_param[0] == 3) - ts->charger_mode = ts->charger_mode | SEC_TS_BIT_CHARGER_MODE_WIRELESS_BATTERY_PACK; + ts->charger_mode = ts->charger_mode | + SEC_TS_BIT_CHARGER_MODE_WIRELESS_BATTERY_PACK; else if (mode == false) - ts->charger_mode = ts->charger_mode & (~SEC_TS_BIT_CHARGER_MODE_WIRELESS_CHARGER) & (~SEC_TS_BIT_CHARGER_MODE_WIRELESS_BATTERY_PACK); + ts->charger_mode = ts->charger_mode & + (~SEC_TS_BIT_CHARGER_MODE_WIRELESS_CHARGER) & + (~SEC_TS_BIT_CHARGER_MODE_WIRELESS_BATTERY_PACK); w_data[0] = ts->charger_mode; ret = ts->sec_ts_write(ts, SET_TS_CMD_SET_CHARGER_MODE, w_data, 1); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: Failed to send command 74\n", __func__); + input_err(true, &ts->client->dev, + "%s: Failed to send command 74\n", __func__); goto NG; } input_err(true, &ts->client->dev, "%s: %s, status =%x\n", - __func__, (mode) ? "wireless enable" : "wireless disable", ts->charger_mode); + __func__, (mode) ? "wireless enable" : "wireless disable", + ts->charger_mode); snprintf(buff, sizeof(buff), "%s", "OK"); sec->cmd_state = SEC_CMD_STATUS_OK; @@ -6358,7 +6575,8 @@ static void set_wirelesscharger_mode(void *device_data) NG: input_err(true, &ts->client->dev, "%s: %s, status =%x\n", - __func__, (mode) ? "wireless enable" : "wireless disable", ts->charger_mode); + __func__, (mode) ? "wireless enable" : "wireless disable", + ts->charger_mode); OUT: snprintf(buff, sizeof(buff), "%s", "NG"); @@ -6390,7 +6608,8 @@ static void spay_enable(void *device_data) ts->lowpower_mode &= ~SEC_TS_MODE_CUSTOMLIB_SPAY; } - input_info(true, &ts->client->dev, "%s: %02X\n", __func__, ts->lowpower_mode); + input_info(true, &ts->client->dev, + "%s: %02X\n", __func__, ts->lowpower_mode); #ifdef SEC_TS_SUPPORT_CUSTOMLIB if (ts->use_customlib) @@ -6437,15 +6656,19 @@ static void set_aod_rect(void *device_data) if (ts->use_customlib) { disable_irq(ts->client->irq); - ret = ts->sec_ts_write(ts, SEC_TS_CMD_CUSTOMLIB_WRITE_PARAM, &data[0], 10); + ret = ts->sec_ts_write(ts, SEC_TS_CMD_CUSTOMLIB_WRITE_PARAM, + &data[0], 10); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: Failed to write offset\n", __func__); + input_err(true, &ts->client->dev, + "%s: Failed to write offset\n", __func__); goto NG; } - ret = ts->sec_ts_write(ts, SEC_TS_CMD_CUSTOMLIB_NOTIFY_PACKET, NULL, 0); + ret = ts->sec_ts_write(ts, SEC_TS_CMD_CUSTOMLIB_NOTIFY_PACKET, + NULL, 0); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: Failed to send notify\n", __func__); + input_err(true, &ts->client->dev, + "%s: Failed to send notify\n", __func__); goto NG; } enable_irq(ts->client->irq); @@ -6484,17 +6707,20 @@ static void get_aod_rect(void *device_data) disable_irq(ts->client->irq); ret = ts->sec_ts_read_customlib(ts, data, 8); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: Failed to read rect\n", __func__); + input_err(true, &ts->client->dev, + "%s: Failed to read rect\n", __func__); goto NG; } enable_irq(ts->client->irq); } for (i = 0; i < 4; i++) - rect_data[i] = (data[i * 2 + 1] & 0xFF) << 8 | (data[i * 2] & 0xFF); + rect_data[i] = (data[i * 2 + 1] & 0xFF) << 8 | + (data[i * 2] & 0xFF); input_info(true, &ts->client->dev, "%s: w:%d, h:%d, x:%d, y:%d\n", - __func__, rect_data[0], rect_data[1], rect_data[2], rect_data[3]); + __func__, + rect_data[0], rect_data[1], rect_data[2], rect_data[3]); snprintf(buff, sizeof(buff), "%s", "OK"); sec->cmd_state = SEC_CMD_STATUS_OK; @@ -6532,7 +6758,8 @@ static void aod_enable(void *device_data) ts->lowpower_mode &= ~SEC_TS_MODE_CUSTOMLIB_AOD; } - input_info(true, &ts->client->dev, "%s: %02X\n", __func__, ts->lowpower_mode); + input_info(true, &ts->client->dev, + "%s: %02X\n", __func__, ts->lowpower_mode); #ifdef SEC_TS_SUPPORT_CUSTOMLIB if (ts->use_customlib) @@ -6578,7 +6805,8 @@ void set_grip_data_to_ic(struct sec_ts_data *ts, u8 flag) { u8 data[8] = { 0 }; - input_info(true, &ts->client->dev, "%s: flag: %02X (clr,lan,nor,edg,han)\n", __func__, flag); + input_info(true, &ts->client->dev, "%s: flag: %02X (clr,lan,nor,edg,han)\n", + __func__, flag); if (flag & G_SET_EDGE_HANDLER) { if (ts->grip_edgehandler_direction == 0) { @@ -6588,13 +6816,15 @@ void set_grip_data_to_ic(struct sec_ts_data *ts, u8 flag) data[3] = 0x0; } else { data[0] = (ts->grip_edgehandler_start_y >> 4) & 0xFF; - data[1] = (ts->grip_edgehandler_start_y << 4 & 0xF0) | ((ts->grip_edgehandler_end_y >> 8) & 0xF); + data[1] = (ts->grip_edgehandler_start_y << 4 & 0xF0) | + ((ts->grip_edgehandler_end_y >> 8) & 0xF); data[2] = ts->grip_edgehandler_end_y & 0xFF; data[3] = ts->grip_edgehandler_direction & 0x3; } ts->sec_ts_write(ts, SEC_TS_CMD_EDGE_HANDLER, data, 4); input_info(true, &ts->client->dev, "%s: 0x%02X %02X,%02X,%02X,%02X\n", - __func__, SEC_TS_CMD_EDGE_HANDLER, data[0], data[1], data[2], data[3]); + __func__, SEC_TS_CMD_EDGE_HANDLER, + data[0], data[1], data[2], data[3]); } if (flag & G_SET_EDGE_ZONE) { @@ -6612,17 +6842,20 @@ void set_grip_data_to_ic(struct sec_ts_data *ts, u8 flag) data[3] = ts->grip_deadzone_y & 0xFF; ts->sec_ts_write(ts, SEC_TS_CMD_DEAD_ZONE, data, 4); input_info(true, &ts->client->dev, "%s: 0x%02X %02X,%02X,%02X,%02X\n", - __func__, SEC_TS_CMD_DEAD_ZONE, data[0], data[1], data[2], data[3]); + __func__, SEC_TS_CMD_DEAD_ZONE, + data[0], data[1], data[2], data[3]); } if (flag & G_SET_LANDSCAPE_MODE) { data[0] = ts->grip_landscape_mode & 0x1; data[1] = (ts->grip_landscape_edge >> 4) & 0xFF; - data[2] = (ts->grip_landscape_edge << 4 & 0xF0) | ((ts->grip_landscape_deadzone >> 8) & 0xF); + data[2] = (ts->grip_landscape_edge << 4 & 0xF0) | + ((ts->grip_landscape_deadzone >> 8) & 0xF); data[3] = ts->grip_landscape_deadzone & 0xFF; ts->sec_ts_write(ts, SEC_TS_CMD_LANDSCAPE_MODE, data, 4); input_info(true, &ts->client->dev, "%s: 0x%02X %02X,%02X,%02X,%02X\n", - __func__, SEC_TS_CMD_LANDSCAPE_MODE, data[0], data[1], data[2], data[3]); + __func__, SEC_TS_CMD_LANDSCAPE_MODE, + data[0], data[1], data[2], data[3]); } if (flag & G_CLR_LANDSCAPE_MODE) { @@ -6634,23 +6867,23 @@ void set_grip_data_to_ic(struct sec_ts_data *ts, u8 flag) } /* - * index 0 : set edge handler - * 1 : portrait (normal) mode - * 2 : landscape mode + * index 0 : set edge handler + * 1 : portrait (normal) mode + * 2 : landscape mode * - * data - * 0, X (direction), X (y start), X (y end) - * direction : 0 (off), 1 (left), 2 (right) - * ex) echo set_grip_data,0,2,600,900 > cmd + * data + * 0, X (direction), X (y start), X (y end) + * direction : 0 (off), 1 (left), 2 (right) + * ex) echo set_grip_data,0,2,600,900 > cmd * - * 1, X (edge zone), X (dead zone up x), X (dead zone down x), X (dead zone y) - * ex) echo set_grip_data,1,200,10,50,1500 > cmd + * 1, X (edge zone), X (dead zone up x), X (dead zone down x), X (dead zone y) + * ex) echo set_grip_data,1,200,10,50,1500 > cmd * - * 2, 1 (landscape mode), X (edge zone), X (dead zone) - * ex) echo set_grip_data,2,1,200,100 > cmd + * 2, 1 (landscape mode), X (edge zone), X (dead zone) + * ex) echo set_grip_data,2,1,200,100 > cmd * - * 2, 0 (portrait mode) - * ex) echo set_grip_data,2,0 > cmd + *2, 0 (portrait mode) + * ex) echo set_grip_data,2,0 > cmd */ static void set_grip_data(void *device_data) @@ -6676,58 +6909,62 @@ static void set_grip_data(void *device_data) ret = ts->sec_ts_write(ts, SEC_TS_CMD_DEADZONE_RANGE, tPara, 2); if (ret < 0) goto err_grip_data; - /* - if (sec->cmd_param[0] == 0) { // edge handler - if (sec->cmd_param[1] == 0) { // clear - ts->grip_edgehandler_direction = 0; - } else if (sec->cmd_param[1] < 3) { - ts->grip_edgehandler_direction = sec->cmd_param[1]; - ts->grip_edgehandler_start_y = sec->cmd_param[2]; - ts->grip_edgehandler_end_y = sec->cmd_param[3]; - } else { - input_err(true, &ts->client->dev, "%s: cmd1 is abnormal, %d (%d)\n", - __func__, sec->cmd_param[1], __LINE__); - goto err_grip_data; - } - - mode = mode | G_SET_EDGE_HANDLER; - set_grip_data_to_ic(ts, mode); - - } else if (sec->cmd_param[0] == 1) { // normal mode - if (ts->grip_edge_range != sec->cmd_param[1]) - mode = mode | G_SET_EDGE_ZONE; - - ts->grip_edge_range = sec->cmd_param[1]; - ts->grip_deadzone_up_x = sec->cmd_param[2]; - ts->grip_deadzone_dn_x = sec->cmd_param[3]; - ts->grip_deadzone_y = sec->cmd_param[4]; - mode = mode | G_SET_NORMAL_MODE; - - if (ts->grip_landscape_mode == 1) { - ts->grip_landscape_mode = 0; - mode = mode | G_CLR_LANDSCAPE_MODE; - } - set_grip_data_to_ic(ts, mode); - } else if (sec->cmd_param[0] == 2) { // landscape mode - if (sec->cmd_param[1] == 0) { // normal mode - ts->grip_landscape_mode = 0; - mode = mode | G_CLR_LANDSCAPE_MODE; - } else if (sec->cmd_param[1] == 1) { - ts->grip_landscape_mode = 1; - ts->grip_landscape_edge = sec->cmd_param[2]; - ts->grip_landscape_deadzone = sec->cmd_param[3]; - mode = mode | G_SET_LANDSCAPE_MODE; - } else { - input_err(true, &ts->client->dev, "%s: cmd1 is abnormal, %d (%d)\n", - __func__, sec->cmd_param[1], __LINE__); - goto err_grip_data; - } - set_grip_data_to_ic(ts, mode); - } else { - input_err(true, &ts->client->dev, "%s: cmd0 is abnormal, %d", __func__, sec->cmd_param[0]); - goto err_grip_data; - } - */ +/* + * if (sec->cmd_param[0] == 0) { // edge handler + * if (sec->cmd_param[1] == 0) { // clear + * ts->grip_edgehandler_direction = 0; + * } else if (sec->cmd_param[1] < 3) { + * ts->grip_edgehandler_direction = sec->cmd_param[1]; + * ts->grip_edgehandler_start_y = sec->cmd_param[2]; + * ts->grip_edgehandler_end_y = sec->cmd_param[3]; + * } else { + * input_err(true, &ts->client->dev, + * "%s: cmd1 is abnormal, %d (%d)\n", + * __func__, sec->cmd_param[1], __LINE__); + * goto err_grip_data; + * } + * + * mode = mode | G_SET_EDGE_HANDLER; + * set_grip_data_to_ic(ts, mode); + * + * } else if (sec->cmd_param[0] == 1) { // normal mode + * if (ts->grip_edge_range != sec->cmd_param[1]) + * mode = mode | G_SET_EDGE_ZONE; + * + * ts->grip_edge_range = sec->cmd_param[1]; + * ts->grip_deadzone_up_x = sec->cmd_param[2]; + * ts->grip_deadzone_dn_x = sec->cmd_param[3]; + * ts->grip_deadzone_y = sec->cmd_param[4]; + * mode = mode | G_SET_NORMAL_MODE; + * + * if (ts->grip_landscape_mode == 1) { + * ts->grip_landscape_mode = 0; + * mode = mode | G_CLR_LANDSCAPE_MODE; + * } + * set_grip_data_to_ic(ts, mode); + * } else if (sec->cmd_param[0] == 2) { // landscape mode + * if (sec->cmd_param[1] == 0) { // normal mode + * ts->grip_landscape_mode = 0; + * mode = mode | G_CLR_LANDSCAPE_MODE; + * } else if (sec->cmd_param[1] == 1) { + * ts->grip_landscape_mode = 1; + * ts->grip_landscape_edge = sec->cmd_param[2]; + * ts->grip_landscape_deadzone = sec->cmd_param[3]; + * mode = mode | G_SET_LANDSCAPE_MODE; + * } else { + * input_err(true, &ts->client->dev, + * "%s: cmd1 is abnormal, %d (%d)\n", + * __func__, sec->cmd_param[1], __LINE__); + * goto err_grip_data; + * } + * set_grip_data_to_ic(ts, mode); + * } else { + * input_err(true, &ts->client->dev, + * "%s: cmd0 is abnormal, %d", + * __func__, sec->cmd_param[0]); + * goto err_grip_data; + * } + **/ mutex_unlock(&ts->device_mutex); @@ -6749,7 +6986,7 @@ err_grip_data: } /* - * Set/Get Dex Mode 0xE7 + * Set/Get Dex Mode 0xE7 * 0: Disable dex mode * 1: Full screen mode * 2: Iris mode @@ -6766,13 +7003,15 @@ static void dex_enable(void *device_data) sec_cmd_set_default_result(sec); if (!ts->plat_data->support_dex) { - input_err(true, &ts->client->dev, "%s: not support DeX mode\n", __func__); + input_err(true, &ts->client->dev, "%s: not support DeX mode\n", + __func__); goto NG; } if ((sec->cmd_param[0] < 0 || sec->cmd_param[0] > 1) && (sec->cmd_param[1] < 0 || sec->cmd_param[1] > 1)) { - input_err(true, &ts->client->dev, "%s: not support param\n", __func__); + input_err(true, &ts->client->dev, "%s: not support param\n", + __func__); goto NG; } @@ -6789,13 +7028,15 @@ static void dex_enable(void *device_data) ts->dex_name = "[DeX]"; } } else { - input_err(true, &ts->client->dev, "%s: set touch mode\n", __func__); + input_err(true, &ts->client->dev, "%s: set touch mode\n", + __func__); ts->input_dev = ts->input_dev_touch; ts->dex_name = ""; } if (ts->power_status == SEC_TS_STATE_POWER_OFF) { - input_err(true, &ts->client->dev, "%s: Touch is stopped!\n", __func__); + input_err(true, &ts->client->dev, "%s: Touch is stopped!\n", + __func__); goto NG; } @@ -6842,21 +7083,25 @@ static void brush_enable(void *device_data) ts->brush_mode = sec->cmd_param[0]; if (ts->power_status == SEC_TS_STATE_POWER_OFF) { - input_err(true, &ts->client->dev, "%s: Touch is stopped!\n", __func__); + input_err(true, &ts->client->dev, + "%s: Touch is stopped!\n", __func__); snprintf(buff, sizeof(buff), "%s", "TSP turned off"); sec->cmd_state = SEC_CMD_STATUS_NOT_APPLICABLE; goto out; } input_info(true, &ts->client->dev, - "%s: set brush mode %s\n", __func__, ts->brush_mode ? "enable" : "disable"); - - /* - 0: Disable Artcanvas min phi mode - - 1: Enable Artcanvas min phi mode */ - ret = ts->sec_ts_write(ts, SEC_TS_CMD_SET_BRUSH_MODE, &ts->brush_mode, 1); + "%s: set brush mode %s\n", __func__, + ts->brush_mode ? "enable" : "disable"); + + /* - 0: Disable Artcanvas min phi mode + * - 1: Enable Artcanvas min phi mode + **/ + ret = ts->sec_ts_write(ts, SEC_TS_CMD_SET_BRUSH_MODE, + &ts->brush_mode, 1); if (ret < 0) { input_err(true, &ts->client->dev, - "%s: failed to set brush mode\n", __func__); + "%s: failed to set brush mode\n", __func__); snprintf(buff, sizeof(buff), "%s", "NG"); sec->cmd_state = SEC_CMD_STATUS_FAIL; goto out; @@ -6935,21 +7180,25 @@ static void set_touchable_area(void *device_data) ts->touchable_area = sec->cmd_param[0]; if (ts->power_status == SEC_TS_STATE_POWER_OFF) { - input_err(true, &ts->client->dev, "%s: Touch is stopped!\n", __func__); + input_err(true, &ts->client->dev, + "%s: Touch is stopped!\n", __func__); snprintf(buff, sizeof(buff), "%s", "TSP turned off"); sec->cmd_state = SEC_CMD_STATUS_NOT_APPLICABLE; goto out; } input_info(true, &ts->client->dev, - "%s: set 16:9 mode %s\n", __func__, ts->touchable_area ? "enable" : "disable"); + "%s: set 16:9 mode %s\n", __func__, + ts->touchable_area ? "enable" : "disable"); /* - 0: Disable 16:9 mode - * - 1: Enable 16:9 mode */ - ret = ts->sec_ts_write(ts, SEC_TS_CMD_SET_TOUCHABLE_AREA, &ts->touchable_area, 1); + * - 1: Enable 16:9 mode + **/ + ret = ts->sec_ts_write(ts, SEC_TS_CMD_SET_TOUCHABLE_AREA, + &ts->touchable_area, 1); if (ret < 0) { input_err(true, &ts->client->dev, - "%s: failed to set 16:9 mode\n", __func__); + "%s: failed to set 16:9 mode\n", __func__); snprintf(buff, sizeof(buff), "%s", "NG"); sec->cmd_state = SEC_CMD_STATUS_FAIL; goto out; @@ -6980,7 +7229,8 @@ static void set_log_level(void *device_data) sec_cmd_set_default_result(sec); if (ts->power_status == SEC_TS_STATE_POWER_OFF) { - input_err(true, &ts->client->dev, "%s: Touch is stopped!\n", __func__); + input_err(true, &ts->client->dev, + "%s: Touch is stopped!\n", __func__); snprintf(buff, sizeof(buff), "%s", "TSP turned off"); sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff))); sec->cmd_state = SEC_CMD_STATUS_FAIL; @@ -6997,7 +7247,8 @@ static void set_log_level(void *device_data) (sec->cmd_param[5] < 0 || sec->cmd_param[5] > 1) || (sec->cmd_param[6] < 0 || sec->cmd_param[6] > 1) || (sec->cmd_param[7] < 0 || sec->cmd_param[7] > 1)) { - input_err(true, &ts->client->dev, "%s: para out of range\n", __func__); + input_err(true, &ts->client->dev, + "%s: para out of range\n", __func__); snprintf(buff, sizeof(buff), "%s", "Para out of range"); sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff))); sec->cmd_state = SEC_CMD_STATUS_FAIL; @@ -7008,7 +7259,8 @@ static void set_log_level(void *device_data) ret = ts->sec_ts_read(ts, SEC_TS_CMD_STATUS_EVENT_TYPE, tBuff, 2); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: Read Event type enable status fail\n", __func__); + input_err(true, &ts->client->dev, + "%s: Read Event type enable status fail\n", __func__); snprintf(buff, sizeof(buff), "%s", "Read Stat Fail"); goto err; } @@ -7023,32 +7275,44 @@ static void set_log_level(void *device_data) ret = ts->sec_ts_write(ts, SEC_TS_CMD_STATUS_EVENT_TYPE, tBuff, 2); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: Write Event type enable status fail\n", __func__); + input_err(true, &ts->client->dev, + "%s: Write Event type enable status fail\n", __func__); snprintf(buff, sizeof(buff), "%s", "Write Stat Fail"); goto err; } - if (sec->cmd_param[0] == 1 && sec->cmd_param[1] == 1 && sec->cmd_param[2] == 1 && sec->cmd_param[3] == 1 && - sec->cmd_param[4] == 1 && sec->cmd_param[5] == 1 && sec->cmd_param[6] == 1 && sec->cmd_param[7] == 1) { + if (sec->cmd_param[0] == 1 && sec->cmd_param[1] == 1 && + sec->cmd_param[2] == 1 && sec->cmd_param[3] == 1 && + sec->cmd_param[4] == 1 && sec->cmd_param[5] == 1 && + sec->cmd_param[6] == 1 && sec->cmd_param[7] == 1) { w_data[0] = 0x1; - ret = ts->sec_ts_write(ts, SEC_TS_CMD_SET_VENDOR_EVENT_LEVEL, w_data, 1); + ret = ts->sec_ts_write(ts, SEC_TS_CMD_SET_VENDOR_EVENT_LEVEL, + w_data, 1); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: Write Vendor Event Level fail\n", __func__); + input_err(true, &ts->client->dev, + "%s: Write Vendor Event Level fail\n", + __func__); snprintf(buff, sizeof(buff), "%s", "Write Stat Fail"); goto err; } } else { w_data[0] = 0x0; - ret = ts->sec_ts_write(ts, SEC_TS_CMD_SET_VENDOR_EVENT_LEVEL, w_data, 0); + ret = ts->sec_ts_write(ts, SEC_TS_CMD_SET_VENDOR_EVENT_LEVEL, + w_data, 0); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: Write Vendor Event Level fail\n", __func__); + input_err(true, &ts->client->dev, + "%s: Write Vendor Event Level fail\n", + __func__); snprintf(buff, sizeof(buff), "%s", "Write Stat Fail"); goto err; } } - input_info(true, &ts->client->dev, "%s: ERROR : %d, INFO : %d, USER_INPUT : %d, INFO_CUSTOMLIB : %d, VENDOR_INFO : %d, VENDOR_EVENT_LEVEL : %d\n", - __func__, sec->cmd_param[0], sec->cmd_param[1], sec->cmd_param[2], sec->cmd_param[5], sec->cmd_param[6], w_data[0]); + input_info(true, &ts->client->dev, + "%s: ERROR : %d, INFO : %d, USER_INPUT : %d, INFO_CUSTOMLIB : %d, VENDOR_INFO : %d, VENDOR_EVENT_LEVEL : %d\n", + __func__, sec->cmd_param[0], sec->cmd_param[1], + sec->cmd_param[2], sec->cmd_param[5], + sec->cmd_param[6], w_data[0]); snprintf(buff, sizeof(buff), "%s", "OK"); sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff))); @@ -7231,7 +7495,8 @@ int sec_ts_fn_init(struct sec_ts_data *ts) &cmd_attr_group); if (retval < 0) { input_err(true, &ts->client->dev, - "%s: FTS Failed to create sysfs attributes\n", __func__); + "%s: FTS Failed to create sysfs attributes\n", + __func__); goto exit; } diff --git a/sec_ts_fw.c b/sec_ts_fw.c index 516d7a9..e30d01b 100644 --- a/sec_ts_fw.c +++ b/sec_ts_fw.c @@ -55,33 +55,40 @@ static int sec_ts_enter_fw_mode(struct sec_ts_data *ts) u8 fw_status; u8 id[3]; - ret = ts->sec_ts_write(ts, SEC_TS_CMD_ENTER_FW_MODE, fw_update_mode_passwd, sizeof(fw_update_mode_passwd)); + ret = ts->sec_ts_write(ts, SEC_TS_CMD_ENTER_FW_MODE, + fw_update_mode_passwd, sizeof(fw_update_mode_passwd)); sec_ts_delay(20); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: write fail, enter_fw_mode\n", __func__); + input_err(true, &ts->client->dev, + "%s: write fail, enter_fw_mode\n", __func__); return 0; } input_info(true, &ts->client->dev, "%s: write ok, enter_fw_mode - 0x%x 0x%x 0x%x\n", - __func__, SEC_TS_CMD_ENTER_FW_MODE, fw_update_mode_passwd[0], fw_update_mode_passwd[1]); + __func__, SEC_TS_CMD_ENTER_FW_MODE, fw_update_mode_passwd[0], + fw_update_mode_passwd[1]); ret = ts->sec_ts_read(ts, SEC_TS_READ_BOOT_STATUS, &fw_status, 1); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: read fail, read_boot_status\n", __func__); + input_err(true, &ts->client->dev, + "%s: read fail, read_boot_status\n", __func__); return 0; } if (fw_status != SEC_TS_STATUS_BOOT_MODE) { - input_err(true, &ts->client->dev, "%s: enter fail! read_boot_status = 0x%x\n", __func__, fw_status); + input_err(true, &ts->client->dev, "%s: enter fail! read_boot_status = 0x%x\n", + __func__, fw_status); return 0; } - input_info(true, &ts->client->dev, "%s: Success! read_boot_status = 0x%x\n", __func__, fw_status); + input_info(true, &ts->client->dev, "%s: Success! read_boot_status = 0x%x\n", + __func__, fw_status); sec_ts_delay(10); ret = ts->sec_ts_read(ts, SEC_TS_READ_ID, id, 3); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: read id fail\n", __func__); + input_err(true, &ts->client->dev, + "%s: read id fail\n", __func__); return 0; } @@ -91,7 +98,8 @@ static int sec_ts_enter_fw_mode(struct sec_ts_data *ts) ts->flash_page_size = SEC_TS_FW_BLK_SIZE_DEFAULT; - input_info(true, &ts->client->dev, "%s: read_boot_id = %02X%02X%02X\n", __func__, id[0], id[1], id[2]); + input_info(true, &ts->client->dev, "%s: read_boot_id = %02X%02X%02X\n", + __func__, id[0], id[1], id[2]); return 1; } @@ -125,7 +133,8 @@ int sec_ts_sw_reset(struct sec_ts_data *ts) ret = ts->sec_ts_write(ts, SEC_TS_CMD_SW_RESET, NULL, 0); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: write fail, sw_reset\n", __func__); + input_err(true, &ts->client->dev, + "%s: write fail, sw_reset\n", __func__); return 0; } @@ -143,7 +152,8 @@ int sec_ts_sw_reset(struct sec_ts_data *ts) /* Sense_on */ ret = ts->sec_ts_write(ts, SEC_TS_CMD_SENSE_ON, NULL, 0); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: write fail, Sense_on\n", __func__); + input_err(true, &ts->client->dev, + "%s: write fail, Sense_on\n", __func__); return 0; } @@ -237,36 +247,52 @@ err_system_reset: return ret; } -static void sec_ts_save_version_of_bin(struct sec_ts_data *ts, const fw_header *fw_hd) +static void sec_ts_save_version_of_bin(struct sec_ts_data *ts, + const fw_header *fw_hd) { - ts->plat_data->img_version_of_bin[3] = ((fw_hd->img_ver >> 24) & 0xff); - ts->plat_data->img_version_of_bin[2] = ((fw_hd->img_ver >> 16) & 0xff); - ts->plat_data->img_version_of_bin[1] = ((fw_hd->img_ver >> 8) & 0xff); - ts->plat_data->img_version_of_bin[0] = ((fw_hd->img_ver >> 0) & 0xff); - - ts->plat_data->core_version_of_bin[3] = ((fw_hd->fw_ver >> 24) & 0xff); - ts->plat_data->core_version_of_bin[2] = ((fw_hd->fw_ver >> 16) & 0xff); - ts->plat_data->core_version_of_bin[1] = ((fw_hd->fw_ver >> 8) & 0xff); - ts->plat_data->core_version_of_bin[0] = ((fw_hd->fw_ver >> 0) & 0xff); - - ts->plat_data->config_version_of_bin[3] = ((fw_hd->para_ver >> 24) & 0xff); - ts->plat_data->config_version_of_bin[2] = ((fw_hd->para_ver >> 16) & 0xff); - ts->plat_data->config_version_of_bin[1] = ((fw_hd->para_ver >> 8) & 0xff); - ts->plat_data->config_version_of_bin[0] = ((fw_hd->para_ver >> 0) & 0xff); - - input_info(true, &ts->client->dev, "%s: img_ver of bin = %x.%x.%x.%x\n", __func__, + ts->plat_data->img_version_of_bin[3] = + ((fw_hd->img_ver >> 24) & 0xff); + ts->plat_data->img_version_of_bin[2] = + ((fw_hd->img_ver >> 16) & 0xff); + ts->plat_data->img_version_of_bin[1] = + ((fw_hd->img_ver >> 8) & 0xff); + ts->plat_data->img_version_of_bin[0] = + ((fw_hd->img_ver >> 0) & 0xff); + + ts->plat_data->core_version_of_bin[3] = + ((fw_hd->fw_ver >> 24) & 0xff); + ts->plat_data->core_version_of_bin[2] = + ((fw_hd->fw_ver >> 16) & 0xff); + ts->plat_data->core_version_of_bin[1] = + ((fw_hd->fw_ver >> 8) & 0xff); + ts->plat_data->core_version_of_bin[0] = + ((fw_hd->fw_ver >> 0) & 0xff); + + ts->plat_data->config_version_of_bin[3] = + ((fw_hd->para_ver >> 24) & 0xff); + ts->plat_data->config_version_of_bin[2] = + ((fw_hd->para_ver >> 16) & 0xff); + ts->plat_data->config_version_of_bin[1] = + ((fw_hd->para_ver >> 8) & 0xff); + ts->plat_data->config_version_of_bin[0] = + ((fw_hd->para_ver >> 0) & 0xff); + + input_info(true, &ts->client->dev, "%s: img_ver of bin = %x.%x.%x.%x\n", + __func__, ts->plat_data->img_version_of_bin[0], ts->plat_data->img_version_of_bin[1], ts->plat_data->img_version_of_bin[2], ts->plat_data->img_version_of_bin[3]); - input_info(true, &ts->client->dev, "%s: core_ver of bin = %x.%x.%x.%x\n", __func__, + input_info(true, &ts->client->dev, "%s: core_ver of bin = %x.%x.%x.%x\n", + __func__, ts->plat_data->core_version_of_bin[0], ts->plat_data->core_version_of_bin[1], ts->plat_data->core_version_of_bin[2], ts->plat_data->core_version_of_bin[3]); - input_info(true, &ts->client->dev, "%s: config_ver of bin = %x.%x.%x.%x\n", __func__, + input_info(true, &ts->client->dev, "%s: config_ver of bin = %x.%x.%x.%x\n", + __func__, ts->plat_data->config_version_of_bin[0], ts->plat_data->config_version_of_bin[1], ts->plat_data->config_version_of_bin[2], @@ -283,11 +309,13 @@ static int sec_ts_save_version_of_ic(struct sec_ts_data *ts) /* Image ver */ ret = ts->sec_ts_read(ts, SEC_TS_READ_IMG_VERSION, img_ver, 4); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: Image version read error\n", __func__); + input_err(true, &ts->client->dev, + "%s: Image version read error\n", __func__); return -EIO; } - input_info(true, &ts->client->dev, "%s: IC Image version info : %x.%x.%x.%x\n", - __func__, img_ver[0], img_ver[1], img_ver[2], img_ver[3]); + input_info(true, &ts->client->dev, + "%s: IC Image version info : %x.%x.%x.%x\n", + __func__, img_ver[0], img_ver[1], img_ver[2], img_ver[3]); ts->plat_data->img_version_of_ic[0] = img_ver[0]; ts->plat_data->img_version_of_ic[1] = img_ver[1]; @@ -297,11 +325,13 @@ static int sec_ts_save_version_of_ic(struct sec_ts_data *ts) /* Core ver */ ret = ts->sec_ts_read(ts, SEC_TS_READ_FW_VERSION, core_ver, 4); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: core version read error\n", __func__); + input_err(true, &ts->client->dev, + "%s: core version read error\n", __func__); return -EIO; } - input_info(true, &ts->client->dev, "%s: IC Core version info : %x.%x.%x.%x,\n", - __func__, core_ver[0], core_ver[1], core_ver[2], core_ver[3]); + input_info(true, &ts->client->dev, + "%s: IC Core version info : %x.%x.%x.%x,\n", + __func__, core_ver[0], core_ver[1], core_ver[2], core_ver[3]); ts->plat_data->core_version_of_ic[0] = core_ver[0]; ts->plat_data->core_version_of_ic[1] = core_ver[1]; @@ -311,11 +341,14 @@ static int sec_ts_save_version_of_ic(struct sec_ts_data *ts) /* Config ver */ ret = ts->sec_ts_read(ts, SEC_TS_READ_PARA_VERSION, config_ver, 4); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: config version read error\n", __func__); + input_err(true, &ts->client->dev, + "%s: config version read error\n", __func__); return -EIO; } - input_info(true, &ts->client->dev, "%s: IC config version info : %x.%x.%x.%x\n", - __func__, config_ver[0], config_ver[1], config_ver[2], config_ver[3]); + input_info(true, &ts->client->dev, + "%s: IC config version info : %x.%x.%x.%x\n", + __func__, config_ver[0], config_ver[1], + config_ver[2], config_ver[3]); ts->plat_data->config_version_of_ic[0] = config_ver[0]; ts->plat_data->config_version_of_ic[1] = config_ver[1]; @@ -325,7 +358,8 @@ static int sec_ts_save_version_of_ic(struct sec_ts_data *ts) return 1; } -static int sec_ts_check_firmware_version(struct sec_ts_data *ts, const u8 *fw_info) +static int sec_ts_check_firmware_version(struct sec_ts_data *ts, + const u8 *fw_info) { fw_header *fw_hd; u8 buff[1]; @@ -345,20 +379,21 @@ static int sec_ts_check_firmware_version(struct sec_ts_data *ts, const u8 *fw_in ret = ts->sec_ts_read(ts, SEC_TS_READ_BOOT_STATUS, buff, 1); if (ret < 0) { input_err(true, &ts->client->dev, - "%s: fail to read BootStatus\n", __func__); + "%s: fail to read BootStatus\n", __func__); return -EIO; } if (buff[0] == SEC_TS_STATUS_BOOT_MODE) { input_err(true, &ts->client->dev, - "%s: ReadBootStatus = 0x%x, Firmware download Start!\n", - __func__, buff[0]); + "%s: ReadBootStatus = 0x%x, Firmware download Start!\n", + __func__, buff[0]); return 1; } ret = sec_ts_save_version_of_ic(ts); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: fail to read ic version\n", __func__); + input_err(true, &ts->client->dev, + "%s: fail to read ic version\n", __func__); return -EIO; } @@ -367,8 +402,10 @@ static int sec_ts_check_firmware_version(struct sec_ts_data *ts, const u8 *fw_in * ver[1] : Project version */ for (i = 0; i < 2; i++) { - if (ts->plat_data->img_version_of_ic[i] != ts->plat_data->img_version_of_bin[i]) { - input_err(true, &ts->client->dev, "%s: do not matched version info\n", __func__); + if (ts->plat_data->img_version_of_ic[i] != + ts->plat_data->img_version_of_bin[i]) { + input_err(true, &ts->client->dev, + "%s: do not matched version info\n", __func__); return 0; } } @@ -393,7 +430,8 @@ static u8 sec_ts_checksum(u8 *data, int offset, int size) return checksum; } -static int sec_ts_flashpageerase(struct sec_ts_data *ts, u32 page_idx, u32 page_num) +static int sec_ts_flashpageerase(struct sec_ts_data *ts, u32 page_idx, + u32 page_num) { int ret; u8 tCmd[6]; @@ -410,7 +448,8 @@ static int sec_ts_flashpageerase(struct sec_ts_data *ts, u32 page_idx, u32 page_ return ret; } -static int sec_ts_flashpagewrite(struct sec_ts_data *ts, u32 page_idx, u8 *page_data) +static int sec_ts_flashpagewrite(struct sec_ts_data *ts, u32 page_idx, + u8 *page_data) { int ret; u8 tCmd[1 + 2 + SEC_TS_FW_BLK_SIZE_MAX + 1]; @@ -421,13 +460,15 @@ static int sec_ts_flashpagewrite(struct sec_ts_data *ts, u32 page_idx, u8 *page_ tCmd[2] = (u8)((page_idx >> 0) & 0xFF); memcpy(&tCmd[3], page_data, flash_page_size); - tCmd[1 + 2 + flash_page_size] = sec_ts_checksum(tCmd, 1, 2 + flash_page_size); + tCmd[1 + 2 + flash_page_size] = sec_ts_checksum(tCmd, 1, + 2 + flash_page_size); ret = ts->sec_ts_write_burst(ts, tCmd, 1 + 2 + flash_page_size + 1); return ret; } -static bool sec_ts_limited_flashpagewrite(struct sec_ts_data *ts, u32 page_idx, u8 *page_data) +static bool sec_ts_limited_flashpagewrite(struct sec_ts_data *ts, + u32 page_idx, u8 *page_data) { int ret = 0; u8 *tCmd; @@ -441,7 +482,8 @@ static bool sec_ts_limited_flashpagewrite(struct sec_ts_data *ts, u32 page_idx, copy_data[1] = (u8)((page_idx >> 0) & 0xFF); /* addL */ memcpy(©_data[2], page_data, flash_page_size); /* DATA */ - copy_data[2 + flash_page_size] = sec_ts_checksum(copy_data, 0, 2 + flash_page_size); /* CS */ + copy_data[2 + flash_page_size] = + sec_ts_checksum(copy_data, 0, 2 + flash_page_size); /* CS */ while (copy_left > 0) { int copy_cur = (copy_left > copy_max) ? copy_max : copy_left; @@ -460,7 +502,7 @@ static bool sec_ts_limited_flashpagewrite(struct sec_ts_data *ts, u32 page_idx, ret = ts->sec_ts_write_burst_heap(ts, tCmd, 1 + copy_cur); if (ret < 0) input_err(true, &ts->client->dev, - "%s: failed, ret:%d\n", __func__, ret); + "%s: failed, ret:%d\n", __func__, ret); copy_size += copy_cur; copy_left -= copy_cur; @@ -475,7 +517,8 @@ err_write: } -static int sec_ts_flashwrite(struct sec_ts_data *ts, u32 mem_addr, u8 *mem_data, u32 mem_size, int retry) +static int sec_ts_flashwrite(struct sec_ts_data *ts, u32 mem_addr, + u8 *mem_data, u32 mem_size, int retry) { int ret; u32 page_idx; @@ -497,8 +540,8 @@ static int sec_ts_flashwrite(struct sec_ts_data *ts, u32 mem_addr, u8 *mem_data, ret = sec_ts_flashpageerase(ts, page_idx_start, page_num); if (ret < 0) { input_err(true, &ts->client->dev, - "%s: fw erase failed, mem_addr= %08X, pagenum = %d\n", - __func__, mem_addr, page_num); + "%s: fw erase failed, mem_addr= %08X, pagenum = %d\n", + __func__, mem_addr, page_num); return -EIO; } @@ -511,34 +554,47 @@ static int sec_ts_flashwrite(struct sec_ts_data *ts, u32 mem_addr, u8 *mem_data, memset(page_buf, 0, flash_page_size); for (page_idx = page_num - 1;; page_idx--) { - memcpy(page_buf, mem_data + (page_idx * flash_page_size), size_copy); + memcpy(page_buf, mem_data + (page_idx * flash_page_size), + size_copy); if (ts->boot_ver[0] == 0xB2) { - ret = sec_ts_flashpagewrite(ts, (page_idx + page_idx_start), page_buf); + ret = sec_ts_flashpagewrite(ts, + (page_idx + page_idx_start), page_buf); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: fw write failed, page_idx = %u\n", __func__, page_idx); + input_err(true, &ts->client->dev, + "%s: fw write failed, page_idx = %u\n", + __func__, page_idx); goto err; } if (retry) { sec_ts_delay(50); - ret = sec_ts_flashpagewrite(ts, (page_idx + page_idx_start), page_buf); + ret = sec_ts_flashpagewrite(ts, + (page_idx + page_idx_start), page_buf); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: fw write failed, page_idx = %u\n", __func__, page_idx); + input_err(true, &ts->client->dev, + "%s: fw write failed, page_idx = %u\n", + __func__, page_idx); goto err; } } } else { - ret = sec_ts_limited_flashpagewrite(ts, (page_idx + page_idx_start), page_buf); + ret = sec_ts_limited_flashpagewrite(ts, + (page_idx + page_idx_start), page_buf); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: fw write failed, page_idx = %u\n", __func__, page_idx); + input_err(true, &ts->client->dev, + "%s: fw write failed, page_idx = %u\n", + __func__, page_idx); goto err; } if (retry) { sec_ts_delay(50); - ret = sec_ts_limited_flashpagewrite(ts, (page_idx + page_idx_start), page_buf); + ret = sec_ts_limited_flashpagewrite(ts, + (page_idx + page_idx_start), page_buf); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: fw write failed, page_idx = %u\n", __func__, page_idx); + input_err(true, &ts->client->dev, + "%s: fw write failed, page_idx = %u\n", + __func__, page_idx); goto err; } } @@ -548,7 +604,9 @@ static int sec_ts_flashwrite(struct sec_ts_data *ts, u32 mem_addr, u8 *mem_data, size_copy = flash_page_size; sec_ts_delay(5); - if (page_idx == 0) /* end condition (page_idx >= 0) page_idx type unsinged int */ + /* end condition (page_idx >= 0) page_idx type unsigned int + **/ + if (page_idx == 0) break; } @@ -558,7 +616,8 @@ err: } #if SEC_TS_ENABLE_FW_VERIFY -static int sec_ts_memoryblockread(struct sec_ts_data *ts, u32 mem_addr, int mem_size, u8 *buf) +static int sec_ts_memoryblockread(struct sec_ts_data *ts, u32 mem_addr, + int mem_size, u8 *buf) { int ret; u8 cmd[5]; @@ -566,7 +625,7 @@ static int sec_ts_memoryblockread(struct sec_ts_data *ts, u32 mem_addr, int mem_ if (mem_size >= 64 * 1024) { input_err(true, &ts->client->dev, - "%s: mem size over 64K\n", __func__); + "%s: mem size over 64K\n", __func__); return -EIO; } @@ -579,7 +638,7 @@ static int sec_ts_memoryblockread(struct sec_ts_data *ts, u32 mem_addr, int mem_ ret = ts->sec_ts_write_burst(ts, cmd, 5); if (ret < 0) { input_err(true, &ts->client->dev, - "%s: send command failed, %02X\n", __func__, cmd[0]); + "%s: send command failed, %02X\n", __func__, cmd[0]); return -EIO; } @@ -590,7 +649,9 @@ static int sec_ts_memoryblockread(struct sec_ts_data *ts, u32 mem_addr, int mem_ ret = ts->sec_ts_write_burst(ts, cmd, 3); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: send command failed, %02X\n", __func__, cmd[0]); + input_err(true, &ts->client->dev, + "%s: send command failed, %02X\n", + __func__, cmd[0]); return -EIO; } @@ -602,17 +663,19 @@ static int sec_ts_memoryblockread(struct sec_ts_data *ts, u32 mem_addr, int mem_ ret = ts->sec_ts_read_heap(ts, cmd[0], data, mem_size); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: memory read failed\n", __func__); + input_err(true, &ts->client->dev, "%s: memory read failed\n", + __func__); return -EIO; } /* - ret = ts->sec_ts_write(ts, cmd[0], NULL, 0); - ret = ts->sec_ts_read_bulk_heap(ts, data, mem_size); -*/ + * ret = ts->sec_ts_write(ts, cmd[0], NULL, 0); + * ret = ts->sec_ts_read_bulk_heap(ts, data, mem_size); + **/ return 0; } -static int sec_ts_memoryread(struct sec_ts_data *ts, u32 mem_addr, u8 *mem_data, u32 mem_size) +static int sec_ts_memoryread(struct sec_ts_data *ts, u32 mem_addr, + u8 *mem_data, u32 mem_size) { int ret; int retry = 3; @@ -633,11 +696,12 @@ static int sec_ts_memoryread(struct sec_ts_data *ts, u32 mem_addr, u8 *mem_data, unit_size = (read_left > max_size) ? max_size : read_left; retry = 3; do { - ret = sec_ts_memoryblockread(ts, mem_addr, unit_size, tmp_data); + ret = sec_ts_memoryblockread(ts, mem_addr, unit_size, + tmp_data); if (retry-- == 0) { input_err(true, &ts->client->dev, - "%s: fw read fail mem_addr=%08X,unit_size=%d\n", - __func__, mem_addr, unit_size); + "%s: fw read fail mem_addr=%08X,unit_size=%d\n", + __func__, mem_addr, unit_size); kfree(tmp_data); return -1; } @@ -656,7 +720,8 @@ static int sec_ts_memoryread(struct sec_ts_data *ts, u32 mem_addr, u8 *mem_data, } #endif -static int sec_ts_chunk_update(struct sec_ts_data *ts, u32 addr, u32 size, u8 *data, int retry) +static int sec_ts_chunk_update(struct sec_ts_data *ts, u32 addr, + u32 size, u8 *data, int retry) { u32 fw_size; u32 write_size; @@ -667,14 +732,17 @@ static int sec_ts_chunk_update(struct sec_ts_data *ts, u32 addr, u32 size, u8 *d write_size = sec_ts_flashwrite(ts, addr, data, fw_size, retry); if (write_size != fw_size) { - input_err(true, &ts->client->dev, "%s: fw write failed, write_size %d != fw_size %d\n", __func__, write_size, fw_size); + input_err(true, &ts->client->dev, + "%s: fw write failed, write_size %d != fw_size %d\n", + __func__, write_size, fw_size); ret = -1; goto err_write_fail; } mem_rb = vzalloc(fw_size); if (!mem_rb) { - input_err(true, &ts->client->dev, "%s: vzalloc failed\n", __func__); + input_err(true, &ts->client->dev, + "%s: vzalloc failed\n", __func__); ret = -1; goto err_write_fail; } @@ -685,13 +753,17 @@ static int sec_ts_chunk_update(struct sec_ts_data *ts, u32 addr, u32 size, u8 *d for (ii = 0; ii < fw_size; ii++) { if (data[ii] != mem_rb[ii]) { - input_info(true, &ts->client->dev, "%s: data = %X, mem_rb = %X, ii = %d\n", __func__, data[ii], mem_rb[ii], ii); + input_info(true, &ts->client->dev, + "%s: data = %X, mem_rb = %X, ii = %d\n", + __func__, data[ii], mem_rb[ii], ii); break; - } + } } if (fw_size != ii) { - input_err(true, &ts->client->dev, "%s: fw verify fail, fw_size %d != ii %d\n", __func__, fw_size, ii); + input_err(true, &ts->client->dev, + "%s: fw verify fail, fw_size %d != ii %d\n", + __func__, fw_size, ii); ret = -1; goto out; } @@ -700,7 +772,8 @@ static int sec_ts_chunk_update(struct sec_ts_data *ts, u32 addr, u32 size, u8 *d goto out; } - input_info(true, &ts->client->dev, "%s: verify done(%d)\n", __func__, ret); + input_info(true, &ts->client->dev, "%s: verify done(%d)\n", + __func__, ret); out: #endif @@ -711,7 +784,8 @@ err_write_fail: return ret; } -static int sec_ts_firmware_update(struct sec_ts_data *ts, const u8 *data, size_t size, int bl_update, int restore_cal, int retry) +static int sec_ts_firmware_update(struct sec_ts_data *ts, const u8 *data, + size_t size, int bl_update, int restore_cal, int retry) { int i; int ret; @@ -730,41 +804,54 @@ static int sec_ts_firmware_update(struct sec_ts_data *ts, const u8 *data, size_t * Enter Firmware Update Mode */ if (!sec_ts_enter_fw_mode(ts)) { - input_err(true, &ts->client->dev, "%s: firmware mode failed\n", __func__); + input_err(true, &ts->client->dev, + "%s: firmware mode failed\n", __func__); return -1; } if (bl_update && (ts->boot_ver[0] == 0xB4)) { - input_info(true, &ts->client->dev, "%s: bootloader is up to date\n", __func__); + input_info(true, &ts->client->dev, + "%s: bootloader is up to date\n", __func__); return 0; } - input_info(true, &ts->client->dev, "%s: firmware update retry :%d\n", __func__, retry); + input_info(true, &ts->client->dev, + "%s: firmware update retry :%d\n", __func__, retry); fw_hd = (fw_header *)fd; fd += sizeof(fw_header); if (fw_hd->signature != SEC_TS_FW_HEADER_SIGN) { - input_err(true, &ts->client->dev, "%s: firmware header error = %08X\n", __func__, fw_hd->signature); + input_err(true, &ts->client->dev, + "%s: firmware header error = %08X\n", + __func__, fw_hd->signature); return -1; } - input_err(true, &ts->client->dev, "%s: num_chunk : %d\n", __func__, fw_hd->num_chunk); + input_err(true, &ts->client->dev, "%s: num_chunk : %d\n", + __func__, fw_hd->num_chunk); for (i = 0; i < fw_hd->num_chunk; i++) { fw_ch = (fw_chunk *)fd; - input_err(true, &ts->client->dev, "%s: [%d] 0x%08X, 0x%08X, 0x%08X, 0x%08X\n", __func__, i, - fw_ch->signature, fw_ch->addr, fw_ch->size, fw_ch->reserved); + input_err(true, &ts->client->dev, + "%s: [%d] 0x%08X, 0x%08X, 0x%08X, 0x%08X\n", + __func__, i, fw_ch->signature, fw_ch->addr, + fw_ch->size, fw_ch->reserved); if (fw_ch->signature != SEC_TS_FW_CHUNK_SIGN) { - input_err(true, &ts->client->dev, "%s: firmware chunk error = %08X\n", __func__, fw_ch->signature); + input_err(true, &ts->client->dev, + "%s: firmware chunk error = %08X\n", + __func__, fw_ch->signature); return -1; } fd += sizeof(fw_chunk); - ret = sec_ts_chunk_update(ts, fw_ch->addr, fw_ch->size, fd, retry); + ret = sec_ts_chunk_update(ts, fw_ch->addr, fw_ch->size, fd, + retry); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: firmware chunk write failed, addr=%08X, size = %d\n", __func__, fw_ch->addr, fw_ch->size); + input_err(true, &ts->client->dev, + "%s: firmware chunk write failed, addr=%08X, size = %d\n", + __func__, fw_ch->addr, fw_ch->size); return -1; } fd += fw_ch->size; @@ -774,88 +861,125 @@ static int sec_ts_firmware_update(struct sec_ts_data *ts, const u8 *data, size_t #ifdef PAT_CONTROL if (restore_cal) { - if(ts->plat_data->pat_function == PAT_CONTROL_PAT_MAGIC) { - /* NOT to control cal count that was marked on external factory ( E0~E5 )*/ - if ((ts->cal_count >= PAT_MAGIC_NUMBER) && (ts->cal_count < PAT_MAX_MAGIC)) + if (ts->plat_data->pat_function == PAT_CONTROL_PAT_MAGIC) { + /* NOT to control cal count that was marked on external + * factory ( E0~E5 ) + **/ + if ((ts->cal_count >= PAT_MAGIC_NUMBER) && + (ts->cal_count < PAT_MAX_MAGIC)) magic_cal = true; } } - input_info(true, &ts->client->dev, "%s: cal_count(0x%02X) pat_function dt(%d) restore_cal(%d) magic_cal(%d)\n", - __func__,ts->cal_count,ts->plat_data->pat_function,restore_cal,magic_cal); + input_info(true, &ts->client->dev, + "%s: cal_count(0x%02X) pat_function dt(%d) restore_cal(%d) magic_cal(%d)\n", + __func__, ts->cal_count, ts->plat_data->pat_function, + restore_cal, magic_cal); #endif if (!bl_update) { #ifdef PAT_CONTROL - if ((ts->cal_count == 0) || (ts->cal_count == 0xFF) || (magic_cal == true)) { - input_err(true, &ts->client->dev, "%s: RUN OFFSET CALIBRATION(0x%02X)\n", __func__, ts->cal_count); + if ((ts->cal_count == 0) || (ts->cal_count == 0xFF) || + (magic_cal == true)) { + input_err(true, &ts->client->dev, + "%s: RUN OFFSET CALIBRATION(0x%02X)\n", + __func__, ts->cal_count); - ret = sec_ts_execute_force_calibration(ts, OFFSET_CAL_SEC); + ret = sec_ts_execute_force_calibration(ts, + OFFSET_CAL_SEC); if (ret < 0) - input_err(true, &ts->client->dev, "%s: fail to write OFFSET CAL SEC!\n", __func__); + input_err(true, &ts->client->dev, + "%s: fail to write OFFSET CAL SEC!\n", + __func__); #ifdef USE_PRESSURE_SENSOR - ret = sec_ts_execute_force_calibration(ts, PRESSURE_CAL); + ret = sec_ts_execute_force_calibration(ts, + PRESSURE_CAL); if (ret < 0) - input_err(true, &ts->client->dev, "%s: fail to write PRESSURE CAL!\n", __func__); + input_err(true, &ts->client->dev, + "%s: fail to write PRESSURE CAL!\n", + __func__); #endif if (ret >= 0 && magic_cal) { - ts->cal_count = get_tsp_nvm_data(ts, SEC_TS_NVM_OFFSET_CAL_COUNT); - if (ts->cal_count == 0x00 || ts->cal_count == 0xFF) + ts->cal_count = get_tsp_nvm_data(ts, + SEC_TS_NVM_OFFSET_CAL_COUNT); + if (ts->cal_count == 0x00 || + ts->cal_count == 0xFF) ts->cal_count = PAT_MAGIC_NUMBER; - else if (PAT_MAGIC_NUMBER <= ts->cal_count && ts->cal_count < PAT_MAX_MAGIC) + else if (ts->cal_count >= PAT_MAGIC_NUMBER && + ts->cal_count < PAT_MAX_MAGIC) ts->cal_count++; - /* Use TSP NV area : in this model, use only one byte + /* Use TSP NV area : in this model, use only + * one byte * buff[0] : offset from user NVM storage - * buff[1] : length of stored data - 1 (ex. using 1byte, value is 1 - 1 = 0) + * buff[1] : length of stored data - 1 (ex. + * using 1byte, value is 1 - 1 = 0) * buff[2] : write data - */ + **/ buff[0] = SEC_TS_NVM_OFFSET_CAL_COUNT; buff[1] = 0; buff[2] = ts->cal_count; - ret = ts->sec_ts_write(ts, SEC_TS_CMD_NVM, buff, 3); + ret = ts->sec_ts_write(ts, SEC_TS_CMD_NVM, + buff, 3); if (ret < 0) input_err(true, &ts->client->dev, - "%s: nvm write failed. ret: %d\n", __func__, ret); + "%s: nvm write failed. ret: %d\n", + __func__, ret); sec_ts_delay(20); - ts->cal_count = get_tsp_nvm_data(ts, SEC_TS_NVM_OFFSET_CAL_COUNT); - input_info(true, &ts->client->dev, "%s: cal_count = [%02X]\n", - __func__, ts->cal_count); + ts->cal_count = get_tsp_nvm_data(ts, + SEC_TS_NVM_OFFSET_CAL_COUNT); + input_info(true, &ts->client->dev, + "%s: cal_count = [%02X]\n", + __func__, ts->cal_count); } - ret = ts->sec_ts_read(ts, SEC_TS_READ_IMG_VERSION, img_ver, 4); + ret = ts->sec_ts_read(ts, SEC_TS_READ_IMG_VERSION, + img_ver, 4); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: Image version read error\n", __func__); + input_err(true, &ts->client->dev, + "%s: Image version read error\n", __func__); } else { memset(buff, 0x00, SEC_CMD_STR_LEN); - buff[0] = get_tsp_nvm_data(ts, SEC_TS_NVM_OFFSET_TUNE_VERSION); + buff[0] = get_tsp_nvm_data(ts, + SEC_TS_NVM_OFFSET_TUNE_VERSION); if (buff[0] == 0xFF) { - set_tsp_nvm_data_clear(ts, SEC_TS_NVM_OFFSET_TUNE_VERSION); - set_tsp_nvm_data_clear(ts, SEC_TS_NVM_OFFSET_TUNE_VERSION+1); + set_tsp_nvm_data_clear(ts, + SEC_TS_NVM_OFFSET_TUNE_VERSION); + set_tsp_nvm_data_clear(ts, + SEC_TS_NVM_OFFSET_TUNE_VERSION + 1); } - ts->tune_fix_ver = (img_ver[2] << 8 | img_ver[3]); + ts->tune_fix_ver = (img_ver[2] << 8 | + img_ver[3]); buff[0] = SEC_TS_NVM_OFFSET_TUNE_VERSION; buff[1] = 1;// 2bytes buff[2] = img_ver[2]; buff[3] = img_ver[3]; - ret = ts->sec_ts_write(ts, SEC_TS_CMD_NVM, buff, 4); + ret = ts->sec_ts_write(ts, SEC_TS_CMD_NVM, + buff, 4); if (ret < 0) { input_err(true, &ts->client->dev, - "%s: nvm write failed. ret: %d\n", __func__, ret); + "%s: nvm write failed. ret: %d\n", + __func__, ret); } sec_ts_delay(20); - buff[0] = get_tsp_nvm_data(ts, SEC_TS_NVM_OFFSET_TUNE_VERSION); - buff[1] = get_tsp_nvm_data(ts, SEC_TS_NVM_OFFSET_TUNE_VERSION+1); + buff[0] = get_tsp_nvm_data(ts, + SEC_TS_NVM_OFFSET_TUNE_VERSION); + buff[1] = get_tsp_nvm_data(ts, + SEC_TS_NVM_OFFSET_TUNE_VERSION + 1); ts->tune_fix_ver = buff[0]<<8 | buff[1]; - input_info(true, &ts->client->dev, "%s: tune_fix_ver [%02X %02X]\n", __func__, buff[0], buff[1]); + input_info(true, &ts->client->dev, + "%s: tune_fix_ver [%02X %02X]\n", + __func__, buff[0], buff[1]); } } else { - input_err(true, &ts->client->dev, "%s: DO NOT CALIBRATION(0x%02X)\n", __func__, ts->cal_count); + input_err(true, &ts->client->dev, + "%s: DO NOT CALIBRATION(0x%02X)\n", + __func__, ts->cal_count); } #else /* auto-calibration if restore_cal = 0 */ @@ -936,42 +1060,57 @@ static int sec_ts_firmware_update(struct sec_ts_data *ts, const u8 *data, size_t /* Update calibration report */ sec_ts_read_calibration_report(ts); } else - input_info(true, &ts->client->dev, "%s: No calibration: restore_cal = %d\n", + input_info(true, &ts->client->dev, + "%s: No calibration: restore_cal = %d\n", __func__, restore_cal); #endif /* Sense_on */ ret = ts->sec_ts_write(ts, SEC_TS_CMD_SENSE_ON, NULL, 0); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: write fail, Sense_on\n", __func__); + input_err(true, &ts->client->dev, + "%s: write fail, Sense_on\n", __func__); return -EIO; } - if (ts->sec_ts_read(ts, SEC_TS_READ_BOOT_STATUS, &fw_status, 1) < 0) { - input_err(true, &ts->client->dev, "%s: read fail, read_boot_status = 0x%x\n", __func__, fw_status); + if (ts->sec_ts_read(ts, SEC_TS_READ_BOOT_STATUS, + &fw_status, 1) < 0) { + input_err(true, &ts->client->dev, + "%s: read fail, read_boot_status = 0x%x\n", + __func__, fw_status); return -EIO; } if (fw_status != SEC_TS_STATUS_APP_MODE) { - input_err(true, &ts->client->dev, "%s: fw update sequence done, BUT read_boot_status = 0x%x\n", __func__, fw_status); + input_err(true, &ts->client->dev, + "%s: fw update sequence done, BUT read_boot_status = 0x%x\n", + __func__, fw_status); return -EIO; } - input_info(true, &ts->client->dev, "%s: fw update Success! read_boot_status = 0x%x\n", __func__, fw_status); + input_info(true, &ts->client->dev, + "%s: fw update Success! read_boot_status = 0x%x\n", + __func__, fw_status); return 1; } else { if (ts->sec_ts_read(ts, SEC_TS_READ_ID, tBuff, 3) < 0) { - input_err(true, &ts->client->dev, "%s: read device id fail after bl fw download\n", __func__); + input_err(true, &ts->client->dev, + "%s: read device id fail after bl fw download\n", + __func__); return -EIO; } if (tBuff[0] == 0xA0) { - input_info(true, &ts->client->dev, "%s: bl fw download success - device id = %02X\n", __func__, tBuff[0]); + input_info(true, &ts->client->dev, + "%s: bl fw download success - device id = %02X\n", + __func__, tBuff[0]); return -EIO; } else { - input_err(true, &ts->client->dev, "%s: bl fw id does not match - device id = %02X\n", __func__, tBuff[0]); + input_err(true, &ts->client->dev, + "%s: bl fw id does not match - device id = %02X\n", + __func__, tBuff[0]); return -EIO; } } @@ -988,16 +1127,21 @@ int sec_ts_firmware_update_bl(struct sec_ts_data *ts) snprintf(fw_path, SEC_TS_MAX_FW_PATH, "%s", SEC_TS_DEFAULT_BL_NAME); - input_info(true, &ts->client->dev, "%s: initial bl update %s\n", __func__, fw_path); + input_info(true, &ts->client->dev, + "%s: initial bl update %s\n", __func__, fw_path); /* Loading Firmware------------------------------------------ */ if (request_firmware(&fw_entry, fw_path, &ts->client->dev) != 0) { - input_err(true, &ts->client->dev, "%s: bt is not available\n", __func__); + input_err(true, &ts->client->dev, + "%s: bt is not available\n", __func__); goto err_request_fw; } - input_info(true, &ts->client->dev, "%s: request bt done! size = %d\n", __func__, (int)fw_entry->size); + input_info(true, &ts->client->dev, + "%s: request bt done! size = %d\n", + __func__, (int)fw_entry->size); - result = sec_ts_firmware_update(ts, fw_entry->data, fw_entry->size, 1, 0, 0); + result = sec_ts_firmware_update(ts, fw_entry->data, fw_entry->size, + 1, 0, 0); err_request_fw: release_firmware(fw_entry); @@ -1014,15 +1158,18 @@ int sec_ts_bl_update(struct sec_ts_data *ts) ret = ts->sec_ts_write(ts, SEC_TS_READ_BL_UPDATE_STATUS, tCmd, 4); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: bl update command send fail!\n", __func__); + input_err(true, &ts->client->dev, + "%s: bl update command send fail!\n", __func__); goto err; } sec_ts_delay(10); do { - ret = ts->sec_ts_read(ts, SEC_TS_READ_BL_UPDATE_STATUS, tBuff, 1); + ret = ts->sec_ts_read(ts, SEC_TS_READ_BL_UPDATE_STATUS, + tBuff, 1); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: read bl update status fail!\n", __func__); + input_err(true, &ts->client->dev, + "%s: read bl update status fail!\n", __func__); goto err; } sec_ts_delay(2); @@ -1033,17 +1180,21 @@ int sec_ts_bl_update(struct sec_ts_data *ts) tCmd[1] = 0xAC; ret = ts->sec_ts_write(ts, 0x57, tCmd, 2); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: write passwd fail!\n", __func__); + input_err(true, &ts->client->dev, + "%s: write passwd fail!\n", __func__); goto err; } ret = ts->sec_ts_read(ts, SEC_TS_READ_ID, tBuff, 3); if (tBuff[0] == 0xB4) { - input_info(true, &ts->client->dev, "%s: bl update completed!\n", __func__); + input_info(true, &ts->client->dev, + "%s: bl update completed!\n", __func__); ret = 1; } else { - input_info(true, &ts->client->dev, "%s: bl updated but bl version not matching, ver=%02X\n", __func__, tBuff[0]); + input_info(true, &ts->client->dev, + "%s: bl updated but bl version not matching, ver=%02X\n", + __func__, tBuff[0]); goto err; } @@ -1061,12 +1212,14 @@ int sec_ts_firmware_update_on_probe(struct sec_ts_data *ts, bool force_update) int ret = 0; if (ts->plat_data->bringup == 1 && ts->is_fw_corrupted == false) { - input_err(true, &ts->client->dev, "%s: bringup. do not update\n", __func__); + input_err(true, &ts->client->dev, + "%s: bringup. do not update\n", __func__); return 0; } if (ts->plat_data->firmware_name) - snprintf(fw_path, SEC_TS_MAX_FW_PATH, "%s", ts->plat_data->firmware_name); + snprintf(fw_path, SEC_TS_MAX_FW_PATH, "%s", + ts->plat_data->firmware_name); else return 0; @@ -1075,69 +1228,96 @@ int sec_ts_firmware_update_on_probe(struct sec_ts_data *ts, bool force_update) /* read cal status */ ts->cal_status = sec_ts_read_calibration_report(ts); - input_info(true, &ts->client->dev, "%s: initial firmware update %s, cal:%X\n", - __func__, fw_path, ts->cal_status); + input_info(true, &ts->client->dev, + "%s: initial firmware update %s, cal:%X\n", + __func__, fw_path, ts->cal_status); /* Loading Firmware */ if (request_firmware(&fw_entry, fw_path, &ts->client->dev) != 0) { - input_err(true, &ts->client->dev, "%s: firmware is not available\n", __func__); + input_err(true, &ts->client->dev, + "%s: firmware is not available\n", __func__); goto err_request_fw; } - input_info(true, &ts->client->dev, "%s: request firmware done! size = %d\n", __func__, (int)fw_entry->size); + input_info(true, &ts->client->dev, + "%s: request firmware done! size = %d\n", + __func__, (int)fw_entry->size); result = sec_ts_check_firmware_version(ts, fw_entry->data); if (ts->plat_data->bringup == 2 && ts->is_fw_corrupted == false) { - input_err(true, &ts->client->dev, "%s: bringup. do not update\n", __func__); + input_err(true, &ts->client->dev, + "%s: bringup. do not update\n", __func__); result = 0; goto err_request_fw; } #ifdef PAT_CONTROL - /* ic fw ver > bin fw ver && force is false*/ + /* ic fw ver > bin fw ver && force is false + **/ if ((result <= 0) && (!force_update)) { - /* clear nv, forced f/w update eventhough same f/w, then apply pat magic */ + /* clear nv, forced f/w update eventhough same f/w, + * then apply pat magic + **/ if (ts->plat_data->pat_function == PAT_CONTROL_FORCE_UPDATE) { - input_info(true, &ts->client->dev, "%s: run forced f/w update and excute autotune\n", __func__); + input_info(true, &ts->client->dev, + "%s: run forced f/w update and excute autotune\n", + __func__); } else { - input_info(true, &ts->client->dev, "%s: skip - fw update & nv read\n", __func__); + input_info(true, &ts->client->dev, + "%s: skip - fw update & nv read\n", + __func__); goto err_request_fw; } } ts->cal_count = get_tsp_nvm_data(ts, SEC_TS_NVM_OFFSET_CAL_COUNT); - input_info(true, &ts->client->dev, "%s: cal_count [%02X]\n", __func__, ts->cal_count); + input_info(true, &ts->client->dev, + "%s: cal_count [%02X]\n", __func__, ts->cal_count); /* initialize nv default value from 0xff to 0x00 */ if (ts->cal_count == 0xFF) { set_tsp_nvm_data_clear(ts, SEC_TS_NVM_OFFSET_CAL_COUNT); set_tsp_nvm_data_clear(ts, SEC_TS_NVM_OFFSET_TUNE_VERSION); set_tsp_nvm_data_clear(ts, SEC_TS_NVM_OFFSET_TUNE_VERSION+1); - input_info(true, &ts->client->dev, "%s: initialize nv as default value & excute autotune\n", __func__); + input_info(true, &ts->client->dev, + "%s: initialize nv as default value & excute autotune\n", + __func__); } - ts->tune_fix_ver = (get_tsp_nvm_data(ts, SEC_TS_NVM_OFFSET_TUNE_VERSION) << 8) | get_tsp_nvm_data(ts, SEC_TS_NVM_OFFSET_TUNE_VERSION+1); - input_info(true, &ts->client->dev, "%s: tune_fix_ver [%04X] afe_base [%04X]\n", __func__, ts->tune_fix_ver, ts->plat_data->afe_base); + ts->tune_fix_ver = (get_tsp_nvm_data(ts, + SEC_TS_NVM_OFFSET_TUNE_VERSION) << 8) | + get_tsp_nvm_data(ts, + SEC_TS_NVM_OFFSET_TUNE_VERSION + 1); + input_info(true, &ts->client->dev, + "%s: tune_fix_ver [%04X] afe_base [%04X]\n", + __func__, ts->tune_fix_ver, ts->plat_data->afe_base); /* check dt to clear pat */ - if (ts->plat_data->pat_function == PAT_CONTROL_CLEAR_NV || ts->plat_data->pat_function == PAT_CONTROL_FORCE_UPDATE) + if (ts->plat_data->pat_function == PAT_CONTROL_CLEAR_NV || + ts->plat_data->pat_function == PAT_CONTROL_FORCE_UPDATE) set_tsp_nvm_data_clear(ts, SEC_TS_NVM_OFFSET_CAL_COUNT); ts->cal_count = get_tsp_nvm_data(ts, SEC_TS_NVM_OFFSET_CAL_COUNT); - /* mismatch calibration - ic has too old calibration data after pat enabled*/ + /* mismatch calibration - + * ic has too old calibration data after pat enabled + **/ if (ts->plat_data->afe_base > ts->tune_fix_ver) { restore_cal = 1; set_tsp_nvm_data_clear(ts, SEC_TS_NVM_OFFSET_CAL_COUNT); - ts->cal_count = get_tsp_nvm_data(ts, SEC_TS_NVM_OFFSET_CAL_COUNT); + ts->cal_count = get_tsp_nvm_data(ts, + SEC_TS_NVM_OFFSET_CAL_COUNT); } - input_info(true, &ts->client->dev, "%s: cal_count [%02X]\n", __func__, ts->cal_count); + input_info(true, &ts->client->dev, + "%s: cal_count [%02X]\n", __func__, ts->cal_count); #else /* ic firmware version >= binary firmare version - * && forced is FALSE */ - /* ic fw ver > bin fw ver && force is false*/ + * && forced is FALSE + * ic fw ver > bin fw ver && force is false + **/ if ((result <= 0) && (!force_update)) { - input_info(true, &ts->client->dev, "%s: skip fw update\n", __func__); + input_info(true, &ts->client->dev, + "%s: skip fw update\n", __func__); goto err_request_fw; } #endif @@ -1157,7 +1337,8 @@ int sec_ts_firmware_update_on_probe(struct sec_ts_data *ts, bool force_update) restore_cal = 1; for (ii = 0; ii < 3; ii++) { - ret = sec_ts_firmware_update(ts, fw_entry->data, fw_entry->size, 0, restore_cal, ii); + ret = sec_ts_firmware_update(ts, fw_entry->data, + fw_entry->size, 0, restore_cal, ii); if (ret >= 0) break; } @@ -1167,11 +1348,15 @@ int sec_ts_firmware_update_on_probe(struct sec_ts_data *ts, bool force_update) } else { result = 0; #ifdef PAT_CONTROL - /* change cal_count from 0 to magic number to make virtual pure auto tune */ - if ((ts->cal_count == 0 && ts->plat_data->pat_function == PAT_CONTROL_PAT_MAGIC)|| - (ts->plat_data->pat_function == PAT_CONTROL_FORCE_UPDATE)) { + /* change cal_count from 0 to magic number to make virtual + * pure auto tune + **/ + if ((ts->cal_count == 0 + && ts->plat_data->pat_function == PAT_CONTROL_PAT_MAGIC) || + (ts->plat_data->pat_function == PAT_CONTROL_FORCE_UPDATE)) { set_pat_magic_number(ts); - ts->cal_count = get_tsp_nvm_data(ts, SEC_TS_NVM_OFFSET_CAL_COUNT); + ts->cal_count = get_tsp_nvm_data(ts, + SEC_TS_NVM_OFFSET_CAL_COUNT); } #endif } @@ -1194,22 +1379,29 @@ static int sec_ts_load_fw_from_bin(struct sec_ts_data *ts) disable_irq(ts->client->irq); if (!ts->plat_data->firmware_name) - snprintf(fw_path, SEC_TS_MAX_FW_PATH, "%s", SEC_TS_DEFAULT_FW_NAME); + snprintf(fw_path, SEC_TS_MAX_FW_PATH, "%s", + SEC_TS_DEFAULT_FW_NAME); else - snprintf(fw_path, SEC_TS_MAX_FW_PATH, "%s", ts->plat_data->firmware_name); + snprintf(fw_path, SEC_TS_MAX_FW_PATH, "%s", + ts->plat_data->firmware_name); - input_info(true, &ts->client->dev, "%s: initial firmware update %s\n", __func__, fw_path); + input_info(true, &ts->client->dev, + "%s: initial firmware update %s\n", __func__, fw_path); /* Loading Firmware */ if (request_firmware(&fw_entry, fw_path, &ts->client->dev) != 0) { - input_err(true, &ts->client->dev, "%s: firmware is not available\n", __func__); + input_err(true, &ts->client->dev, + "%s: firmware is not available\n", __func__); error = -1; goto err_request_fw; } - input_info(true, &ts->client->dev, "%s: request firmware done! size = %d\n", __func__, (int)fw_entry->size); + input_info(true, &ts->client->dev, + "%s: request firmware done! size = %d\n", + __func__, (int)fw_entry->size); /* use virtual pat_control - magic cal 1 */ - if (sec_ts_firmware_update(ts, fw_entry->data, fw_entry->size, 0, 1, 0) < 0) + if (sec_ts_firmware_update(ts, fw_entry->data, fw_entry->size, + 0, 1, 0) < 0) error = -1; else error = 0; @@ -1263,16 +1455,21 @@ static int sec_ts_load_fw_from_ums(struct sec_ts_data *ts) error = -EIO; } else { fw_hd = (fw_header *)fw_data; -/* - sec_ts_check_firmware_version(ts, fw_data); -*/ - input_info(true, &ts->client->dev, "%s: firmware version %08X\n", __func__, fw_hd->fw_ver); - input_info(true, &ts->client->dev, "%s: parameter version %08X\n", __func__, fw_hd->para_ver); + /* + * sec_ts_check_firmware_version(ts, fw_data); + **/ + input_info(true, &ts->client->dev, + "%s: firmware version %08X\n", + __func__, fw_hd->fw_ver); + input_info(true, &ts->client->dev, + "%s: parameter version %08X\n", + __func__, fw_hd->para_ver); if (ts->client->irq) disable_irq(ts->client->irq); /* use virtual pat_control - magic cal 1 */ - if (sec_ts_firmware_update(ts, fw_data, fw_size, 0, 1, 0) < 0) + if (sec_ts_firmware_update(ts, fw_data, fw_size, + 0, 1, 0) < 0) goto done; sec_ts_save_version_of_ic(ts); @@ -1303,14 +1500,18 @@ static int sec_ts_load_fw_from_ffu(struct sec_ts_data *ts) disable_irq(ts->client->irq); - input_info(true, ts->dev, "%s: Load firmware : %s\n", __func__, fw_path); + input_info(true, ts->dev, + "%s: Load firmware : %s\n", __func__, fw_path); /* Loading Firmware */ if (request_firmware(&fw_entry, fw_path, &ts->client->dev) != 0) { - input_err(true, &ts->client->dev, "%s: firmware is not available\n", __func__); + input_err(true, &ts->client->dev, + "%s: firmware is not available\n", __func__); goto err_request_fw; } - input_info(true, &ts->client->dev, "%s: request firmware done! size = %d\n", __func__, (int)fw_entry->size); + input_info(true, &ts->client->dev, + "%s: request firmware done! size = %d\n", + __func__, (int)fw_entry->size); sec_ts_check_firmware_version(ts, fw_entry->data); @@ -1342,7 +1543,8 @@ err_request_fw: return result; } -int sec_ts_firmware_update_on_hidden_menu(struct sec_ts_data *ts, int update_type) +int sec_ts_firmware_update_on_hidden_menu(struct sec_ts_data *ts, + int update_type) { int ret = 0; @@ -1394,3 +1596,4 @@ int sec_ts_firmware_update_on_hidden_menu(struct sec_ts_data *ts, int update_typ return ret; } EXPORT_SYMBOL(sec_ts_firmware_update_on_hidden_menu); + diff --git a/sec_ts_only_vendor.c b/sec_ts_only_vendor.c index bc272d0..d4a740b 100644 --- a/sec_ts_only_vendor.c +++ b/sec_ts_only_vendor.c @@ -96,7 +96,7 @@ static struct attribute_group cmd_attr_group = { .attrs = cmd_attributes, }; -/* for debugging--------------------------------------------------------------------------------------*/ +/* for debugging-------------------------------------------------------------*/ static void sec_ts_parsing_cmds(struct device *dev, const char *buf, size_t size, bool write) { @@ -207,9 +207,9 @@ static ssize_t sec_ts_reg_manual_store(struct device *dev, ts->sec_ts_write_burst(ts, cmd_buf, cmd_buf_num); input_info(true, &ts->client->dev, - "%s: size %d, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x\n", __func__, - cmd_buf_num, cmd_buf[0], cmd_buf[1], cmd_buf[2], - cmd_buf[3], cmd_buf[4]); + "%s: size %d, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x\n", + __func__, cmd_buf_num, cmd_buf[0], cmd_buf[1], + cmd_buf[2], cmd_buf[3], cmd_buf[4]); } return size; @@ -310,7 +310,8 @@ static ssize_t sec_ts_reg_store(struct device *dev, struct sec_ts_data *ts = dev_get_drvdata(dev); if (ts->power_status == SEC_TS_STATE_POWER_OFF) { - input_info(true, &ts->client->dev, "%s: Power off state\n", __func__); + input_info(true, &ts->client->dev, "%s: Power off state\n", + __func__); return -EIO; } @@ -323,13 +324,15 @@ static ssize_t sec_ts_reg_store(struct device *dev, return size; } -static ssize_t sec_ts_regread_show(struct device *dev, struct device_attribute *attr, char *buf) +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; if (ts->power_status == SEC_TS_STATE_POWER_OFF) { - input_err(true, &ts->client->dev, "%s: Power off state\n", __func__); + input_err(true, &ts->client->dev, "%s: Power off state\n", + __func__); return -EIO; } @@ -348,7 +351,8 @@ static ssize_t sec_ts_regread_show(struct device *dev, struct device_attribute * goto i2c_err; } - input_info(true, &ts->client->dev, "%s: lv1_readsize = %d\n", __func__, lv1_readsize); + 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: @@ -361,22 +365,27 @@ malloc_err: return lv1_readsize; } -static ssize_t sec_ts_gesture_status_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) { 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]); + "%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) +static ssize_t sec_ts_regreadsize_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t size) { struct sec_ts_data *ts = dev_get_drvdata(dev); @@ -384,7 +393,9 @@ static ssize_t sec_ts_regreadsize_store(struct device *dev, struct device_attrib 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); + ((unsigned int)buf[3] << 16) | + ((unsigned int) buf[2] << 8) | + ((unsigned int)buf[1] << 0); lv1_readoffset = 0; lv1_readremain = 0; @@ -393,7 +404,9 @@ static ssize_t sec_ts_regreadsize_store(struct device *dev, struct device_attrib return size; } -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_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 = ts->plat_data; @@ -411,14 +424,20 @@ static ssize_t sec_ts_enter_recovery_store(struct device *dev, struct device_att disable_irq(ts->client->irq); gpio_free(pdata->irq_gpio); - input_info(true, &ts->client->dev, "%s: gpio free\n", __func__); + input_info(true, &ts->client->dev, + "%s: gpio free\n", __func__); if (gpio_is_valid(pdata->irq_gpio)) { - ret = gpio_request_one(pdata->irq_gpio, GPIOF_OUT_INIT_LOW, "sec,tsp_int"); - input_info(true, &ts->client->dev, "%s: gpio request one\n", __func__); + ret = gpio_request_one(pdata->irq_gpio, + GPIOF_OUT_INIT_LOW, "sec,tsp_int"); + input_info(true, &ts->client->dev, + "%s: gpio request one\n", __func__); if (ret < 0) - input_err(true, &ts->client->dev, "%s: Unable to request tsp_int [%d]: %d\n", __func__, pdata->irq_gpio, ret); + input_err(true, &ts->client->dev, + "%s: Unable to request tsp_int [%d]: %d\n", + __func__, pdata->irq_gpio, ret); } else { - input_err(true, &ts->client->dev, "%s: Failed to get irq gpio\n", __func__); + input_err(true, &ts->client->dev, + "%s: Failed to get irq gpio\n", __func__); return -EINVAL; } @@ -429,13 +448,17 @@ static ssize_t sec_ts_enter_recovery_store(struct device *dev, struct device_att gpio_free(pdata->irq_gpio); if (gpio_is_valid(pdata->irq_gpio)) { - ret = gpio_request_one(pdata->irq_gpio, GPIOF_DIR_IN, "sec,tsp_int"); + ret = gpio_request_one(pdata->irq_gpio, GPIOF_DIR_IN, + "sec,tsp_int"); if (ret) { - input_err(true, &ts->client->dev, "%s: Unable to request tsp_int [%d]\n", __func__, pdata->irq_gpio); + input_err(true, &ts->client->dev, + "%s: Unable to request tsp_int [%d]\n", + __func__, pdata->irq_gpio); return -EINVAL; } } else { - input_err(true, &ts->client->dev, "%s: Failed to get irq gpio\n", __func__); + input_err(true, &ts->client->dev, + "%s: Failed to get irq gpio\n", __func__); return -EINVAL; } @@ -445,9 +468,11 @@ static ssize_t sec_ts_enter_recovery_store(struct device *dev, struct device_att sec_ts_delay(500); /* AFE Calibration */ - ret = ts->sec_ts_write(ts, SEC_TS_CMD_CALIBRATION_AMBIENT, NULL, 0); + ret = ts->sec_ts_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__); + input_err(true, &ts->client->dev, + "%s: fail to write AFE_CAL\n", __func__); sec_ts_delay(1000); enable_irq(ts->client->irq); @@ -463,7 +488,8 @@ static inline ssize_t sec_ts_show_error(struct device *dev, { struct sec_ts_data *ts = dev_get_drvdata(dev); - input_err(true, &ts->client->dev, "%s: read only function, %s\n", __func__, attr->attr.name); + input_err(true, &ts->client->dev, + "%s: read only function, %s\n", __func__, attr->attr.name); return -EPERM; } @@ -472,7 +498,8 @@ static inline ssize_t sec_ts_store_error(struct device *dev, { struct sec_ts_data *ts = dev_get_drvdata(dev); - input_err(true, &ts->client->dev, "%s: write only function, %s\n", __func__, attr->attr.name); + input_err(true, &ts->client->dev, + "%s: write only function, %s\n", __func__, attr->attr.name); return -EPERM; } @@ -487,13 +514,15 @@ int sec_ts_raw_device_init(struct sec_ts_data *ts) #endif ret = IS_ERR(ts->dev); if (ret) { - input_err(true, &ts->client->dev, "%s: fail - device_create\n", __func__); + input_err(true, &ts->client->dev, + "%s: fail - device_create\n", __func__); return ret; } ret = sysfs_create_group(&ts->dev->kobj, &cmd_attr_group); if (ret < 0) { - input_err(true, &ts->client->dev, "%s: fail - sysfs_create_group\n", __func__); + input_err(true, &ts->client->dev, + "%s: fail - sysfs_create_group\n", __func__); goto err_sysfs; } |