// SPDX-License-Identifier: GPL-2.0
|
/*
|
* ELAN HID-I2C TouchScreen driver.
|
*
|
* Copyright (C) 2014 Elan Microelectronics Corporation.
|
*
|
* Author: Chuming Zhang <chuming.zhang@elanic.com.cn>
|
*/
|
|
#include "elan_ts.h"
|
#include <linux/of_gpio.h>
|
#include <linux/buffer_head.h>
|
#include <linux/types.h>
|
#include <linux/irq.h>
|
#include <linux/interrupt.h>
|
|
#define IntToASCII(c) (c)>9?((c)+0x37):((c)+0x30)
|
|
static ssize_t store_disable_irq(struct device *dev,
|
struct device_attribute *attr,
|
const char *buf, size_t count)
|
{
|
struct i2c_client *client = to_i2c_client(dev);
|
struct elan_ts_data *ts = i2c_get_clientdata(client);
|
/*
|
if (ts->irq_lock_flag == 0) {
|
disable_irq(ts->hw_info.irq_num);
|
ts->irq_lock_flag = 1;
|
}
|
*/
|
elan_switch_irq(ts, 0);
|
dev_info(&client->dev, "Disable IRQ.\n");
|
return count;
|
}
|
static DEVICE_ATTR(disable_irq, S_IWUSR, NULL, store_disable_irq);
|
|
static ssize_t store_enable_irq(struct device *dev,
|
struct device_attribute *attr,
|
const char *buf, size_t count)
|
{
|
struct i2c_client *client = to_i2c_client(dev);
|
struct elan_ts_data *ts = i2c_get_clientdata(client);
|
/*
|
if (ts->irq_lock_flag == 1) {
|
enable_irq(ts->hw_info.irq_num);
|
ts->irq_lock_flag = 0;
|
}
|
*/
|
elan_switch_irq(ts, 1);
|
dev_info(&client->dev, "Enable IRQ.\n");
|
return count;
|
}
|
static DEVICE_ATTR(enable_irq, S_IWUSR, NULL, store_enable_irq);
|
|
|
static ssize_t store_reset(struct device *dev,
|
struct device_attribute *attr,
|
const char *buf, size_t count)
|
{
|
struct i2c_client *client = to_i2c_client(dev);
|
struct elan_ts_data *ts = i2c_get_clientdata(client);
|
|
elan_ts_hw_reset(&ts->hw_info);
|
dev_info(&client->dev,
|
"Reset Touch Screen Controller!\n");
|
return count;
|
}
|
static DEVICE_ATTR(reset, S_IWUSR, NULL, store_reset);
|
|
static ssize_t show_gpio_int(struct device *dev,
|
struct device_attribute *attr, char *buf)
|
{
|
struct i2c_client *client = to_i2c_client(dev);
|
struct elan_ts_data *ts = i2c_get_clientdata(client);
|
|
return sprintf(buf, "%d\n",
|
gpio_get_value(ts->hw_info.intr_gpio));
|
}
|
static DEVICE_ATTR(gpio_int, S_IRUGO, show_gpio_int, NULL);
|
|
static ssize_t store_calibrate(struct device *dev,
|
struct device_attribute *attr,
|
const char *buf, size_t count)
|
{
|
struct i2c_client *client = to_i2c_client(dev);
|
struct elan_ts_data *ts = i2c_get_clientdata(client);
|
int ret = 0;
|
/*
|
if (ts->irq_lock_flag == 0) {
|
disable_irq(ts->hw_info.irq_num);
|
ts->irq_lock_flag = 1;
|
}
|
*/
|
elan_switch_irq(ts, 0);
|
ret = elan_ts_calibrate(client);
|
|
if (ret == 0)
|
dev_info(&client->dev, "ELAN CALIBRATE Success\n");
|
else
|
dev_err(&client->dev, "ELAN CALIBRATE Fail\n");
|
/*
|
if (ts->irq_lock_flag == 1) {
|
enable_irq(ts->hw_info.irq_num);
|
ts->irq_lock_flag = 0;
|
}
|
*/
|
elan_switch_irq(ts, 1);
|
return count;
|
}
|
static DEVICE_ATTR(calibrate, S_IWUSR, NULL, store_calibrate);
|
|
|
static ssize_t store_check_rek(struct device *dev,
|
struct device_attribute *attr,
|
const char *buf, size_t count)
|
{
|
struct i2c_client *client = to_i2c_client(dev);
|
struct elan_ts_data *ts = i2c_get_clientdata(client);
|
int ret = 0;
|
|
/*
|
if (ts->irq_lock_flag == 0) {
|
disable_irq(ts->hw_info.irq_num);
|
ts->irq_lock_flag = 1;
|
}
|
*/
|
elan_switch_irq(ts, 0);
|
ret = elan_ts_check_calibrate(client);
|
|
if (ret)
|
dev_err(&client->dev, "ELAN CALIBRATE CHECK Fail\n");
|
else
|
dev_info(&client->dev, "ELAN CHECK CALIBRATE Success\n");
|
/*
|
if (ts->irq_lock_flag == 1) {
|
enable_irq(ts->hw_info.irq_num);
|
ts->irq_lock_flag = 0;
|
}
|
*/
|
elan_switch_irq(ts, 1);
|
return count;
|
}
|
static DEVICE_ATTR(check_rek, S_IWUSR, NULL, store_check_rek);
|
|
static ssize_t show_fw_info(struct device *dev,
|
struct device_attribute *attr, char *buf)
|
{
|
struct i2c_client *client = to_i2c_client(dev);
|
struct elan_ts_data *ts = i2c_get_clientdata(client);
|
|
return sprintf(buf, "FW VER = 0x%04x, FW ID = 0x%04x, BC VER = 0x%04x, tx:rx = %d:%d\n",\
|
ts->fw_info.fw_ver, ts->fw_info.fw_id, ts->fw_info.fw_bcv, ts->fw_info.tx, ts->fw_info.rx);
|
}
|
static ssize_t store_fw_info(struct device *dev,
|
struct device_attribute *attr,
|
const char *buf, size_t count)
|
{
|
struct i2c_client *client = to_i2c_client(dev);
|
struct elan_ts_data *ts = i2c_get_clientdata(client);
|
/*
|
if (ts->irq_lock_flag == 0) {
|
disable_irq(ts->hw_info.irq_num);
|
ts->irq_lock_flag = 1;
|
}
|
*/
|
elan_switch_irq(ts, 0);
|
|
elan__fw_packet_handler(ts->client);
|
/*
|
if (ts->irq_lock_flag == 1) {
|
enable_irq(ts->hw_info.irq_num);
|
ts->irq_lock_flag = 0;
|
}
|
*/
|
elan_switch_irq(ts, 1);
|
|
return count;
|
}
|
static DEVICE_ATTR(fw_info, S_IWUSR | S_IRUSR, show_fw_info, store_fw_info);
|
|
static ssize_t store_iap_status(struct device *dev,
|
struct device_attribute *attr,
|
const char *buf, size_t count)
|
{
|
struct i2c_client *client = to_i2c_client(dev);
|
struct elan_ts_data *ts = i2c_get_clientdata(client);
|
/*
|
if (ts->irq_lock_flag == 0) {
|
disable_irq(ts->hw_info.irq_num);
|
ts->irq_lock_flag = 1;
|
}
|
*/
|
elan_switch_irq(ts, 0);
|
elan_ts_hw_reset(&ts->hw_info);
|
mdelay(200);
|
elan__hello_packet_handler(client, ts->chip_type);
|
|
/*
|
if (ts->irq_lock_flag == 1) {
|
enable_irq(ts->hw_info.irq_num);
|
ts->irq_lock_flag = 0;
|
}
|
*/
|
elan_switch_irq(ts, 1);
|
return count;
|
}
|
|
static ssize_t show_iap_status(struct device *dev,
|
struct device_attribute *attr, char *buf)
|
{
|
|
struct i2c_client *client = to_i2c_client(dev);
|
struct elan_ts_data *ts = i2c_get_clientdata(client);
|
|
return sprintf(buf, "IAP STATUS = %s\n",(ts->recover < 0 ? "UNKNOW":(ts->recover == 0x01 ? "RECOVERY":"NORMAL")));
|
}
|
static DEVICE_ATTR(iap_status, S_IWUSR | S_IRUSR, show_iap_status, store_iap_status);
|
|
static ssize_t store_fw_upgrade(struct device *dev,
|
struct device_attribute *attr,
|
const char *buf, size_t count)
|
{
|
struct i2c_client *client = to_i2c_client(dev);
|
struct elan_ts_data *ts = i2c_get_clientdata(client);
|
/*
|
if (ts->irq_lock_flag == 0) {
|
disable_irq(ts->hw_info.irq_num);
|
ts->irq_lock_flag = 1;
|
}
|
*/
|
elan_switch_irq(ts, 0);
|
// elan_get_vendor_fw(ts,ts->fw_store_type);
|
// elan_FW_Update(ts->client);
|
elan_check_update_flage(ts);
|
/*
|
if (ts->irq_lock_flag == 1) {
|
enable_irq(ts->hw_info.irq_num);
|
ts->irq_lock_flag = 0;
|
}
|
*/
|
elan_switch_irq(ts, 1);
|
return count;
|
}
|
static DEVICE_ATTR(fw_update, S_IWUSR, NULL, store_fw_upgrade);
|
|
|
static ssize_t show_fw_store(struct device *dev,
|
struct device_attribute *attr, char *buf)
|
{
|
struct i2c_client *client = to_i2c_client(dev);
|
struct elan_ts_data *ts = i2c_get_clientdata(client);
|
|
if (ts->fw_store_type > -1 && ts->fw_store_type < 3) {
|
return sprintf(buf, "FW STORE = %s\n",\
|
(ts->fw_store_type == FROM_SYS_ETC_FIRMWARE ? "/system/etc/firmware/elants_i2c.ekt":\
|
(ts->fw_store_type == FROM_SDCARD_FIRMWARE ? "/data/local/tmp/elants_i2c.ekt":"build in driver")));
|
} else {
|
return sprintf(buf, "FW STORE TYPE OUT OF RANGE\n");
|
}
|
}
|
|
|
static ssize_t store_fw_store(struct device *dev,
|
struct device_attribute *attr,
|
const char *buf, size_t count)
|
{
|
|
struct i2c_client *client = to_i2c_client(dev);
|
struct elan_ts_data *ts = i2c_get_clientdata(client);
|
int type;
|
|
sscanf(buf,"%d",&type);
|
if (type > -1 && type < 3) {
|
ts->fw_store_type = type;
|
} else {
|
dev_info(&client->dev, "[elan] fw store type out of range!!!\n");
|
}
|
return count;
|
|
}
|
static DEVICE_ATTR(fw_store, S_IWUSR | S_IRUSR, show_fw_store, store_fw_store);
|
|
#if 0
|
static ssize_t store_tp_module_test(struct device *dev,
|
struct device_attribute *attr,
|
const char *buf, size_t count)
|
{
|
|
struct i2c_client *client = to_i2c_client(dev);
|
struct elan_ts_data *ts = i2c_get_clientdata(client);
|
int ret = 0;
|
|
ret = elan_tp_module_test(ts);
|
return count;
|
}
|
static DEVICE_ATTR(elan_tp_module_test, S_IWUSR, NULL, store_tp_module_test);
|
#endif
|
static ssize_t store_tp_print_level(struct device *dev,
|
struct device_attribute *attr,
|
const char *buf, size_t count)
|
{
|
int level = 0;
|
struct i2c_client *client = to_i2c_client(dev);
|
struct elan_ts_data *ts = i2c_get_clientdata(client);
|
|
sscanf(buf, "%x", &level);
|
ts->level = level;
|
return count;
|
}
|
|
|
static ssize_t show_tp_print_level(struct device *dev,
|
struct device_attribute *attr, char *buf)
|
{
|
struct i2c_client *client = to_i2c_client(dev);
|
struct elan_ts_data *ts = i2c_get_clientdata(client);
|
|
return sprintf(buf, "PRINT LEVEL = %s\n",\
|
(ts->level == TP_DEBUG ? "DEBUG":(ts->level == TP_INFO ? "INFO" : (ts->level == TP_WARNING ?"WARNING":"ERROR"))));
|
}
|
static DEVICE_ATTR(tp_print_level, S_IWUSR | S_IRUSR, show_tp_print_level, store_tp_print_level);
|
|
static ssize_t store_tp_cmd_send(struct device *dev,
|
struct device_attribute *attr,
|
const char *buf, size_t count)
|
{
|
|
int valid_size = 0;
|
struct i2c_client *client = to_i2c_client(dev);
|
struct elan_ts_data *ts = i2c_get_clientdata(client);
|
char cmd[37] = {0x04, 0x00, 0x23, 0x00, 0x03};
|
int ret = 0;
|
|
sscanf(buf, "%d:%x:%x:%x:%x:%x:%x:%x:%x", &valid_size,\
|
(int *)&cmd[5], (int *)&cmd[6], (int *)&cmd[7], (int *)&cmd[8],\
|
(int *)&cmd[9], (int *)&cmd[10], (int *)&cmd[11], (int *)&cmd[12]);
|
/*
|
if (ts->irq_lock_flag == 0) {
|
disable_irq(ts->hw_info.irq_num);
|
ts->irq_lock_flag = 1;
|
}
|
*/
|
elan_switch_irq(ts, 0);
|
dev_info(&client->dev, "cmd: %x:%x:%x:%x:%x:%x:%x:%x\n",cmd[5],cmd[6],cmd[7],cmd[8],cmd[9],cmd[10],cmd[11],cmd[12]);
|
|
|
if (ts->chip_type == HID_TYPE_PROTOCOL) {
|
ret = ts->ops->send(cmd, sizeof(cmd));
|
if (ret != sizeof(cmd))
|
dev_err(&client->dev, "send cmd failed %d:%ld\n", ret, sizeof(cmd));
|
} else {
|
ret = ts->ops->send(&cmd[7], valid_size);
|
if (ret != valid_size)
|
dev_err(&client->dev, "send cmd failed %d:%d\n",ret, valid_size);
|
}
|
return count;
|
}
|
|
static ssize_t show_tp_cmd_recv(struct device *dev,
|
struct device_attribute *attr, char *buf)
|
{
|
struct i2c_client *client = to_i2c_client(dev);
|
struct elan_ts_data *ts = i2c_get_clientdata(client);
|
uint8_t rbuf[67] = {0x00};
|
|
int i = 0;
|
char c1;
|
char out[1024];
|
int shift = 0;
|
|
while(!ts->ops->poll()) {
|
ts->ops->recv(rbuf, 67);
|
dev_info(&client->dev, "rbuf: %x:%x:%x:%x:%x:%x:%x:%x\n",
|
rbuf[1],rbuf[2],rbuf[3],rbuf[4],rbuf[5],rbuf[6],rbuf[7],rbuf[8]);
|
|
for(i = 0; i < sizeof(rbuf); i++) {
|
c1 = rbuf[i] & 0xF0;
|
out[3 * i + 0 + shift] = IntToASCII(c1 >> 4);
|
|
c1 = rbuf[i]&0x0F;
|
out[3 * i + 1 + shift] = IntToASCII(c1);
|
|
if((i %7 ==0) && (i !=0)) {
|
out[3 * i + 2 + shift] = 0x0A;//'\n' = 0x0A;
|
} else {
|
out[3 * i + 2 + shift] = 0x20;//space = 0x20;
|
}
|
}
|
printk("%s\n", out);
|
sprintf(buf + strlen(buf), "%s\n", out+shift);
|
shift += 3 * i;
|
}
|
/*
|
if (ts->irq_lock_flag == 1) {
|
enable_irq(ts->hw_info.irq_num);
|
ts->irq_lock_flag = 0;
|
}
|
*/
|
elan_switch_irq(ts, 1);
|
return strlen(buf);
|
}
|
|
|
static DEVICE_ATTR(raw_cmd, S_IWUSR | S_IRUSR, show_tp_cmd_recv, store_tp_cmd_send);
|
|
static struct attribute *elan_default_attributes[] = {
|
&dev_attr_enable_irq.attr,
|
&dev_attr_disable_irq.attr,
|
&dev_attr_gpio_int.attr,
|
&dev_attr_reset.attr,
|
&dev_attr_calibrate.attr,
|
&dev_attr_check_rek.attr,
|
&dev_attr_fw_info.attr,
|
&dev_attr_iap_status.attr,
|
&dev_attr_fw_update.attr,
|
&dev_attr_fw_store.attr,
|
// &dev_attr_tp_module_test.attr,
|
&dev_attr_tp_print_level.attr,
|
&dev_attr_raw_cmd.attr,
|
NULL
|
};
|
|
static struct attribute_group elan_default_attribute_group = {
|
.name = "elan_ktf",
|
.attrs = elan_default_attributes,
|
};
|
|
int elan_sysfs_attri_file(struct elan_ts_data *ts)
|
{
|
int err = 0;
|
|
err = sysfs_create_group(&ts->client->dev.kobj, &elan_default_attribute_group);
|
if ( err ) {
|
dev_err(&ts->client->dev, "[elan] %s sysfs create group error\n",__func__);
|
} else {
|
dev_err(&ts->client->dev,"[elan] %s sysfs create group success\n",__func__);
|
}
|
|
return err;
|
}
|
|
void elan_sysfs_attri_file_remove(struct elan_ts_data *ts)
|
{
|
sysfs_remove_group(&ts->client->dev.kobj, &elan_default_attribute_group);
|
}
|
