aubrey/kernel_samsung_a34x-permissive
1
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity
kernel_samsung_a34x-permissive/drivers/input/touchscreen/gt9895/sec_cmd.c
Fede2782 6db4831e98
Import A346BXXU4BWK2 kernel source 
Android 14
2024-04-28 15:51:13 +02:00

1108 lines
30 KiB
C
Raw Blame History

/*
* sec_cmd.c - samsung input command driver
*
* Copyright (C) 2014 Samsung Electronics
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
*/
#include "sec_cmd.h"
#include "sec_input.h"
#include "sec_tsp_log.h"
struct class *tsp_sec_class;
#if IS_ENABLED(CONFIG_SEC_KUNIT)
__visible_for_testing struct sec_cmd_data *kunit_sec;
EXPORT_SYMBOL(kunit_sec);
#else
#define __visible_for_testing static
#endif
#if IS_ENABLED(CONFIG_TOUCHSCREEN_DUAL_FOLDABLE)
static struct sec_cmd_data *main_sec;
static struct sec_cmd_data *sub_sec;
#endif
#ifdef USE_SEC_CMD_QUEUE
static void sec_cmd_store_function(struct sec_cmd_data *data);
void sec_cmd_execution(struct sec_cmd_data *data, bool lock)
{
if (lock)
mutex_lock(&data->fs_lock);
/* check lock */
mutex_lock(&data->cmd_lock);
data->cmd_is_running = true;
mutex_unlock(&data->cmd_lock);
data->cmd_state = SEC_CMD_STATUS_RUNNING;
sec_cmd_store_function(data);
if (lock)
mutex_unlock(&data->fs_lock);
}
#endif
void sec_cmd_set_cmd_exit(struct sec_cmd_data *data)
{
#ifdef USE_SEC_CMD_QUEUE
mutex_lock(&data->fifo_lock);
if (kfifo_len(&data->cmd_queue)) {
pr_info("%s: %s %s: do next cmd, left cmd[%d]\n", dev_name(data->fac_dev), SECLOG, __func__,
(int)(kfifo_len(&data->cmd_queue) / sizeof(struct command)));
mutex_unlock(&data->fifo_lock);
#if IS_ENABLED(CONFIG_TOUCHSCREEN_DUAL_FOLDABLE)
sec_cmd_execution(data, false);
#else
schedule_work(&data->cmd_work.work);
#endif
} else {
mutex_unlock(&data->fifo_lock);
mutex_lock(&data->cmd_lock);
data->cmd_is_running = false;
mutex_unlock(&data->cmd_lock);
}
if (data->wait_cmd_result_done)
complete_all(&data->cmd_result_done);
#else
mutex_lock(&data->cmd_lock);
data->cmd_is_running = false;
mutex_unlock(&data->cmd_lock);
#endif
}
EXPORT_SYMBOL(sec_cmd_set_cmd_exit);
#ifdef USE_SEC_CMD_QUEUE
static void cmd_exit_work(struct work_struct *work)
{
struct sec_cmd_data *data = container_of(work, struct sec_cmd_data, cmd_work.work);
sec_cmd_execution(data, true);
}
#endif
void sec_cmd_set_default_result(struct sec_cmd_data *data)
{
char *delim = ":";
memset(data->cmd_result, 0x00, SEC_CMD_RESULT_STR_LEN_EXPAND);
memcpy(data->cmd_result, data->cmd, SEC_CMD_STR_LEN);
strlcat(data->cmd_result, delim, SEC_CMD_RESULT_STR_LEN_EXPAND);
}
EXPORT_SYMBOL(sec_cmd_set_default_result);
void sec_cmd_set_cmd_result_all(struct sec_cmd_data *data, char *buff, int len, char *item)
{
char *delim1 = " ";
char *delim2 = ":";
int cmd_result_len;
cmd_result_len = (int)strlen(data->cmd_result_all) + len + 2 + (int)strlen(item);
if (cmd_result_len >= SEC_CMD_RESULT_STR_LEN) {
pr_err("%s: %s %s: cmd length is over (%d)!!", dev_name(data->fac_dev), SECLOG, __func__, cmd_result_len);
return;
}
data->item_count++;
strlcat(data->cmd_result_all, delim1, sizeof(data->cmd_result_all));
strlcat(data->cmd_result_all, item, sizeof(data->cmd_result_all));
strlcat(data->cmd_result_all, delim2, sizeof(data->cmd_result_all));
strlcat(data->cmd_result_all, buff, sizeof(data->cmd_result_all));
}
EXPORT_SYMBOL(sec_cmd_set_cmd_result_all);
void sec_cmd_set_cmd_result(struct sec_cmd_data *data, char *buff, int len)
{
if (strlen(buff) >= (unsigned int)SEC_CMD_RESULT_STR_LEN_EXPAND) {
pr_err("%s %s: cmd length is over (%d)!!", SECLOG, __func__, (int)strlen(buff));
strlcat(data->cmd_result, "NG", SEC_CMD_RESULT_STR_LEN_EXPAND);
return;
}
data->cmd_result_expand = (int)strlen(buff) / SEC_CMD_RESULT_STR_LEN;
data->cmd_result_expand_count = 0;
strlcat(data->cmd_result, buff, SEC_CMD_RESULT_STR_LEN_EXPAND);
}
EXPORT_SYMBOL(sec_cmd_set_cmd_result);
#ifndef USE_SEC_CMD_QUEUE
__visible_for_testing ssize_t sec_cmd_store(struct device *dev,
struct device_attribute *devattr, const char *buf, size_t count)
{
struct sec_cmd_data *data = dev_get_drvdata(dev);
char *cur, *start, *end;
char buff[SEC_CMD_STR_LEN] = { 0 };
int len, i;
struct sec_cmd *sec_cmd_ptr = NULL;
char delim = ',';
bool cmd_found = false;
int param_cnt = 0;
if (!data) {
pr_err("%s %s: No platform data found\n", SECLOG, __func__);
return -EINVAL;
}
if (strnlen(buf, SEC_CMD_STR_LEN) >= SEC_CMD_STR_LEN) {
pr_err("%s: %s %s: cmd length(strlen(buf)) is over (%d,%s)!!\n",
dev_name(data->fac_dev), SECLOG, __func__, (int)strlen(buf), buf);
return -EINVAL;
}
if (count >= (unsigned int)SEC_CMD_STR_LEN) {
pr_err("%s: %s %s: cmd length(count) is over (%d,%s)!!\n",
dev_name(data->fac_dev), SECLOG, __func__, (unsigned int)count, buf);
return -EINVAL;
}
if (data->cmd_is_running == true) {
pr_err("%s: %s %s: other cmd is running.\n", dev_name(data->fac_dev), SECLOG, __func__);
return -EBUSY;
}
/* check lock */
mutex_lock(&data->cmd_lock);
data->cmd_is_running = true;
mutex_unlock(&data->cmd_lock);
data->cmd_state = SEC_CMD_STATUS_RUNNING;
for (i = 0; i < ARRAY_SIZE(data->cmd_param); i++)
data->cmd_param[i] = 0;
len = (int)count;
if (*(buf + len - 1) == '\n')
len--;
memset(data->cmd, 0x00, ARRAY_SIZE(data->cmd));
memcpy(data->cmd, buf, len);
cur = strchr(buf, (int)delim);
if (cur)
memcpy(buff, buf, cur - buf);
else
memcpy(buff, buf, len);
pr_debug("%s: %s %s: COMMAND = %s\n", dev_name(data->fac_dev), SECLOG, __func__, buff);
/* find command */
list_for_each_entry(sec_cmd_ptr, &data->cmd_list_head, list) {
if (!strncmp(buff, sec_cmd_ptr->cmd_name, SEC_CMD_STR_LEN)) {
cmd_found = true;
break;
}
}
/* set not_support_cmd */
if (!cmd_found) {
list_for_each_entry(sec_cmd_ptr, &data->cmd_list_head, list) {
if (!strncmp("not_support_cmd", sec_cmd_ptr->cmd_name,
SEC_CMD_STR_LEN))
break;
}
}
/* parsing parameters */
if (cur && cmd_found) {
cur++;
start = cur;
memset(buff, 0x00, ARRAY_SIZE(buff));
do {
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)
goto err_out;
start = cur + 1;
memset(buff, 0x00, ARRAY_SIZE(buff));
param_cnt++;
}
cur++;
} while ((cur - buf <= len) && (param_cnt < SEC_CMD_PARAM_NUM));
}
if (cmd_found) {
pr_info("%s: %s %s: cmd = %s", dev_name(data->fac_dev), SECLOG, __func__, sec_cmd_ptr->cmd_name);
for (i = 0; i < param_cnt; i++) {
if (i == 0)
pr_cont(" param =");
pr_cont(" %d", data->cmd_param[i]);
}
pr_cont("\n");
} else {
pr_info("%s: %s %s: cmd = %s(%s)\n", dev_name(data->fac_dev), SECLOG, __func__, buff, sec_cmd_ptr->cmd_name);
}
sec_cmd_ptr->cmd_func(data);
err_out:
return count;
}
#else /* defined USE_SEC_CMD_QUEUE */
static void sec_cmd_store_function(struct sec_cmd_data *data)
{
char *cur, *start, *end;
char buff[SEC_CMD_STR_LEN] = { 0 };
int len, i;
struct sec_cmd *sec_cmd_ptr = NULL;
char delim = ',';
bool cmd_found = false;
int param_cnt = 0;
int ret;
const char *buf;
size_t count;
struct command cmd = {{0}};
if (!data) {
pr_err("%s %s: No platform data found\n", SECLOG, __func__);
return;
}
mutex_lock(&data->fifo_lock);
if (kfifo_len(&data->cmd_queue)) {
ret = kfifo_out(&data->cmd_queue, &cmd, sizeof(struct command));
if (!ret) {
pr_err("%s: %s %s: kfifo_out failed, it seems empty, ret=%d\n", dev_name(data->fac_dev), SECLOG, __func__, ret);
mutex_unlock(&data->fifo_lock);
return;
}
} else {
pr_err("%s: %s %s: left cmd is nothing\n", dev_name(data->fac_dev), SECLOG, __func__);
mutex_unlock(&data->fifo_lock);
mutex_lock(&data->cmd_lock);
data->cmd_is_running = false;
mutex_unlock(&data->cmd_lock);
return;
}
mutex_unlock(&data->fifo_lock);
buf = cmd.cmd;
count = strlen(buf);
for (i = 0; i < (int)ARRAY_SIZE(data->cmd_param); i++)
data->cmd_param[i] = 0;
len = (int)count;
if (*(buf + len - 1) == '\n')
len--;
memset(data->cmd, 0x00, ARRAY_SIZE(data->cmd));
memcpy(data->cmd, buf, len);
cur = strchr(buf, (int)delim);
if (cur)
memcpy(buff, buf, cur - buf);
else
memcpy(buff, buf, len);
pr_debug("%s: %s %s: COMMAND : %s\n", dev_name(data->fac_dev), SECLOG, __func__, buff);
/* find command */
list_for_each_entry(sec_cmd_ptr, &data->cmd_list_head, list) {
if (!strncmp(buff, sec_cmd_ptr->cmd_name, SEC_CMD_STR_LEN)) {
cmd_found = true;
break;
}
}
/* set not_support_cmd */
if (!cmd_found) {
list_for_each_entry(sec_cmd_ptr, &data->cmd_list_head, list) {
if (!strncmp("not_support_cmd", sec_cmd_ptr->cmd_name,
SEC_CMD_STR_LEN))
break;
}
}
/* parsing parameters */
if (cur && cmd_found) {
cur++;
start = cur;
memset(buff, 0x00, ARRAY_SIZE(buff));
do {
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)
return;
start = cur + 1;
memset(buff, 0x00, ARRAY_SIZE(buff));
param_cnt++;
}
cur++;
} while ((cur - buf <= len) && (param_cnt < SEC_CMD_PARAM_NUM));
}
if (cmd_found) {
pr_info("%s: %s %s: cmd = %s", dev_name(data->fac_dev), SECLOG, __func__, sec_cmd_ptr->cmd_name);
for (i = 0; i < param_cnt; i++) {
if (i == 0)
pr_cont(" param =");
pr_cont(" %d", data->cmd_param[i]);
}
pr_cont("\n");
} else {
pr_info("%s: %s %s: cmd = %s(%s)\n", dev_name(data->fac_dev), SECLOG, __func__, buff, sec_cmd_ptr->cmd_name);
}
sec_cmd_ptr->cmd_func(data);
if (cmd_found && sec_cmd_ptr->cmd_log) {
char tbuf[32];
unsigned long long t;
unsigned long nanosec_rem;
memset(tbuf, 0x00, sizeof(tbuf));
t = local_clock();
nanosec_rem = do_div(t, 1000000000);
snprintf(tbuf, sizeof(tbuf), "[r:%lu.%06lu]",
(unsigned long)t,
nanosec_rem / 1000);
#if IS_ENABLED(CONFIG_SEC_DEBUG_TSP_LOG)
sec_debug_tsp_command_history(tbuf);
#endif
}
}
__visible_for_testing ssize_t sec_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 sec_cmd *sec_cmd_ptr = NULL;
int queue_size;
if (!data) {
pr_err("%s %s: No platform data found\n", SECLOG, __func__);
return -EINVAL;
}
if (strnlen(buf, SEC_CMD_STR_LEN) >= SEC_CMD_STR_LEN) {
pr_err("%s: %s %s: cmd length(strlen(buf)) is over (%d,%s)!!\n",
dev_name(data->fac_dev), SECLOG, __func__, (int)strlen(buf), buf);
return -EINVAL;
}
if (count >= (unsigned int)SEC_CMD_STR_LEN) {
pr_err("%s: %s %s: cmd length(count) is over (%d,%s)!!\n",
dev_name(data->fac_dev), SECLOG, __func__, (unsigned int)count, buf);
return -EINVAL;
}
if (strnlen(buf, SEC_CMD_STR_LEN) == 0) {
pr_err("%s: %s %s: cmd length is zero (%d,%s) count(%ld)!!\n",
dev_name(data->fac_dev), SECLOG, __func__, (int)strlen(buf), buf, count);
return -EINVAL;
}
strncpy(cmd.cmd, buf, count);
if (data->wait_cmd_result_done) {
int ret;
mutex_lock(&data->wait_lock);
if (!data->cmd_result_done.done)
pr_info("%s: %s %s: %s - waiting prev cmd...\n", dev_name(data->fac_dev), SECLOG, __func__, cmd.cmd);
ret = wait_for_completion_interruptible_timeout(&data->cmd_result_done, msecs_to_jiffies(2000));
if (ret <= 0)
pr_err("%s: %s %s: completion %d\n", dev_name(data->fac_dev), SECLOG, __func__, ret);
reinit_completion(&data->cmd_result_done);
mutex_unlock(&data->wait_lock);
}
list_for_each_entry(sec_cmd_ptr, &data->cmd_list_head, list) {
if (!strncmp(cmd.cmd, sec_cmd_ptr->cmd_name, strlen(sec_cmd_ptr->cmd_name))) {
if (sec_cmd_ptr->cmd_log) {
char task_info[40];
char tbuf[32];
unsigned long long t;
unsigned long nanosec_rem;
memset(tbuf, 0x00, sizeof(tbuf));
t = local_clock();
nanosec_rem = do_div(t, 1000000000);
snprintf(tbuf, sizeof(tbuf), "[q:%lu.%06lu]",
(unsigned long)t,
nanosec_rem / 1000);
snprintf(task_info, 40, "\n[%d:%s:%s]", current->pid, current->comm, dev_name(data->fac_dev));
#if IS_ENABLED(CONFIG_SEC_DEBUG_TSP_LOG)
sec_debug_tsp_command_history(task_info);
sec_debug_tsp_command_history(cmd.cmd);
sec_debug_tsp_command_history(tbuf);
#endif
}
break;
}
}
mutex_lock(&data->fifo_lock);
queue_size = (kfifo_len(&data->cmd_queue) / sizeof(struct command));
if (kfifo_avail(&data->cmd_queue) && (queue_size < SEC_CMD_MAX_QUEUE)) {
kfifo_in(&data->cmd_queue, &cmd, sizeof(struct command));
pr_info("%s: %s %s: push cmd: %s\n", dev_name(data->fac_dev), SECLOG, __func__, cmd.cmd);
} else {
pr_err("%s: %s %s: cmd_queue is full!!\n", dev_name(data->fac_dev), SECLOG, __func__);
kfifo_reset(&data->cmd_queue);
pr_err("%s: %s %s: cmd_queue is reset!!\n", dev_name(data->fac_dev), SECLOG, __func__);
mutex_unlock(&data->fifo_lock);
mutex_lock(&data->cmd_lock);
data->cmd_is_running = false;
mutex_unlock(&data->cmd_lock);
if (data->wait_cmd_result_done)
complete_all(&data->cmd_result_done);
return -ENOSPC;
}
if (data->cmd_is_running == true) {
pr_err("%s: %s %s: other cmd is running. Wait until previous cmd is done[%d]\n",
dev_name(data->fac_dev), SECLOG, __func__, (int)(kfifo_len(&data->cmd_queue) / sizeof(struct command)));
mutex_unlock(&data->fifo_lock);
return count;
}
mutex_unlock(&data->fifo_lock);
sec_cmd_execution(data, true);
return count;
}
#endif
__visible_for_testing ssize_t sec_cmd_show_status(struct device *dev,
struct device_attribute *devattr, char *buf)
{
struct sec_cmd_data *data = dev_get_drvdata(dev);
char buff[16] = { 0 };
if (!data) {
pr_err("%s %s: No platform data found\n", SECLOG, __func__);
return -EINVAL;
}
if (data->cmd_state == SEC_CMD_STATUS_WAITING)
snprintf(buff, sizeof(buff), "WAITING");
else if (data->cmd_state == SEC_CMD_STATUS_RUNNING)
snprintf(buff, sizeof(buff), "RUNNING");
else if (data->cmd_state == SEC_CMD_STATUS_OK)
snprintf(buff, sizeof(buff), "OK");
else if (data->cmd_state == SEC_CMD_STATUS_FAIL)
snprintf(buff, sizeof(buff), "FAIL");
else if (data->cmd_state == SEC_CMD_STATUS_EXPAND)
snprintf(buff, sizeof(buff), "EXPAND");
else if (data->cmd_state == SEC_CMD_STATUS_NOT_APPLICABLE)
snprintf(buff, sizeof(buff), "NOT_APPLICABLE");
pr_debug("%s: %s %s: %d, %s\n", dev_name(data->fac_dev), SECLOG, __func__, data->cmd_state, buff);
return snprintf(buf, SEC_CMD_BUF_SIZE, "%s\n", buff);
}
static ssize_t sec_cmd_show_status_all(struct device *dev,
struct device_attribute *devattr, char *buf)
{
struct sec_cmd_data *data = dev_get_drvdata(dev);
char buff[16] = { 0 };
if (!data) {
pr_err("%s %s: No platform data found\n", SECLOG, __func__);
return -EINVAL;
}
if (data->cmd_all_factory_state == SEC_CMD_STATUS_WAITING)
snprintf(buff, sizeof(buff), "WAITING");
else if (data->cmd_all_factory_state == SEC_CMD_STATUS_RUNNING)
snprintf(buff, sizeof(buff), "RUNNING");
else if (data->cmd_all_factory_state == SEC_CMD_STATUS_OK)
snprintf(buff, sizeof(buff), "OK");
else if (data->cmd_all_factory_state == SEC_CMD_STATUS_FAIL)
snprintf(buff, sizeof(buff), "FAIL");
else if (data->cmd_state == SEC_CMD_STATUS_EXPAND)
snprintf(buff, sizeof(buff), "EXPAND");
else if (data->cmd_all_factory_state == SEC_CMD_STATUS_NOT_APPLICABLE)
snprintf(buff, sizeof(buff), "NOT_APPLICABLE");
pr_debug("%s: %s %s: %d, %s\n", dev_name(data->fac_dev), SECLOG, __func__, data->cmd_all_factory_state, buff);
return snprintf(buf, SEC_CMD_BUF_SIZE, "%s\n", buff);
}
__visible_for_testing ssize_t sec_cmd_show_result(struct device *dev,
struct device_attribute *devattr, char *buf)
{
struct sec_cmd_data *data = dev_get_drvdata(dev);
int size;
if (!data) {
pr_err("%s %s: No platform data found\n", SECLOG, __func__);
return -EINVAL;
}
size = snprintf(buf, SEC_CMD_RESULT_STR_LEN, "%s\n",
data->cmd_result + (SEC_CMD_RESULT_STR_LEN - 1) * data->cmd_result_expand_count);
if (data->cmd_result_expand_count != data->cmd_result_expand) {
data->cmd_state = SEC_CMD_STATUS_EXPAND;
data->cmd_result_expand_count++;
} else {
data->cmd_state = SEC_CMD_STATUS_WAITING;
}
pr_info("%s: %s %s: %s\n", dev_name(data->fac_dev), SECLOG, __func__, buf);
sec_cmd_set_cmd_exit(data);
return size;
}
static ssize_t sec_cmd_show_result_all(struct device *dev,
struct device_attribute *devattr, char *buf)
{
struct sec_cmd_data *data = dev_get_drvdata(dev);
int size;
if (!data) {
pr_err("%s %s: No platform data found\n", SECLOG, __func__);
return -EINVAL;
}
data->cmd_state = SEC_CMD_STATUS_WAITING;
pr_info("%s: %s %s: %d, %s\n", dev_name(data->fac_dev), SECLOG, __func__, data->item_count, data->cmd_result_all);
size = snprintf(buf, SEC_CMD_RESULT_STR_LEN, "%d%s\n", data->item_count, data->cmd_result_all);
sec_cmd_set_cmd_exit(data);
data->item_count = 0;
memset(data->cmd_result_all, 0x00, SEC_CMD_RESULT_STR_LEN);
return size;
}
static ssize_t sec_cmd_list_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct sec_cmd_data *data = dev_get_drvdata(dev);
struct sec_cmd *sec_cmd_ptr = NULL;
char *buffer;
char buffer_name[SEC_CMD_STR_LEN];
int ret = 0;
buffer = kzalloc(data->cmd_buffer_size + 30, GFP_KERNEL);
if (!buffer)
return -ENOMEM;
snprintf(buffer, 30, "++factory command list++\n");
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);
strlcat(buffer, buffer_name, data->cmd_buffer_size + 30);
}
}
ret = snprintf(buf, SEC_CMD_BUF_SIZE, "%s\n", buffer);
kfree(buffer);
return ret;
}
static DEVICE_ATTR(cmd, 0220, NULL, sec_cmd_store);
static DEVICE_ATTR(cmd_status, 0444, sec_cmd_show_status, NULL);
static DEVICE_ATTR(cmd_status_all, 0444, sec_cmd_show_status_all, NULL);
static DEVICE_ATTR(cmd_result, 0444, sec_cmd_show_result, NULL);
static DEVICE_ATTR(cmd_result_all, 0444, sec_cmd_show_result_all, NULL);
static DEVICE_ATTR(cmd_list, 0444, sec_cmd_list_show, NULL);
static struct attribute *sec_fac_attrs[] = {
&dev_attr_cmd.attr,
&dev_attr_cmd_status.attr,
&dev_attr_cmd_status_all.attr,
&dev_attr_cmd_result.attr,
&dev_attr_cmd_result_all.attr,
&dev_attr_cmd_list.attr,
NULL,
};
static struct attribute_group sec_fac_attr_group = {
.attrs = sec_fac_attrs,
};
int sec_cmd_init(struct sec_cmd_data *data, struct sec_cmd *cmds,
int len, int devt)
{
const char *dev_name;
int ret, i;
INIT_LIST_HEAD(&data->cmd_list_head);
data->cmd_buffer_size = 0;
for (i = 0; i < len; i++) {
list_add_tail(&cmds[i].list, &data->cmd_list_head);
if (cmds[i].cmd_name)
data->cmd_buffer_size += strlen(cmds[i].cmd_name) + 1;
}
mutex_init(&data->cmd_lock);
mutex_init(&data->fs_lock);
mutex_lock(&data->cmd_lock);
data->cmd_is_running = false;
mutex_unlock(&data->cmd_lock);
data->cmd_result = kzalloc(SEC_CMD_RESULT_STR_LEN_EXPAND, GFP_KERNEL);
if (!data->cmd_result)
goto err_alloc_cmd_result;
#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__);
goto err_alloc_queue;
}
mutex_init(&data->fifo_lock);
mutex_init(&data->wait_lock);
init_completion(&data->cmd_result_done);
complete_all(&data->cmd_result_done);
INIT_DELAYED_WORK(&data->cmd_work, cmd_exit_work);
#endif
switch (devt) {
case SEC_CLASS_DEVT_TSP:
dev_name = SEC_CLASS_DEV_NAME_TSP;
break;
#if IS_ENABLED(CONFIG_TOUCHSCREEN_DUAL_FOLDABLE)
case SEC_CLASS_DEVT_TSP1:
dev_name = SEC_CLASS_DEV_NAME_TSP1;
break;
case SEC_CLASS_DEVT_TSP2:
dev_name = SEC_CLASS_DEV_NAME_TSP2;
break;
#endif
case SEC_CLASS_DEVT_TKEY:
dev_name = SEC_CLASS_DEV_NAME_TKEY;
break;
case SEC_CLASS_DEVT_WACOM:
dev_name = SEC_CLASS_DEV_NAME_WACOM;
break;
case SEC_CLASS_DEVT_SIDEKEY:
dev_name = SEC_CLASS_DEV_NAME_SIDEKEY;
break;
default:
pr_err("%s %s: not defined devt=%d\n", SECLOG, __func__, devt);
goto err_get_dev_name;
}
#if 0
/* #if IS_ENABLED(CONFIG_DRV_SAMSUNG) */
data->fac_dev = sec_device_create(data, dev_name);
#else
tsp_sec_class = class_create(THIS_MODULE, "tsp_sec");
if (unlikely(IS_ERR(tsp_sec_class))) {
pr_err("%s %s: Failed to create class(sec) %ld\n", SECLOG, __func__, PTR_ERR(tsp_sec_class));
return PTR_ERR(tsp_sec_class);
}
data->fac_dev = device_create(tsp_sec_class, NULL, devt, data, "%s", dev_name);
#endif
if (IS_ERR(data->fac_dev)) {
pr_err("%s %s: failed to create device for the sysfs\n", SECLOG, __func__);
goto err_sysfs_device;
}
dev_set_drvdata(data->fac_dev, data);
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__);
goto err_sysfs_group;
}
#if IS_ENABLED(CONFIG_TOUCHSCREEN_DUAL_FOLDABLE)
switch (devt) {
case SEC_CLASS_DEVT_TSP1:
case SEC_CLASS_DEVT_TSP2:
sec_cmd_virtual_tsp_register(data);
break;
};
#endif
pr_info("%s: %s %s: done\n", dev_name, SECLOG, __func__);
return 0;
err_sysfs_group:
#if 0
/* #if IS_ENABLED(CONFIG_DRV_SAMSUNG) */
sec_device_destroy(data->fac_dev->devt);
#else
device_destroy(tsp_sec_class, devt);
#endif
err_sysfs_device:
err_get_dev_name:
#ifdef USE_SEC_CMD_QUEUE
mutex_destroy(&data->fifo_lock);
kfifo_free(&data->cmd_queue);
mutex_destroy(&data->wait_lock);
err_alloc_queue:
#endif
kfree(data->cmd_result);
err_alloc_cmd_result:
mutex_destroy(&data->cmd_lock);
list_del(&data->cmd_list_head);
return -ENODEV;
}
EXPORT_SYMBOL(sec_cmd_init);
void sec_cmd_exit(struct sec_cmd_data *data, int devt)
{
#ifdef USE_SEC_CMD_QUEUE
struct command cmd = {{0}};
int ret;
#endif
pr_info("%s: %s %s\n", dev_name(data->fac_dev), SECLOG, __func__);
sysfs_remove_group(&data->fac_dev->kobj, &sec_fac_attr_group);
dev_set_drvdata(data->fac_dev, NULL);
#if 0
/* #if IS_ENABLED(CONFIG_DRV_SAMSUNG) */
sec_device_destroy(data->fac_dev->devt);
#else
device_destroy(tsp_sec_class, devt);
#endif
#ifdef USE_SEC_CMD_QUEUE
mutex_lock(&data->fifo_lock);
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_info("%s %s: remove pending commands: %s", SECLOG, __func__, cmd.cmd);
}
mutex_unlock(&data->fifo_lock);
mutex_destroy(&data->fifo_lock);
kfifo_free(&data->cmd_queue);
mutex_destroy(&data->wait_lock);
cancel_delayed_work_sync(&data->cmd_work);
flush_delayed_work(&data->cmd_work);
#endif
data->fac_dev = NULL;
kfree(data->cmd_result);
mutex_destroy(&data->cmd_lock);
list_del(&data->cmd_list_head);
}
EXPORT_SYMBOL(sec_cmd_exit);
void sec_cmd_send_event_to_user(struct sec_cmd_data *data, char *test, char *result)
{
char *event[5];
char timestamp[32];
char feature[32];
char stest[32];
char sresult[64];
ktime_t calltime;
u64 realtime;
int curr_time;
char *eol = "\0";
if (!data || !data->fac_dev)
return;
calltime = ktime_get();
realtime = ktime_to_ns(calltime);
do_div(realtime, NSEC_PER_USEC);
curr_time = realtime / USEC_PER_MSEC;
snprintf(timestamp, 32, "TIMESTAMP=%d", curr_time);
strncat(timestamp, eol, 1);
snprintf(feature, 32, "FEATURE=TSP");
strncat(feature, eol, 1);
if (!test) {
snprintf(stest, 32, "TEST=NULL");
} else {
snprintf(stest, 32, "%s", test);
}
strncat(stest, eol, 1);
if (!result) {
snprintf(sresult, 64, "RESULT=NULL");
} else {
snprintf(sresult, 64, "%s", result);
}
strncat(sresult, eol, 1);
pr_info("%s: %s %s: time:%s, feature:%s, test:%s, result:%s\n",
dev_name(data->fac_dev), SECLOG, __func__, timestamp, feature, stest, sresult);
event[0] = timestamp;
event[1] = feature;
event[2] = stest;
event[3] = sresult;
event[4] = NULL;
kobject_uevent_env(&data->fac_dev->kobj, KOBJ_CHANGE, event);
}
EXPORT_SYMBOL(sec_cmd_send_event_to_user);
#if IS_ENABLED(CONFIG_TOUCHSCREEN_DUAL_FOLDABLE)
void sec_cmd_virtual_tsp_register(struct sec_cmd_data *sec)
{
if (strcmp(dev_name(sec->fac_dev), SEC_CLASS_DEV_NAME_TSP1) == 0) {
main_sec = sec;
input_info(true, sec->fac_dev, "%s: main\n", __func__);
} else if (strcmp(dev_name(sec->fac_dev), SEC_CLASS_DEV_NAME_TSP2) == 0) {
sub_sec = sec;
input_info(true, sec->fac_dev, "%s: sub\n", __func__);
}
}
int sec_cmd_virtual_tsp_read_sysfs(struct sec_cmd_data *sec, const char *path, char *buf, int len)
{
int ret = 0;
mm_segment_t old_fs;
struct file *sysfs;
#if (LINUX_VERSION_CODE > KERNEL_VERSION(5, 10, 0))
return 0;
#endif
old_fs = get_fs();
set_fs(KERNEL_DS);
sysfs = filp_open(path, O_RDONLY, 0444);
if (IS_ERR(sysfs)) {
ret = PTR_ERR(sysfs);
input_err(true, sec->fac_dev, "%s: %s open fail, %d\n", __func__, path, ret);
set_fs(old_fs);
return ret;
}
ret = sysfs->f_op->read(sysfs, buf, len, &sysfs->f_pos);
if (ret < 0) {
input_err(true, sec->fac_dev, "%s: failed to read, len:%d, ret:%d\n", __func__, len, ret);
ret = -EIO;
}
filp_close(sysfs, current->files);
set_fs(old_fs);
return ret;
}
EXPORT_SYMBOL(sec_cmd_virtual_tsp_read_sysfs);
int sec_cmd_virtual_tsp_write_sysfs(struct sec_cmd_data *sec, const char *path, const char *cmd)
{
int ret = 0;
mm_segment_t old_fs;
struct file *sysfs;
int len;
#if (LINUX_VERSION_CODE > KERNEL_VERSION(5, 10, 0))
return 0;
#endif
old_fs = get_fs();
set_fs(KERNEL_DS);
sysfs = filp_open(path, O_WRONLY, 0220);
if (IS_ERR(sysfs)) {
ret = PTR_ERR(sysfs);
input_err(true, sec->fac_dev, "%s: %s open fail, %d\n", __func__, path, ret);
set_fs(old_fs);
return ret;
}
len = strlen(cmd);
ret = sysfs->f_op->write(sysfs, cmd, len, &sysfs->f_pos);
if (ret != len) {
input_err(true, sec->fac_dev, "%s: failed to write, len:%d, ret:%d\n", __func__, len, ret);
ret = -EIO;
}
filp_close(sysfs, current->files);
set_fs(old_fs);
return ret;
}
EXPORT_SYMBOL(sec_cmd_virtual_tsp_write_sysfs);
static int sec_cmd_virtual_tsp_get_cmd_status(struct sec_cmd_data *sec, char *path)
{
u8 buff[16];
int ret;
memset(buff, 0x00, sizeof(buff));
ret = sec_cmd_virtual_tsp_read_sysfs(sec, path, buff, 16);
if (ret < 0)
return SEC_CMD_STATUS_FAIL;
if (strncmp(buff, "WAITING", 7) == 0)
return SEC_CMD_STATUS_WAITING;
else if (strncmp(buff, "OK", 2) == 0)
return SEC_CMD_STATUS_OK;
else if (strncmp(buff, "FAIL", 4) == 0)
return SEC_CMD_STATUS_FAIL;
else if (strncmp(buff, "RUNNING", 7) == 0)
return SEC_CMD_STATUS_RUNNING;
else if (strncmp(buff, "EXPAND", 6) == 0)
return SEC_CMD_STATUS_EXPAND;
else
return SEC_CMD_STATUS_NOT_APPLICABLE;
}
int sec_cmd_virtual_tsp_write_cmd(struct sec_cmd_data *sec, bool main, bool sub)
{
u8 buff[16];
int ret_sub = 0;
int ret_main = 0;
bool exit = false;
sec_cmd_set_default_result(sec);
if (!main && !sub) {
snprintf(buff, sizeof(buff), "%s", "NA");
sec->cmd_state = SEC_CMD_STATUS_NOT_APPLICABLE;
goto err;
}
if (sub && sub_sec) {
input_dbg(true, sec->fac_dev, "%s: send to sub\n", sec->cmd);
ret_sub = sec_cmd_virtual_tsp_write_sysfs(sec, PATH_SUB_SEC_CMD, sec->cmd);
if (ret_sub < 0) {
snprintf(buff, sizeof(buff), "%s", "NG");
sec->cmd_state = SEC_CMD_STATUS_FAIL;
goto main;
}
sec->cmd_state = sec_cmd_virtual_tsp_get_cmd_status(sec, PATH_SUB_SEC_CMD_STATUS);
input_dbg(true, sec->fac_dev, "%s: sub_sec OK\n", sec->cmd);
if (!sub_sec->cmd_is_running)
exit = true;
sec_cmd_virtual_tsp_read_sysfs(sec, PATH_SUB_SEC_CMD_RESULT, sec->cmd_result, SEC_CMD_RESULT_STR_LEN);
memset(sec->cmd_result, 0x00, SEC_CMD_RESULT_STR_LEN_EXPAND);
sec_cmd_set_cmd_result(sec, sub_sec->cmd_result, strlen(sub_sec->cmd_result));
}
main:
if (main && main_sec) {
input_dbg(true, sec->fac_dev, "%s: send to main\n", sec->cmd);
ret_main = sec_cmd_virtual_tsp_write_sysfs(sec, PATH_MAIN_SEC_CMD, sec->cmd);
if (ret_main < 0) {
snprintf(buff, sizeof(buff), "%s", "NG");
sec->cmd_state = SEC_CMD_STATUS_FAIL;
goto err;
}
sec->cmd_state = sec_cmd_virtual_tsp_get_cmd_status(sec, PATH_MAIN_SEC_CMD_STATUS);
input_dbg(true, sec->fac_dev, "%s: main_sec OK\n", sec->cmd);
if (!main_sec->cmd_is_running)
exit = true;
sec_cmd_virtual_tsp_read_sysfs(sec, PATH_MAIN_SEC_CMD_RESULT, sec->cmd_result, SEC_CMD_RESULT_STR_LEN);
memset(sec->cmd_result, 0x00, SEC_CMD_RESULT_STR_LEN_EXPAND);
sec_cmd_set_cmd_result(sec, main_sec->cmd_result, strlen(main_sec->cmd_result));
}
if (exit) {
input_dbg(true, sec->fac_dev, "%s: set_cmd_exit\n", sec->cmd);
sec_cmd_set_cmd_exit(sec);
}
return (ret_sub < 0 || ret_main < 0) ? -1 : 0;
err:
sec_cmd_set_cmd_result(sec, buff, SEC_CMD_RESULT_STR_LEN);
sec_cmd_set_cmd_exit(sec);
return -1;
}
EXPORT_SYMBOL(sec_cmd_virtual_tsp_write_cmd);
void sec_cmd_virtual_tsp_write_cmd_factory_all(struct sec_cmd_data *sec, bool main, bool sub)
{
u8 buff[16];
int ret = 0;
sec_cmd_set_default_result(sec);
if (!main && !sub) {
snprintf(buff, sizeof(buff), "%s", "NA");
sec->cmd_state = SEC_CMD_STATUS_NOT_APPLICABLE;
goto err;
}
if (sub && sub_sec) {
input_dbg(true, sec->fac_dev, "%s: sub\n", sec->cmd);
ret = sec_cmd_virtual_tsp_write_sysfs(sec, PATH_SUB_SEC_CMD, sec->cmd);
if (ret < 0) {
snprintf(buff, sizeof(buff), "%s", "NG");
sec->cmd_all_factory_state = SEC_CMD_STATUS_FAIL;
goto main;
}
sec->cmd_all_factory_state = sec_cmd_virtual_tsp_get_cmd_status(sec, PATH_SUB_SEC_CMD_STATUS_ALL);
sec_cmd_virtual_tsp_read_sysfs(sec, PATH_SUB_SEC_CMD_RESULT_ALL, sec->cmd_result_all, SEC_CMD_RESULT_STR_LEN);
}
main:
if (main && main_sec) {
input_dbg(true, sec->fac_dev, "%s: main\n", sec->cmd);
ret = sec_cmd_virtual_tsp_write_sysfs(sec, PATH_MAIN_SEC_CMD, sec->cmd);
if (ret < 0) {
snprintf(buff, sizeof(buff), "%s", "NG");
sec->cmd_all_factory_state = SEC_CMD_STATUS_FAIL;
goto err;
}
sec->cmd_all_factory_state = sec_cmd_virtual_tsp_get_cmd_status(sec, PATH_MAIN_SEC_CMD_STATUS_ALL);
sec_cmd_virtual_tsp_read_sysfs(sec, PATH_MAIN_SEC_CMD_RESULT_ALL, sec->cmd_result_all, SEC_CMD_RESULT_STR_LEN);
}
return;
err:
sec_cmd_set_cmd_result_all(sec, buff, SEC_CMD_RESULT_STR_LEN, "NONE");
}
EXPORT_SYMBOL(sec_cmd_virtual_tsp_write_cmd_factory_all);
#endif
#if IS_ENABLED(CONFIG_SEC_KUNIT) && !IS_ENABLED(CONFIG_TOUCHSCREEN_DUAL_FOLDABLE)
kunit_notifier_chain_init(sec_cmd_test_module);
static int __init sec_cmd_m_init(void)
{
kunit_notifier_chain_register(sec_cmd_test_module);
return 0;
}
static void __exit sec_cmd_m_exit(void)
{
kunit_notifier_chain_unregister(sec_cmd_test_module);
}
module_init(sec_cmd_m_init);
module_exit(sec_cmd_m_exit);
#endif
MODULE_DESCRIPTION("Samsung input command");
MODULE_LICENSE("GPL");
Reference in a new issue View git blame Copy permalink