/*
|
* cyttsp5_core.c
|
* Parade TrueTouch(TM) Standard Product V5 Core Module.
|
* For use with Parade touchscreen controllers.
|
* Supported parts include:
|
* CYTMA5XX
|
* CYTMA448
|
* CYTMA445A
|
* CYTT21XXX
|
* CYTT31XXX
|
*
|
* Copyright (C) 2015 Parade Technologies
|
* Copyright (C) 2012-2015 Cypress Semiconductor
|
*
|
* This program is free software; you can redistribute it and/or
|
* modify it under the terms of the GNU General Public License
|
* version 2, and only version 2, as published by the
|
* Free Software Foundation.
|
*
|
* This program is distributed in the hope that it will be useful,
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
* GNU General Public License for more details.
|
*
|
* Contact Parade Technologies at www.paradetech.com <ttdrivers@paradetech.com>
|
*
|
*/
|
|
#include "cyttsp5_regs.h"
|
#include <linux/kthread.h>
|
|
#include <linux/notifier.h>
|
#include <linux/regulator/driver.h>
|
#include <linux/regulator/consumer.h>
|
|
static struct cyttsp5_core_data *priv_data;
|
#define CY_CORE_STARTUP_RETRY_COUNT 3
|
|
MODULE_FIRMWARE(CY_FW_FILE_NAME);
|
|
static const char *cy_driver_core_name = CYTTSP5_CORE_NAME;
|
static const char *cy_driver_core_version = CY_DRIVER_VERSION;
|
static const char *cy_driver_core_date = CY_DRIVER_DATE;
|
static bool cyttsp5_first_probe = true;
|
static bool is_cyttsp5_probe_success;
|
static const struct cyttsp5_bus_ops *cyttsp5_bus_ops_save;
|
|
struct cyttsp5_hid_field {
|
int report_count;
|
int report_size;
|
int size; /* report_count * report_size */
|
int offset;
|
int data_type;
|
int logical_min;
|
int logical_max;
|
/* Usage Page (Hi 16 bit) + Usage (Lo 16 bit) */
|
u32 usage_page;
|
u32 collection_usage_pages[CY_HID_MAX_COLLECTIONS];
|
struct cyttsp5_hid_report *report;
|
bool record_field;
|
};
|
|
struct cyttsp5_hid_report {
|
u8 id;
|
u8 type;
|
int size;
|
struct cyttsp5_hid_field *fields[CY_HID_MAX_FIELDS];
|
int num_fields;
|
int record_field_index;
|
int header_size;
|
int record_size;
|
u32 usage_page;
|
};
|
|
struct atten_node {
|
struct list_head node;
|
char *id;
|
struct device *dev;
|
|
int (*func)(struct device *);
|
int mode;
|
};
|
|
struct param_node {
|
struct list_head node;
|
u8 id;
|
u32 value;
|
u8 size;
|
};
|
|
struct module_node {
|
struct list_head node;
|
struct cyttsp5_module *module;
|
void *data;
|
};
|
|
struct cyttsp5_hid_cmd {
|
u8 opcode;
|
u8 report_type;
|
union {
|
u8 report_id;
|
u8 power_state;
|
};
|
u8 has_data_register;
|
size_t write_length;
|
u8 *write_buf;
|
u8 *read_buf;
|
u8 wait_interrupt;
|
u8 reset_cmd;
|
u16 timeout_ms;
|
};
|
|
struct cyttsp5_hid_output {
|
u8 cmd_type;
|
u16 length;
|
u8 command_code;
|
size_t write_length;
|
u8 *write_buf;
|
u8 novalidate;
|
u8 reset_expected;
|
u16 timeout_ms;
|
};
|
|
#define SET_CMD_OPCODE(byte, opcode) SET_CMD_LOW(byte, opcode)
|
#define SET_CMD_REPORT_TYPE(byte, type) SET_CMD_HIGH(byte, ((type) << 4))
|
#define SET_CMD_REPORT_ID(byte, id) SET_CMD_LOW(byte, id)
|
|
#define HID_OUTPUT_APP_COMMAND(command) \
|
.cmd_type = HID_OUTPUT_CMD_APP, \
|
.command_code = command
|
|
#define HID_OUTPUT_BL_COMMAND(command) \
|
.cmd_type = HID_OUTPUT_CMD_BL, \
|
.command_code = command
|
|
#ifdef VERBOSE_DEBUG
|
void cyttsp5_pr_buf(struct device *dev, u8 *dptr, int size,
|
const char *data_name)
|
{
|
struct cyttsp5_core_data *cd = dev_get_drvdata(dev);
|
u8 *pr_buf = cd->pr_buf;
|
int i, k;
|
const char fmt[] = "%02X ";
|
int max;
|
|
if (!size)
|
return;
|
|
max = (CY_MAX_PRBUF_SIZE - 1) - sizeof(CY_PR_TRUNCATED);
|
|
pr_buf[0] = 0;
|
for (i = k = 0; i < size && k < max; i++, k += 3)
|
scnprintf(pr_buf + k, CY_MAX_PRBUF_SIZE, fmt, dptr[i]);
|
|
if (size) {
|
parade_debug(dev, DEBUG_LEVEL_2, "%s: %s[0..%d]=%s%s\n",
|
__func__, data_name,
|
size - 1, pr_buf, size <= max ? "" : CY_PR_TRUNCATED);
|
} else {
|
parade_debug(dev, DEBUG_LEVEL_2, "%s: %s[]\n",
|
__func__, data_name);
|
}
|
}
|
EXPORT_SYMBOL_GPL(cyttsp5_pr_buf);
|
#endif
|
|
#ifdef TTHE_TUNER_SUPPORT
|
static int tthe_print(struct cyttsp5_core_data *cd, u8 *buf, int buf_len,
|
const u8 *data_name)
|
{
|
int len = strlen(data_name);
|
int i, n;
|
u8 *p;
|
int remain;
|
u8 data_name_with_time_stamp[100];
|
|
if (cd->show_timestamp) {
|
sprintf(data_name_with_time_stamp, "[%u] %s",
|
jiffies_to_msecs(jiffies), data_name);
|
data_name = data_name_with_time_stamp;
|
len = strlen(data_name);
|
}
|
|
mutex_lock(&cd->tthe_lock);
|
if (!cd->tthe_buf)
|
goto exit;
|
|
if (cd->tthe_buf_len + (len + buf_len) > CY_MAX_PRBUF_SIZE)
|
goto exit;
|
|
if (len + buf_len == 0)
|
goto exit;
|
|
remain = CY_MAX_PRBUF_SIZE - cd->tthe_buf_len;
|
if (remain < len)
|
len = remain;
|
|
p = cd->tthe_buf + cd->tthe_buf_len;
|
memcpy(p, data_name, len);
|
cd->tthe_buf_len += len;
|
p += len;
|
remain -= len;
|
|
*p = 0;
|
for (i = 0; i < buf_len; i++) {
|
n = scnprintf(p, remain, "%02X ", buf[i]);
|
if (!n)
|
break;
|
p += n;
|
remain -= n;
|
cd->tthe_buf_len += n;
|
}
|
|
n = scnprintf(p, remain, "\n");
|
if (!n)
|
cd->tthe_buf[cd->tthe_buf_len] = 0;
|
cd->tthe_buf_len += n;
|
wake_up(&cd->wait_q);
|
exit:
|
mutex_unlock(&cd->tthe_lock);
|
return 0;
|
}
|
|
static int _cyttsp5_request_tthe_print(struct device *dev, u8 *buf,
|
int buf_len, const u8 *data_name)
|
{
|
struct cyttsp5_core_data *cd = dev_get_drvdata(dev);
|
|
return tthe_print(cd, buf, buf_len, data_name);
|
}
|
#endif
|
|
#ifdef CYTTSP_WATCHDOG_DELAY_ENBALE
|
static void watchdog_delay_enable(struct work_struct *work)
|
{
|
struct cyttsp5_core_data *cd;
|
|
cd = container_of(work, struct cyttsp5_core_data, watchdog_enable_work.work);
|
cd->watchdog_interval = CY_WATCHDOG_TIMEOUT;
|
printk("++++++watchdog_delay_enable\n");
|
}
|
#endif
|
|
/*
|
* cyttsp5_platform_detect_read()
|
*
|
* This function is passed to platform detect
|
* function to perform a read operation
|
*/
|
static int cyttsp5_platform_detect_read(struct device *dev, void *buf, int size)
|
{
|
struct cyttsp5_core_data *cd = dev_get_drvdata(dev);
|
|
return cyttsp5_adap_read_default(cd, buf, size);
|
}
|
|
/* Must be called with cd->hid_report_lock acquired */
|
static struct cyttsp5_hid_report *cyttsp5_get_hid_report_(
|
struct cyttsp5_core_data *cd, u8 report_type, u8 report_id,
|
bool create)
|
{
|
struct cyttsp5_hid_report *report = NULL;
|
int i;
|
|
/* Look for created reports */
|
for (i = 0; i < cd->num_hid_reports; i++) {
|
if (cd->hid_reports[i]->type == report_type
|
&& cd->hid_reports[i]->id == report_id) {
|
return cd->hid_reports[i];
|
}
|
}
|
|
/* Create a new report */
|
if (create && cd->num_hid_reports < CY_HID_MAX_REPORTS) {
|
report = kzalloc(sizeof(struct cyttsp5_hid_report),
|
GFP_KERNEL);
|
if (!report)
|
return NULL;
|
|
report->type = report_type;
|
report->id = report_id;
|
cd->hid_reports[cd->num_hid_reports++] = report;
|
}
|
|
return report;
|
}
|
|
/* Must be called with cd->hid_report_lock acquired */
|
static void cyttsp5_free_hid_reports_(struct cyttsp5_core_data *cd)
|
{
|
struct cyttsp5_hid_report *report;
|
int i, j;
|
|
for (i = 0; i < cd->num_hid_reports; i++) {
|
report = cd->hid_reports[i];
|
for (j = 0; j < report->num_fields; j++)
|
kfree(report->fields[j]);
|
kfree(report);
|
cd->hid_reports[i] = NULL;
|
}
|
|
cd->num_hid_reports = 0;
|
}
|
|
static void cyttsp5_free_hid_reports(struct cyttsp5_core_data *cd)
|
{
|
mutex_lock(&cd->hid_report_lock);
|
cyttsp5_free_hid_reports_(cd);
|
mutex_unlock(&cd->hid_report_lock);
|
}
|
|
/* Must be called with cd->hid_report_lock acquired */
|
static struct cyttsp5_hid_field *cyttsp5_create_hid_field_(
|
struct cyttsp5_hid_report *report)
|
{
|
struct cyttsp5_hid_field *field;
|
|
if (!report)
|
return NULL;
|
|
if (report->num_fields == CY_HID_MAX_FIELDS)
|
return NULL;
|
|
field = kzalloc(sizeof(struct cyttsp5_hid_field), GFP_KERNEL);
|
if (!field)
|
return NULL;
|
|
field->report = report;
|
|
report->fields[report->num_fields++] = field;
|
|
return field;
|
}
|
|
static int cyttsp5_add_parameter(struct cyttsp5_core_data *cd,
|
u8 param_id, u32 param_value, u8 param_size)
|
{
|
struct param_node *param, *param_new;
|
|
/* Check if parameter exists */
|
spin_lock(&cd->spinlock);
|
list_for_each_entry(param, &cd->param_list, node) {
|
if (param->id == param_id) {
|
/* Update parameter */
|
param->value = param_value;
|
parade_debug(cd->dev, DEBUG_LEVEL_2, "%s: Update parameter id:%d value:%d size:%d\n",
|
__func__, param_id, param_value, param_size);
|
goto exit_unlock;
|
}
|
}
|
spin_unlock(&cd->spinlock);
|
|
param_new = kzalloc(sizeof(*param_new), GFP_KERNEL);
|
if (!param_new)
|
return -ENOMEM;
|
|
param_new->id = param_id;
|
param_new->value = param_value;
|
param_new->size = param_size;
|
|
parade_debug(cd->dev, DEBUG_LEVEL_2, "%s: Add parameter id:%d value:%d size:%d\n",
|
__func__, param_id, param_value, param_size);
|
|
spin_lock(&cd->spinlock);
|
list_add(¶m_new->node, &cd->param_list);
|
exit_unlock:
|
spin_unlock(&cd->spinlock);
|
|
return 0;
|
}
|
|
int request_exclusive(struct cyttsp5_core_data *cd, void *ownptr,
|
int timeout_ms)
|
{
|
int t = msecs_to_jiffies(timeout_ms);
|
bool with_timeout = (timeout_ms != 0);
|
|
mutex_lock(&cd->system_lock);
|
if (!cd->exclusive_dev && cd->exclusive_waits == 0) {
|
cd->exclusive_dev = ownptr;
|
goto exit;
|
}
|
|
cd->exclusive_waits++;
|
wait:
|
mutex_unlock(&cd->system_lock);
|
if (with_timeout) {
|
t = wait_event_timeout(cd->wait_q, !cd->exclusive_dev, t);
|
if (IS_TMO(t)) {
|
dev_err(cd->dev, "%s: tmo waiting exclusive access\n",
|
__func__);
|
return -ETIME;
|
}
|
} else {
|
wait_event(cd->wait_q, !cd->exclusive_dev);
|
}
|
mutex_lock(&cd->system_lock);
|
if (cd->exclusive_dev)
|
goto wait;
|
cd->exclusive_dev = ownptr;
|
cd->exclusive_waits--;
|
exit:
|
mutex_unlock(&cd->system_lock);
|
parade_debug(cd->dev, DEBUG_LEVEL_2, "%s: request_exclusive ok=%p\n",
|
__func__, ownptr);
|
|
return 0;
|
}
|
|
static int release_exclusive_(struct cyttsp5_core_data *cd, void *ownptr)
|
{
|
if (cd->exclusive_dev != ownptr)
|
return -EINVAL;
|
|
parade_debug(cd->dev, DEBUG_LEVEL_2, "%s: exclusive_dev %p freed\n",
|
__func__, cd->exclusive_dev);
|
cd->exclusive_dev = NULL;
|
wake_up(&cd->wait_q);
|
return 0;
|
}
|
|
/*
|
* returns error if was not owned
|
*/
|
int release_exclusive(struct cyttsp5_core_data *cd, void *ownptr)
|
{
|
int rc;
|
|
mutex_lock(&cd->system_lock);
|
rc = release_exclusive_(cd, ownptr);
|
mutex_unlock(&cd->system_lock);
|
|
return rc;
|
}
|
|
static int cyttsp5_hid_exec_cmd_(struct cyttsp5_core_data *cd,
|
struct cyttsp5_hid_cmd *hid_cmd)
|
{
|
int rc;
|
u8 *cmd;
|
u8 cmd_length;
|
u8 cmd_offset = 0;
|
|
cmd_length = 2 /* command register */
|
+ 2 /* command */
|
+ (hid_cmd->report_id >= 0XF ? 1 : 0) /* Report ID */
|
+ (hid_cmd->has_data_register ? 2 : 0) /* Data register */
|
+ hid_cmd->write_length; /* Data length */
|
|
cmd = kzalloc(cmd_length, GFP_KERNEL);
|
if (!cmd)
|
return -ENOMEM;
|
|
/* Set Command register */
|
memcpy(&cmd[cmd_offset], &cd->hid_desc.command_register,
|
sizeof(cd->hid_desc.command_register));
|
cmd_offset += sizeof(cd->hid_desc.command_register);
|
|
/* Set Command */
|
SET_CMD_REPORT_TYPE(cmd[cmd_offset], hid_cmd->report_type);
|
|
if (hid_cmd->report_id >= 0XF)
|
SET_CMD_REPORT_ID(cmd[cmd_offset], 0xF);
|
else
|
SET_CMD_REPORT_ID(cmd[cmd_offset], hid_cmd->report_id);
|
cmd_offset++;
|
|
SET_CMD_OPCODE(cmd[cmd_offset], hid_cmd->opcode);
|
cmd_offset++;
|
|
if (hid_cmd->report_id >= 0XF) {
|
cmd[cmd_offset] = hid_cmd->report_id;
|
cmd_offset++;
|
}
|
|
/* Set Data register */
|
if (hid_cmd->has_data_register) {
|
memcpy(&cmd[cmd_offset], &cd->hid_desc.data_register,
|
sizeof(cd->hid_desc.data_register));
|
cmd_offset += sizeof(cd->hid_desc.data_register);
|
}
|
|
/* Set Data */
|
if (hid_cmd->write_length && hid_cmd->write_buf) {
|
memcpy(&cmd[cmd_offset], hid_cmd->write_buf,
|
hid_cmd->write_length);
|
cmd_offset += hid_cmd->write_length;
|
}
|
|
rc = cyttsp5_adap_write_read_specific(cd, cmd_length, cmd,
|
hid_cmd->read_buf);
|
if (rc)
|
dev_err(cd->dev, "%s: Fail cyttsp5_adap_transfer\n", __func__);
|
|
kfree(cmd);
|
return rc;
|
}
|
|
static int cyttsp5_hid_exec_cmd_and_wait_(struct cyttsp5_core_data *cd,
|
struct cyttsp5_hid_cmd *hid_cmd)
|
{
|
int rc;
|
int t;
|
u16 timeout_ms;
|
int *cmd_state;
|
|
if (hid_cmd->reset_cmd)
|
cmd_state = &cd->hid_reset_cmd_state;
|
else
|
cmd_state = &cd->hid_cmd_state;
|
|
if (hid_cmd->wait_interrupt) {
|
mutex_lock(&cd->system_lock);
|
*cmd_state = 1;
|
mutex_unlock(&cd->system_lock);
|
}
|
|
rc = cyttsp5_hid_exec_cmd_(cd, hid_cmd);
|
if (rc) {
|
if (hid_cmd->wait_interrupt)
|
goto error;
|
|
goto exit;
|
}
|
|
if (!hid_cmd->wait_interrupt)
|
goto exit;
|
|
if (hid_cmd->timeout_ms)
|
timeout_ms = hid_cmd->timeout_ms;
|
else
|
timeout_ms = CY_HID_RESET_TIMEOUT;
|
//printk("****%s timeout_ms=%d, rc=%d\n", __func__, timeout_ms, rc);
|
|
t = wait_event_timeout(cd->wait_q, (*cmd_state == 0),
|
msecs_to_jiffies(timeout_ms));
|
if (IS_TMO(t)) {
|
dev_err(cd->dev, "%s: HID output cmd execution timed out %d\n",
|
__func__, timeout_ms);
|
rc = -ETIME;
|
goto error;
|
}
|
|
goto exit;
|
|
error:
|
mutex_lock(&cd->system_lock);
|
*cmd_state = 0;
|
mutex_unlock(&cd->system_lock);
|
|
exit:
|
return rc;
|
}
|
|
static int cyttsp5_hid_cmd_reset_(struct cyttsp5_core_data *cd)
|
{
|
struct cyttsp5_hid_cmd hid_cmd = {
|
.opcode = HID_CMD_RESET,
|
.wait_interrupt = 1,
|
.reset_cmd = 1,
|
.timeout_ms = CY_HID_RESET_TIMEOUT,
|
};
|
|
return cyttsp5_hid_exec_cmd_and_wait_(cd, &hid_cmd);
|
}
|
|
static int cyttsp5_hid_cmd_reset(struct cyttsp5_core_data *cd)
|
{
|
int rc;
|
|
rc = request_exclusive(cd, cd->dev, CY_REQUEST_EXCLUSIVE_TIMEOUT);
|
if (rc < 0) {
|
dev_err(cd->dev, "%s: fail get exclusive ex=%p own=%p\n",
|
__func__, cd->exclusive_dev, cd->dev);
|
return rc;
|
}
|
|
rc = cyttsp5_hid_cmd_reset_(cd);
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
dev_err(cd->dev, "%s: fail to release exclusive\n", __func__);
|
|
return rc;
|
}
|
|
static int cyttsp5_hid_cmd_set_power_(struct cyttsp5_core_data *cd,
|
u8 power_state)
|
{
|
int rc;
|
struct cyttsp5_hid_cmd hid_cmd = {
|
.opcode = HID_CMD_SET_POWER,
|
.wait_interrupt = 1,
|
.timeout_ms = CY_HID_SET_POWER_TIMEOUT,
|
};
|
hid_cmd.power_state = power_state;
|
|
rc = cyttsp5_hid_exec_cmd_and_wait_(cd, &hid_cmd);
|
if (rc) {
|
dev_err(cd->dev, "%s: Failed to set power to state:%d\n",
|
__func__, power_state);
|
return rc;
|
}
|
|
/* validate */
|
if ((cd->response_buf[2] != HID_RESPONSE_REPORT_ID)
|
|| ((cd->response_buf[3] & 0x3) != power_state)
|
|| ((cd->response_buf[4] & 0xF) != HID_CMD_SET_POWER))
|
rc = -EINVAL;
|
|
return rc;
|
}
|
|
static int cyttsp5_hid_cmd_set_power(struct cyttsp5_core_data *cd,
|
u8 power_state)
|
{
|
int rc;
|
|
rc = request_exclusive(cd, cd->dev, CY_REQUEST_EXCLUSIVE_TIMEOUT);
|
if (rc < 0) {
|
dev_err(cd->dev, "%s: fail get exclusive ex=%p own=%p\n",
|
__func__, cd->exclusive_dev, cd->dev);
|
return rc;
|
}
|
|
rc = cyttsp5_hid_cmd_set_power_(cd, power_state);
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
dev_err(cd->dev, "%s: fail to release exclusive\n", __func__);
|
|
return rc;
|
}
|
|
static const u16 crc_table[16] = {
|
0x0000, 0x1021, 0x2042, 0x3063,
|
0x4084, 0x50a5, 0x60c6, 0x70e7,
|
0x8108, 0x9129, 0xa14a, 0xb16b,
|
0xc18c, 0xd1ad, 0xe1ce, 0xf1ef,
|
};
|
|
static u16 _cyttsp5_compute_crc(u8 *buf, u32 size)
|
{
|
u16 remainder = 0xFFFF;
|
u16 xor_mask = 0x0000;
|
u32 index;
|
u32 byte_value;
|
u32 table_index;
|
u32 crc_bit_width = sizeof(u16) * 8;
|
|
/* Divide the message by polynomial, via the table. */
|
for (index = 0; index < size; index++) {
|
byte_value = buf[index];
|
table_index = ((byte_value >> 4) & 0x0F)
|
^ (remainder >> (crc_bit_width - 4));
|
remainder = crc_table[table_index] ^ (remainder << 4);
|
table_index = (byte_value & 0x0F)
|
^ (remainder >> (crc_bit_width - 4));
|
remainder = crc_table[table_index] ^ (remainder << 4);
|
}
|
|
/* Perform the final remainder CRC. */
|
return remainder ^ xor_mask;
|
}
|
|
static int cyttsp5_hid_output_validate_bl_response(
|
struct cyttsp5_core_data *cd,
|
struct cyttsp5_hid_output *hid_output)
|
{
|
u16 size;
|
u16 crc;
|
u8 status;
|
|
size = get_unaligned_le16(&cd->response_buf[0]);
|
|
if (hid_output->reset_expected && !size)
|
return 0;
|
|
if (cd->response_buf[HID_OUTPUT_RESPONSE_REPORT_OFFSET]
|
!= HID_BL_RESPONSE_REPORT_ID) {
|
dev_err(cd->dev, "%s: HID output response, wrong report_id\n",
|
__func__);
|
return -EPROTO;
|
}
|
|
if (cd->response_buf[4] != HID_OUTPUT_BL_SOP) {
|
dev_err(cd->dev, "%s: HID output response, wrong SOP\n",
|
__func__);
|
return -EPROTO;
|
}
|
|
if (cd->response_buf[size - 1] != HID_OUTPUT_BL_EOP) {
|
dev_err(cd->dev, "%s: HID output response, wrong EOP\n",
|
__func__);
|
return -EPROTO;
|
}
|
|
crc = _cyttsp5_compute_crc(&cd->response_buf[4], size - 7);
|
if (cd->response_buf[size - 3] != LOW_BYTE(crc)
|
|| cd->response_buf[size - 2] != HI_BYTE(crc)) {
|
dev_err(cd->dev, "%s: HID output response, wrong CRC 0x%X\n",
|
__func__, crc);
|
return -EPROTO;
|
}
|
|
status = cd->response_buf[5];
|
if (status) {
|
dev_err(cd->dev, "%s: HID output response, ERROR:%d\n",
|
__func__, status);
|
return -EPROTO;
|
}
|
|
return 0;
|
}
|
|
static int cyttsp5_hid_output_validate_app_response(
|
struct cyttsp5_core_data *cd,
|
struct cyttsp5_hid_output *hid_output)
|
{
|
int command_code;
|
u16 size;
|
|
size = get_unaligned_le16(&cd->response_buf[0]);
|
|
if (hid_output->reset_expected && !size)
|
return 0;
|
|
if (cd->response_buf[HID_OUTPUT_RESPONSE_REPORT_OFFSET]
|
!= HID_APP_RESPONSE_REPORT_ID) {
|
dev_err(cd->dev, "%s: HID output response, wrong report_id\n",
|
__func__);
|
return -EPROTO;
|
}
|
|
command_code = cd->response_buf[HID_OUTPUT_RESPONSE_CMD_OFFSET]
|
& HID_OUTPUT_RESPONSE_CMD_MASK;
|
if (command_code != hid_output->command_code) {
|
dev_err(cd->dev,
|
"%s: HID output response, wrong command_code:%X\n",
|
__func__, command_code);
|
return -EPROTO;
|
}
|
|
return 0;
|
}
|
|
static void cyttsp5_check_set_parameter(struct cyttsp5_core_data *cd,
|
struct cyttsp5_hid_output *hid_output, bool raw)
|
{
|
u8 *param_buf;
|
u32 param_value = 0;
|
u8 param_size;
|
u8 param_id;
|
int i = 0;
|
|
if (!(cd->cpdata->flags & CY_CORE_FLAG_RESTORE_PARAMETERS))
|
return;
|
|
/* Check command input for Set Parameter command */
|
if (raw && hid_output->length >= 10 && hid_output->length <= 13
|
&& !memcmp(&hid_output->write_buf[0],
|
&cd->hid_desc.output_register,
|
sizeof(cd->hid_desc.output_register))
|
&& hid_output->write_buf[4] ==
|
HID_APP_OUTPUT_REPORT_ID
|
&& hid_output->write_buf[6] ==
|
HID_OUTPUT_SET_PARAM)
|
param_buf = &hid_output->write_buf[7];
|
else if (!raw && hid_output->cmd_type == HID_OUTPUT_CMD_APP
|
&& hid_output->command_code == HID_OUTPUT_SET_PARAM
|
&& hid_output->write_length >= 3
|
&& hid_output->write_length <= 6)
|
param_buf = &hid_output->write_buf[0];
|
else
|
return;
|
|
/* Get parameter ID, size and value */
|
param_id = param_buf[0];
|
param_size = param_buf[1];
|
if (param_size > 4) {
|
dev_err(cd->dev, "%s: Invalid parameter size\n", __func__);
|
return;
|
}
|
|
param_buf = ¶m_buf[2];
|
while (i < param_size)
|
param_value += *(param_buf++) << (8 * i++);
|
|
/* Check command response for Set Parameter command */
|
if (cd->response_buf[2] != HID_APP_RESPONSE_REPORT_ID
|
|| (cd->response_buf[4] & HID_OUTPUT_CMD_MASK) !=
|
HID_OUTPUT_SET_PARAM
|
|| cd->response_buf[5] != param_id
|
|| cd->response_buf[6] != param_size) {
|
dev_err(cd->dev, "%s: Set Parameter command not successful\n",
|
__func__);
|
return;
|
}
|
|
cyttsp5_add_parameter(cd, param_id, param_value, param_size);
|
}
|
|
static void cyttsp5_check_command(struct cyttsp5_core_data *cd,
|
struct cyttsp5_hid_output *hid_output, bool raw)
|
{
|
cyttsp5_check_set_parameter(cd, hid_output, raw);
|
}
|
|
static int cyttsp5_hid_output_validate_response(struct cyttsp5_core_data *cd,
|
struct cyttsp5_hid_output *hid_output)
|
{
|
if (hid_output->cmd_type == HID_OUTPUT_CMD_BL)
|
return cyttsp5_hid_output_validate_bl_response(cd, hid_output);
|
|
return cyttsp5_hid_output_validate_app_response(cd, hid_output);
|
|
}
|
|
static int cyttsp5_hid_send_output_user_(struct cyttsp5_core_data *cd,
|
struct cyttsp5_hid_output *hid_output)
|
{
|
int rc;
|
|
if (!hid_output->length || !hid_output->write_buf)
|
return -EINVAL;
|
|
rc = cyttsp5_adap_write_read_specific(cd, hid_output->length,
|
hid_output->write_buf, NULL);
|
if (rc)
|
dev_err(cd->dev, "%s: Fail cyttsp5_adap_transfer\n", __func__);
|
|
return rc;
|
}
|
|
static int cyttsp5_hid_send_output_user_and_wait_(struct cyttsp5_core_data *cd,
|
struct cyttsp5_hid_output *hid_output)
|
{
|
int rc;
|
int t;
|
|
mutex_lock(&cd->system_lock);
|
cd->hid_cmd_state = HID_OUTPUT_USER_CMD + 1;
|
mutex_unlock(&cd->system_lock);
|
|
rc = cyttsp5_hid_send_output_user_(cd, hid_output);
|
if (rc)
|
goto error;
|
|
t = wait_event_timeout(cd->wait_q, (cd->hid_cmd_state == 0),
|
msecs_to_jiffies(CY_HID_OUTPUT_USER_TIMEOUT));
|
if (IS_TMO(t)) {
|
dev_err(cd->dev, "%s: HID output cmd execution timed out\n",
|
__func__);
|
rc = -ETIME;
|
goto error;
|
}
|
|
cyttsp5_check_command(cd, hid_output, true);
|
|
goto exit;
|
|
error:
|
mutex_lock(&cd->system_lock);
|
cd->hid_cmd_state = 0;
|
mutex_unlock(&cd->system_lock);
|
|
exit:
|
return rc;
|
}
|
|
static int cyttsp5_hid_send_output_(struct cyttsp5_core_data *cd,
|
struct cyttsp5_hid_output *hid_output)
|
{
|
int rc;
|
u8 *cmd;
|
u16 length;
|
u8 report_id;
|
u8 cmd_offset = 0;
|
u16 crc;
|
u8 cmd_allocated = 0;
|
|
switch (hid_output->cmd_type) {
|
case HID_OUTPUT_CMD_APP:
|
report_id = HID_APP_OUTPUT_REPORT_ID;
|
length = 5;
|
break;
|
case HID_OUTPUT_CMD_BL:
|
report_id = HID_BL_OUTPUT_REPORT_ID;
|
length = 11 /* 5 + SOP + LEN(2) + CRC(2) + EOP */;
|
break;
|
default:
|
return -EINVAL;
|
}
|
|
length += hid_output->write_length;
|
|
if (length + 2 > CYTTSP5_PREALLOCATED_CMD_BUFFER) {
|
cmd = kzalloc(length + 2, GFP_KERNEL);
|
if (!cmd)
|
return -ENOMEM;
|
cmd_allocated = 1;
|
} else {
|
cmd = cd->cmd_buf;
|
}
|
|
/* Set Output register */
|
memcpy(&cmd[cmd_offset], &cd->hid_desc.output_register,
|
sizeof(cd->hid_desc.output_register));
|
cmd_offset += sizeof(cd->hid_desc.output_register);
|
|
cmd[cmd_offset++] = LOW_BYTE(length);
|
cmd[cmd_offset++] = HI_BYTE(length);
|
cmd[cmd_offset++] = report_id;
|
cmd[cmd_offset++] = 0x0; /* reserved */
|
if (hid_output->cmd_type == HID_OUTPUT_CMD_BL)
|
cmd[cmd_offset++] = HID_OUTPUT_BL_SOP;
|
cmd[cmd_offset++] = hid_output->command_code;
|
|
/* Set Data Length for bootloader */
|
if (hid_output->cmd_type == HID_OUTPUT_CMD_BL) {
|
cmd[cmd_offset++] = LOW_BYTE(hid_output->write_length);
|
cmd[cmd_offset++] = HI_BYTE(hid_output->write_length);
|
}
|
/* Set Data */
|
if (hid_output->write_length && hid_output->write_buf) {
|
memcpy(&cmd[cmd_offset], hid_output->write_buf,
|
hid_output->write_length);
|
cmd_offset += hid_output->write_length;
|
}
|
if (hid_output->cmd_type == HID_OUTPUT_CMD_BL) {
|
crc = _cyttsp5_compute_crc(&cmd[6],
|
hid_output->write_length + 4);
|
cmd[cmd_offset++] = LOW_BYTE(crc);
|
cmd[cmd_offset++] = HI_BYTE(crc);
|
cmd[cmd_offset++] = HID_OUTPUT_BL_EOP;
|
}
|
|
cyttsp5_pr_buf(cd->dev, cmd, length + 2, "command");
|
rc = cyttsp5_adap_write_read_specific(cd, length + 2, cmd, NULL);
|
if (rc)
|
dev_err(cd->dev, "%s: Fail cyttsp5_adap_transfer\n", __func__);
|
|
if (cmd_allocated)
|
kfree(cmd);
|
return rc;
|
}
|
|
static int cyttsp5_hid_send_output_and_wait_(struct cyttsp5_core_data *cd,
|
struct cyttsp5_hid_output *hid_output)
|
{
|
int rc;
|
int t;
|
#ifdef VERBOSE_DEBUG
|
u16 size;
|
#endif
|
u16 timeout_ms;
|
|
mutex_lock(&cd->system_lock);
|
cd->hid_cmd_state = hid_output->command_code + 1;
|
mutex_unlock(&cd->system_lock);
|
|
if (hid_output->timeout_ms)
|
timeout_ms = hid_output->timeout_ms;
|
else
|
timeout_ms = CY_HID_OUTPUT_TIMEOUT;
|
|
rc = cyttsp5_hid_send_output_(cd, hid_output);
|
if (rc)
|
goto error;
|
|
//printk("%s time=%d\n", __func__, timeout_ms);
|
t = wait_event_timeout(cd->wait_q, (cd->hid_cmd_state == 0),
|
msecs_to_jiffies(timeout_ms));
|
if (IS_TMO(t)) {
|
dev_err(cd->dev, "%s: HID output cmd execution timed out\n",
|
__func__);
|
rc = -ETIME;
|
goto error;
|
}
|
|
if (!hid_output->novalidate)
|
rc = cyttsp5_hid_output_validate_response(cd, hid_output);
|
|
cyttsp5_check_command(cd, hid_output, false);
|
|
#ifdef VERBOSE_DEBUG
|
size = get_unaligned_le16(&cd->response_buf[0]);
|
cyttsp5_pr_buf(cd->dev, cd->response_buf, size, "return_buf");
|
#endif
|
|
goto exit;
|
|
error:
|
mutex_lock(&cd->system_lock);
|
cd->hid_cmd_state = 0;
|
mutex_unlock(&cd->system_lock);
|
exit:
|
return rc;
|
}
|
|
static int cyttsp5_hid_output_null_(struct cyttsp5_core_data *cd)
|
{
|
struct cyttsp5_hid_output hid_output = {
|
HID_OUTPUT_APP_COMMAND(HID_OUTPUT_NULL),
|
};
|
|
return cyttsp5_hid_send_output_and_wait_(cd, &hid_output);
|
}
|
|
static int cyttsp5_hid_output_null(struct cyttsp5_core_data *cd)
|
{
|
int rc;
|
|
rc = request_exclusive(cd, cd->dev, CY_REQUEST_EXCLUSIVE_TIMEOUT);
|
if (rc < 0) {
|
dev_err(cd->dev, "%s: fail get exclusive ex=%p own=%p\n",
|
__func__, cd->exclusive_dev, cd->dev);
|
return rc;
|
}
|
|
rc = cyttsp5_hid_output_null_(cd);
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
dev_err(cd->dev, "%s: fail to release exclusive\n", __func__);
|
|
return rc;
|
}
|
|
static int cyttsp5_hid_output_start_bootloader_(struct cyttsp5_core_data *cd)
|
{
|
struct cyttsp5_hid_output hid_output = {
|
HID_OUTPUT_APP_COMMAND(HID_OUTPUT_START_BOOTLOADER),
|
.timeout_ms = CY_HID_OUTPUT_START_BOOTLOADER_TIMEOUT,
|
.reset_expected = 1,
|
};
|
|
return cyttsp5_hid_send_output_and_wait_(cd, &hid_output);
|
}
|
|
static int cyttsp5_hid_output_start_bootloader(struct cyttsp5_core_data *cd)
|
{
|
int rc;
|
|
rc = request_exclusive(cd, cd->dev, CY_REQUEST_EXCLUSIVE_TIMEOUT);
|
if (rc < 0) {
|
dev_err(cd->dev, "%s: fail get exclusive ex=%p own=%p\n",
|
__func__, cd->exclusive_dev, cd->dev);
|
return rc;
|
}
|
|
rc = cyttsp5_hid_output_start_bootloader_(cd);
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
dev_err(cd->dev, "%s: fail to release exclusive\n", __func__);
|
|
return rc;
|
}
|
|
static int _cyttsp5_request_hid_output_start_bl(struct device *dev, int protect)
|
{
|
struct cyttsp5_core_data *cd = dev_get_drvdata(dev);
|
|
if (protect)
|
return cyttsp5_hid_output_start_bootloader(cd);
|
|
return cyttsp5_hid_output_start_bootloader_(cd);
|
}
|
|
static void cyttsp5_si_get_cydata(struct cyttsp5_core_data *cd)
|
{
|
struct cyttsp5_cydata *cydata = &cd->sysinfo.cydata;
|
struct cyttsp5_cydata_dev *cydata_dev =
|
(struct cyttsp5_cydata_dev *)
|
&cd->response_buf[HID_SYSINFO_CYDATA_OFFSET];
|
|
cydata->pip_ver_major = cydata_dev->pip_ver_major;
|
cydata->pip_ver_minor = cydata_dev->pip_ver_minor;
|
cydata->bl_ver_major = cydata_dev->bl_ver_major;
|
cydata->bl_ver_minor = cydata_dev->bl_ver_minor;
|
cydata->fw_ver_major = cydata_dev->fw_ver_major;
|
cydata->fw_ver_minor = cydata_dev->fw_ver_minor;
|
|
cydata->fw_pid = get_unaligned_le16(&cydata_dev->fw_pid);
|
cydata->fw_ver_conf = get_unaligned_le16(&cydata_dev->fw_ver_conf);
|
cydata->post_code = get_unaligned_le16(&cydata_dev->post_code);
|
cydata->revctrl = get_unaligned_le32(&cydata_dev->revctrl);
|
cydata->jtag_id_l = get_unaligned_le16(&cydata_dev->jtag_si_id_l);
|
cydata->jtag_id_h = get_unaligned_le16(&cydata_dev->jtag_si_id_h);
|
|
memcpy(cydata->mfg_id, cydata_dev->mfg_id, CY_NUM_MFGID);
|
|
cyttsp5_pr_buf(cd->dev, (u8 *)cydata_dev,
|
sizeof(struct cyttsp5_cydata_dev), "sysinfo_cydata");
|
}
|
|
static void cyttsp5_si_get_sensing_conf_data(struct cyttsp5_core_data *cd)
|
{
|
struct cyttsp5_sensing_conf_data *scd = &cd->sysinfo.sensing_conf_data;
|
struct cyttsp5_sensing_conf_data_dev *scd_dev =
|
(struct cyttsp5_sensing_conf_data_dev *)
|
&cd->response_buf[HID_SYSINFO_SENSING_OFFSET];
|
|
scd->electrodes_x = scd_dev->electrodes_x;
|
scd->electrodes_y = scd_dev->electrodes_y;
|
scd->origin_x = scd_dev->origin_x;
|
scd->origin_y = scd_dev->origin_y;
|
|
/* PIP 1.4 (001-82649 *Q) add X_IS_TX bit in X_ORG */
|
if (scd->origin_x & 0x02) {
|
scd->tx_num = scd->electrodes_x;
|
scd->rx_num = scd->electrodes_y;
|
} else {
|
scd->tx_num = scd->electrodes_y;
|
scd->rx_num = scd->electrodes_x;
|
}
|
|
scd->panel_id = scd_dev->panel_id;
|
scd->btn = scd_dev->btn;
|
scd->scan_mode = scd_dev->scan_mode;
|
scd->max_tch = scd_dev->max_num_of_tch_per_refresh_cycle;
|
|
scd->res_x = get_unaligned_le16(&scd_dev->res_x);
|
scd->res_y = get_unaligned_le16(&scd_dev->res_y);
|
scd->max_z = get_unaligned_le16(&scd_dev->max_z);
|
scd->len_x = get_unaligned_le16(&scd_dev->len_x);
|
scd->len_y = get_unaligned_le16(&scd_dev->len_y);
|
|
cyttsp5_pr_buf(cd->dev, (u8 *)scd_dev,
|
sizeof(struct cyttsp5_sensing_conf_data_dev),
|
"sensing_conf_data");
|
}
|
|
static int cyttsp5_si_setup(struct cyttsp5_core_data *cd)
|
{
|
struct cyttsp5_sysinfo *si = &cd->sysinfo;
|
int max_tch = si->sensing_conf_data.max_tch;
|
|
if (!si->xy_data)
|
si->xy_data = kzalloc(max_tch * si->desc.tch_record_size,
|
GFP_KERNEL);
|
if (!si->xy_data)
|
return -ENOMEM;
|
|
if (!si->xy_mode)
|
si->xy_mode = kzalloc(si->desc.tch_header_size, GFP_KERNEL);
|
if (!si->xy_mode) {
|
kfree(si->xy_data);
|
return -ENOMEM;
|
}
|
|
return 0;
|
}
|
|
static int cyttsp5_si_get_btn_data(struct cyttsp5_core_data *cd)
|
{
|
struct cyttsp5_sysinfo *si = &cd->sysinfo;
|
int num_btns = 0;
|
int num_defined_keys;
|
u16 *key_table;
|
int btn;
|
int i;
|
int rc = 0;
|
unsigned int btns = cd->response_buf[HID_SYSINFO_BTN_OFFSET]
|
& HID_SYSINFO_BTN_MASK;
|
size_t btn_keys_size;
|
|
parade_debug(cd->dev, DEBUG_LEVEL_2, "%s: get btn data\n", __func__);
|
|
for (i = 0; i < HID_SYSINFO_MAX_BTN; i++) {
|
if (btns & (1 << i))
|
num_btns++;
|
}
|
si->num_btns = num_btns;
|
|
if (num_btns) {
|
btn_keys_size = num_btns * sizeof(struct cyttsp5_btn);
|
if (!si->btn)
|
si->btn = kzalloc(btn_keys_size, GFP_KERNEL);
|
if (!si->btn)
|
return -ENOMEM;
|
|
if (cd->cpdata->sett[CY_IC_GRPNUM_BTN_KEYS] == NULL)
|
num_defined_keys = 0;
|
else if (cd->cpdata->sett[CY_IC_GRPNUM_BTN_KEYS]->data == NULL)
|
num_defined_keys = 0;
|
else
|
num_defined_keys = cd->cpdata->sett
|
[CY_IC_GRPNUM_BTN_KEYS]->size;
|
|
for (btn = 0; btn < num_btns && btn < num_defined_keys; btn++) {
|
key_table = (u16 *)cd->cpdata->sett
|
[CY_IC_GRPNUM_BTN_KEYS]->data;
|
si->btn[btn].key_code = key_table[btn];
|
si->btn[btn].enabled = true;
|
}
|
for (; btn < num_btns; btn++) {
|
si->btn[btn].key_code = KEY_RESERVED;
|
si->btn[btn].enabled = true;
|
}
|
|
return rc;
|
}
|
|
kfree(si->btn);
|
si->btn = NULL;
|
return rc;
|
}
|
|
static void cyttsp5_si_put_log_data(struct cyttsp5_core_data *cd)
|
{
|
struct cyttsp5_sysinfo *si = &cd->sysinfo;
|
struct cyttsp5_cydata *cydata = &si->cydata;
|
struct cyttsp5_sensing_conf_data *scd = &si->sensing_conf_data;
|
int i;
|
|
parade_debug(cd->dev, DEBUG_LEVEL_1, "%s: pip_ver_major =0x%02X (%d)\n",
|
__func__, cydata->pip_ver_major, cydata->pip_ver_major);
|
parade_debug(cd->dev, DEBUG_LEVEL_1, "%s: pip_ver_minor =0x%02X (%d)\n",
|
__func__, cydata->pip_ver_minor, cydata->pip_ver_minor);
|
parade_debug(cd->dev, DEBUG_LEVEL_1, "%s: fw_pid =0x%04X (%d)\n",
|
__func__, cydata->fw_pid, cydata->fw_pid);
|
parade_debug(cd->dev, DEBUG_LEVEL_1, "%s: fw_ver_major =0x%02X (%d)\n",
|
__func__, cydata->fw_ver_major, cydata->fw_ver_major);
|
parade_debug(cd->dev, DEBUG_LEVEL_1, "%s: fw_ver_minor =0x%02X (%d)\n",
|
__func__, cydata->fw_ver_minor, cydata->fw_ver_minor);
|
parade_debug(cd->dev, DEBUG_LEVEL_1, "%s: revctrl =0x%08X (%d)\n",
|
__func__, cydata->revctrl, cydata->revctrl);
|
parade_debug(cd->dev, DEBUG_LEVEL_1, "%s: fw_ver_conf =0x%04X (%d)\n",
|
__func__, cydata->fw_ver_conf, cydata->fw_ver_conf);
|
parade_debug(cd->dev, DEBUG_LEVEL_1, "%s: bl_ver_major =0x%02X (%d)\n",
|
__func__, cydata->bl_ver_major, cydata->bl_ver_major);
|
parade_debug(cd->dev, DEBUG_LEVEL_1, "%s: bl_ver_minor =0x%02X (%d)\n",
|
__func__, cydata->bl_ver_minor, cydata->bl_ver_minor);
|
parade_debug(cd->dev, DEBUG_LEVEL_1, "%s: jtag_id_h =0x%04X (%d)\n",
|
__func__, cydata->jtag_id_h, cydata->jtag_id_h);
|
parade_debug(cd->dev, DEBUG_LEVEL_1, "%s: jtag_id_l =0x%04X (%d)\n",
|
__func__, cydata->jtag_id_l, cydata->jtag_id_l);
|
for (i = 0; i < CY_NUM_MFGID; i++)
|
parade_debug(cd->dev, DEBUG_LEVEL_1, "%s: mfg_id[%d] =0x%02X (%d)\n",
|
__func__, i, cydata->mfg_id[i], cydata->mfg_id[i]);
|
parade_debug(cd->dev, DEBUG_LEVEL_1, "%s: post_code =0x%04X (%d)\n",
|
__func__, cydata->post_code, cydata->post_code);
|
|
parade_debug(cd->dev, DEBUG_LEVEL_1, "%s: electrodes_x =0x%02X (%d)\n",
|
__func__, scd->electrodes_x, scd->electrodes_x);
|
parade_debug(cd->dev, DEBUG_LEVEL_1, "%s: electrodes_y =0x%02X (%d)\n",
|
__func__, scd->electrodes_y, scd->electrodes_y);
|
parade_debug(cd->dev, DEBUG_LEVEL_1, "%s: len_x =0x%04X (%d)\n",
|
__func__, scd->len_x, scd->len_x);
|
parade_debug(cd->dev, DEBUG_LEVEL_1, "%s: len_y =0x%04X (%d)\n",
|
__func__, scd->len_y, scd->len_y);
|
parade_debug(cd->dev, DEBUG_LEVEL_1, "%s: res_x =0x%04X (%d)\n",
|
__func__, scd->res_x, scd->res_x);
|
parade_debug(cd->dev, DEBUG_LEVEL_1, "%s: res_y =0x%04X (%d)\n",
|
__func__, scd->res_y, scd->res_y);
|
parade_debug(cd->dev, DEBUG_LEVEL_1, "%s: max_z =0x%04X (%d)\n",
|
__func__, scd->max_z, scd->max_z);
|
parade_debug(cd->dev, DEBUG_LEVEL_1, "%s: origin_x =0x%02X (%d)\n",
|
__func__, scd->origin_x, scd->origin_x);
|
parade_debug(cd->dev, DEBUG_LEVEL_1, "%s: origin_y =0x%02X (%d)\n",
|
__func__, scd->origin_y, scd->origin_y);
|
parade_debug(cd->dev, DEBUG_LEVEL_1, "%s: panel_id =0x%02X (%d)\n",
|
__func__, scd->panel_id, scd->panel_id);
|
parade_debug(cd->dev, DEBUG_LEVEL_1, "%s: btn =0x%02X (%d)\n",
|
__func__, scd->btn, scd->btn);
|
parade_debug(cd->dev, DEBUG_LEVEL_1, "%s: scan_mode =0x%02X (%d)\n",
|
__func__, scd->scan_mode, scd->scan_mode);
|
parade_debug(cd->dev, DEBUG_LEVEL_1, "%s: max_num_of_tch_per_refresh_cycle =0x%02X (%d)\n",
|
__func__, scd->max_tch, scd->max_tch);
|
parade_debug(cd->dev, DEBUG_LEVEL_1, "%s: xy_mode =%p\n",
|
__func__, si->xy_mode);
|
parade_debug(cd->dev, DEBUG_LEVEL_1, "%s: xy_data =%p\n",
|
__func__, si->xy_data);
|
}
|
|
static int cyttsp5_get_sysinfo_regs(struct cyttsp5_core_data *cd)
|
{
|
struct cyttsp5_sysinfo *si = &cd->sysinfo;
|
int rc;
|
|
rc = cyttsp5_si_get_btn_data(cd);
|
if (rc < 0)
|
return rc;
|
|
cyttsp5_si_get_cydata(cd);
|
|
cyttsp5_si_get_sensing_conf_data(cd);
|
|
cyttsp5_si_setup(cd);
|
|
cyttsp5_si_put_log_data(cd);
|
|
si->ready = true;
|
return rc;
|
}
|
|
static void cyttsp5_free_si_ptrs(struct cyttsp5_core_data *cd)
|
{
|
struct cyttsp5_sysinfo *si = &cd->sysinfo;
|
|
kfree(si->btn);
|
kfree(si->xy_mode);
|
kfree(si->xy_data);
|
}
|
|
static int cyttsp5_hid_output_get_sysinfo_(struct cyttsp5_core_data *cd)
|
{
|
int rc;
|
struct cyttsp5_hid_output hid_output = {
|
HID_OUTPUT_APP_COMMAND(HID_OUTPUT_GET_SYSINFO),
|
.timeout_ms = CY_HID_OUTPUT_GET_SYSINFO_TIMEOUT,
|
};
|
|
rc = cyttsp5_hid_send_output_and_wait_(cd, &hid_output);
|
if (rc)
|
return rc;
|
|
rc = cyttsp5_get_sysinfo_regs(cd);
|
if (rc)
|
cyttsp5_free_si_ptrs(cd);
|
|
return rc;
|
}
|
|
static int cyttsp5_hid_output_get_sysinfo(struct cyttsp5_core_data *cd)
|
{
|
int rc;
|
|
rc = request_exclusive(cd, cd->dev, CY_REQUEST_EXCLUSIVE_TIMEOUT);
|
if (rc < 0) {
|
dev_err(cd->dev, "%s: fail get exclusive ex=%p own=%p\n",
|
__func__, cd->exclusive_dev, cd->dev);
|
return rc;
|
}
|
|
rc = cyttsp5_hid_output_get_sysinfo_(cd);
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
dev_err(cd->dev, "%s: fail to release exclusive\n", __func__);
|
|
return rc;
|
}
|
|
static int cyttsp5_hid_output_suspend_scanning_(struct cyttsp5_core_data *cd)
|
{
|
struct cyttsp5_hid_output hid_output = {
|
HID_OUTPUT_APP_COMMAND(HID_OUTPUT_SUSPEND_SCANNING),
|
.timeout_ms = 1000,
|
};
|
|
return cyttsp5_hid_send_output_and_wait_(cd, &hid_output);
|
}
|
|
static int cyttsp5_hid_output_suspend_scanning(struct cyttsp5_core_data *cd)
|
{
|
int rc;
|
|
rc = request_exclusive(cd, cd->dev, CY_REQUEST_EXCLUSIVE_TIMEOUT);
|
if (rc < 0) {
|
dev_err(cd->dev, "%s: fail get exclusive ex=%p own=%p\n",
|
__func__, cd->exclusive_dev, cd->dev);
|
return rc;
|
}
|
|
rc = cyttsp5_hid_output_suspend_scanning_(cd);
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
dev_err(cd->dev, "%s: fail to release exclusive\n", __func__);
|
|
return rc;
|
}
|
|
static int _cyttsp5_request_hid_output_suspend_scanning(struct device *dev,
|
int protect)
|
{
|
struct cyttsp5_core_data *cd = dev_get_drvdata(dev);
|
|
if (protect)
|
return cyttsp5_hid_output_suspend_scanning(cd);
|
|
return cyttsp5_hid_output_suspend_scanning_(cd);
|
}
|
|
static int cyttsp5_hid_output_resume_scanning_(struct cyttsp5_core_data *cd)
|
{
|
struct cyttsp5_hid_output hid_output = {
|
HID_OUTPUT_APP_COMMAND(HID_OUTPUT_RESUME_SCANNING),
|
};
|
|
return cyttsp5_hid_send_output_and_wait_(cd, &hid_output);
|
}
|
|
static int cyttsp5_hid_output_resume_scanning(struct cyttsp5_core_data *cd)
|
{
|
int rc;
|
|
rc = request_exclusive(cd, cd->dev, CY_REQUEST_EXCLUSIVE_TIMEOUT);
|
if (rc < 0) {
|
dev_err(cd->dev, "%s: fail get exclusive ex=%p own=%p\n",
|
__func__, cd->exclusive_dev, cd->dev);
|
return rc;
|
}
|
|
rc = cyttsp5_hid_output_resume_scanning_(cd);
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
dev_err(cd->dev, "%s: fail to release exclusive\n", __func__);
|
|
return rc;
|
}
|
|
static int _cyttsp5_request_hid_output_resume_scanning(struct device *dev,
|
int protect)
|
{
|
struct cyttsp5_core_data *cd = dev_get_drvdata(dev);
|
|
if (protect)
|
return cyttsp5_hid_output_resume_scanning(cd);
|
|
return cyttsp5_hid_output_resume_scanning_(cd);
|
}
|
|
static int cyttsp5_hid_output_get_param_(struct cyttsp5_core_data *cd,
|
u8 param_id, u32 *value)
|
{
|
int write_length = 1;
|
u8 param[1] = { param_id };
|
u8 read_param_id;
|
int param_size;
|
u8 *ptr;
|
int rc;
|
int i;
|
struct cyttsp5_hid_output hid_output = {
|
HID_OUTPUT_APP_COMMAND(HID_OUTPUT_GET_PARAM),
|
.write_length = write_length,
|
.write_buf = param,
|
};
|
|
rc = cyttsp5_hid_send_output_and_wait_(cd, &hid_output);
|
if (rc)
|
return rc;
|
|
read_param_id = cd->response_buf[5];
|
if (read_param_id != param_id)
|
return -EPROTO;
|
|
param_size = cd->response_buf[6];
|
ptr = &cd->response_buf[7];
|
*value = 0;
|
for (i = 0; i < param_size; i++)
|
*value += ptr[i] << (i * 8);
|
return 0;
|
}
|
|
static int cyttsp5_hid_output_get_param(struct cyttsp5_core_data *cd,
|
u8 param_id, u32 *value)
|
{
|
int rc;
|
|
rc = request_exclusive(cd, cd->dev, CY_REQUEST_EXCLUSIVE_TIMEOUT);
|
if (rc < 0) {
|
dev_err(cd->dev, "%s: fail get exclusive ex=%p own=%p\n",
|
__func__, cd->exclusive_dev, cd->dev);
|
return rc;
|
}
|
|
rc = cyttsp5_hid_output_get_param_(cd, param_id, value);
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
dev_err(cd->dev, "%s: fail to release exclusive\n", __func__);
|
|
return rc;
|
}
|
|
int _cyttsp5_request_hid_output_get_param(struct device *dev,
|
int protect, u8 param_id, u32 *value)
|
{
|
struct cyttsp5_core_data *cd = dev_get_drvdata(dev);
|
|
if (protect)
|
return cyttsp5_hid_output_get_param(cd, param_id, value);
|
|
return cyttsp5_hid_output_get_param_(cd, param_id, value);
|
}
|
|
static int cyttsp5_hid_output_set_param_(struct cyttsp5_core_data *cd,
|
u8 param_id, u32 value, u8 size)
|
{
|
u8 write_buf[6];
|
u8 *ptr = &write_buf[2];
|
int rc;
|
int i;
|
struct cyttsp5_hid_output hid_output = {
|
HID_OUTPUT_APP_COMMAND(HID_OUTPUT_SET_PARAM),
|
.write_buf = write_buf,
|
};
|
|
write_buf[0] = param_id;
|
write_buf[1] = size;
|
for (i = 0; i < size; i++) {
|
ptr[i] = value & 0xFF;
|
value = value >> 8;
|
}
|
|
hid_output.write_length = 2 + size;
|
|
rc = cyttsp5_hid_send_output_and_wait_(cd, &hid_output);
|
if (rc)
|
return rc;
|
|
if (param_id != cd->response_buf[5] || size != cd->response_buf[6])
|
return -EPROTO;
|
|
return 0;
|
}
|
|
static int cyttsp5_hid_output_set_param(struct cyttsp5_core_data *cd,
|
u8 param_id, u32 value, u8 size)
|
{
|
int rc;
|
|
rc = request_exclusive(cd, cd->dev, CY_REQUEST_EXCLUSIVE_TIMEOUT);
|
if (rc < 0) {
|
dev_err(cd->dev, "%s: fail get exclusive ex=%p own=%p\n",
|
__func__, cd->exclusive_dev, cd->dev);
|
return rc;
|
}
|
|
rc = cyttsp5_hid_output_set_param_(cd, param_id, value, size);
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
dev_err(cd->dev, "%s: fail to release exclusive\n", __func__);
|
|
return rc;
|
}
|
|
int _cyttsp5_request_hid_output_set_param(struct device *dev,
|
int protect, u8 param_id, u32 value, u8 size)
|
{
|
struct cyttsp5_core_data *cd = dev_get_drvdata(dev);
|
|
if (protect)
|
return cyttsp5_hid_output_set_param(cd, param_id, value, size);
|
|
return cyttsp5_hid_output_set_param_(cd, param_id, value, size);
|
}
|
|
static int cyttsp5_hid_output_enter_easywake_state_(
|
struct cyttsp5_core_data *cd, u8 data, u8 *return_data)
|
{
|
int write_length = 1;
|
u8 param[1] = { data };
|
int rc;
|
struct cyttsp5_hid_output hid_output = {
|
HID_OUTPUT_APP_COMMAND(HID_OUTPUT_ENTER_EASYWAKE_STATE),
|
.write_length = write_length,
|
.write_buf = param,
|
};
|
|
rc = cyttsp5_hid_send_output_and_wait_(cd, &hid_output);
|
if (rc)
|
return rc;
|
|
*return_data = cd->response_buf[5];
|
return rc;
|
}
|
|
static int cyttsp5_hid_output_verify_config_block_crc_(
|
struct cyttsp5_core_data *cd, u8 ebid, u8 *status,
|
u16 *calculated_crc, u16 *stored_crc)
|
{
|
int write_length = 1;
|
u8 param[1] = { ebid };
|
u8 *ptr;
|
int rc;
|
struct cyttsp5_hid_output hid_output = {
|
HID_OUTPUT_APP_COMMAND(HID_OUTPUT_VERIFY_CONFIG_BLOCK_CRC),
|
.write_length = write_length,
|
.write_buf = param,
|
.timeout_ms = 1000,
|
};
|
|
rc = cyttsp5_hid_send_output_and_wait_(cd, &hid_output);
|
if (rc)
|
return rc;
|
|
ptr = &cd->response_buf[5];
|
*status = ptr[0];
|
*calculated_crc = get_unaligned_le16(&ptr[1]);
|
*stored_crc = get_unaligned_le16(&ptr[3]);
|
return 0;
|
}
|
|
static int cyttsp5_hid_output_verify_config_block_crc(
|
struct cyttsp5_core_data *cd, u8 ebid, u8 *status,
|
u16 *calculated_crc, u16 *stored_crc)
|
{
|
int rc;
|
|
rc = request_exclusive(cd, cd->dev, CY_REQUEST_EXCLUSIVE_TIMEOUT);
|
if (rc < 0) {
|
dev_err(cd->dev, "%s: fail get exclusive ex=%p own=%p\n",
|
__func__, cd->exclusive_dev, cd->dev);
|
return rc;
|
}
|
|
rc = cyttsp5_hid_output_verify_config_block_crc_(cd, ebid, status,
|
calculated_crc, stored_crc);
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
dev_err(cd->dev, "%s: fail to release exclusive\n", __func__);
|
|
return rc;
|
}
|
|
static int _cyttsp5_request_hid_output_verify_config_block_crc(
|
struct device *dev, int protect, u8 ebid, u8 *status,
|
u16 *calculated_crc, u16 *stored_crc)
|
{
|
struct cyttsp5_core_data *cd = dev_get_drvdata(dev);
|
|
if (protect)
|
return cyttsp5_hid_output_verify_config_block_crc(cd, ebid,
|
status, calculated_crc, stored_crc);
|
|
return cyttsp5_hid_output_verify_config_block_crc_(cd, ebid,
|
status, calculated_crc, stored_crc);
|
}
|
|
static int cyttsp5_hid_output_get_config_row_size_(struct cyttsp5_core_data *cd,
|
u16 *row_size)
|
{
|
int rc;
|
struct cyttsp5_hid_output hid_output = {
|
HID_OUTPUT_APP_COMMAND(HID_OUTPUT_GET_CONFIG_ROW_SIZE),
|
};
|
|
rc = cyttsp5_hid_send_output_and_wait_(cd, &hid_output);
|
if (rc)
|
return rc;
|
|
*row_size = get_unaligned_le16(&cd->response_buf[5]);
|
return 0;
|
}
|
|
static int cyttsp5_hid_output_get_config_row_size(struct cyttsp5_core_data *cd,
|
u16 *row_size)
|
{
|
int rc;
|
|
rc = request_exclusive(cd, cd->dev, CY_REQUEST_EXCLUSIVE_TIMEOUT);
|
if (rc < 0) {
|
dev_err(cd->dev, "%s: fail get exclusive ex=%p own=%p\n",
|
__func__, cd->exclusive_dev, cd->dev);
|
return rc;
|
}
|
|
rc = cyttsp5_hid_output_get_config_row_size_(cd, row_size);
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
dev_err(cd->dev, "%s: fail to release exclusive\n", __func__);
|
|
return rc;
|
}
|
|
static int _cyttsp5_request_hid_output_get_config_row_size(struct device *dev,
|
int protect, u16 *row_size)
|
{
|
struct cyttsp5_core_data *cd = dev_get_drvdata(dev);
|
|
if (protect)
|
return cyttsp5_hid_output_get_config_row_size(cd, row_size);
|
|
return cyttsp5_hid_output_get_config_row_size_(cd, row_size);
|
}
|
|
static int cyttsp5_hid_output_read_conf_block_(struct cyttsp5_core_data *cd,
|
u16 row_number, u16 length, u8 ebid, u8 *read_buf, u16 *crc)
|
{
|
int read_ebid;
|
int read_length;
|
int status;
|
int rc;
|
int write_length = 5;
|
u8 write_buf[5];
|
u8 cmd_offset = 0;
|
struct cyttsp5_hid_output hid_output = {
|
HID_OUTPUT_APP_COMMAND(HID_OUTPUT_READ_CONF_BLOCK),
|
.write_length = write_length,
|
.write_buf = write_buf,
|
};
|
|
write_buf[cmd_offset++] = LOW_BYTE(row_number);
|
write_buf[cmd_offset++] = HI_BYTE(row_number);
|
write_buf[cmd_offset++] = LOW_BYTE(length);
|
write_buf[cmd_offset++] = HI_BYTE(length);
|
write_buf[cmd_offset++] = ebid;
|
|
rc = cyttsp5_hid_send_output_and_wait_(cd, &hid_output);
|
if (rc)
|
return rc;
|
|
status = cd->response_buf[5];
|
if (status)
|
return -EINVAL;
|
|
read_ebid = cd->response_buf[6];
|
if ((read_ebid != ebid) || (cd->response_buf[9] != 0))
|
return -EPROTO;
|
|
read_length = get_unaligned_le16(&cd->response_buf[7]);
|
if (length < read_length)
|
length = read_length;
|
|
memcpy(read_buf, &cd->response_buf[10], length);
|
*crc = get_unaligned_le16(&cd->response_buf[read_length + 10]);
|
|
return 0;
|
}
|
|
static int cyttsp5_hid_output_read_conf_ver_(struct cyttsp5_core_data *cd,
|
u16 *config_ver)
|
{
|
int rc;
|
u8 read_buf[CY_TTCONFIG_VERSION_OFFSET + CY_TTCONFIG_VERSION_SIZE];
|
u16 crc;
|
|
rc = cyttsp5_hid_output_read_conf_block_(cd, CY_TTCONFIG_VERSION_ROW,
|
CY_TTCONFIG_VERSION_OFFSET + CY_TTCONFIG_VERSION_SIZE,
|
CY_TCH_PARM_EBID, read_buf, &crc);
|
if (rc)
|
return rc;
|
|
*config_ver = get_unaligned_le16(
|
&read_buf[CY_TTCONFIG_VERSION_OFFSET]);
|
|
return 0;
|
}
|
|
static int cyttsp5_hid_output_write_conf_block_(struct cyttsp5_core_data *cd,
|
u16 row_number, u16 write_length, u8 ebid, u8 *write_buf,
|
u8 *security_key, u16 *actual_write_len)
|
{
|
/* row_number + write_len + ebid + security_key + crc */
|
int full_write_length = 2 + 2 + 1 + write_length + 8 + 2;
|
u8 *full_write_buf;
|
u8 cmd_offset = 0;
|
u16 crc;
|
int status;
|
int rc;
|
int read_ebid;
|
u8 *data;
|
struct cyttsp5_hid_output hid_output = {
|
HID_OUTPUT_APP_COMMAND(HID_OUTPUT_WRITE_CONF_BLOCK),
|
.write_length = full_write_length,
|
.timeout_ms = CY_HID_OUTPUT_WRITE_CONF_BLOCK_TIMEOUT,
|
};
|
|
full_write_buf = kzalloc(full_write_length, GFP_KERNEL);
|
if (!full_write_buf)
|
return -ENOMEM;
|
|
hid_output.write_buf = full_write_buf;
|
full_write_buf[cmd_offset++] = LOW_BYTE(row_number);
|
full_write_buf[cmd_offset++] = HI_BYTE(row_number);
|
full_write_buf[cmd_offset++] = LOW_BYTE(write_length);
|
full_write_buf[cmd_offset++] = HI_BYTE(write_length);
|
full_write_buf[cmd_offset++] = ebid;
|
data = &full_write_buf[cmd_offset];
|
memcpy(data, write_buf, write_length);
|
cmd_offset += write_length;
|
memcpy(&full_write_buf[cmd_offset], security_key, 8);
|
cmd_offset += 8;
|
crc = _cyttsp5_compute_crc(data, write_length);
|
full_write_buf[cmd_offset++] = LOW_BYTE(crc);
|
full_write_buf[cmd_offset++] = HI_BYTE(crc);
|
|
rc = cyttsp5_hid_send_output_and_wait_(cd, &hid_output);
|
if (rc)
|
goto exit;
|
|
status = cd->response_buf[5];
|
if (status) {
|
rc = -EINVAL;
|
goto exit;
|
}
|
|
read_ebid = cd->response_buf[6];
|
if (read_ebid != ebid) {
|
rc = -EPROTO;
|
goto exit;
|
}
|
|
*actual_write_len = get_unaligned_le16(&cd->response_buf[7]);
|
|
exit:
|
kfree(full_write_buf);
|
return rc;
|
}
|
|
static int cyttsp5_hid_output_write_conf_block(struct cyttsp5_core_data *cd,
|
u16 row_number, u16 write_length, u8 ebid, u8 *write_buf,
|
u8 *security_key, u16 *actual_write_len)
|
{
|
int rc;
|
|
rc = request_exclusive(cd, cd->dev, CY_REQUEST_EXCLUSIVE_TIMEOUT);
|
if (rc < 0) {
|
dev_err(cd->dev, "%s: fail get exclusive ex=%p own=%p\n",
|
__func__, cd->exclusive_dev, cd->dev);
|
return rc;
|
}
|
|
rc = cyttsp5_hid_output_write_conf_block_(cd, row_number, write_length,
|
ebid, write_buf, security_key, actual_write_len);
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
dev_err(cd->dev, "%s: fail to release exclusive\n", __func__);
|
|
return rc;
|
}
|
|
static int _cyttsp5_request_hid_output_write_conf_block(struct device *dev,
|
int protect, u16 row_number, u16 write_length, u8 ebid,
|
u8 *write_buf, u8 *security_key, u16 *actual_write_len)
|
{
|
struct cyttsp5_core_data *cd = dev_get_drvdata(dev);
|
|
if (protect)
|
return cyttsp5_hid_output_write_conf_block(cd, row_number,
|
write_length, ebid, write_buf, security_key,
|
actual_write_len);
|
|
return cyttsp5_hid_output_write_conf_block_(cd, row_number,
|
write_length, ebid, write_buf, security_key,
|
actual_write_len);
|
}
|
|
static int cyttsp5_hid_output_get_data_structure_(
|
struct cyttsp5_core_data *cd, u16 read_offset, u16 read_length,
|
u8 data_id, u8 *status, u8 *data_format, u16 *actual_read_len,
|
u8 *data)
|
{
|
int rc;
|
u16 total_read_len = 0;
|
u16 read_len;
|
u16 off_buf = 0;
|
u8 write_buf[5];
|
u8 read_data_id;
|
struct cyttsp5_hid_output hid_output = {
|
HID_OUTPUT_APP_COMMAND(HID_OUTPUT_GET_DATA_STRUCTURE),
|
.write_length = 5,
|
.write_buf = write_buf,
|
};
|
|
again:
|
write_buf[0] = LOW_BYTE(read_offset);
|
write_buf[1] = HI_BYTE(read_offset);
|
write_buf[2] = LOW_BYTE(read_length);
|
write_buf[3] = HI_BYTE(read_length);
|
write_buf[4] = data_id;
|
|
rc = cyttsp5_hid_send_output_and_wait_(cd, &hid_output);
|
if (rc)
|
return rc;
|
|
if (cd->response_buf[5] != CY_CMD_STATUS_SUCCESS)
|
goto set_status;
|
|
read_data_id = cd->response_buf[6];
|
if (read_data_id != data_id)
|
return -EPROTO;
|
|
read_len = get_unaligned_le16(&cd->response_buf[7]);
|
if (read_len && data) {
|
memcpy(&data[off_buf], &cd->response_buf[10], read_len);
|
|
total_read_len += read_len;
|
|
if (read_len < read_length) {
|
read_offset += read_len;
|
off_buf += read_len;
|
read_length -= read_len;
|
goto again;
|
}
|
}
|
|
if (data_format)
|
*data_format = cd->response_buf[9];
|
if (actual_read_len)
|
*actual_read_len = total_read_len;
|
set_status:
|
if (status)
|
*status = cd->response_buf[5];
|
|
return rc;
|
}
|
|
static int cyttsp5_hid_output_get_data_structure(
|
struct cyttsp5_core_data *cd, u16 read_offset, u16 read_length,
|
u8 data_id, u8 *status, u8 *data_format, u16 *actual_read_len,
|
u8 *data)
|
{
|
int rc;
|
|
rc = request_exclusive(cd, cd->dev, CY_REQUEST_EXCLUSIVE_TIMEOUT);
|
if (rc < 0) {
|
dev_err(cd->dev, "%s: fail get exclusive ex=%p own=%p\n",
|
__func__, cd->exclusive_dev, cd->dev);
|
return rc;
|
}
|
|
rc = cyttsp5_hid_output_get_data_structure_(cd, read_offset,
|
read_length, data_id, status, data_format,
|
actual_read_len, data);
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
dev_err(cd->dev, "%s: fail to release exclusive\n", __func__);
|
|
return rc;
|
}
|
|
static int _cyttsp5_request_hid_output_get_data_structure(struct device *dev,
|
int protect, u16 read_offset, u16 read_length, u8 data_id,
|
u8 *status, u8 *data_format, u16 *actual_read_len, u8 *data)
|
{
|
struct cyttsp5_core_data *cd = dev_get_drvdata(dev);
|
|
if (protect)
|
return cyttsp5_hid_output_get_data_structure(cd,
|
read_offset, read_length, data_id, status,
|
data_format, actual_read_len, data);
|
|
return cyttsp5_hid_output_get_data_structure_(cd,
|
read_offset, read_length, data_id, status,
|
data_format, actual_read_len, data);
|
}
|
|
static int cyttsp5_hid_output_run_selftest_(
|
struct cyttsp5_core_data *cd, u8 test_id,
|
u8 write_idacs_to_flash, u8 *status, u8 *summary_result,
|
u8 *results_available)
|
{
|
int rc;
|
u8 write_buf[2];
|
struct cyttsp5_hid_output hid_output = {
|
HID_OUTPUT_APP_COMMAND(HID_OUTPUT_RUN_SELF_TEST),
|
.write_length = 2,
|
.write_buf = write_buf,
|
.timeout_ms = CY_HID_OUTPUT_RUN_SELF_TEST_TIMEOUT,
|
};
|
|
write_buf[0] = test_id;
|
write_buf[1] = write_idacs_to_flash;
|
|
rc = cyttsp5_hid_send_output_and_wait_(cd, &hid_output);
|
if (rc)
|
return rc;
|
|
if (status)
|
*status = cd->response_buf[5];
|
if (summary_result)
|
*summary_result = cd->response_buf[6];
|
if (results_available)
|
*results_available = cd->response_buf[7];
|
|
return rc;
|
}
|
|
static int cyttsp5_hid_output_run_selftest(
|
struct cyttsp5_core_data *cd, u8 test_id,
|
u8 write_idacs_to_flash, u8 *status, u8 *summary_result,
|
u8 *results_available)
|
{
|
int rc;
|
|
rc = request_exclusive(cd, cd->dev, CY_REQUEST_EXCLUSIVE_TIMEOUT);
|
if (rc < 0) {
|
dev_err(cd->dev, "%s: fail get exclusive ex=%p own=%p\n",
|
__func__, cd->exclusive_dev, cd->dev);
|
return rc;
|
}
|
|
rc = cyttsp5_hid_output_run_selftest_(cd, test_id,
|
write_idacs_to_flash, status, summary_result,
|
results_available);
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
dev_err(cd->dev, "%s: fail to release exclusive\n", __func__);
|
|
return rc;
|
}
|
|
static int _cyttsp5_request_hid_output_run_selftest(struct device *dev,
|
int protect, u8 test_id, u8 write_idacs_to_flash, u8 *status,
|
u8 *summary_result, u8 *results_available)
|
{
|
struct cyttsp5_core_data *cd = dev_get_drvdata(dev);
|
|
if (protect)
|
return cyttsp5_hid_output_run_selftest(cd, test_id,
|
write_idacs_to_flash, status, summary_result,
|
results_available);
|
|
return cyttsp5_hid_output_run_selftest_(cd, test_id,
|
write_idacs_to_flash, status, summary_result,
|
results_available);
|
}
|
|
static int cyttsp5_hid_output_get_selftest_result_(
|
struct cyttsp5_core_data *cd, u16 read_offset, u16 read_length,
|
u8 test_id, u8 *status, u16 *actual_read_len, u8 *data)
|
{
|
int rc;
|
u16 total_read_len = 0;
|
u16 read_len;
|
u16 off_buf = 0;
|
u8 write_buf[5];
|
u8 read_test_id;
|
bool repeat;
|
struct cyttsp5_hid_output hid_output = {
|
HID_OUTPUT_APP_COMMAND(HID_OUTPUT_GET_SELF_TEST_RESULT),
|
.write_length = 5,
|
.write_buf = write_buf,
|
};
|
|
/*
|
* Do not repeat reading for Auto Shorts test
|
* when PIP version < 1.3
|
*/
|
repeat = IS_PIP_VER_GE(&cd->sysinfo, 1, 3)
|
|| test_id != CY_ST_ID_AUTOSHORTS;
|
|
again:
|
write_buf[0] = LOW_BYTE(read_offset);
|
write_buf[1] = HI_BYTE(read_offset);
|
write_buf[2] = LOW_BYTE(read_length);
|
write_buf[3] = HI_BYTE(read_length);
|
write_buf[4] = test_id;
|
|
rc = cyttsp5_hid_send_output_and_wait_(cd, &hid_output);
|
if (rc)
|
return rc;
|
|
if (cd->response_buf[5] != CY_CMD_STATUS_SUCCESS)
|
goto set_status;
|
|
read_test_id = cd->response_buf[6];
|
if (read_test_id != test_id)
|
return -EPROTO;
|
|
read_len = get_unaligned_le16(&cd->response_buf[7]);
|
if (read_len && data) {
|
memcpy(&data[off_buf], &cd->response_buf[10], read_len);
|
|
total_read_len += read_len;
|
|
if (repeat && read_len < read_length) {
|
read_offset += read_len;
|
off_buf += read_len;
|
read_length -= read_len;
|
goto again;
|
}
|
}
|
|
if (actual_read_len)
|
*actual_read_len = total_read_len;
|
set_status:
|
if (status)
|
*status = cd->response_buf[5];
|
|
return rc;
|
}
|
|
static int cyttsp5_hid_output_get_selftest_result(
|
struct cyttsp5_core_data *cd, u16 read_offset, u16 read_length,
|
u8 test_id, u8 *status, u16 *actual_read_len, u8 *data)
|
{
|
int rc;
|
|
rc = request_exclusive(cd, cd->dev, CY_REQUEST_EXCLUSIVE_TIMEOUT);
|
if (rc < 0) {
|
dev_err(cd->dev, "%s: fail get exclusive ex=%p own=%p\n",
|
__func__, cd->exclusive_dev, cd->dev);
|
return rc;
|
}
|
|
rc = cyttsp5_hid_output_get_selftest_result_(cd, read_offset,
|
read_length, test_id, status, actual_read_len, data);
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
dev_err(cd->dev, "%s: fail to release exclusive\n", __func__);
|
|
return rc;
|
}
|
|
static int _cyttsp5_request_hid_output_get_selftest_result(struct device *dev,
|
int protect, u16 read_offset, u16 read_length, u8 test_id,
|
u8 *status, u16 *actual_read_len, u8 *data)
|
{
|
struct cyttsp5_core_data *cd = dev_get_drvdata(dev);
|
|
if (protect)
|
return cyttsp5_hid_output_get_selftest_result(cd, read_offset,
|
read_length, test_id, status, actual_read_len,
|
data);
|
|
return cyttsp5_hid_output_get_selftest_result_(cd, read_offset,
|
read_length, test_id, status, actual_read_len,
|
data);
|
}
|
|
static int cyttsp5_hid_output_calibrate_idacs_(struct cyttsp5_core_data *cd,
|
u8 mode, u8 *status)
|
{
|
int rc;
|
int write_length = 1;
|
u8 write_buf[1];
|
u8 cmd_offset = 0;
|
struct cyttsp5_hid_output hid_output = {
|
HID_OUTPUT_APP_COMMAND(HID_OUTPUT_CALIBRATE_IDACS),
|
.write_length = write_length,
|
.write_buf = write_buf,
|
.timeout_ms = CY_HID_OUTPUT_CALIBRATE_IDAC_TIMEOUT,
|
};
|
|
write_buf[cmd_offset++] = mode;
|
rc = cyttsp5_hid_send_output_and_wait_(cd, &hid_output);
|
if (rc)
|
return rc;
|
|
*status = cd->response_buf[5];
|
if (*status)
|
return -EINVAL;
|
|
return 0;
|
}
|
|
static int cyttsp5_hid_output_calibrate_idacs(struct cyttsp5_core_data *cd,
|
u8 mode, u8 *status)
|
{
|
int rc;
|
|
rc = request_exclusive(cd, cd->dev, CY_REQUEST_EXCLUSIVE_TIMEOUT);
|
if (rc < 0) {
|
dev_err(cd->dev, "%s: fail get exclusive ex=%p own=%p\n",
|
__func__, cd->exclusive_dev, cd->dev);
|
return rc;
|
}
|
|
rc = cyttsp5_hid_output_calibrate_idacs_(cd, mode, status);
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
dev_err(cd->dev, "%s: fail to release exclusive\n", __func__);
|
|
return rc;
|
}
|
|
static int _cyttsp5_request_hid_output_calibrate_idacs(struct device *dev,
|
int protect, u8 mode, u8 *status)
|
{
|
struct cyttsp5_core_data *cd = dev_get_drvdata(dev);
|
|
if (protect)
|
return cyttsp5_hid_output_calibrate_idacs(cd, mode, status);
|
|
return cyttsp5_hid_output_calibrate_idacs_(cd, mode, status);
|
}
|
|
static int cyttsp5_hid_output_initialize_baselines_(
|
struct cyttsp5_core_data *cd, u8 test_id, u8 *status)
|
{
|
int rc;
|
int write_length = 1;
|
u8 write_buf[1];
|
u8 cmd_offset = 0;
|
struct cyttsp5_hid_output hid_output = {
|
HID_OUTPUT_APP_COMMAND(HID_OUTPUT_INITIALIZE_BASELINES),
|
.write_length = write_length,
|
.write_buf = write_buf,
|
};
|
|
write_buf[cmd_offset++] = test_id;
|
|
rc = cyttsp5_hid_send_output_and_wait_(cd, &hid_output);
|
if (rc)
|
return rc;
|
|
*status = cd->response_buf[5];
|
if (*status)
|
return -EINVAL;
|
|
return rc;
|
}
|
|
static int cyttsp5_hid_output_initialize_baselines(struct cyttsp5_core_data *cd,
|
u8 test_id, u8 *status)
|
{
|
int rc;
|
|
rc = request_exclusive(cd, cd->dev, CY_REQUEST_EXCLUSIVE_TIMEOUT);
|
if (rc < 0) {
|
dev_err(cd->dev, "%s: fail get exclusive ex=%p own=%p\n",
|
__func__, cd->exclusive_dev, cd->dev);
|
return rc;
|
}
|
|
rc = cyttsp5_hid_output_initialize_baselines_(cd, test_id, status);
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
dev_err(cd->dev, "%s: fail to release exclusive\n", __func__);
|
|
return rc;
|
}
|
|
static int _cyttsp5_request_hid_output_initialize_baselines(struct device *dev,
|
int protect, u8 test_id, u8 *status)
|
{
|
struct cyttsp5_core_data *cd = dev_get_drvdata(dev);
|
|
if (protect)
|
return cyttsp5_hid_output_initialize_baselines(cd, test_id,
|
status);
|
|
return cyttsp5_hid_output_initialize_baselines_(cd, test_id, status);
|
}
|
|
static int cyttsp5_hid_output_exec_panel_scan_(struct cyttsp5_core_data *cd)
|
{
|
struct cyttsp5_hid_output hid_output = {
|
HID_OUTPUT_APP_COMMAND(HID_OUTPUT_EXEC_PANEL_SCAN),
|
};
|
|
return cyttsp5_hid_send_output_and_wait_(cd, &hid_output);
|
}
|
|
static int cyttsp5_hid_output_exec_panel_scan(struct cyttsp5_core_data *cd)
|
{
|
int rc;
|
|
rc = request_exclusive(cd, cd->dev, CY_REQUEST_EXCLUSIVE_TIMEOUT);
|
if (rc < 0) {
|
dev_err(cd->dev, "%s: fail get exclusive ex=%p own=%p\n",
|
__func__, cd->exclusive_dev, cd->dev);
|
return rc;
|
}
|
|
rc = cyttsp5_hid_output_exec_panel_scan_(cd);
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
dev_err(cd->dev, "%s: fail to release exclusive\n", __func__);
|
|
return rc;
|
}
|
|
static int _cyttsp5_request_hid_output_exec_panel_scan(struct device *dev,
|
int protect)
|
{
|
struct cyttsp5_core_data *cd = dev_get_drvdata(dev);
|
|
if (protect)
|
return cyttsp5_hid_output_exec_panel_scan(cd);
|
|
return cyttsp5_hid_output_exec_panel_scan_(cd);
|
}
|
|
/* @response: set none NULL only if all response required including header */
|
static int cyttsp5_hid_output_retrieve_panel_scan_(
|
struct cyttsp5_core_data *cd, u16 read_offset, u16 read_count,
|
u8 data_id, u8 *response, u8 *config, u16 *actual_read_len,
|
u8 *read_buf)
|
{
|
int status;
|
u8 read_data_id;
|
int rc;
|
int write_length = 5;
|
u8 write_buf[5];
|
u8 cmd_offset = 0;
|
u8 data_elem_size;
|
int size;
|
int data_size;
|
struct cyttsp5_hid_output hid_output = {
|
HID_OUTPUT_APP_COMMAND(HID_OUTPUT_RETRIEVE_PANEL_SCAN),
|
.write_length = write_length,
|
.write_buf = write_buf,
|
};
|
|
write_buf[cmd_offset++] = LOW_BYTE(read_offset);
|
write_buf[cmd_offset++] = HI_BYTE(read_offset);
|
write_buf[cmd_offset++] = LOW_BYTE(read_count);
|
write_buf[cmd_offset++] = HI_BYTE(read_count);
|
write_buf[cmd_offset++] = data_id;
|
|
rc = cyttsp5_hid_send_output_and_wait_(cd, &hid_output);
|
if (rc)
|
return rc;
|
|
status = cd->response_buf[5];
|
if (status)
|
return -EINVAL;
|
|
read_data_id = cd->response_buf[6];
|
if (read_data_id != data_id)
|
return -EPROTO;
|
|
size = get_unaligned_le16(&cd->response_buf[0]);
|
*actual_read_len = get_unaligned_le16(&cd->response_buf[7]);
|
*config = cd->response_buf[9];
|
|
data_elem_size = *config & 0x07;
|
data_size = *actual_read_len * data_elem_size;
|
|
if (read_buf)
|
memcpy(read_buf, &cd->response_buf[10], data_size);
|
if (response)
|
memcpy(response, cd->response_buf, size);
|
return rc;
|
}
|
|
static int cyttsp5_hid_output_retrieve_panel_scan(
|
struct cyttsp5_core_data *cd, u16 read_offset, u16 read_count,
|
u8 data_id, u8 *response, u8 *config, u16 *actual_read_len,
|
u8 *read_buf)
|
{
|
int rc;
|
|
rc = request_exclusive(cd, cd->dev, CY_REQUEST_EXCLUSIVE_TIMEOUT);
|
if (rc < 0) {
|
dev_err(cd->dev, "%s: fail get exclusive ex=%p own=%p\n",
|
__func__, cd->exclusive_dev, cd->dev);
|
return rc;
|
}
|
|
rc = cyttsp5_hid_output_retrieve_panel_scan_(cd, read_offset,
|
read_count, data_id, response, config,
|
actual_read_len, read_buf);
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
dev_err(cd->dev, "%s: fail to release exclusive\n", __func__);
|
|
return rc;
|
}
|
|
static int _cyttsp5_request_hid_output_retrieve_panel_scan(struct device *dev,
|
int protect, u16 read_offset, u16 read_count, u8 data_id,
|
u8 *response, u8 *config, u16 *actual_read_len, u8 *read_buf)
|
{
|
struct cyttsp5_core_data *cd = dev_get_drvdata(dev);
|
|
if (protect)
|
return cyttsp5_hid_output_retrieve_panel_scan(cd,
|
read_offset, read_count, data_id, response,
|
config, actual_read_len, read_buf);
|
|
return cyttsp5_hid_output_retrieve_panel_scan_(cd,
|
read_offset, read_count, data_id, response,
|
config, actual_read_len, read_buf);
|
}
|
|
static int cyttsp5_hid_output_user_cmd_(struct cyttsp5_core_data *cd,
|
u16 read_len, u8 *read_buf, u16 write_len, u8 *write_buf,
|
u16 *actual_read_len)
|
{
|
int rc;
|
u16 size;
|
#ifdef TTHE_TUNER_SUPPORT
|
int command_code = 0;
|
int len;
|
#endif
|
struct cyttsp5_hid_output hid_output = {
|
.length = write_len,
|
.write_buf = write_buf,
|
};
|
|
rc = cyttsp5_hid_send_output_user_and_wait_(cd, &hid_output);
|
if (rc)
|
return rc;
|
|
size = get_unaligned_le16(&cd->response_buf[0]);
|
if (size == 0)
|
size = 2;
|
|
if (size > read_len) {
|
*actual_read_len = 0;
|
return -EINVAL;
|
}
|
|
memcpy(read_buf, cd->response_buf, size);
|
*actual_read_len = size;
|
|
#ifdef TTHE_TUNER_SUPPORT
|
/* print up to cmd code */
|
len = HID_OUTPUT_CMD_OFFSET + 1;
|
if (write_len < len)
|
len = write_len;
|
else
|
command_code = write_buf[HID_OUTPUT_CMD_OFFSET]
|
& HID_OUTPUT_CMD_MASK;
|
|
/* Do not print for EXEC_PANEL_SCAN & RETRIEVE_PANEL_SCAN commands */
|
if (command_code != HID_OUTPUT_EXEC_PANEL_SCAN
|
&& command_code != HID_OUTPUT_RETRIEVE_PANEL_SCAN)
|
tthe_print(cd, write_buf, len, "CMD=");
|
#endif
|
|
return 0;
|
}
|
|
static int cyttsp5_get_config_ver_(struct cyttsp5_core_data *cd)
|
{
|
struct cyttsp5_sysinfo *si = &cd->sysinfo;
|
int rc;
|
u16 config_ver = 0;
|
|
rc = cyttsp5_hid_output_suspend_scanning_(cd);
|
if (rc)
|
goto error;
|
|
rc = cyttsp5_hid_output_read_conf_ver_(cd, &config_ver);
|
if (rc)
|
goto exit;
|
|
si->cydata.fw_ver_conf = config_ver;
|
|
exit:
|
cyttsp5_hid_output_resume_scanning_(cd);
|
error:
|
parade_debug(cd->dev, DEBUG_LEVEL_1, "%s: CONFIG_VER:%04X\n",
|
__func__, config_ver);
|
return rc;
|
}
|
|
static int cyttsp5_hid_output_user_cmd(struct cyttsp5_core_data *cd,
|
u16 read_len, u8 *read_buf, u16 write_len, u8 *write_buf,
|
u16 *actual_read_len)
|
{
|
int rc;
|
|
rc = request_exclusive(cd, cd->dev, CY_REQUEST_EXCLUSIVE_TIMEOUT);
|
if (rc < 0) {
|
dev_err(cd->dev, "%s: fail get exclusive ex=%p own=%p\n",
|
__func__, cd->exclusive_dev, cd->dev);
|
return rc;
|
}
|
|
rc = cyttsp5_hid_output_user_cmd_(cd, read_len, read_buf,
|
write_len, write_buf, actual_read_len);
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
dev_err(cd->dev, "%s: fail to release exclusive\n", __func__);
|
|
return rc;
|
}
|
|
static int _cyttsp5_request_hid_output_user_cmd(struct device *dev,
|
int protect, u16 read_len, u8 *read_buf, u16 write_len,
|
u8 *write_buf, u16 *actual_read_len)
|
{
|
struct cyttsp5_core_data *cd = dev_get_drvdata(dev);
|
|
if (protect)
|
return cyttsp5_hid_output_user_cmd(cd, read_len, read_buf,
|
write_len, write_buf, actual_read_len);
|
|
return cyttsp5_hid_output_user_cmd_(cd, read_len, read_buf,
|
write_len, write_buf, actual_read_len);
|
}
|
|
static int cyttsp5_hid_output_bl_get_information_(struct cyttsp5_core_data *cd,
|
u8 *return_data)
|
{
|
int rc;
|
int data_len;
|
struct cyttsp5_hid_output hid_output = {
|
HID_OUTPUT_BL_COMMAND(HID_OUTPUT_BL_GET_INFO),
|
};
|
|
rc = cyttsp5_hid_send_output_and_wait_(cd, &hid_output);
|
if (rc)
|
return rc;
|
|
data_len = get_unaligned_le16(&cd->input_buf[6]);
|
if (!data_len)
|
return -EPROTO;
|
|
memcpy(return_data, &cd->response_buf[8], data_len);
|
|
return 0;
|
}
|
|
static int cyttsp5_hid_output_bl_get_information(struct cyttsp5_core_data *cd,
|
u8 *return_data)
|
{
|
int rc;
|
|
rc = request_exclusive(cd, cd->dev, CY_REQUEST_EXCLUSIVE_TIMEOUT);
|
if (rc < 0) {
|
dev_err(cd->dev, "%s: fail get exclusive ex=%p own=%p\n",
|
__func__, cd->exclusive_dev, cd->dev);
|
return rc;
|
}
|
|
rc = cyttsp5_hid_output_bl_get_information_(cd, return_data);
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
dev_err(cd->dev, "%s: fail to release exclusive\n", __func__);
|
|
return rc;
|
}
|
|
static int _cyttsp5_request_hid_output_bl_get_information(struct device *dev,
|
int protect, u8 *return_data)
|
{
|
struct cyttsp5_core_data *cd = dev_get_drvdata(dev);
|
|
if (protect)
|
return cyttsp5_hid_output_bl_get_information(cd, return_data);
|
|
return cyttsp5_hid_output_bl_get_information_(cd, return_data);
|
}
|
|
static int cyttsp5_hid_output_bl_initiate_bl_(struct cyttsp5_core_data *cd,
|
u16 key_size, u8 *key_buf, u16 row_size, u8 *metadata_row_buf)
|
{
|
u16 write_length = key_size + row_size;
|
u8 *write_buf;
|
int rc;
|
struct cyttsp5_hid_output hid_output = {
|
HID_OUTPUT_BL_COMMAND(HID_OUTPUT_BL_INITIATE_BL),
|
.write_length = write_length,
|
.timeout_ms = CY_HID_OUTPUT_BL_INITIATE_BL_TIMEOUT,
|
};
|
|
write_buf = kzalloc(write_length, GFP_KERNEL);
|
if (!write_buf)
|
return -ENOMEM;
|
|
hid_output.write_buf = write_buf;
|
|
if (key_size)
|
memcpy(write_buf, key_buf, key_size);
|
|
if (row_size)
|
memcpy(&write_buf[key_size], metadata_row_buf, row_size);
|
|
rc = cyttsp5_hid_send_output_and_wait_(cd, &hid_output);
|
|
kfree(write_buf);
|
return rc;
|
}
|
|
static int cyttsp5_hid_output_bl_initiate_bl(struct cyttsp5_core_data *cd,
|
u16 key_size, u8 *key_buf, u16 row_size, u8 *metadata_row_buf)
|
{
|
int rc;
|
|
rc = request_exclusive(cd, cd->dev, CY_REQUEST_EXCLUSIVE_TIMEOUT);
|
if (rc < 0) {
|
dev_err(cd->dev, "%s: fail get exclusive ex=%p own=%p\n",
|
__func__, cd->exclusive_dev, cd->dev);
|
return rc;
|
}
|
|
rc = cyttsp5_hid_output_bl_initiate_bl_(cd, key_size, key_buf,
|
row_size, metadata_row_buf);
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
dev_err(cd->dev, "%s: fail to release exclusive\n", __func__);
|
|
return rc;
|
}
|
|
static int _cyttsp5_request_hid_output_bl_initiate_bl(struct device *dev,
|
int protect, u16 key_size, u8 *key_buf, u16 row_size,
|
u8 *metadata_row_buf)
|
{
|
struct cyttsp5_core_data *cd = dev_get_drvdata(dev);
|
|
if (protect)
|
return cyttsp5_hid_output_bl_initiate_bl(cd, key_size, key_buf,
|
row_size, metadata_row_buf);
|
|
return cyttsp5_hid_output_bl_initiate_bl_(cd, key_size, key_buf,
|
row_size, metadata_row_buf);
|
}
|
|
static int cyttsp5_hid_output_bl_program_and_verify_(
|
struct cyttsp5_core_data *cd, u16 data_len, u8 *data_buf)
|
{
|
struct cyttsp5_hid_output hid_output = {
|
HID_OUTPUT_BL_COMMAND(HID_OUTPUT_BL_PROGRAM_AND_VERIFY),
|
.write_length = data_len,
|
.write_buf = data_buf,
|
.timeout_ms = CY_HID_OUTPUT_BL_PROGRAM_AND_VERIFY_TIMEOUT,
|
};
|
|
return cyttsp5_hid_send_output_and_wait_(cd, &hid_output);
|
}
|
|
static int cyttsp5_hid_output_bl_program_and_verify(
|
struct cyttsp5_core_data *cd, u16 data_len, u8 *data_buf)
|
{
|
int rc;
|
|
rc = request_exclusive(cd, cd->dev, CY_REQUEST_EXCLUSIVE_TIMEOUT);
|
if (rc < 0) {
|
dev_err(cd->dev, "%s: fail get exclusive ex=%p own=%p\n",
|
__func__, cd->exclusive_dev, cd->dev);
|
return rc;
|
}
|
|
rc = cyttsp5_hid_output_bl_program_and_verify_(cd, data_len, data_buf);
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
dev_err(cd->dev, "%s: fail to release exclusive\n", __func__);
|
|
return rc;
|
}
|
|
static int _cyttsp5_request_hid_output_bl_program_and_verify(
|
struct device *dev, int protect, u16 data_len, u8 *data_buf)
|
{
|
struct cyttsp5_core_data *cd = dev_get_drvdata(dev);
|
|
if (protect)
|
return cyttsp5_hid_output_bl_program_and_verify(cd, data_len,
|
data_buf);
|
|
return cyttsp5_hid_output_bl_program_and_verify_(cd, data_len,
|
data_buf);
|
}
|
|
static int cyttsp5_hid_output_bl_verify_app_integrity_(
|
struct cyttsp5_core_data *cd, u8 *result)
|
{
|
int rc;
|
struct cyttsp5_hid_output hid_output = {
|
HID_OUTPUT_BL_COMMAND(HID_OUTPUT_BL_VERIFY_APP_INTEGRITY),
|
};
|
|
rc = cyttsp5_hid_send_output_and_wait_(cd, &hid_output);
|
if (rc) {
|
*result = 0;
|
return rc;
|
}
|
|
*result = cd->response_buf[8];
|
return 0;
|
}
|
|
static int cyttsp5_hid_output_bl_verify_app_integrity(
|
struct cyttsp5_core_data *cd, u8 *result)
|
{
|
int rc;
|
|
rc = request_exclusive(cd, cd->dev, CY_REQUEST_EXCLUSIVE_TIMEOUT);
|
if (rc < 0) {
|
dev_err(cd->dev, "%s: fail get exclusive ex=%p own=%p\n",
|
__func__, cd->exclusive_dev, cd->dev);
|
return rc;
|
}
|
|
rc = cyttsp5_hid_output_bl_verify_app_integrity_(cd, result);
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
dev_err(cd->dev, "%s: fail to release exclusive\n", __func__);
|
|
return rc;
|
}
|
|
static int _cyttsp5_request_hid_output_bl_verify_app_integrity(
|
struct device *dev, int protect, u8 *result)
|
{
|
struct cyttsp5_core_data *cd = dev_get_drvdata(dev);
|
|
if (protect)
|
return cyttsp5_hid_output_bl_verify_app_integrity(cd, result);
|
|
return cyttsp5_hid_output_bl_verify_app_integrity_(cd, result);
|
}
|
|
static int cyttsp5_hid_output_bl_launch_app_(struct cyttsp5_core_data *cd)
|
{
|
struct cyttsp5_hid_output hid_output = {
|
HID_OUTPUT_BL_COMMAND(HID_OUTPUT_BL_LAUNCH_APP),
|
.reset_expected = 1,
|
};
|
|
return cyttsp5_hid_send_output_and_wait_(cd, &hid_output);
|
}
|
|
static int cyttsp5_hid_output_bl_launch_app(struct cyttsp5_core_data *cd)
|
{
|
int rc;
|
|
rc = request_exclusive(cd, cd->dev, CY_REQUEST_EXCLUSIVE_TIMEOUT);
|
if (rc < 0) {
|
dev_err(cd->dev, "%s: fail get exclusive ex=%p own=%p\n",
|
__func__, cd->exclusive_dev, cd->dev);
|
return rc;
|
}
|
|
rc = cyttsp5_hid_output_bl_launch_app_(cd);
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
dev_err(cd->dev, "%s: fail to release exclusive\n", __func__);
|
|
return rc;
|
}
|
|
static int _cyttsp5_request_hid_output_launch_app(struct device *dev,
|
int protect)
|
{
|
struct cyttsp5_core_data *cd = dev_get_drvdata(dev);
|
|
if (protect)
|
return cyttsp5_hid_output_bl_launch_app(cd);
|
|
return cyttsp5_hid_output_bl_launch_app_(cd);
|
}
|
|
static int cyttsp5_hid_output_bl_get_panel_id_(
|
struct cyttsp5_core_data *cd, u8 *panel_id)
|
{
|
int rc;
|
struct cyttsp5_hid_output hid_output = {
|
HID_OUTPUT_BL_COMMAND(HID_OUTPUT_BL_GET_PANEL_ID),
|
};
|
|
rc = cyttsp5_hid_send_output_and_wait_(cd, &hid_output);
|
if (rc == -EPROTO && cd->response_buf[5] == ERROR_COMMAND) {
|
parade_debug(cd->dev, DEBUG_LEVEL_1,
|
"%s: Get Panel ID command not supported\n",
|
__func__);
|
*panel_id = PANEL_ID_NOT_ENABLED;
|
return 0;
|
} else if (rc < 0) {
|
dev_err(cd->dev, "%s: Error on Get Panel ID command\n",
|
__func__);
|
return rc;
|
}
|
|
*panel_id = cd->response_buf[8];
|
return 0;
|
}
|
|
static int cyttsp5_hid_output_bl_get_panel_id(
|
struct cyttsp5_core_data *cd, u8 *panel_id)
|
{
|
int rc;
|
|
rc = request_exclusive(cd, cd->dev, CY_REQUEST_EXCLUSIVE_TIMEOUT);
|
if (rc < 0) {
|
dev_err(cd->dev, "%s: fail get exclusive ex=%p own=%p\n",
|
__func__, cd->exclusive_dev, cd->dev);
|
return rc;
|
}
|
|
rc = cyttsp5_hid_output_bl_get_panel_id_(cd, panel_id);
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
dev_err(cd->dev, "%s: fail to release exclusive\n", __func__);
|
|
return rc;
|
}
|
|
static int _cyttsp5_request_hid_output_bl_get_panel_id(
|
struct device *dev, int protect, u8 *panel_id)
|
{
|
struct cyttsp5_core_data *cd = dev_get_drvdata(dev);
|
|
if (protect)
|
return cyttsp5_hid_output_bl_get_panel_id(cd, panel_id);
|
|
return cyttsp5_hid_output_bl_get_panel_id_(cd, panel_id);
|
}
|
|
static int cyttsp5_get_hid_descriptor_(struct cyttsp5_core_data *cd,
|
struct cyttsp5_hid_desc *desc)
|
{
|
struct device *dev = cd->dev;
|
int rc;
|
int t;
|
u8 cmd[2];
|
|
/* Read HID descriptor length and version */
|
mutex_lock(&cd->system_lock);
|
cd->hid_cmd_state = 1;
|
mutex_unlock(&cd->system_lock);
|
|
/* Set HID descriptor register */
|
memcpy(cmd, &cd->hid_core.hid_desc_register,
|
sizeof(cd->hid_core.hid_desc_register));
|
|
rc = cyttsp5_adap_write_read_specific(cd, 2, cmd, NULL);
|
if (rc) {
|
dev_err(dev, "%s: failed to get HID descriptor length and version, rc=%d\n",
|
__func__, rc);
|
goto error;
|
}
|
|
t = wait_event_timeout(cd->wait_q, (cd->hid_cmd_state == 0),
|
msecs_to_jiffies(CY_HID_GET_HID_DESCRIPTOR_TIMEOUT));
|
if (IS_TMO(t)) {
|
dev_err(cd->dev, "%s: HID get descriptor timed out\n",
|
__func__);
|
rc = -ETIME;
|
goto error;
|
}
|
|
memcpy((u8 *)desc, cd->response_buf, sizeof(struct cyttsp5_hid_desc));
|
|
/* Check HID descriptor length and version */
|
parade_debug(dev, DEBUG_LEVEL_2, "%s: HID len:%X HID ver:%X\n",
|
__func__,
|
le16_to_cpu(desc->hid_desc_len),
|
le16_to_cpu(desc->bcd_version));
|
|
if (le16_to_cpu(desc->hid_desc_len) != sizeof(*desc) ||
|
le16_to_cpu(desc->bcd_version) != CY_HID_VERSION) {
|
dev_err(dev, "%s: Unsupported HID version\n", __func__);
|
return -ENODEV;
|
}
|
|
goto exit;
|
|
error:
|
mutex_lock(&cd->system_lock);
|
cd->hid_cmd_state = 0;
|
mutex_unlock(&cd->system_lock);
|
exit:
|
return rc;
|
}
|
|
static int cyttsp5_get_hid_descriptor(struct cyttsp5_core_data *cd,
|
struct cyttsp5_hid_desc *desc)
|
{
|
int rc;
|
|
rc = request_exclusive(cd, cd->dev, CY_REQUEST_EXCLUSIVE_TIMEOUT);
|
if (rc < 0) {
|
dev_err(cd->dev, "%s: fail get exclusive ex=%p own=%p\n",
|
__func__, cd->exclusive_dev, cd->dev);
|
return rc;
|
}
|
|
rc = cyttsp5_get_hid_descriptor_(cd, desc);
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
dev_err(cd->dev, "%s: fail to release exclusive\n", __func__);
|
|
return rc;
|
}
|
|
static int _cyttsp5_request_get_hid_desc(struct device *dev, int protect)
|
{
|
struct cyttsp5_core_data *cd = dev_get_drvdata(dev);
|
|
if (protect)
|
return cyttsp5_get_hid_descriptor(cd, &cd->hid_desc);
|
|
return cyttsp5_get_hid_descriptor_(cd, &cd->hid_desc);
|
}
|
|
static int cyttsp5_hw_soft_reset(struct cyttsp5_core_data *cd)
|
{
|
int rc;
|
|
if (cd->hid_desc.hid_desc_len == 0) {
|
rc = cyttsp5_get_hid_descriptor_(cd, &cd->hid_desc);
|
if (rc < 0)
|
return rc;
|
}
|
|
rc = cyttsp5_hid_cmd_reset_(cd);
|
if (rc < 0) {
|
dev_err(cd->dev, "%s: FAILED to execute SOFT reset\n",
|
__func__);
|
return rc;
|
}
|
parade_debug(cd->dev, DEBUG_LEVEL_1, "%s: execute SOFT reset\n",
|
__func__);
|
return 0;
|
}
|
|
static int cyttsp5_hw_hard_reset(struct cyttsp5_core_data *cd)
|
{
|
if (cd->cpdata->xres) {
|
cd->cpdata->xres(cd->cpdata, cd->dev);
|
parade_debug(cd->dev, DEBUG_LEVEL_1, "%s: execute HARD reset\n",
|
__func__);
|
return 0;
|
}
|
dev_err(cd->dev, "%s: FAILED to execute HARD reset\n", __func__);
|
return -ENODEV;
|
}
|
|
static int cyttsp5_hw_reset(struct cyttsp5_core_data *cd)
|
{
|
int rc;
|
|
mutex_lock(&cd->system_lock);
|
rc = cyttsp5_hw_hard_reset(cd);
|
//printk("======cyttsp5_hw_reset rc=%d \n", rc);
|
mutex_unlock(&cd->system_lock);
|
if (rc == -ENODEV)
|
rc = cyttsp5_hw_soft_reset(cd);
|
return rc;
|
}
|
|
static inline int get_hid_item_data(u8 *data, int item_size)
|
{
|
if (item_size == 1)
|
return (int)*data;
|
else if (item_size == 2)
|
return (int)get_unaligned_le16(data);
|
else if (item_size == 4)
|
return (int)get_unaligned_le32(data);
|
return 0;
|
}
|
|
static int parse_report_descriptor(struct cyttsp5_core_data *cd,
|
u8 *report_desc, size_t len)
|
{
|
struct cyttsp5_hid_report *report;
|
struct cyttsp5_hid_field *field;
|
u8 *buf = report_desc;
|
u8 *end = buf + len;
|
int rc = 0;
|
int offset = 0;
|
int i;
|
u8 report_type;
|
u32 up_usage;
|
/* Global items */
|
u8 report_id = 0;
|
u16 usage_page = 0;
|
int report_count = 0;
|
int report_size = 0;
|
int logical_min = 0;
|
int logical_max = 0;
|
/* Local items */
|
u16 usage = 0;
|
/* Main items - Collection stack */
|
u32 collection_usages[CY_HID_MAX_NESTED_COLLECTIONS] = {0};
|
u8 collection_types[CY_HID_MAX_NESTED_COLLECTIONS] = {0};
|
/* First collection for header, second for report */
|
int logical_collection_count = 0;
|
int collection_nest = 0;
|
|
parade_debug(cd->dev, DEBUG_LEVEL_2, "%s: Report descriptor length: %u\n",
|
__func__, (u32)len);
|
|
mutex_lock(&cd->hid_report_lock);
|
cyttsp5_free_hid_reports_(cd);
|
|
while (buf < end) {
|
int item_type;
|
int item_size;
|
int item_tag;
|
u8 *data;
|
|
/* Get Item */
|
item_size = HID_GET_ITEM_SIZE(buf[0]);
|
if (item_size == 3)
|
item_size = 4;
|
item_type = HID_GET_ITEM_TYPE(buf[0]);
|
item_tag = HID_GET_ITEM_TAG(buf[0]);
|
|
data = ++buf;
|
buf += item_size;
|
|
/* Process current item */
|
switch (item_type) {
|
case HID_ITEM_TYPE_GLOBAL:
|
switch (item_tag) {
|
case HID_GLOBAL_ITEM_TAG_REPORT_ID:
|
if (item_size != 1) {
|
rc = -EINVAL;
|
goto exit;
|
}
|
report_id = get_hid_item_data(data, item_size);
|
offset = 0;
|
logical_collection_count = 0;
|
break;
|
case HID_GLOBAL_ITEM_TAG_USAGE_PAGE:
|
if (item_size == 0 || item_size == 4) {
|
rc = -EINVAL;
|
goto exit;
|
}
|
usage_page = (u16)get_hid_item_data(data,
|
item_size);
|
break;
|
case HID_GLOBAL_ITEM_TAG_LOGICAL_MINIMUM:
|
if (item_size == 0) {
|
rc = -EINVAL;
|
goto exit;
|
}
|
logical_min = get_hid_item_data(data,
|
item_size);
|
break;
|
case HID_GLOBAL_ITEM_TAG_LOGICAL_MAXIMUM:
|
if (item_size == 0) {
|
rc = -EINVAL;
|
goto exit;
|
}
|
logical_max = get_hid_item_data(data,
|
item_size);
|
break;
|
case HID_GLOBAL_ITEM_TAG_REPORT_COUNT:
|
if (item_size == 0) {
|
rc = -EINVAL;
|
goto exit;
|
}
|
report_count = get_hid_item_data(data,
|
item_size);
|
break;
|
case HID_GLOBAL_ITEM_TAG_REPORT_SIZE:
|
if (item_size == 0) {
|
rc = -EINVAL;
|
goto exit;
|
}
|
report_size = get_hid_item_data(data,
|
item_size);
|
break;
|
default:
|
dev_info(cd->dev,
|
"%s: Unrecognized Global tag %d\n",
|
__func__, item_tag);
|
}
|
break;
|
case HID_ITEM_TYPE_LOCAL:
|
switch (item_tag) {
|
case HID_LOCAL_ITEM_TAG_USAGE:
|
if (item_size == 0 || item_size == 4) {
|
rc = -EINVAL;
|
goto exit;
|
}
|
usage = (u16)get_hid_item_data(data,
|
item_size);
|
break;
|
case HID_LOCAL_ITEM_TAG_USAGE_MINIMUM:
|
if (item_size == 0) {
|
rc = -EINVAL;
|
goto exit;
|
}
|
/* usage_min = */
|
get_hid_item_data(data, item_size);
|
break;
|
case HID_LOCAL_ITEM_TAG_USAGE_MAXIMUM:
|
if (item_size == 0) {
|
rc = -EINVAL;
|
goto exit;
|
}
|
/* usage_max = */
|
get_hid_item_data(data, item_size);
|
break;
|
default:
|
dev_info(cd->dev,
|
"%s: Unrecognized Local tag %d\n",
|
__func__, item_tag);
|
}
|
break;
|
case HID_ITEM_TYPE_MAIN:
|
switch (item_tag) {
|
case HID_MAIN_ITEM_TAG_BEGIN_COLLECTION:
|
if (item_size != 1) {
|
rc = -EINVAL;
|
goto exit;
|
}
|
if (CY_HID_MAX_NESTED_COLLECTIONS ==
|
collection_nest) {
|
rc = -EINVAL;
|
goto exit;
|
}
|
|
up_usage = usage_page << 16 | usage;
|
|
/* Update collection stack */
|
collection_usages[collection_nest] = up_usage;
|
collection_types[collection_nest] =
|
get_hid_item_data(data, item_size);
|
|
if (collection_types[collection_nest] ==
|
HID_COLLECTION_LOGICAL)
|
logical_collection_count++;
|
|
collection_nest++;
|
break;
|
case HID_MAIN_ITEM_TAG_END_COLLECTION:
|
if (item_size != 0) {
|
rc = -EINVAL;
|
goto exit;
|
}
|
if (--collection_nest < 0) {
|
rc = -EINVAL;
|
goto exit;
|
}
|
break;
|
case HID_MAIN_ITEM_TAG_INPUT:
|
report_type = HID_INPUT_REPORT;
|
goto continue_main_item;
|
case HID_MAIN_ITEM_TAG_OUTPUT:
|
report_type = HID_OUTPUT_REPORT;
|
goto continue_main_item;
|
case HID_MAIN_ITEM_TAG_FEATURE:
|
report_type = HID_FEATURE_REPORT;
|
continue_main_item:
|
if (item_size != 1) {
|
rc = -EINVAL;
|
goto exit;
|
}
|
|
up_usage = usage_page << 16 | usage;
|
|
/* Get or create report */
|
report = cyttsp5_get_hid_report_(cd,
|
report_type, report_id, true);
|
if (!report) {
|
rc = -ENOMEM;
|
goto exit;
|
}
|
if (!report->usage_page && collection_nest > 0)
|
report->usage_page =
|
collection_usages
|
[collection_nest - 1];
|
|
/* Create field */
|
field = cyttsp5_create_hid_field_(report);
|
if (!field) {
|
rc = -ENOMEM;
|
goto exit;
|
}
|
|
field->report_count = report_count;
|
field->report_size = report_size;
|
field->size = report_count * report_size;
|
field->offset = offset;
|
field->data_type =
|
get_hid_item_data(data, item_size);
|
field->logical_min = logical_min;
|
field->logical_max = logical_max;
|
field->usage_page = up_usage;
|
|
for (i = 0; i < collection_nest; i++) {
|
field->collection_usage_pages
|
[collection_types[i]] =
|
collection_usages[i];
|
}
|
|
/* Update report's header or record size */
|
if (logical_collection_count == 1) {
|
report->header_size += field->size;
|
} else if (logical_collection_count == 2) {
|
field->record_field = true;
|
field->offset -= report->header_size;
|
/* Set record field index */
|
if (report->record_field_index == 0)
|
report->record_field_index =
|
report->num_fields - 1;
|
report->record_size += field->size;
|
}
|
|
report->size += field->size;
|
|
offset += field->size;
|
break;
|
default:
|
dev_info(cd->dev, "%s: Unrecognized Main tag %d\n",
|
__func__, item_tag);
|
}
|
|
/* Reset all local items */
|
usage = 0;
|
break;
|
}
|
}
|
|
if (buf != end) {
|
dev_err(cd->dev, "%s: Report descriptor length invalid\n",
|
__func__);
|
rc = -EINVAL;
|
goto exit;
|
}
|
|
if (collection_nest) {
|
dev_err(cd->dev, "%s: Unbalanced collection items (%d)\n",
|
__func__, collection_nest);
|
rc = -EINVAL;
|
goto exit;
|
}
|
|
exit:
|
if (rc)
|
cyttsp5_free_hid_reports_(cd);
|
mutex_unlock(&cd->hid_report_lock);
|
return rc;
|
}
|
|
static struct cyttsp5_hid_field *find_report_desc_field(
|
struct cyttsp5_core_data *cd, u32 usage_page,
|
u32 collection_usage_page)
|
{
|
struct cyttsp5_hid_report *report = NULL;
|
struct cyttsp5_hid_field *field = NULL;
|
int i;
|
int j;
|
u32 field_cup;
|
u32 field_up;
|
|
for (i = 0; i < cd->num_hid_reports; i++) {
|
report = cd->hid_reports[i];
|
for (j = 0; j < report->num_fields; j++) {
|
field = report->fields[j];
|
field_cup = field->collection_usage_pages
|
[HID_COLLECTION_LOGICAL];
|
field_up = field->usage_page;
|
if (field_cup == collection_usage_page
|
&& field_up == usage_page) {
|
return field;
|
}
|
}
|
}
|
|
return NULL;
|
}
|
|
static int fill_tch_abs(struct cyttsp5_tch_abs_params *tch_abs,
|
struct cyttsp5_hid_field *field)
|
{
|
tch_abs->ofs = field->offset / 8;
|
tch_abs->size = field->report_size / 8;
|
if (field->report_size % 8)
|
tch_abs->size += 1;
|
tch_abs->min = 0;
|
tch_abs->max = 1 << field->report_size;
|
tch_abs->bofs = field->offset - (tch_abs->ofs << 3);
|
|
return 0;
|
}
|
|
static struct cyttsp5_hid_report *find_report_desc(struct cyttsp5_core_data *cd,
|
u32 usage_page)
|
{
|
struct cyttsp5_hid_report *report = NULL;
|
int i;
|
|
for (i = 0; i < cd->num_hid_reports; i++) {
|
if (cd->hid_reports[i]->usage_page == usage_page) {
|
report = cd->hid_reports[i];
|
break;
|
}
|
}
|
|
return report;
|
}
|
|
static int setup_report_descriptor(struct cyttsp5_core_data *cd)
|
{
|
struct cyttsp5_sysinfo *si = &cd->sysinfo;
|
struct cyttsp5_hid_report *report;
|
struct cyttsp5_hid_field *field;
|
int i;
|
u32 tch_collection_usage_page = HID_CY_TCH_COL_USAGE_PG;
|
u32 btn_collection_usage_page = HID_CY_BTN_COL_USAGE_PG;
|
|
for (i = CY_TCH_X; i < CY_TCH_NUM_ABS; i++) {
|
field = find_report_desc_field(cd,
|
cyttsp5_tch_abs_field_map[i],
|
tch_collection_usage_page);
|
if (field) {
|
parade_debug(cd->dev, DEBUG_LEVEL_2,
|
" Field %p: rep_cnt:%d rep_sz:%d off:%d data:%02X min:%d max:%d usage_page:%08X\n",
|
field, field->report_count, field->report_size,
|
field->offset, field->data_type,
|
field->logical_min, field->logical_max,
|
field->usage_page);
|
fill_tch_abs(&si->tch_abs[i], field);
|
si->tch_abs[i].report = 1;
|
parade_debug(cd->dev, DEBUG_LEVEL_2, "%s: ofs:%u size:%u min:%u max:%u bofs:%u report:%d",
|
cyttsp5_tch_abs_string[i],
|
(u32)si->tch_abs[i].ofs,
|
(u32)si->tch_abs[i].size,
|
(u32)si->tch_abs[i].min,
|
(u32)si->tch_abs[i].max,
|
(u32)si->tch_abs[i].bofs,
|
si->tch_abs[i].report);
|
|
} else {
|
si->tch_abs[i].report = 0;
|
}
|
}
|
for (i = CY_TCH_TIME; i < CY_TCH_NUM_HDR; i++) {
|
field = find_report_desc_field(cd,
|
cyttsp5_tch_hdr_field_map[i],
|
tch_collection_usage_page);
|
if (field) {
|
parade_debug(cd->dev, DEBUG_LEVEL_2,
|
" Field %p: rep_cnt:%d rep_sz:%d off:%d data:%02X min:%d max:%d usage_page:%08X\n",
|
field, field->report_count, field->report_size,
|
field->offset, field->data_type,
|
field->logical_min, field->logical_max,
|
field->usage_page);
|
fill_tch_abs(&si->tch_hdr[i], field);
|
si->tch_hdr[i].report = 1;
|
parade_debug(cd->dev, DEBUG_LEVEL_2, "%s: ofs:%u size:%u min:%u max:%u bofs:%u report:%d",
|
cyttsp5_tch_hdr_string[i],
|
(u32)si->tch_hdr[i].ofs,
|
(u32)si->tch_hdr[i].size,
|
(u32)si->tch_hdr[i].min,
|
(u32)si->tch_hdr[i].max,
|
(u32)si->tch_hdr[i].bofs,
|
si->tch_hdr[i].report);
|
|
} else {
|
si->tch_hdr[i].report = 0;
|
}
|
}
|
|
report = find_report_desc(cd, tch_collection_usage_page);
|
if (report) {
|
si->desc.tch_report_id = report->id;
|
si->desc.tch_record_size = report->record_size / 8;
|
si->desc.tch_header_size = (report->header_size / 8) + 3;
|
} else {
|
si->desc.tch_report_id = HID_TOUCH_REPORT_ID;
|
si->desc.tch_record_size = TOUCH_REPORT_SIZE;
|
si->desc.tch_header_size = TOUCH_INPUT_HEADER_SIZE;
|
}
|
|
report = find_report_desc(cd, btn_collection_usage_page);
|
if (report)
|
si->desc.btn_report_id = report->id;
|
else
|
si->desc.btn_report_id = HID_BTN_REPORT_ID;
|
|
for (i = 0; i < cd->num_hid_reports; i++) {
|
struct cyttsp5_hid_report *report = cd->hid_reports[i];
|
|
switch (report->id) {
|
case HID_WAKEUP_REPORT_ID:
|
cd->features.easywake = 1;
|
break;
|
case HID_NOISE_METRIC_REPORT_ID:
|
cd->features.noise_metric = 1;
|
break;
|
case HID_TRACKING_HEATMAP_REPOR_ID:
|
cd->features.tracking_heatmap = 1;
|
break;
|
case HID_SENSOR_DATA_REPORT_ID:
|
cd->features.sensor_data = 1;
|
break;
|
default:
|
break;
|
}
|
}
|
|
parade_debug(cd->dev, DEBUG_LEVEL_1, "Features: easywake:%d noise_metric:%d tracking_heatmap:%d sensor_data:%d\n",
|
cd->features.easywake, cd->features.noise_metric,
|
cd->features.tracking_heatmap,
|
cd->features.sensor_data);
|
|
return 0;
|
}
|
|
static int cyttsp5_get_report_descriptor_(struct cyttsp5_core_data *cd)
|
{
|
struct device *dev = cd->dev;
|
u8 cmd[2];
|
int rc;
|
int t;
|
|
/* Read report descriptor length and version */
|
mutex_lock(&cd->system_lock);
|
cd->hid_cmd_state = 1;
|
mutex_unlock(&cd->system_lock);
|
|
/* Set report descriptor register */
|
memcpy(cmd, &cd->hid_desc.report_desc_register,
|
sizeof(cd->hid_desc.report_desc_register));
|
|
rc = cyttsp5_adap_write_read_specific(cd, 2, cmd, NULL);
|
if (rc) {
|
dev_err(dev, "%s: failed to get HID descriptor length and version, rc=%d\n",
|
__func__, rc);
|
goto error;
|
}
|
|
t = wait_event_timeout(cd->wait_q, (cd->hid_cmd_state == 0),
|
msecs_to_jiffies(CY_HID_GET_REPORT_DESCRIPTOR_TIMEOUT));
|
if (IS_TMO(t)) {
|
dev_err(cd->dev, "%s: HID get descriptor timed out\n",
|
__func__);
|
rc = -ETIME;
|
goto error;
|
}
|
|
cyttsp5_pr_buf(cd->dev, cd->response_buf,
|
cd->hid_core.hid_report_desc_len, "Report Desc");
|
|
rc = parse_report_descriptor(cd, cd->response_buf + 3,
|
get_unaligned_le16(&cd->response_buf[0]) - 3);
|
if (rc) {
|
dev_err(cd->dev, "%s: Error parsing report descriptor r=%d\n",
|
__func__, rc);
|
}
|
|
parade_debug(cd->dev, DEBUG_LEVEL_1, "%s: %d reports found in descriptor\n",
|
__func__, cd->num_hid_reports);
|
|
for (t = 0; t < cd->num_hid_reports; t++) {
|
struct cyttsp5_hid_report *report = cd->hid_reports[t];
|
int j;
|
|
parade_debug(cd->dev, DEBUG_LEVEL_2,
|
"Report %d: type:%d id:%02X size:%d fields:%d rec_fld_index:%d hdr_sz:%d rec_sz:%d usage_page:%08X\n",
|
t, report->type, report->id,
|
report->size, report->num_fields,
|
report->record_field_index, report->header_size,
|
report->record_size, report->usage_page);
|
|
for (j = 0; j < report->num_fields; j++) {
|
struct cyttsp5_hid_field *field = report->fields[j];
|
|
parade_debug(cd->dev, DEBUG_LEVEL_2,
|
" Field %d: rep_cnt:%d rep_sz:%d off:%d data:%02X min:%d max:%d usage_page:%08X\n",
|
j, field->report_count, field->report_size,
|
field->offset, field->data_type,
|
field->logical_min, field->logical_max,
|
field->usage_page);
|
|
parade_debug(cd->dev, DEBUG_LEVEL_2, " Collections Phys:%08X App:%08X Log:%08X\n",
|
field->collection_usage_pages
|
[HID_COLLECTION_PHYSICAL],
|
field->collection_usage_pages
|
[HID_COLLECTION_APPLICATION],
|
field->collection_usage_pages
|
[HID_COLLECTION_LOGICAL]);
|
}
|
}
|
|
rc = setup_report_descriptor(cd);
|
|
/* Free it for now */
|
cyttsp5_free_hid_reports_(cd);
|
|
parade_debug(cd->dev, DEBUG_LEVEL_1, "%s: %d reports found in descriptor\n",
|
__func__, cd->num_hid_reports);
|
|
goto exit;
|
|
error:
|
mutex_lock(&cd->system_lock);
|
cd->hid_cmd_state = 0;
|
mutex_unlock(&cd->system_lock);
|
exit:
|
return rc;
|
}
|
|
static int cyttsp5_get_mode(struct cyttsp5_core_data *cd,
|
struct cyttsp5_hid_desc *desc)
|
{
|
if (desc->packet_id == CY_HID_APP_REPORT_ID)
|
return CY_MODE_OPERATIONAL;
|
else if (desc->packet_id == CY_HID_BL_REPORT_ID)
|
return CY_MODE_BOOTLOADER;
|
|
return CY_MODE_UNKNOWN;
|
}
|
|
static int _cyttsp5_request_get_mode(struct device *dev, int protect, u8 *mode)
|
{
|
struct cyttsp5_core_data *cd = dev_get_drvdata(dev);
|
int rc;
|
|
if (protect)
|
rc = cyttsp5_get_hid_descriptor(cd, &cd->hid_desc);
|
else
|
rc = cyttsp5_get_hid_descriptor_(cd, &cd->hid_desc);
|
|
if (rc)
|
*mode = CY_MODE_UNKNOWN;
|
else
|
*mode = cyttsp5_get_mode(cd, &cd->hid_desc);
|
|
return rc;
|
}
|
|
static void cyttsp5_queue_startup_(struct cyttsp5_core_data *cd)
|
{
|
if (cd->startup_state == STARTUP_NONE) {
|
cd->startup_state = STARTUP_QUEUED;
|
schedule_work(&cd->startup_work);
|
dev_info(cd->dev, "%s: cyttsp5_startup queued\n", __func__);
|
} else {
|
parade_debug(cd->dev, DEBUG_LEVEL_1, "%s: startup_state = %d\n",
|
__func__, cd->startup_state);
|
}
|
}
|
|
static void cyttsp5_queue_startup(struct cyttsp5_core_data *cd)
|
{
|
mutex_lock(&cd->system_lock);
|
cyttsp5_queue_startup_(cd);
|
mutex_unlock(&cd->system_lock);
|
}
|
|
static void call_atten_cb(struct cyttsp5_core_data *cd,
|
enum cyttsp5_atten_type type, int mode)
|
{
|
struct atten_node *atten, *atten_n;
|
|
parade_debug(cd->dev, DEBUG_LEVEL_2, "%s: check list type=%d mode=%d\n",
|
__func__, type, mode);
|
spin_lock(&cd->spinlock);
|
list_for_each_entry_safe(atten, atten_n,
|
&cd->atten_list[type], node) {
|
if (!mode || atten->mode & mode) {
|
spin_unlock(&cd->spinlock);
|
parade_debug(cd->dev, DEBUG_LEVEL_2, "%s: attention for '%s'",
|
__func__, dev_name(atten->dev));
|
atten->func(atten->dev);
|
spin_lock(&cd->spinlock);
|
}
|
}
|
spin_unlock(&cd->spinlock);
|
}
|
|
#ifdef CYTTSP_WATCHDOG_DELAY_ENBALE
|
static void cyttsp5_start_wd_timer(struct cyttsp5_core_data *cd)
|
{
|
if (!cd->watchdog_interval){
|
//printk("++++++cyttsp5_start_wd_timer %d\n",cd->watchdog_interval);
|
return;
|
}
|
|
mod_timer(&cd->watchdog_timer, jiffies +
|
msecs_to_jiffies(cd->watchdog_interval));
|
}
|
|
static void cyttsp5_stop_wd_timer(struct cyttsp5_core_data *cd)
|
{
|
if (!cd->watchdog_interval)
|
{
|
//printk("++++++cyttsp5_stop_wd_timer %d\n",cd->watchdog_interval);
|
return;
|
}
|
|
/*
|
* Ensure we wait until the watchdog timer
|
* running on a different CPU finishes
|
*/
|
del_timer_sync(&cd->watchdog_timer);
|
cancel_work_sync(&cd->watchdog_work);
|
del_timer_sync(&cd->watchdog_timer);
|
}
|
|
static int start_fw_upgrade(void *data)
|
{
|
struct cyttsp5_core_data *cd = (struct cyttsp5_core_data *)data;
|
|
call_atten_cb(cd, CY_ATTEN_LOADER, 0);
|
return 0;
|
}
|
|
static void cyttsp5_watchdog_work(struct work_struct *work)
|
{
|
struct cyttsp5_core_data *cd =
|
container_of(work, struct cyttsp5_core_data,
|
watchdog_work);
|
int rc;
|
/*fix CDT207254
|
*if found the current sleep_state is SS_SLEEPING
|
*then no need to request_exclusive, directly return
|
*/
|
if (cd->sleep_state == SS_SLEEPING)
|
return;
|
|
rc = request_exclusive(cd, cd->dev, CY_REQUEST_EXCLUSIVE_TIMEOUT);
|
if (rc < 0) {
|
dev_err(cd->dev, "%s: fail get exclusive ex=%p own=%p\n",
|
__func__, cd->exclusive_dev, cd->dev);
|
goto queue_startup;
|
}
|
|
rc = cyttsp5_hid_output_null_(cd);
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
dev_err(cd->dev, "%s: fail to release exclusive\n", __func__);
|
|
queue_startup:
|
if (rc) {
|
dev_err(cd->dev,
|
"%s: failed to access device in watchdog timer r=%d\n",
|
__func__, rc);
|
|
/* Already tried FW upgrade because of watchdog but failed */
|
if (cd->startup_retry_count > CY_WATCHDOG_RETRY_COUNT)
|
return;
|
|
if (cd->startup_retry_count++ < CY_WATCHDOG_RETRY_COUNT)
|
cyttsp5_queue_startup(cd);
|
else
|
kthread_run(start_fw_upgrade, cd, "cyttp5_loader");
|
|
return;
|
}
|
|
cyttsp5_start_wd_timer(cd);
|
}
|
|
static void cyttsp5_watchdog_timer(struct timer_list *t)//(unsigned long handle)
|
{
|
struct cyttsp5_core_data *cd = from_timer(cd, t, watchdog_timer);
|
|
if (!cd)
|
return;
|
|
parade_debug(cd->dev, DEBUG_LEVEL_2, "%s: Watchdog timer triggered\n",
|
__func__);
|
|
if (!work_pending(&cd->watchdog_work))
|
schedule_work(&cd->watchdog_work);
|
}
|
#endif
|
static int cyttsp5_put_device_into_easy_wakeup_(struct cyttsp5_core_data *cd)
|
{
|
int rc;
|
u8 status = 0;
|
|
mutex_lock(&cd->system_lock);
|
cd->wait_until_wake = 0;
|
mutex_unlock(&cd->system_lock);
|
|
rc = cyttsp5_hid_output_enter_easywake_state_(cd,
|
cd->easy_wakeup_gesture, &status);
|
if (rc || status == 0)
|
return -EBUSY;
|
|
return rc;
|
}
|
|
static int cyttsp5_put_device_into_deep_sleep_(struct cyttsp5_core_data *cd)
|
{
|
int rc;
|
|
rc = cyttsp5_hid_cmd_set_power_(cd, HID_POWER_SLEEP);
|
if (rc)
|
rc = -EBUSY;
|
return rc;
|
}
|
|
static int cyttsp5_put_device_into_sleep_(struct cyttsp5_core_data *cd)
|
{
|
int rc;
|
|
//dev_err(cd->dev, "%s: \n",
|
// __func__);
|
if (IS_DEEP_SLEEP_CONFIGURED(cd->easy_wakeup_gesture))
|
rc = cyttsp5_put_device_into_deep_sleep_(cd);
|
else
|
rc = cyttsp5_put_device_into_easy_wakeup_(cd);
|
|
return rc;
|
}
|
|
static int cyttsp5_core_poweroff_device_(struct cyttsp5_core_data *cd)
|
{
|
int rc;
|
|
//dev_err(cd->dev, "%s: irq_enabled=0x%x\n",
|
// __func__, cd->irq_enabled);
|
if (cd->irq_enabled) {
|
cd->irq_enabled = false;
|
disable_irq_nosync(cd->irq);
|
}
|
|
rc = cd->cpdata->power(cd->cpdata, 0, cd->dev, 0);
|
if (rc < 0)
|
dev_err(cd->dev, "%s: HW Power down fails r=%d\n",
|
__func__, rc);
|
return rc;
|
}
|
|
static int cyttsp5_core_sleep_(struct cyttsp5_core_data *cd)
|
{
|
int rc;
|
|
mutex_lock(&cd->system_lock);
|
if (cd->sleep_state == SS_SLEEP_OFF) {
|
cd->sleep_state = SS_SLEEPING;
|
} else {
|
mutex_unlock(&cd->system_lock);
|
return 1;
|
}
|
mutex_unlock(&cd->system_lock);
|
|
#ifdef CYTTSP_WATCHDOG_DELAY_ENBALE
|
/* Ensure watchdog and startup works stopped */
|
cyttsp5_stop_wd_timer(cd);
|
#endif
|
cancel_work_sync(&cd->startup_work);
|
#ifdef CYTTSP_WATCHDOG_DELAY_ENBALE
|
cyttsp5_stop_wd_timer(cd);
|
#endif
|
//dev_err(cd->dev, "%s: flags=0x%x\n",
|
// __func__, cd->cpdata->flags);
|
|
if (cd->cpdata->flags & CY_CORE_FLAG_POWEROFF_ON_SLEEP)
|
rc = cyttsp5_core_poweroff_device_(cd);
|
else
|
rc = cyttsp5_put_device_into_sleep_(cd);
|
|
mutex_lock(&cd->system_lock);
|
cd->sleep_state = SS_SLEEP_ON;
|
mutex_unlock(&cd->system_lock);
|
|
return rc;
|
}
|
|
static int cyttsp5_core_sleep(struct cyttsp5_core_data *cd)
|
{
|
int rc;
|
|
rc = request_exclusive(cd, cd->dev, CY_REQUEST_EXCLUSIVE_TIMEOUT);
|
if (rc < 0) {
|
dev_err(cd->dev, "%s: fail get exclusive ex=%p own=%p\n",
|
__func__, cd->exclusive_dev, cd->dev);
|
return rc;
|
}
|
|
rc = cyttsp5_core_sleep_(cd);
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
dev_err(cd->dev, "%s: fail to release exclusive\n", __func__);
|
else
|
parade_debug(cd->dev, DEBUG_LEVEL_2, "%s: pass release exclusive\n",
|
__func__);
|
|
return rc;
|
}
|
|
static int cyttsp5_wakeup_host(struct cyttsp5_core_data *cd)
|
{
|
#ifndef EASYWAKE_TSG6
|
/* TSG5 EasyWake */
|
int rc = 0;
|
int event_id;
|
int size = get_unaligned_le16(&cd->input_buf[0]);
|
|
/* Validate report */
|
if (size != 4 || cd->input_buf[2] != 4)
|
rc = -EINVAL;
|
|
cd->wake_initiated_by_device = 1;
|
event_id = cd->input_buf[3];
|
|
parade_debug(cd->dev, DEBUG_LEVEL_1, "%s: e=%d, rc=%d\n",
|
__func__, event_id, rc);
|
|
if (rc) {
|
cyttsp5_core_sleep_(cd);
|
goto exit;
|
}
|
|
/* attention WAKE */
|
call_atten_cb(cd, CY_ATTEN_WAKE, 0);
|
exit:
|
return rc;
|
#else
|
/* TSG6 FW1.3 EasyWake */
|
int rc = 0;
|
int i = 0;
|
int report_length;
|
|
/* Validate report */
|
if (cd->input_buf[2] != 4)
|
rc = -EINVAL;
|
|
cd->wake_initiated_by_device = 1;
|
|
parade_debug(cd->dev, DEBUG_LEVEL_1, "%s: rc=%d\n", __func__, rc);
|
|
if (rc) {
|
cyttsp5_core_sleep_(cd);
|
goto exit;
|
}
|
|
/* Get gesture id and gesture data length */
|
cd->gesture_id = cd->input_buf[3];
|
report_length = (cd->input_buf[1] << 8) | (cd->input_buf[0]);
|
cd->gesture_data_length = report_length - 4;
|
|
parade_debug(cd->dev, DEBUG_LEVEL_1, "%s: gesture_id = %d, gesture_data_length = %d\n",
|
__func__, cd->gesture_id, cd->gesture_data_length);
|
|
for (i = 0; i < cd->gesture_data_length; i++)
|
cd->gesture_data[i] = cd->input_buf[4 + i];
|
|
/* attention WAKE */
|
call_atten_cb(cd, CY_ATTEN_WAKE, 0);
|
exit:
|
return rc;
|
#endif
|
}
|
|
static void cyttsp5_get_touch_axis(struct cyttsp5_core_data *cd,
|
int *axis, int size, int max, u8 *data, int bofs)
|
{
|
int nbyte;
|
int next;
|
|
for (nbyte = 0, *axis = 0, next = 0; nbyte < size; nbyte++) {
|
*axis = *axis + ((data[next] >> bofs) << (nbyte * 8));
|
next++;
|
}
|
|
*axis &= max - 1;
|
}
|
|
static int move_tracking_hetmap_data(struct cyttsp5_core_data *cd,
|
struct cyttsp5_sysinfo *si)
|
{
|
#ifdef TTHE_TUNER_SUPPORT
|
int size = get_unaligned_le16(&cd->input_buf[0]);
|
|
if (size)
|
tthe_print(cd, cd->input_buf, size, "THM=");
|
#endif
|
memcpy(si->xy_mode, cd->input_buf, SENSOR_HEADER_SIZE);
|
return 0;
|
}
|
|
static int move_sensor_data(struct cyttsp5_core_data *cd,
|
struct cyttsp5_sysinfo *si)
|
{
|
#ifdef TTHE_TUNER_SUPPORT
|
int size = get_unaligned_le16(&cd->input_buf[0]);
|
|
if (size)
|
tthe_print(cd, cd->input_buf, size, "sensor_monitor=");
|
#endif
|
memcpy(si->xy_mode, cd->input_buf, SENSOR_HEADER_SIZE);
|
return 0;
|
}
|
|
static int move_button_data(struct cyttsp5_core_data *cd,
|
struct cyttsp5_sysinfo *si)
|
{
|
#ifdef TTHE_TUNER_SUPPORT
|
int size = get_unaligned_le16(&cd->input_buf[0]);
|
|
if (size)
|
tthe_print(cd, cd->input_buf, size, "OpModeData=");
|
#endif
|
memcpy(si->xy_mode, cd->input_buf, BTN_INPUT_HEADER_SIZE);
|
cyttsp5_pr_buf(cd->dev, (u8 *)si->xy_mode, BTN_INPUT_HEADER_SIZE,
|
"xy_mode");
|
|
memcpy(si->xy_data, &cd->input_buf[BTN_INPUT_HEADER_SIZE],
|
BTN_REPORT_SIZE);
|
cyttsp5_pr_buf(cd->dev, (u8 *)si->xy_data, BTN_REPORT_SIZE, "xy_data");
|
return 0;
|
}
|
|
static int move_touch_data(struct cyttsp5_core_data *cd,
|
struct cyttsp5_sysinfo *si)
|
{
|
int max_tch = si->sensing_conf_data.max_tch;
|
int num_cur_tch;
|
int length;
|
struct cyttsp5_tch_abs_params *tch = &si->tch_hdr[CY_TCH_NUM];
|
#ifdef TTHE_TUNER_SUPPORT
|
int size = get_unaligned_le16(&cd->input_buf[0]);
|
|
if (size)
|
tthe_print(cd, cd->input_buf, size, "OpModeData=");
|
#endif
|
|
memcpy(si->xy_mode, cd->input_buf, si->desc.tch_header_size);
|
cyttsp5_pr_buf(cd->dev, (u8 *)si->xy_mode, si->desc.tch_header_size,
|
"xy_mode");
|
|
cyttsp5_get_touch_axis(cd, &num_cur_tch, tch->size,
|
tch->max, si->xy_mode + 3 + tch->ofs, tch->bofs);
|
if (unlikely(num_cur_tch > max_tch))
|
num_cur_tch = max_tch;
|
|
length = num_cur_tch * si->desc.tch_record_size;
|
|
memcpy(si->xy_data, &cd->input_buf[si->desc.tch_header_size], length);
|
cyttsp5_pr_buf(cd->dev, (u8 *)si->xy_data, length, "xy_data");
|
return 0;
|
}
|
|
static int parse_touch_input(struct cyttsp5_core_data *cd, int size)
|
{
|
struct cyttsp5_sysinfo *si = &cd->sysinfo;
|
int report_id = cd->input_buf[2];
|
int rc = -EINVAL;
|
|
parade_debug(cd->dev, DEBUG_LEVEL_2, "%s: Received touch report\n",
|
__func__);
|
if (!si->ready) {
|
dev_err(cd->dev,
|
"%s: Need system information to parse touches\n",
|
__func__);
|
return 0;
|
}
|
|
if (!si->xy_mode || !si->xy_data)
|
return rc;
|
|
if (report_id == si->desc.tch_report_id)
|
rc = move_touch_data(cd, si);
|
else if (report_id == si->desc.btn_report_id)
|
rc = move_button_data(cd, si);
|
else if (report_id == HID_SENSOR_DATA_REPORT_ID)
|
rc = move_sensor_data(cd, si);
|
else if (report_id == HID_TRACKING_HEATMAP_REPOR_ID)
|
rc = move_tracking_hetmap_data(cd, si);
|
|
if (rc)
|
return rc;
|
|
/* attention IRQ */
|
call_atten_cb(cd, CY_ATTEN_IRQ, cd->mode);
|
|
return 0;
|
}
|
|
static int parse_command_input(struct cyttsp5_core_data *cd, int size)
|
{
|
parade_debug(cd->dev, DEBUG_LEVEL_2, "%s: Received cmd interrupt\n",
|
__func__);
|
|
memcpy(cd->response_buf, cd->input_buf, size);
|
|
mutex_lock(&cd->system_lock);
|
cd->hid_cmd_state = 0;
|
mutex_unlock(&cd->system_lock);
|
wake_up(&cd->wait_q);
|
|
return 0;
|
}
|
|
static int cyttsp5_parse_input(struct cyttsp5_core_data *cd)
|
{
|
int report_id;
|
int is_command = 0;
|
int size;
|
|
//printk("*******cyttsp5_parse_input \n");
|
size = get_unaligned_le16(&cd->input_buf[0]);
|
|
/* check reset */
|
if (size == 0) {
|
parade_debug(cd->dev, DEBUG_LEVEL_1, "%s: Reset complete\n",
|
__func__);
|
memcpy(cd->response_buf, cd->input_buf, 2);
|
mutex_lock(&cd->system_lock);
|
if (!cd->hid_reset_cmd_state && !cd->hid_cmd_state) {
|
mutex_unlock(&cd->system_lock);
|
parade_debug(cd->dev, DEBUG_LEVEL_1, "%s: Device Initiated Reset\n",
|
__func__);
|
return 0;
|
}
|
|
cd->hid_reset_cmd_state = 0;
|
if (cd->hid_cmd_state == HID_OUTPUT_START_BOOTLOADER + 1
|
|| cd->hid_cmd_state ==
|
HID_OUTPUT_BL_LAUNCH_APP + 1
|
|| cd->hid_cmd_state ==
|
HID_OUTPUT_USER_CMD + 1)
|
cd->hid_cmd_state = 0;
|
wake_up(&cd->wait_q);
|
mutex_unlock(&cd->system_lock);
|
return 0;
|
} else if (size == 2 || size >= CY_PIP_1P7_EMPTY_BUF)
|
/*
|
* Before PIP 1.7, empty buffer is 0x0002;
|
* From PIP 1.7, empty buffer is 0xFFXX
|
*/
|
return 0;
|
|
report_id = cd->input_buf[2];
|
parade_debug(cd->dev, DEBUG_LEVEL_2, "%s: report_id:%X\n",
|
__func__, report_id);
|
|
/* Check wake-up report */
|
if (report_id == HID_WAKEUP_REPORT_ID) {
|
cyttsp5_wakeup_host(cd);
|
return 0;
|
}
|
#ifdef CYTTSP_WATCHDOG_DELAY_ENBALE
|
/* update watchdog expire time */
|
mod_timer_pending(&cd->watchdog_timer, jiffies +
|
msecs_to_jiffies(cd->watchdog_interval));
|
#endif
|
if (report_id != cd->sysinfo.desc.tch_report_id
|
&& report_id != cd->sysinfo.desc.btn_report_id
|
&& report_id != HID_SENSOR_DATA_REPORT_ID
|
&& report_id != HID_TRACKING_HEATMAP_REPOR_ID)
|
is_command = 1;
|
|
if (unlikely(is_command)) {
|
parse_command_input(cd, size);
|
return 0;
|
}
|
parse_touch_input(cd, size);
|
return 0;
|
}
|
|
static int cyttsp5_read_input(struct cyttsp5_core_data *cd)
|
{
|
struct device *dev = cd->dev;
|
int rc;
|
int t;
|
|
//printk("**********cyttsp5_read_input \n");
|
/* added as workaround to CDT170960: easywake failure */
|
/* Interrupt for easywake, wait for bus controller to wake */
|
mutex_lock(&cd->system_lock);
|
if (!IS_DEEP_SLEEP_CONFIGURED(cd->easy_wakeup_gesture)) {
|
if (cd->sleep_state == SS_SLEEP_ON) {
|
mutex_unlock(&cd->system_lock);
|
if (!dev->power.is_suspended)
|
goto read;
|
t = wait_event_timeout(cd->wait_q,
|
(cd->wait_until_wake == 1),
|
msecs_to_jiffies(2000));
|
if (IS_TMO(t))
|
cyttsp5_queue_startup(cd);
|
goto read;
|
}
|
}
|
mutex_unlock(&cd->system_lock);
|
|
read:
|
rc = cyttsp5_adap_read_default_nosize(cd, cd->input_buf, CY_MAX_INPUT);
|
if (rc) {
|
dev_err(dev, "%s: Error getting report, r=%d\n",
|
__func__, rc);
|
return rc;
|
}
|
parade_debug(dev, DEBUG_LEVEL_2, "%s: Read input successfully\n",
|
__func__);
|
return rc;
|
}
|
|
static bool cyttsp5_check_irq_asserted(struct cyttsp5_core_data *cd)
|
{
|
#ifdef ENABLE_WORKAROUND_FOR_GLITCH_AFTER_BL_LAUNCH_APP
|
/*
|
* Workaround for FW defect, CDT165308
|
* bl_launch app creates a glitch in IRQ line
|
*/
|
if (cd->hid_cmd_state == HID_OUTPUT_BL_LAUNCH_APP + 1
|
&& cd->cpdata->irq_stat){
|
/*
|
* in X1S panel and GC1546 panel, the width for the INT
|
* glitch is about 4us,the normal INT width of response
|
* will last more than 200us, so use 10us delay
|
* for distinguish the glitch the normal INT is enough.
|
*/
|
udelay(10);
|
if (cd->cpdata->irq_stat(cd->cpdata, cd->dev)
|
!= CY_IRQ_ASSERTED_VALUE)
|
return false;
|
}
|
#endif
|
return true;
|
}
|
|
|
static irqreturn_t cyttsp5_irq(int irq, void *handle)
|
{
|
struct cyttsp5_core_data *cd = handle;
|
int rc;
|
//printk("&&&&&&cyttsp5_irq \n");
|
if (!cyttsp5_check_irq_asserted(cd))
|
return IRQ_HANDLED;
|
|
pm_stay_awake(cd->dev);
|
|
rc = cyttsp5_read_input(cd);
|
if (!rc)
|
cyttsp5_parse_input(cd);
|
|
pm_relax(cd->dev);
|
|
return IRQ_HANDLED;
|
}
|
|
int _cyttsp5_subscribe_attention(struct device *dev,
|
enum cyttsp5_atten_type type, char *id, int (*func)(struct device *),
|
int mode)
|
{
|
struct cyttsp5_core_data *cd = dev_get_drvdata(dev);
|
struct atten_node *atten, *atten_new;
|
|
atten_new = kzalloc(sizeof(*atten_new), GFP_KERNEL);
|
if (!atten_new)
|
return -ENOMEM;
|
|
parade_debug(cd->dev, DEBUG_LEVEL_1, "%s from '%s'\n", __func__,
|
dev_name(cd->dev));
|
|
spin_lock(&cd->spinlock);
|
list_for_each_entry(atten, &cd->atten_list[type], node) {
|
if (atten->id == id && atten->mode == mode) {
|
spin_unlock(&cd->spinlock);
|
kfree(atten_new);
|
parade_debug(cd->dev, DEBUG_LEVEL_2, "%s: %s=%p %s=%d\n",
|
__func__,
|
"already subscribed attention",
|
dev, "mode", mode);
|
|
return 0;
|
}
|
}
|
|
atten_new->id = id;
|
atten_new->dev = dev;
|
atten_new->mode = mode;
|
atten_new->func = func;
|
|
list_add(&atten_new->node, &cd->atten_list[type]);
|
spin_unlock(&cd->spinlock);
|
|
return 0;
|
}
|
|
int _cyttsp5_unsubscribe_attention(struct device *dev,
|
enum cyttsp5_atten_type type, char *id, int (*func)(struct device *),
|
int mode)
|
{
|
struct cyttsp5_core_data *cd = dev_get_drvdata(dev);
|
struct atten_node *atten, *atten_n;
|
|
spin_lock(&cd->spinlock);
|
list_for_each_entry_safe(atten, atten_n, &cd->atten_list[type], node) {
|
if (atten->id == id && atten->mode == mode) {
|
list_del(&atten->node);
|
spin_unlock(&cd->spinlock);
|
parade_debug(cd->dev, DEBUG_LEVEL_2, "%s: %s=%p %s=%d\n",
|
__func__,
|
"unsub for atten->dev", atten->dev,
|
"atten->mode", atten->mode);
|
kfree(atten);
|
return 0;
|
}
|
}
|
spin_unlock(&cd->spinlock);
|
|
return -ENODEV;
|
}
|
|
static int _cyttsp5_request_exclusive(struct device *dev,
|
int timeout_ms)
|
{
|
struct cyttsp5_core_data *cd = dev_get_drvdata(dev);
|
|
return request_exclusive(cd, (void *)dev, timeout_ms);
|
}
|
|
static int _cyttsp5_release_exclusive(struct device *dev)
|
{
|
struct cyttsp5_core_data *cd = dev_get_drvdata(dev);
|
|
return release_exclusive(cd, (void *)dev);
|
}
|
|
static int cyttsp5_reset(struct cyttsp5_core_data *cd)
|
{
|
int rc;
|
|
/* reset hardware */
|
parade_debug(cd->dev, DEBUG_LEVEL_1, "%s: reset hw...\n", __func__);
|
rc = cyttsp5_hw_reset(cd);
|
if (rc < 0)
|
dev_err(cd->dev, "%s: %s dev='%s' r=%d\n", __func__,
|
"Fail hw reset", dev_name(cd->dev), rc);
|
return rc;
|
}
|
|
static int cyttsp5_reset_and_wait(struct cyttsp5_core_data *cd)
|
{
|
int rc;
|
int t;
|
|
mutex_lock(&cd->system_lock);
|
cd->hid_reset_cmd_state = 1;
|
mutex_unlock(&cd->system_lock);
|
|
rc = cyttsp5_reset(cd);
|
if (rc < 0)
|
goto error;
|
|
t = wait_event_timeout(cd->wait_q, (cd->hid_reset_cmd_state == 0),
|
msecs_to_jiffies(CY_HID_RESET_TIMEOUT));
|
if (IS_TMO(t)) {
|
dev_err(cd->dev, "%s: reset timed out\n",
|
__func__);
|
rc = -ETIME;
|
goto error;
|
}
|
|
goto exit;
|
|
error:
|
mutex_lock(&cd->system_lock);
|
cd->hid_reset_cmd_state = 0;
|
mutex_unlock(&cd->system_lock);
|
exit:
|
return rc;
|
}
|
|
/*
|
* returns err if refused or timeout(core uses fixed timeout period) occurs;
|
* blocks until ISR occurs
|
*/
|
static int _cyttsp5_request_reset(struct device *dev)
|
{
|
struct cyttsp5_core_data *cd = dev_get_drvdata(dev);
|
int rc;
|
|
mutex_lock(&cd->system_lock);
|
cd->hid_reset_cmd_state = 1;
|
mutex_unlock(&cd->system_lock);
|
|
rc = cyttsp5_reset(cd);
|
if (rc < 0) {
|
dev_err(cd->dev, "%s: Error on h/w reset r=%d\n",
|
__func__, rc);
|
mutex_lock(&cd->system_lock);
|
cd->hid_reset_cmd_state = 0;
|
mutex_unlock(&cd->system_lock);
|
}
|
|
return rc;
|
}
|
|
/*
|
* returns err if refused ; if no error then restart has completed
|
* and system is in normal operating mode
|
*/
|
static int _cyttsp5_request_restart(struct device *dev, bool wait)
|
{
|
struct cyttsp5_core_data *cd = dev_get_drvdata(dev);
|
|
cyttsp5_queue_startup(cd);
|
|
if (wait)
|
wait_event(cd->wait_q, cd->startup_state == STARTUP_NONE);
|
|
return 0;
|
}
|
|
/*
|
* returns NULL if sysinfo has not been acquired from the device yet
|
*/
|
struct cyttsp5_sysinfo *_cyttsp5_request_sysinfo(struct device *dev)
|
{
|
struct cyttsp5_core_data *cd = dev_get_drvdata(dev);
|
|
if (cd->sysinfo.ready)
|
return &cd->sysinfo;
|
|
return NULL;
|
}
|
|
static struct cyttsp5_loader_platform_data *_cyttsp5_request_loader_pdata(
|
struct device *dev)
|
{
|
struct cyttsp5_core_data *cd = dev_get_drvdata(dev);
|
|
return cd->pdata->loader_pdata;
|
}
|
|
#ifdef CYTTSP_WATCHDOG_DELAY_ENBALE
|
static int _cyttsp5_request_start_wd(struct device *dev)
|
{
|
struct cyttsp5_core_data *cd = dev_get_drvdata(dev);
|
|
cyttsp5_start_wd_timer(cd);
|
return 0;
|
}
|
|
static int _cyttsp5_request_stop_wd(struct device *dev)
|
{
|
struct cyttsp5_core_data *cd = dev_get_drvdata(dev);
|
|
cyttsp5_stop_wd_timer(cd);
|
return 0;
|
}
|
#endif
|
|
static int cyttsp5_core_wake_device_from_deep_sleep_(
|
struct cyttsp5_core_data *cd)
|
{
|
int rc;
|
|
rc = cyttsp5_hid_cmd_set_power_(cd, HID_POWER_ON);
|
if (rc)
|
rc = -EAGAIN;
|
|
/* Prevent failure on sequential wake/sleep requests from OS */
|
msleep(20);
|
|
return rc;
|
}
|
|
static int cyttsp5_core_wake_device_(struct cyttsp5_core_data *cd)
|
{
|
if (!IS_DEEP_SLEEP_CONFIGURED(cd->easy_wakeup_gesture)) {
|
mutex_lock(&cd->system_lock);
|
cd->wait_until_wake = 1;
|
mutex_unlock(&cd->system_lock);
|
wake_up(&cd->wait_q);
|
msleep(20);
|
|
if (cd->wake_initiated_by_device) {
|
cd->wake_initiated_by_device = 0;
|
return 0;
|
}
|
}
|
|
return cyttsp5_core_wake_device_from_deep_sleep_(cd);
|
}
|
|
static int cyttsp5_restore_parameters_(struct cyttsp5_core_data *cd)
|
{
|
struct param_node *param;
|
int rc = 0;
|
|
if (!(cd->cpdata->flags & CY_CORE_FLAG_RESTORE_PARAMETERS))
|
goto exit;
|
|
spin_lock(&cd->spinlock);
|
list_for_each_entry(param, &cd->param_list, node) {
|
spin_unlock(&cd->spinlock);
|
parade_debug(cd->dev, DEBUG_LEVEL_2, "%s: Parameter id:%d value:%d\n",
|
__func__, param->id, param->value);
|
rc = cyttsp5_hid_output_set_param_(cd, param->id,
|
param->value, param->size);
|
if (rc)
|
goto exit;
|
spin_lock(&cd->spinlock);
|
}
|
spin_unlock(&cd->spinlock);
|
exit:
|
return rc;
|
}
|
|
static int _fast_startup(struct cyttsp5_core_data *cd)
|
{
|
int retry = CY_CORE_STARTUP_RETRY_COUNT;
|
int rc;
|
|
reset:
|
if (retry != CY_CORE_STARTUP_RETRY_COUNT)
|
parade_debug(cd->dev, DEBUG_LEVEL_1, "%s: Retry %d\n",
|
__func__, CY_CORE_STARTUP_RETRY_COUNT - retry);
|
|
rc = cyttsp5_get_hid_descriptor_(cd, &cd->hid_desc);
|
if (rc < 0) {
|
dev_err(cd->dev, "%s: Error on getting HID descriptor r=%d\n",
|
__func__, rc);
|
if (retry--)
|
goto reset;
|
goto exit;
|
}
|
cd->mode = cyttsp5_get_mode(cd, &cd->hid_desc);
|
|
if (cd->mode == CY_MODE_BOOTLOADER) {
|
dev_info(cd->dev, "%s: Bootloader mode\n", __func__);
|
rc = cyttsp5_hid_output_bl_launch_app_(cd);
|
if (rc < 0) {
|
dev_err(cd->dev, "%s: Error on launch app r=%d\n",
|
__func__, rc);
|
if (retry--)
|
goto reset;
|
goto exit;
|
}
|
rc = cyttsp5_get_hid_descriptor_(cd, &cd->hid_desc);
|
if (rc < 0) {
|
dev_err(cd->dev,
|
"%s: Error on getting HID descriptor r=%d\n",
|
__func__, rc);
|
if (retry--)
|
goto reset;
|
goto exit;
|
}
|
cd->mode = cyttsp5_get_mode(cd, &cd->hid_desc);
|
if (cd->mode == CY_MODE_BOOTLOADER) {
|
if (retry--)
|
goto reset;
|
goto exit;
|
}
|
}
|
|
rc = cyttsp5_restore_parameters_(cd);
|
if (rc)
|
dev_err(cd->dev, "%s: failed to restore parameters rc=%d\n",
|
__func__, rc);
|
|
exit:
|
return rc;
|
}
|
|
static int cyttsp5_core_poweron_device_(struct cyttsp5_core_data *cd)
|
{
|
struct device *dev = cd->dev;
|
int rc;
|
|
rc = cd->cpdata->power(cd->cpdata, 1, dev, 0);
|
if (rc < 0) {
|
dev_err(dev, "%s: HW Power up fails r=%d\n", __func__, rc);
|
goto exit;
|
}
|
|
if (!cd->irq_enabled) {
|
cd->irq_enabled = true;
|
enable_irq(cd->irq);
|
}
|
|
rc = _fast_startup(cd);
|
exit:
|
return rc;
|
}
|
|
static int cyttsp5_core_wake_(struct cyttsp5_core_data *cd)
|
{
|
int rc;
|
|
mutex_lock(&cd->system_lock);
|
if (cd->sleep_state == SS_SLEEP_ON) {
|
cd->sleep_state = SS_WAKING;
|
} else {
|
mutex_unlock(&cd->system_lock);
|
return 1;
|
}
|
mutex_unlock(&cd->system_lock);
|
|
if (cd->cpdata->flags & CY_CORE_FLAG_POWEROFF_ON_SLEEP)
|
rc = cyttsp5_core_poweron_device_(cd);
|
else
|
rc = cyttsp5_core_wake_device_(cd);
|
|
mutex_lock(&cd->system_lock);
|
cd->sleep_state = SS_SLEEP_OFF;
|
mutex_unlock(&cd->system_lock);
|
|
#ifdef CYTTSP_WATCHDOG_DELAY_ENBALE
|
cyttsp5_start_wd_timer(cd);
|
#endif
|
return rc;
|
}
|
|
static int cyttsp5_core_wake(struct cyttsp5_core_data *cd)
|
{
|
int rc;
|
|
rc = request_exclusive(cd, cd->dev, CY_REQUEST_EXCLUSIVE_TIMEOUT);
|
if (rc < 0) {
|
dev_err(cd->dev, "%s: fail get exclusive ex=%p own=%p\n",
|
__func__, cd->exclusive_dev, cd->dev);
|
return rc;
|
}
|
|
rc = cyttsp5_core_wake_(cd);
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
dev_err(cd->dev, "%s: fail to release exclusive\n", __func__);
|
else
|
parade_debug(cd->dev, DEBUG_LEVEL_2, "%s: pass release exclusive\n",
|
__func__);
|
|
return rc;
|
}
|
|
static int cyttsp5_get_ic_crc_(struct cyttsp5_core_data *cd, u8 ebid)
|
{
|
struct cyttsp5_sysinfo *si = &cd->sysinfo;
|
int rc;
|
u8 status;
|
u16 calculated_crc = 0;
|
u16 stored_crc = 0;
|
|
rc = cyttsp5_hid_output_suspend_scanning_(cd);
|
if (rc)
|
goto error;
|
|
rc = cyttsp5_hid_output_verify_config_block_crc_(cd, ebid, &status,
|
&calculated_crc, &stored_crc);
|
if (rc)
|
goto exit;
|
|
if (status) {
|
rc = -EINVAL;
|
goto exit;
|
}
|
|
si->ttconfig.crc = stored_crc;
|
|
exit:
|
cyttsp5_hid_output_resume_scanning_(cd);
|
error:
|
parade_debug(cd->dev, DEBUG_LEVEL_1, "%s: CRC: ebid:%d, crc:0x%04X\n",
|
__func__, ebid, si->ttconfig.crc);
|
return rc;
|
}
|
|
static int cyttsp5_check_and_deassert_int(struct cyttsp5_core_data *cd)
|
{
|
u16 size;
|
u8 buf[2];
|
u8 *p;
|
u8 retry = 3;
|
int rc;
|
|
do {
|
rc = cyttsp5_adap_read_default(cd, buf, 2);
|
if (rc < 0)
|
return rc;
|
size = get_unaligned_le16(&buf[0]);
|
|
if (size == 2 || size == 0 || size >= CY_PIP_1P7_EMPTY_BUF)
|
return 0;
|
|
p = kzalloc(size, GFP_KERNEL);
|
if (!p)
|
return -ENOMEM;
|
|
rc = cyttsp5_adap_read_default(cd, p, size);
|
kfree(p);
|
if (rc < 0)
|
return rc;
|
} while (retry--);
|
|
return -EINVAL;
|
}
|
|
static int cyttsp5_startup_(struct cyttsp5_core_data *cd, bool reset)
|
{
|
int retry = CY_CORE_STARTUP_RETRY_COUNT;
|
int rc;
|
bool detected = false;
|
|
#ifdef TTHE_TUNER_SUPPORT
|
tthe_print(cd, NULL, 0, "enter startup");
|
#endif
|
|
#ifdef CYTTSP_WATCHDOG_DELAY_ENBALE
|
cyttsp5_stop_wd_timer(cd);
|
#endif
|
//printk("++++++++++cyttsp5_startup_ start reset=%d\n", reset);
|
|
reset:
|
if (retry != CY_CORE_STARTUP_RETRY_COUNT)
|
parade_debug(cd->dev, DEBUG_LEVEL_1, "%s: Retry %d\n",
|
__func__, CY_CORE_STARTUP_RETRY_COUNT - retry);
|
|
rc = cyttsp5_check_and_deassert_int(cd);
|
|
if (reset || retry != CY_CORE_STARTUP_RETRY_COUNT) {
|
/* reset hardware */
|
//printk("++++++++++cyttsp5_startup_ cyttsp5_reset_and_wait\n");
|
rc = cyttsp5_reset_and_wait(cd);
|
if (rc < 0) {
|
dev_err(cd->dev, "%s: Error on h/w reset r=%d\n",
|
__func__, rc);
|
if (retry--)
|
goto reset;
|
//printk("++++++++++cyttsp5_startup_ goto exit\n");
|
goto exit;
|
}
|
}
|
|
//printk("++++++++++cyttsp5_startup_ next\n");
|
rc = cyttsp5_get_hid_descriptor_(cd, &cd->hid_desc);
|
if (rc < 0) {
|
dev_err(cd->dev, "%s: Error on getting HID descriptor r=%d\n",
|
__func__, rc);
|
if (retry--)
|
goto reset;
|
goto exit;
|
}
|
cd->mode = cyttsp5_get_mode(cd, &cd->hid_desc);
|
|
detected = true;
|
|
/* Switch to bootloader mode to get Panel ID */
|
if (cd->mode == CY_MODE_OPERATIONAL) {
|
rc = cyttsp5_hid_output_start_bootloader_(cd);
|
if (rc < 0) {
|
dev_err(cd->dev, "%s: Error on start bootloader r=%d\n",
|
__func__, rc);
|
if (retry--)
|
goto reset;
|
goto exit;
|
}
|
dev_info(cd->dev, "%s: Bootloader mode\n", __func__);
|
}
|
|
cyttsp5_hid_output_bl_get_panel_id_(cd, &cd->panel_id);
|
|
parade_debug(cd->dev, DEBUG_LEVEL_1, "%s: Panel ID: 0x%02X\n",
|
__func__, cd->panel_id);
|
|
rc = cyttsp5_hid_output_bl_launch_app_(cd);
|
if (rc < 0) {
|
dev_err(cd->dev, "%s: Error on launch app r=%d\n",
|
__func__, rc);
|
if (retry--)
|
goto reset;
|
goto exit;
|
}
|
|
rc = cyttsp5_get_hid_descriptor_(cd, &cd->hid_desc);
|
if (rc < 0) {
|
dev_err(cd->dev,
|
"%s: Error on getting HID descriptor r=%d\n",
|
__func__, rc);
|
if (retry--)
|
goto reset;
|
goto exit;
|
}
|
cd->mode = cyttsp5_get_mode(cd, &cd->hid_desc);
|
if (cd->mode == CY_MODE_BOOTLOADER) {
|
if (retry--)
|
goto reset;
|
goto exit;
|
}
|
|
mutex_lock(&cd->system_lock);
|
/* Read descriptor lengths */
|
cd->hid_core.hid_report_desc_len =
|
le16_to_cpu(cd->hid_desc.report_desc_len);
|
cd->hid_core.hid_max_input_len =
|
le16_to_cpu(cd->hid_desc.max_input_len);
|
cd->hid_core.hid_max_output_len =
|
le16_to_cpu(cd->hid_desc.max_output_len);
|
|
cd->mode = cyttsp5_get_mode(cd, &cd->hid_desc);
|
if (cd->mode == CY_MODE_OPERATIONAL)
|
dev_info(cd->dev, "%s: Operational mode\n", __func__);
|
else if (cd->mode == CY_MODE_BOOTLOADER)
|
dev_info(cd->dev, "%s: Bootloader mode\n", __func__);
|
else if (cd->mode == CY_MODE_UNKNOWN) {
|
dev_err(cd->dev, "%s: Unknown mode\n", __func__);
|
rc = -ENODEV;
|
mutex_unlock(&cd->system_lock);
|
if (retry--)
|
goto reset;
|
goto exit;
|
}
|
mutex_unlock(&cd->system_lock);
|
|
dev_info(cd->dev, "%s: Reading report descriptor\n", __func__);
|
rc = cyttsp5_get_report_descriptor_(cd);
|
if (rc < 0) {
|
dev_err(cd->dev, "%s: Error on getting report descriptor r=%d\n",
|
__func__, rc);
|
if (retry--)
|
goto reset;
|
goto exit;
|
}
|
|
if (!cd->features.easywake)
|
cd->easy_wakeup_gesture = CY_CORE_EWG_NONE;
|
|
rc = cyttsp5_hid_output_get_sysinfo_(cd);
|
if (rc) {
|
dev_err(cd->dev, "%s: Error on getting sysinfo r=%d\n",
|
__func__, rc);
|
if (retry--)
|
goto reset;
|
goto exit;
|
}
|
|
dev_info(cd->dev, "cyttsp5 Protocol Version: %d.%d\n",
|
cd->sysinfo.cydata.pip_ver_major,
|
cd->sysinfo.cydata.pip_ver_minor);
|
|
/* Read config version directly if PIP version < 1.2 */
|
if (!IS_PIP_VER_GE(&cd->sysinfo, 1, 2)) {
|
rc = cyttsp5_get_config_ver_(cd);
|
if (rc)
|
dev_err(cd->dev, "%s: failed to read config version rc=%d\n",
|
__func__, rc);
|
}
|
|
rc = cyttsp5_get_ic_crc_(cd, CY_TCH_PARM_EBID);
|
if (rc)
|
dev_err(cd->dev, "%s: failed to crc data rc=%d\n",
|
__func__, rc);
|
|
rc = cyttsp5_restore_parameters_(cd);
|
if (rc)
|
dev_err(cd->dev, "%s: failed to restore parameters rc=%d\n",
|
__func__, rc);
|
|
/* attention startup */
|
call_atten_cb(cd, CY_ATTEN_STARTUP, 0);
|
|
exit:
|
if (!rc)
|
cd->startup_retry_count = 0;
|
|
#ifdef CYTTSP_WATCHDOG_DELAY_ENBALE
|
cyttsp5_start_wd_timer(cd);
|
#endif
|
if (!detected)
|
rc = -ENODEV;
|
|
#ifdef TTHE_TUNER_SUPPORT
|
tthe_print(cd, NULL, 0, "exit startup");
|
#endif
|
|
return rc;
|
}
|
|
static int cyttsp5_startup(struct cyttsp5_core_data *cd, bool reset)
|
{
|
int rc;
|
|
mutex_lock(&cd->system_lock);
|
cd->startup_state = STARTUP_RUNNING;
|
mutex_unlock(&cd->system_lock);
|
|
rc = request_exclusive(cd, cd->dev, CY_REQUEST_EXCLUSIVE_TIMEOUT);
|
if (rc < 0) {
|
dev_err(cd->dev, "%s: fail get exclusive ex=%p own=%p\n",
|
__func__, cd->exclusive_dev, cd->dev);
|
goto exit;
|
}
|
|
rc = cyttsp5_startup_(cd, reset);
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
/* Don't return fail code, mode is already changed. */
|
dev_err(cd->dev, "%s: fail to release exclusive\n", __func__);
|
else
|
parade_debug(cd->dev, DEBUG_LEVEL_2, "%s: pass release exclusive\n",
|
__func__);
|
|
exit:
|
mutex_lock(&cd->system_lock);
|
cd->startup_state = STARTUP_NONE;
|
mutex_unlock(&cd->system_lock);
|
|
/* Wake the waiters for end of startup */
|
wake_up(&cd->wait_q);
|
|
return rc;
|
}
|
|
static void cyttsp5_startup_work_function(struct work_struct *work)
|
{
|
struct cyttsp5_core_data *cd = container_of(work,
|
struct cyttsp5_core_data, startup_work);
|
int rc;
|
|
rc = cyttsp5_startup(cd, true);
|
if (rc < 0)
|
dev_err(cd->dev, "%s: Fail queued startup r=%d\n",
|
__func__, rc);
|
}
|
|
/*
|
* CONFIG_PM_RUNTIME option is removed in 3.19.0.
|
*/
|
#if defined(CONFIG_PM_RUNTIME) || \
|
(KERNEL_VERSION(3, 19, 0) <= LINUX_VERSION_CODE)
|
static int cyttsp5_core_rt_suspend(struct device *dev)
|
{
|
struct cyttsp5_core_data *cd = dev_get_drvdata(dev);
|
int rc;
|
//printk("cyttsp5_core_rt_suspend\n");
|
rc = cyttsp5_core_sleep(cd);
|
if (rc < 0) {
|
dev_err(dev, "%s: Error on sleep\n", __func__);
|
return -EAGAIN;
|
}
|
return 0;
|
}
|
|
static int cyttsp5_core_rt_resume(struct device *dev)
|
{
|
struct cyttsp5_core_data *cd = dev_get_drvdata(dev);
|
int rc;
|
|
//printk("cyttsp5_core_rt_resume\n");
|
rc = cyttsp5_core_wake(cd);
|
if (rc < 0) {
|
dev_err(dev, "%s: Error on wake\n", __func__);
|
return -EAGAIN;
|
}
|
|
return 0;
|
}
|
#endif
|
|
#if defined(CONFIG_PM_SLEEP)
|
static int cyttsp5_core_suspend(struct device *dev)
|
{
|
struct cyttsp5_core_data *cd = dev_get_drvdata(dev);
|
|
if (cd->is_suspend)
|
return 0;
|
cyttsp5_core_sleep(cd);
|
|
return 0;
|
}
|
|
static int cyttsp5_core_resume(struct device *dev)
|
{
|
struct cyttsp5_core_data *cd = dev_get_drvdata(dev);
|
|
if (cd->is_suspend)
|
return 0;
|
cyttsp5_core_wake(cd);
|
|
return 0;
|
}
|
|
static int cyttsp5_core_early_suspend(struct tp_device *tp_d)
|
{
|
struct cyttsp5_core_data *cd = container_of(tp_d, struct cyttsp5_core_data, tp);
|
|
cyttsp5_core_sleep(cd);
|
if (!cd->irq_disabled) {
|
disable_irq(cd->irq);
|
cd->irq_disabled = 1;
|
}
|
gpio_direction_output(cd->cpdata->rst_gpio, 0);
|
gpio_direction_output(cd->cpdata->irq_gpio, 0);
|
if (cd->supply)
|
regulator_disable(cd->supply);
|
cd->is_suspend = 1;
|
|
return 0;
|
}
|
|
static int cyttsp5_core_late_resume(struct tp_device *tp_d)
|
{
|
struct cyttsp5_core_data *cd = container_of(tp_d, struct cyttsp5_core_data, tp);
|
int ret;
|
|
if (cd->supply) {
|
ret = regulator_enable(cd->supply);
|
if (ret < 0)
|
dev_err(cd->dev, "failed to enable cyttsp5 power supply\n");
|
}
|
gpio_direction_input(cd->cpdata->irq_gpio);
|
cyttsp5_hw_hard_reset(cd);
|
if (cd->irq_disabled) {
|
enable_irq(cd->irq);
|
cd->irq_disabled = 0;
|
}
|
cyttsp5_core_wake(cd);
|
cd->is_suspend = 0;
|
|
return 0;
|
}
|
#endif
|
|
#if NEED_SUSPEND_NOTIFIER
|
static int cyttsp5_pm_notifier(struct notifier_block *nb,
|
unsigned long action, void *data)
|
{
|
struct cyttsp5_core_data *cd = container_of(nb,
|
struct cyttsp5_core_data, pm_notifier);
|
|
if (action == PM_SUSPEND_PREPARE) {
|
parade_debug(cd->dev, DEBUG_LEVEL_1, "%s: Suspend prepare\n",
|
__func__);
|
|
/*
|
* If not runtime PM suspended, either call runtime
|
* PM suspend callback or wait until it finishes
|
*/
|
if (!pm_runtime_suspended(cd->dev))
|
pm_runtime_suspend(cd->dev);
|
|
(void) cyttsp5_core_suspend(cd->dev);
|
}
|
|
return NOTIFY_DONE;
|
}
|
#endif
|
|
const struct dev_pm_ops cyttsp5_pm_ops = {
|
SET_LATE_SYSTEM_SLEEP_PM_OPS(cyttsp5_core_suspend, cyttsp5_core_resume)
|
SET_RUNTIME_PM_OPS(cyttsp5_core_rt_suspend, cyttsp5_core_rt_resume,
|
NULL)
|
};
|
EXPORT_SYMBOL_GPL(cyttsp5_pm_ops);
|
|
/*
|
* Show Firmware version via sysfs
|
*/
|
static ssize_t cyttsp5_ic_ver_show(struct device *dev,
|
struct device_attribute *attr, char *buf)
|
{
|
struct cyttsp5_core_data *cd = dev_get_drvdata(dev);
|
struct cyttsp5_cydata *cydata = &cd->sysinfo.cydata;
|
|
return sprintf(buf,
|
"%s: 0x%02X\n"
|
"%s: 0x%02X\n"
|
"%s: 0x%08X\n"
|
"%s: 0x%04X\n"
|
"%s: 0x%02X\n"
|
"%s: 0x%02X\n"
|
"%s: 0x%02X\n"
|
"%s: 0x%02X\n",
|
"Firmware Major Version", cydata->fw_ver_major,
|
"Firmware Minor Version", cydata->fw_ver_minor,
|
"Revision Control Number", cydata->revctrl,
|
"Firmware Configuration Version", cydata->fw_ver_conf,
|
"Bootloader Major Version", cydata->bl_ver_major,
|
"Bootloader Minor Version", cydata->bl_ver_minor,
|
"Protocol Major Version", cydata->pip_ver_major,
|
"Protocol Minor Version", cydata->pip_ver_minor);
|
}
|
|
/*
|
* Show Driver version via sysfs
|
*/
|
static ssize_t cyttsp5_drv_ver_show(struct device *dev,
|
struct device_attribute *attr, char *buf)
|
{
|
return snprintf(buf, CY_MAX_PRBUF_SIZE,
|
"Driver: %s\nVersion: %s\nDate: %s\n",
|
cy_driver_core_name, cy_driver_core_version,
|
cy_driver_core_date);
|
}
|
|
/*
|
* HW reset via sysfs
|
*/
|
static ssize_t cyttsp5_hw_reset_store(struct device *dev,
|
struct device_attribute *attr, const char *buf, size_t size)
|
{
|
struct cyttsp5_core_data *cd = dev_get_drvdata(dev);
|
int rc;
|
|
rc = cyttsp5_startup(cd, true);
|
if (rc < 0)
|
dev_err(dev, "%s: HW reset failed r=%d\n",
|
__func__, rc);
|
|
return size;
|
}
|
|
/*
|
* Show IRQ status via sysfs
|
*/
|
static ssize_t cyttsp5_hw_irq_stat_show(struct device *dev,
|
struct device_attribute *attr, char *buf)
|
{
|
struct cyttsp5_core_data *cd = dev_get_drvdata(dev);
|
int retval;
|
|
if (cd->cpdata->irq_stat) {
|
retval = cd->cpdata->irq_stat(cd->cpdata, dev);
|
switch (retval) {
|
case 0:
|
return snprintf(buf, CY_MAX_PRBUF_SIZE,
|
"Interrupt line is LOW.\n");
|
case 1:
|
return snprintf(buf, CY_MAX_PRBUF_SIZE,
|
"Interrupt line is HIGH.\n");
|
default:
|
return snprintf(buf, CY_MAX_PRBUF_SIZE,
|
"Function irq_stat() returned %d.\n", retval);
|
}
|
}
|
|
return snprintf(buf, CY_MAX_PRBUF_SIZE,
|
"Function irq_stat() undefined.\n");
|
}
|
|
/*
|
* Show IRQ enable/disable status via sysfs
|
*/
|
static ssize_t cyttsp5_drv_irq_show(struct device *dev,
|
struct device_attribute *attr, char *buf)
|
{
|
struct cyttsp5_core_data *cd = dev_get_drvdata(dev);
|
ssize_t ret;
|
|
mutex_lock(&cd->system_lock);
|
if (cd->irq_enabled)
|
ret = snprintf(buf, CY_MAX_PRBUF_SIZE,
|
"Driver interrupt is ENABLED\n");
|
else
|
ret = snprintf(buf, CY_MAX_PRBUF_SIZE,
|
"Driver interrupt is DISABLED\n");
|
mutex_unlock(&cd->system_lock);
|
|
return ret;
|
}
|
|
/*
|
* Enable/disable IRQ via sysfs
|
*/
|
static ssize_t cyttsp5_drv_irq_store(struct device *dev,
|
struct device_attribute *attr, const char *buf, size_t size)
|
{
|
struct cyttsp5_core_data *cd = dev_get_drvdata(dev);
|
unsigned long value;
|
int retval = 0;
|
|
retval = kstrtoul(buf, 10, &value);
|
if (retval < 0) {
|
dev_err(dev, "%s: Invalid value\n", __func__);
|
goto cyttsp5_drv_irq_store_error_exit;
|
}
|
|
mutex_lock(&cd->system_lock);
|
switch (value) {
|
case 0:
|
if (cd->irq_enabled) {
|
cd->irq_enabled = false;
|
/* Disable IRQ */
|
disable_irq_nosync(cd->irq);
|
dev_info(dev, "%s: Driver IRQ now disabled\n",
|
__func__);
|
} else
|
dev_info(dev, "%s: Driver IRQ already disabled\n",
|
__func__);
|
break;
|
|
case 1:
|
if (cd->irq_enabled == false) {
|
cd->irq_enabled = true;
|
/* Enable IRQ */
|
enable_irq(cd->irq);
|
dev_info(dev, "%s: Driver IRQ now enabled\n",
|
__func__);
|
} else
|
dev_info(dev, "%s: Driver IRQ already enabled\n",
|
__func__);
|
break;
|
|
default:
|
dev_err(dev, "%s: Invalid value\n", __func__);
|
}
|
mutex_unlock(&(cd->system_lock));
|
|
cyttsp5_drv_irq_store_error_exit:
|
|
return size;
|
}
|
|
/*
|
* Gets user input from sysfs and parse it
|
* return size of parsed output buffer
|
*/
|
|
#define CY_MAX_CONFIG_BYTES_DEC 256
|
#define CYTTSP5_INPUT_ELEM_SZ_DEC 10
|
|
static int cyttsp5_ic_parse_input_dec(struct device *dev, const char *buf,
|
size_t buf_size, u32 *ic_buf, size_t ic_buf_size)
|
{
|
const char *pbuf = buf;
|
unsigned long value;
|
char scan_buf[CYTTSP5_INPUT_ELEM_SZ_DEC];
|
u32 i = 0;
|
u32 j;
|
int last = 0;
|
int ret;
|
|
parade_debug(dev, DEBUG_LEVEL_1, "%s: pbuf=%p buf=%p size=%zu %s=%zu buf=%s\n",
|
__func__, pbuf, buf, buf_size, "scan buf size",
|
(size_t)CYTTSP5_INPUT_ELEM_SZ_DEC, buf);
|
|
while (pbuf <= (buf + buf_size)) {
|
if (i >= CY_MAX_CONFIG_BYTES_DEC) {
|
dev_err(dev, "%s: %s size=%d max=%d\n", __func__,
|
"Max cmd size exceeded", i,
|
CY_MAX_CONFIG_BYTES_DEC);
|
return -EINVAL;
|
}
|
if (i >= ic_buf_size) {
|
dev_err(dev, "%s: %s size=%d buf_size=%zu\n", __func__,
|
"Buffer size exceeded", i, ic_buf_size);
|
return -EINVAL;
|
}
|
while (((*pbuf == ' ') || (*pbuf == ','))
|
&& (pbuf < (buf + buf_size))) {
|
last = *pbuf;
|
pbuf++;
|
}
|
|
if (pbuf >= (buf + buf_size))
|
break;
|
|
memset(scan_buf, 0, CYTTSP5_INPUT_ELEM_SZ_DEC);
|
if ((last == ',') && (*pbuf == ',')) {
|
dev_err(dev, "%s: %s \",,\" not allowed.\n", __func__,
|
"Invalid data format.");
|
return -EINVAL;
|
}
|
for (j = 0; j < (CYTTSP5_INPUT_ELEM_SZ_DEC - 1)
|
&& (pbuf < (buf + buf_size))
|
&& (*pbuf != ' ')
|
&& (*pbuf != ','); j++) {
|
last = *pbuf;
|
scan_buf[j] = *pbuf++;
|
}
|
ret = kstrtoul(scan_buf, 10, &value);
|
if (ret < 0) {
|
dev_err(dev, "%s: Invalid data format.\n", __func__);
|
return ret;
|
}
|
|
ic_buf[i] = value;
|
i++;
|
}
|
|
return i;
|
}
|
|
/*
|
* Debugging options via sysfs
|
*/
|
static ssize_t cyttsp5_drv_debug_store(struct device *dev,
|
struct device_attribute *attr, const char *buf, size_t size)
|
{
|
struct cyttsp5_core_data *cd = dev_get_drvdata(dev);
|
unsigned long value;
|
int rc;
|
u8 return_data[8];
|
static u8 wd_disabled;
|
u32 input_data[2];
|
int length;
|
|
/*maximal input two data*/
|
length = cyttsp5_ic_parse_input_dec(dev, buf, size, input_data,
|
3);
|
if (length <= 0) {
|
dev_err(dev, "%s: %s failed\n", __func__,
|
"cyttsp5_ic_parse_input_dec");
|
goto cyttsp5_drv_debug_store_exit;
|
}
|
value = input_data[0];
|
|
|
/* Start watchdog timer command */
|
if (value == CY_DBG_HID_START_WD) {
|
dev_info(dev, "%s: start watchdog (cd=%p)\n", __func__, cd);
|
wd_disabled = 0;
|
#ifdef CYTTSP_WATCHDOG_DELAY_ENBALE
|
cyttsp5_start_wd_timer(cd);
|
#endif
|
goto cyttsp5_drv_debug_store_exit;
|
}
|
|
#ifdef CYTTSP_WATCHDOG_DELAY_ENBALE
|
/* Stop watchdog timer temporarily */
|
cyttsp5_stop_wd_timer(cd);
|
#endif
|
if (value == CY_DBG_HID_STOP_WD) {
|
dev_info(dev, "%s: stop watchdog (cd=%p)\n", __func__, cd);
|
wd_disabled = 1;
|
goto cyttsp5_drv_debug_store_exit;
|
}
|
|
switch (value) {
|
case CY_DBG_SUSPEND:
|
dev_info(dev, "%s: SUSPEND (cd=%p)\n", __func__, cd);
|
rc = cyttsp5_core_sleep(cd);
|
if (rc)
|
dev_err(dev, "%s: Suspend failed rc=%d\n",
|
__func__, rc);
|
else
|
dev_info(dev, "%s: Suspend succeeded\n", __func__);
|
break;
|
|
case CY_DBG_RESUME:
|
dev_info(dev, "%s: RESUME (cd=%p)\n", __func__, cd);
|
rc = cyttsp5_core_wake(cd);
|
if (rc)
|
dev_err(dev, "%s: Resume failed rc=%d\n",
|
__func__, rc);
|
else
|
dev_info(dev, "%s: Resume succeeded\n", __func__);
|
break;
|
case CY_DBG_SOFT_RESET:
|
dev_info(dev, "%s: SOFT RESET (cd=%p)\n", __func__, cd);
|
rc = cyttsp5_hw_soft_reset(cd);
|
break;
|
case CY_DBG_RESET:
|
dev_info(dev, "%s: HARD RESET (cd=%p)\n", __func__, cd);
|
rc = cyttsp5_hw_hard_reset(cd);
|
break;
|
case CY_DBG_HID_RESET:
|
dev_info(dev, "%s: hid_reset (cd=%p)\n", __func__, cd);
|
cyttsp5_hid_cmd_reset(cd);
|
break;
|
case CY_DBG_HID_SET_POWER_ON:
|
dev_info(dev, "%s: hid_set_power_on (cd=%p)\n", __func__, cd);
|
cyttsp5_hid_cmd_set_power(cd, HID_POWER_ON);
|
wd_disabled = 0;
|
break;
|
case CY_DBG_HID_SET_POWER_SLEEP:
|
dev_info(dev, "%s: hid_set_power_off (cd=%p)\n", __func__, cd);
|
wd_disabled = 1;
|
cyttsp5_hid_cmd_set_power(cd, HID_POWER_SLEEP);
|
break;
|
case CY_DBG_HID_NULL:
|
dev_info(dev, "%s: hid_null (cd=%p)\n", __func__, cd);
|
cyttsp5_hid_output_null(cd);
|
break;
|
case CY_DBG_HID_ENTER_BL:
|
dev_info(dev, "%s: start_bootloader (cd=%p)\n", __func__, cd);
|
cyttsp5_hid_output_start_bootloader(cd);
|
break;
|
case CY_DBG_HID_SYSINFO:
|
dev_info(dev, "%s: get_sysinfo (cd=%p)\n", __func__, cd);
|
cyttsp5_hid_output_get_sysinfo(cd);
|
break;
|
case CY_DBG_HID_SUSPEND_SCAN:
|
dev_info(dev, "%s: suspend_scanning (cd=%p)\n", __func__, cd);
|
cyttsp5_hid_output_suspend_scanning(cd);
|
break;
|
case CY_DBG_HID_RESUME_SCAN:
|
dev_info(dev, "%s: resume_scanning (cd=%p)\n", __func__, cd);
|
cyttsp5_hid_output_resume_scanning(cd);
|
break;
|
case HID_OUTPUT_BL_VERIFY_APP_INTEGRITY:
|
dev_info(dev, "%s: verify app integ (cd=%p)\n", __func__, cd);
|
cyttsp5_hid_output_bl_verify_app_integrity(cd, &return_data[0]);
|
break;
|
case HID_OUTPUT_BL_GET_INFO:
|
dev_info(dev, "%s: bl get info (cd=%p)\n", __func__, cd);
|
cyttsp5_hid_output_bl_get_information(cd, return_data);
|
break;
|
case HID_OUTPUT_BL_PROGRAM_AND_VERIFY:
|
dev_info(dev, "%s: program and verify (cd=%p)\n", __func__, cd);
|
cyttsp5_hid_output_bl_program_and_verify(cd, 0, NULL);
|
break;
|
case HID_OUTPUT_BL_LAUNCH_APP:
|
dev_info(dev, "%s: launch app (cd=%p)\n", __func__, cd);
|
cyttsp5_hid_output_bl_launch_app(cd);
|
break;
|
case HID_OUTPUT_BL_INITIATE_BL:
|
dev_info(dev, "%s: initiate bl (cd=%p)\n", __func__, cd);
|
cyttsp5_hid_output_bl_initiate_bl(cd, 0, NULL, 0, NULL);
|
break;
|
#ifdef TTHE_TUNER_SUPPORT
|
case CY_TTHE_TUNER_EXIT:
|
cd->tthe_exit = 1;
|
wake_up(&cd->wait_q);
|
kfree(cd->tthe_buf);
|
cd->tthe_buf = NULL;
|
cd->tthe_exit = 0;
|
break;
|
case CY_TTHE_BUF_CLEAN:
|
if (cd->tthe_buf)
|
memset(cd->tthe_buf, 0, CY_MAX_PRBUF_SIZE);
|
else
|
dev_info(dev, "%s : tthe_buf not existed\n", __func__);
|
break;
|
#endif
|
case CY_DBG_REPORT_LEVEL:
|
mutex_lock(&cd->system_lock);
|
cd->debug_level = input_data[1];
|
dev_info(dev, "%s: Set debug_level: %d\n",
|
__func__, cd->debug_level);
|
mutex_unlock(&(cd->system_lock));
|
break;
|
case CY_DBG_WATCHDOG_INTERVAL:
|
mutex_lock(&cd->system_lock);
|
if (input_data[1] > 0)
|
cd->watchdog_interval = input_data[1];
|
dev_info(dev, "%s: Set watchdog_interval: %d\n",
|
__func__, cd->watchdog_interval);
|
mutex_unlock(&(cd->system_lock));
|
break;
|
case CY_DBG_SHOW_TIMESTAMP:
|
mutex_lock(&cd->system_lock);
|
cd->show_timestamp = input_data[1];
|
dev_info(dev, "%s: Set show_timestamp: %d\n",
|
__func__, cd->show_timestamp);
|
mutex_unlock(&(cd->system_lock));
|
break;
|
|
default:
|
dev_err(dev, "%s: Invalid value\n", __func__);
|
}
|
|
#ifdef CYTTSP_WATCHDOG_DELAY_ENBALE
|
/* Enable watchdog timer */
|
if (!wd_disabled)
|
cyttsp5_start_wd_timer(cd);
|
#endif
|
cyttsp5_drv_debug_store_exit:
|
return size;
|
}
|
|
/*
|
* Show system status on deep sleep status via sysfs
|
*/
|
static ssize_t cyttsp5_sleep_status_show(struct device *dev,
|
struct device_attribute *attr, char *buf)
|
{
|
struct cyttsp5_core_data *cd = dev_get_drvdata(dev);
|
ssize_t ret;
|
|
mutex_lock(&cd->system_lock);
|
if (cd->sleep_state == SS_SLEEP_ON)
|
ret = snprintf(buf, CY_MAX_PRBUF_SIZE, "off\n");
|
else
|
ret = snprintf(buf, CY_MAX_PRBUF_SIZE, "on\n");
|
mutex_unlock(&cd->system_lock);
|
|
return ret;
|
}
|
|
static ssize_t cyttsp5_easy_wakeup_gesture_show(struct device *dev,
|
struct device_attribute *attr, char *buf)
|
{
|
struct cyttsp5_core_data *cd = dev_get_drvdata(dev);
|
ssize_t ret;
|
|
mutex_lock(&cd->system_lock);
|
ret = snprintf(buf, CY_MAX_PRBUF_SIZE, "0x%02X\n",
|
cd->easy_wakeup_gesture);
|
mutex_unlock(&cd->system_lock);
|
return ret;
|
}
|
|
static ssize_t cyttsp5_easy_wakeup_gesture_store(struct device *dev,
|
struct device_attribute *attr, const char *buf, size_t size)
|
{
|
struct cyttsp5_core_data *cd = dev_get_drvdata(dev);
|
unsigned long value;
|
int ret;
|
|
if (!cd->features.easywake)
|
return -EINVAL;
|
|
ret = kstrtoul(buf, 10, &value);
|
if (ret < 0)
|
return ret;
|
|
if (value > 0xFF)
|
return -EINVAL;
|
|
pm_runtime_get_sync(dev);
|
|
mutex_lock(&cd->system_lock);
|
if (cd->sysinfo.ready && IS_PIP_VER_GE(&cd->sysinfo, 1, 2))
|
cd->easy_wakeup_gesture = (u8)value;
|
else
|
ret = -ENODEV;
|
mutex_unlock(&cd->system_lock);
|
|
pm_runtime_put(dev);
|
|
if (ret)
|
return ret;
|
|
return size;
|
}
|
|
#ifdef EASYWAKE_TSG6
|
/*
|
* Show easywake gesture id via sysfs
|
*/
|
static ssize_t cyttsp5_easy_wakeup_gesture_id_show(struct device *dev,
|
struct device_attribute *attr, char *buf)
|
{
|
struct cyttsp5_core_data *cd = dev_get_drvdata(dev);
|
ssize_t ret;
|
|
mutex_lock(&cd->system_lock);
|
ret = snprintf(buf, CY_MAX_PRBUF_SIZE, "0x%02X\n",
|
cd->gesture_id);
|
mutex_unlock(&cd->system_lock);
|
return ret;
|
}
|
|
/*
|
* Show easywake gesture data via sysfs
|
* The format:
|
* x1(LSB), x1(MSB),y1(LSB), y1(MSB),x2(LSB), x2(MSB),y2(LSB), y2(MSB),...
|
*/
|
static ssize_t cyttsp5_easy_wakeup_gesture_data_show(struct device *dev,
|
struct device_attribute *attr, char *buf)
|
{
|
struct cyttsp5_core_data *cd = dev_get_drvdata(dev);
|
ssize_t ret = 0;
|
int i;
|
|
mutex_lock(&cd->system_lock);
|
|
for (i = 0; i < cd->gesture_data_length; i++)
|
ret += snprintf(buf + ret, CY_MAX_PRBUF_SIZE - ret,
|
"0x%02X\n", cd->gesture_data[i]);
|
|
ret += snprintf(buf + ret, CY_MAX_PRBUF_SIZE - ret,
|
"(%d bytes)\n", cd->gesture_data_length);
|
|
mutex_unlock(&cd->system_lock);
|
return ret;
|
}
|
#endif
|
|
/* Show Panel ID via sysfs */
|
static ssize_t cyttsp5_panel_id_show(struct device *dev,
|
struct device_attribute *attr, char *buf)
|
{
|
struct cyttsp5_core_data *cd = dev_get_drvdata(dev);
|
ssize_t ret;
|
|
ret = snprintf(buf, CY_MAX_PRBUF_SIZE, "0x%02X\n",
|
cd->panel_id);
|
return ret;
|
}
|
|
/* Show platform data via sysfs */
|
static ssize_t cyttsp5_platform_data_show(struct device *dev,
|
struct device_attribute *attr, char *buf)
|
{
|
struct cyttsp5_platform_data *pdata = dev_get_platdata(dev);
|
ssize_t ret;
|
|
ret = sprintf(buf,
|
"%s: %d\n"
|
"%s: %d\n"
|
"%s: %d\n"
|
"%s: %d\n"
|
"%s: %d\n"
|
"%s: %d\n"
|
"%s: %d\n"
|
"%s: %d\n"
|
"%s: %d\n"
|
"%s: %d\n"
|
"%s: %d\n"
|
"%s: %d\n",
|
"Interrupt GPIO", pdata->core_pdata->irq_gpio,
|
"Reset GPIO", pdata->core_pdata->rst_gpio,
|
"Level trigger delay (us)", pdata->core_pdata->level_irq_udelay,
|
"HID descriptor register", pdata->core_pdata->hid_desc_register,
|
"Vendor ID", pdata->core_pdata->vendor_id,
|
"Product ID", pdata->core_pdata->product_id,
|
"Easy wakeup gesture", pdata->core_pdata->easy_wakeup_gesture,
|
"Vkeys x", pdata->mt_pdata->vkeys_x,
|
"Vkeys y", pdata->mt_pdata->vkeys_y,
|
"Core data flags", pdata->core_pdata->flags,
|
"MT data flags", pdata->mt_pdata->flags,
|
"Loader data flags", pdata->loader_pdata->flags);
|
return ret;
|
}
|
|
static struct device_attribute attributes[] = {
|
__ATTR(ic_ver, S_IRUGO, cyttsp5_ic_ver_show, NULL),
|
__ATTR(drv_ver, S_IRUGO, cyttsp5_drv_ver_show, NULL),
|
__ATTR(hw_reset, S_IWUSR, NULL, cyttsp5_hw_reset_store),
|
__ATTR(hw_irq_stat, S_IRUSR, cyttsp5_hw_irq_stat_show, NULL),
|
__ATTR(drv_irq, S_IRUSR | S_IWUSR, cyttsp5_drv_irq_show,
|
cyttsp5_drv_irq_store),
|
__ATTR(drv_debug, S_IWUSR, NULL, cyttsp5_drv_debug_store),
|
__ATTR(sleep_status, S_IRUSR, cyttsp5_sleep_status_show, NULL),
|
__ATTR(easy_wakeup_gesture, S_IRUSR | S_IWUSR,
|
cyttsp5_easy_wakeup_gesture_show,
|
cyttsp5_easy_wakeup_gesture_store),
|
#ifdef EASYWAKE_TSG6
|
__ATTR(easy_wakeup_gesture_id, S_IRUSR,
|
cyttsp5_easy_wakeup_gesture_id_show, NULL),
|
__ATTR(easy_wakeup_gesture_data, S_IRUSR,
|
cyttsp5_easy_wakeup_gesture_data_show, NULL),
|
#endif
|
__ATTR(panel_id, S_IRUGO, cyttsp5_panel_id_show, NULL),
|
__ATTR(platform_data, S_IRUGO, cyttsp5_platform_data_show, NULL),
|
};
|
|
static int add_sysfs_interfaces(struct device *dev)
|
{
|
int i;
|
|
for (i = 0; i < ARRAY_SIZE(attributes); i++)
|
if (device_create_file(dev, attributes + i))
|
goto undo;
|
return 0;
|
undo:
|
for (i--; i >= 0; i--)
|
device_remove_file(dev, attributes + i);
|
dev_err(dev, "%s: failed to create sysfs interface\n", __func__);
|
return -ENODEV;
|
}
|
|
static void remove_sysfs_interfaces(struct device *dev)
|
{
|
u32 i;
|
|
for (i = 0; i < ARRAY_SIZE(attributes); i++)
|
device_remove_file(dev, attributes + i);
|
}
|
|
/*
|
* ttdl_restart via sysfs
|
*/
|
static ssize_t cyttsp5_ttdl_restart_store(struct device *dev,
|
struct device_attribute *attr, const char *buf, size_t size)
|
{
|
int rc;
|
struct i2c_client *client =
|
(struct i2c_client *)container_of(dev, struct i2c_client, dev);
|
|
if (is_cyttsp5_probe_success) {
|
dev_err(dev, "%s: previous cyttsp5_probe is successful, do nothing\n",
|
__func__);
|
return size;
|
}
|
|
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
|
dev_err(dev, "%s I2C functionality not Supported\n", __func__);
|
return -EIO;
|
}
|
|
#ifdef CONFIG_TOUCHSCREEN_CYPRESS_CYTTSP5_DEVICETREE_SUPPORT
|
rc = cyttsp5_devtree_create_and_get_pdata(dev);
|
if (rc < 0)
|
return rc;
|
#endif
|
|
rc = cyttsp5_probe(cyttsp5_bus_ops_save, &client->dev, client->irq,
|
512);
|
|
if (!rc) {
|
is_cyttsp5_probe_success = true;
|
dev_err(dev, "%s restart successful\n", __func__);
|
} else {
|
is_cyttsp5_probe_success = false;
|
dev_err(dev, "%s: ttdl restart failed r=%d\n",
|
__func__, rc);
|
}
|
|
#ifdef CONFIG_TOUCHSCREEN_CYPRESS_CYTTSP5_DEVICETREE_SUPPORT
|
if (rc)
|
cyttsp5_devtree_clean_pdata(dev);
|
#endif
|
|
return size;
|
|
}
|
static DEVICE_ATTR(ttdl_restart, S_IWUSR, NULL, cyttsp5_ttdl_restart_store);
|
|
|
#ifdef TTHE_TUNER_SUPPORT
|
static int tthe_debugfs_open(struct inode *inode, struct file *filp)
|
{
|
struct cyttsp5_core_data *cd = inode->i_private;
|
|
filp->private_data = inode->i_private;
|
|
if (cd->tthe_buf)
|
return -EBUSY;
|
|
cd->tthe_buf = kzalloc(CY_MAX_PRBUF_SIZE, GFP_KERNEL);
|
if (!cd->tthe_buf)
|
return -ENOMEM;
|
|
return 0;
|
}
|
|
static int tthe_debugfs_close(struct inode *inode, struct file *filp)
|
{
|
struct cyttsp5_core_data *cd = filp->private_data;
|
|
filp->private_data = NULL;
|
|
kfree(cd->tthe_buf);
|
cd->tthe_buf = NULL;
|
|
return 0;
|
}
|
|
static ssize_t tthe_debugfs_read(struct file *filp, char __user *buf,
|
size_t count, loff_t *ppos)
|
{
|
struct cyttsp5_core_data *cd = filp->private_data;
|
int size;
|
int ret;
|
|
wait_event_interruptible(cd->wait_q,
|
cd->tthe_buf_len != 0 || cd->tthe_exit);
|
mutex_lock(&cd->tthe_lock);
|
if (cd->tthe_exit) {
|
mutex_unlock(&cd->tthe_lock);
|
return 0;
|
}
|
if (count > cd->tthe_buf_len)
|
size = cd->tthe_buf_len;
|
else
|
size = count;
|
if (!size) {
|
mutex_unlock(&cd->tthe_lock);
|
return 0;
|
}
|
|
ret = copy_to_user(buf, cd->tthe_buf, cd->tthe_buf_len);
|
if (ret == size)
|
return -EFAULT;
|
size -= ret;
|
cd->tthe_buf_len -= size;
|
mutex_unlock(&cd->tthe_lock);
|
*ppos += size;
|
return size;
|
}
|
|
static const struct file_operations tthe_debugfs_fops = {
|
.open = tthe_debugfs_open,
|
.release = tthe_debugfs_close,
|
.read = tthe_debugfs_read,
|
};
|
#endif
|
|
static struct cyttsp5_core_nonhid_cmd _cyttsp5_core_nonhid_cmd = {
|
.start_bl = _cyttsp5_request_hid_output_start_bl,
|
.suspend_scanning = _cyttsp5_request_hid_output_suspend_scanning,
|
.resume_scanning = _cyttsp5_request_hid_output_resume_scanning,
|
.get_param = _cyttsp5_request_hid_output_get_param,
|
.set_param = _cyttsp5_request_hid_output_set_param,
|
.verify_config_block_crc =
|
_cyttsp5_request_hid_output_verify_config_block_crc,
|
.get_config_row_size = _cyttsp5_request_hid_output_get_config_row_size,
|
.get_data_structure = _cyttsp5_request_hid_output_get_data_structure,
|
.run_selftest = _cyttsp5_request_hid_output_run_selftest,
|
.get_selftest_result = _cyttsp5_request_hid_output_get_selftest_result,
|
.calibrate_idacs = _cyttsp5_request_hid_output_calibrate_idacs,
|
.initialize_baselines =
|
_cyttsp5_request_hid_output_initialize_baselines,
|
.exec_panel_scan = _cyttsp5_request_hid_output_exec_panel_scan,
|
.retrieve_panel_scan = _cyttsp5_request_hid_output_retrieve_panel_scan,
|
.write_conf_block = _cyttsp5_request_hid_output_write_conf_block,
|
.user_cmd = _cyttsp5_request_hid_output_user_cmd,
|
.get_bl_info = _cyttsp5_request_hid_output_bl_get_information,
|
.initiate_bl = _cyttsp5_request_hid_output_bl_initiate_bl,
|
.launch_app = _cyttsp5_request_hid_output_launch_app,
|
.prog_and_verify = _cyttsp5_request_hid_output_bl_program_and_verify,
|
.verify_app_integrity =
|
_cyttsp5_request_hid_output_bl_verify_app_integrity,
|
.get_panel_id = _cyttsp5_request_hid_output_bl_get_panel_id,
|
};
|
|
static struct cyttsp5_core_commands _cyttsp5_core_commands = {
|
.subscribe_attention = _cyttsp5_subscribe_attention,
|
.unsubscribe_attention = _cyttsp5_unsubscribe_attention,
|
.request_exclusive = _cyttsp5_request_exclusive,
|
.release_exclusive = _cyttsp5_release_exclusive,
|
.request_reset = _cyttsp5_request_reset,
|
.request_restart = _cyttsp5_request_restart,
|
.request_sysinfo = _cyttsp5_request_sysinfo,
|
.request_loader_pdata = _cyttsp5_request_loader_pdata,
|
#ifdef CYTTSP_WATCHDOG_DELAY_ENBALE
|
.request_stop_wd = _cyttsp5_request_stop_wd,
|
.request_start_wd = _cyttsp5_request_start_wd,
|
#endif
|
.request_get_hid_desc = _cyttsp5_request_get_hid_desc,
|
.request_get_mode = _cyttsp5_request_get_mode,
|
#ifdef TTHE_TUNER_SUPPORT
|
.request_tthe_print = _cyttsp5_request_tthe_print,
|
#endif
|
.nonhid_cmd = &_cyttsp5_core_nonhid_cmd,
|
};
|
|
struct cyttsp5_core_commands *cyttsp5_get_commands(void)
|
{
|
return &_cyttsp5_core_commands;
|
}
|
EXPORT_SYMBOL_GPL(cyttsp5_get_commands);
|
|
static DEFINE_MUTEX(core_list_lock);
|
static LIST_HEAD(core_list);
|
static DEFINE_MUTEX(module_list_lock);
|
static LIST_HEAD(module_list);
|
static int core_number;
|
|
static int cyttsp5_probe_module(struct cyttsp5_core_data *cd,
|
struct cyttsp5_module *module)
|
{
|
struct module_node *module_node;
|
int rc = 0;
|
|
module_node = kzalloc(sizeof(*module_node), GFP_KERNEL);
|
if (!module_node)
|
return -ENOMEM;
|
|
module_node->module = module;
|
|
mutex_lock(&cd->module_list_lock);
|
list_add(&module_node->node, &cd->module_list);
|
mutex_unlock(&cd->module_list_lock);
|
|
rc = module->probe(cd->dev, &module_node->data);
|
if (rc) {
|
/*
|
* Remove from the list when probe fails
|
* in order not to call release
|
*/
|
mutex_lock(&cd->module_list_lock);
|
list_del(&module_node->node);
|
mutex_unlock(&cd->module_list_lock);
|
kfree(module_node);
|
goto exit;
|
}
|
|
exit:
|
return rc;
|
}
|
|
static void cyttsp5_release_module(struct cyttsp5_core_data *cd,
|
struct cyttsp5_module *module)
|
{
|
struct module_node *m, *m_n;
|
|
mutex_lock(&cd->module_list_lock);
|
list_for_each_entry_safe(m, m_n, &cd->module_list, node)
|
if (m->module == module) {
|
module->release(cd->dev, m->data);
|
list_del(&m->node);
|
kfree(m);
|
break;
|
}
|
mutex_unlock(&cd->module_list_lock);
|
}
|
|
static void cyttsp5_probe_modules(struct cyttsp5_core_data *cd)
|
{
|
struct cyttsp5_module *m;
|
int rc = 0;
|
|
mutex_lock(&module_list_lock);
|
list_for_each_entry(m, &module_list, node) {
|
rc = cyttsp5_probe_module(cd, m);
|
if (rc)
|
dev_err(cd->dev, "%s: Probe fails for module %s\n",
|
__func__, m->name);
|
}
|
mutex_unlock(&module_list_lock);
|
}
|
|
static void cyttsp5_release_modules(struct cyttsp5_core_data *cd)
|
{
|
struct cyttsp5_module *m;
|
|
mutex_lock(&module_list_lock);
|
list_for_each_entry(m, &module_list, node)
|
cyttsp5_release_module(cd, m);
|
mutex_unlock(&module_list_lock);
|
}
|
|
struct cyttsp5_core_data *cyttsp5_get_core_data(char *id)
|
{
|
struct cyttsp5_core_data *d;
|
|
list_for_each_entry(d, &core_list, node)
|
if (!strncmp(d->core_id, id, 20))
|
return d;
|
return NULL;
|
}
|
EXPORT_SYMBOL_GPL(cyttsp5_get_core_data);
|
|
static void cyttsp5_add_core(struct device *dev)
|
{
|
struct cyttsp5_core_data *d;
|
struct cyttsp5_core_data *cd = dev_get_drvdata(dev);
|
|
mutex_lock(&core_list_lock);
|
list_for_each_entry(d, &core_list, node)
|
if (d->dev == dev)
|
goto unlock;
|
|
list_add(&cd->node, &core_list);
|
unlock:
|
mutex_unlock(&core_list_lock);
|
}
|
|
static void cyttsp5_del_core(struct device *dev)
|
{
|
struct cyttsp5_core_data *d, *d_n;
|
|
mutex_lock(&core_list_lock);
|
list_for_each_entry_safe(d, d_n, &core_list, node)
|
if (d->dev == dev) {
|
list_del(&d->node);
|
goto unlock;
|
}
|
unlock:
|
mutex_unlock(&core_list_lock);
|
}
|
|
int cyttsp5_register_module(struct cyttsp5_module *module)
|
{
|
struct cyttsp5_module *m;
|
struct cyttsp5_core_data *cd;
|
|
int rc = 0;
|
|
if (!module || !module->probe || !module->release)
|
return -EINVAL;
|
|
mutex_lock(&module_list_lock);
|
list_for_each_entry(m, &module_list, node)
|
if (m == module) {
|
rc = -EEXIST;
|
goto unlock;
|
}
|
|
list_add(&module->node, &module_list);
|
|
/* Probe the module for each core */
|
mutex_lock(&core_list_lock);
|
list_for_each_entry(cd, &core_list, node)
|
cyttsp5_probe_module(cd, module);
|
mutex_unlock(&core_list_lock);
|
|
unlock:
|
mutex_unlock(&module_list_lock);
|
return rc;
|
}
|
EXPORT_SYMBOL_GPL(cyttsp5_register_module);
|
|
void cyttsp5_unregister_module(struct cyttsp5_module *module)
|
{
|
struct cyttsp5_module *m, *m_n;
|
struct cyttsp5_core_data *cd;
|
|
if (!module)
|
return;
|
|
mutex_lock(&module_list_lock);
|
|
/* Release the module for each core */
|
mutex_lock(&core_list_lock);
|
list_for_each_entry(cd, &core_list, node)
|
cyttsp5_release_module(cd, module);
|
mutex_unlock(&core_list_lock);
|
|
list_for_each_entry_safe(m, m_n, &module_list, node)
|
if (m == module) {
|
list_del(&m->node);
|
break;
|
}
|
|
mutex_unlock(&module_list_lock);
|
}
|
EXPORT_SYMBOL_GPL(cyttsp5_unregister_module);
|
|
void *cyttsp5_get_module_data(struct device *dev, struct cyttsp5_module *module)
|
{
|
struct cyttsp5_core_data *cd = dev_get_drvdata(dev);
|
struct module_node *m;
|
void *data = NULL;
|
|
mutex_lock(&cd->module_list_lock);
|
list_for_each_entry(m, &cd->module_list, node)
|
if (m->module == module) {
|
data = m->data;
|
break;
|
}
|
mutex_unlock(&cd->module_list_lock);
|
|
return data;
|
}
|
EXPORT_SYMBOL(cyttsp5_get_module_data);
|
|
#if 0 //def CONFIG_HAS_EARLYSUSPEND
|
static void cyttsp5_early_suspend(struct early_suspend *h)
|
{
|
struct cyttsp5_core_data *cd =
|
container_of(h, struct cyttsp5_core_data, es);
|
|
call_atten_cb(cd, CY_ATTEN_SUSPEND, 0);
|
}
|
|
static void cyttsp5_late_resume(struct early_suspend *h)
|
{
|
struct cyttsp5_core_data *cd =
|
container_of(h, struct cyttsp5_core_data, es);
|
|
call_atten_cb(cd, CY_ATTEN_RESUME, 0);
|
}
|
|
static void cyttsp5_setup_early_suspend(struct cyttsp5_core_data *cd)
|
{
|
cd->es.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
|
cd->es.suspend = cyttsp5_early_suspend;
|
cd->es.resume = cyttsp5_late_resume;
|
|
register_early_suspend(&cd->es);
|
}
|
#endif
|
#if 0 //defined(CONFIG_FB)
|
static int fb_notifier_callback(struct notifier_block *self,
|
unsigned long event, void *data)
|
{
|
struct cyttsp5_core_data *cd =
|
container_of(self, struct cyttsp5_core_data, fb_notifier);
|
struct fb_event *evdata = data;
|
int *blank;
|
|
if (event != FB_EVENT_BLANK || !evdata)
|
goto exit;
|
|
blank = evdata->data;
|
if (*blank == FB_BLANK_UNBLANK) {
|
dev_info(cd->dev, "%s: UNBLANK!\n", __func__);
|
if (cd->fb_state != FB_ON) {
|
call_atten_cb(cd, CY_ATTEN_RESUME, 0);
|
cd->fb_state = FB_ON;
|
}
|
} else if (*blank == FB_BLANK_POWERDOWN) {
|
dev_info(cd->dev, "%s: POWERDOWN!\n", __func__);
|
if (cd->fb_state != FB_OFF) {
|
call_atten_cb(cd, CY_ATTEN_SUSPEND, 0);
|
cd->fb_state = FB_OFF;
|
}
|
}
|
|
exit:
|
return 0;
|
}
|
|
static void cyttsp5_setup_fb_notifier(struct cyttsp5_core_data *cd)
|
{
|
int rc;
|
|
cd->fb_state = FB_ON;
|
|
cd->fb_notifier.notifier_call = fb_notifier_callback;
|
|
rc = fb_register_client(&cd->fb_notifier);
|
if (rc)
|
dev_err(cd->dev, "Unable to register fb_notifier: %d\n", rc);
|
}
|
#endif
|
|
static int cyttsp5_setup_irq_gpio(struct cyttsp5_core_data *cd)
|
{
|
struct device *dev = cd->dev;
|
unsigned long irq_flags;
|
int rc; //reg, val;
|
|
/* Initialize IRQ */
|
cd->irq = gpio_to_irq(cd->cpdata->irq_gpio);
|
//printk("%%%% cyttsp5_setup_irq_gpio irq=%d\n", cd->irq);
|
if (cd->irq < 0)
|
return -EINVAL;
|
|
cd->irq_enabled = true;
|
|
parade_debug(dev, DEBUG_LEVEL_1, "%s: initialize threaded irq=%d\n",
|
__func__, cd->irq);
|
if (cd->cpdata->level_irq_udelay > 0)
|
/* use level triggered interrupts */
|
irq_flags = IRQF_TRIGGER_LOW | IRQF_ONESHOT;
|
else
|
/* use edge triggered interrupts */
|
irq_flags = IRQF_TRIGGER_FALLING | IRQF_ONESHOT ;
|
|
rc = request_threaded_irq(cd->irq, NULL, cyttsp5_irq, IRQF_TRIGGER_LOW | IRQF_ONESHOT | IRQF_NO_SUSPEND,
|
dev_name(dev), cd);
|
if (rc < 0)
|
dev_err(dev, "%s: Error, could not request irq\n", __func__);
|
return rc;
|
}
|
|
int cyttsp5_probe(const struct cyttsp5_bus_ops *ops, struct device *dev,
|
u16 irq, size_t xfer_buf_size)
|
{
|
struct cyttsp5_core_data *cd;
|
struct cyttsp5_platform_data *pdata = dev_get_platdata(dev);
|
enum cyttsp5_atten_type type;
|
int rc = 0;
|
|
/* Set default values on first probe */
|
if (cyttsp5_first_probe) {
|
cyttsp5_first_probe = false;
|
is_cyttsp5_probe_success = false;
|
cyttsp5_bus_ops_save = NULL;
|
}
|
|
if (!pdata || !pdata->core_pdata || !pdata->mt_pdata) {
|
dev_err(dev, "%s: Missing platform data\n", __func__);
|
rc = -ENODEV;
|
goto error_no_pdata;
|
}
|
|
if (pdata->core_pdata->flags & CY_CORE_FLAG_POWEROFF_ON_SLEEP) {
|
if (!pdata->core_pdata->power) {
|
dev_err(dev, "%s: Missing platform data function\n",
|
__func__);
|
rc = -ENODEV;
|
goto error_no_pdata;
|
}
|
}
|
|
/* get context and debug print buffers */
|
cd = kzalloc(sizeof(*cd), GFP_KERNEL);
|
if (!cd) {
|
rc = -ENOMEM;
|
goto error_alloc_data;
|
}
|
|
cd->supply = devm_regulator_get(dev, "cytp");
|
if (cd->supply) {
|
dev_info(dev, "cyttsp5 touch supply = %dmv\n", regulator_get_voltage(cd->supply));
|
rc = regulator_enable(cd->supply);
|
if (rc < 0)
|
dev_err(dev, "failed to enable cyttsp5 power supply\n");
|
}
|
|
/* Initialize device info */
|
cd->dev = dev;
|
cd->pdata = pdata;
|
cd->cpdata = pdata->core_pdata;
|
cd->bus_ops = ops;
|
cd->debug_level = CY_INITIAL_DEBUG_LEVEL;
|
//2019-03-22 interval is 0, solve reboot huge
|
cd->watchdog_interval = 0;//CY_WATCHDOG_TIMEOUT;
|
cd->show_timestamp = CY_INITIAL_SHOW_TIME_STAMP;
|
scnprintf(cd->core_id, 20, "%s%d", CYTTSP5_CORE_NAME, core_number++);
|
|
/* Initialize mutexes and spinlocks */
|
mutex_init(&cd->module_list_lock);
|
mutex_init(&cd->system_lock);
|
mutex_init(&cd->adap_lock);
|
mutex_init(&cd->hid_report_lock);
|
spin_lock_init(&cd->spinlock);
|
|
/* Initialize module list */
|
INIT_LIST_HEAD(&cd->module_list);
|
|
/* Initialize attention lists */
|
for (type = 0; type < CY_ATTEN_NUM_ATTEN; type++)
|
INIT_LIST_HEAD(&cd->atten_list[type]);
|
|
/* Initialize parameter list */
|
INIT_LIST_HEAD(&cd->param_list);
|
|
/* Initialize wait queue */
|
init_waitqueue_head(&cd->wait_q);
|
|
/* Initialize works */
|
INIT_WORK(&cd->startup_work, cyttsp5_startup_work_function);
|
#ifdef CYTTSP_WATCHDOG_DELAY_ENBALE
|
INIT_WORK(&cd->watchdog_work, cyttsp5_watchdog_work);
|
#endif
|
/* Initialize HID specific data */
|
cd->hid_core.hid_vendor_id = (cd->cpdata->vendor_id) ?
|
cd->cpdata->vendor_id : CY_HID_VENDOR_ID;
|
cd->hid_core.hid_product_id = (cd->cpdata->product_id) ?
|
cd->cpdata->product_id : CY_HID_APP_PRODUCT_ID;
|
cd->hid_core.hid_desc_register =
|
cpu_to_le16(cd->cpdata->hid_desc_register);
|
|
/* Set platform easywake value */
|
cd->easy_wakeup_gesture = cd->cpdata->easy_wakeup_gesture;
|
|
/* Set Panel ID to Not Enabled */
|
cd->panel_id = PANEL_ID_NOT_ENABLED;
|
|
dev_set_drvdata(dev, cd);
|
cyttsp5_add_core(dev);
|
|
/*create ttdl_restart sysfs node is probe failed*/
|
if (!is_cyttsp5_probe_success)
|
device_create_file(dev, &dev_attr_ttdl_restart);
|
|
/*
|
* Save the pointer to a global value, which will be used
|
* in ttdl_restart function
|
*/
|
cyttsp5_bus_ops_save = ops;
|
|
/* Call platform detect function */
|
if (cd->cpdata->detect) {
|
dev_info(cd->dev, "%s: Detect HW\n", __func__);
|
rc = cd->cpdata->detect(cd->cpdata, cd->dev,
|
cyttsp5_platform_detect_read);
|
if (rc) {
|
dev_info(cd->dev, "%s: No HW detected\n", __func__);
|
rc = -ENODEV;
|
goto error_detect;
|
}
|
}
|
#ifdef CYTTSP_WATCHDOG_DELAY_ENBALE
|
/* Setup watchdog timer */
|
timer_setup(&cd->watchdog_timer, cyttsp5_watchdog_timer,
|
(unsigned long)cd);
|
#endif
|
rc = cyttsp5_setup_irq_gpio(cd);
|
if (rc < 0) {
|
dev_err(dev, "%s: Error, could not setup IRQ\n", __func__);
|
goto error_setup_irq;
|
}
|
|
parade_debug(dev, DEBUG_LEVEL_1, "%s: add sysfs interfaces\n",
|
__func__);
|
rc = add_sysfs_interfaces(dev);
|
if (rc < 0) {
|
dev_err(dev, "%s: Error, fail sysfs init\n", __func__);
|
goto error_attr_create;
|
}
|
|
#ifdef TTHE_TUNER_SUPPORT
|
mutex_init(&cd->tthe_lock);
|
cd->tthe_debugfs = debugfs_create_file(CYTTSP5_TTHE_TUNER_FILE_NAME,
|
0644, NULL, cd, &tthe_debugfs_fops);
|
#endif
|
rc = device_init_wakeup(dev, 1);
|
if (rc < 0)
|
dev_err(dev, "%s: Error, device_init_wakeup rc:%d\n",
|
__func__, rc);
|
enable_irq_wake(cd->irq);
|
cd->irq_wake = 1;
|
|
pm_runtime_get_noresume(dev);
|
pm_runtime_set_active(dev);
|
pm_runtime_enable(dev);
|
|
/*
|
* call startup directly to ensure that the device
|
* is tested before leaving the probe
|
*/
|
parade_debug(dev, DEBUG_LEVEL_1, "%s: call startup\n", __func__);
|
rc = cyttsp5_startup(cd, false);
|
|
pm_runtime_put_sync(dev);
|
|
/* Do not fail probe if startup fails but the device is detected */
|
if (rc == -ENODEV) {
|
dev_err(cd->dev, "%s: Fail initial startup r=%d\n",
|
__func__, rc);
|
goto error_startup;
|
}
|
|
rc = cyttsp5_mt_probe(dev);
|
if (rc < 0) {
|
dev_err(dev, "%s: Error, fail mt probe\n", __func__);
|
goto error_startup;
|
}
|
|
rc = cyttsp5_btn_probe(dev);
|
if (rc < 0) {
|
dev_err(dev, "%s: Error, fail btn probe\n", __func__);
|
goto error_startup_mt;
|
}
|
|
rc = cyttsp5_proximity_probe(dev);
|
if (rc < 0) {
|
dev_err(dev, "%s: Error, fail proximity probe\n", __func__);
|
goto error_startup_btn;
|
}
|
|
/* Probe registered modules */
|
cyttsp5_probe_modules(cd);
|
|
//#ifdef CONFIG_HAS_EARLYSUSPEND
|
// cyttsp5_setup_early_suspend(cd);
|
//#elif defined(CONFIG_FB)
|
// cyttsp5_setup_fb_notifier(cd);
|
//#endif
|
|
#if NEED_SUSPEND_NOTIFIER
|
cd->pm_notifier.notifier_call = cyttsp5_pm_notifier;
|
register_pm_notifier(&cd->pm_notifier);
|
#endif
|
|
cd->tp.tp_resume = cyttsp5_core_late_resume;
|
cd->tp.tp_suspend = cyttsp5_core_early_suspend;
|
tp_register_fb(&cd->tp);
|
|
if (!priv_data) {
|
priv_data = cd;
|
}
|
#ifdef CYTTSP_WATCHDOG_DELAY_ENBALE
|
INIT_DELAYED_WORK(&cd->watchdog_enable_work, watchdog_delay_enable);
|
schedule_delayed_work(&cd->watchdog_enable_work, msecs_to_jiffies(25 * 1000));
|
#endif
|
is_cyttsp5_probe_success = true;
|
return 0;
|
|
error_startup_btn:
|
cyttsp5_btn_release(dev);
|
error_startup_mt:
|
cyttsp5_mt_release(dev);
|
error_startup:
|
pm_runtime_disable(dev);
|
#if (KERNEL_VERSION(3, 16, 0) > LINUX_VERSION_CODE)
|
device_wakeup_disable(dev);
|
#endif
|
device_init_wakeup(dev, 0);
|
cancel_work_sync(&cd->startup_work);
|
#ifdef CYTTSP_WATCHDOG_DELAY_ENBALE
|
cyttsp5_stop_wd_timer(cd);
|
#endif
|
cyttsp5_free_si_ptrs(cd);
|
remove_sysfs_interfaces(dev);
|
error_attr_create:
|
free_irq(cd->irq, cd);
|
#ifdef CYTTSP_WATCHDOG_DELAY_ENBALE
|
del_timer(&cd->watchdog_timer);
|
#endif
|
error_setup_irq:
|
error_detect:
|
if (cd->cpdata->init)
|
cd->cpdata->init(cd->cpdata, 0, dev);
|
cyttsp5_del_core(dev);
|
dev_set_drvdata(dev, NULL);
|
kfree(cd);
|
error_alloc_data:
|
error_no_pdata:
|
dev_err(dev, "%s failed.\n", __func__);
|
is_cyttsp5_probe_success = false;
|
return rc;
|
}
|
EXPORT_SYMBOL_GPL(cyttsp5_probe);
|
|
int cyttsp5_release(struct cyttsp5_core_data *cd)
|
{
|
struct device *dev = cd->dev;
|
|
/* Release successfully probed modules */
|
cyttsp5_release_modules(cd);
|
|
cyttsp5_proximity_release(dev);
|
cyttsp5_btn_release(dev);
|
cyttsp5_mt_release(dev);
|
|
//#ifdef CONFIG_HAS_EARLYSUSPEND
|
// unregister_early_suspend(&cd->es);
|
//#elif defined(CONFIG_FB)
|
// fb_unregister_client(&cd->fb_notifier);
|
//#endif
|
|
#if NEED_SUSPEND_NOTIFIER
|
unregister_pm_notifier(&cd->pm_notifier);
|
#endif
|
|
/*
|
* Suspend the device before freeing the startup_work and stopping
|
* the watchdog since sleep function restarts watchdog on failure
|
*/
|
pm_runtime_suspend(dev);
|
pm_runtime_disable(dev);
|
|
cancel_work_sync(&cd->startup_work);
|
|
#ifdef CYTTSP_WATCHDOG_DELAY_ENBALE
|
cyttsp5_stop_wd_timer(cd);
|
#endif
|
|
#if (KERNEL_VERSION(3, 16, 0) > LINUX_VERSION_CODE)
|
device_wakeup_disable(dev);
|
#endif
|
device_init_wakeup(dev, 0);
|
|
#ifdef TTHE_TUNER_SUPPORT
|
mutex_lock(&cd->tthe_lock);
|
cd->tthe_exit = 1;
|
wake_up(&cd->wait_q);
|
mutex_unlock(&cd->tthe_lock);
|
debugfs_remove(cd->tthe_debugfs);
|
#endif
|
remove_sysfs_interfaces(dev);
|
free_irq(cd->irq, cd);
|
if (cd->cpdata->init)
|
cd->cpdata->init(cd->cpdata, 0, dev);
|
dev_set_drvdata(dev, NULL);
|
cyttsp5_del_core(dev);
|
cyttsp5_free_si_ptrs(cd);
|
cyttsp5_free_hid_reports(cd);
|
kfree(cd);
|
|
priv_data = NULL;
|
|
return 0;
|
}
|
EXPORT_SYMBOL_GPL(cyttsp5_release);
|
|
MODULE_LICENSE("GPL");
|
MODULE_DESCRIPTION("Parade TrueTouch(R) Standard Product Core Driver");
|
MODULE_AUTHOR("Parade Technologies <ttdrivers@paradetech.com>");
|
