You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
498 lines
12 KiB
498 lines
12 KiB
/*
|
|
* sec_secure_touch.c - samsung secure touch driver
|
|
*
|
|
* Copyright (C) 2018 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.
|
|
*
|
|
*/
|
|
|
|
struct sec_secure_touch *g_ss_touch;
|
|
|
|
#undef SEC_SECURE_TOUCH_NEXT_PLAN
|
|
|
|
#include <linux/input/sec_secure_touch.h>
|
|
#include <linux/notifier.h>
|
|
|
|
int sec_secure_touch_set_device(struct sec_secure_touch *data, int dev_num);
|
|
void sec_secure_touch_sysfs_notify(struct sec_secure_touch *data);
|
|
|
|
int sec_secure_touch_set_device(struct sec_secure_touch *data, int dev_num)
|
|
{
|
|
int number = dev_num - 1;
|
|
int ret;
|
|
|
|
if (data->touch_driver[number].registered == 0)
|
|
return -ENODEV;
|
|
|
|
mutex_lock(&data->lock);
|
|
ret = sysfs_create_link(&data->device->kobj, data->touch_driver[number].kobj, "secure");
|
|
if (ret < 0) {
|
|
mutex_unlock(&data->lock);
|
|
return -EINVAL;
|
|
}
|
|
|
|
pr_info("%s: %s: create link ret:%d, %s\n", SECLOG, __func__, ret, data->touch_driver[number].kobj->name);
|
|
|
|
data->touch_driver[number].enabled = 1;
|
|
|
|
mutex_unlock(&data->lock);
|
|
|
|
return ret;
|
|
}
|
|
|
|
struct sec_touch_driver *sec_secure_touch_register(void *drv_data, int dev_num, struct kobject *kobj)
|
|
{
|
|
struct sec_secure_touch *data = g_ss_touch;
|
|
int number = dev_num - 1;
|
|
|
|
if (!data) {
|
|
pr_info("%s %s: null\n", SECLOG, __func__);
|
|
return NULL;
|
|
}
|
|
|
|
pr_info("%s %s\n", SECLOG, __func__);
|
|
|
|
if (dev_num < 1) {
|
|
dev_err(&data->pdev->dev, "%s: invalid parameter:%d\n", __func__, dev_num);
|
|
return NULL;
|
|
}
|
|
|
|
if (data->touch_driver[number].registered) {
|
|
dev_info(&data->pdev->dev, "%s: already registered device number\n", __func__);
|
|
return NULL;
|
|
}
|
|
|
|
pr_info("%s %s: name is %s\n", SECLOG, __func__, kobj->name);
|
|
data->touch_driver[number].drv_number = dev_num;
|
|
data->touch_driver[number].drv_data = drv_data;
|
|
data->touch_driver[number].kobj = kobj;
|
|
data->touch_driver[number].registered = 1;
|
|
|
|
data->device_number++;
|
|
|
|
sec_secure_touch_set_device(data, dev_num);
|
|
|
|
return &data->touch_driver[number];
|
|
}
|
|
|
|
void sec_secure_touch_unregister(int dev_num)
|
|
{
|
|
struct sec_secure_touch *data = g_ss_touch;
|
|
int number = dev_num - 1;
|
|
|
|
pr_info("%s: %s\n", SECLOG, __func__);
|
|
|
|
data->touch_driver[number].drv_number = 0;
|
|
data->touch_driver[number].drv_data = NULL;
|
|
data->touch_driver[number].kobj = NULL;
|
|
data->touch_driver[number].registered = 0;
|
|
|
|
data->device_number--;
|
|
|
|
}
|
|
|
|
void sec_secure_touch_sysfs_notify(struct sec_secure_touch *data)
|
|
{
|
|
if (!data)
|
|
sysfs_notify(&g_ss_touch->device->kobj, NULL, "secure_touch");
|
|
else
|
|
sysfs_notify(&data->device->kobj, NULL, "secure_touch");
|
|
|
|
dev_info(&g_ss_touch->pdev->dev, "%s\n", __func__);
|
|
}
|
|
|
|
#ifdef SEC_SECURE_TOUCH_NEXT_PLAN
|
|
static ssize_t secure_touch_enable_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct sec_secure_touch *data = dev_get_drvdata(dev);
|
|
|
|
if (!data)
|
|
return -ENOMEM;
|
|
|
|
if (data->device_number < 1)
|
|
return -ENODEV;
|
|
|
|
dev_info(&data->pdev->dev, "%s\n", __func__);
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%d", data->secure_enabled);
|
|
}
|
|
|
|
static ssize_t secure_touch_enable_store(struct device *dev,
|
|
struct device_attribute *addr, const char *buf, size_t count)
|
|
{
|
|
struct sec_secure_touch *data = dev_get_drvdata(dev);
|
|
int ret;
|
|
unsigned long val;
|
|
|
|
if (!data)
|
|
return -ENOMEM;
|
|
|
|
if (data->device_number < 1)
|
|
return -ENODEV;
|
|
|
|
ret = kstrtoul(buf, 10, &val);
|
|
if (ret != 0) {
|
|
pr_info("%s %s: failed to read:%d\n", SECLOG, __func__, ret);
|
|
return -EINVAL;
|
|
}
|
|
|
|
data->secure_enabled = (int)val;
|
|
pr_info("%s %s:%d\n", SECLOG, __func__, data->secure_enabled);
|
|
|
|
if (val == 1)
|
|
data->touch_drvier[data->current_device].enable(data->touch_driver[data->current_device].drv_data);
|
|
else if (val == 0)
|
|
data->touch_drvier[data->current_device].disable(data->touch_driver[data->current_device].drv_data);
|
|
else
|
|
dev_info(&data->pdev->dev, "%s: invalid value.\n", __func__);
|
|
|
|
return count;
|
|
}
|
|
|
|
static ssize_t secure_touch_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct sec_secure_touch *data = dev_get_drvdata(dev);
|
|
|
|
if (!data)
|
|
return -ENOMEM;
|
|
|
|
if (data->device_number < 1)
|
|
return -ENODEV;
|
|
|
|
dev_info(&data->pdev->dev, "%s\n", __func__);
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%u", data->secure_enabled);
|
|
}
|
|
|
|
static ssize_t secure_ownership_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
return snprintf(buf, PAGE_SIZE, "1");
|
|
}
|
|
|
|
static ssize_t virtual_hall_ic_store(struct device *dev,
|
|
struct device_attribute *addr, const char *buf, size_t count)
|
|
{
|
|
struct sec_secure_touch *data = dev_get_drvdata(dev);
|
|
int ret;
|
|
unsigned long val;
|
|
|
|
if (!data)
|
|
return -ENOMEM;
|
|
|
|
if (data->device_number < 1)
|
|
return -ENODEV;
|
|
|
|
ret = kstrtoul(buf, 10, &val);
|
|
if (ret != 0) {
|
|
pr_info("%s %s: failed to read:%d\n", SECLOG, __func__, ret);
|
|
return -EINVAL;
|
|
}
|
|
|
|
data->hall_ic = (int)val;
|
|
pr_info("%s %s:%d\n", SECLOG, __func__, data->hall_ic);
|
|
|
|
dev_info(&data->pdev->dev, "%s\n", __func__);
|
|
|
|
return count;
|
|
}
|
|
|
|
static ssize_t virtual_hall_ic_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct sec_secure_touch *data = dev_get_drvdata(dev);
|
|
|
|
if (!data)
|
|
return -ENOMEM;
|
|
|
|
if (data->device_number < 1)
|
|
return -ENODEV;
|
|
|
|
dev_info(&data->pdev->dev, "%s: %d\n", __func__, data->hall_ic);
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%u", data->hall_ic);
|
|
}
|
|
|
|
static DEVICE_ATTR(secure_touch_enable, 0664,
|
|
secure_touch_enable_show, secure_touch_enable_store);
|
|
static DEVICE_ATTR(secure_touch, 0444, secure_touch_show, NULL);
|
|
static DEVICE_ATTR(secure_ownership, 0444, secure_ownership_show, NULL);
|
|
static DEVICE_ATTR(hall_ic, 0664, virtual_hall_ic_show, virtual_hall_ic_store);
|
|
|
|
static struct attribute *sec_secure_touch_attrs[] = {
|
|
&dev_attr_secure_touch_enable.attr,
|
|
&dev_attr_secure_touch.attr,
|
|
&dev_attr_secure_ownership.attr,
|
|
&dev_attr_hall_ic.attr,
|
|
NULL,
|
|
};
|
|
|
|
#else
|
|
static ssize_t secure_dev_count_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct sec_secure_touch *data = dev_get_drvdata(dev);
|
|
|
|
if (!data)
|
|
return -ENOMEM;
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%d", data->device_number);
|
|
}
|
|
|
|
/* virtual hall ic sysfs : for Testing */
|
|
static ssize_t virtual_hall_ic_store(struct device *dev,
|
|
struct device_attribute *addr, const char *buf, size_t count)
|
|
{
|
|
struct sec_secure_touch *data = dev_get_drvdata(dev);
|
|
int ret;
|
|
unsigned long val;
|
|
|
|
if (!data)
|
|
return -ENOMEM;
|
|
|
|
if (data->device_number < 1)
|
|
return -ENODEV;
|
|
|
|
ret = kstrtoul(buf, 10, &val);
|
|
if (ret != 0) {
|
|
pr_info("%s %s: failed to read:%d\n", SECLOG, __func__, ret);
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (val == 1) {
|
|
if (data->hall_ic == 2)
|
|
sysfs_delete_link(&data->device->kobj, data->touch_driver[2 - 1].kobj, "secure");
|
|
|
|
ret = sysfs_create_link(&data->device->kobj, data->touch_driver[1 - 1].kobj, "secure");
|
|
pr_info("%s: %s: create link ret:%d\n", SECLOG, __func__, ret);
|
|
if (ret < 0)
|
|
return -EINVAL;
|
|
} else if (val == 2) {
|
|
if (data->hall_ic == 1)
|
|
sysfs_delete_link(&data->device->kobj, data->touch_driver[1 - 1].kobj, "secure");
|
|
|
|
ret = sysfs_create_link(&data->device->kobj, data->touch_driver[2 - 1].kobj, "secure");
|
|
pr_info("%s: %s: create link ret:%d\n", SECLOG, __func__, ret);
|
|
if (ret < 0)
|
|
return -EINVAL;
|
|
} else if (val == 0) {
|
|
sysfs_delete_link(&data->device->kobj, data->touch_driver[data->hall_ic - 1].kobj, "secure");
|
|
pr_info("%s: %s: delete previous link\n", SECLOG, __func__);
|
|
} else {
|
|
return -EINVAL;
|
|
}
|
|
|
|
data->hall_ic = (int)val;
|
|
pr_info("%s %s:%d\n", SECLOG, __func__, data->hall_ic);
|
|
|
|
dev_info(&data->pdev->dev, "%s\n", __func__);
|
|
|
|
return count;
|
|
}
|
|
|
|
static ssize_t virtual_hall_ic_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct sec_secure_touch *data = dev_get_drvdata(dev);
|
|
|
|
if (!data)
|
|
return -ENOMEM;
|
|
|
|
if (data->device_number < 1)
|
|
return -ENODEV;
|
|
|
|
dev_info(&data->pdev->dev, "%s: %d\n", __func__, data->hall_ic);
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%u", data->hall_ic);
|
|
}
|
|
|
|
static DEVICE_ATTR(virtual_hall_ic, 0664, virtual_hall_ic_show, virtual_hall_ic_store);
|
|
static DEVICE_ATTR(dev_count, 0444, secure_dev_count_show, NULL);
|
|
|
|
static struct attribute *sec_secure_touch_attrs[] = {
|
|
&dev_attr_virtual_hall_ic.attr,
|
|
&dev_attr_dev_count.attr,
|
|
NULL,
|
|
};
|
|
#endif
|
|
|
|
static struct attribute_group sec_secure_touch_attr_group = {
|
|
.attrs = sec_secure_touch_attrs,
|
|
};
|
|
|
|
#ifdef CONFIG_TOUCHSCREEN_DUAL_FOLDABLE
|
|
static int sec_secure_touch_hall_ic_notifier(struct notifier_block *nb, unsigned long cover, void *ptr)
|
|
{
|
|
struct sec_secure_touch *data = container_of(nb, struct sec_secure_touch, nb);
|
|
int ret;
|
|
|
|
if (!data)
|
|
return -ENOMEM;
|
|
|
|
if (data->device_number < 1)
|
|
return -ENODEV;
|
|
|
|
pr_info("%s %s: device number:%d\n", SECLOG, __func__, data->device_number);
|
|
|
|
mutex_lock(&data->lock);
|
|
if (cover == 0) {
|
|
if (data->touch_driver[1].enabled) {
|
|
sysfs_delete_link(&data->device->kobj, data->touch_driver[1].kobj, "secure");
|
|
data->touch_driver[1].enabled = 0;
|
|
}
|
|
|
|
if (data->touch_driver[0].registered) {
|
|
ret = sysfs_create_link(&data->device->kobj, data->touch_driver[0].kobj, "secure");
|
|
if (ret < 0) {
|
|
mutex_unlock(&data->lock);
|
|
return -EINVAL;
|
|
}
|
|
|
|
pr_info("%s: %s: create link ret:%d, %s\n", SECLOG, __func__, ret, data->touch_driver[0].kobj->name);
|
|
data->touch_driver[0].enabled = 1;
|
|
}
|
|
} else if (cover == 1) {
|
|
if (data->touch_driver[0].enabled) {
|
|
sysfs_delete_link(&data->device->kobj, data->touch_driver[0].kobj, "secure");
|
|
data->touch_driver[0].enabled = 0;
|
|
}
|
|
|
|
if (data->touch_driver[1].registered) {
|
|
ret = sysfs_create_link(&data->device->kobj, data->touch_driver[1].kobj, "secure");
|
|
if (ret < 0) {
|
|
mutex_unlock(&data->lock);
|
|
return -EINVAL;
|
|
}
|
|
|
|
pr_info("%s: %s: create link ret:%d, %s\n", SECLOG, __func__, ret, data->touch_driver[1].kobj->name);
|
|
data->touch_driver[1].enabled = 1;
|
|
}
|
|
} else {
|
|
mutex_unlock(&data->lock);
|
|
return -EINVAL;
|
|
}
|
|
|
|
mutex_unlock(&data->lock);
|
|
return ret;
|
|
}
|
|
#endif
|
|
|
|
static int sec_secure_touch_probe(struct platform_device *pdev)
|
|
{
|
|
struct sec_secure_touch *data;
|
|
int ret;
|
|
|
|
data = kzalloc(sizeof(struct sec_secure_touch), GFP_KERNEL);
|
|
if (!data) {
|
|
pr_info("%s %s: failed probe: mem\n", SECLOG, __func__);
|
|
return -ENOMEM;
|
|
}
|
|
data->pdev = pdev;
|
|
|
|
data->device = sec_device_create(14, data, SECURE_TOUCH_DEV_NAME);
|
|
if (IS_ERR(data->device)) {
|
|
pr_info("%s %s: failed probe: create\n", SECLOG, __func__);
|
|
kfree(data);
|
|
return -ENODEV;
|
|
}
|
|
|
|
g_ss_touch = data;
|
|
|
|
dev_set_drvdata(data->device, data);
|
|
|
|
platform_set_drvdata(pdev, data);
|
|
|
|
mutex_init(&data->lock);
|
|
|
|
ret = sysfs_create_group(&data->device->kobj, &sec_secure_touch_attr_group);
|
|
if (ret < 0) {
|
|
pr_info("%s %s: failed probe: create sysfs\n", SECLOG, __func__);
|
|
sec_device_destroy(data->device->devt);
|
|
g_ss_touch = NULL;
|
|
kfree(data);
|
|
return -ENODEV;
|
|
}
|
|
|
|
|
|
#ifdef CONFIG_TOUCHSCREEN_DUAL_FOLDABLE
|
|
data->nb.notifier_call = sec_secure_touch_hall_ic_notifier;
|
|
data->nb.priority = 1;
|
|
hall_ic_register_notify(&data->nb);
|
|
#else
|
|
sec_secure_touch_set_device(data, 1);
|
|
#endif
|
|
pr_info("%s: %s\n", SECLOG, __func__);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int sec_secure_touch_remove(struct platform_device *pdev)
|
|
{
|
|
struct sec_secure_touch *data = platform_get_drvdata(pdev);
|
|
int ii;
|
|
|
|
pr_info("%s: %s\n", SECLOG, __func__);
|
|
#ifdef CONFIG_TOUCHSCREEN_DUAL_FOLDABLE
|
|
mutex_lock(&data->lock);
|
|
hall_ic_unregister_notify(&data->nb);
|
|
mutex_unlock(&data->lock);
|
|
#endif
|
|
for (ii = 0; ii < sizeof(data->touch_driver) / sizeof(struct sec_touch_driver); ii++) {
|
|
if (data->touch_driver[ii].registered)
|
|
sysfs_delete_link(&data->device->kobj, data->touch_driver[ii].kobj, "secure");
|
|
|
|
sysfs_remove_group(&data->device->kobj, &sec_secure_touch_attr_group);
|
|
}
|
|
|
|
mutex_destroy(&data->lock);
|
|
sec_device_destroy(data->device->devt);
|
|
|
|
g_ss_touch = NULL;
|
|
kfree(data);
|
|
return 0;
|
|
}
|
|
|
|
#if CONFIG_OF
|
|
static const struct of_device_id sec_secure_touch_dt_match[] = {
|
|
{ .compatible = "samsung,ss_touch" },
|
|
{}
|
|
};
|
|
#endif
|
|
|
|
struct platform_driver sec_secure_touch_driver = {
|
|
.probe = sec_secure_touch_probe,
|
|
.remove = sec_secure_touch_remove,
|
|
.driver = {
|
|
.name = "sec_secure_touch",
|
|
.owner = THIS_MODULE,
|
|
#if CONFIG_OF
|
|
.of_match_table = sec_secure_touch_dt_match,
|
|
#endif
|
|
},
|
|
};
|
|
|
|
static int __init sec_secure_touch_init(void)
|
|
{
|
|
pr_info("%s: %s\n", SECLOG, __func__);
|
|
|
|
platform_driver_register(&sec_secure_touch_driver);
|
|
return 0;
|
|
}
|
|
|
|
static void __exit sec_secure_touch_exit(void)
|
|
{
|
|
pr_info("%s; %s\n", SECLOG, __func__);
|
|
|
|
};
|
|
|
|
module_init(sec_secure_touch_init);
|
|
module_exit(sec_secure_touch_exit);
|
|
|
|
MODULE_DESCRIPTION("Samsung Secure Touch Driver");
|
|
MODULE_LICENSE("GPL");
|
|
|
|
|