17288 lines
495 KiB
C
Executable File
17288 lines
495 KiB
C
Executable File
/*
|
|
* pt_core.c
|
|
* Parade TrueTouch(TM) Standard Product Core Module.
|
|
* For use with Parade touchscreen controllers.
|
|
* Supported parts include:
|
|
* TMA5XX
|
|
* TMA448
|
|
* TMA445A
|
|
* TT21XXX
|
|
* TT31XXX
|
|
* TT4XXXX
|
|
* TT7XXX
|
|
* TC3XXX
|
|
*
|
|
* Copyright (C) 2015-2020 Parade Technologies
|
|
*
|
|
* 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 "pt_regs.h"
|
|
#include <linux/kthread.h>
|
|
#include <linux/i2c.h>
|
|
#include <linux/gpio.h>
|
|
#include <linux/regulator/consumer.h>
|
|
|
|
|
|
#define PT_CORE_STARTUP_RETRY_COUNT 3
|
|
|
|
MODULE_FIRMWARE(PT_FW_FILE_NAME);
|
|
|
|
static const char *pt_driver_core_name = PT_CORE_NAME;
|
|
static const char *pt_driver_core_version = PT_DRIVER_VERSION;
|
|
static const char *pt_driver_core_date = PT_DRIVER_DATE;
|
|
|
|
struct pt_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[PT_HID_MAX_COLLECTIONS];
|
|
struct pt_hid_report *report;
|
|
bool record_field;
|
|
};
|
|
|
|
struct pt_hid_report {
|
|
u8 id;
|
|
u8 type;
|
|
int size;
|
|
struct pt_hid_field *fields[PT_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 *dev);
|
|
int mode;
|
|
};
|
|
|
|
struct param_node {
|
|
struct list_head node;
|
|
u8 id;
|
|
u32 value;
|
|
u8 size;
|
|
};
|
|
|
|
struct module_node {
|
|
struct list_head node;
|
|
struct pt_module *module;
|
|
void *data;
|
|
};
|
|
|
|
struct pt_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 pt_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 CREATE_PIP1_FW_CMD(command) \
|
|
.cmd_type = PIP1_CMD_TYPE_FW, \
|
|
.command_code = command
|
|
|
|
#define CREATE_PIP1_BL_CMD(command) \
|
|
.cmd_type = PIP1_CMD_TYPE_BL, \
|
|
.command_code = command
|
|
|
|
#define PT_MAX_PR_BUF_SIZE 2048
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_pr_buf
|
|
*
|
|
* SUMMARY: Print out the contents of a buffer to kmsg based on the debug level
|
|
*
|
|
* RETURN: Void
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to Device structure
|
|
* debug_level - requested debug level to print at
|
|
* *buf - pointer to buffer to print
|
|
* buf_len - size of buf
|
|
* *data_name - Descriptive name of data prefixed to data
|
|
******************************************************************************/
|
|
void pt_pr_buf(struct device *dev, u8 debug_level, u8 *buf,
|
|
u16 buf_len, const char *data_name)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
int i;
|
|
int pr_buf_index = 0;
|
|
int max_size;
|
|
|
|
/* only proceed if valid debug level and there is data to print */
|
|
if (debug_level <= cd->debug_level && buf_len > 0) {
|
|
char *pr_buf = kzalloc(PT_MAX_PR_BUF_SIZE, GFP_KERNEL);
|
|
|
|
if (!pr_buf)
|
|
return;
|
|
|
|
/*
|
|
* With a space each printed char takes 3 bytes, subtract
|
|
* the length of the data_name prefix as well as 11 bytes
|
|
* for the " [0..xxx]: " printed before the data.
|
|
*/
|
|
max_size = (PT_MAX_PR_BUF_SIZE - sizeof(data_name) - 11) / 3;
|
|
|
|
/* Ensure pr_buf_index stays within the 1018 size */
|
|
pr_buf_index += sprintf(pr_buf, "%s [0..%d]: ",
|
|
data_name, buf_len);
|
|
for (i = 0; i < buf_len && i < max_size; i++)
|
|
pr_buf_index += sprintf(pr_buf + pr_buf_index,
|
|
"%02X ", buf[i]);
|
|
|
|
pt_debug(dev, debug_level, "%s\n", pr_buf);
|
|
kfree(pr_buf);
|
|
}
|
|
}
|
|
EXPORT_SYMBOL_GPL(pt_pr_buf);
|
|
|
|
#ifdef TTHE_TUNER_SUPPORT
|
|
/*******************************************************************************
|
|
* FUNCTION: tthe_print
|
|
*
|
|
* SUMMARY: Format data name and time stamp as the header and format the
|
|
* content of input buffer with hex base to "tthe_buf". And then wake up event
|
|
* semaphore for tthe debugfs node.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* *buf - pointer to input buffer
|
|
* buf_len - size of input buffer
|
|
* *data_name - pointer to data name
|
|
******************************************************************************/
|
|
static int tthe_print(struct pt_core_data *cd, u8 *buf, int buf_len,
|
|
const u8 *data_name)
|
|
{
|
|
int name_len = strlen(data_name);
|
|
int i, n;
|
|
u8 *p;
|
|
int remain;
|
|
u8 data_name_with_time_stamp[100];
|
|
|
|
/* Prepend timestamp, if requested, to data_name */
|
|
if (cd->show_timestamp) {
|
|
sprintf(data_name_with_time_stamp, "[%u] %s",
|
|
pt_get_time_stamp(), data_name);
|
|
data_name = data_name_with_time_stamp;
|
|
name_len = strlen(data_name);
|
|
}
|
|
|
|
mutex_lock(&cd->tthe_lock);
|
|
if (!cd->tthe_buf)
|
|
goto exit;
|
|
|
|
/* Add 1 due to the '\n' that is appended at the end */
|
|
if (cd->tthe_buf_len + name_len + buf_len + 1 > cd->tthe_buf_size)
|
|
goto exit;
|
|
|
|
if (name_len + buf_len == 0)
|
|
goto exit;
|
|
|
|
remain = cd->tthe_buf_size - cd->tthe_buf_len;
|
|
if (remain < name_len)
|
|
name_len = remain;
|
|
|
|
p = cd->tthe_buf + cd->tthe_buf_len;
|
|
memcpy(p, data_name, name_len);
|
|
cd->tthe_buf_len += name_len;
|
|
p += name_len;
|
|
remain -= name_len;
|
|
|
|
*p = 0;
|
|
for (i = 0; i < buf_len; i++) {
|
|
n = scnprintf(p, remain, "%02X ", buf[i]);
|
|
if (n <= 0)
|
|
break;
|
|
p += n;
|
|
remain -= n;
|
|
cd->tthe_buf_len += n;
|
|
}
|
|
|
|
n = scnprintf(p, remain, "\n");
|
|
cd->tthe_buf_len += n;
|
|
exit:
|
|
wake_up(&cd->wait_q);
|
|
mutex_unlock(&cd->tthe_lock);
|
|
return 0;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_request_tthe_print
|
|
*
|
|
* SUMMARY: Function pointer included in core_cmds to allow other modules
|
|
* to request to print data to the "tthe_buffer".
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
******************************************************************************/
|
|
static int _pt_request_tthe_print(struct device *dev, u8 *buf,
|
|
int buf_len, const u8 *data_name)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
|
|
return tthe_print(cd, buf, buf_len, data_name);
|
|
}
|
|
#endif
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_platform_detect_read
|
|
*
|
|
* SUMMARY: To be passed to platform dectect function to perform a read
|
|
* operation.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to Device structure
|
|
* *buf - pointer to buffer where the data read will be stored
|
|
* size - size to be read
|
|
******************************************************************************/
|
|
static int pt_platform_detect_read(struct device *dev, void *buf, int size)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
|
|
return pt_adap_read_default(cd, buf, size);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_add_parameter
|
|
*
|
|
* SUMMARY: Adds a parameter that has been altered to the parameter linked list.
|
|
* On every reset of the DUT this linked list is traversed and all
|
|
* parameters in it are restored to the DUT.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* param_id - parameter ID to add
|
|
* param_value - Value corresponding to the ID
|
|
* param_size - Size of param_value
|
|
******************************************************************************/
|
|
static int pt_add_parameter(struct pt_core_data *cd,
|
|
u8 param_id, u32 param_value, u8 param_size)
|
|
{
|
|
struct param_node *param, *param_new;
|
|
|
|
/* Check if parameter already exists in the list */
|
|
spin_lock(&cd->spinlock);
|
|
list_for_each_entry(param, &cd->param_list, node) {
|
|
if (param->id == param_id) {
|
|
/* Update parameter */
|
|
param->value = param_value;
|
|
pt_debug(cd->dev, DL_INFO,
|
|
"%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;
|
|
|
|
pt_debug(cd->dev, DL_INFO,
|
|
"%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;
|
|
}
|
|
|
|
#ifdef TTDL_DIAGNOSTICS
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_erase_parameter_list
|
|
*
|
|
* SUMMARY: Empty out the entire parameter linked list of all parameter/value
|
|
* pairs. In some test cases this functionality is needed to ensure DUT
|
|
* returns to a virgin state after a reset and no parameters are restored.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
******************************************************************************/
|
|
static int pt_erase_parameter_list(struct pt_core_data *cd)
|
|
{
|
|
struct param_node *pos, *temp;
|
|
|
|
spin_lock(&cd->spinlock);
|
|
list_for_each_entry_safe(pos, temp, &cd->param_list, node) {
|
|
pt_debug(cd->dev, DL_INFO,
|
|
"%s: Parameter Restore List - remove 0x%02x\n",
|
|
__func__, pos->id);
|
|
list_del(&pos->node);
|
|
kfree(pos);
|
|
}
|
|
spin_unlock(&cd->spinlock);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_count_parameter_list
|
|
*
|
|
* SUMMARY: Count the items in the RAM parameter restor list
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
******************************************************************************/
|
|
static int pt_count_parameter_list(struct pt_core_data *cd)
|
|
{
|
|
struct param_node *pos, *temp;
|
|
int entries = 0;
|
|
|
|
spin_lock(&cd->spinlock);
|
|
list_for_each_entry_safe(pos, temp, &cd->param_list, node)
|
|
entries++;
|
|
spin_unlock(&cd->spinlock);
|
|
|
|
return entries;
|
|
}
|
|
#endif /* TTDL_DIAGNOSTICS */
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: request_exclusive
|
|
*
|
|
* SUMMARY: Request exclusive access to the DUT
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* *ownptr - pointer to device
|
|
* timeout_ms - Timeout value
|
|
******************************************************************************/
|
|
int request_exclusive(struct pt_core_data *cd, void *ownptr,
|
|
int timeout_ms)
|
|
{
|
|
int t = msecs_to_jiffies(timeout_ms);
|
|
bool with_timeout = (timeout_ms != 0);
|
|
|
|
pt_debug(cd->dev, DL_INFO, "%s: Attempt to Request EXCLUSIVE t=%d\n",
|
|
__func__, timeout_ms);
|
|
|
|
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)) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%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);
|
|
pt_debug(cd->dev, DL_DEBUG, "%s: request exclusive ok=%p\n",
|
|
__func__, ownptr);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: release_exclusive_
|
|
*
|
|
* SUMMARY: Release exclusive access to the DUT
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* *ownptr - pointer to device
|
|
******************************************************************************/
|
|
static int release_exclusive_(struct pt_core_data *cd, void *ownptr)
|
|
{
|
|
pt_debug(cd->dev, DL_INFO, "%s: Attempt to Release EXCLUSIVE\n",
|
|
__func__);
|
|
if (cd->exclusive_dev != ownptr)
|
|
return -EINVAL;
|
|
|
|
pt_debug(cd->dev, DL_DEBUG, "%s: exclusive_dev %p freed\n",
|
|
__func__, cd->exclusive_dev);
|
|
cd->exclusive_dev = NULL;
|
|
wake_up(&cd->wait_q);
|
|
return 0;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: release_exclusive
|
|
*
|
|
* SUMMARY: Protected wrapper to release_exclusive_()
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* *ownptr - pointer to device
|
|
******************************************************************************/
|
|
int release_exclusive(struct pt_core_data *cd, void *ownptr)
|
|
{
|
|
int rc;
|
|
|
|
mutex_lock(&cd->system_lock);
|
|
rc = release_exclusive_(cd, ownptr);
|
|
mutex_unlock(&cd->system_lock);
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_hid_exec_cmd_
|
|
*
|
|
* SUMMARY: Send the HID command to the DUT
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* *hid_cmd - pointer to the HID command to send
|
|
******************************************************************************/
|
|
static int pt_hid_exec_cmd_(struct pt_core_data *cd,
|
|
struct pt_hid_cmd *hid_cmd)
|
|
{
|
|
int rc = 0;
|
|
u8 *cmd;
|
|
u16 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;
|
|
}
|
|
|
|
pt_debug(cd->dev, DL_INFO,
|
|
">>> %s: Write Buffer Size[%d] Cmd[0x%02X]\n",
|
|
__func__, cmd_length, hid_cmd->report_id);
|
|
pt_pr_buf(cd->dev, DL_DEBUG, cmd, cmd_length, ">>> CMD");
|
|
rc = pt_adap_write_read_specific(cd, cmd_length, cmd,
|
|
hid_cmd->read_buf);
|
|
if (rc)
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: Fail pt_adap_transfer\n", __func__);
|
|
|
|
kfree(cmd);
|
|
return rc;
|
|
}
|
|
#ifdef TTDL_DIAGNOSTICS
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_toggle_err_gpio
|
|
*
|
|
* SUMMARY: Toggles the pre-defined error GPIO
|
|
*
|
|
* RETURN: n/a
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* type - type of err that occured
|
|
******************************************************************************/
|
|
void pt_toggle_err_gpio(struct pt_core_data *cd, u8 type)
|
|
{
|
|
pt_debug(cd->dev, DL_DEBUG, "%s called with type = %d\n",
|
|
__func__, type);
|
|
if (cd->err_gpio && type == cd->err_gpio_type) {
|
|
pt_debug(cd->dev, DL_WARN, "%s: Toggle ERR GPIO\n", __func__);
|
|
gpio_direction_output(cd->err_gpio,
|
|
!gpio_get_value(cd->err_gpio));
|
|
}
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_request_toggle_err_gpio
|
|
*
|
|
* SUMMARY: Function pointer included in core_cmds to allow other modules
|
|
* to request to toggle the err_gpio
|
|
*
|
|
* RETURN: n/a
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* type - type of err that occured
|
|
******************************************************************************/
|
|
void _pt_request_toggle_err_gpio(struct device *dev, u8 type)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
|
|
pt_toggle_err_gpio(cd, type);
|
|
}
|
|
#endif /* TTDL_DIAGNOSTICS */
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_hid_exec_cmd_and_wait_
|
|
*
|
|
* SUMMARY: Send the HID command to the DUT and wait for the response
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* *hid_cmd - pointer to the HID command to send
|
|
******************************************************************************/
|
|
static int pt_hid_exec_cmd_and_wait_(struct pt_core_data *cd,
|
|
struct pt_hid_cmd *hid_cmd)
|
|
{
|
|
int rc = 0;
|
|
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 = pt_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 = PT_HID_CMD_DEFAULT_TIMEOUT;
|
|
|
|
t = wait_event_timeout(cd->wait_q, (*cmd_state == 0),
|
|
msecs_to_jiffies(timeout_ms));
|
|
if (IS_TMO(t)) {
|
|
#ifdef TTDL_DIAGNOSTICS
|
|
cd->bus_transmit_error_count++;
|
|
pt_toggle_err_gpio(cd, PT_ERR_GPIO_I2C_TRANS);
|
|
#endif /* TTDL_DIAGNOSTICS */
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: HID output cmd execution timed out\n",
|
|
__func__);
|
|
rc = -ETIME;
|
|
goto error;
|
|
}
|
|
|
|
goto exit;
|
|
|
|
error:
|
|
mutex_lock(&cd->system_lock);
|
|
*cmd_state = 0;
|
|
mutex_unlock(&cd->system_lock);
|
|
|
|
exit:
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_hid_cmd_reset_
|
|
*
|
|
* SUMMARY: Send the HID RESET command to the DUT
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
******************************************************************************/
|
|
static int pt_hid_cmd_reset_(struct pt_core_data *cd)
|
|
{
|
|
struct pt_hid_cmd hid_cmd = {
|
|
.opcode = HID_CMD_RESET,
|
|
.wait_interrupt = 1,
|
|
.reset_cmd = 1,
|
|
.timeout_ms = PT_HID_CMD_DEFAULT_TIMEOUT,
|
|
};
|
|
|
|
return pt_hid_exec_cmd_and_wait_(cd, &hid_cmd);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_hid_cmd_reset
|
|
*
|
|
* SUMMARY: Wrapper function for pt_hid_cmd_reset_ that guarantees exclusive
|
|
* access.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
******************************************************************************/
|
|
static int pt_hid_cmd_reset(struct pt_core_data *cd)
|
|
{
|
|
int rc = 0;
|
|
|
|
rc = request_exclusive(cd, cd->dev, PT_REQUEST_EXCLUSIVE_TIMEOUT);
|
|
if (rc < 0) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail get exclusive ex=%p own=%p\n",
|
|
__func__, cd->exclusive_dev, cd->dev);
|
|
return rc;
|
|
}
|
|
|
|
pt_debug(cd->dev, DL_INFO, "%s: Send HID Reset command\n", __func__);
|
|
rc = pt_hid_cmd_reset_(cd);
|
|
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail to release exclusive\n", __func__);
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_hid_cmd_set_power_
|
|
*
|
|
* SUMMARY: Send hid cmd to set power state for the DUT and wait for response
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* power_state - power state to set(HID_POWER_ON/HID_POWER_SLEEP)
|
|
******************************************************************************/
|
|
static int pt_hid_cmd_set_power_(struct pt_core_data *cd,
|
|
u8 power_state)
|
|
{
|
|
int rc = 0;
|
|
struct pt_hid_cmd hid_cmd = {
|
|
.opcode = HID_CMD_SET_POWER,
|
|
.wait_interrupt = 1,
|
|
.timeout_ms = PT_HID_CMD_DEFAULT_TIMEOUT,
|
|
};
|
|
hid_cmd.power_state = power_state;
|
|
|
|
/* The chip won't give response if goes to Deep Standby */
|
|
if (power_state == HID_POWER_STANDBY) {
|
|
rc = pt_hid_exec_cmd_(cd, &hid_cmd);
|
|
if (rc)
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: Failed to set power to state:%d\n",
|
|
__func__, power_state);
|
|
else
|
|
cd->fw_sys_mode_in_standby_state = true;
|
|
return rc;
|
|
}
|
|
cd->fw_sys_mode_in_standby_state = false;
|
|
|
|
rc = pt_hid_exec_cmd_and_wait_(cd, &hid_cmd);
|
|
if (rc) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%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;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_hid_cmd_set_power
|
|
*
|
|
* SUMMARY: Wrapper function for pt_hid_cmd_set_power_ that guarantees
|
|
* exclusive access.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* power_state - power state to set(HID_POWER_ON/HID_POWER_SLEEP)
|
|
******************************************************************************/
|
|
static int pt_hid_cmd_set_power(struct pt_core_data *cd,
|
|
u8 power_state)
|
|
{
|
|
int rc;
|
|
|
|
rc = request_exclusive(cd, cd->dev, PT_REQUEST_EXCLUSIVE_TIMEOUT);
|
|
if (rc < 0) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail get exclusive ex=%p own=%p\n",
|
|
__func__, cd->exclusive_dev, cd->dev);
|
|
return rc;
|
|
}
|
|
|
|
rc = pt_hid_cmd_set_power_(cd, power_state);
|
|
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%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,
|
|
};
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_compute_crc
|
|
*
|
|
* SUMMARY: Calculate CRC by CRC table.
|
|
*
|
|
* RETURN:
|
|
* CRC calculation result
|
|
*
|
|
* PARAMETERS:
|
|
* *buf - pointer to the data array to be calculated
|
|
* size - size of data array
|
|
******************************************************************************/
|
|
static u16 _pt_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;
|
|
}
|
|
|
|
u16 ccitt_Table[] = {
|
|
0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7,
|
|
0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF,
|
|
0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6,
|
|
0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE,
|
|
0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485,
|
|
0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D,
|
|
0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4,
|
|
0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC,
|
|
0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823,
|
|
0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B,
|
|
0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12,
|
|
0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A,
|
|
0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41,
|
|
0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49,
|
|
0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70,
|
|
0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78,
|
|
0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F,
|
|
0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067,
|
|
0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E,
|
|
0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256,
|
|
0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D,
|
|
0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
|
|
0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C,
|
|
0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634,
|
|
0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB,
|
|
0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3,
|
|
0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A,
|
|
0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92,
|
|
0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9,
|
|
0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1,
|
|
0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8,
|
|
0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0,
|
|
};
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: crc_ccitt_calculate
|
|
*
|
|
* SUMMARY: Calculate CRC with ccitt standard by CRC table.
|
|
*
|
|
* RETURN:
|
|
* CRC calculation result
|
|
*
|
|
* PARAMETERS:
|
|
* *q - pointer to the data array to be calculated
|
|
* len - size of data array
|
|
******************************************************************************/
|
|
static unsigned short crc_ccitt_calculate(unsigned char *q, int len)
|
|
{
|
|
unsigned short crc = 0xffff;
|
|
|
|
while (len-- > 0)
|
|
crc = ccitt_Table[(crc >> 8 ^ *q++) & 0xff] ^ (crc << 8);
|
|
return crc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_pip2_cmd_calculate_crc
|
|
*
|
|
* SUMMARY: Calculate the CRC of a command packet
|
|
*
|
|
* RETURN: void
|
|
*
|
|
* PARAMETERS:
|
|
* *cmd - pointer to command data
|
|
* extra_bytes - Extra bytes included in command length
|
|
******************************************************************************/
|
|
static void pt_pip2_cmd_calculate_crc(struct pip2_cmd_structure *cmd,
|
|
u8 extra_bytes)
|
|
{
|
|
u8 buf[PT_MAX_PIP2_MSG_SIZE + 1] = {0};
|
|
unsigned short crc;
|
|
|
|
buf[0] = cmd->len & 0xff;
|
|
buf[1] = (cmd->len & 0xff00) >> 8;
|
|
buf[2] = cmd->seq;
|
|
buf[3] = cmd->id;
|
|
memcpy(&buf[4], cmd->data, cmd->len - extra_bytes);
|
|
/* Calculate the CRC for the first 4 bytes above and the data payload */
|
|
crc = crc_ccitt_calculate(buf, 4 + (cmd->len - extra_bytes));
|
|
cmd->crc[0] = (crc & 0xff00) >> 8;
|
|
cmd->crc[1] = (crc & 0xff);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_pip2_get_next_cmd_seq
|
|
*
|
|
* SUMMARY: Gets the next sequence number for a PIP2 command. The sequence
|
|
* number is a 3 bit value (bits [0-2]) but because TTDL will always have
|
|
* the TAG bit set (bit 3), the counter starts at 0x08 and goes to 0x0F.
|
|
* If the "force_pip2_seq" holds a valid seq value (0x08-0x0F) then do not
|
|
* increment, just use the forced value.
|
|
*
|
|
* RETURN: Next command sequence number [0x08-0x0F]
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
******************************************************************************/
|
|
static u8 pt_pip2_get_next_cmd_seq(struct pt_core_data *cd)
|
|
{
|
|
#ifdef TTDL_DIAGNOSTICS
|
|
if (cd->force_pip2_seq <= 0x07) {
|
|
cd->pip2_cmd_tag_seq++;
|
|
if (cd->pip2_cmd_tag_seq > 0x0F)
|
|
cd->pip2_cmd_tag_seq = 0x08;
|
|
} else {
|
|
cd->pip2_cmd_tag_seq = cd->force_pip2_seq;
|
|
}
|
|
#else
|
|
cd->pip2_cmd_tag_seq++;
|
|
if (cd->pip2_cmd_tag_seq > 0x0F)
|
|
cd->pip2_cmd_tag_seq = 0x08;
|
|
#endif
|
|
return cd->pip2_cmd_tag_seq;
|
|
}
|
|
|
|
/*
|
|
* Following macros are to define the response time (the interval between PIP2
|
|
* command finishes sending and INT pin falls). The unit is in microsecond.
|
|
* It has different time settings between the solution GPIO polling and Bus
|
|
* polling due to the considration for system load.
|
|
*/
|
|
#ifdef PT_POLL_RESP_BY_BUS
|
|
#define POLL_RETRY_DEFAULT_INTERVAL 50
|
|
#define PIP2_RESP_DEFAULT_TIME_MIN 50
|
|
#define PIP2_RESP_DEFAULT_TIME_MAX (PT_PIP_CMD_DEFAULT_TIMEOUT * 1000)
|
|
#define PIP2_RESP_FILE_WRITE_TIME_MIN 220
|
|
#define PIP2_RESP_FILE_IOCTL_TIME_MAX (PT_PIP2_CMD_FILE_ERASE_TIMEOUT * 1000)
|
|
#else
|
|
#define POLL_RETRY_DEFAULT_INTERVAL 20
|
|
#define PIP2_RESP_DEFAULT_TIME_MIN 20
|
|
#define PIP2_RESP_DEFAULT_TIME_MAX (PT_PIP_CMD_DEFAULT_TIMEOUT * 1000)
|
|
#define PIP2_RESP_FILE_WRITE_TIME_MIN 20
|
|
#define PIP2_RESP_FILE_IOCTL_TIME_MAX (PT_PIP2_CMD_FILE_ERASE_TIMEOUT * 1000)
|
|
#endif
|
|
/*
|
|
* id: the command id defined in PIP2
|
|
* response_len: the (maximum) length of response.
|
|
* response_time_min: minimum response time in microsecond
|
|
* response_time_max: maximum response time in microsecond
|
|
*/
|
|
static const struct pip2_cmd_response_structure pip2_cmd_response[] = {
|
|
{.id = PIP2_CMD_ID_PING,
|
|
.response_len = 255,
|
|
.response_time_min = PIP2_RESP_DEFAULT_TIME_MIN,
|
|
.response_time_max = PIP2_RESP_DEFAULT_TIME_MAX},
|
|
{.id = PIP2_CMD_ID_STATUS,
|
|
.response_len = PIP2_EXTRA_BYTES_NUM + 5,
|
|
.response_time_min = PIP2_RESP_DEFAULT_TIME_MIN,
|
|
.response_time_max = PIP2_RESP_DEFAULT_TIME_MAX},
|
|
{.id = PIP2_CMD_ID_CTRL,
|
|
.response_len = PIP2_EXTRA_BYTES_NUM + 1,
|
|
.response_time_min = PIP2_RESP_DEFAULT_TIME_MIN,
|
|
.response_time_max = PT_PIP2_CMD_FILE_ERASE_TIMEOUT},
|
|
{.id = PIP2_CMD_ID_CONFIG,
|
|
.response_len = PIP2_EXTRA_BYTES_NUM + 1,
|
|
.response_time_min = PIP2_RESP_DEFAULT_TIME_MIN,
|
|
.response_time_max = PIP2_RESP_DEFAULT_TIME_MAX},
|
|
{.id = PIP2_CMD_ID_CLEAR,
|
|
.response_len = PIP2_EXTRA_BYTES_NUM + 0,
|
|
.response_time_min = PIP2_RESP_DEFAULT_TIME_MIN,
|
|
.response_time_max = PIP2_RESP_DEFAULT_TIME_MAX},
|
|
{.id = PIP2_CMD_ID_RESET,
|
|
.response_len = PIP2_EXTRA_BYTES_NUM + 1,
|
|
.response_time_min = PIP2_RESP_DEFAULT_TIME_MIN,
|
|
.response_time_max = PIP2_RESP_DEFAULT_TIME_MAX},
|
|
{.id = PIP2_CMD_ID_VERSION,
|
|
.response_len = PIP2_EXTRA_BYTES_NUM + 23,
|
|
.response_time_min = PIP2_RESP_DEFAULT_TIME_MIN,
|
|
.response_time_max = PIP2_RESP_DEFAULT_TIME_MAX},
|
|
{.id = PIP2_CMD_ID_FILE_OPEN,
|
|
.response_len = PIP2_EXTRA_BYTES_NUM + 2,
|
|
.response_time_min = PIP2_RESP_DEFAULT_TIME_MIN,
|
|
.response_time_max = PIP2_RESP_DEFAULT_TIME_MAX},
|
|
{.id = PIP2_CMD_ID_FILE_CLOSE,
|
|
.response_len = PIP2_EXTRA_BYTES_NUM + 1,
|
|
.response_time_min = PIP2_RESP_DEFAULT_TIME_MIN,
|
|
.response_time_max = PIP2_RESP_DEFAULT_TIME_MAX},
|
|
{.id = PIP2_CMD_ID_FILE_READ,
|
|
.response_len = 255,
|
|
.response_time_min = PIP2_RESP_DEFAULT_TIME_MIN,
|
|
.response_time_max = PIP2_RESP_DEFAULT_TIME_MAX},
|
|
{.id = PIP2_CMD_ID_FILE_WRITE,
|
|
.response_len = PIP2_EXTRA_BYTES_NUM + 1,
|
|
.response_time_min = PIP2_RESP_FILE_WRITE_TIME_MIN,
|
|
.response_time_max = PIP2_RESP_DEFAULT_TIME_MAX},
|
|
{.id = PIP2_CMD_ID_FILE_IOCTL,
|
|
.response_len = PIP2_EXTRA_BYTES_NUM + 10,
|
|
.response_time_min = PIP2_RESP_DEFAULT_TIME_MIN,
|
|
.response_time_max = PIP2_RESP_FILE_IOCTL_TIME_MAX},
|
|
{.id = PIP2_CMD_ID_FLASH_INFO,
|
|
.response_len = PIP2_EXTRA_BYTES_NUM + 17,
|
|
.response_time_min = PIP2_RESP_DEFAULT_TIME_MIN,
|
|
.response_time_max = PIP2_RESP_DEFAULT_TIME_MAX},
|
|
{.id = PIP2_CMD_ID_EXECUTE,
|
|
.response_len = PIP2_EXTRA_BYTES_NUM + 1,
|
|
.response_time_min = PIP2_RESP_DEFAULT_TIME_MIN,
|
|
.response_time_max = PIP2_RESP_DEFAULT_TIME_MAX},
|
|
{.id = PIP2_CMD_ID_GET_LAST_ERRNO,
|
|
.response_len = PIP2_EXTRA_BYTES_NUM + 3,
|
|
.response_time_min = PIP2_RESP_DEFAULT_TIME_MIN,
|
|
.response_time_max = PIP2_RESP_DEFAULT_TIME_MAX},
|
|
{.id = PIP2_CMD_ID_EXIT_HOST_MODE,
|
|
.response_len = PIP2_EXTRA_BYTES_NUM + 1,
|
|
.response_time_min = PIP2_RESP_DEFAULT_TIME_MIN,
|
|
.response_time_max = PIP2_RESP_DEFAULT_TIME_MAX},
|
|
{.id = PIP2_CMD_ID_READ_GPIO,
|
|
.response_len = PIP2_EXTRA_BYTES_NUM + 5,
|
|
.response_time_min = PIP2_RESP_DEFAULT_TIME_MIN,
|
|
.response_time_max = PIP2_RESP_DEFAULT_TIME_MAX},
|
|
{.id = PIP2_CMD_EXECUTE_SCAN,
|
|
.response_len = PIP2_EXTRA_BYTES_NUM + 1,
|
|
.response_time_min = PIP2_RESP_DEFAULT_TIME_MIN,
|
|
.response_time_max = PIP2_RESP_DEFAULT_TIME_MAX},
|
|
{.id = PIP2_CMD_SET_PARAMETER,
|
|
.response_len = PIP2_EXTRA_BYTES_NUM + 1,
|
|
.response_time_min = PIP2_RESP_DEFAULT_TIME_MIN,
|
|
.response_time_max = PIP2_RESP_DEFAULT_TIME_MAX},
|
|
{.id = PIP2_CMD_GET_PARAMETER,
|
|
.response_len = PIP2_EXTRA_BYTES_NUM + 7,
|
|
.response_time_min = PIP2_RESP_DEFAULT_TIME_MIN,
|
|
.response_time_max = PIP2_RESP_DEFAULT_TIME_MAX},
|
|
{.id = PIP2_CMD_SET_DDI_REG,
|
|
.response_len = PIP2_EXTRA_BYTES_NUM + 1,
|
|
.response_time_min = PIP2_RESP_DEFAULT_TIME_MIN,
|
|
.response_time_max = PIP2_RESP_DEFAULT_TIME_MAX},
|
|
{.id = PIP2_CMD_GET_DDI_REG,
|
|
.response_len = PIP2_EXTRA_BYTES_NUM + 249,
|
|
.response_time_min = PIP2_RESP_DEFAULT_TIME_MIN,
|
|
.response_time_max = PIP2_RESP_DEFAULT_TIME_MAX},
|
|
{.id = PIP2_CMD_ID_END,
|
|
.response_len = 255,
|
|
.response_time_min = PIP2_RESP_DEFAULT_TIME_MIN,
|
|
.response_time_max = PIP2_RESP_DEFAULT_TIME_MAX}
|
|
};
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_pip2_get_cmd_response_len
|
|
*
|
|
* SUMMARY: Gets the expected response length based on the command ID
|
|
*
|
|
* RETURN: Expected response length
|
|
*
|
|
* PARAMETERS:
|
|
* id - Command ID (-1 means input ID is not in list of PIP2 command)
|
|
******************************************************************************/
|
|
static int pt_pip2_get_cmd_response_len(u8 id)
|
|
{
|
|
const struct pip2_cmd_response_structure *p = pip2_cmd_response;
|
|
|
|
while ((p->id != id) && (p->id != PIP2_CMD_ID_END))
|
|
p++;
|
|
|
|
if (p->id != PIP2_CMD_ID_END)
|
|
return p->response_len;
|
|
else
|
|
return -1;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_pip2_get_cmd_resp_time_min
|
|
*
|
|
* SUMMARY: Gets the minimum response time (the interval between PIP2 command
|
|
* finishes sending and INT pin falls) based on the command ID
|
|
*
|
|
* RETURN: Estimated minimum response time in microsecond
|
|
*
|
|
* PARAMETERS:
|
|
* id - Command ID
|
|
******************************************************************************/
|
|
static u32 pt_pip2_get_cmd_resp_time_min(u8 id)
|
|
{
|
|
const struct pip2_cmd_response_structure *p = pip2_cmd_response;
|
|
|
|
while ((p->id != id) && (p->id != PIP2_CMD_ID_END))
|
|
p++;
|
|
|
|
if (p->id != PIP2_CMD_ID_END)
|
|
return p->response_time_min;
|
|
else
|
|
return PIP2_RESP_DEFAULT_TIME_MIN;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_pip2_get_cmd_resp_time_max
|
|
*
|
|
* SUMMARY: Gets the maximum response time (the interval between PIP2 command
|
|
* finishes sending and INT pin falls) based on the command ID
|
|
*
|
|
* RETURN: Estimated maximum response time in microsecond
|
|
*
|
|
* PARAMETERS:
|
|
* id - Command ID
|
|
******************************************************************************/
|
|
static u32 pt_pip2_get_cmd_resp_time_max(u8 id)
|
|
{
|
|
const struct pip2_cmd_response_structure *p = pip2_cmd_response;
|
|
|
|
while ((p->id != id) && (p->id != PIP2_CMD_ID_END))
|
|
p++;
|
|
|
|
if (p->id != PIP2_CMD_ID_END)
|
|
return p->response_time_max;
|
|
else
|
|
return PIP2_RESP_DEFAULT_TIME_MAX;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_pip2_validate_response
|
|
*
|
|
* SUMMARY: Validate the response of PIP2 command.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* *pip2_cmd - pointer to PIP2 command to send
|
|
* *read_buf - pointer to response buffer
|
|
* actual_read_len - actual read length of the response
|
|
******************************************************************************/
|
|
static int pt_pip2_validate_response(struct pt_core_data *cd,
|
|
struct pip2_cmd_structure *pip2_cmd, u8 *read_buf,
|
|
u16 actual_read_len)
|
|
{
|
|
int rc = 0;
|
|
u8 response_seq = 0;
|
|
u8 reserved_bits = 0;
|
|
u8 cmd_id = 0;
|
|
u8 response_bit = 0;
|
|
unsigned short calc_crc = 0;
|
|
unsigned short resp_crc = 0;
|
|
|
|
/* Verify the length of response buffer */
|
|
if (actual_read_len < PT_MIN_PIP2_PACKET_SIZE) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s cmd[0x%02X] read lenght ERR: read_len = %d\n",
|
|
__func__, pip2_cmd->id, actual_read_len);
|
|
rc = -EINVAL;
|
|
goto exit;
|
|
}
|
|
|
|
/* Verify the CRC */
|
|
calc_crc = crc_ccitt_calculate(read_buf, actual_read_len - 2);
|
|
resp_crc = read_buf[actual_read_len - 2] << 8;
|
|
resp_crc |= read_buf[actual_read_len - 1];
|
|
if (resp_crc != calc_crc) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: cmd[0x%02X] CRC ERR: calc=0x%04X rsp=0x%04X\n",
|
|
__func__, pip2_cmd->id, calc_crc, resp_crc);
|
|
#ifdef TTDL_DIAGNOSTICS
|
|
cd->pip2_crc_error_count++;
|
|
#endif /* TTDL_DIAGNOSTICS */
|
|
rc = -EINVAL;
|
|
goto exit;
|
|
}
|
|
|
|
/* Verify the response bit is set */
|
|
response_bit = read_buf[PIP2_RESP_REPORT_ID_OFFSET] & 0x80;
|
|
if (!response_bit) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s cmd[0x%02X] response bit ERR: response_bit = %d\n",
|
|
__func__, pip2_cmd->id, response_bit);
|
|
rc = -EINVAL;
|
|
goto exit;
|
|
}
|
|
|
|
/* Verify the command ID matches from command to response */
|
|
cmd_id = read_buf[PIP2_RESP_REPORT_ID_OFFSET] & 0x7F;
|
|
if (cmd_id != pip2_cmd->id) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s cmd[0x%02X] command ID ERR: cmd_id = 0x%02X\n",
|
|
__func__, pip2_cmd->id, cmd_id);
|
|
rc = -EINVAL;
|
|
goto exit;
|
|
}
|
|
|
|
/* Verify the SEQ number matches from command to response */
|
|
response_seq = read_buf[PIP2_RESP_SEQUENCE_OFFSET] & 0x0F;
|
|
if ((pip2_cmd->seq & 0x0F) != response_seq) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s cmd[0x%02X] send_seq = 0x%02X, resp_seq = 0x%02X\n",
|
|
__func__, pip2_cmd->id,
|
|
pip2_cmd->seq, response_seq);
|
|
rc = -EINVAL;
|
|
goto exit;
|
|
}
|
|
|
|
/* Verify the reserved bits are 0 */
|
|
reserved_bits = read_buf[PIP2_RESP_SEQUENCE_OFFSET] & 0xF0;
|
|
if (reserved_bits)
|
|
pt_debug(cd->dev, DL_WARN,
|
|
"%s cmd[0x%02X] reserved_bits = 0x%02X\n",
|
|
__func__, pip2_cmd->id, reserved_bits);
|
|
|
|
exit:
|
|
if (rc)
|
|
pt_pr_buf(cd->dev, DL_WARN, cd->input_buf, actual_read_len,
|
|
"PIP RSP:");
|
|
return rc;
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_hid_output_validate_bl_response
|
|
*
|
|
* SUMMARY: Validate the response of bootloader command.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* *hid_output - pointer to hid output data structure
|
|
******************************************************************************/
|
|
static int pt_hid_output_validate_bl_response(
|
|
struct pt_core_data *cd,
|
|
struct pt_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[PIP1_RESP_REPORT_ID_OFFSET]
|
|
!= PT_PIP_BL_RESPONSE_REPORT_ID) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: BL output response, wrong report_id\n", __func__);
|
|
return -EPROTO;
|
|
}
|
|
|
|
if (cd->response_buf[4] != PIP1_BL_SOP) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: BL output response, wrong SOP\n", __func__);
|
|
return -EPROTO;
|
|
}
|
|
|
|
if (cd->response_buf[size - 1] != PIP1_BL_EOP) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: BL output response, wrong EOP\n", __func__);
|
|
return -EPROTO;
|
|
}
|
|
|
|
crc = _pt_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)) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: BL output response, wrong CRC 0x%X\n",
|
|
__func__, crc);
|
|
return -EPROTO;
|
|
}
|
|
|
|
status = cd->response_buf[5];
|
|
if (status) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: BL output response, ERROR:%d\n",
|
|
__func__, status);
|
|
return -EPROTO;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_hid_output_validate_app_response
|
|
*
|
|
* SUMMARY: Validate the response of application command.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* *hid_output - pointer to hid output data structure
|
|
******************************************************************************/
|
|
static int pt_hid_output_validate_app_response(
|
|
struct pt_core_data *cd,
|
|
struct pt_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[PIP1_RESP_REPORT_ID_OFFSET]
|
|
!= PT_PIP_NON_HID_RESPONSE_ID) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: APP output response, wrong report_id\n", __func__);
|
|
return -EPROTO;
|
|
}
|
|
|
|
command_code = cd->response_buf[PIP1_RESP_COMMAND_ID_OFFSET]
|
|
& PIP1_RESP_COMMAND_ID_MASK;
|
|
if (command_code != hid_output->command_code) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: APP output response, wrong command_code:%X\n",
|
|
__func__, command_code);
|
|
return -EPROTO;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_check_set_parameter
|
|
*
|
|
* SUMMARY: Check command input and response for Set Parameter command.And
|
|
* store the parameter to the list for resume work if pass the check.
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* *hid_output - pointer to hid output data structure
|
|
* raw - flag to show if output cmd is user cmd(1:user cmd)
|
|
******************************************************************************/
|
|
static void pt_check_set_parameter(struct pt_core_data *cd,
|
|
struct pt_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 & PT_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] ==
|
|
PT_PIP_NON_HID_COMMAND_ID
|
|
&& hid_output->write_buf[6] ==
|
|
PIP1_CMD_ID_SET_PARAM)
|
|
param_buf = &hid_output->write_buf[7];
|
|
else if (!raw && hid_output->cmd_type == PIP1_CMD_TYPE_FW
|
|
&& hid_output->command_code == PIP1_CMD_ID_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) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%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] != PT_PIP_NON_HID_RESPONSE_ID
|
|
|| (cd->response_buf[4] &
|
|
PIP1_RESP_COMMAND_ID_MASK) !=
|
|
PIP1_CMD_ID_SET_PARAM
|
|
|| cd->response_buf[5] != param_id
|
|
|| cd->response_buf[6] != param_size) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: Set Parameter command not successful\n",
|
|
__func__);
|
|
return;
|
|
}
|
|
|
|
pt_add_parameter(cd, param_id, param_value, param_size);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_check_command
|
|
*
|
|
* SUMMARY: Check the output command. The function pt_check_set_parameter() is
|
|
* called here to check output command and store parameter to the list.
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* *hid_output - pointer to hid output data structure
|
|
* raw - flag to show if output cmd is user cmd(1:user cmd)
|
|
******************************************************************************/
|
|
static void pt_check_command(struct pt_core_data *cd,
|
|
struct pt_hid_output *hid_output, bool raw)
|
|
{
|
|
pt_check_set_parameter(cd, hid_output, raw);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_hid_output_validate_response
|
|
*
|
|
* SUMMARY: Validate the response of application or bootloader command.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* *hid_output - pointer to hid output data structure
|
|
******************************************************************************/
|
|
static int pt_hid_output_validate_response(struct pt_core_data *cd,
|
|
struct pt_hid_output *hid_output)
|
|
{
|
|
if (hid_output->cmd_type == PIP1_CMD_TYPE_BL)
|
|
return pt_hid_output_validate_bl_response(cd, hid_output);
|
|
|
|
return pt_hid_output_validate_app_response(cd, hid_output);
|
|
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_hid_send_output_user_
|
|
*
|
|
* SUMMARY: Blindly send user data to the DUT.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* *hid_output - pointer to the command to send
|
|
******************************************************************************/
|
|
static int pt_hid_send_output_user_(struct pt_core_data *cd,
|
|
struct pt_hid_output *hid_output)
|
|
{
|
|
int rc = 0;
|
|
int cmd;
|
|
|
|
if (!hid_output->length || !hid_output->write_buf)
|
|
return -EINVAL;
|
|
|
|
if (cd->pip2_prot_active) {
|
|
cmd = hid_output->write_buf[PIP2_CMD_COMMAND_ID_OFFSET];
|
|
cmd &= PIP2_CMD_COMMAND_ID_MASK;
|
|
} else
|
|
cmd = hid_output->write_buf[PIP1_CMD_COMMAND_ID_OFFSET];
|
|
|
|
pt_debug(cd->dev, DL_INFO,
|
|
">>> %s: Write Buffer Size[%d] Cmd[0x%02X]\n",
|
|
__func__, hid_output->length, cmd);
|
|
pt_pr_buf(cd->dev, DL_DEBUG, hid_output->write_buf,
|
|
hid_output->length, ">>> User CMD");
|
|
|
|
rc = pt_adap_write_read_specific(cd, hid_output->length,
|
|
hid_output->write_buf, NULL);
|
|
if (rc)
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: Fail pt_adap_transfer\n", __func__);
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_hid_send_output_user_and_wait_
|
|
*
|
|
* SUMMARY: Blindly send user data to the DUT and wait for the response.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* *hid_output - pointer to the command to send
|
|
******************************************************************************/
|
|
static int pt_hid_send_output_user_and_wait_(struct pt_core_data *cd,
|
|
struct pt_hid_output *hid_output)
|
|
{
|
|
int rc = 0;
|
|
int t;
|
|
|
|
mutex_lock(&cd->system_lock);
|
|
cd->hid_cmd_state = PIP1_CMD_ID_USER_CMD + 1;
|
|
mutex_unlock(&cd->system_lock);
|
|
|
|
rc = pt_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(cd->pip_cmd_timeout));
|
|
if (IS_TMO(t)) {
|
|
#ifdef TTDL_DIAGNOSTICS
|
|
cd->bus_transmit_error_count++;
|
|
pt_toggle_err_gpio(cd, PT_ERR_GPIO_I2C_TRANS);
|
|
#endif /* TTDL_DIAGNOSTICS */
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: HID output cmd execution timed out\n",
|
|
__func__);
|
|
rc = -ETIME;
|
|
goto error;
|
|
}
|
|
|
|
pt_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;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_check_irq_asserted
|
|
*
|
|
* SUMMARY: Checks if the IRQ GPIO is asserted or not. There are times when
|
|
* the FW can hold the INT line low ~150us after the read is complete.
|
|
* NOTE: if irq_stat is not defined this function will return false
|
|
*
|
|
* RETURN:
|
|
* true = IRQ asserted
|
|
* false = IRQ not asserted
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
******************************************************************************/
|
|
static bool pt_check_irq_asserted(struct pt_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 == PIP1_BL_CMD_ID_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);
|
|
}
|
|
#endif
|
|
if (cd->cpdata->irq_stat) {
|
|
if (cd->cpdata->irq_stat(cd->cpdata, cd->dev)
|
|
== PT_IRQ_ASSERTED_VALUE) {
|
|
/* Debounce to allow FW to release INT */
|
|
usleep_range(100, 200);
|
|
}
|
|
if (cd->cpdata->irq_stat(cd->cpdata, cd->dev)
|
|
== PT_IRQ_ASSERTED_VALUE)
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_flush_bus
|
|
*
|
|
* SUMMARY: Force flushing the bus by reading len bytes or forced 255 bytes
|
|
* Used if IRQ is found to be stuck low
|
|
*
|
|
* RETURN: Length of bytes read from bus
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* flush_type - type of flush
|
|
* - PT_FLUSH_BUS_BASED_ON_LEN (two reads)
|
|
* - PT_FLUSH_BUS_FULL_256_READ
|
|
* *read_buf - pointer to store read data
|
|
******************************************************************************/
|
|
static ssize_t pt_flush_bus(struct pt_core_data *cd,
|
|
u8 flush_type, u8 *read_buf)
|
|
{
|
|
u8 buf[PT_MAX_PIP2_MSG_SIZE];
|
|
u16 pip_len;
|
|
int bytes_read;
|
|
int rc = 0;
|
|
|
|
if (flush_type == PT_FLUSH_BUS_BASED_ON_LEN) {
|
|
rc = pt_adap_read_default(cd, buf, 2);
|
|
if (rc) {
|
|
bytes_read = 0;
|
|
goto exit;
|
|
}
|
|
|
|
pip_len = get_unaligned_le16(&buf[0]);
|
|
|
|
if (pip_len == 2 || pip_len >= PT_PIP_1P7_EMPTY_BUF) {
|
|
#ifdef TTDL_DIAGNOSTICS
|
|
pt_toggle_err_gpio(cd, PT_ERR_GPIO_EMPTY_PACKET);
|
|
#endif
|
|
bytes_read = 2;
|
|
pt_debug(cd->dev, DL_INFO,
|
|
"%s: Empty buf detected - len=0x%04X\n",
|
|
__func__, pip_len);
|
|
} else if (pip_len == 0) {
|
|
bytes_read = 0;
|
|
pt_debug(cd->dev, DL_INFO,
|
|
"%s: Sentinel detected\n", __func__);
|
|
} else if (pip_len > PT_MAX_PIP2_MSG_SIZE) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: Illegal len=0x%04x, force %d byte read\n",
|
|
__func__, pip_len, PT_MAX_PIP2_MSG_SIZE);
|
|
rc = pt_adap_read_default(cd, buf,
|
|
PT_MAX_PIP2_MSG_SIZE);
|
|
if (!rc)
|
|
bytes_read = PT_MAX_PIP2_MSG_SIZE;
|
|
else
|
|
bytes_read = 0;
|
|
} else {
|
|
pt_debug(cd->dev, DL_INFO,
|
|
"%s: Flush read of %d bytes...\n",
|
|
__func__, pip_len);
|
|
|
|
rc = pt_adap_read_default(cd, buf, pip_len);
|
|
if (!rc)
|
|
bytes_read = pip_len;
|
|
else
|
|
bytes_read = 0;
|
|
}
|
|
} else {
|
|
pt_debug(cd->dev, DL_INFO,
|
|
"%s: Forced flush of max %d bytes...\n",
|
|
__func__, PT_MAX_PIP2_MSG_SIZE);
|
|
rc = pt_adap_read_default(cd, buf, PT_MAX_PIP2_MSG_SIZE);
|
|
if (!rc)
|
|
bytes_read = PT_MAX_PIP2_MSG_SIZE;
|
|
else
|
|
bytes_read = 0;
|
|
}
|
|
|
|
if (read_buf && (bytes_read > 3))
|
|
memcpy(read_buf, buf, bytes_read);
|
|
|
|
exit:
|
|
return bytes_read;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_flush_bus_if_irq_asserted
|
|
*
|
|
* SUMMARY: This function will flush the active bus if the INT is found to be
|
|
* asserted.
|
|
*
|
|
* RETURN: bytes cleared from bus
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer the core data structure
|
|
* flush_type - type of flush
|
|
* - PT_FLUSH_BUS_BASED_ON_LEN
|
|
* - PT_FLUSH_BUS_FULL_256_READ
|
|
******************************************************************************/
|
|
static int pt_flush_bus_if_irq_asserted(struct pt_core_data *cd, u8 flush_type)
|
|
{
|
|
int count = 0;
|
|
int bytes_read = 0;
|
|
|
|
while (pt_check_irq_asserted(cd) && count < 5) {
|
|
count++;
|
|
bytes_read = pt_flush_bus(cd, flush_type, NULL);
|
|
if (bytes_read) {
|
|
pt_debug(cd->dev, DL_WARN,
|
|
"%s: Cleared %d bytes off bus\n",
|
|
__func__, bytes_read);
|
|
}
|
|
}
|
|
if (pt_check_irq_asserted(cd)) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: IRQ still asserted, %d bytes read\n",
|
|
__func__, bytes_read);
|
|
} else {
|
|
pt_debug(cd->dev, DL_INFO,
|
|
"%s: IRQ cleared, %d bytes read\n",
|
|
__func__, bytes_read);
|
|
}
|
|
return bytes_read;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_hid_send_output_
|
|
*
|
|
* SUMMARY: Send a touch application command to the DUT
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* *hid_output - pointer to the command to send
|
|
******************************************************************************/
|
|
static int pt_hid_send_output_(struct pt_core_data *cd,
|
|
struct pt_hid_output *hid_output)
|
|
{
|
|
int rc = 0;
|
|
u8 *cmd;
|
|
u16 length;
|
|
u16 crc;
|
|
u8 report_id;
|
|
u8 cmd_offset = 0;
|
|
u8 cmd_allocated = 0;
|
|
|
|
|
|
switch (hid_output->cmd_type) {
|
|
case PIP1_CMD_TYPE_FW:
|
|
report_id = PT_PIP_NON_HID_COMMAND_ID;
|
|
length = 5;
|
|
break;
|
|
case PIP1_CMD_TYPE_BL:
|
|
report_id = PT_PIP_BL_COMMAND_REPORT_ID;
|
|
length = 11 /* 5 + SOP + LEN(2) + CRC(2) + EOP */;
|
|
break;
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
|
|
length += hid_output->write_length;
|
|
|
|
if (length + 2 > PT_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 == PIP1_CMD_TYPE_BL)
|
|
cmd[cmd_offset++] = PIP1_BL_SOP;
|
|
cmd[cmd_offset++] = hid_output->command_code;
|
|
|
|
/* Set Data Length for bootloader */
|
|
if (hid_output->cmd_type == PIP1_CMD_TYPE_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 == PIP1_CMD_TYPE_BL) {
|
|
crc = _pt_compute_crc(&cmd[6],
|
|
hid_output->write_length + 4);
|
|
cmd[cmd_offset++] = LOW_BYTE(crc);
|
|
cmd[cmd_offset++] = HI_BYTE(crc);
|
|
cmd[cmd_offset++] = PIP1_BL_EOP;
|
|
}
|
|
|
|
pt_debug(cd->dev, DL_INFO,
|
|
">>> %s: Write Buffer Size[%d] Cmd[0x%02X]\n",
|
|
__func__, length + 2, hid_output->command_code);
|
|
pt_pr_buf(cd->dev, DL_DEBUG, cmd, length + 2, ">>> CMD");
|
|
rc = pt_adap_write_read_specific(cd, length + 2, cmd, NULL);
|
|
|
|
if (rc)
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: Fail pt_adap_transfer rc=%d\n", __func__, rc);
|
|
|
|
if (cmd_allocated)
|
|
kfree(cmd);
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_pip1_send_output_and_wait_
|
|
*
|
|
* SUMMARY: Send valid PIP1 command to the DUT and wait for the response.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* *hid_output - pointer to the command to send
|
|
******************************************************************************/
|
|
static int pt_pip1_send_output_and_wait_(struct pt_core_data *cd,
|
|
struct pt_hid_output *hid_output)
|
|
{
|
|
int rc = 0;
|
|
int t;
|
|
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 = PT_PIP1_CMD_DEFAULT_TIMEOUT;
|
|
|
|
rc = pt_hid_send_output_(cd, hid_output);
|
|
if (rc)
|
|
goto error;
|
|
|
|
t = wait_event_timeout(cd->wait_q, (cd->hid_cmd_state == 0),
|
|
msecs_to_jiffies(timeout_ms));
|
|
if (IS_TMO(t)) {
|
|
#ifdef TTDL_DIAGNOSTICS
|
|
cd->bus_transmit_error_count++;
|
|
pt_toggle_err_gpio(cd, PT_ERR_GPIO_I2C_TRANS);
|
|
#endif /* TTDL_DIAGNOSTICS */
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: HID output cmd execution timed out (%dms)\n",
|
|
__func__, timeout_ms);
|
|
rc = -ETIME;
|
|
goto error;
|
|
}
|
|
|
|
if (!hid_output->novalidate)
|
|
rc = pt_hid_output_validate_response(cd, hid_output);
|
|
|
|
pt_check_command(cd, hid_output, false);
|
|
goto exit;
|
|
|
|
error:
|
|
mutex_lock(&cd->system_lock);
|
|
cd->hid_cmd_state = 0;
|
|
mutex_unlock(&cd->system_lock);
|
|
exit:
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_hid_output_user_cmd_
|
|
*
|
|
* SUMMARY: Load the write buffer into a HID structure and send it as a HID cmd
|
|
* to the DUT waiting for the response and loading it into the read buffer
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* read_len - expected read length of the response
|
|
* *read_buf - pointer to where the response will be loaded
|
|
* write_len - length of the write buffer
|
|
* *write_buf - pointer to the write buffer
|
|
* *actual_read_len - pointer to the actual amount of data read back
|
|
******************************************************************************/
|
|
static int pt_hid_output_user_cmd_(struct pt_core_data *cd,
|
|
u16 read_len, u8 *read_buf, u16 write_len, u8 *write_buf,
|
|
u16 *actual_read_len)
|
|
{
|
|
int rc = 0;
|
|
u16 size;
|
|
struct pt_hid_output hid_output = {
|
|
.length = write_len,
|
|
.write_buf = write_buf,
|
|
};
|
|
|
|
#ifdef TTHE_TUNER_SUPPORT
|
|
if (!cd->pip2_send_user_cmd) {
|
|
int command_code = 0;
|
|
int len;
|
|
|
|
/* Print up to cmd ID */
|
|
len = PIP1_CMD_COMMAND_ID_OFFSET + 1;
|
|
if (write_len < len)
|
|
len = write_len;
|
|
else
|
|
command_code = write_buf[PIP1_CMD_COMMAND_ID_OFFSET]
|
|
& PIP1_CMD_COMMAND_ID_MASK;
|
|
|
|
/* Don't print EXEC_PANEL_SCAN & RETRIEVE_PANEL_SCAN commands */
|
|
if (command_code != PIP1_CMD_ID_EXEC_PANEL_SCAN &&
|
|
command_code != PIP1_CMD_ID_RETRIEVE_PANEL_SCAN)
|
|
tthe_print(cd, write_buf, len, "CMD=");
|
|
}
|
|
#endif
|
|
|
|
rc = pt_hid_send_output_user_and_wait_(cd, &hid_output);
|
|
if (rc)
|
|
return rc;
|
|
|
|
/* Get the response size from the first 2 bytes in the response */
|
|
size = get_unaligned_le16(&cd->response_buf[0]);
|
|
|
|
/* Ensure size is not greater than max buffer size */
|
|
if (size > PT_MAX_PIP2_MSG_SIZE)
|
|
size = PT_MAX_PIP2_MSG_SIZE;
|
|
|
|
/* Minimum size to read is the 2 byte len field */
|
|
if (size == 0)
|
|
size = 2;
|
|
|
|
if (size > read_len) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: PIP2 len field=%d, requested read_len=%d\n",
|
|
__func__, size, read_len);
|
|
*actual_read_len = 0;
|
|
return -EIO;
|
|
}
|
|
|
|
memcpy(read_buf, cd->response_buf, size);
|
|
*actual_read_len = size;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_hid_output_user_cmd
|
|
*
|
|
* SUMMARY: Protected call to pt_hid_output_user_cmd_ by exclusive access to
|
|
* the DUT.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* read_len - length of data to read
|
|
* *read_buf - pointer to store read data
|
|
* write_len - length of data to write
|
|
* *write_buf - pointer to buffer to write
|
|
* *actual_read_len - pointer to store data length actually read
|
|
******************************************************************************/
|
|
static int pt_hid_output_user_cmd(struct pt_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, PT_REQUEST_EXCLUSIVE_TIMEOUT);
|
|
if (rc < 0) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail get exclusive ex=%p own=%p\n",
|
|
__func__, cd->exclusive_dev, cd->dev);
|
|
return rc;
|
|
}
|
|
|
|
rc = pt_hid_output_user_cmd_(cd, read_len, read_buf,
|
|
write_len, write_buf, actual_read_len);
|
|
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail to release exclusive\n", __func__);
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_request_pip2_send_cmd
|
|
*
|
|
* SUMMARY: Writes a PIP2 command packet to DUT, then waits for the
|
|
* interrupt and reads response data to read_buf
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* protect - flag to run in protected mode
|
|
* id - ID of PIP command
|
|
* *data - pointer to PIP data payload
|
|
* report_body_len - report length
|
|
* *read_buf - pointer to response buffer
|
|
* *actual_read_len - pointer to response buffer length
|
|
******************************************************************************/
|
|
static int _pt_request_pip2_send_cmd(struct device *dev,
|
|
int protect, u8 id, u8 *data, u16 report_body_len, u8 *read_buf,
|
|
u16 *actual_read_len)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
struct pip2_cmd_structure pip2_cmd;
|
|
int rc = 0;
|
|
int i = 0;
|
|
int j = 0;
|
|
u16 write_len;
|
|
u8 *write_buf = NULL;
|
|
u16 read_len;
|
|
u8 extra_bytes;
|
|
|
|
memset(&pip2_cmd, 0, sizeof(pip2_cmd));
|
|
|
|
/* Hard coded register for PIP2.x */
|
|
pip2_cmd.reg[0] = 0x01;
|
|
pip2_cmd.reg[1] = 0x01;
|
|
|
|
/*
|
|
* For PIP2.1+ the length field value includes itself:
|
|
* ADD 6: 2 (LEN) + 1 (SEQ) + 1 (REPORT ID) + 2 (CRC)
|
|
*
|
|
* The overall write length must include only the register:
|
|
* ADD 2: 2 (Register)
|
|
*/
|
|
extra_bytes = 6;
|
|
write_len = 2;
|
|
|
|
/* PIP2 the CMD ID is a 7bit field */
|
|
if (id > PIP2_CMD_ID_END) {
|
|
pt_debug(dev, DL_WARN, "%s: Invalid PIP2 CMD ID 0x%02X\n",
|
|
__func__, id);
|
|
rc = -EINVAL;
|
|
goto exit;
|
|
}
|
|
|
|
pip2_cmd.len = report_body_len + extra_bytes;
|
|
pip2_cmd.id = id & PIP2_CMD_COMMAND_ID_MASK;
|
|
pip2_cmd.seq = pt_pip2_get_next_cmd_seq(cd);
|
|
pip2_cmd.data = data;
|
|
pt_pip2_cmd_calculate_crc(&pip2_cmd, extra_bytes);
|
|
|
|
/* Add the command length to the extra bytes based on PIP version */
|
|
write_len += pip2_cmd.len;
|
|
|
|
pt_debug(dev, DL_INFO, "%s Length Field: %d, Write Len: %d",
|
|
__func__, pip2_cmd.len, write_len);
|
|
|
|
write_buf = kzalloc(write_len, GFP_KERNEL);
|
|
if (write_buf == NULL) {
|
|
rc = -ENOMEM;
|
|
goto exit;
|
|
}
|
|
|
|
write_buf[i++] = pip2_cmd.reg[0];
|
|
write_buf[i++] = pip2_cmd.reg[1];
|
|
write_buf[i++] = pip2_cmd.len & 0xff;
|
|
write_buf[i++] = (pip2_cmd.len & 0xff00) >> 8;
|
|
write_buf[i++] = pip2_cmd.seq;
|
|
write_buf[i++] = pip2_cmd.id;
|
|
|
|
for (j = i; j < i + pip2_cmd.len - extra_bytes; j++)
|
|
write_buf[j] = pip2_cmd.data[j-i];
|
|
write_buf[j++] = pip2_cmd.crc[0];
|
|
write_buf[j++] = pip2_cmd.crc[1];
|
|
|
|
read_len = pt_pip2_get_cmd_response_len(pip2_cmd.id);
|
|
if (read_len < 0)
|
|
read_len = 255;
|
|
pt_debug(dev, DL_INFO,
|
|
"%s cmd_id[0x%02X] expected response length:%d ",
|
|
__func__, pip2_cmd.id, read_len);
|
|
|
|
/*
|
|
* All PIP2 commands come through this function.
|
|
* Set flag for PIP2.x interface to allow response parsing to know
|
|
* how to decode the protocol header.
|
|
*/
|
|
mutex_lock(&cd->system_lock);
|
|
cd->pip2_prot_active = true;
|
|
cd->pip2_send_user_cmd = true;
|
|
mutex_unlock(&cd->system_lock);
|
|
|
|
if (protect == PT_CORE_CMD_PROTECTED)
|
|
rc = pt_hid_output_user_cmd(cd, read_len, read_buf,
|
|
write_len, write_buf, actual_read_len);
|
|
else
|
|
rc = pt_hid_output_user_cmd_(cd, read_len, read_buf,
|
|
write_len, write_buf, actual_read_len);
|
|
if (rc) {
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s: nonhid_cmd->user_cmd() Error = %d\n",
|
|
__func__, rc);
|
|
goto exit;
|
|
}
|
|
|
|
rc = pt_pip2_validate_response(cd, &pip2_cmd, read_buf,
|
|
*actual_read_len);
|
|
|
|
exit:
|
|
mutex_lock(&cd->system_lock);
|
|
cd->pip2_prot_active = false;
|
|
cd->pip2_send_user_cmd = false;
|
|
mutex_unlock(&cd->system_lock);
|
|
kfree(write_buf);
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_pip2_send_cmd_no_int
|
|
*
|
|
* SUMMARY: Writes a PIP2 command packet to DUT, then poll the response and
|
|
* reads response data to read_buf if response is available.
|
|
*
|
|
* NOTE:
|
|
* Interrupt MUST be disabled before to call this function.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* protect - flag to run in protected mode
|
|
* id - ID of PIP command
|
|
* *data - pointer to PIP data payload
|
|
* report_body_len - report length
|
|
* *read_buf - pointer to response buffer
|
|
* *actual_read_len - pointer to response buffer length
|
|
******************************************************************************/
|
|
static int _pt_pip2_send_cmd_no_int(struct device *dev,
|
|
int protect, u8 id, u8 *data, u16 report_body_len, u8 *read_buf,
|
|
u16 *actual_read_len)
|
|
{
|
|
int max_retry = 0;
|
|
int retry = 0;
|
|
int rc = 0;
|
|
int i = 0;
|
|
int j = 0;
|
|
u16 write_len;
|
|
u8 *write_buf = NULL;
|
|
u16 read_len;
|
|
u16 size = 0;
|
|
u8 response_seq = 0;
|
|
u8 extra_bytes;
|
|
u32 retry_interval = 0;
|
|
u32 retry_total_time = 0;
|
|
u32 resp_time_min = pt_pip2_get_cmd_resp_time_min(id);
|
|
u32 resp_time_max = pt_pip2_get_cmd_resp_time_max(id);
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
struct pip2_cmd_structure pip2_cmd;
|
|
|
|
if (protect == PT_CORE_CMD_PROTECTED) {
|
|
rc = request_exclusive(cd,
|
|
cd->dev, PT_REQUEST_EXCLUSIVE_TIMEOUT);
|
|
if (rc < 0) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail get exclusive ex=%p own=%p\n",
|
|
__func__, cd->exclusive_dev, cd->dev);
|
|
return rc;
|
|
}
|
|
}
|
|
|
|
memset(&pip2_cmd, 0, sizeof(pip2_cmd));
|
|
|
|
/* Hard coded register for PIP2.x */
|
|
pip2_cmd.reg[0] = 0x01;
|
|
pip2_cmd.reg[1] = 0x01;
|
|
|
|
/*
|
|
* For PIP2.1+ the length field value includes itself:
|
|
* ADD 6: 2 (LEN) + 1 (SEQ) + 1 (REPORT ID) + 2 (CRC)
|
|
*
|
|
* The overall write length must include only the register:
|
|
* ADD 2: 2 (Register)
|
|
*/
|
|
extra_bytes = 6;
|
|
write_len = 2;
|
|
|
|
pip2_cmd.len = report_body_len + extra_bytes;
|
|
pip2_cmd.id = id;
|
|
pip2_cmd.seq = pt_pip2_get_next_cmd_seq(cd);
|
|
pip2_cmd.data = data;
|
|
pt_pip2_cmd_calculate_crc(&pip2_cmd, extra_bytes);
|
|
|
|
/* Add the command length to the extra bytes based on PIP version */
|
|
write_len += pip2_cmd.len;
|
|
|
|
write_buf = kzalloc(write_len, GFP_KERNEL);
|
|
if (write_buf == NULL) {
|
|
rc = -ENOMEM;
|
|
goto exit;
|
|
}
|
|
|
|
write_buf[i++] = pip2_cmd.reg[0];
|
|
write_buf[i++] = pip2_cmd.reg[1];
|
|
write_buf[i++] = pip2_cmd.len & 0xff;
|
|
write_buf[i++] = (pip2_cmd.len & 0xff00) >> 8;
|
|
write_buf[i++] = pip2_cmd.seq;
|
|
write_buf[i++] = pip2_cmd.id;
|
|
|
|
for (j = i; j < i + pip2_cmd.len - extra_bytes; j++)
|
|
write_buf[j] = pip2_cmd.data[j-i];
|
|
write_buf[j++] = pip2_cmd.crc[0];
|
|
write_buf[j++] = pip2_cmd.crc[1];
|
|
|
|
read_len = pt_pip2_get_cmd_response_len(pip2_cmd.id);
|
|
if (read_len < 0)
|
|
read_len = 255;
|
|
pt_debug(dev, DL_INFO,
|
|
"%s: ATM - cmd_id[0x%02X] expected response length:%d ",
|
|
__func__, pip2_cmd.id, read_len);
|
|
|
|
pt_pr_buf(cd->dev, DL_DEBUG, write_buf, write_len, ">>> NO_INT CMD");
|
|
|
|
rc = pt_adap_write_read_specific(cd, write_len, write_buf, NULL);
|
|
if (rc) {
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s: SPI write Error = %d\n",
|
|
__func__, rc);
|
|
goto exit;
|
|
}
|
|
|
|
#ifdef PT_POLL_RESP_BY_BUS
|
|
/*
|
|
* Frequent bus read can increase system load obviously. The expected
|
|
* first bus read should be valid and timely. The tollerance for
|
|
* usleep_range should be limited. The minimum response delay (between
|
|
* command finishes sending and INT pin falls) is less than 50
|
|
* microseconds. So the 10 microseconds should be maximum tollerance
|
|
* with the consideration that the unit to calculate the response delay
|
|
* is 10 microseconds and more precise is not necessary. Every
|
|
* additional 10 microseconds only contribute less than 3 milliseconds
|
|
* for whole BL.
|
|
*/
|
|
usleep_range(resp_time_min, resp_time_min+10);
|
|
max_retry = resp_time_max / POLL_RETRY_DEFAULT_INTERVAL;
|
|
while ((retry < max_retry) && (retry_total_time < resp_time_max)) {
|
|
rc = pt_adap_read_default(cd, read_buf, read_len);
|
|
if (rc) {
|
|
pt_debug(dev, DL_ERROR, "%s: SPI read Error = %d\n",
|
|
__func__, rc);
|
|
break;
|
|
}
|
|
response_seq = read_buf[PIP2_RESP_SEQUENCE_OFFSET];
|
|
size = get_unaligned_le16(&read_buf[0]);
|
|
if ((size <= read_len) &&
|
|
(size >= PIP2_EXTRA_BYTES_NUM) &&
|
|
(pip2_cmd.seq & 0x07) == (response_seq & 0x07)) {
|
|
break;
|
|
}
|
|
|
|
/*
|
|
* To reduce the bus and system load, increase the sleep
|
|
* step gradually:
|
|
* 1 ~ 19 : step=50 us, sleep_us=[50, 100, 150, 200, ..950]
|
|
* 20 ~ 39 : step=1000 us, sleep_us=[1950, 2950, ...20950]
|
|
* 40 ~ MAX: step=50 ms, sleep_ms=[71, 121, 191,..]
|
|
*/
|
|
retry++;
|
|
if (retry < 20) {
|
|
retry_interval += POLL_RETRY_DEFAULT_INTERVAL;
|
|
usleep_range(retry_interval,
|
|
retry_interval + POLL_RETRY_DEFAULT_INTERVAL);
|
|
} else if (retry < 40) {
|
|
retry_interval += 1000;
|
|
usleep_range(retry_interval, retry_interval + 1000);
|
|
} else {
|
|
retry_interval += 50000;
|
|
msleep(retry_interval/1000);
|
|
}
|
|
retry_total_time += retry_interval;
|
|
}
|
|
#else
|
|
/*
|
|
* Frequent GPIO read will not increase CPU/sytem load heavily if the
|
|
* interval is longer than 10 us, so it is safe to poll GPIO with a
|
|
* fixed interval: 20 us.
|
|
*/
|
|
usleep_range(resp_time_min, resp_time_min+10);
|
|
max_retry = resp_time_max / POLL_RETRY_DEFAULT_INTERVAL;
|
|
while ((retry < max_retry) && (retry_total_time < resp_time_max)) {
|
|
if (!gpio_get_value(cd->cpdata->irq_gpio)) {
|
|
rc = pt_adap_read_default(cd, read_buf, read_len);
|
|
size = get_unaligned_le16(&read_buf[0]);
|
|
if (rc)
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s: SPI read Error = %d\n",
|
|
__func__, rc);
|
|
else if (size > read_len) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: PIP2 len field=%d, requested read_len=%d\n",
|
|
__func__, size, read_len);
|
|
rc = -EIO;
|
|
}
|
|
break;
|
|
}
|
|
/*
|
|
* Poll GPIO with fixed interval 20 us, and tollerance is
|
|
* limited to 10 us to speed up the process.
|
|
*/
|
|
retry_interval = POLL_RETRY_DEFAULT_INTERVAL;
|
|
usleep_range(retry_interval, retry_interval+10);
|
|
retry_total_time += retry_interval;
|
|
}
|
|
#endif
|
|
|
|
*actual_read_len = size;
|
|
|
|
if (rc || (retry >= max_retry) || (retry_total_time >= resp_time_max)) {
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s cmd[0x%02X] timed out, send_seq=0x%02X, resp_seq=0x%02X\n",
|
|
__func__, pip2_cmd.id, pip2_cmd.seq, response_seq);
|
|
*actual_read_len = 0;
|
|
rc = -EINVAL;
|
|
}
|
|
|
|
pt_pr_buf(cd->dev, DL_DEBUG, read_buf, *actual_read_len,
|
|
"<<< NO_INT Read");
|
|
|
|
exit:
|
|
kfree(write_buf);
|
|
if (protect == PT_CORE_CMD_PROTECTED) {
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail to release exclusive\n", __func__);
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_pip_null_
|
|
*
|
|
* SUMMARY: Send the PIP "ping"(0x00) command to the DUT and wait for response.
|
|
* This function is used by watchdog to check if the fw corrupts.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
******************************************************************************/
|
|
static int pt_pip_null_(struct pt_core_data *cd)
|
|
{
|
|
struct pt_hid_output hid_output = {
|
|
CREATE_PIP1_FW_CMD(PIP1_CMD_ID_NULL),
|
|
};
|
|
|
|
return pt_pip1_send_output_and_wait_(cd, &hid_output);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_pip_null
|
|
*
|
|
* SUMMARY: Wrapper function for pt_pip_null_ that guarantees exclusive access.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
******************************************************************************/
|
|
static int pt_pip_null(struct pt_core_data *cd)
|
|
{
|
|
int rc;
|
|
|
|
rc = request_exclusive(cd, cd->dev, PT_REQUEST_EXCLUSIVE_TIMEOUT);
|
|
if (rc < 0) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail get exclusive ex=%p own=%p\n",
|
|
__func__, cd->exclusive_dev, cd->dev);
|
|
return rc;
|
|
}
|
|
|
|
rc = pt_pip_null_(cd);
|
|
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail to release exclusive\n", __func__);
|
|
|
|
return rc;
|
|
}
|
|
|
|
static void pt_stop_wd_timer(struct pt_core_data *cd);
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_pip_start_bootloader_
|
|
*
|
|
* SUMMARY: Sends the HID command start_bootloader [PIP cmd 0x01] to the DUT
|
|
*
|
|
* NOTE: The WD MUST be stopped/restarted by the calling Function. Having
|
|
* the WD active could cause this function to fail!
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
******************************************************************************/
|
|
static int pt_pip_start_bootloader_(struct pt_core_data *cd)
|
|
{
|
|
int rc = 0;
|
|
|
|
struct pt_hid_output hid_output = {
|
|
CREATE_PIP1_FW_CMD(PIP1_CMD_ID_START_BOOTLOADER),
|
|
.timeout_ms = PT_PIP1_START_BOOTLOADER_TIMEOUT,
|
|
.reset_expected = 1,
|
|
};
|
|
|
|
if (cd->watchdog_enabled) {
|
|
pt_debug(cd->dev, DL_WARN,
|
|
"%s: watchdog isn't stopped before enter bl\n",
|
|
__func__);
|
|
goto exit;
|
|
}
|
|
|
|
/* Reset startup status after entering BL, new DUT enum required */
|
|
cd->startup_status = STARTUP_STATUS_START;
|
|
pt_debug(cd->dev, DL_DEBUG, "%s: Startup Status Reset\n", __func__);
|
|
rc = pt_pip1_send_output_and_wait_(cd, &hid_output);
|
|
if (rc) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: Start BL PIP cmd failed. rc = %d\n",
|
|
__func__, rc);
|
|
}
|
|
|
|
exit:
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_pip_start_bootloader
|
|
*
|
|
* SUMMARY: Protected function to force DUT to enter the BL
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data structure
|
|
******************************************************************************/
|
|
static int pt_pip_start_bootloader(struct pt_core_data *cd)
|
|
{
|
|
int rc;
|
|
|
|
rc = request_exclusive(cd, cd->dev, PT_REQUEST_EXCLUSIVE_TIMEOUT);
|
|
if (rc < 0) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail get exclusive ex=%p own=%p\n",
|
|
__func__, cd->exclusive_dev, cd->dev);
|
|
return rc;
|
|
}
|
|
|
|
rc = pt_pip_start_bootloader_(cd);
|
|
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail to release exclusive\n", __func__);
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_request_pip_start_bl
|
|
*
|
|
* SUMMARY: Function pointer included in core_nonhid_cmds to allow other
|
|
* modules to request the DUT to enter the BL
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* protect - flag to run in protected mode
|
|
******************************************************************************/
|
|
static int _pt_request_pip_start_bl(struct device *dev, int protect)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
|
|
if (protect)
|
|
return pt_pip_start_bootloader(cd);
|
|
|
|
return pt_pip_start_bootloader_(cd);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_pip2_ver_load_ttdata
|
|
*
|
|
* SUMMARY: Function to load the Version information from the PIP2 VERSION
|
|
* command into the core data struct.
|
|
*
|
|
* RETURN: n/a
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data structure
|
|
* len - Length of data in response_buf
|
|
******************************************************************************/
|
|
static void pt_pip2_ver_load_ttdata(struct pt_core_data *cd, u16 len)
|
|
{
|
|
struct pt_ttdata *ttdata = &cd->sysinfo.ttdata;
|
|
struct pt_pip2_version_full *full_ver;
|
|
struct pt_pip2_version *ver;
|
|
|
|
/*
|
|
* The PIP2 VERSION command can return different lengths of data.
|
|
* The additional LOT fields are included when the packet
|
|
* size is >= 29 bytes. Older FW sends a reduced packet size.
|
|
* NOTE:
|
|
* - The FW would swap the BL and FW versions when reporting
|
|
* the small packet.
|
|
* - Sub Lot bytes 16 and 17 are reserved.
|
|
*/
|
|
if (len >= 0x1D) {
|
|
full_ver = (struct pt_pip2_version_full *)
|
|
&cd->response_buf[PIP2_RESP_STATUS_OFFSET];
|
|
|
|
ttdata->pip_ver_major = full_ver->pip2_version_msb;
|
|
ttdata->pip_ver_minor = full_ver->pip2_version_lsb;
|
|
ttdata->bl_ver_major = full_ver->bl_version_msb;
|
|
ttdata->bl_ver_minor = full_ver->bl_version_lsb;
|
|
ttdata->fw_ver_major = full_ver->fw_version_msb;
|
|
ttdata->fw_ver_minor = full_ver->fw_version_lsb;
|
|
/*
|
|
* BL PIP 2.02 and greater the version fields are
|
|
* swapped
|
|
*/
|
|
if (ttdata->pip_ver_major >= 2 && ttdata->pip_ver_minor >= 2) {
|
|
ttdata->chip_rev =
|
|
get_unaligned_le16(&full_ver->chip_rev);
|
|
ttdata->chip_id =
|
|
get_unaligned_le16(&full_ver->chip_id);
|
|
} else {
|
|
ttdata->chip_rev =
|
|
get_unaligned_le16(&full_ver->chip_id);
|
|
ttdata->chip_id =
|
|
get_unaligned_le16(&full_ver->chip_rev);
|
|
}
|
|
memcpy(ttdata->uid, full_ver->uid, PT_UID_SIZE);
|
|
|
|
pt_pr_buf(cd->dev, DL_INFO, (u8 *)full_ver,
|
|
sizeof(struct pt_pip2_version_full),
|
|
"PIP2 VERSION FULL");
|
|
} else {
|
|
ver = (struct pt_pip2_version *)
|
|
&cd->response_buf[PIP2_RESP_STATUS_OFFSET];
|
|
|
|
ttdata->pip_ver_major = ver->pip2_version_msb;
|
|
ttdata->pip_ver_minor = ver->pip2_version_lsb;
|
|
ttdata->bl_ver_major = ver->bl_version_msb;
|
|
ttdata->bl_ver_minor = ver->bl_version_lsb;
|
|
ttdata->fw_ver_major = ver->fw_version_msb;
|
|
ttdata->fw_ver_minor = ver->fw_version_lsb;
|
|
ttdata->chip_rev = get_unaligned_le16(&ver->chip_rev);
|
|
ttdata->chip_id = get_unaligned_le16(&ver->chip_id);
|
|
|
|
pt_pr_buf(cd->dev, DL_INFO, (u8 *)ver,
|
|
sizeof(struct pt_pip2_version), "PIP2 VERSION");
|
|
}
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_si_get_ttdata
|
|
*
|
|
* SUMMARY: Function to load the version information from the system information
|
|
* PIP command into the core data struct.
|
|
*
|
|
* RETURN: n/a
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data structure
|
|
******************************************************************************/
|
|
static void pt_si_get_ttdata(struct pt_core_data *cd)
|
|
{
|
|
struct pt_ttdata *ttdata = &cd->sysinfo.ttdata;
|
|
struct pt_ttdata_dev *ttdata_dev =
|
|
(struct pt_ttdata_dev *)
|
|
&cd->response_buf[PIP1_SYSINFO_TTDATA_OFFSET];
|
|
|
|
ttdata->pip_ver_major = ttdata_dev->pip_ver_major;
|
|
ttdata->pip_ver_minor = ttdata_dev->pip_ver_minor;
|
|
ttdata->bl_ver_major = ttdata_dev->bl_ver_major;
|
|
ttdata->bl_ver_minor = ttdata_dev->bl_ver_minor;
|
|
ttdata->fw_ver_major = ttdata_dev->fw_ver_major;
|
|
ttdata->fw_ver_minor = ttdata_dev->fw_ver_minor;
|
|
|
|
ttdata->fw_pid = get_unaligned_le16(&ttdata_dev->fw_pid);
|
|
ttdata->fw_ver_conf = get_unaligned_le16(&ttdata_dev->fw_ver_conf);
|
|
ttdata->post_code = get_unaligned_le16(&ttdata_dev->post_code);
|
|
ttdata->revctrl = get_unaligned_le32(&ttdata_dev->revctrl);
|
|
ttdata->jtag_id_l = get_unaligned_le16(&ttdata_dev->jtag_si_id_l);
|
|
ttdata->jtag_id_h = get_unaligned_le16(&ttdata_dev->jtag_si_id_h);
|
|
|
|
memcpy(ttdata->mfg_id, ttdata_dev->mfg_id, PT_NUM_MFGID);
|
|
|
|
pt_pr_buf(cd->dev, DL_INFO, (u8 *)ttdata_dev,
|
|
sizeof(struct pt_ttdata_dev), "sysinfo_ttdata");
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_si_get_sensing_conf_data
|
|
*
|
|
* SUMMARY: Function to load the sensing information from the system information
|
|
* PIP command into the core data struct.
|
|
*
|
|
* RETURN: n/a
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data structure
|
|
******************************************************************************/
|
|
static void pt_si_get_sensing_conf_data(struct pt_core_data *cd)
|
|
{
|
|
struct pt_sensing_conf_data *scd = &cd->sysinfo.sensing_conf_data;
|
|
struct pt_sensing_conf_data_dev *scd_dev =
|
|
(struct pt_sensing_conf_data_dev *)
|
|
&cd->response_buf[PIP1_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;
|
|
}
|
|
|
|
/*
|
|
* When the Panel ID is coming from an XY pin and not a dedicated
|
|
* GPIO, store the PID in pid_for_loader. This cannot be done for all
|
|
* other DUTs as the loader will use cd->pid_for_loader to generate
|
|
* the bin file name but will ignore it if pid_for_loader is still
|
|
* set to PANEL_ID_NOT_ENABLED
|
|
*/
|
|
if (cd->panel_id_support &
|
|
(PT_PANEL_ID_BY_BL | PT_PANEL_ID_BY_SYS_INFO)) {
|
|
mutex_lock(&cd->system_lock);
|
|
cd->pid_for_loader = scd_dev->panel_id;
|
|
mutex_unlock(&cd->system_lock);
|
|
}
|
|
|
|
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);
|
|
|
|
pt_pr_buf(cd->dev, DL_INFO, (u8 *)scd_dev,
|
|
sizeof(struct pt_sensing_conf_data_dev),
|
|
"sensing_conf_data");
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_si_setup
|
|
*
|
|
* SUMMARY: Setup the xy_data and xy_mode by allocating the needed memory
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data structure
|
|
******************************************************************************/
|
|
static int pt_si_setup(struct pt_core_data *cd)
|
|
{
|
|
struct pt_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;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_si_get_btn_data
|
|
*
|
|
* SUMMARY: Setup the core data button information based on the response of the
|
|
* System Information PIP command.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data structure
|
|
******************************************************************************/
|
|
static int pt_si_get_btn_data(struct pt_core_data *cd)
|
|
{
|
|
struct pt_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[PIP1_SYSINFO_BTN_OFFSET]
|
|
& PIP1_SYSINFO_BTN_MASK;
|
|
size_t btn_keys_size;
|
|
|
|
pt_debug(cd->dev, DL_INFO, "%s: get btn data\n", __func__);
|
|
|
|
for (i = 0; i < PIP1_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 pt_btn);
|
|
if (!si->btn)
|
|
si->btn = kzalloc(btn_keys_size, GFP_KERNEL);
|
|
if (!si->btn)
|
|
return -ENOMEM;
|
|
|
|
if (cd->cpdata->sett[PT_IC_GRPNUM_BTN_KEYS] == NULL)
|
|
num_defined_keys = 0;
|
|
else if (cd->cpdata->sett[PT_IC_GRPNUM_BTN_KEYS]->data == NULL)
|
|
num_defined_keys = 0;
|
|
else
|
|
num_defined_keys = cd->cpdata->sett
|
|
[PT_IC_GRPNUM_BTN_KEYS]->size;
|
|
|
|
for (btn = 0; btn < num_btns && btn < num_defined_keys; btn++) {
|
|
key_table = (u16 *)cd->cpdata->sett
|
|
[PT_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;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_si_put_log_data
|
|
*
|
|
* SUMMARY: Prints all sys info data to kmsg log
|
|
*
|
|
* RETURN: n/a
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data structure
|
|
******************************************************************************/
|
|
static void pt_si_put_log_data(struct pt_core_data *cd)
|
|
{
|
|
struct pt_sysinfo *si = &cd->sysinfo;
|
|
struct pt_ttdata *ttdata = &si->ttdata;
|
|
struct pt_sensing_conf_data *scd = &si->sensing_conf_data;
|
|
int i;
|
|
|
|
pt_debug(cd->dev, DL_DEBUG, "%s: pip_ver_major = 0x%02X (%d)\n",
|
|
__func__, ttdata->pip_ver_major, ttdata->pip_ver_major);
|
|
pt_debug(cd->dev, DL_DEBUG, "%s: pip_ver_minor = 0x%02X (%d)\n",
|
|
__func__, ttdata->pip_ver_minor, ttdata->pip_ver_minor);
|
|
pt_debug(cd->dev, DL_DEBUG, "%s: fw_pid = 0x%04X (%d)\n",
|
|
__func__, ttdata->fw_pid, ttdata->fw_pid);
|
|
pt_debug(cd->dev, DL_DEBUG, "%s: fw_ver_major = 0x%02X (%d)\n",
|
|
__func__, ttdata->fw_ver_major, ttdata->fw_ver_major);
|
|
pt_debug(cd->dev, DL_DEBUG, "%s: fw_ver_minor = 0x%02X (%d)\n",
|
|
__func__, ttdata->fw_ver_minor, ttdata->fw_ver_minor);
|
|
pt_debug(cd->dev, DL_DEBUG, "%s: revctrl = 0x%08X (%d)\n",
|
|
__func__, ttdata->revctrl, ttdata->revctrl);
|
|
pt_debug(cd->dev, DL_DEBUG, "%s: fw_ver_conf = 0x%04X (%d)\n",
|
|
__func__, ttdata->fw_ver_conf, ttdata->fw_ver_conf);
|
|
pt_debug(cd->dev, DL_DEBUG, "%s: bl_ver_major = 0x%02X (%d)\n",
|
|
__func__, ttdata->bl_ver_major, ttdata->bl_ver_major);
|
|
pt_debug(cd->dev, DL_DEBUG, "%s: bl_ver_minor = 0x%02X (%d)\n",
|
|
__func__, ttdata->bl_ver_minor, ttdata->bl_ver_minor);
|
|
pt_debug(cd->dev, DL_DEBUG, "%s: jtag_id_h = 0x%04X (%d)\n",
|
|
__func__, ttdata->jtag_id_h, ttdata->jtag_id_h);
|
|
pt_debug(cd->dev, DL_DEBUG, "%s: jtag_id_l = 0x%04X (%d)\n",
|
|
__func__, ttdata->jtag_id_l, ttdata->jtag_id_l);
|
|
|
|
for (i = 0; i < PT_NUM_MFGID; i++)
|
|
pt_debug(cd->dev, DL_DEBUG,
|
|
"%s: mfg_id[%d] = 0x%02X (%d)\n",
|
|
__func__, i, ttdata->mfg_id[i],
|
|
ttdata->mfg_id[i]);
|
|
|
|
pt_debug(cd->dev, DL_DEBUG, "%s: post_code = 0x%04X (%d)\n",
|
|
__func__, ttdata->post_code, ttdata->post_code);
|
|
pt_debug(cd->dev, DL_DEBUG, "%s: electrodes_x = 0x%02X (%d)\n",
|
|
__func__, scd->electrodes_x, scd->electrodes_x);
|
|
pt_debug(cd->dev, DL_DEBUG, "%s: electrodes_y = 0x%02X (%d)\n",
|
|
__func__, scd->electrodes_y, scd->electrodes_y);
|
|
pt_debug(cd->dev, DL_DEBUG, "%s: len_x = 0x%04X (%d)\n",
|
|
__func__, scd->len_x, scd->len_x);
|
|
pt_debug(cd->dev, DL_DEBUG, "%s: len_y = 0x%04X (%d)\n",
|
|
__func__, scd->len_y, scd->len_y);
|
|
pt_debug(cd->dev, DL_DEBUG, "%s: res_x = 0x%04X (%d)\n",
|
|
__func__, scd->res_x, scd->res_x);
|
|
pt_debug(cd->dev, DL_DEBUG, "%s: res_y = 0x%04X (%d)\n",
|
|
__func__, scd->res_y, scd->res_y);
|
|
pt_debug(cd->dev, DL_DEBUG, "%s: max_z = 0x%04X (%d)\n",
|
|
__func__, scd->max_z, scd->max_z);
|
|
pt_debug(cd->dev, DL_DEBUG, "%s: origin_x = 0x%02X (%d)\n",
|
|
__func__, scd->origin_x, scd->origin_x);
|
|
pt_debug(cd->dev, DL_DEBUG, "%s: origin_y = 0x%02X (%d)\n",
|
|
__func__, scd->origin_y, scd->origin_y);
|
|
pt_debug(cd->dev, DL_DEBUG, "%s: panel_id = 0x%02X (%d)\n",
|
|
__func__, scd->panel_id, scd->panel_id);
|
|
pt_debug(cd->dev, DL_DEBUG, "%s: btn =0x%02X (%d)\n",
|
|
__func__, scd->btn, scd->btn);
|
|
pt_debug(cd->dev, DL_DEBUG, "%s: scan_mode = 0x%02X (%d)\n",
|
|
__func__, scd->scan_mode, scd->scan_mode);
|
|
pt_debug(cd->dev, DL_DEBUG,
|
|
"%s: max_num_of_tch_per_refresh_cycle = 0x%02X (%d)\n",
|
|
__func__, scd->max_tch, scd->max_tch);
|
|
pt_debug(cd->dev, DL_DEBUG, "%s: xy_mode = %p\n",
|
|
__func__, si->xy_mode);
|
|
pt_debug(cd->dev, DL_DEBUG, "%s: xy_data = %p\n",
|
|
__func__, si->xy_data);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_get_sysinfo_regs
|
|
*
|
|
* SUMMARY: Setup all the core data System information based on the response
|
|
* of the System Information PIP command.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data structure
|
|
******************************************************************************/
|
|
static int pt_get_sysinfo_regs(struct pt_core_data *cd)
|
|
{
|
|
struct pt_sysinfo *si = &cd->sysinfo;
|
|
int rc;
|
|
|
|
rc = pt_si_get_btn_data(cd);
|
|
if (rc < 0)
|
|
return rc;
|
|
|
|
pt_si_get_ttdata(cd);
|
|
|
|
pt_si_get_sensing_conf_data(cd);
|
|
|
|
pt_si_setup(cd);
|
|
|
|
pt_si_put_log_data(cd);
|
|
|
|
si->ready = true;
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_free_si_ptrs
|
|
*
|
|
* SUMMARY: Frees all memory associated with the System Information within
|
|
* core data
|
|
*
|
|
* RETURN: n/a
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data structure
|
|
******************************************************************************/
|
|
static void pt_free_si_ptrs(struct pt_core_data *cd)
|
|
{
|
|
struct pt_sysinfo *si = &cd->sysinfo;
|
|
|
|
kfree(si->btn);
|
|
kfree(si->xy_mode);
|
|
kfree(si->xy_data);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_hid_output_get_sysinfo_
|
|
*
|
|
* SUMMARY: Sends the PIP Get SYS INFO command to the DUT and waits for the
|
|
* response.
|
|
*
|
|
* RETURN::
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data structure
|
|
******************************************************************************/
|
|
static int pt_hid_output_get_sysinfo_(struct pt_core_data *cd)
|
|
{
|
|
int rc = 0;
|
|
struct pt_hid_output hid_output = {
|
|
CREATE_PIP1_FW_CMD(PIP1_CMD_ID_GET_SYSINFO),
|
|
.timeout_ms = PT_PIP1_CMD_GET_SYSINFO_TIMEOUT,
|
|
};
|
|
|
|
rc = pt_pip1_send_output_and_wait_(cd, &hid_output);
|
|
if (rc)
|
|
return rc;
|
|
|
|
/* Parse the sysinfo data */
|
|
rc = pt_get_sysinfo_regs(cd);
|
|
if (rc)
|
|
pt_free_si_ptrs(cd);
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_hid_output_get_sysinfo
|
|
*
|
|
* SUMMARY: Protected call to pt_hid_output_get_sysinfo_
|
|
*
|
|
* RETURN::
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data structure
|
|
******************************************************************************/
|
|
static int pt_hid_output_get_sysinfo(struct pt_core_data *cd)
|
|
{
|
|
int rc;
|
|
|
|
rc = request_exclusive(cd, cd->dev, PT_REQUEST_EXCLUSIVE_TIMEOUT);
|
|
if (rc < 0) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail get exclusive ex=%p own=%p\n",
|
|
__func__, cd->exclusive_dev, cd->dev);
|
|
return rc;
|
|
}
|
|
|
|
rc = pt_hid_output_get_sysinfo_(cd);
|
|
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail to release exclusive\n", __func__);
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_pip_suspend_scanning_
|
|
*
|
|
* SUMMARY: Sends the PIP Suspend Scanning command to the DUT
|
|
*
|
|
* RETURN::
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data structure
|
|
******************************************************************************/
|
|
static int pt_pip_suspend_scanning_(struct pt_core_data *cd)
|
|
{
|
|
int rc = 0;
|
|
struct pt_hid_output hid_output = {
|
|
CREATE_PIP1_FW_CMD(PIP1_CMD_ID_SUSPEND_SCANNING),
|
|
};
|
|
|
|
rc = pt_pip1_send_output_and_wait_(cd, &hid_output);
|
|
if (rc) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: Suspend Scan PIP cmd failed. rc = %d\n",
|
|
__func__, rc);
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_pip_suspend_scanning
|
|
*
|
|
* SUMMARY: Protected wrapper for calling pt_hid_output_suspend_scanning_
|
|
*
|
|
* RETURN::
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data structure
|
|
******************************************************************************/
|
|
static int pt_pip_suspend_scanning(struct pt_core_data *cd)
|
|
{
|
|
int rc;
|
|
|
|
rc = request_exclusive(cd, cd->dev, PT_REQUEST_EXCLUSIVE_TIMEOUT);
|
|
if (rc < 0) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail get exclusive ex=%p own=%p\n",
|
|
__func__, cd->exclusive_dev, cd->dev);
|
|
return rc;
|
|
}
|
|
|
|
rc = pt_pip_suspend_scanning_(cd);
|
|
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail to release exclusive\n", __func__);
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_request_pip_suspend_scanning
|
|
*
|
|
* SUMMARY: Function pointer included in core_nonhid_cmd struct for external
|
|
* calls to the protected or unprotected call to pt_pip_suspend_scanning
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* protect - 0 = call non-protected function
|
|
* 1 = call protected function
|
|
******************************************************************************/
|
|
static int _pt_request_pip_suspend_scanning(struct device *dev,
|
|
int protect)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
|
|
if (protect)
|
|
return pt_pip_suspend_scanning(cd);
|
|
|
|
return pt_pip_suspend_scanning_(cd);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_pip_resume_scanning_
|
|
*
|
|
* SUMMARY: Sends the PIP Resume Scanning command to the DUT
|
|
*
|
|
* RETURN::
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data structure
|
|
******************************************************************************/
|
|
static int pt_pip_resume_scanning_(struct pt_core_data *cd)
|
|
{
|
|
int rc = 0;
|
|
struct pt_hid_output hid_output = {
|
|
CREATE_PIP1_FW_CMD(PIP1_CMD_ID_RESUME_SCANNING),
|
|
};
|
|
|
|
rc = pt_pip1_send_output_and_wait_(cd, &hid_output);
|
|
if (rc) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: Resume Scan PIP cmd failed. rc = %d\n",
|
|
__func__, rc);
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_pip_resume_scanning
|
|
*
|
|
* SUMMARY: Protected wrapper for calling pt_pip_resume_scanning_
|
|
*
|
|
* RETURN::
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data structure
|
|
******************************************************************************/
|
|
static int pt_pip_resume_scanning(struct pt_core_data *cd)
|
|
{
|
|
int rc;
|
|
|
|
rc = request_exclusive(cd, cd->dev, PT_REQUEST_EXCLUSIVE_TIMEOUT);
|
|
if (rc < 0) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail get exclusive ex=%p own=%p\n",
|
|
__func__, cd->exclusive_dev, cd->dev);
|
|
return rc;
|
|
}
|
|
|
|
rc = pt_pip_resume_scanning_(cd);
|
|
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail to release exclusive\n", __func__);
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_request_pip_resume_scanning
|
|
*
|
|
* SUMMARY: Function pointer included in core_nonhid_cmd struct for external
|
|
* calls to the protected or unprotected call to pt_pip_resume_scanning
|
|
*
|
|
* RETURN::
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* protect - 0 = call non-protected function
|
|
* 1 = call protected function
|
|
******************************************************************************/
|
|
static int _pt_request_pip_resume_scanning(struct device *dev,
|
|
int protect)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
|
|
if (protect)
|
|
return pt_pip_resume_scanning(cd);
|
|
|
|
return pt_pip_resume_scanning_(cd);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_pip_get_param_
|
|
*
|
|
* SUMMARY: Sends a PIP command 0x05 Get Parameter to the DUT and returns
|
|
* the 32bit parameter value
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* param_id - parameter ID to retrieve
|
|
* *value - value of DUT parameter
|
|
******************************************************************************/
|
|
static int pt_pip_get_param_(struct pt_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 = 0;
|
|
int i;
|
|
struct pt_hid_output hid_output = {
|
|
CREATE_PIP1_FW_CMD(PIP1_CMD_ID_GET_PARAM),
|
|
.write_length = write_length,
|
|
.write_buf = param,
|
|
};
|
|
|
|
rc = pt_pip1_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;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_pip_get_param
|
|
*
|
|
* SUMMARY: Protected call to pt_hid_output_get_param_ by a request exclusive
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* param_id - parameter ID to retrieve
|
|
* *value - value of DUT parameter
|
|
******************************************************************************/
|
|
static int pt_pip_get_param(struct pt_core_data *cd,
|
|
u8 param_id, u32 *value)
|
|
{
|
|
int rc;
|
|
|
|
rc = request_exclusive(cd, cd->dev, PT_REQUEST_EXCLUSIVE_TIMEOUT);
|
|
if (rc < 0) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail get exclusive ex=%p own=%p\n",
|
|
__func__, cd->exclusive_dev, cd->dev);
|
|
return rc;
|
|
}
|
|
|
|
rc = pt_pip_get_param_(cd, param_id, value);
|
|
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail to release exclusive\n", __func__);
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_request_pip_get_param
|
|
*
|
|
* SUMMARY: Function pointer included in core_nonhid_cmd struct for external
|
|
* calls to the protected or unprotected call to pt_pip_get_param
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* protect - flag to call protected or non protected function
|
|
* param_id - parameter ID to retrieve
|
|
* *value - value of DUT parameter
|
|
******************************************************************************/
|
|
int _pt_request_pip_get_param(struct device *dev,
|
|
int protect, u8 param_id, u32 *value)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
|
|
if (protect)
|
|
return pt_pip_get_param(cd, param_id, value);
|
|
|
|
return pt_pip_get_param_(cd, param_id, value);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_pip_set_param_
|
|
*
|
|
* SUMMARY: Sends a PIP command 0x06 Set Parameter to the DUT writing the
|
|
* passed in value to flash
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* param_id - parameter ID to set
|
|
* value - value to write
|
|
* size - size to write
|
|
******************************************************************************/
|
|
static int pt_pip_set_param_(struct pt_core_data *cd,
|
|
u8 param_id, u32 value, u8 size)
|
|
{
|
|
u8 write_buf[6];
|
|
u8 *ptr = &write_buf[2];
|
|
int rc = 0;
|
|
int i;
|
|
struct pt_hid_output hid_output = {
|
|
CREATE_PIP1_FW_CMD(PIP1_CMD_ID_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 = pt_pip1_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;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_pip_set_param
|
|
*
|
|
* SUMMARY: Protected call to pt_hid_output_set_param_ by a request exclusive
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* param_id - parameter ID to set
|
|
* value - value to write
|
|
* size - size to write
|
|
******************************************************************************/
|
|
static int pt_pip_set_param(struct pt_core_data *cd,
|
|
u8 param_id, u32 value, u8 size)
|
|
{
|
|
int rc;
|
|
|
|
rc = request_exclusive(cd, cd->dev, PT_REQUEST_EXCLUSIVE_TIMEOUT);
|
|
if (rc < 0) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail get exclusive ex=%p own=%p\n",
|
|
__func__, cd->exclusive_dev, cd->dev);
|
|
return rc;
|
|
}
|
|
|
|
rc = pt_pip_set_param_(cd, param_id, value, size);
|
|
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail to release exclusive\n", __func__);
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_request_pip_set_param
|
|
*
|
|
* SUMMARY: Function pointer included in core_nonhid_cmd struct for external
|
|
* calls to the protected or unprotected call to pt_pip_set_param
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* protect - flag to call protected or non-protected
|
|
* param_id - parameter ID to set
|
|
* value - value to write
|
|
* size - size to write
|
|
******************************************************************************/
|
|
int _pt_request_pip_set_param(struct device *dev, int protect,
|
|
u8 param_id, u32 value, u8 size)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
|
|
if (protect)
|
|
return pt_pip_set_param(cd, param_id, value, size);
|
|
|
|
return pt_pip_set_param_(cd, param_id, value, size);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_pip_enter_easywake_state_
|
|
*
|
|
* SUMMARY: Sends a PIP command 0x09 Enter EasyWake State to the DUT
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* data - easywake guesture (Only used for PIP1.6 and earlier)
|
|
* *return_data - return status if easywake was entered
|
|
******************************************************************************/
|
|
static int pt_hid_output_enter_easywake_state_(
|
|
struct pt_core_data *cd, u8 data, u8 *return_data)
|
|
{
|
|
int write_length = 1;
|
|
u8 param[1] = { data };
|
|
int rc = 0;
|
|
struct pt_hid_output hid_output = {
|
|
CREATE_PIP1_FW_CMD(PIP1_CMD_ID_ENTER_EASYWAKE_STATE),
|
|
.write_length = write_length,
|
|
.write_buf = param,
|
|
};
|
|
|
|
rc = pt_pip1_send_output_and_wait_(cd, &hid_output);
|
|
if (rc)
|
|
return rc;
|
|
|
|
*return_data = cd->response_buf[5];
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_pip_verify_config_block_crc_
|
|
*
|
|
* SUMMARY: Sends the PIP "Verify Data Block CRC" (0x20) command to the DUT
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer the core data structure
|
|
* ebid - enumerated block ID
|
|
* *status - PIP command status
|
|
* calculated_crc - calculated CRC
|
|
* stored_crc - stored CRC in config area
|
|
******************************************************************************/
|
|
static int pt_pip_verify_config_block_crc_(
|
|
struct pt_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 = 0;
|
|
struct pt_hid_output hid_output = {
|
|
CREATE_PIP1_FW_CMD(PIP1_CMD_ID_VERIFY_CONFIG_BLOCK_CRC),
|
|
.write_length = write_length,
|
|
.write_buf = param,
|
|
};
|
|
|
|
rc = pt_pip1_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;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_pip_verify_config_block_crc
|
|
*
|
|
* SUMMARY: Protected call to pt_hid_output_verify_config_block_crc_() within
|
|
* an exclusive access to the DUT.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer the core data structure
|
|
* ebid - enumerated block ID
|
|
* *status - PIP command status
|
|
* calculated_crc - calculated CRC
|
|
* stored_crc - stored CRC in config area
|
|
******************************************************************************/
|
|
static int pt_pip_verify_config_block_crc(
|
|
struct pt_core_data *cd, u8 ebid, u8 *status,
|
|
u16 *calculated_crc, u16 *stored_crc)
|
|
{
|
|
int rc;
|
|
|
|
rc = request_exclusive(cd, cd->dev, PT_REQUEST_EXCLUSIVE_TIMEOUT);
|
|
if (rc < 0) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail get exclusive ex=%p own=%p\n",
|
|
__func__, cd->exclusive_dev, cd->dev);
|
|
return rc;
|
|
}
|
|
|
|
rc = pt_pip_verify_config_block_crc_(cd, ebid, status,
|
|
calculated_crc, stored_crc);
|
|
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail to release exclusive\n", __func__);
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_request_pip_verify_config_block_crc
|
|
*
|
|
* SUMMARY: Function pointer included in core_nonhid_cmd struct for external
|
|
* calls to the protected or unprotected call to
|
|
* pt_pip_verify_config_block_crc_
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* protect - flag to call protected or non-protected
|
|
* ebid - enumerated block ID
|
|
* *status - PIP command status
|
|
* calculated_crc - calculated CRC
|
|
* stored_crc - stored CRC in config area
|
|
******************************************************************************/
|
|
static int _pt_request_pip_verify_config_block_crc(
|
|
struct device *dev, int protect, u8 ebid, u8 *status,
|
|
u16 *calculated_crc, u16 *stored_crc)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
|
|
if (protect)
|
|
return pt_pip_verify_config_block_crc(cd, ebid,
|
|
status, calculated_crc, stored_crc);
|
|
|
|
return pt_pip_verify_config_block_crc_(cd, ebid,
|
|
status, calculated_crc, stored_crc);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_pip_get_config_row_size_
|
|
*
|
|
* SUMMARY: Sends the PIP "Get Data Row Size" (0x21) command to the DUT
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* protect - flag to call protected or non-protected
|
|
* *row_size - pointer to store the retrieved row size
|
|
******************************************************************************/
|
|
static int pt_pip_get_config_row_size_(struct pt_core_data *cd,
|
|
u16 *row_size)
|
|
{
|
|
int rc = 0;
|
|
struct pt_hid_output hid_output = {
|
|
CREATE_PIP1_FW_CMD(PIP1_CMD_ID_GET_CONFIG_ROW_SIZE),
|
|
};
|
|
|
|
rc = pt_pip1_send_output_and_wait_(cd, &hid_output);
|
|
if (rc)
|
|
return rc;
|
|
|
|
*row_size = get_unaligned_le16(&cd->response_buf[5]);
|
|
return 0;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_pip_get_config_row_size
|
|
*
|
|
* SUMMARY: Protected call to pt_hid_output_get_config_row_size_ within
|
|
* an exclusive access to the DUT.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* protect - flag to call protected or non-protected
|
|
* *row_size - pointer to store the retrieved row size
|
|
******************************************************************************/
|
|
static int pt_pip_get_config_row_size(struct pt_core_data *cd,
|
|
u16 *row_size)
|
|
{
|
|
int rc;
|
|
|
|
rc = request_exclusive(cd, cd->dev, PT_REQUEST_EXCLUSIVE_TIMEOUT);
|
|
if (rc < 0) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail get exclusive ex=%p own=%p\n",
|
|
__func__, cd->exclusive_dev, cd->dev);
|
|
return rc;
|
|
}
|
|
|
|
rc = pt_pip_get_config_row_size_(cd, row_size);
|
|
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail to release exclusive\n", __func__);
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_request_pip_get_config_row_size
|
|
*
|
|
* SUMMARY: Function pointer included in core_nonhid_cmd struct for external
|
|
* calls to the protected or unprotected call to
|
|
* pt_pip_get_config_row_size_
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* protect - flag to call protected or non-protected
|
|
* *row_size - pointer to store the retrieved row size
|
|
******************************************************************************/
|
|
static int _pt_request_pip_get_config_row_size(struct device *dev,
|
|
int protect, u16 *row_size)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
|
|
if (protect)
|
|
return pt_pip_get_config_row_size(cd, row_size);
|
|
|
|
return pt_pip_get_config_row_size_(cd, row_size);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_pip1_read_data_block_
|
|
*
|
|
* SUMMARY: Sends the PIP "Read Data Block" (0x22) command to the DUT and print
|
|
* output data to the "read_buf" and update "crc".
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* row_number - row number
|
|
* length - length of data to read
|
|
* ebid - block id
|
|
* *actual_read_len - Actual data length read
|
|
* *read_buf - pointer to the buffer to store read data
|
|
* read_buf_size - size of read_buf
|
|
* *crc - pointer to store CRC of row data
|
|
******************************************************************************/
|
|
static int pt_pip1_read_data_block_(struct pt_core_data *cd,
|
|
u16 row_number, u16 length, u8 ebid, u16 *actual_read_len,
|
|
u8 *read_buf, u16 read_buf_size, u16 *crc)
|
|
{
|
|
int read_ebid;
|
|
int status;
|
|
int rc = 0;
|
|
int write_length = 5;
|
|
u8 write_buf[5];
|
|
u8 cmd_offset = 0;
|
|
u16 calc_crc;
|
|
struct pt_hid_output hid_output = {
|
|
CREATE_PIP1_FW_CMD(PIP1_CMD_ID_READ_DATA_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 = pt_pip1_send_output_and_wait_(cd, &hid_output);
|
|
if (rc)
|
|
return rc;
|
|
|
|
status = cd->response_buf[5];
|
|
if (status)
|
|
return status;
|
|
|
|
read_ebid = cd->response_buf[6];
|
|
if ((read_ebid != ebid) || (cd->response_buf[9] != 0))
|
|
return -EPROTO;
|
|
|
|
*actual_read_len = get_unaligned_le16(&cd->response_buf[7]);
|
|
if (length == 0 || *actual_read_len == 0)
|
|
return 0;
|
|
|
|
if (read_buf_size >= *actual_read_len)
|
|
memcpy(read_buf, &cd->response_buf[10], *actual_read_len);
|
|
else
|
|
return -EPROTO;
|
|
|
|
*crc = get_unaligned_le16(&cd->response_buf[*actual_read_len + 10]);
|
|
|
|
/* Validate Row Data CRC */
|
|
calc_crc = _pt_compute_crc(read_buf, *actual_read_len);
|
|
if (*crc == calc_crc) {
|
|
return 0;
|
|
} else {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: CRC Missmatch packet=0x%04X calc=0x%04X\n",
|
|
__func__, *crc, calc_crc);
|
|
return -EPROTO;
|
|
}
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_request_pip_read_data_block
|
|
*
|
|
* SUMMARY: Function pointer included in core_nonhid_cmd struct for external
|
|
* calls to pt_pip1_read_data_block_
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* row_number - row number
|
|
* length - length of data to read
|
|
* ebid - block id
|
|
* *actual_read_len - Actual data length read
|
|
* *read_buf - pointer to the buffer to store read data
|
|
* *crc - pointer to store CRC of row data
|
|
******************************************************************************/
|
|
static int _pt_request_pip_read_data_block(struct device *dev,
|
|
u16 row_number, u16 length, u8 ebid, u16 *actual_read_len,
|
|
u8 *read_buf, u16 read_buf_size, u16 *crc)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
|
|
return pt_pip1_read_data_block_(cd, row_number, length,
|
|
ebid, actual_read_len, read_buf, read_buf_size, crc);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_pip1_write_data_block_
|
|
*
|
|
* SUMMARY: Sends the PIP "Write Data Block" (0x23) command to the DUT and
|
|
* write data to the data block.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* row_number - row in config block to write to
|
|
* write_length - length of data to write
|
|
* ebid - enumerated block ID
|
|
* *write_buf - pointer to buffer to write
|
|
* *security_key - pointer to security key to allow write
|
|
* *actual_write_len - pointer to store data length actually written
|
|
******************************************************************************/
|
|
static int pt_pip1_write_data_block_(struct pt_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 = 0;
|
|
int read_ebid;
|
|
u8 *data;
|
|
struct pt_hid_output hid_output = {
|
|
CREATE_PIP1_FW_CMD(PIP1_CMD_ID_WRITE_DATA_BLOCK),
|
|
.write_length = full_write_length,
|
|
.timeout_ms = PT_PIP1_CMD_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 = _pt_compute_crc(data, write_length);
|
|
full_write_buf[cmd_offset++] = LOW_BYTE(crc);
|
|
full_write_buf[cmd_offset++] = HI_BYTE(crc);
|
|
|
|
rc = pt_pip1_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;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_request_pip_write_data_block
|
|
*
|
|
* SUMMARY: Function pointer included in core_nonhid_cmd struct for external
|
|
* calls to the protected or unprotected call to pt_pip1_write_data_block_
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* protect - flag to call protected or non-protected
|
|
* row_number - row in config block to write to
|
|
* write_length - length of data to write
|
|
* ebid - enumerated block ID
|
|
* *write_buf - pointer to buffer to write
|
|
* *security_key - pointer to security key to allow write
|
|
* *actual_write_len - pointer to store data length actually written
|
|
******************************************************************************/
|
|
static int _pt_request_pip_write_data_block(struct device *dev,
|
|
u16 row_number, u16 write_length, u8 ebid,
|
|
u8 *write_buf, u8 *security_key, u16 *actual_write_len)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
|
|
return pt_pip1_write_data_block_(cd, row_number,
|
|
write_length, ebid, write_buf, security_key,
|
|
actual_write_len);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_pip_get_data_structure_
|
|
*
|
|
* SUMMARY: Sends the PIP "Retrieve Data Structure" (0x24) command to the DUT
|
|
* returning a structure of data defined by data_id
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* read_offset - read pointer offset
|
|
* read_length - length of data to read
|
|
* data_id - data ID to read
|
|
* *status - pointer to store the read response status
|
|
* *data_format - pointer to store format of data read
|
|
* *actual_read_len - pointer to store data length actually read
|
|
* *data - pointer to store data read
|
|
******************************************************************************/
|
|
static int pt_pip_get_data_structure_(
|
|
struct pt_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 = 0;
|
|
u16 total_read_len = 0;
|
|
u16 read_len;
|
|
u16 off_buf = 0;
|
|
u8 write_buf[5];
|
|
u8 read_data_id;
|
|
struct pt_hid_output hid_output = {
|
|
CREATE_PIP1_FW_CMD(PIP1_CMD_ID_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 = pt_pip1_send_output_and_wait_(cd, &hid_output);
|
|
if (rc)
|
|
return rc;
|
|
|
|
if (cd->response_buf[5] != PT_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;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_pip_get_data_structure
|
|
*
|
|
* SUMMARY: Protected call to pt_hid_output_get_data_structure within
|
|
* an exclusive access to the DUT.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* read_offset - read pointer offset
|
|
* read_length - length of data to read
|
|
* data_id - data ID to read
|
|
* *status - pointer to store the read response status
|
|
* *data_format - pointer to store format of data read
|
|
* *actual_read_len - pointer to store data length actually read
|
|
* *data - pointer to store data read
|
|
******************************************************************************/
|
|
static int pt_pip_get_data_structure(
|
|
struct pt_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, PT_REQUEST_EXCLUSIVE_TIMEOUT);
|
|
if (rc < 0) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail get exclusive ex=%p own=%p\n",
|
|
__func__, cd->exclusive_dev, cd->dev);
|
|
return rc;
|
|
}
|
|
|
|
rc = pt_pip_get_data_structure_(cd, read_offset,
|
|
read_length, data_id, status, data_format,
|
|
actual_read_len, data);
|
|
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail to release exclusive\n", __func__);
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_request_pip_get_data_structure
|
|
*
|
|
* SUMMARY: Function pointer included in core_nonhid_cmd struct for external
|
|
* calls to the protected or unprotected call to
|
|
* pt_pip_get_data_structure
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* protect - flag to call protected or non-protected
|
|
* read_offset - read pointer offset
|
|
* read_length - length of data to read
|
|
* data_id - data ID to read
|
|
* *status - pointer to store the read response status
|
|
* *data_format - pointer to store format of data read
|
|
* *actual_read_len - pointer to store data length actually read
|
|
* *data - pointer to store data read
|
|
******************************************************************************/
|
|
static int _pt_request_pip_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 pt_core_data *cd = dev_get_drvdata(dev);
|
|
|
|
if (protect)
|
|
return pt_pip_get_data_structure(cd,
|
|
read_offset, read_length, data_id, status,
|
|
data_format, actual_read_len, data);
|
|
|
|
return pt_pip_get_data_structure_(cd,
|
|
read_offset, read_length, data_id, status,
|
|
data_format, actual_read_len, data);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_manage_local_cal_data
|
|
*
|
|
* SUMMARY: This function manages storing or restoring a copy of the Firmware
|
|
* CALIBRATION data. It stores it in a local static array and can be
|
|
* cleared, loaded or used to restore the CAL data back to the running FW.
|
|
* The CAL data is read or restored by use of the PIP1 commands:
|
|
* - READ_DATA_BLOCK (0x22)
|
|
* - WRITE_DATA_BLOCK (0x23)
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* action - One of the following actions:
|
|
* - PT_CAL_DATA_SAVE
|
|
* - PT_CAL_DATA_RESTORE
|
|
* - PT_CAL_DATA_CLEAR
|
|
* - PT_CAL_DATA_SIZE
|
|
* *size - pointer to the number of bytes transfered
|
|
* *crc - pointer to Chip ID CRC that the CAL data was retrieved from
|
|
******************************************************************************/
|
|
static int _pt_manage_local_cal_data(struct device *dev, u8 action, u16 *size,
|
|
unsigned short *crc)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
struct pt_ttdata *ttdata = &cd->sysinfo.ttdata;
|
|
unsigned short calc_id_crc = 0;
|
|
static u8 *cal_cache_data;
|
|
static u16 cal_cache_len;
|
|
static unsigned short cal_cache_chip_id;
|
|
int rc = 0;
|
|
u8 *tmp_data = NULL;
|
|
u8 row_number = 0;
|
|
u8 prefix[20];
|
|
u16 cal_size = 0;
|
|
u16 transfer_size;
|
|
u16 act_trans_len = 0;
|
|
u16 byte_offset = 0;
|
|
u16 cal_blk_size;
|
|
u16 total_rows;
|
|
u16 remain_bytes;
|
|
u16 data_block_crc;
|
|
u16 buf_size = 12;
|
|
|
|
pt_debug(dev, DL_INFO, "%s: ATM - CAL Cache action=%d\n",
|
|
__func__, action);
|
|
switch (action) {
|
|
case PT_CAL_DATA_SAVE:
|
|
/* Read the size of the CAL block and calculate # rows */
|
|
tmp_data = kzalloc(buf_size, GFP_KERNEL);
|
|
if (!tmp_data) {
|
|
rc = -ENOMEM;
|
|
goto exit;
|
|
}
|
|
/*
|
|
* Don't check rc as doing a read size will give a false
|
|
* error on the CRC check.
|
|
*/
|
|
rc = pt_pip1_read_data_block_(cd, row_number, 0, PT_CAL_EBID,
|
|
&act_trans_len, tmp_data, buf_size, &data_block_crc);
|
|
cal_blk_size = act_trans_len;
|
|
kfree(tmp_data);
|
|
|
|
pt_debug(dev, DL_INFO,
|
|
"%s: CAL Cache size=%d FW CAL Size=%d\n",
|
|
__func__, cal_cache_len, cal_blk_size);
|
|
|
|
/* Safety net to ensure we didn't read incorrect size */
|
|
if (cal_blk_size > PT_CAL_DATA_MAX_SIZE) {
|
|
pt_debug(dev, DL_ERROR, "%s: Alloc struct Failed\n",
|
|
__func__);
|
|
rc = 1;
|
|
goto exit;
|
|
}
|
|
|
|
/* Panels could have diff CAL sizes, Re-allocate the cache */
|
|
if (cal_blk_size != cal_cache_len) {
|
|
kfree(cal_cache_data);
|
|
cal_cache_data = kzalloc(cal_blk_size + 2,
|
|
GFP_KERNEL);
|
|
if (!cal_cache_data) {
|
|
rc = -ENOMEM;
|
|
goto exit;
|
|
}
|
|
|
|
pt_debug(dev, DL_INFO, "%s: CAL Cache Allocated\n",
|
|
__func__);
|
|
}
|
|
memset(&cal_cache_data[0], 0, cal_blk_size + 2);
|
|
|
|
/* Calculate how many rows [0-n] (PIP Transactions) */
|
|
total_rows = (cal_blk_size / PT_CAL_DATA_ROW_SIZE) - 1;
|
|
remain_bytes = cal_blk_size % PT_CAL_DATA_ROW_SIZE;
|
|
/* Add row if we have a last partial row */
|
|
if (remain_bytes > 0)
|
|
total_rows++;
|
|
pt_debug(dev, DL_INFO,
|
|
"%s: CAL size=%d rows=[0-%d] partial row bytes=%d\n",
|
|
__func__, cal_blk_size, total_rows, remain_bytes);
|
|
|
|
/* Read all rows unless an error occurs */
|
|
rc = 0;
|
|
while (rc == 0 && row_number <= total_rows) {
|
|
act_trans_len = 0;
|
|
if (remain_bytes > 0 && row_number == total_rows)
|
|
transfer_size = remain_bytes;
|
|
else
|
|
transfer_size = PT_CAL_DATA_ROW_SIZE;
|
|
|
|
rc = pt_pip1_read_data_block_(cd, row_number,
|
|
transfer_size, PT_CAL_EBID,
|
|
&act_trans_len,
|
|
&cal_cache_data[byte_offset], cal_blk_size + 2,
|
|
&data_block_crc);
|
|
if (rc) {
|
|
/* Error occured, exit loop */
|
|
cal_size = 0;
|
|
break;
|
|
}
|
|
|
|
pt_debug(dev, DL_INFO,
|
|
"%s: CAL read rc=%d actual read len=%d\n",
|
|
__func__, rc, act_trans_len);
|
|
|
|
byte_offset += act_trans_len;
|
|
cal_size = byte_offset;
|
|
|
|
sprintf(prefix, "%s[%d]", "CAL DATA ROW", row_number);
|
|
pt_pr_buf(dev, DL_INFO,
|
|
&cal_cache_data[byte_offset - act_trans_len],
|
|
act_trans_len, prefix);
|
|
|
|
row_number++;
|
|
}
|
|
|
|
if (cal_size > 0) {
|
|
/* Save a CRC of the chip info the CAL was saved from */
|
|
calc_id_crc = crc_ccitt_calculate(
|
|
(u8 *)&ttdata->chip_rev, 4 + PT_UID_SIZE);
|
|
cal_cache_chip_id = calc_id_crc;
|
|
cal_cache_len = cal_size;
|
|
pt_debug(dev, DL_INFO,
|
|
"%s: CAL Cache: CRC=0x%04X Total Size=%d\n",
|
|
__func__, calc_id_crc, cal_size);
|
|
}
|
|
|
|
*size = cal_size;
|
|
*crc = calc_id_crc;
|
|
break;
|
|
case PT_CAL_DATA_RESTORE:
|
|
cal_size = cal_cache_len;
|
|
while ((rc == 0) && (byte_offset < cal_size)) {
|
|
if (cal_size - byte_offset > PT_CAL_DATA_ROW_SIZE)
|
|
transfer_size = PT_CAL_DATA_ROW_SIZE;
|
|
else
|
|
transfer_size = cal_size - byte_offset;
|
|
|
|
rc = pt_pip1_write_data_block_(cd, row_number,
|
|
transfer_size, PT_CAL_EBID,
|
|
&cal_cache_data[byte_offset],
|
|
(u8 *)pt_data_block_security_key,
|
|
&act_trans_len);
|
|
|
|
byte_offset += act_trans_len;
|
|
pt_debug(dev, DL_INFO, "%s: CAL write byte offset=%d\n",
|
|
__func__, byte_offset);
|
|
|
|
sprintf(prefix, "%s[%d]", "CAL DATA ROW", row_number);
|
|
pt_pr_buf(dev, DL_INFO,
|
|
&cal_cache_data[byte_offset - act_trans_len],
|
|
act_trans_len, prefix);
|
|
|
|
|
|
if ((byte_offset > cal_size) ||
|
|
(act_trans_len != transfer_size))
|
|
rc = -EIO;
|
|
row_number++;
|
|
}
|
|
*size = byte_offset;
|
|
*crc = cal_cache_chip_id;
|
|
break;
|
|
case PT_CAL_DATA_CLEAR:
|
|
if (cal_cache_data)
|
|
memset(&cal_cache_data[0], 0, cal_cache_len);
|
|
cal_cache_len = 0;
|
|
cal_cache_chip_id = 0;
|
|
*size = 0;
|
|
*crc = 0;
|
|
break;
|
|
case PT_CAL_DATA_INFO:
|
|
default:
|
|
*size = cal_cache_len;
|
|
*crc = cal_cache_chip_id;
|
|
pt_debug(dev, DL_INFO,
|
|
"%s: CAL Cache: CRC=%04X Total Size=%d\n",
|
|
__func__, cal_cache_chip_id,
|
|
cal_cache_len);
|
|
break;
|
|
}
|
|
|
|
exit:
|
|
pt_debug(dev, DL_INFO,
|
|
"%s: CAL Cache exit: rc=%d CRC=0x%04X Total Size=%d\n",
|
|
__func__, rc, *crc, *size);
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_pip_run_selftest_
|
|
*
|
|
* SUMMARY: Sends the PIP "Run Self Test" (0x26) command to the DUT
|
|
* to execute a FW built in self test
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* test_id - enumerated test ID to run
|
|
* write_idacs_to_flash - flag whether to write new IDACS to flash
|
|
* *status - pointer to store the read response status
|
|
* *summary_results - pointer to store the results summary
|
|
* *results_available - pointer to store if results are available
|
|
*****************************************************************************/
|
|
static int pt_pip_run_selftest_(
|
|
struct pt_core_data *cd, u8 test_id,
|
|
u8 write_idacs_to_flash, u8 *status, u8 *summary_result,
|
|
u8 *results_available)
|
|
{
|
|
int rc = 0;
|
|
u8 write_buf[2];
|
|
struct pt_hid_output hid_output = {
|
|
CREATE_PIP1_FW_CMD(PIP1_CMD_ID_RUN_SELF_TEST),
|
|
.write_length = 2,
|
|
.write_buf = write_buf,
|
|
.timeout_ms = PT_PIP1_CMD_RUN_SELF_TEST_TIMEOUT,
|
|
};
|
|
|
|
write_buf[0] = test_id;
|
|
write_buf[1] = write_idacs_to_flash;
|
|
|
|
if (cd->active_dut_generation == DUT_PIP2_CAPABLE)
|
|
hid_output.write_length = 1;
|
|
|
|
rc = pt_pip1_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];
|
|
/* results_available only available before PIP 1.03 */
|
|
if (cd->sysinfo.ready && !IS_PIP_VER_GE(&cd->sysinfo, 1, 3)) {
|
|
if (results_available)
|
|
*results_available = cd->response_buf[7];
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_pip_run_selftest
|
|
*
|
|
* SUMMARY: Protected call to pt_hid_output_run_selftest within
|
|
* an exclusive access to the DUT.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* test_id - enumerated test ID to run
|
|
* write_idacs_to_flash - flag whether to write new IDACS to flash
|
|
* *status - pointer to store the read response status
|
|
* *summary_results - pointer to store the results summary
|
|
* *results_available - pointer to store if results are available
|
|
******************************************************************************/
|
|
static int pt_pip_run_selftest(
|
|
struct pt_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, PT_REQUEST_EXCLUSIVE_TIMEOUT);
|
|
if (rc < 0) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail get exclusive ex=%p own=%p\n",
|
|
__func__, cd->exclusive_dev, cd->dev);
|
|
return rc;
|
|
}
|
|
|
|
rc = pt_pip_run_selftest_(cd, test_id,
|
|
write_idacs_to_flash, status, summary_result,
|
|
results_available);
|
|
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail to release exclusive\n", __func__);
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_request_pip_run_selftest
|
|
*
|
|
* SUMMARY: Function pointer included in core_nonhid_cmd struct for external
|
|
* calls to the protected or unprotected call to pt_pip_run_selftest
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* protect - flag to call protected or non-protected
|
|
* test_id - enumerated test ID to run
|
|
* write_idacs_to_flash - flag whether to write new IDACS to flash
|
|
* *status - pointer to store the read response status
|
|
* *summary_results - pointer to store the results summary
|
|
* *results_available - pointer to store if results are available
|
|
******************************************************************************/
|
|
static int _pt_request_pip_run_selftest(struct device *dev,
|
|
int protect, u8 test_id, u8 write_idacs_to_flash, u8 *status,
|
|
u8 *summary_result, u8 *results_available)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
|
|
if (protect)
|
|
return pt_pip_run_selftest(cd, test_id,
|
|
write_idacs_to_flash, status, summary_result,
|
|
results_available);
|
|
|
|
return pt_pip_run_selftest_(cd, test_id,
|
|
write_idacs_to_flash, status, summary_result,
|
|
results_available);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_pip_get_selftest_result_
|
|
*
|
|
* SUMMARY: Sends the PIP "Get Self Test Results" (0x27) command to the DUT
|
|
* to retrieve the self test results from the self test already executed
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* read_offset - read pointer offset
|
|
* read_length - length of data to read
|
|
* test_id - enumerated test ID to read selftest results from
|
|
* *status - pointer to store the read response status
|
|
* *actual_read_len - pointer to store data length actually read
|
|
* *status - pointer to where the cmd response statas is stored
|
|
******************************************************************************/
|
|
static int pt_pip_get_selftest_result_(
|
|
struct pt_core_data *cd, u16 read_offset, u16 read_length,
|
|
u8 test_id, u8 *status, u16 *actual_read_len, u8 *data)
|
|
{
|
|
int rc = 0;
|
|
u16 total_read_len = 0;
|
|
u16 read_len;
|
|
u16 off_buf = 0;
|
|
u8 write_buf[5];
|
|
u8 read_test_id;
|
|
bool repeat;
|
|
struct pt_hid_output hid_output = {
|
|
CREATE_PIP1_FW_CMD(PIP1_CMD_ID_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 != PT_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 = pt_pip1_send_output_and_wait_(cd, &hid_output);
|
|
if (rc)
|
|
return rc;
|
|
|
|
if (cd->response_buf[5] != PT_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;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_pip_get_selftest_result
|
|
*
|
|
* SUMMARY: Protected call to pt_hid_output_get_selftest_result by exclusive
|
|
* access to the DUT
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* read_offset - read pointer offset
|
|
* read_length - length of data to read
|
|
* test_id - enumerated test ID to read selftest results from
|
|
* *status - pointer to store the read response status
|
|
* *actual_read_len - pointer to store data length actually read
|
|
* *status - pointer to where the cmd response statas is stored
|
|
******************************************************************************/
|
|
static int pt_pip_get_selftest_result(
|
|
struct pt_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, PT_REQUEST_EXCLUSIVE_TIMEOUT);
|
|
if (rc < 0) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail get exclusive ex=%p own=%p\n",
|
|
__func__, cd->exclusive_dev, cd->dev);
|
|
return rc;
|
|
}
|
|
|
|
rc = pt_pip_get_selftest_result_(cd, read_offset,
|
|
read_length, test_id, status, actual_read_len, data);
|
|
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail to release exclusive\n", __func__);
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_request_pip_get_selftest_result
|
|
*
|
|
* SUMMARY: Function pointer included in core_nonhid_cmd struct for external
|
|
* calls to the protected or unprotected call to pt_pip_get_selftest_result
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* protect - flag to call protected or non-protected
|
|
* read_offset - read pointer offset
|
|
* read_length - length of data to read
|
|
* test_id - enumerated test ID to read selftest results from
|
|
* *status - pointer to store the read response status
|
|
* *actual_read_len - pointer to store data length actually read
|
|
* *data - pointer to where the data read is stored
|
|
******************************************************************************/
|
|
static int _pt_request_pip_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 pt_core_data *cd = dev_get_drvdata(dev);
|
|
|
|
if (protect)
|
|
return pt_pip_get_selftest_result(cd, read_offset,
|
|
read_length, test_id, status, actual_read_len,
|
|
data);
|
|
|
|
return pt_pip_get_selftest_result_(cd, read_offset,
|
|
read_length, test_id, status, actual_read_len,
|
|
data);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_pip_load_self_test_param
|
|
*
|
|
* SUMMARY: Sends the PIP "Load Self Test Parameters" (0x25) command to the DUT
|
|
* to load paramters needed by a self test
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* self_test_id - enumerated test ID for which the parmeters belong
|
|
* load_offset - mem offset to where to load parameters
|
|
* load_length - length of parameter data to load
|
|
* *parameters - pointer to list of parameter data
|
|
* *status - pointer to store the response status
|
|
* *ret_test_id - pointer to returned test id the paramters were stored
|
|
* *act_load_len - pointer to store the actual load length that was writen
|
|
******************************************************************************/
|
|
static int pt_pip_load_self_test_param_(struct pt_core_data *cd,
|
|
u8 self_test_id, u16 load_offset, u16 load_length,
|
|
u8 *parameters, u8 *status, u8 *ret_test_id, u16 *act_load_len)
|
|
{
|
|
int rc = 0;
|
|
int i;
|
|
u8 write_buf[PT_MAX_PIP1_MSG_SIZE];
|
|
struct pt_hid_output hid_output = {
|
|
CREATE_PIP1_FW_CMD(PIP1_CMD_ID_LOAD_SELF_TEST_PARAM),
|
|
.write_length = 5 + load_length,
|
|
.write_buf = write_buf,
|
|
.timeout_ms = PT_PIP1_CMD_DEFAULT_TIMEOUT,
|
|
};
|
|
|
|
write_buf[0] = LOW_BYTE(load_offset);
|
|
write_buf[1] = HI_BYTE(load_offset);
|
|
write_buf[2] = LOW_BYTE(load_length);
|
|
write_buf[3] = HI_BYTE(load_length);
|
|
write_buf[4] = self_test_id;
|
|
for (i = 0; i < load_length; i++)
|
|
write_buf[i + 5] = parameters[i];
|
|
|
|
rc = pt_pip1_send_output_and_wait_(cd, &hid_output);
|
|
if (rc)
|
|
return rc;
|
|
|
|
if (status)
|
|
*status = cd->response_buf[5];
|
|
if (ret_test_id)
|
|
*ret_test_id = cd->response_buf[6];
|
|
if (act_load_len)
|
|
*act_load_len = get_unaligned_le16(&cd->response_buf[7]);
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_pip_load_self_test_param
|
|
*
|
|
* SUMMARY: Protected call to pt_pip_load_self_test_param_ within an exclusive
|
|
* access to the DUT.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* self_test_id - enumerated test ID for which the parmeters belong
|
|
* load_offset - mem offset to where to load parameters
|
|
* load_length - length of parameter data to load
|
|
* *parameters - pointer to list of parameter data
|
|
* *status - pointer to store the response status
|
|
* *ret_test_id - pointer to returned test id the paramters were stored
|
|
* *act_load_len - pointer to store the actual load length that was writen
|
|
******************************************************************************/
|
|
static int pt_pip_load_self_test_param(struct pt_core_data *cd,
|
|
u8 self_test_id, u16 load_offset, u16 load_length,
|
|
u8 *parameters, u8 *status, u8 *ret_test_id, u16 *act_load_len)
|
|
{
|
|
int rc;
|
|
|
|
rc = request_exclusive(cd, cd->dev, PT_REQUEST_EXCLUSIVE_TIMEOUT);
|
|
if (rc < 0) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail get exclusive ex=%p own=%p\n",
|
|
__func__, cd->exclusive_dev, cd->dev);
|
|
return rc;
|
|
}
|
|
|
|
rc = pt_pip_load_self_test_param_(cd, self_test_id, load_offset,
|
|
load_length, parameters, status, ret_test_id, act_load_len);
|
|
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail to release exclusive\n", __func__);
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_request_pip_load_self_test_param
|
|
*
|
|
* SUMMARY: Function pointer included in core_nonhid_cmd struct for external
|
|
* calls to the protected or unprotected call to
|
|
* pt_pip_load_self_test_param
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* protect - flag to call protected or non-protected
|
|
* self_test_id - enumerated test ID for which the parmeters belong
|
|
* load_offset - mem offset to where to load parameters
|
|
* load_length - length of parameter data to load
|
|
* *parameters - pointer to list of parameter data
|
|
* *status - pointer to store the response status
|
|
* *ret_test_id - pointer to returned test id the paramters were stored
|
|
* *act_load_len - pointer to store the actual load length that was writen
|
|
******************************************************************************/
|
|
static int _pt_request_pip_load_self_test_param(struct device *dev,
|
|
int protect, u8 self_test_id, u16 load_offset, u16 load_length,
|
|
u8 *parameters, u8 *status, u8 *ret_test_id, u16 *act_load_len)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
|
|
if (protect)
|
|
return pt_pip_load_self_test_param(cd, self_test_id,
|
|
load_offset, load_length, parameters, status, ret_test_id,
|
|
act_load_len);
|
|
|
|
return pt_pip_load_self_test_param_(cd, self_test_id, load_offset,
|
|
load_length, parameters, status, ret_test_id, act_load_len);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_pip_calibrate_ext_
|
|
*
|
|
* SUMMARY: Send the PIP1 Extended Calibrate command (0x30) to the DUT waiting
|
|
* for the response
|
|
*
|
|
* NOTE: This calibrate command requires the DUT to support PIP version >= 1.10
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* *cal_data - pointer to extended calibration data structure
|
|
* *status - pointer to where the command response status is stored
|
|
******************************************************************************/
|
|
static int pt_pip_calibrate_ext_(struct pt_core_data *cd,
|
|
struct pt_cal_ext_data *cal_data, u8 *status)
|
|
{
|
|
int rc = 0;
|
|
int write_length = 4;
|
|
u8 write_buf[4];
|
|
u16 size = 0;
|
|
unsigned short crc = 0;
|
|
|
|
struct pt_hid_output hid_output = {
|
|
CREATE_PIP1_FW_CMD(PIP1_CMD_ID_CALIBRATE_DEVICE_EXTENDED),
|
|
.write_length = write_length,
|
|
.write_buf = write_buf,
|
|
.timeout_ms = PT_PIP1_CMD_CALIBRATE_EXT_TIMEOUT,
|
|
};
|
|
|
|
if (cal_data == NULL)
|
|
return -EINVAL;
|
|
|
|
memcpy(write_buf, cal_data, sizeof(struct pt_cal_ext_data));
|
|
|
|
rc = pt_pip1_send_output_and_wait_(cd, &hid_output);
|
|
if (rc)
|
|
return rc;
|
|
|
|
if (status)
|
|
*status = cd->response_buf[5];
|
|
|
|
/*
|
|
* When doing a calibration on a flashless DUT, save CAL data in
|
|
* the TTDL cache on any successful calibration
|
|
*/
|
|
if (*status == 0 && cd->cal_cache_in_host) {
|
|
pt_debug(cd->dev, DL_INFO, "%s: Retrieve and Save CAL\n",
|
|
__func__);
|
|
rc = _pt_manage_local_cal_data(cd->dev, PT_CAL_DATA_SAVE,
|
|
&size, &crc);
|
|
if (rc)
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: Error Saving CAL rc=%d\n", __func__, rc);
|
|
else
|
|
pt_debug(cd->dev, DL_INFO,
|
|
"%s: Saved CAL: chip ID=0x%04X size=%d\n",
|
|
__func__, crc, size);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_pip_calibrate_ext
|
|
*
|
|
* SUMMARY: Protected call to pt_pip_calibrate_ext_ by exclusive access to the
|
|
* DUT
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* *cal_data - pointer to extended calibration data structure
|
|
* *status - pointer to where the command response status is stored
|
|
******************************************************************************/
|
|
static int pt_pip_calibrate_ext(struct pt_core_data *cd,
|
|
struct pt_cal_ext_data *cal_data, u8 *status)
|
|
{
|
|
int rc;
|
|
|
|
rc = request_exclusive(cd, cd->dev, PT_REQUEST_EXCLUSIVE_TIMEOUT);
|
|
if (rc < 0) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail get exclusive ex=%p own=%p\n",
|
|
__func__, cd->exclusive_dev, cd->dev);
|
|
return rc;
|
|
}
|
|
|
|
rc = pt_pip_calibrate_ext_(cd, cal_data, status);
|
|
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail to release exclusive\n", __func__);
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_request_pip_calibrate_ext
|
|
*
|
|
* SUMMARY: Function pointer included in core_nonhid_cmd struct for external
|
|
* calls to the protected or unprotected call to pt_pip_calibrate_ext
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* protect - flag to call protected or non-protected
|
|
* *cal_data - pointer to extended calibration data structure
|
|
* *status - pointer to where the command response status is stored
|
|
******************************************************************************/
|
|
static int _pt_request_pip_calibrate_ext(struct device *dev,
|
|
int protect, struct pt_cal_ext_data *cal_data, u8 *status)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
|
|
if (protect)
|
|
return pt_pip_calibrate_ext(cd, cal_data, status);
|
|
|
|
return pt_pip_calibrate_ext_(cd, cal_data, status);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_pip_calibrate_idacs_
|
|
*
|
|
* SUMMARY: Send the PIP Calibrate IDACs command (0x28) to the DUT waiting
|
|
* for the response
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* mode - sense mode to calibrate (0-5)
|
|
* *status - pointer to where the command response status is stored
|
|
******************************************************************************/
|
|
static int pt_pip_calibrate_idacs_(struct pt_core_data *cd,
|
|
u8 mode, u8 *status)
|
|
{
|
|
int rc = 0;
|
|
int write_length = 1;
|
|
u8 write_buf[1];
|
|
u8 cmd_offset = 0;
|
|
struct pt_hid_output hid_output = {
|
|
CREATE_PIP1_FW_CMD(PIP1_CMD_ID_CALIBRATE_IDACS),
|
|
.write_length = write_length,
|
|
.write_buf = write_buf,
|
|
.timeout_ms = PT_PIP1_CMD_CALIBRATE_IDAC_TIMEOUT,
|
|
};
|
|
|
|
write_buf[cmd_offset++] = mode;
|
|
rc = pt_pip1_send_output_and_wait_(cd, &hid_output);
|
|
if (rc)
|
|
return rc;
|
|
|
|
*status = cd->response_buf[5];
|
|
if (*status)
|
|
return -EINVAL;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_pip_calibrate_idacs
|
|
*
|
|
* SUMMARY: Protected call to pt_hid_output_calibrate_idacs_ by exclusive
|
|
* access to the DUT
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* mode - sense mode to calibrate (0-5)
|
|
* *status - pointer to where the command response status is stored
|
|
******************************************************************************/
|
|
static int pt_pip_calibrate_idacs(struct pt_core_data *cd,
|
|
u8 mode, u8 *status)
|
|
{
|
|
int rc;
|
|
|
|
rc = request_exclusive(cd, cd->dev, PT_REQUEST_EXCLUSIVE_TIMEOUT);
|
|
if (rc < 0) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail get exclusive ex=%p own=%p\n",
|
|
__func__, cd->exclusive_dev, cd->dev);
|
|
return rc;
|
|
}
|
|
|
|
rc = pt_pip_calibrate_idacs_(cd, mode, status);
|
|
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail to release exclusive\n", __func__);
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_request_pip_calibrate_idacs
|
|
*
|
|
* SUMMARY: Function pointer included in core_nonhid_cmd struct for external
|
|
* calls to the protected or unprotected call to pt_pip_calibrate_idacs
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* protect - flag to call protected or non-protected
|
|
* mode - sense mode to calibrate (0-5)
|
|
* *status - pointer to where the command response status is stored
|
|
******************************************************************************/
|
|
static int _pt_request_pip_calibrate_idacs(struct device *dev,
|
|
int protect, u8 mode, u8 *status)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
|
|
if (protect)
|
|
return pt_pip_calibrate_idacs(cd, mode, status);
|
|
|
|
return pt_pip_calibrate_idacs_(cd, mode, status);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_hid_output_initialize_baselines_
|
|
*
|
|
* SUMMARY: Send the PIP "Initialize Baselines" command (0x29) to the DUT
|
|
* waiting for the response.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* test_id - bit type flag to allow initialize baseline MUT,BTN,SELG
|
|
* each or together with a single command.
|
|
* *status - pointer to where the command response status is stored
|
|
******************************************************************************/
|
|
static int pt_hid_output_initialize_baselines_(
|
|
struct pt_core_data *cd, u8 test_id, u8 *status)
|
|
{
|
|
int rc = 0;
|
|
int write_length = 1;
|
|
u8 write_buf[1];
|
|
u8 cmd_offset = 0;
|
|
struct pt_hid_output hid_output = {
|
|
CREATE_PIP1_FW_CMD(PIP1_CMD_ID_INITIALIZE_BASELINES),
|
|
.write_length = write_length,
|
|
.write_buf = write_buf,
|
|
};
|
|
|
|
write_buf[cmd_offset++] = test_id;
|
|
|
|
rc = pt_pip1_send_output_and_wait_(cd, &hid_output);
|
|
if (rc)
|
|
return rc;
|
|
|
|
*status = cd->response_buf[5];
|
|
if (*status)
|
|
return -EINVAL;
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_hid_output_initialize_baselines
|
|
*
|
|
* SUMMARY: Protected call to pt_hid_output_initialize_baselines_ by exclusive
|
|
* access to the DUT
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* test_id - enumerated ID against which to initialize the baseline
|
|
* *status - pointer to where the command response status is stored
|
|
******************************************************************************/
|
|
static int pt_hid_output_initialize_baselines(struct pt_core_data *cd,
|
|
u8 test_id, u8 *status)
|
|
{
|
|
int rc;
|
|
|
|
rc = request_exclusive(cd, cd->dev, PT_REQUEST_EXCLUSIVE_TIMEOUT);
|
|
if (rc < 0) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail get exclusive ex=%p own=%p\n",
|
|
__func__, cd->exclusive_dev, cd->dev);
|
|
return rc;
|
|
}
|
|
|
|
rc = pt_hid_output_initialize_baselines_(cd, test_id, status);
|
|
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail to release exclusive\n", __func__);
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_request_pip_initialize_baselines
|
|
*
|
|
* SUMMARY: Function pointer included in core_nonhid_cmd struct for external
|
|
* calls to the protected or unprotected call to
|
|
* pt_pip_initialize_baselines
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* protect - flag to call protected or non-protected
|
|
* test_id - enumerated ID against which to initialize the baseline
|
|
* *status - pointer to where the command response status is stored
|
|
******************************************************************************/
|
|
static int _pt_request_pip_initialize_baselines(struct device *dev,
|
|
int protect, u8 test_id, u8 *status)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
|
|
if (protect)
|
|
return pt_hid_output_initialize_baselines(cd, test_id,
|
|
status);
|
|
|
|
return pt_hid_output_initialize_baselines_(cd, test_id, status);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_hid_output_exec_panel_scan_
|
|
*
|
|
* SUMMARY: Sends the PIP "Execute Panel Scan" (0x2A) to the DUT and waits for
|
|
* the response
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
******************************************************************************/
|
|
static int pt_hid_output_exec_panel_scan_(struct pt_core_data *cd)
|
|
{
|
|
struct pt_hid_output hid_output = {
|
|
CREATE_PIP1_FW_CMD(PIP1_CMD_ID_EXEC_PANEL_SCAN),
|
|
};
|
|
|
|
return pt_pip1_send_output_and_wait_(cd, &hid_output);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_hid_output_exec_panel_scan
|
|
*
|
|
* SUMMARY: Protected call to pt_hid_output_exec_panel_scan_ by exclusive
|
|
* access to the DUT.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
******************************************************************************/
|
|
static int pt_hid_output_exec_panel_scan(struct pt_core_data *cd)
|
|
{
|
|
int rc;
|
|
|
|
rc = request_exclusive(cd, cd->dev, PT_REQUEST_EXCLUSIVE_TIMEOUT);
|
|
if (rc < 0) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail get exclusive ex=%p own=%p\n",
|
|
__func__, cd->exclusive_dev, cd->dev);
|
|
return rc;
|
|
}
|
|
|
|
rc = pt_hid_output_exec_panel_scan_(cd);
|
|
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail to release exclusive\n", __func__);
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_pip2_exec_panel_scan_
|
|
*
|
|
* SUMMARY: Send the PIP2 "Execute Panel Scan" (0x21) to the DUT and waits for
|
|
* the response
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* scan_type - type of panel scan to perform (PIP2 only)
|
|
******************************************************************************/
|
|
static int pt_pip2_exec_panel_scan_(struct pt_core_data *cd, u8 scan_type)
|
|
{
|
|
int rc = 0;
|
|
u8 data[2];
|
|
u8 read_buf[10];
|
|
u16 actual_read_len;
|
|
|
|
pt_debug(cd->dev, DL_DEBUG, "%s: PIP2 Execute Scan %d\n",
|
|
__func__, scan_type);
|
|
data[0] = scan_type;
|
|
rc = _pt_request_pip2_send_cmd(cd->dev,
|
|
PT_CORE_CMD_UNPROTECTED, PIP2_CMD_EXECUTE_SCAN,
|
|
data, 1, read_buf, &actual_read_len);
|
|
if (rc) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s EXECUTE_SCAN command for type %d failed. rc=%d\n",
|
|
__func__, scan_type, rc);
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_pip2_exec_panel_scan
|
|
*
|
|
* SUMMARY: Protected call to pt_pip2_exec_panel_scan_ by exclusive
|
|
* access to the DUT.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* scan_type - type of panel scan to perform (PIP2 only)
|
|
******************************************************************************/
|
|
static int pt_pip2_exec_panel_scan(struct pt_core_data *cd, u8 scan_type)
|
|
{
|
|
int rc;
|
|
|
|
rc = request_exclusive(cd, cd->dev, PT_REQUEST_EXCLUSIVE_TIMEOUT);
|
|
if (rc < 0) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail get exclusive ex=%p own=%p\n",
|
|
__func__, cd->exclusive_dev, cd->dev);
|
|
return rc;
|
|
}
|
|
|
|
rc = pt_pip2_exec_panel_scan_(cd, scan_type);
|
|
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail to release exclusive\n", __func__);
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_request_pip_exec_panel_scan
|
|
*
|
|
* SUMMARY: Function pointer included in core_nonhid_cmd struct for external
|
|
* calls to the protected or unprotected call to
|
|
* pt_pip2_exec_panel_scan or pt_hid_output_exec_panel_scan
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* protect - flag to call protected or non-protected
|
|
* scan_type - type of panel scan to perform (PIP2 only)
|
|
******************************************************************************/
|
|
static int _pt_request_pip_exec_panel_scan(struct device *dev,
|
|
int protect, u8 scan_type)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
|
|
if (cd->sysinfo.ready && IS_PIP_VER_GE(&cd->sysinfo, 1, 12)) {
|
|
if (protect)
|
|
return pt_pip2_exec_panel_scan(cd, scan_type);
|
|
|
|
return pt_pip2_exec_panel_scan_(cd, scan_type);
|
|
}
|
|
|
|
if (protect)
|
|
return pt_hid_output_exec_panel_scan(cd);
|
|
|
|
return pt_hid_output_exec_panel_scan_(cd);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_hid_output_retrieve_panel_scan_
|
|
*
|
|
* SUMMARY: Sends the PIP "Retrieve Panel Scan" (0x2B) command to the DUT
|
|
* to retrieve the specified data type for a the last successful Execute
|
|
* Panel Scan command.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* protect - flag to call protected or non-protected
|
|
* read_offset - read pointer offset
|
|
* read_count - length of data to read
|
|
* data_id - enumerated test ID to read selftest results from
|
|
* *response - pointer to store the read response status
|
|
* *config - pointer to store config data
|
|
* *actual_read_len - pointer to store data length actually read
|
|
* *read_buf - pointer to the read buffer
|
|
******************************************************************************/
|
|
static int pt_hid_output_retrieve_panel_scan_(
|
|
struct pt_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 = 0;
|
|
int write_length = 5;
|
|
u8 write_buf[5];
|
|
u8 cmd_offset = 0;
|
|
u8 data_elem_size;
|
|
int size;
|
|
int data_size;
|
|
struct pt_hid_output hid_output = {
|
|
CREATE_PIP1_FW_CMD(PIP1_CMD_ID_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 = pt_pip1_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;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_hid_output_retrieve_panel_scan
|
|
*
|
|
* SUMMARY: Protected call to pt_hid_output_retrieve_panel_scan_ by exclusive
|
|
* access to the DUT.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* protect - flag to call protected or non-protected
|
|
* read_offset - read pointer offset
|
|
* read_count - length of data to read
|
|
* data_id - enumerated test ID to read selftest results from
|
|
* *response - pointer to store the read response status
|
|
* *config - pointer to store config data
|
|
* *actual_read_len - pointer to store data length actually read
|
|
* *read_buf - pointer to the read buffer
|
|
******************************************************************************/
|
|
static int pt_hid_output_retrieve_panel_scan(
|
|
struct pt_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, PT_REQUEST_EXCLUSIVE_TIMEOUT);
|
|
if (rc < 0) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail get exclusive ex=%p own=%p\n",
|
|
__func__, cd->exclusive_dev, cd->dev);
|
|
return rc;
|
|
}
|
|
|
|
rc = pt_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)
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail to release exclusive\n", __func__);
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_request_pip_retrieve_panel_scan
|
|
*
|
|
* SUMMARY: Function pointer included in core_nonhid_cmd struct for external
|
|
* calls to the protected or unprotected call to
|
|
* pt_hid_output_retrieve_panel_scan
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* protect - flag to call protected or non-protected
|
|
* read_offset - read pointer offset
|
|
* read_count - length of data to read
|
|
* data_id - enumerated test ID to read selftest results from
|
|
* *response - pointer to store the read response status
|
|
* *config - pointer to store config data
|
|
* *actual_read_len - pointer to store data length actually read
|
|
* *read_buf - pointer to the read buffer
|
|
******************************************************************************/
|
|
static int _pt_request_pip_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 pt_core_data *cd = dev_get_drvdata(dev);
|
|
|
|
if (protect)
|
|
return pt_hid_output_retrieve_panel_scan(cd,
|
|
read_offset, read_count, data_id, response,
|
|
config, actual_read_len, read_buf);
|
|
|
|
return pt_hid_output_retrieve_panel_scan_(cd,
|
|
read_offset, read_count, data_id, response,
|
|
config, actual_read_len, read_buf);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_request_pip_user_cmd
|
|
*
|
|
* SUMMARY: Function pointer included in core_nonhid_cmd struct for external
|
|
* calls to the protected or unprotected call to
|
|
* pt_hid_output_user_cmd
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* protect - flag to call protected or non-protected
|
|
* read_len - length of data to read
|
|
* *read_buf - pointer to store read data
|
|
* write_len - length of data to write
|
|
* *write_buf - pointer to buffer to write
|
|
* *actual_read_len - pointer to store data length actually read
|
|
******************************************************************************/
|
|
static int _pt_request_pip_user_cmd(struct device *dev,
|
|
int protect, u16 read_len, u8 *read_buf, u16 write_len,
|
|
u8 *write_buf, u16 *actual_read_len)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
|
|
if (protect)
|
|
return pt_hid_output_user_cmd(cd, read_len, read_buf,
|
|
write_len, write_buf, actual_read_len);
|
|
|
|
return pt_hid_output_user_cmd_(cd, read_len, read_buf,
|
|
write_len, write_buf, actual_read_len);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_hid_output_bl_get_information_
|
|
*
|
|
* SUMMARY: Sends the PIP "Get Bootloader Information" (0x38) command to the
|
|
* DUT to retrieve bootloader version and chip identification information.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* *return_data - pointer to store the return data
|
|
*****************************************************************************/
|
|
static int pt_hid_output_bl_get_information_(struct pt_core_data *cd,
|
|
u8 *return_data)
|
|
{
|
|
int rc;
|
|
int data_len;
|
|
struct pt_hid_output hid_output = {
|
|
CREATE_PIP1_BL_CMD(PIP1_BL_CMD_ID_GET_INFO),
|
|
};
|
|
|
|
rc = pt_pip1_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;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_hid_output_bl_get_information
|
|
*
|
|
* SUMMARY: Protected call to pt_hid_output_bl_get_information_ by exclusive
|
|
* access to the DUT.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* *return_data - pointer to store the return data
|
|
******************************************************************************/
|
|
static int pt_hid_output_bl_get_information(struct pt_core_data *cd,
|
|
u8 *return_data)
|
|
{
|
|
int rc;
|
|
|
|
rc = request_exclusive(cd, cd->dev, PT_REQUEST_EXCLUSIVE_TIMEOUT);
|
|
if (rc < 0) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail get exclusive ex=%p own=%p\n",
|
|
__func__, cd->exclusive_dev, cd->dev);
|
|
return rc;
|
|
}
|
|
|
|
rc = pt_hid_output_bl_get_information_(cd, return_data);
|
|
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail to release exclusive\n", __func__);
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_request_pip_bl_get_information
|
|
*
|
|
* SUMMARY: Function pointer included in core_nonhid_cmd struct for external
|
|
* calls to the protected or unprotected call to
|
|
* pt_hid_output_bl_get_information
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* protect - flag to call protected or non-protected
|
|
* *return_data - pointer to store bl data
|
|
******************************************************************************/
|
|
static int _pt_request_pip_bl_get_information(struct device *dev,
|
|
int protect, u8 *return_data)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
|
|
if (protect)
|
|
return pt_hid_output_bl_get_information(cd, return_data);
|
|
|
|
return pt_hid_output_bl_get_information_(cd, return_data);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_hid_output_bl_initiate_bl_
|
|
*
|
|
* SUMMARY: Sends the PIP "Get Bootloader Information" (0x48) command to the
|
|
* DUT to erases the entire TrueTouch application, Configuration Data block,
|
|
* and Design Data block in flash and enables the host to execute the Program
|
|
* and Verify Row command to bootload the application image and data.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* protect - flag to call protected or non-protected
|
|
* key_size - size of key
|
|
* *key_buf - pointer to key data to allow operation
|
|
* row_size - size of the meta data row
|
|
* *metadata_row_buf - pointer to meta data to write
|
|
******************************************************************************/
|
|
static int pt_hid_output_bl_initiate_bl_(struct pt_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 = 0;
|
|
struct pt_hid_output hid_output = {
|
|
CREATE_PIP1_BL_CMD(PIP1_BL_CMD_ID_INITIATE_BL),
|
|
.write_length = write_length,
|
|
.timeout_ms = PT_PIP1_CMD_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 = pt_pip1_send_output_and_wait_(cd, &hid_output);
|
|
|
|
kfree(write_buf);
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_hid_output_bl_initiate_bl
|
|
*
|
|
* SUMMARY: Protected call to pt_hid_output_bl_initiate_bl_ by exclusive
|
|
* access to the DUT.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* key_size - size of key
|
|
* *key_buf - pointer to key data to allow operation
|
|
* row_size - size of the meta data row
|
|
* *metadata_row_buf - pointer to meta data to write
|
|
******************************************************************************/
|
|
static int pt_hid_output_bl_initiate_bl(struct pt_core_data *cd,
|
|
u16 key_size, u8 *key_buf, u16 row_size, u8 *metadata_row_buf)
|
|
{
|
|
int rc;
|
|
|
|
rc = request_exclusive(cd, cd->dev, PT_REQUEST_EXCLUSIVE_TIMEOUT);
|
|
if (rc < 0) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail get exclusive ex=%p own=%p\n",
|
|
__func__, cd->exclusive_dev, cd->dev);
|
|
return rc;
|
|
}
|
|
|
|
rc = pt_hid_output_bl_initiate_bl_(cd, key_size, key_buf,
|
|
row_size, metadata_row_buf);
|
|
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail to release exclusive\n", __func__);
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_request_pip_bl_initiate_bl
|
|
*
|
|
* SUMMARY: Function pointer included in core_nonhid_cmd struct for external
|
|
* calls to the protected or unprotected call to
|
|
* pt_hid_output_bl_initiate_bl
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* protect - flag to call protected or non-protected
|
|
* key_size - size of key
|
|
* *key_buf - pointer to key data to allow operation
|
|
* row_size - size of the meta data row
|
|
* *metadata_row_buf - pointer to meta data to write
|
|
******************************************************************************/
|
|
static int _pt_request_pip_bl_initiate_bl(struct device *dev,
|
|
int protect, u16 key_size, u8 *key_buf, u16 row_size,
|
|
u8 *metadata_row_buf)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
|
|
if (protect)
|
|
return pt_hid_output_bl_initiate_bl(cd, key_size, key_buf,
|
|
row_size, metadata_row_buf);
|
|
|
|
return pt_hid_output_bl_initiate_bl_(cd, key_size, key_buf,
|
|
row_size, metadata_row_buf);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_hid_output_bl_program_and_verify_
|
|
*
|
|
* SUMMARY: Sends the PIP "Get Bootloader Information" (0x39) command to upload
|
|
* and program a 128-byte row into the flash, and then verifies written data.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* data_len - length of data_buf
|
|
* *data_buf - firmware image to program
|
|
******************************************************************************/
|
|
static int pt_hid_output_bl_program_and_verify_(
|
|
struct pt_core_data *cd, u16 data_len, u8 *data_buf)
|
|
{
|
|
struct pt_hid_output hid_output = {
|
|
CREATE_PIP1_BL_CMD(PIP1_BL_CMD_ID_PROGRAM_AND_VERIFY),
|
|
.write_length = data_len,
|
|
.write_buf = data_buf,
|
|
.timeout_ms = PT_PIP1_CMD_PROGRAM_AND_VERIFY_TIMEOUT,
|
|
};
|
|
|
|
return pt_pip1_send_output_and_wait_(cd, &hid_output);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_hid_output_bl_program_and_verify
|
|
*
|
|
* SUMMARY: Protected call to pt_hid_output_bl_program_and_verify_ by exclusive
|
|
* access to the DUT.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* data_len - length of data_buf
|
|
* *data_buf - firmware image to program
|
|
******************************************************************************/
|
|
static int pt_hid_output_bl_program_and_verify(
|
|
struct pt_core_data *cd, u16 data_len, u8 *data_buf)
|
|
{
|
|
int rc;
|
|
|
|
rc = request_exclusive(cd, cd->dev, PT_REQUEST_EXCLUSIVE_TIMEOUT);
|
|
if (rc < 0) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail get exclusive ex=%p own=%p\n",
|
|
__func__, cd->exclusive_dev, cd->dev);
|
|
return rc;
|
|
}
|
|
|
|
rc = pt_hid_output_bl_program_and_verify_(cd, data_len, data_buf);
|
|
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail to release exclusive\n", __func__);
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_request_pip_bl_program_and_verify
|
|
*
|
|
* SUMMARY: Function pointer included in core_nonhid_cmds to allow other modules
|
|
* to request to have the BL program and verify a FW image
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* protect - boolean to determine to call the protected function
|
|
* data_len - length of data_buf
|
|
* *data_buf - firmware image to program
|
|
******************************************************************************/
|
|
static int _pt_request_pip_bl_program_and_verify(
|
|
struct device *dev, int protect, u16 data_len, u8 *data_buf)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
|
|
if (protect)
|
|
return pt_hid_output_bl_program_and_verify(cd, data_len,
|
|
data_buf);
|
|
|
|
return pt_hid_output_bl_program_and_verify_(cd, data_len,
|
|
data_buf);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_hid_output_bl_verify_app_integrity_
|
|
*
|
|
* SUMMARY: Sends the PIP "Get Bootloader Information" (0x31) command to
|
|
* perform a full verification of the application integrity by calculating the
|
|
* CRC of the image in flash and compare it to the expected CRC stored in the
|
|
* Metadata row.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* *result - pointer to store result
|
|
******************************************************************************/
|
|
static int pt_hid_output_bl_verify_app_integrity_(
|
|
struct pt_core_data *cd, u8 *result)
|
|
{
|
|
int rc;
|
|
struct pt_hid_output hid_output = {
|
|
CREATE_PIP1_BL_CMD(PIP1_BL_CMD_ID_VERIFY_APP_INTEGRITY),
|
|
};
|
|
|
|
rc = pt_pip1_send_output_and_wait_(cd, &hid_output);
|
|
if (rc) {
|
|
*result = 0;
|
|
return rc;
|
|
}
|
|
|
|
*result = cd->response_buf[8];
|
|
return 0;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_hid_output_bl_verify_app_integrity
|
|
*
|
|
* SUMMARY: Protected call to pt_hid_output_bl_verify_app_integrity_ by
|
|
* exclusive access to the DUT.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* *result - pointer to store result
|
|
******************************************************************************/
|
|
static int pt_hid_output_bl_verify_app_integrity(
|
|
struct pt_core_data *cd, u8 *result)
|
|
{
|
|
int rc;
|
|
|
|
rc = request_exclusive(cd, cd->dev, PT_REQUEST_EXCLUSIVE_TIMEOUT);
|
|
if (rc < 0) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail get exclusive ex=%p own=%p\n",
|
|
__func__, cd->exclusive_dev, cd->dev);
|
|
return rc;
|
|
}
|
|
|
|
rc = pt_hid_output_bl_verify_app_integrity_(cd, result);
|
|
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail to release exclusive\n", __func__);
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_request_pip_bl_verify_app_integrity
|
|
*
|
|
* SUMMARY: Function pointer included in core_nonhid_cmds to allow other modules
|
|
* to request to have the BL verify the application integrity (PIP1.x only)
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* protect - boolean to determine to call the protected function
|
|
* *result - pointer to store result
|
|
******************************************************************************/
|
|
static int _pt_request_pip_bl_verify_app_integrity(
|
|
struct device *dev, int protect, u8 *result)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
|
|
if (protect)
|
|
return pt_hid_output_bl_verify_app_integrity(cd, result);
|
|
|
|
return pt_hid_output_bl_verify_app_integrity_(cd, result);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_hid_output_bl_launch_app_
|
|
*
|
|
* SUMMARY: Sends the PIP "Launch Application" (0x3B) command to launch the
|
|
* application from bootloader (PIP1.x only).
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
******************************************************************************/
|
|
static int pt_hid_output_bl_launch_app_(struct pt_core_data *cd)
|
|
{
|
|
struct pt_hid_output hid_output = {
|
|
CREATE_PIP1_BL_CMD(PIP1_BL_CMD_ID_LAUNCH_APP),
|
|
.reset_expected = 1,
|
|
};
|
|
|
|
return pt_pip1_send_output_and_wait_(cd, &hid_output);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_hid_output_bl_launch_app
|
|
*
|
|
* SUMMARY: Protected call to pt_hid_output_bl_launch_app_ by exclusive access
|
|
* to the DUT.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
******************************************************************************/
|
|
static int pt_hid_output_bl_launch_app(struct pt_core_data *cd)
|
|
{
|
|
int rc;
|
|
|
|
rc = request_exclusive(cd, cd->dev, PT_REQUEST_EXCLUSIVE_TIMEOUT);
|
|
if (rc < 0) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail get exclusive ex=%p own=%p\n",
|
|
__func__, cd->exclusive_dev, cd->dev);
|
|
return rc;
|
|
}
|
|
|
|
rc = pt_hid_output_bl_launch_app_(cd);
|
|
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail to release exclusive\n", __func__);
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_request_pip_launch_app
|
|
*
|
|
* SUMMARY: Function pointer included in core_nonhid_cmds to allow other modules
|
|
* to request to have the BL launch the application. (PIP1.x only)
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* protect - boolean to determine to call the protected function
|
|
******************************************************************************/
|
|
static int _pt_request_pip_launch_app(struct device *dev,
|
|
int protect)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
|
|
if (protect)
|
|
return pt_hid_output_bl_launch_app(cd);
|
|
|
|
return pt_hid_output_bl_launch_app_(cd);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_hid_output_bl_get_panel_id_
|
|
*
|
|
* SUMMARY: Sends the PIP "Get Panel ID" (0x3E) command to return the Panel ID
|
|
* value store in the System Information.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* *panel_id - pointer to where the panel ID will be stored
|
|
******************************************************************************/
|
|
static int pt_hid_output_bl_get_panel_id_(
|
|
struct pt_core_data *cd, u8 *panel_id)
|
|
{
|
|
int rc;
|
|
struct pt_hid_output hid_output = {
|
|
CREATE_PIP1_BL_CMD(PIP1_BL_CMD_ID_GET_PANEL_ID),
|
|
};
|
|
|
|
rc = pt_pip1_send_output_and_wait_(cd, &hid_output);
|
|
if (rc == -EPROTO && cd->response_buf[5] == ERROR_COMMAND) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: Get Panel ID command not supported\n",
|
|
__func__);
|
|
*panel_id = PANEL_ID_NOT_ENABLED;
|
|
return 0;
|
|
} else if (rc < 0) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: Error on Get Panel ID command\n", __func__);
|
|
return rc;
|
|
}
|
|
|
|
*panel_id = cd->response_buf[8];
|
|
return 0;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_hid_output_bl_get_panel_id
|
|
*
|
|
* SUMMARY: Protected call to pt_hid_output_bl_get_panel_id_ by exclusive access
|
|
* to the DUT.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* *panel_id - pointer to where the panel ID will be stored
|
|
******************************************************************************/
|
|
static int pt_hid_output_bl_get_panel_id(
|
|
struct pt_core_data *cd, u8 *panel_id)
|
|
{
|
|
int rc;
|
|
|
|
rc = request_exclusive(cd, cd->dev, PT_REQUEST_EXCLUSIVE_TIMEOUT);
|
|
if (rc < 0) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail get exclusive ex=%p own=%p\n",
|
|
__func__, cd->exclusive_dev, cd->dev);
|
|
return rc;
|
|
}
|
|
|
|
rc = pt_hid_output_bl_get_panel_id_(cd, panel_id);
|
|
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail to release exclusive\n", __func__);
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_request_pip_bl_get_panel_id
|
|
*
|
|
* SUMMARY: Function pointer included in core_nonhid_cmds to allow other modules
|
|
* to have the BL retrieve the panel ID
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* protect - flag to run in protected mode
|
|
* *panel_id - pointer to where the panel ID will be stored
|
|
******************************************************************************/
|
|
static int _pt_request_pip_bl_get_panel_id(
|
|
struct device *dev, int protect, u8 *panel_id)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
|
|
if (protect)
|
|
return pt_hid_output_bl_get_panel_id(cd, panel_id);
|
|
|
|
return pt_hid_output_bl_get_panel_id_(cd, panel_id);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_pip2_get_mode_sysmode_
|
|
*
|
|
* SUMMARY: Determine the current mode and system mode of the DUT by use of the
|
|
* PIP2 STATUS command.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data structure
|
|
* *mode - pointer to store the retrieved mode
|
|
* *sys_mode - pointer to store the FW system mode
|
|
******************************************************************************/
|
|
static int pt_pip2_get_mode_sysmode_(struct pt_core_data *cd,
|
|
u8 *mode, u8 *sys_mode)
|
|
{
|
|
u16 actual_read_len;
|
|
u8 read_buf[12];
|
|
u8 status, boot;
|
|
int rc = 0;
|
|
|
|
rc = _pt_request_pip2_send_cmd(cd->dev, PT_CORE_CMD_UNPROTECTED,
|
|
PIP2_CMD_ID_STATUS, NULL, 0, read_buf, &actual_read_len);
|
|
|
|
pt_debug(cd->dev, DL_INFO, "%s: PIP2 STATUS command rc = %d\n",
|
|
__func__, rc);
|
|
|
|
if (!rc) {
|
|
pt_pr_buf(cd->dev, DL_DEBUG, read_buf, actual_read_len,
|
|
"PIP2 STATUS");
|
|
|
|
status = read_buf[PIP2_RESP_STATUS_OFFSET];
|
|
boot = read_buf[PIP2_RESP_BODY_OFFSET] & 0x01;
|
|
if (sys_mode) {
|
|
if (status == PIP2_RSP_ERR_NONE &&
|
|
boot == PIP2_STATUS_APP_EXEC)
|
|
*sys_mode = read_buf[PIP2_RESP_BODY_OFFSET + 1];
|
|
else
|
|
*sys_mode = FW_SYS_MODE_UNDEFINED;
|
|
}
|
|
if (mode) {
|
|
if (status == PIP2_RSP_ERR_NONE &&
|
|
boot == PIP2_STATUS_BOOT_EXEC)
|
|
*mode = PT_MODE_BOOTLOADER;
|
|
else if (status == PIP2_RSP_ERR_NONE &&
|
|
boot == PIP2_STATUS_APP_EXEC)
|
|
*mode = PT_MODE_OPERATIONAL;
|
|
else
|
|
*mode = PT_MODE_UNKNOWN;
|
|
}
|
|
} else {
|
|
if (mode)
|
|
*mode = PT_MODE_UNKNOWN;
|
|
if (sys_mode)
|
|
*sys_mode = FW_SYS_MODE_UNDEFINED;
|
|
pt_debug(cd->dev, DL_WARN,
|
|
"%s: Mode and sys_mode could not be determined\n",
|
|
__func__);
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_pip2_get_mode_sysmode
|
|
*
|
|
* SUMMARY: Protected call to pt_pip2_get_mode_sysmode_ by exclusive
|
|
* access to the DUT.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data structure
|
|
* *mode - pointer to store the retrieved mode
|
|
* *sys_mode - pointer to store the FW system mode
|
|
******************************************************************************/
|
|
static int pt_pip2_get_mode_sysmode(struct pt_core_data *cd,
|
|
u8 *mode, u8 *sys_mode)
|
|
{
|
|
int rc;
|
|
|
|
rc = request_exclusive(cd, cd->dev, PT_REQUEST_EXCLUSIVE_TIMEOUT);
|
|
if (rc < 0) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail get exclusive ex=%p own=%p\n",
|
|
__func__, cd->exclusive_dev, cd->dev);
|
|
return rc;
|
|
}
|
|
|
|
rc = pt_pip2_get_mode_sysmode_(cd, mode, sys_mode);
|
|
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail to release exclusive\n", __func__);
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_request_pip2_get_mode_sysmode
|
|
*
|
|
* SUMMARY: Function pointer included in core_commands struct for external
|
|
* calls to the protected or unprotected call to
|
|
* pt_pip2_get_mode_sysmode
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* *mode - pointer to store the retrieved mode
|
|
* *sys_mode - pointer to store the FW system mode
|
|
******************************************************************************/
|
|
static int _pt_request_pip2_get_mode_sysmode(struct device *dev,
|
|
int protect, u8 *mode, u8 *sys_mode)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
|
|
if (protect)
|
|
return pt_pip2_get_mode_sysmode(cd, mode, sys_mode);
|
|
|
|
return pt_pip2_get_mode_sysmode_(cd, mode, sys_mode);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_poll_for_fw_exit_boot_mode
|
|
*
|
|
* SUMMARY: Verify and or poll for the FW to exit BOOT mode. During the FW BOOT
|
|
* mode only the following PIP commands will be serviced, any other PIP
|
|
* command the FW will respond with an "Invalid PIP Command" response.
|
|
* - Get HID Descriptor (Register 0x0001, no command ID)
|
|
* - Reset (Register 0x0005, RESET HID request)
|
|
* - Ping (Register 0x0004, Command ID 0x00
|
|
* - Get System Information (Register 0x0004, Command ID 0x02)
|
|
* - PIP2 Status (Register 0x0101, Command ID 0x01)
|
|
* - PIP2 Version (Register 0x0101, Command ID 0x07)
|
|
* This function will loop on the results of the STATUS command until
|
|
* the FW reports it is out of BOOT mode.
|
|
*
|
|
* NOTE:
|
|
* - This function will update cd->fw_system_mode
|
|
* - The STATUS cmd only supports this functionality for PIP 1.11+
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* timeout - max time (ms) to wait for FW to exit BOOT mode
|
|
* actual_wait - pointer to actual time waited for FW to exit BOOT mode
|
|
******************************************************************************/
|
|
static int _pt_poll_for_fw_exit_boot_mode(struct pt_core_data *cd, int timeout,
|
|
int *actual_wait)
|
|
{
|
|
int loop = 0;
|
|
u8 sys_mode = cd->fw_system_mode;
|
|
u8 pause = 10; /* in ms */
|
|
int rc = 0;
|
|
int max_loop = (timeout / pause) + 1; /* Add 1 due to int math */
|
|
|
|
if (cd->sysinfo.ready && !IS_PIP_VER_GE(&cd->sysinfo, 1, 11)) {
|
|
/*
|
|
* For PIP <1.11, no support for polling wait so do a hard
|
|
* coded wait and assume the FW is out of BOOT. Added 1 to
|
|
* timeout to make it clear in kmsg if non polling was done.
|
|
*/
|
|
*actual_wait = PT_FW_EXIT_BOOT_MODE_TIMEOUT + 1;
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: PIP %d.%d no support for ext STATUS, sleep %d\n",
|
|
__func__,
|
|
cd->sysinfo.ttdata.pip_ver_major,
|
|
cd->sysinfo.ttdata.pip_ver_minor, *actual_wait);
|
|
msleep(*actual_wait);
|
|
sys_mode = FW_SYS_MODE_SCANNING;
|
|
}
|
|
|
|
if (sys_mode == FW_SYS_MODE_BOOT) {
|
|
while (!rc && loop <= max_loop &&
|
|
(sys_mode == FW_SYS_MODE_BOOT)) {
|
|
loop++;
|
|
usleep_range(9000, pause * 1000);
|
|
rc = pt_pip2_get_mode_sysmode_(cd, NULL, &sys_mode);
|
|
pt_debug(cd->dev, DL_DEBUG,
|
|
"%s: FW in BOOT mode-sleep %dms, sys_mode=%d\n",
|
|
__func__, loop * pause, sys_mode);
|
|
}
|
|
*actual_wait = (int)(loop * pause);
|
|
pt_debug(cd->dev, DL_WARN,
|
|
"%s: FW exited BOOT mode in %dms, sys_mode=%d\n",
|
|
__func__, *actual_wait, sys_mode);
|
|
|
|
if (rc)
|
|
sys_mode = FW_SYS_MODE_UNDEFINED;
|
|
else if (sys_mode == FW_SYS_MODE_BOOT ||
|
|
sys_mode == FW_SYS_MODE_UNDEFINED)
|
|
rc = -EBUSY;
|
|
}
|
|
|
|
mutex_lock(&cd->system_lock);
|
|
cd->fw_system_mode = sys_mode;
|
|
mutex_unlock(&cd->system_lock);
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_poll_for_fw_exit_boot_mode
|
|
*
|
|
* SUMMARY: Protected call to _pt_poll_for_fw_exit_boot_mode by exclusive
|
|
* access to the DUT.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* timeout - max time (ms) to wait for FW to exit BOOT mode
|
|
* actual_wait - pointer to actual time waited for FW to exit BOOT mode
|
|
******************************************************************************/
|
|
static int pt_poll_for_fw_exit_boot_mode(struct pt_core_data *cd, int timeout,
|
|
int *actual_wait)
|
|
{
|
|
int rc;
|
|
|
|
rc = request_exclusive(cd, cd->dev, PT_REQUEST_EXCLUSIVE_TIMEOUT);
|
|
if (rc < 0) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail get exclusive ex=%p own=%p\n",
|
|
__func__, cd->exclusive_dev, cd->dev);
|
|
return rc;
|
|
}
|
|
|
|
rc = _pt_poll_for_fw_exit_boot_mode(cd, timeout, actual_wait);
|
|
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail to release exclusive\n", __func__);
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_get_fw_sys_mode
|
|
*
|
|
* SUMMARY: Determine the FW system mode. For PIP 1.11+ the
|
|
* PIP2 STATUS command is used to directly query the FW system mode. For older
|
|
* PIP versions, there is no direct PIP commamnd that will directly provide this
|
|
* information but any PIP command above 0x1F requires scanning to be disabled
|
|
* before it will be operational. If scanning was not disabled before sending
|
|
* these PIP commands the FW will respond with a 6 byte error response. So to
|
|
* safely determine the scanning state, a PIP message that will not affect the
|
|
* operation of the FW was chosen:
|
|
* "Verify Data Block CRC (ID 0x20)" is sent and if a 6 byte error code is
|
|
* received scanning is active.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* *sys_mode - pointer to FW System mode
|
|
* *mode - pointer to mode (BL/FW)
|
|
******************************************************************************/
|
|
static int _pt_get_fw_sys_mode(struct pt_core_data *cd, u8 *sys_mode, u8 *mode)
|
|
{
|
|
int write_length = 1;
|
|
int report_length;
|
|
int rc = 0;
|
|
u8 tmp_sys_mode = FW_SYS_MODE_UNDEFINED;
|
|
u8 tmp_mode = PT_MODE_UNKNOWN;
|
|
u8 param[1] = { PT_TCH_PARM_EBID };
|
|
struct pt_hid_output hid_output = {
|
|
CREATE_PIP1_FW_CMD(PIP1_CMD_ID_VERIFY_CONFIG_BLOCK_CRC),
|
|
.write_length = write_length,
|
|
.write_buf = param,
|
|
.novalidate = true,
|
|
};
|
|
|
|
/* AFter PIP1.11 the preferred method is using STATUS cmd */
|
|
if (IS_PIP_VER_GE(&cd->sysinfo, 1, 11)) {
|
|
rc = pt_pip2_get_mode_sysmode_(cd, &tmp_mode, &tmp_sys_mode);
|
|
pt_debug(cd->dev, DL_DEBUG, "%s: tmp_sys_mode=%d tmp_mode=%d\n",
|
|
__func__, tmp_sys_mode, tmp_mode);
|
|
if (!rc) {
|
|
if (tmp_mode != PT_MODE_OPERATIONAL)
|
|
tmp_sys_mode = FW_SYS_MODE_UNDEFINED;
|
|
}
|
|
goto exit;
|
|
}
|
|
|
|
/* Older systems use PIP1 CONFIG_BLOCK_CRC to best determine sys_mode */
|
|
if (cd->mode != PT_MODE_OPERATIONAL) {
|
|
tmp_mode = cd->mode;
|
|
goto exit;
|
|
}
|
|
|
|
rc = pt_pip1_send_output_and_wait_(cd, &hid_output);
|
|
if (rc)
|
|
goto exit;
|
|
|
|
report_length = (cd->response_buf[1] << 8) | (cd->response_buf[0]);
|
|
if ((report_length == 0x06) &&
|
|
((cd->response_buf[4] & PIP1_RESP_COMMAND_ID_MASK) == 0x00) &&
|
|
(cd->response_buf[5] == PIP1_CMD_ID_VERIFY_CONFIG_BLOCK_CRC)) {
|
|
tmp_mode = PIP2_STATUS_APP_EXEC;
|
|
tmp_sys_mode = FW_SYS_MODE_SCANNING;
|
|
} else if ((report_length == 0x0A) &&
|
|
((cd->response_buf[4] & PIP1_RESP_COMMAND_ID_MASK) ==
|
|
PIP1_CMD_ID_VERIFY_CONFIG_BLOCK_CRC)) {
|
|
tmp_mode = PIP2_STATUS_APP_EXEC;
|
|
tmp_sys_mode = FW_SYS_MODE_TEST;
|
|
}
|
|
|
|
exit:
|
|
if (mode)
|
|
*mode = tmp_mode;
|
|
if (sys_mode)
|
|
*sys_mode = tmp_sys_mode;
|
|
pt_debug(cd->dev, DL_INFO, "%s: Return Mode=%d sys_mode=%d\n",
|
|
__func__, tmp_mode, tmp_sys_mode);
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_get_fw_sys_mode
|
|
*
|
|
* SUMMARY: Protected call to _pt_get_fw_sys_mode() to determine if FW scanning
|
|
* is active or not.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* *sys_mode - pointer to fw system mode
|
|
* *mode - pointer to mode
|
|
******************************************************************************/
|
|
static int pt_get_fw_sys_mode(struct pt_core_data *cd, u8 *sys_mode, u8 *mode)
|
|
{
|
|
int rc;
|
|
|
|
rc = request_exclusive(cd, cd->dev, PT_REQUEST_EXCLUSIVE_TIMEOUT);
|
|
if (rc < 0) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail get exclusive ex=%p own=%p\n",
|
|
__func__, cd->exclusive_dev, cd->dev);
|
|
return rc;
|
|
}
|
|
|
|
rc = _pt_get_fw_sys_mode(cd, sys_mode, mode);
|
|
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail to release exclusive\n", __func__);
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_request_get_fw_sys_mode
|
|
*
|
|
* SUMMARY: Function pointer included in core_cmds to allow other modules
|
|
* to request to get scan state
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* protect - flag to call protected or non-protected
|
|
* *sys_mode - pointer to FW system mode
|
|
* *mode - pointer to mode
|
|
******************************************************************************/
|
|
static int _pt_request_get_fw_sys_mode(struct device *dev, int protect,
|
|
u8 *sys_mode, u8 *mode)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
|
|
if (protect)
|
|
return pt_get_fw_sys_mode(cd, sys_mode, mode);
|
|
|
|
return _pt_get_fw_sys_mode(cd, sys_mode, mode);
|
|
}
|
|
|
|
/* Default hid descriptor to provide basic register map */
|
|
const struct pt_hid_desc hid_desc_default = {
|
|
230, /* hid_desc_len */
|
|
HID_APP_REPORT_ID, /* packet_id */
|
|
0x00, /* reserved_byte */
|
|
0x0100, /* bcd_version */
|
|
0x00EC, /* report_desc_len */
|
|
0x0002, /* report_desc_register */
|
|
0x0003, /* input_register */
|
|
0x00FE, /* max_input_len */
|
|
0x0004, /* output_register */
|
|
0x00FE, /* max_output_len */
|
|
0x0005, /* command_register */
|
|
0x0006, /* data_register */
|
|
0x04B4, /* vendor_id */
|
|
0xC101, /* product_id */
|
|
0x0100, /* version_id */
|
|
{0x00, 0x00, 0x00, 0x00} /* reserved[4] */
|
|
};
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_init_hid_descriptor
|
|
*
|
|
* SUMMARY: Setup default values for HID descriptor structure
|
|
*
|
|
*
|
|
* PARAMETERS:
|
|
* *desc - pointer to the HID descriptor data read back from DUT
|
|
******************************************************************************/
|
|
static inline void pt_init_hid_descriptor(struct pt_hid_desc *desc)
|
|
{
|
|
memcpy(desc, &hid_desc_default, sizeof(hid_desc_default));
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_get_hid_descriptor_
|
|
*
|
|
* SUMMARY: Send the get HID descriptor command to the DUT and load the response
|
|
* into the HID descriptor structure
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* *desc - pointer to the HID descriptor data read back from DUT
|
|
******************************************************************************/
|
|
static int pt_get_hid_descriptor_(struct pt_core_data *cd,
|
|
struct pt_hid_desc *desc)
|
|
{
|
|
struct device *dev = cd->dev;
|
|
int rc = 0;
|
|
int t;
|
|
u8 cmd[2];
|
|
|
|
/*
|
|
* During startup the HID descriptor is required for all future
|
|
* processing. If IRQ is already asserted due to an early touch report
|
|
* the report must be cleared before sending command.
|
|
*/
|
|
pt_flush_bus_if_irq_asserted(cd, PT_FLUSH_BUS_BASED_ON_LEN);
|
|
|
|
/* 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));
|
|
|
|
pt_debug(cd->dev, DL_INFO, ">>> %s: Write Buffer [%zu]",
|
|
__func__, sizeof(cmd));
|
|
pt_pr_buf(cd->dev, DL_DEBUG, cmd, sizeof(cmd), ">>> Get HID Desc");
|
|
rc = pt_adap_write_read_specific(cd, 2, cmd, NULL);
|
|
if (rc) {
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s: failed to get HID descriptor, rc=%d\n",
|
|
__func__, rc);
|
|
goto error;
|
|
}
|
|
|
|
t = wait_event_timeout(cd->wait_q, (cd->hid_cmd_state == 0),
|
|
msecs_to_jiffies(PT_GET_HID_DESCRIPTOR_TIMEOUT));
|
|
|
|
if (IS_TMO(t)) {
|
|
#ifdef TTDL_DIAGNOSTICS
|
|
cd->bus_transmit_error_count++;
|
|
pt_toggle_err_gpio(cd, PT_ERR_GPIO_I2C_TRANS);
|
|
#endif /* TTDL_DIAGNOSTICS */
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: HID get descriptor timed out\n", __func__);
|
|
rc = -ETIME;
|
|
goto error;
|
|
} else {
|
|
cd->hw_detected = true;
|
|
}
|
|
|
|
/* Load the HID descriptor including all registers */
|
|
memcpy((u8 *)desc, cd->response_buf, sizeof(struct pt_hid_desc));
|
|
|
|
/* Check HID descriptor length and version */
|
|
pt_debug(dev, DL_INFO, "%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) != HID_VERSION) {
|
|
pt_debug(dev, DL_ERROR, "%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;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_get_hid_descriptor
|
|
*
|
|
* SUMMARY: Protected call to pt_get_hid_descriptor_()
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* *desc - pointer to the HID descriptor data read back from DUT
|
|
******************************************************************************/
|
|
static int pt_get_hid_descriptor(struct pt_core_data *cd,
|
|
struct pt_hid_desc *desc)
|
|
{
|
|
int rc;
|
|
|
|
rc = request_exclusive(cd, cd->dev, PT_REQUEST_EXCLUSIVE_TIMEOUT);
|
|
if (rc < 0) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail get exclusive ex=%p own=%p\n",
|
|
__func__, cd->exclusive_dev, cd->dev);
|
|
return rc;
|
|
}
|
|
|
|
rc = pt_get_hid_descriptor_(cd, desc);
|
|
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail to release exclusive\n", __func__);
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_pip2_get_version_
|
|
*
|
|
* SUMMARY: Sends a PIP2 VERSION command to the DUT and stores the data in
|
|
* cd-ttdata
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
******************************************************************************/
|
|
static int pt_pip2_get_version_(struct pt_core_data *cd)
|
|
{
|
|
int rc = 0;
|
|
int status;
|
|
u8 read_buf[64];
|
|
u16 actual_read_len;
|
|
|
|
rc = _pt_request_pip2_send_cmd(cd->dev,
|
|
PT_CORE_CMD_UNPROTECTED, PIP2_CMD_ID_VERSION,
|
|
NULL, 0, read_buf, &actual_read_len);
|
|
if (rc) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: Error Sending PIP2 VERSION Cmd rc=%d\n",
|
|
__func__, rc);
|
|
return rc;
|
|
}
|
|
|
|
status = read_buf[PIP2_RESP_STATUS_OFFSET];
|
|
if (status == 0) {
|
|
/* Parse the PIP2 VERSION response into ttdata */
|
|
pt_pip2_ver_load_ttdata(cd, actual_read_len);
|
|
} else {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: Error in PIP2 VERSION Cmd status=%d\n",
|
|
__func__, status);
|
|
return status;
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_pip2_get_version
|
|
*
|
|
* SUMMARY: Protected call to pt_pip2_get_version_ by exclusive
|
|
* access to the DUT.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data structure
|
|
******************************************************************************/
|
|
static int pt_pip2_get_version(struct pt_core_data *cd)
|
|
{
|
|
int rc;
|
|
|
|
rc = request_exclusive(cd, cd->dev, PT_REQUEST_EXCLUSIVE_TIMEOUT);
|
|
if (rc < 0) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail get exclusive ex=%p own=%p\n",
|
|
__func__, cd->exclusive_dev, cd->dev);
|
|
return rc;
|
|
}
|
|
|
|
rc = pt_pip2_get_version_(cd);
|
|
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail to release exclusive\n", __func__);
|
|
|
|
return rc;
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_request_active_pip_protocol
|
|
*
|
|
* SUMMARY: Get active PIP protocol version using the PIP2 version command.
|
|
* Function will return PIP version of BL or application based on
|
|
* when it's called.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* protect - flag to run in protected mode
|
|
* *pip_version_major - pointer to store PIP major version
|
|
* *pip_version_minor - pointer to store PIP minor version
|
|
******************************************************************************/
|
|
int _pt_request_active_pip_protocol(struct device *dev, int protect,
|
|
u8 *pip_version_major, u8 *pip_version_minor)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
struct pt_ttdata *ttdata = &cd->sysinfo.ttdata;
|
|
int rc = 0;
|
|
struct pt_hid_output sys_info = {
|
|
CREATE_PIP1_FW_CMD(PIP1_CMD_ID_GET_SYSINFO),
|
|
.timeout_ms = PT_PIP1_CMD_GET_SYSINFO_TIMEOUT,
|
|
};
|
|
|
|
pt_flush_bus_if_irq_asserted(cd, PT_FLUSH_BUS_BASED_ON_LEN);
|
|
|
|
/* Skip PIP2 command if DUT generation is confirmed */
|
|
if (cd->active_dut_generation == DUT_PIP1_ONLY)
|
|
goto skip_pip2_command;
|
|
|
|
rc = pt_pip2_get_version_(cd);
|
|
if (!rc) {
|
|
*pip_version_major = ttdata->pip_ver_major;
|
|
*pip_version_minor = ttdata->pip_ver_minor;
|
|
pt_debug(dev, DL_INFO,
|
|
"%s: pip_version = %d.%d\n", __func__,
|
|
*pip_version_major, *pip_version_minor);
|
|
} else {
|
|
/*
|
|
* Legacy products do not support the pip2 protocol to get
|
|
* pip version. However, they do support the "get sysinfo"
|
|
* command to get pip version from FW, but the bootloader
|
|
* does not support it. This function will try "get sysinfo"
|
|
* command if the pip2 command failed but this cmd could also
|
|
* fail if DUT is stuck in bootloader mode.
|
|
*/
|
|
pt_debug(dev, DL_INFO,
|
|
"%s: PIP2 no response rc = %d, try legacy cmd\n",
|
|
__func__, rc);
|
|
|
|
skip_pip2_command:
|
|
rc = pt_pip1_send_output_and_wait_(cd, &sys_info);
|
|
if (!rc) {
|
|
*pip_version_minor =
|
|
cd->response_buf[PIP1_SYSINFO_TTDATA_OFFSET + 1];
|
|
*pip_version_major =
|
|
cd->response_buf[PIP1_SYSINFO_TTDATA_OFFSET];
|
|
|
|
pt_debug(dev, DL_INFO,
|
|
"%s: pip_version = %d.%d\n", __func__,
|
|
*pip_version_major, *pip_version_minor);
|
|
} else {
|
|
*pip_version_major = 0;
|
|
*pip_version_minor = 0;
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s: pip_version Not Detected\n", __func__);
|
|
}
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
EXPORT_SYMBOL_GPL(_pt_request_active_pip_protocol);
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_detect_dut_generation
|
|
*
|
|
* SUMMARY: Determine the generation of device that we are communicating with:
|
|
* DUT_PIP1_ONLY (Gen5 or Gen6)
|
|
* DUT_PIP2_CAPABLE (TC33xx or TT7xxx)
|
|
* The HID_DESC command is supported in Gen5/6 BL and FW as well as
|
|
* TT/TC FW. The packet ID in the descriptor, however, is unique when
|
|
* coming form the BL or the FW:
|
|
* Packet_ID in BL = HID_BL_REPORT_ID (0xFF)
|
|
* Packet_ID in FW = HID_APP_REPORT_ID (0xF7)
|
|
* This function will return a modified status if it detects the DUT
|
|
* is in the BL. In the case of a Gen5/6 BL, which also sends out a FW
|
|
* reset sentinel, the status is "corrected" from a FW to BL sentinel.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* *status - pointer to status bitmask
|
|
* *dut_gen - pointer to store the dut_generation
|
|
* *mode - pointer to store the PT_MODE
|
|
******************************************************************************/
|
|
static int _pt_detect_dut_generation(struct device *dev,
|
|
u32 *status, u8 *dut_gen, enum pt_mode *mode)
|
|
{
|
|
int rc = 0;
|
|
u8 dut_gen_tmp = DUT_UNKNOWN;
|
|
u8 mode_tmp = PT_MODE_UNKNOWN;
|
|
u8 attempt = 1;
|
|
u32 status_tmp = STARTUP_STATUS_START;
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
struct pt_hid_desc hid_desc;
|
|
|
|
memset(&hid_desc, 0, sizeof(hid_desc));
|
|
rc = pt_get_hid_descriptor_(cd, &hid_desc);
|
|
while (rc && attempt < 3) {
|
|
attempt++;
|
|
usleep_range(2000, 5000);
|
|
rc = pt_get_hid_descriptor_(cd, &hid_desc);
|
|
}
|
|
|
|
if (!rc && hid_desc.packet_id == HID_BL_REPORT_ID) {
|
|
dut_gen_tmp = DUT_PIP1_ONLY; /* Gen5/6 BL */
|
|
mode_tmp = PT_MODE_BOOTLOADER;
|
|
status_tmp = STARTUP_STATUS_BL_RESET_SENTINEL;
|
|
} else if (!rc && hid_desc.packet_id == HID_APP_REPORT_ID) {
|
|
rc = pt_pip2_get_version_(cd);
|
|
if (!rc)
|
|
dut_gen_tmp = DUT_PIP2_CAPABLE; /* TT/TC FW */
|
|
else
|
|
dut_gen_tmp = DUT_PIP1_ONLY; /* Gen5/6 FW */
|
|
mode_tmp = PT_MODE_OPERATIONAL;
|
|
status_tmp = STARTUP_STATUS_FW_RESET_SENTINEL;
|
|
rc = 0; /* To return success instead of error code */
|
|
} else if (rc) {
|
|
rc = pt_pip2_get_version_(cd);
|
|
if (!rc) {
|
|
dut_gen_tmp = DUT_PIP2_CAPABLE; /* TT/TC BL */
|
|
mode_tmp = PT_MODE_BOOTLOADER;
|
|
status_tmp = STARTUP_STATUS_BL_RESET_SENTINEL;
|
|
}
|
|
}
|
|
|
|
mutex_lock(&cd->system_lock);
|
|
if (dut_gen)
|
|
*dut_gen = dut_gen_tmp;
|
|
if (mode)
|
|
*mode = mode_tmp;
|
|
if (status)
|
|
*status = status_tmp;
|
|
mutex_unlock(&cd->system_lock);
|
|
|
|
#ifdef TTDL_DIAGNOSTICS
|
|
pt_debug(cd->dev, DL_INFO, "%s: Generation=%d Mode=%d\n",
|
|
__func__, dut_gen_tmp, mode_tmp);
|
|
#endif /* TTDL_DIAGNOSTICS */
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_request_dut_generation
|
|
*
|
|
* SUMMARY: Function pointer included in core_cmds to allow other modules
|
|
* to get current dut generation.
|
|
*
|
|
* NOTE: This function WILL NOT try to determine dut generation.
|
|
*
|
|
* RETURN:
|
|
* The current dut generation.
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
******************************************************************************/
|
|
static int _pt_request_dut_generation(struct device *dev)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
|
|
return cd->active_dut_generation;
|
|
}
|
|
|
|
#define HW_VERSION_LEN_MAX 13
|
|
/*******************************************************************************
|
|
* FUNCTION: _legacy_generate_hw_version
|
|
*
|
|
* SUMMARY: Format chip infomation from struct ttdata (maintained by PIP1
|
|
* SYSINFO command) or struct bl_info (maintained by PIP1 BL INFOMATION
|
|
* command) to the hw_version.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* *hw_version - pointer to store the hardware version
|
|
******************************************************************************/
|
|
static int _legacy_generate_hw_version(struct pt_core_data *cd,
|
|
char *hw_version)
|
|
{
|
|
struct pt_ttdata *ttdata = &cd->sysinfo.ttdata;
|
|
|
|
if (cd->sysinfo.ready) {
|
|
snprintf(hw_version, HW_VERSION_LEN_MAX, "%04X.FFFF.%02X",
|
|
ttdata->jtag_id_h, cd->pid_for_loader);
|
|
return 0;
|
|
} else if (cd->bl_info.ready) {
|
|
snprintf(hw_version, HW_VERSION_LEN_MAX, "%04X.FFFF.%02X",
|
|
cd->bl_info.chip_id, cd->pid_for_loader);
|
|
return 0;
|
|
} else {
|
|
snprintf(hw_version, HW_VERSION_LEN_MAX, "FFFF.FFFF.FF");
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: SYSINFO and BL_INFO are not ready\n", __func__);
|
|
return -ENODATA;
|
|
}
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pip2_generate_hw_version
|
|
*
|
|
* SUMMARY: Format chip infomation from struct ttdata (maintained by PIP2
|
|
* VERSION command) to the hw_version.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* *hw_version - pointer to store the hardware version
|
|
******************************************************************************/
|
|
static int _pip2_generate_hw_version(struct pt_core_data *cd, char *hw_version)
|
|
{
|
|
struct pt_ttdata *ttdata = &cd->sysinfo.ttdata;
|
|
|
|
if (cd->app_pip_ver_ready | cd->bl_pip_ver_ready) {
|
|
snprintf(hw_version, HW_VERSION_LEN_MAX, "%04X.%04X.%02X",
|
|
ttdata->chip_id, ttdata->chip_rev, cd->pid_for_loader);
|
|
return 0;
|
|
} else {
|
|
snprintf(hw_version, HW_VERSION_LEN_MAX, "FFFF.FFFF.FF");
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: PIP Version are not ready\n", __func__);
|
|
return -ENODATA;
|
|
}
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_generate_hw_version
|
|
*
|
|
* SUMMARY: Wraaper function for both legacy and TT/TC products generate the
|
|
* hw_version from static data.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* *hw_version - pointer to store the hardware version
|
|
******************************************************************************/
|
|
static int pt_generate_hw_version(struct pt_core_data *cd, char *hw_version)
|
|
{
|
|
int rc = 0;
|
|
|
|
if (!hw_version)
|
|
return -ENOMEM;
|
|
|
|
if (cd->active_dut_generation == DUT_PIP1_ONLY)
|
|
rc = _legacy_generate_hw_version(cd, hw_version);
|
|
else if (cd->active_dut_generation == DUT_PIP2_CAPABLE)
|
|
rc = _pip2_generate_hw_version(cd, hw_version);
|
|
else {
|
|
snprintf(hw_version, HW_VERSION_LEN_MAX, "FFFF.FFFF.FF");
|
|
rc = -ENODATA;
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
/*******************************************************************************
|
|
* SUMMARY: Attempt to retrieve the HW version of the connected DUT
|
|
*
|
|
* NOTE: The calling function must ensure to free *hw_version
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = Failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* *hw_version - pointer to where the hw_version string will be stored
|
|
******************************************************************************/
|
|
static int _pt_request_hw_version(struct device *dev, char *hw_version)
|
|
{
|
|
int rc = 0;
|
|
u16 actual_read_len;
|
|
u16 pip_ver;
|
|
u8 rd_buf[256];
|
|
u8 status;
|
|
u8 index = PIP2_RESP_STATUS_OFFSET;
|
|
u8 return_data[8];
|
|
u8 panel_id;
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
struct pt_ttdata *ttdata = &cd->sysinfo.ttdata;
|
|
|
|
if (!hw_version)
|
|
return -ENOMEM;
|
|
|
|
if (!cd->hw_detected) {
|
|
/* No HW detected */
|
|
rc = -ENODEV;
|
|
pt_debug(dev, DL_ERROR, "%s: no hardware is detected!\n",
|
|
__func__);
|
|
goto exit_error;
|
|
}
|
|
|
|
/* For Parade TC or TT parts */
|
|
if (cd->active_dut_generation == DUT_PIP2_CAPABLE) {
|
|
rc = _pt_request_pip2_send_cmd(dev,
|
|
PT_CORE_CMD_UNPROTECTED, PIP2_CMD_ID_VERSION,
|
|
NULL, 0, rd_buf, &actual_read_len);
|
|
|
|
if (rc) {
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s: Failed to send PIP2 VERSION cmd\n",
|
|
__func__);
|
|
goto exit_error;
|
|
}
|
|
|
|
status = rd_buf[index];
|
|
if (status == 0) {
|
|
pip_ver = 256 * rd_buf[index + 2] + rd_buf[index + 1];
|
|
|
|
/*
|
|
* BL PIP 2.02 and greater the version fields are
|
|
* swapped
|
|
*/
|
|
if (pip_ver >= 0x0202) {
|
|
snprintf(hw_version, HW_VERSION_LEN_MAX,
|
|
"%02X%02X.%02X%02X.FF",
|
|
rd_buf[index + 10], rd_buf[index + 9],
|
|
rd_buf[index + 8], rd_buf[index + 7]);
|
|
} else {
|
|
snprintf(hw_version, HW_VERSION_LEN_MAX,
|
|
"%02X%02X.%02X%02X.FF",
|
|
rd_buf[index + 8], rd_buf[index + 7],
|
|
rd_buf[index + 10], rd_buf[index + 9]);
|
|
}
|
|
return STATUS_SUCCESS;
|
|
} else {
|
|
rc = status;
|
|
pt_debug(dev, DL_WARN,
|
|
"%s: PIP2 VERSION cmd response error\n",
|
|
__func__);
|
|
}
|
|
} else if (cd->active_dut_generation == DUT_PIP1_ONLY) {
|
|
/*
|
|
* For Parade/Cypress legacy parts the RevID and FamilyID are
|
|
* hard coded to FFFF
|
|
*/
|
|
if (cd->mode == PT_MODE_OPERATIONAL) {
|
|
rc = pt_hid_output_get_sysinfo(cd);
|
|
if (!rc) {
|
|
panel_id =
|
|
cd->sysinfo.sensing_conf_data.panel_id;
|
|
} else {
|
|
panel_id = PANEL_ID_NOT_ENABLED;
|
|
}
|
|
/* In FW - simply retrieve from ttdata struct */
|
|
snprintf(hw_version, HW_VERSION_LEN_MAX,
|
|
"%04X.FFFF.%02X",
|
|
ttdata->jtag_id_h,
|
|
panel_id);
|
|
return STATUS_SUCCESS;
|
|
} else {
|
|
/*
|
|
* Return the stored value if PT_PANEL_ID_BY_BL
|
|
* is not supported while other feature is.
|
|
*/
|
|
if (cd->panel_id_support & PT_PANEL_ID_BY_BL) {
|
|
rc = pt_hid_output_bl_get_information(
|
|
cd, return_data);
|
|
if (!rc) {
|
|
rc = pt_hid_output_bl_get_panel_id(
|
|
cd, &panel_id);
|
|
}
|
|
} else
|
|
panel_id = cd->pid_for_loader;
|
|
if (!rc) {
|
|
snprintf(hw_version,
|
|
HW_VERSION_LEN_MAX,
|
|
"%02X%02X.FFFF.%02X",
|
|
return_data[3], return_data[2],
|
|
panel_id);
|
|
return STATUS_SUCCESS;
|
|
}
|
|
}
|
|
} else {
|
|
/* Unknown generation */
|
|
rc = -ENODEV;
|
|
pt_debug(dev, DL_ERROR, "%s: generation is unkown!\n",
|
|
__func__);
|
|
}
|
|
|
|
exit_error:
|
|
snprintf(hw_version, HW_VERSION_LEN_MAX, "FFFF.FFFF.FF");
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_start_wd_timer
|
|
*
|
|
* SUMMARY: Starts the TTDL watchdog timer if the timer interval is > 0
|
|
*
|
|
* RETURN: void
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
******************************************************************************/
|
|
static void pt_start_wd_timer(struct pt_core_data *cd)
|
|
{
|
|
if (cd->watchdog_interval < 100) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: WARNING: Invalid watchdog interval: %d\n",
|
|
__func__, cd->watchdog_interval);
|
|
return;
|
|
}
|
|
|
|
if (cd->watchdog_force_stop) {
|
|
pt_debug(cd->dev, DL_INFO,
|
|
"%s: TTDL WD Forced stop\n", __func__);
|
|
return;
|
|
}
|
|
|
|
mod_timer(&cd->watchdog_timer, jiffies +
|
|
msecs_to_jiffies(cd->watchdog_interval));
|
|
cd->watchdog_enabled = 1;
|
|
pt_debug(cd->dev, DL_INFO, "%s: TTDL WD Started\n", __func__);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_stop_wd_timer
|
|
*
|
|
* SUMMARY: Stops the TTDL watchdog timer if the timer interval is > 0
|
|
*
|
|
* RETURN: void
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
******************************************************************************/
|
|
static void pt_stop_wd_timer(struct pt_core_data *cd)
|
|
{
|
|
if (!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);
|
|
cd->watchdog_enabled = 0;
|
|
pt_debug(cd->dev, DL_INFO, "%s: TTDL WD Stopped\n", __func__);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_hw_soft_reset
|
|
*
|
|
* SUMMARY: Sends a PIP reset command to the DUT. Disable/re-enable the
|
|
* TTDL watchdog around the reset to ensure the WD doesn't happen to
|
|
* schedule an enum if it fires when the DUT is being reset.
|
|
* This can cause a double reset.
|
|
*
|
|
* NOTE: The WD MUST be stopped/restarted by the calling Function. Having
|
|
* the WD active could cause this function to fail!
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data struct
|
|
* protect - flag to call protected or non-protected
|
|
******************************************************************************/
|
|
static int pt_hw_soft_reset(struct pt_core_data *cd, int protect)
|
|
{
|
|
int rc = 0;
|
|
|
|
mutex_lock(&cd->system_lock);
|
|
cd->startup_status = STARTUP_STATUS_START;
|
|
pt_debug(cd->dev, DL_DEBUG, "%s: Startup Status Reset\n", __func__);
|
|
mutex_unlock(&cd->system_lock);
|
|
if (protect)
|
|
rc = pt_hid_cmd_reset(cd);
|
|
else
|
|
rc = pt_hid_cmd_reset_(cd);
|
|
if (rc < 0) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: FAILED to execute SOFT reset\n", __func__);
|
|
return rc;
|
|
}
|
|
pt_debug(cd->dev, DL_INFO, "%s: SOFT reset successful\n",
|
|
__func__);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_hw_hard_reset
|
|
*
|
|
* SUMMARY: Calls the platform xres function if it exists to perform a hard
|
|
* reset on the DUT by toggling the XRES gpio. Disable/re-enable the
|
|
* TTDL watchdog around the reset to ensure the WD doesn't happen to
|
|
* schedule an enum if it fires when the DUT is being reset.
|
|
* This can cause a double reset.
|
|
*
|
|
* NOTE: The WD MUST be stopped/restarted by the calling Function. Having
|
|
* the WD active could cause this function to fail!
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data struct
|
|
******************************************************************************/
|
|
static int pt_hw_hard_reset(struct pt_core_data *cd)
|
|
{
|
|
if (cd->cpdata->xres) {
|
|
cd->startup_status = STARTUP_STATUS_START;
|
|
pt_debug(cd->dev, DL_DEBUG, "%s: Startup Status Reset\n",
|
|
__func__);
|
|
cd->cpdata->xres(cd->cpdata, cd->dev);
|
|
pt_debug(cd->dev, DL_WARN, "%s: executed HARD reset\n",
|
|
__func__);
|
|
return 0;
|
|
}
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: FAILED to execute HARD reset\n", __func__);
|
|
|
|
return -ENODEV;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_dut_reset
|
|
*
|
|
* SUMMARY: Attempts to reset the DUT by a hard reset and if that fails a
|
|
* soft reset.
|
|
*
|
|
* NOTE: The WD MUST be stopped/restarted by the calling Function. Having
|
|
* the WD active could cause this function to fail!
|
|
* NOTE: "protect" flag is only used for soft reset.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data structure
|
|
* protect - flag to call protected or non-protected
|
|
******************************************************************************/
|
|
static int pt_dut_reset(struct pt_core_data *cd, int protect)
|
|
{
|
|
int rc = 0;
|
|
|
|
pt_debug(cd->dev, DL_INFO, "%s: reset hw...\n", __func__);
|
|
mutex_lock(&cd->system_lock);
|
|
cd->hid_reset_cmd_state = 1;
|
|
rc = pt_hw_hard_reset(cd);
|
|
mutex_unlock(&cd->system_lock);
|
|
|
|
if (rc == -ENODEV) {
|
|
mutex_lock(&cd->system_lock);
|
|
cd->hid_reset_cmd_state = 0;
|
|
mutex_unlock(&cd->system_lock);
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: Hard reset failed, try soft reset\n", __func__);
|
|
rc = pt_hw_soft_reset(cd, protect);
|
|
}
|
|
|
|
if (rc)
|
|
pt_debug(cd->dev, DL_ERROR, "%s: %s dev='%s' r=%d\n",
|
|
__func__, "Fail hw reset", dev_name(cd->dev), rc);
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_dut_reset_and_wait
|
|
*
|
|
* SUMMARY: Wrapper function for pt_dut_reset that waits for the reset to
|
|
* complete
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data structure
|
|
******************************************************************************/
|
|
static int pt_dut_reset_and_wait(struct pt_core_data *cd)
|
|
{
|
|
int rc = 0;
|
|
int t;
|
|
|
|
rc = pt_dut_reset(cd, PT_CORE_CMD_UNPROTECTED);
|
|
if (rc < 0)
|
|
goto exit;
|
|
|
|
t = wait_event_timeout(cd->wait_q,
|
|
(cd->hid_reset_cmd_state == 0),
|
|
msecs_to_jiffies(PT_HID_CMD_DEFAULT_TIMEOUT));
|
|
if (IS_TMO(t)) {
|
|
#ifdef TTDL_DIAGNOSTICS
|
|
cd->bus_transmit_error_count++;
|
|
pt_toggle_err_gpio(cd, PT_ERR_GPIO_I2C_TRANS);
|
|
#endif /* TTDL_DIAGNOSTICS */
|
|
pt_debug(cd->dev, DL_ERROR, "%s: reset timed out\n",
|
|
__func__);
|
|
rc = -ETIME;
|
|
goto exit;
|
|
}
|
|
|
|
exit:
|
|
return rc;
|
|
}
|
|
|
|
/*
|
|
* touch default parameters (from report descriptor) to resolve protocol for
|
|
* touch report
|
|
*/
|
|
const struct pt_tch_abs_params tch_hdr_default[PT_TCH_NUM_HDR] = {
|
|
/* byte offset, size, min, max, bit offset, report */
|
|
{0x00, 0x02, 0x00, 0x10000, 0x00, 0x01}, /* SCAN TIME */
|
|
{0x02, 0x01, 0x00, 0x20, 0x00, 0x01}, /* NUMBER OF RECORDS */
|
|
{0x02, 0x01, 0x00, 0x02, 0x05, 0x01}, /* LARGE OBJECT */
|
|
{0x03, 0x01, 0x00, 0x08, 0x00, 0x01}, /* NOISE EFFECT */
|
|
{0x03, 0x01, 0x00, 0x04, 0x06, 0x01}, /* REPORT_COUNTER */
|
|
};
|
|
|
|
/*
|
|
* button default parameters (from report descriptor) to resolve protocol for
|
|
* button report
|
|
*/
|
|
const struct pt_tch_abs_params tch_abs_default[PT_TCH_NUM_ABS] = {
|
|
/* byte offset, size, min, max, bit offset, report */
|
|
{0x02, 0x02, 0x00, 0x10000, 0x00, 0x01}, /* X */
|
|
{0x04, 0x02, 0x00, 0x10000, 0x00, 0x01}, /* Y */
|
|
{0x06, 0x01, 0x00, 0x100, 0x00, 0x01}, /* P (Z) */
|
|
{0x01, 0x01, 0x00, 0x20, 0x00, 0x01}, /* TOUCH ID */
|
|
{0x01, 0x01, 0x00, 0x04, 0x05, 0x01}, /* EVENT ID */
|
|
{0x00, 0x01, 0x00, 0x08, 0x00, 0x01}, /* OBJECT ID */
|
|
{0x01, 0x01, 0x00, 0x02, 0x07, 0x01}, /* LIFTOFF */
|
|
{0x07, 0x01, 0x00, 0x100, 0x00, 0x01}, /* TOUCH_MAJOR */
|
|
{0x08, 0x01, 0x00, 0x100, 0x00, 0x01}, /* TOUCH_MINOR */
|
|
{0x09, 0x01, 0x00, 0x100, 0x00, 0x01}, /* ORIENTATION */
|
|
};
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_init_pip_report_fields
|
|
*
|
|
* SUMMARY: Setup default values for touch/button report parsing.
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data structure
|
|
******************************************************************************/
|
|
static void pt_init_pip_report_fields(struct pt_core_data *cd)
|
|
{
|
|
struct pt_sysinfo *si = &cd->sysinfo;
|
|
|
|
memcpy(si->tch_hdr, tch_hdr_default, sizeof(tch_hdr_default));
|
|
memcpy(si->tch_abs, tch_abs_default, sizeof(tch_abs_default));
|
|
|
|
si->desc.tch_report_id = PT_PIP_TOUCH_REPORT_ID;
|
|
si->desc.tch_record_size = TOUCH_REPORT_SIZE;
|
|
si->desc.tch_header_size = TOUCH_INPUT_HEADER_SIZE;
|
|
si->desc.btn_report_id = PT_PIP_CAPSENSE_BTN_REPORT_ID;
|
|
|
|
cd->features.easywake = 1;
|
|
cd->features.noise_metric = 1;
|
|
cd->features.tracking_heatmap = 1;
|
|
cd->features.sensor_data = 1;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_get_mode
|
|
*
|
|
* SUMMARY: Determine the current mode from the contents of a HID descriptor
|
|
* message
|
|
*
|
|
* RETURN: Enum of the current mode
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to the Core Data structure
|
|
* protect - run command in protected mode
|
|
* *mode - pointer to store the retrieved mode
|
|
******************************************************************************/
|
|
static int pt_get_mode(struct pt_core_data *cd, struct pt_hid_desc *desc)
|
|
{
|
|
if (desc->packet_id == HID_APP_REPORT_ID)
|
|
return PT_MODE_OPERATIONAL;
|
|
else if (desc->packet_id == HID_BL_REPORT_ID)
|
|
return PT_MODE_BOOTLOADER;
|
|
|
|
return PT_MODE_UNKNOWN;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_request_get_mode
|
|
*
|
|
* SUMMARY: Function pointer included in core_cmds to allow other modules
|
|
* to determine the current mode of the DUT by use of the Get HID
|
|
* Descriptor command.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* protect - run command in protected mode
|
|
* *mode - pointer to store the retrieved mode
|
|
******************************************************************************/
|
|
static int _pt_request_get_mode(struct device *dev, int protect, u8 *mode)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
struct pt_hid_desc hid_desc;
|
|
int rc = 0;
|
|
|
|
memset(&hid_desc, 0, sizeof(hid_desc));
|
|
if (protect)
|
|
rc = pt_get_hid_descriptor(cd, &hid_desc);
|
|
else
|
|
rc = pt_get_hid_descriptor_(cd, &hid_desc);
|
|
|
|
if (rc)
|
|
*mode = PT_MODE_UNKNOWN;
|
|
else
|
|
*mode = pt_get_mode(cd, &hid_desc);
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_queue_enum_
|
|
*
|
|
* SUMMARY: Queues a TTDL enum by scheduling work with the pt_enum_with_dut()
|
|
* function. It won't try to add/delete sysfs node or modules.
|
|
*
|
|
* RETURN: void
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
******************************************************************************/
|
|
static void pt_queue_enum_(struct pt_core_data *cd)
|
|
{
|
|
if (cd->startup_state == STARTUP_NONE) {
|
|
cd->startup_state = STARTUP_QUEUED;
|
|
|
|
#ifdef TTDL_DIAGNOSTICS
|
|
if (!cd->bridge_mode)
|
|
schedule_work(&cd->enum_work);
|
|
else
|
|
cd->startup_state = STARTUP_NONE;
|
|
#else
|
|
schedule_work(&cd->enum_work);
|
|
#endif
|
|
pt_debug(cd->dev, DL_INFO,
|
|
"%s: enum_work queued\n", __func__);
|
|
} else {
|
|
pt_debug(cd->dev, DL_WARN,
|
|
"%s: Enum not queued - startup_state = %d\n",
|
|
__func__, cd->startup_state);
|
|
}
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_queue_enum
|
|
*
|
|
* SUMMARY: Queues a TTDL enum within a mutex lock
|
|
*
|
|
* RETURN: void
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
******************************************************************************/
|
|
static void pt_queue_enum(struct pt_core_data *cd)
|
|
{
|
|
mutex_lock(&cd->system_lock);
|
|
pt_queue_enum_(cd);
|
|
mutex_unlock(&cd->system_lock);
|
|
}
|
|
|
|
static void remove_sysfs_and_modules(struct device *dev);
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_queue_restart
|
|
*
|
|
* SUMMARY: Queues a TTDL restart within a mutex lock
|
|
*
|
|
* RETURN: void
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* remove_sysfs_module - True: remove all DUT relative sysfs nodes and modules
|
|
* False: will not perform remove action
|
|
******************************************************************************/
|
|
static void pt_queue_restart(struct pt_core_data *cd)
|
|
{
|
|
mutex_lock(&cd->system_lock);
|
|
if (cd->startup_state == STARTUP_NONE) {
|
|
cd->startup_state = STARTUP_QUEUED;
|
|
|
|
schedule_work(&cd->ttdl_restart_work);
|
|
pt_debug(cd->dev, DL_INFO,
|
|
"%s: pt_ttdl_restart queued\n", __func__);
|
|
} else {
|
|
pt_debug(cd->dev, DL_INFO, "%s: startup_state = %d\n",
|
|
__func__, cd->startup_state);
|
|
}
|
|
mutex_unlock(&cd->system_lock);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: call_atten_cb
|
|
*
|
|
* SUMMARY: Iterate over attention list call the function that registered.
|
|
*
|
|
* RETURN: void
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* type - type of attention list
|
|
* mode - condition for execution
|
|
******************************************************************************/
|
|
static void call_atten_cb(struct pt_core_data *cd,
|
|
enum pt_atten_type type, int mode)
|
|
{
|
|
struct atten_node *atten, *atten_n;
|
|
|
|
pt_debug(cd->dev, DL_DEBUG, "%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);
|
|
pt_debug(cd->dev, DL_DEBUG,
|
|
"%s: attention for '%s'",
|
|
__func__, dev_name(atten->dev));
|
|
atten->func(atten->dev);
|
|
spin_lock(&cd->spinlock);
|
|
}
|
|
}
|
|
spin_unlock(&cd->spinlock);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: start_fw_upgrade
|
|
*
|
|
* SUMMARY: Calling "PT_ATTEN_LOADER" attention list that loader registered to
|
|
* start firmware upgrade.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
*
|
|
* PARAMETERS:
|
|
* *data - pointer to core data
|
|
******************************************************************************/
|
|
static int start_fw_upgrade(void *data)
|
|
{
|
|
struct pt_core_data *cd = (struct pt_core_data *)data;
|
|
|
|
call_atten_cb(cd, PT_ATTEN_LOADER, 0);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_put_device_into_easy_wakeup_
|
|
*
|
|
* SUMMARY: Call the enter_easywake_state function and set the device into easy
|
|
* wake up state.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
******************************************************************************/
|
|
static int pt_put_device_into_easy_wakeup_(struct pt_core_data *cd)
|
|
{
|
|
int rc = 0;
|
|
u8 status = 0;
|
|
|
|
mutex_lock(&cd->system_lock);
|
|
cd->wait_until_wake = 0;
|
|
mutex_unlock(&cd->system_lock);
|
|
|
|
rc = pt_hid_output_enter_easywake_state_(cd,
|
|
cd->easy_wakeup_gesture, &status);
|
|
if (rc || status == 0)
|
|
return -EBUSY;
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_put_device_into_deep_sleep_
|
|
*
|
|
* SUMMARY: Call the set_power function and set the DUT to deep sleep
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = error
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
******************************************************************************/
|
|
static int pt_put_device_into_deep_sleep_(struct pt_core_data *cd)
|
|
{
|
|
int rc = 0;
|
|
|
|
rc = pt_hid_cmd_set_power_(cd, HID_POWER_SLEEP);
|
|
if (rc)
|
|
rc = -EBUSY;
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_put_device_into_deep_standby_
|
|
*
|
|
* SUMMARY: Call the set_power function and set the DUT to Deep Standby
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = error
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
******************************************************************************/
|
|
static int pt_put_device_into_deep_standby_(struct pt_core_data *cd)
|
|
{
|
|
int rc = 0;
|
|
|
|
rc = pt_hid_cmd_set_power_(cd, HID_POWER_STANDBY);
|
|
if (rc)
|
|
rc = -EBUSY;
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_core_poweroff_device_
|
|
*
|
|
* SUMMARY: Disable IRQ and HW power down the device.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
******************************************************************************/
|
|
static int pt_core_poweroff_device_(struct pt_core_data *cd)
|
|
{
|
|
int rc;
|
|
|
|
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)
|
|
pt_debug(cd->dev, DL_ERROR, "%s: HW Power down fails r=%d\n",
|
|
__func__, rc);
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_core_sleep_
|
|
*
|
|
* SUMMARY: Suspend the device with power off or deep sleep based on the
|
|
* configuration in the core platform data structure.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
******************************************************************************/
|
|
static int pt_core_sleep_(struct pt_core_data *cd)
|
|
{
|
|
int rc = 0;
|
|
|
|
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);
|
|
|
|
/* Ensure watchdog and startup works stopped */
|
|
pt_stop_wd_timer(cd);
|
|
cancel_work_sync(&cd->enum_work);
|
|
pt_stop_wd_timer(cd);
|
|
|
|
if (IS_EASY_WAKE_CONFIGURED(cd->easy_wakeup_gesture))
|
|
rc = pt_put_device_into_easy_wakeup_(cd);
|
|
else if (cd->cpdata->flags & PT_CORE_FLAG_POWEROFF_ON_SLEEP)
|
|
rc = pt_core_poweroff_device_(cd);
|
|
else if (cd->cpdata->flags & PT_CORE_FLAG_DEEP_STANDBY)
|
|
rc = pt_put_device_into_deep_standby_(cd);
|
|
else
|
|
rc = pt_put_device_into_deep_sleep_(cd);
|
|
|
|
mutex_lock(&cd->system_lock);
|
|
cd->sleep_state = SS_SLEEP_ON;
|
|
mutex_unlock(&cd->system_lock);
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_core_sleep
|
|
*
|
|
* SUMMARY: Protected call to pt_core_sleep_ by exclusive access to the DUT.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
******************************************************************************/
|
|
static int pt_core_sleep(struct pt_core_data *cd)
|
|
{
|
|
int rc = 0;
|
|
|
|
rc = request_exclusive(cd, cd->dev, PT_REQUEST_EXCLUSIVE_TIMEOUT);
|
|
if (rc < 0) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail get exclusive ex=%p own=%p\n",
|
|
__func__, cd->exclusive_dev, cd->dev);
|
|
return rc;
|
|
}
|
|
|
|
rc = pt_core_sleep_(cd);
|
|
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail to release exclusive\n", __func__);
|
|
else
|
|
pt_debug(cd->dev, DL_DEBUG, "%s: pass release exclusive\n",
|
|
__func__);
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_wakeup_host
|
|
*
|
|
* SUMMARY: Check wake up report and call the PT_ATTEN_WAKE attention list.
|
|
*
|
|
* NOTE: TSG5 EasyWake and TSG6 EasyWake use different protocol.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
******************************************************************************/
|
|
static int pt_wakeup_host(struct pt_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;
|
|
|
|
event_id = cd->input_buf[3];
|
|
|
|
pt_debug(cd->dev, DL_INFO, "%s: e=%d, rc=%d\n",
|
|
__func__, event_id, rc);
|
|
|
|
if (rc) {
|
|
pt_core_sleep_(cd);
|
|
goto exit;
|
|
}
|
|
|
|
/* attention WAKE */
|
|
call_atten_cb(cd, PT_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] != PT_PIP_WAKEUP_REPORT_ID) {
|
|
rc = -EINVAL;
|
|
pt_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;
|
|
|
|
pt_debug(cd->dev, DL_INFO,
|
|
"%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, PT_ATTEN_WAKE, 0);
|
|
exit:
|
|
return rc;
|
|
#endif
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_get_touch_axis
|
|
*
|
|
* SUMMARY: Function to calculate touch axis
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data structure
|
|
* *axis - pointer to axis calculation result
|
|
* size - size in bytes
|
|
* max - max value of result
|
|
* *xy_data - pointer to input data to be parsed
|
|
* bofs - bit offset
|
|
******************************************************************************/
|
|
static void pt_get_touch_axis(struct pt_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;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: move_tracking_heatmap_data
|
|
*
|
|
* SUMMARY: Move the valid tracking heatmap data from the input buffer into the
|
|
* system information structure, xy_mode and xy_data.
|
|
* - If TTHE_TUNER_SUPPORT is defined print the raw sensor data into
|
|
* the tthe_tuner sysfs node under the label "THM"
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* *si - pointer to the system information structure
|
|
******************************************************************************/
|
|
static int move_tracking_heatmap_data(struct pt_core_data *cd,
|
|
struct pt_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;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: move_sensor_data
|
|
*
|
|
* SUMMARY: Move the valid sensor data from the input buffer into the system
|
|
* system information structure, xy_mode and xy_data.
|
|
* - If TTHE_TUNER_SUPPORT is defined print the raw sensor data into
|
|
* the tthe_tuner sysfs node under the label "sensor_monitor"
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* *si - pointer to the system information structure
|
|
******************************************************************************/
|
|
static int move_sensor_data(struct pt_core_data *cd,
|
|
struct pt_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;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: move_button_data
|
|
*
|
|
* SUMMARY: Move the valid button data from the input buffer into the system
|
|
* system information structure, xy_mode and xy_data.
|
|
* - If TTHE_TUNER_SUPPORT is defined print the raw button data into
|
|
* the tthe_tuner sysfs node under the label "OpModeData"
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* *si - pointer to the system information structure
|
|
******************************************************************************/
|
|
static int move_button_data(struct pt_core_data *cd,
|
|
struct pt_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);
|
|
pt_pr_buf(cd->dev, DL_INFO, (u8 *)si->xy_mode, BTN_INPUT_HEADER_SIZE,
|
|
"xy_mode");
|
|
|
|
memcpy(si->xy_data, &cd->input_buf[BTN_INPUT_HEADER_SIZE],
|
|
BTN_REPORT_SIZE);
|
|
pt_pr_buf(cd->dev, DL_INFO, (u8 *)si->xy_data, BTN_REPORT_SIZE,
|
|
"xy_data");
|
|
return 0;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: move_touch_data
|
|
*
|
|
* SUMMARY: Move the valid touch data from the input buffer into the system
|
|
* system information structure, xy_mode and xy_data.
|
|
* - If TTHE_TUNER_SUPPORT is defined print the raw touch data into
|
|
* the tthe_tuner sysfs node under the label "OpModeData"
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* *si - pointer to the system information structure
|
|
******************************************************************************/
|
|
static int move_touch_data(struct pt_core_data *cd, struct pt_sysinfo *si)
|
|
{
|
|
int max_tch = si->sensing_conf_data.max_tch;
|
|
int num_cur_tch;
|
|
int length;
|
|
struct pt_tch_abs_params *tch = &si->tch_hdr[PT_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);
|
|
pt_pr_buf(cd->dev, DL_INFO, (u8 *)si->xy_mode,
|
|
si->desc.tch_header_size, "xy_mode");
|
|
|
|
pt_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);
|
|
pt_pr_buf(cd->dev, DL_INFO, (u8 *)si->xy_data, length, "xy_data");
|
|
return 0;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: move_hid_pen_data
|
|
*
|
|
* SUMMARY: TODO Move the valid pen data from the input buffer into the system
|
|
* system information structure, xy_mode and xy_data.
|
|
* - If TTHE_TUNER_SUPPORT is defined print the raw pen data into
|
|
* the tthe_tuner sysfs node under the label "HID" starting with the
|
|
* report ID.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* *si - pointer to the system information structure
|
|
******************************************************************************/
|
|
static int move_hid_pen_data(struct pt_core_data *cd, struct pt_sysinfo *si)
|
|
{
|
|
#ifdef TTHE_TUNER_SUPPORT
|
|
int size = get_unaligned_le16(&cd->input_buf[0]);
|
|
|
|
if (size) {
|
|
/*
|
|
* HID over USB does not require the two byte length field, so
|
|
* this should print from input_buf[2] but to keep both finger
|
|
* and pen reports the same the length is included
|
|
*/
|
|
if (cd->tthe_hid_usb_format == PT_FEATURE_ENABLE)
|
|
tthe_print(cd, &(cd->input_buf[2]), size - 2,
|
|
"HID-USB=");
|
|
else
|
|
tthe_print(cd, &(cd->input_buf[0]), size,
|
|
"HID-I2C=");
|
|
}
|
|
#endif
|
|
pt_pr_buf(cd->dev, DL_INFO, (u8 *)&(cd->input_buf[0]), size, "HID Pen");
|
|
return 0;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: parse_touch_input
|
|
*
|
|
* SUMMARY: Parse the touch report and take action based on the touch
|
|
* report_id.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* size - size of touch record
|
|
******************************************************************************/
|
|
static int parse_touch_input(struct pt_core_data *cd, int size)
|
|
{
|
|
struct pt_sysinfo *si = &cd->sysinfo;
|
|
int report_id = cd->input_buf[2];
|
|
int rc = -EINVAL;
|
|
|
|
pt_debug(cd->dev, DL_DEBUG, "%s: Received touch report\n",
|
|
__func__);
|
|
if (!si->ready) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: Need system information to parse touches\n",
|
|
__func__);
|
|
return 0;
|
|
}
|
|
|
|
if (!si->xy_mode || !si->xy_data)
|
|
return rc;
|
|
|
|
if (report_id == PT_PIP_TOUCH_REPORT_ID)
|
|
rc = move_touch_data(cd, si);
|
|
else if (report_id == PT_HID_PEN_REPORT_ID)
|
|
rc = move_hid_pen_data(cd, si);
|
|
else if (report_id == PT_PIP_CAPSENSE_BTN_REPORT_ID)
|
|
rc = move_button_data(cd, si);
|
|
else if (report_id == PT_PIP_SENSOR_DATA_REPORT_ID)
|
|
rc = move_sensor_data(cd, si);
|
|
else if (report_id == PT_PIP_TRACKING_HEATMAP_REPORT_ID)
|
|
rc = move_tracking_heatmap_data(cd, si);
|
|
|
|
if (rc)
|
|
return rc;
|
|
|
|
/* attention IRQ */
|
|
call_atten_cb(cd, PT_ATTEN_IRQ, cd->mode);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: parse_command_input
|
|
*
|
|
* SUMMARY: Move the response data from the input buffer to the response buffer
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* size - size of response data
|
|
******************************************************************************/
|
|
static int parse_command_input(struct pt_core_data *cd, int size)
|
|
{
|
|
pt_debug(cd->dev, DL_DEBUG, "%s: Received cmd interrupt\n",
|
|
__func__);
|
|
|
|
memcpy(cd->response_buf, cd->input_buf, size);
|
|
#if defined(TTHE_TUNER_SUPPORT) && defined(TTDL_DIAGNOSTICS)
|
|
if (size && cd->show_tt_data) {
|
|
if (cd->pip2_prot_active)
|
|
tthe_print(cd, cd->input_buf, size, "TT_DATA_PIP2=");
|
|
else
|
|
tthe_print(cd, cd->input_buf, size, "TT_DATA=");
|
|
}
|
|
#endif
|
|
|
|
mutex_lock(&cd->system_lock);
|
|
cd->hid_cmd_state = 0;
|
|
mutex_unlock(&cd->system_lock);
|
|
wake_up(&cd->wait_q);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_allow_enumeration
|
|
*
|
|
* SUMMARY: Determine if an enumeration or fully re-probe should perform when
|
|
* FW sentinel is seen.
|
|
*
|
|
* RETURN:
|
|
* true = allow enumeration or fully re-probe
|
|
* false = skip enumeration and fully re-probe
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
******************************************************************************/
|
|
static inline bool pt_allow_enumeration(struct pt_core_data *cd)
|
|
{
|
|
if ((cd->panel_id_support & PT_PANEL_ID_BY_SYS_INFO) &&
|
|
(!cd->hid_reset_cmd_state) &&
|
|
(cd->core_probe_complete) &&
|
|
(cd->hid_cmd_state != PIP1_CMD_ID_START_BOOTLOADER + 1) &&
|
|
(cd->hid_cmd_state != PIP1_BL_CMD_ID_LAUNCH_APP + 1) &&
|
|
(cd->mode == PT_MODE_OPERATIONAL)) {
|
|
return true;
|
|
}
|
|
|
|
if ((!cd->hid_reset_cmd_state) &&
|
|
(cd->core_probe_complete) &&
|
|
(cd->hid_cmd_state != PIP1_CMD_ID_START_BOOTLOADER + 1) &&
|
|
(cd->hid_cmd_state != PIP1_BL_CMD_ID_LAUNCH_APP + 1) &&
|
|
(cd->active_dut_generation != DUT_PIP1_ONLY)) {
|
|
return true;
|
|
}
|
|
|
|
pt_debug(cd->dev, DL_INFO,
|
|
"%s: Dissallow - %s=%d %s=%d %s=0x%02X %s=%d\n",
|
|
__func__,
|
|
"hid_reset_cmd_state(0)", cd->hid_reset_cmd_state,
|
|
"core_probe_complete(1)", cd->core_probe_complete,
|
|
"hid_cmd_state(Not 0x02 or 0x39)", cd->hid_cmd_state,
|
|
"active_dut_gen(0,2)", cd->active_dut_generation);
|
|
return false;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_is_touch_report
|
|
*
|
|
* SUMMARY: Determine if a report ID should be treated as a touch report
|
|
*
|
|
* RETURN:
|
|
* true = report ID is a touch report
|
|
* false = report ID is not a touch report
|
|
*
|
|
* PARAMETERS:
|
|
* id - Report ID
|
|
******************************************************************************/
|
|
static bool pt_is_touch_report(int id)
|
|
{
|
|
if (id == PT_PIP_TOUCH_REPORT_ID ||
|
|
id == PT_HID_PEN_REPORT_ID ||
|
|
id == PT_PIP_CAPSENSE_BTN_REPORT_ID ||
|
|
id == PT_PIP_SENSOR_DATA_REPORT_ID ||
|
|
id == PT_PIP_TRACKING_HEATMAP_REPORT_ID)
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_parse_input
|
|
*
|
|
* SUMMARY: Parse the input data read from DUT due to IRQ. Handle data based
|
|
* on if its a response to a command or asynchronous touch data / reset
|
|
* sentinel. PIP2.x messages have additional error checking that is
|
|
* parsed (SEQ match from cmd to rsp, CRC valid).
|
|
* Look for special packets based on unique lengths:
|
|
* 0 bytes - APP(FW) reset sentinel or Gen5/6 BL sentinel
|
|
* 2 bytes - Empty buffer (PIP 1.7 and earlier)
|
|
* 11 bytes - possible PIP2.x reset sentinel (TAG and SEQ must = 0)
|
|
* 0xFFXX - Empty buffer (PIP 1.7+)
|
|
* Queue a startup after any asynchronous FW reset sentinel is seen, unless
|
|
* the initial probe has not yet been done.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
******************************************************************************/
|
|
static int pt_parse_input(struct pt_core_data *cd)
|
|
{
|
|
int report_id;
|
|
int cmd_id;
|
|
int is_command = 0;
|
|
int size;
|
|
int print_size;
|
|
bool touch_report = true;
|
|
unsigned short calc_crc;
|
|
unsigned short resp_crc;
|
|
|
|
cd->fw_sys_mode_in_standby_state = false;
|
|
size = get_unaligned_le16(&cd->input_buf[0]);
|
|
print_size = size;
|
|
pt_debug(cd->dev, DL_DEBUG, "<<< %s: IRQ Triggered, read len [%d]\n",
|
|
__func__, print_size);
|
|
if (print_size <= PT_MAX_INPUT)
|
|
pt_pr_buf(cd->dev, DL_DEBUG, cd->input_buf, print_size,
|
|
"<<< Read buf");
|
|
|
|
if (size == 0 ||
|
|
(size == 11 &&
|
|
(cd->input_buf[PIP2_RESP_SEQUENCE_OFFSET] &
|
|
PIP2_RESP_SEQUENCE_MASK) == 0 &&
|
|
(cd->input_buf[PIP2_RESP_REPORT_ID_OFFSET] &
|
|
PIP2_CMD_COMMAND_ID_MASK) ==
|
|
PIP2_CMD_ID_STATUS)) {
|
|
touch_report = false;
|
|
cd->hw_detected = true;
|
|
cd->bl_pip_ver_ready = false;
|
|
cd->app_pip_ver_ready = false;
|
|
if (size == 0) {
|
|
mutex_lock(&cd->system_lock);
|
|
cd->pip2_prot_active = false;
|
|
if (cd->active_dut_generation == DUT_PIP1_ONLY) {
|
|
/*
|
|
* For Gen5/6 this sentinel could be from
|
|
* the BL or FW. Attempt to set the correct
|
|
* mode based on the previous PIP command.
|
|
*/
|
|
if (cd->hid_cmd_state ==
|
|
PIP1_BL_CMD_ID_LAUNCH_APP + 1) {
|
|
cd->mode = PT_MODE_OPERATIONAL;
|
|
cd->startup_status =
|
|
STARTUP_STATUS_FW_RESET_SENTINEL;
|
|
} else if (cd->hid_cmd_state ==
|
|
PIP1_CMD_ID_START_BOOTLOADER + 1 ||
|
|
cd->hid_reset_cmd_state) {
|
|
cd->mode = PT_MODE_BOOTLOADER;
|
|
cd->startup_status =
|
|
STARTUP_STATUS_BL_RESET_SENTINEL;
|
|
} else {
|
|
cd->mode = PT_MODE_UNKNOWN;
|
|
cd->startup_status =
|
|
STARTUP_STATUS_START;
|
|
}
|
|
cd->fw_system_mode = FW_SYS_MODE_UNDEFINED;
|
|
|
|
pt_debug(cd->dev, DL_INFO,
|
|
"%s: ATM Gen5/6 %s sentinel received\n",
|
|
__func__,
|
|
(cd->mode == PT_MODE_OPERATIONAL ?
|
|
"FW" :
|
|
(cd->mode == PT_MODE_BOOTLOADER ?
|
|
"BL" : "Unknown")));
|
|
} else {
|
|
cd->mode = PT_MODE_OPERATIONAL;
|
|
cd->fw_system_mode = FW_SYS_MODE_BOOT;
|
|
cd->startup_status =
|
|
STARTUP_STATUS_FW_RESET_SENTINEL;
|
|
pt_debug(cd->dev, DL_INFO,
|
|
"%s: ATM PT/TT FW sentinel received\n",
|
|
__func__);
|
|
}
|
|
mutex_unlock(&cd->system_lock);
|
|
|
|
if (pt_allow_enumeration(cd)) {
|
|
if (cd->active_dut_generation == DUT_UNKNOWN) {
|
|
pt_debug(cd->dev, DL_INFO,
|
|
"%s: Queue Restart\n", __func__);
|
|
pt_queue_restart(cd);
|
|
} else {
|
|
pt_debug(cd->dev, DL_INFO,
|
|
"%s: Queue Enum\n", __func__);
|
|
pt_queue_enum(cd);
|
|
}
|
|
} else {
|
|
pt_debug(cd->dev, DL_INFO,
|
|
"%s: Sentinel - No Queued Action\n",
|
|
__func__);
|
|
}
|
|
|
|
} else {
|
|
/* Sentinel must be from TT/TC BL */
|
|
mutex_lock(&cd->system_lock);
|
|
cd->pip2_prot_active = true;
|
|
cd->startup_status = STARTUP_STATUS_BL_RESET_SENTINEL;
|
|
cd->mode = PT_MODE_BOOTLOADER;
|
|
cd->sysinfo.ready = false;
|
|
mutex_unlock(&cd->system_lock);
|
|
pt_debug(cd->dev, DL_INFO,
|
|
"%s: BL Reset sentinel received\n", __func__);
|
|
if (cd->flashless_dut &&
|
|
cd->flashless_auto_bl == PT_ALLOW_AUTO_BL) {
|
|
pt_debug(cd->dev, DL_INFO,
|
|
"%s: BL to RAM for flashless DUT\n",
|
|
__func__);
|
|
kthread_run(start_fw_upgrade, cd, "pt_loader");
|
|
}
|
|
}
|
|
mutex_lock(&cd->system_lock);
|
|
memcpy(cd->response_buf, cd->input_buf, 2);
|
|
if (!cd->hid_reset_cmd_state && !cd->hid_cmd_state) {
|
|
mutex_unlock(&cd->system_lock);
|
|
pt_debug(cd->dev, DL_WARN,
|
|
"%s: Device Initiated Reset\n", __func__);
|
|
wake_up(&cd->wait_q);
|
|
return 0;
|
|
}
|
|
|
|
cd->hid_reset_cmd_state = 0;
|
|
if (cd->hid_cmd_state == PIP1_CMD_ID_START_BOOTLOADER + 1 ||
|
|
cd->hid_cmd_state == PIP1_BL_CMD_ID_LAUNCH_APP + 1 ||
|
|
cd->hid_cmd_state == PIP1_CMD_ID_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 >= PT_PIP_1P7_EMPTY_BUF) {
|
|
/*
|
|
* This debug message below is used by PBATS to calculate the
|
|
* time from the last lift off IRQ to when FW exits LFT mode.
|
|
*/
|
|
touch_report = false;
|
|
pt_debug(cd->dev, DL_WARN,
|
|
"%s: DUT - Empty buffer detected\n", __func__);
|
|
return 0;
|
|
} else if (size > PT_MAX_INPUT) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: DUT - Unexpected len field in active bus data!\n",
|
|
__func__);
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (cd->pip2_prot_active) {
|
|
pt_debug(cd->dev, DL_DEBUG,
|
|
"%s: Decode PIP2.x Response\n", __func__);
|
|
|
|
/* PIP2 does not have a report id, hard code it */
|
|
report_id = 0x00;
|
|
cmd_id = cd->input_buf[PIP2_RESP_COMMAND_ID_OFFSET];
|
|
|
|
calc_crc = crc_ccitt_calculate(cd->input_buf, size - 2);
|
|
resp_crc = cd->input_buf[size - 2] << 8;
|
|
resp_crc |= cd->input_buf[size - 1];
|
|
|
|
if ((cd->pip2_cmd_tag_seq !=
|
|
(cd->input_buf[PIP2_RESP_SEQUENCE_OFFSET] & 0x0F)) &&
|
|
(resp_crc != calc_crc) &&
|
|
((cd->input_buf[PIP1_RESP_REPORT_ID_OFFSET]
|
|
== PT_PIP_TOUCH_REPORT_ID) ||
|
|
(cd->input_buf[PIP1_RESP_REPORT_ID_OFFSET]
|
|
== PT_PIP_CAPSENSE_BTN_REPORT_ID))) {
|
|
pt_debug(cd->dev, DL_WARN,
|
|
"%s: %s %d %s\n",
|
|
__func__,
|
|
"Received PIP1 report id =",
|
|
cd->input_buf[PIP1_RESP_REPORT_ID_OFFSET],
|
|
"when expecting a PIP2 report - IGNORE report");
|
|
return 0;
|
|
}
|
|
|
|
is_command = 1;
|
|
touch_report = false;
|
|
} else {
|
|
report_id = cd->input_buf[PIP1_RESP_REPORT_ID_OFFSET];
|
|
cmd_id = cd->input_buf[PIP1_RESP_COMMAND_ID_OFFSET];
|
|
}
|
|
|
|
#ifdef TTDL_DIAGNOSTICS
|
|
pt_debug(cd->dev, DL_DEBUG,
|
|
"%s: pip2 = %d report_id: 0x%02X, cmd_code: 0x%02X\n",
|
|
__func__, cd->pip2_prot_active, report_id,
|
|
(cmd_id & PIP2_CMD_COMMAND_ID_MASK));
|
|
#endif /* TTDL_DIAGNOSTICS */
|
|
|
|
if (report_id == PT_PIP_WAKEUP_REPORT_ID) {
|
|
pt_wakeup_host(cd);
|
|
#ifdef TTHE_TUNER_SUPPORT
|
|
tthe_print(cd, cd->input_buf, size, "TT_WAKEUP=");
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
mod_timer_pending(&cd->watchdog_timer, jiffies +
|
|
msecs_to_jiffies(cd->watchdog_interval));
|
|
|
|
/*
|
|
* If it is PIP2 response, the report_id has been set to 0,
|
|
* so it will not be parsed as a touch packet.
|
|
*/
|
|
if (!pt_is_touch_report(report_id)) {
|
|
is_command = 1;
|
|
touch_report = false;
|
|
}
|
|
|
|
if (unlikely(is_command)) {
|
|
parse_command_input(cd, size);
|
|
return 0;
|
|
}
|
|
|
|
if (touch_report)
|
|
parse_touch_input(cd, size);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_read_input
|
|
*
|
|
* SUMMARY: Reads incoming data off of the active bus
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
******************************************************************************/
|
|
static int pt_read_input(struct pt_core_data *cd)
|
|
{
|
|
struct device *dev = cd->dev;
|
|
int rc = 0;
|
|
int t;
|
|
int retry = PT_BUS_READ_INPUT_RETRY_COUNT;
|
|
|
|
/*
|
|
* Workaround for easywake failure
|
|
* Interrupt for easywake, wait for bus controller to wake
|
|
*/
|
|
mutex_lock(&cd->system_lock);
|
|
if (IS_EASY_WAKE_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));
|
|
#ifdef TTDL_DIAGNOSTICS
|
|
if (IS_TMO(t)) {
|
|
cd->bus_transmit_error_count++;
|
|
pt_toggle_err_gpio(cd, PT_ERR_GPIO_I2C_TRANS);
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s: !!!I2C Transmission Error %d\n",
|
|
__func__,
|
|
cd->bus_transmit_error_count);
|
|
}
|
|
#else
|
|
if (IS_TMO(t))
|
|
pt_queue_enum(cd);
|
|
#endif /* TTDL_DIAGNOSTICS */
|
|
goto read;
|
|
}
|
|
}
|
|
mutex_unlock(&cd->system_lock);
|
|
|
|
read:
|
|
/* Try reading up to 'retry' times */
|
|
while (retry-- != 0) {
|
|
rc = pt_adap_read_default_nosize(cd, cd->input_buf,
|
|
PT_MAX_INPUT);
|
|
if (!rc) {
|
|
pt_debug(dev, DL_DEBUG,
|
|
"%s: Read input successfully\n", __func__);
|
|
goto read_exit;
|
|
}
|
|
usleep_range(1000, 2000);
|
|
}
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s: Error getting report, rc=%d\n", __func__, rc);
|
|
|
|
read_exit:
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_irq
|
|
*
|
|
* SUMMARY: Process all detected interrupts
|
|
*
|
|
* RETURN:
|
|
* IRQ_HANDLED - Finished processing the interrupt
|
|
*
|
|
* PARAMETERS:
|
|
* irq - IRQ number
|
|
* *handle - pointer to core data struct
|
|
******************************************************************************/
|
|
irqreturn_t pt_irq(int irq, void *handle)
|
|
{
|
|
struct pt_core_data *cd = handle;
|
|
int rc = 0;
|
|
|
|
if (!pt_check_irq_asserted(cd))
|
|
return IRQ_HANDLED;
|
|
|
|
rc = pt_read_input(cd);
|
|
#ifdef TTDL_DIAGNOSTICS
|
|
cd->irq_count++;
|
|
|
|
/* Used to calculate T-Refresh */
|
|
if (cd->t_refresh_active) {
|
|
if (cd->t_refresh_count == 0) {
|
|
cd->t_refresh_time = jiffies;
|
|
cd->t_refresh_count++;
|
|
} else if (cd->t_refresh_count < cd->t_refresh_total) {
|
|
cd->t_refresh_count++;
|
|
} else {
|
|
cd->t_refresh_active = 0;
|
|
cd->t_refresh_time =
|
|
jiffies_to_msecs(jiffies - cd->t_refresh_time);
|
|
}
|
|
}
|
|
#endif /* TTDL_DIAGNOSTICS */
|
|
|
|
if (!rc)
|
|
pt_parse_input(cd);
|
|
|
|
return IRQ_HANDLED;
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_subscribe_attention
|
|
*
|
|
* SUMMARY: Function pointer included in core_cmds to allow other modules
|
|
* to subscribe themselves into the TTDL attention list
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* type - attention type enum
|
|
* *id - ID of the module calling this function
|
|
* *func - callback function pointer to be called when notified
|
|
* mode - attention mode
|
|
******************************************************************************/
|
|
int _pt_subscribe_attention(struct device *dev,
|
|
enum pt_atten_type type, char *id, int (*func)(struct device *),
|
|
int mode)
|
|
{
|
|
struct pt_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;
|
|
|
|
pt_debug(cd->dev, DL_INFO, "%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);
|
|
pt_debug(cd->dev, DL_INFO, "%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;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_unsubscribe_attention
|
|
*
|
|
* SUMMARY: Function pointer included in core_cmds to allow other modules
|
|
* to unsubscribe themselves from the TTDL attention list
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* type - attention type enum
|
|
* *id - ID of the module calling this function
|
|
* *func - function pointer
|
|
* mode - attention mode
|
|
******************************************************************************/
|
|
int _pt_unsubscribe_attention(struct device *dev,
|
|
enum pt_atten_type type, char *id, int (*func)(struct device *),
|
|
int mode)
|
|
{
|
|
struct pt_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);
|
|
kfree(atten);
|
|
pt_debug(cd->dev, DL_DEBUG, "%s: %s=%p %s=%d\n",
|
|
__func__,
|
|
"unsub for atten->dev", atten->dev,
|
|
"atten->mode", atten->mode);
|
|
return 0;
|
|
}
|
|
}
|
|
spin_unlock(&cd->spinlock);
|
|
|
|
return -ENODEV;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_request_exclusive
|
|
*
|
|
* SUMMARY: Function pointer included in core_cmds to allow other modules
|
|
* to request exclusive access
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* timeout_ms - timeout to wait for exclusive access
|
|
******************************************************************************/
|
|
static int _pt_request_exclusive(struct device *dev,
|
|
int timeout_ms)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
|
|
return request_exclusive(cd, (void *)dev, timeout_ms);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_release_exclusive
|
|
*
|
|
* SUMMARY: Function pointer included in core_cmds to allow other modules
|
|
* to release exclusive access
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
******************************************************************************/
|
|
static int _pt_release_exclusive(struct device *dev)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
|
|
return release_exclusive(cd, (void *)dev);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_request_reset
|
|
*
|
|
* SUMMARY: Function pointer included in core_cmds to allow other modules
|
|
* to request the DUT to be reset. Function returns err if refused or
|
|
* timeout occurs (Note: core uses fixed timeout period).
|
|
*
|
|
* NOTE: Function blocks until ISR occurs.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* protect - flag to call protected or non-protected
|
|
******************************************************************************/
|
|
static int _pt_request_reset(struct device *dev, int protect)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
int rc;
|
|
|
|
rc = pt_dut_reset(cd, protect);
|
|
if (rc < 0) {
|
|
pt_debug(cd->dev, DL_ERROR, "%s: Error on h/w reset r=%d\n",
|
|
__func__, rc);
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_request_enum
|
|
*
|
|
* SUMMARY: Function pointer included in core_cmds to allow other modules
|
|
* to request TTDL to queue an enum. This function will return err
|
|
* if refused; if no error then enum has completed and system is in
|
|
* normal operation mode.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* wait - boolean to determine if to wait for startup event
|
|
******************************************************************************/
|
|
static int _pt_request_enum(struct device *dev, bool wait)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
|
|
pt_queue_enum(cd);
|
|
|
|
if (wait)
|
|
wait_event_timeout(cd->wait_q,
|
|
cd->startup_state == STARTUP_NONE,
|
|
msecs_to_jiffies(PT_REQUEST_ENUM_TIMEOUT));
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_request_sysinfo
|
|
*
|
|
* SUMMARY: Function pointer included in core_cmds to allow other modules
|
|
* to request the pointer to the system information structure. This
|
|
* function will return NULL if sysinfo has not been acquired from the
|
|
* DUT yet.
|
|
*
|
|
* RETURN: Pointer to the system information struct
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
******************************************************************************/
|
|
struct pt_sysinfo *_pt_request_sysinfo(struct device *dev)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
int rc = 0;
|
|
|
|
/* Attempt to get sysinfo if not ready and panel_id is from XY pin */
|
|
if ((cd->panel_id_support & PT_PANEL_ID_BY_SYS_INFO) &&
|
|
!cd->sysinfo.ready) {
|
|
rc = pt_hid_output_get_sysinfo_(cd);
|
|
if (rc) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: Error getting sysinfo rc=%d\n",
|
|
__func__, rc);
|
|
}
|
|
}
|
|
|
|
if (cd->sysinfo.ready)
|
|
return &cd->sysinfo;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_request_loader_pdata
|
|
*
|
|
* SUMMARY: Function pointer included in core_cmds to allow other modules
|
|
* to request the pointer to the loader platform data
|
|
*
|
|
* RETURN: Pointer to the loader platform data struct
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
******************************************************************************/
|
|
static struct pt_loader_platform_data *_pt_request_loader_pdata(
|
|
struct device *dev)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
|
|
return cd->pdata->loader_pdata;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_request_start_wd
|
|
*
|
|
* SUMMARY: Function pointer included in core_cmds to allow other modules
|
|
* to request to start the TTDL watchdog
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
******************************************************************************/
|
|
static int _pt_request_start_wd(struct device *dev)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
|
|
pt_start_wd_timer(cd);
|
|
return 0;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_request_stop_wd
|
|
*
|
|
* SUMMARY: Function pointer included in core_cmds to allow other modules
|
|
* to request to stop the TTDL watchdog
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
******************************************************************************/
|
|
static int _pt_request_stop_wd(struct device *dev)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
|
|
pt_stop_wd_timer(cd);
|
|
return 0;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_pip2_launch_app
|
|
*
|
|
* SUMMARY: Sends the PIP2 EXECUTE command to launch the APP and then wait for
|
|
* the FW reset sentinel to indicate the function succeeded.
|
|
*
|
|
* NOTE: Calling this function when the DUT is in Application mode WILL result
|
|
* in a timeout delay and with the DUT being reset with an XRES.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data structure
|
|
* protect - flag to call protected or non-protected
|
|
******************************************************************************/
|
|
static int pt_pip2_launch_app(struct device *dev, int protect)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
u16 actual_read_len;
|
|
u16 tmp_startup_status = cd->startup_status;
|
|
u8 read_buf[12];
|
|
u8 status;
|
|
int time = 0;
|
|
int rc = 0;
|
|
|
|
mutex_lock(&cd->system_lock);
|
|
cd->startup_status = STARTUP_STATUS_START;
|
|
pt_debug(dev, DL_DEBUG, "%s: Startup Status Reset\n", __func__);
|
|
mutex_unlock(&cd->system_lock);
|
|
|
|
rc = _pt_request_pip2_send_cmd(dev, protect,
|
|
PIP2_CMD_ID_EXECUTE, NULL, 0, read_buf,
|
|
&actual_read_len);
|
|
if (rc) {
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s: PIP2 EXECUTE cmd failed rc = %d\n",
|
|
__func__, rc);
|
|
} else {
|
|
status = read_buf[PIP2_RESP_STATUS_OFFSET];
|
|
|
|
/* Test for no or invalid image in FLASH, no point to reset */
|
|
if (status == PIP2_RSP_ERR_INVALID_IMAGE) {
|
|
rc = status;
|
|
goto exit;
|
|
}
|
|
|
|
/* Any other boot failure */
|
|
if (status != 0) {
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s: FW did not EXECUTE, status = %d\n",
|
|
__func__, status);
|
|
rc = status;
|
|
}
|
|
}
|
|
|
|
if (rc) {
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s: Failed to launch APP, XRES DUT rc = %d\n",
|
|
__func__, rc);
|
|
goto exit;
|
|
}
|
|
|
|
while ((cd->startup_status == STARTUP_STATUS_START) && time < 240) {
|
|
msleep(20);
|
|
pt_debug(cd->dev, DL_INFO, "%s: wait for %d for enum=0x%04X\n",
|
|
__func__, time, cd->startup_status);
|
|
time += 20;
|
|
}
|
|
if (cd->startup_status == STARTUP_STATUS_START) {
|
|
pt_debug(cd->dev, DL_WARN,
|
|
"%s: TMO waiting for FW reset sentinel\n", __func__);
|
|
rc = -ETIME;
|
|
}
|
|
|
|
exit:
|
|
if (cd->startup_status == STARTUP_STATUS_START) {
|
|
/* Reset to original state because we could be stuck in BL */
|
|
mutex_lock(&cd->system_lock);
|
|
cd->startup_status = tmp_startup_status;
|
|
mutex_unlock(&cd->system_lock);
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_request_pip2_launch_app
|
|
*
|
|
* SUMMARY: Calls pt_pip2_launch_app() when configured to. A small delay is
|
|
* inserted to ensure the reset has allowed the BL reset sentinel to be
|
|
* consumed.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data structure
|
|
******************************************************************************/
|
|
static int _pt_request_pip2_launch_app(struct device *dev, int protect)
|
|
{
|
|
return pt_pip2_launch_app(dev, protect);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_request_wait_for_enum_state
|
|
*
|
|
* SUMMARY: Loops for up to timeout waiting for the startup_status to reach
|
|
* the state passed in or STARTUP_STATUS_COMPLETE whichever comes first
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data structure
|
|
* timeout - timeout for how long to wait
|
|
* state - enum state to wait for
|
|
******************************************************************************/
|
|
static int _pt_request_wait_for_enum_state(struct device *dev, int timeout,
|
|
int state)
|
|
{
|
|
int rc = 0;
|
|
int t;
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
|
|
t = wait_event_timeout(cd->wait_q,
|
|
(cd->startup_status & state) || (cd->startup_status & 0x0100),
|
|
msecs_to_jiffies(timeout));
|
|
if (IS_TMO(t)) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: TMO waiting for enum state 0x%04X in %dms\n",
|
|
__func__, state, timeout);
|
|
pt_debug(cd->dev, DL_WARN,
|
|
"%s: enum state reached 0x%04X\n",
|
|
__func__, cd->startup_status);
|
|
rc = -ETIME;
|
|
} else if (cd->startup_status & state) {
|
|
pt_debug(cd->dev, DL_INFO,
|
|
"%s: Enum state reached: enum=0x%04X in %dms\n",
|
|
__func__, cd->startup_status,
|
|
(t == 1) ? timeout : (timeout - jiffies_to_msecs(t)));
|
|
} else {
|
|
if (t == 1) {
|
|
pt_debug(
|
|
cd->dev, DL_ERROR,
|
|
"%s: TMO waiting for enum state 0x%04X in %dms\n",
|
|
__func__, state, timeout);
|
|
rc = -ETIME;
|
|
} else {
|
|
pt_debug(
|
|
cd->dev, DL_ERROR,
|
|
"%s: Enum state 0x%04X not reached in %dms\n",
|
|
__func__, state, timeout - jiffies_to_msecs(t));
|
|
rc = -EINVAL;
|
|
}
|
|
pt_debug(cd->dev, DL_INFO, "%s: enum state reached 0x%04X\n",
|
|
__func__, cd->startup_status);
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_core_wake_device_from_deep_sleep_
|
|
*
|
|
* SUMMARY: Call the set_power function and set the DUT to wake up from
|
|
* deep sleep.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = error
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
******************************************************************************/
|
|
static int pt_core_wake_device_from_deep_sleep_(
|
|
struct pt_core_data *cd)
|
|
{
|
|
int rc;
|
|
|
|
rc = pt_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;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_core_wake_device_from_easy_wake_
|
|
*
|
|
* SUMMARY: Wake up device from Easy-Wake state.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
******************************************************************************/
|
|
static int pt_core_wake_device_from_easy_wake_(struct pt_core_data *cd)
|
|
{
|
|
mutex_lock(&cd->system_lock);
|
|
cd->wait_until_wake = 1;
|
|
mutex_unlock(&cd->system_lock);
|
|
wake_up(&cd->wait_q);
|
|
msleep(20);
|
|
|
|
return pt_core_wake_device_from_deep_sleep_(cd);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_restore_parameters_
|
|
*
|
|
* SUMMARY: This function sends all RAM parameters stored in the linked list
|
|
* back to the DUT
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer the core data structure
|
|
******************************************************************************/
|
|
static int pt_restore_parameters_(struct pt_core_data *cd)
|
|
{
|
|
struct param_node *param;
|
|
int rc = 0;
|
|
|
|
if (!(cd->cpdata->flags & PT_CORE_FLAG_RESTORE_PARAMETERS))
|
|
goto exit;
|
|
|
|
spin_lock(&cd->spinlock);
|
|
list_for_each_entry(param, &cd->param_list, node) {
|
|
spin_unlock(&cd->spinlock);
|
|
pt_debug(cd->dev, DL_INFO, "%s: Parameter id:%d value:%d\n",
|
|
__func__, param->id, param->value);
|
|
rc = pt_pip_set_param_(cd, param->id,
|
|
param->value, param->size);
|
|
if (rc)
|
|
goto exit;
|
|
spin_lock(&cd->spinlock);
|
|
}
|
|
spin_unlock(&cd->spinlock);
|
|
exit:
|
|
return rc;
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_pip2_exit_bl_
|
|
*
|
|
* SUMMARY: Attempt to exit the BL and run the application, taking into account
|
|
* a DUT that may not have flash and will need FW to be loaded into RAM
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer the core data structure
|
|
* *status_str - pointer to optional status string buffer
|
|
* buf_size - size of status_str buffer
|
|
******************************************************************************/
|
|
int pt_pip2_exit_bl_(struct pt_core_data *cd, u8 *status_str, int buf_size)
|
|
{
|
|
int rc;
|
|
int wait_time = 0;
|
|
u8 mode = PT_MODE_UNKNOWN;
|
|
bool load_status_str = false;
|
|
|
|
/*
|
|
* Below function has protective call to ensure no enum is still on
|
|
* going, while this kind of protection should be applied widely in
|
|
* future (TODO).
|
|
*/
|
|
rc = pt_pip2_get_mode_sysmode(cd, &mode, NULL);
|
|
|
|
if (status_str && buf_size <= 50)
|
|
load_status_str = true;
|
|
|
|
if (mode == PT_MODE_BOOTLOADER) {
|
|
if (cd->flashless_dut == 1) {
|
|
rc = pt_hw_hard_reset(cd);
|
|
} else {
|
|
rc = pt_pip2_launch_app(cd->dev,
|
|
PT_CORE_CMD_UNPROTECTED);
|
|
if (rc == PIP2_RSP_ERR_INVALID_IMAGE) {
|
|
pt_debug(cd->dev, DL_ERROR, "%s: %s = %d\n",
|
|
__func__, "Invalid image in FLASH rc", rc);
|
|
} else if (rc) {
|
|
pt_debug(cd->dev, DL_ERROR, "%s: %s = %d\n",
|
|
__func__, "Failed to launch app rc", rc);
|
|
}
|
|
}
|
|
|
|
if (!rc) {
|
|
if (cd->flashless_dut == 1) {
|
|
/* Wait for BL to complete before enum */
|
|
rc = _pt_request_wait_for_enum_state(cd->dev,
|
|
4000, STARTUP_STATUS_FW_RESET_SENTINEL);
|
|
if (rc && load_status_str) {
|
|
strcpy(status_str,
|
|
"No FW sentinel after BL");
|
|
goto exit;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* If the host wants to interact with the FW or do a
|
|
* forced calibration, the FW must be out of BOOT mode
|
|
* and the system information must have been retrieved.
|
|
* Reaching the FW_OUT_OF_BOOT state guarantees both.
|
|
* If, however, the enumeration does not reach this
|
|
* point, the DUT may still be in APP mode so test
|
|
* for all conditions.
|
|
*/
|
|
rc = _pt_request_wait_for_enum_state(cd->dev, 4500,
|
|
STARTUP_STATUS_FW_OUT_OF_BOOT);
|
|
if (!rc || cd->startup_status >=
|
|
STARTUP_STATUS_FW_RESET_SENTINEL) {
|
|
mutex_lock(&cd->system_lock);
|
|
cd->mode = PT_MODE_OPERATIONAL;
|
|
mutex_unlock(&cd->system_lock);
|
|
}
|
|
if (rc) {
|
|
pt_debug(cd->dev, DL_WARN, "%s: %s: 0x%04X\n",
|
|
__func__, "Failed to enum with DUT",
|
|
cd->startup_status);
|
|
if (load_status_str && !(cd->startup_status &
|
|
STARTUP_STATUS_FW_OUT_OF_BOOT)) {
|
|
strcpy(status_str,
|
|
"FW Stuck in Boot mode");
|
|
goto exit;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* The comming FW sentinel could wake up the event
|
|
* queue, which has chance to be taken by next command
|
|
* wrongly. Following delay is a workaround to avoid
|
|
* this issue for most situations.
|
|
*/
|
|
msleep(20);
|
|
|
|
pt_start_wd_timer(cd);
|
|
}
|
|
if (load_status_str) {
|
|
if (rc == PIP2_RSP_ERR_INVALID_IMAGE)
|
|
strcpy(status_str,
|
|
"Failed - Invalid image in FLASH");
|
|
else if (!rc)
|
|
strcpy(status_str,
|
|
"Entered APP from BL mode");
|
|
else
|
|
strcpy(status_str,
|
|
"Failed to enter APP from BL mode");
|
|
}
|
|
} else if (mode == PT_MODE_OPERATIONAL) {
|
|
mutex_lock(&cd->system_lock);
|
|
cd->mode = mode;
|
|
mutex_unlock(&cd->system_lock);
|
|
rc = pt_poll_for_fw_exit_boot_mode(cd, 1500, &wait_time);
|
|
if (load_status_str) {
|
|
if (!rc)
|
|
strcpy(status_str,
|
|
"Already in APP mode");
|
|
else
|
|
strcpy(status_str,
|
|
"Already in APP mode - FW stuck in Boot mode");
|
|
}
|
|
} else if (rc || mode == PT_MODE_UNKNOWN) {
|
|
mutex_lock(&cd->system_lock);
|
|
cd->mode = mode;
|
|
mutex_unlock(&cd->system_lock);
|
|
if (load_status_str)
|
|
strcpy(status_str, "Failed to determine active mode");
|
|
}
|
|
|
|
exit:
|
|
if (!rc)
|
|
pt_start_wd_timer(cd);
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_pip2_exit_bl
|
|
*
|
|
* SUMMARY: Wrapper function for _pt_pip2_exit_bl that guarantees exclusive
|
|
* access.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer the core data structure
|
|
* *status_str - pointer to optional status string buffer
|
|
* buf_size - size of status_str buffer
|
|
******************************************************************************/
|
|
int pt_pip2_exit_bl(struct pt_core_data *cd, u8 *status_str, int buf_size)
|
|
{
|
|
int rc;
|
|
|
|
rc = request_exclusive(cd, cd->dev, PT_REQUEST_EXCLUSIVE_TIMEOUT);
|
|
if (rc < 0) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail get exclusive ex=%p own=%p\n", __func__,
|
|
cd->exclusive_dev, cd->dev);
|
|
return rc;
|
|
}
|
|
|
|
rc = pt_pip2_exit_bl_(cd, status_str, buf_size);
|
|
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
|
pt_debug(cd->dev, DL_ERROR, "%s: fail to release exclusive\n",
|
|
__func__);
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _fast_startup
|
|
*
|
|
* SUMMARY: Perform fast startup after resume device by power on/off stratergy.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer the core data structure
|
|
******************************************************************************/
|
|
static int _fast_startup(struct pt_core_data *cd)
|
|
{
|
|
int retry = PT_CORE_STARTUP_RETRY_COUNT;
|
|
int rc = 0;
|
|
u8 mode = PT_MODE_UNKNOWN;
|
|
struct pt_hid_desc hid_desc;
|
|
int wait_time = 0;
|
|
|
|
memset(&hid_desc, 0, sizeof(hid_desc));
|
|
|
|
reset:
|
|
if (retry != PT_CORE_STARTUP_RETRY_COUNT)
|
|
pt_debug(cd->dev, DL_INFO, "%s: Retry %d\n", __func__,
|
|
PT_CORE_STARTUP_RETRY_COUNT - retry);
|
|
|
|
if (cd->active_dut_generation == DUT_PIP1_ONLY) {
|
|
pt_debug(cd->dev, DL_INFO, "%s: PIP1 Enumeration start\n",
|
|
__func__);
|
|
pt_flush_bus_if_irq_asserted(cd, PT_FLUSH_BUS_BASED_ON_LEN);
|
|
|
|
rc = pt_get_hid_descriptor_(cd, &hid_desc);
|
|
if (rc < 0) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: Error on getting HID descriptor r=%d\n",
|
|
__func__, rc);
|
|
if (retry--)
|
|
goto reset;
|
|
goto exit;
|
|
}
|
|
cd->mode = pt_get_mode(cd, &hid_desc);
|
|
|
|
if (cd->mode == PT_MODE_BOOTLOADER) {
|
|
pt_debug(cd->dev, DL_INFO, "%s: Bootloader mode\n",
|
|
__func__);
|
|
rc = pt_hid_output_bl_launch_app_(cd);
|
|
if (rc < 0) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: Error on launch app r=%d\n",
|
|
__func__, rc);
|
|
if (retry--)
|
|
goto reset;
|
|
goto exit;
|
|
}
|
|
rc = pt_get_hid_descriptor_(cd, &hid_desc);
|
|
if (rc < 0) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: Error on getting HID descriptor r=%d\n",
|
|
__func__, rc);
|
|
if (retry--)
|
|
goto reset;
|
|
goto exit;
|
|
}
|
|
cd->mode = pt_get_mode(cd, &hid_desc);
|
|
if (cd->mode == PT_MODE_BOOTLOADER) {
|
|
if (retry--)
|
|
goto reset;
|
|
goto exit;
|
|
}
|
|
}
|
|
|
|
cd->startup_status |= STARTUP_STATUS_GET_DESC;
|
|
cd->startup_status |= STARTUP_STATUS_FW_OUT_OF_BOOT;
|
|
} else {
|
|
pt_debug(cd->dev, DL_INFO, "%s: PIP2 Enumeration start\n",
|
|
__func__);
|
|
|
|
if (retry == PT_CORE_STARTUP_RETRY_COUNT) {
|
|
/* Wait for any sentinel before first try */
|
|
rc = _pt_request_wait_for_enum_state(
|
|
cd->dev, 150,
|
|
STARTUP_STATUS_BL_RESET_SENTINEL |
|
|
STARTUP_STATUS_FW_RESET_SENTINEL);
|
|
if (rc)
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: No Sentinel detected rc = %d\n",
|
|
__func__, rc);
|
|
} else
|
|
pt_flush_bus_if_irq_asserted(cd,
|
|
PT_FLUSH_BUS_BASED_ON_LEN);
|
|
|
|
rc = pt_pip2_get_mode_sysmode_(cd, &mode, NULL);
|
|
if (rc) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: Get mode failed, mode unknown\n",
|
|
__func__);
|
|
mode = PT_MODE_UNKNOWN;
|
|
}
|
|
cd->mode = mode;
|
|
|
|
if (cd->mode == PT_MODE_BOOTLOADER) {
|
|
pt_debug(cd->dev, DL_INFO, "%s: Bootloader mode\n",
|
|
__func__);
|
|
rc = pt_pip2_exit_bl_(cd, NULL, 0);
|
|
if (rc) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s Failed to exit bootloader\n",
|
|
__func__);
|
|
msleep(50);
|
|
rc = -ENODEV;
|
|
if (retry--)
|
|
goto reset;
|
|
goto exit;
|
|
} else {
|
|
pt_debug(cd->dev, DL_INFO,
|
|
"%s: Exit bootloader succesfully\n",
|
|
__func__);
|
|
}
|
|
|
|
if (cd->mode != PT_MODE_OPERATIONAL) {
|
|
pt_debug(cd->dev, DL_WARN,
|
|
"%s: restore mode failure mode = %d\n",
|
|
__func__, cd->mode);
|
|
if (retry--)
|
|
goto reset;
|
|
goto exit;
|
|
}
|
|
}
|
|
cd->startup_status |= STARTUP_STATUS_GET_DESC;
|
|
}
|
|
|
|
/* FW cannot handle most PIP cmds when it is still in BOOT mode */
|
|
rc = _pt_poll_for_fw_exit_boot_mode(cd, 500, &wait_time);
|
|
if (!rc) {
|
|
cd->startup_status |= STARTUP_STATUS_FW_OUT_OF_BOOT;
|
|
pt_debug(cd->dev, DL_WARN,
|
|
"%s: Exit FW BOOT Mode after %dms\n",
|
|
__func__, wait_time);
|
|
} else {
|
|
pt_debug(cd->dev, DL_WARN,
|
|
"%s: FW stuck in BOOT Mode after %dms\n",
|
|
__func__, wait_time);
|
|
goto exit;
|
|
}
|
|
|
|
if (!cd->sysinfo.ready) {
|
|
rc = pt_hid_output_get_sysinfo_(cd);
|
|
if (rc) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: Error on getting sysinfo r=%d\n",
|
|
__func__, rc);
|
|
if (retry--)
|
|
goto reset;
|
|
goto exit;
|
|
}
|
|
}
|
|
cd->startup_status |= STARTUP_STATUS_GET_SYS_INFO;
|
|
|
|
rc = pt_restore_parameters_(cd);
|
|
if (rc)
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: failed to restore parameters rc=%d\n",
|
|
__func__, rc);
|
|
else
|
|
cd->startup_status |= STARTUP_STATUS_RESTORE_PARM;
|
|
|
|
exit:
|
|
cd->startup_status |= STARTUP_STATUS_COMPLETE;
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_core_poweron_device_
|
|
*
|
|
* SUMMARY: Power on device, enable IRQ, and then perform a fast startup.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
******************************************************************************/
|
|
static int pt_core_poweron_device_(struct pt_core_data *cd)
|
|
{
|
|
struct device *dev = cd->dev;
|
|
int rc = 0;
|
|
|
|
/*
|
|
* After power on action, the chip can general FW sentinel. It can
|
|
* trigger an enumeration without hid_reset_cmd_state flag. Since the
|
|
* _fast_startup() can perform a quick enumeration too, here doesn't
|
|
* need another enumeration.
|
|
*/
|
|
mutex_lock(&cd->system_lock);
|
|
cd->startup_status = STARTUP_STATUS_START;
|
|
cd->hid_reset_cmd_state = 1;
|
|
mutex_unlock(&cd->system_lock);
|
|
|
|
rc = cd->cpdata->power(cd->cpdata, 1, dev, 0);
|
|
if (rc < 0) {
|
|
pt_debug(dev, DL_ERROR, "%s: HW Power up fails r=%d\n",
|
|
__func__, rc);
|
|
goto exit;
|
|
}
|
|
|
|
if (!cd->irq_enabled) {
|
|
cd->irq_enabled = true;
|
|
enable_irq(cd->irq);
|
|
}
|
|
|
|
/* TBD: following function doesn't update startup_status */
|
|
rc = _fast_startup(cd);
|
|
exit:
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_core_wake_device_from_deep_standby_
|
|
*
|
|
* SUMMARY: Reset device, and then trigger a full enumeration.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
******************************************************************************/
|
|
static int pt_core_wake_device_from_deep_standby_(struct pt_core_data *cd)
|
|
{
|
|
int rc;
|
|
|
|
rc = pt_dut_reset_and_wait(cd);
|
|
if (rc < 0) {
|
|
pt_debug(cd->dev, DL_ERROR, "%s: Error on h/w reset r=%d\n",
|
|
__func__, rc);
|
|
goto exit;
|
|
}
|
|
|
|
rc = _fast_startup(cd);
|
|
exit:
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_core_wake_
|
|
*
|
|
* SUMMARY: Resume the device with a power on or wake from deep sleep based on
|
|
* the configuration in the core platform data structure.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
******************************************************************************/
|
|
static int pt_core_wake_(struct pt_core_data *cd)
|
|
{
|
|
int rc = 0;
|
|
|
|
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 & PT_CORE_FLAG_SKIP_RESUME)) {
|
|
if (IS_EASY_WAKE_CONFIGURED(cd->easy_wakeup_gesture))
|
|
rc = pt_core_wake_device_from_easy_wake_(cd);
|
|
else if (cd->cpdata->flags & PT_CORE_FLAG_POWEROFF_ON_SLEEP)
|
|
rc = pt_core_poweron_device_(cd);
|
|
else if (cd->cpdata->flags & PT_CORE_FLAG_DEEP_STANDBY)
|
|
rc = pt_core_wake_device_from_deep_standby_(cd);
|
|
else /* Default action to exit DeepSleep */
|
|
rc = pt_core_wake_device_from_deep_sleep_(cd);
|
|
}
|
|
|
|
mutex_lock(&cd->system_lock);
|
|
cd->sleep_state = SS_SLEEP_OFF;
|
|
mutex_unlock(&cd->system_lock);
|
|
|
|
pt_start_wd_timer(cd);
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_core_wake_
|
|
*
|
|
* SUMMARY: Protected call to pt_core_wake_ by exclusive access to the DUT.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
******************************************************************************/
|
|
static int pt_core_wake(struct pt_core_data *cd)
|
|
{
|
|
int rc;
|
|
|
|
rc = request_exclusive(cd, cd->dev, PT_REQUEST_EXCLUSIVE_TIMEOUT);
|
|
if (rc < 0) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail get exclusive ex=%p own=%p\n",
|
|
__func__, cd->exclusive_dev, cd->dev);
|
|
return rc;
|
|
}
|
|
|
|
rc = pt_core_wake_(cd);
|
|
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
|
pt_debug(cd->dev, DL_ERROR, "%s: fail to release exclusive\n",
|
|
__func__);
|
|
else
|
|
pt_debug(cd->dev, DL_DEBUG, "%s: pass release exclusive\n",
|
|
__func__);
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_get_ic_crc_
|
|
*
|
|
* SUMMARY: This function retrieves the config block CRC
|
|
*
|
|
* NOTE: The post condition of calling this function will be that the DUT will
|
|
* be in SCANNINING mode if no failures occur
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer the core data structure
|
|
* ebid - enumerated block ID
|
|
******************************************************************************/
|
|
static int pt_get_ic_crc_(struct pt_core_data *cd, u8 ebid)
|
|
{
|
|
struct pt_sysinfo *si = &cd->sysinfo;
|
|
int rc = 0;
|
|
u8 status;
|
|
u16 calculated_crc = 0;
|
|
u16 stored_crc = 0;
|
|
|
|
rc = pt_pip_suspend_scanning_(cd);
|
|
if (rc)
|
|
goto error;
|
|
|
|
rc = pt_pip_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:
|
|
pt_pip_resume_scanning_(cd);
|
|
error:
|
|
pt_debug(cd->dev, DL_INFO,
|
|
"%s: CRC: ebid:%d, calc:0x%04X, stored:0x%04X, rc=%d\n",
|
|
__func__, ebid, calculated_crc, stored_crc, rc);
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_pip2_read_gpio
|
|
*
|
|
* SUMMARY: Sends a PIP2 READ_GPIO command to the DUT and stores the 32 gpio
|
|
* bits into the passed in variable
|
|
*
|
|
* NOTE: PIP2 READ_GPIO command is only supported in bootloader
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* *status - pointer to where the command response status is stored
|
|
* *gpio - pointer to device attributes structure
|
|
******************************************************************************/
|
|
static int pt_pip2_read_gpio(struct device *dev, u8 *status, u32 *gpio)
|
|
{
|
|
int rc = 0;
|
|
u16 actual_read_len;
|
|
u8 read_buf[12];
|
|
u8 tmp_status = 0;
|
|
u8 index = PIP2_RESP_STATUS_OFFSET;
|
|
|
|
memset(read_buf, 0, ARRAY_SIZE(read_buf));
|
|
rc = _pt_request_pip2_send_cmd(dev,
|
|
PT_CORE_CMD_UNPROTECTED, PIP2_CMD_ID_READ_GPIO,
|
|
NULL, 0, read_buf, &actual_read_len);
|
|
|
|
if (rc) {
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s: Failed to send PIP2 READ_GPIO cmd\n", __func__);
|
|
rc = -ECOMM;
|
|
} else {
|
|
tmp_status = read_buf[index];
|
|
}
|
|
|
|
if (status)
|
|
*status = tmp_status;
|
|
|
|
if (!rc && gpio && (tmp_status == 0)) {
|
|
*gpio = ((read_buf[index + 4] << 24) |
|
|
(read_buf[index + 3] << 16) |
|
|
(read_buf[index + 2] << 8) |
|
|
(read_buf[index + 1]));
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_pip2_get_panel_id_by_gpio
|
|
*
|
|
* SUMMARY: Wrapper function to call pt_pip2_read_gpio() to get panel ID
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer the core data structure
|
|
* *pid - pointer to store panel ID
|
|
******************************************************************************/
|
|
static int _pt_pip2_get_panel_id_by_gpio(struct pt_core_data *cd, u8 *pid)
|
|
{
|
|
u32 gpio_value = 0;
|
|
u8 status = 0;
|
|
u8 panel_id = PANEL_ID_NOT_ENABLED;
|
|
int rc = 0;
|
|
|
|
if (!pid)
|
|
return -ENOMEM;
|
|
|
|
rc = pt_pip2_read_gpio(cd->dev, &status, &gpio_value);
|
|
if (!rc) {
|
|
if (status == 0) {
|
|
panel_id = (gpio_value & PT_PANEL_ID_BITMASK) >>
|
|
PT_PANEL_ID_SHIFT;
|
|
pt_debug(cd->dev, DL_INFO, "%s: %s=0x%02X %s=0x%08X\n",
|
|
__func__,
|
|
"BL mode PID", panel_id, "gpio", gpio_value);
|
|
*pid = panel_id;
|
|
} else {
|
|
pt_debug(cd->dev, DL_ERROR, "%s: %s=%d\n",
|
|
__func__,
|
|
"BL read gpio failed status", status);
|
|
}
|
|
} else {
|
|
pt_debug(cd->dev, DL_ERROR, "%s: %s=%d\n",
|
|
__func__,
|
|
"BL read gpio failed status", status);
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_enum_with_dut_
|
|
*
|
|
* SUMMARY: This function does the full enumeration of the DUT with TTDL.
|
|
* The core data (cd) startup_status will store, as a bitmask, each
|
|
* state of the enumeration process. The startup will be attempted
|
|
* PT_CORE_STARTUP_RETRY_COUNT times before giving up.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer the core data structure
|
|
* reset - Flag to reset the DUT before attempting to enumerate
|
|
* *status - poionter to store the enum status bitmask flags
|
|
******************************************************************************/
|
|
static int pt_enum_with_dut_(struct pt_core_data *cd, bool reset,
|
|
u32 *enum_status)
|
|
{
|
|
int try = 1;
|
|
int rc = 0;
|
|
int wait_time = 0;
|
|
bool detected = false;
|
|
u8 return_data[8];
|
|
u8 mode = PT_MODE_UNKNOWN;
|
|
u8 pid = PANEL_ID_NOT_ENABLED;
|
|
u8 sys_mode = FW_SYS_MODE_UNDEFINED;
|
|
struct pt_hid_desc hid_desc;
|
|
|
|
memset(&hid_desc, 0, sizeof(hid_desc));
|
|
#ifdef TTHE_TUNER_SUPPORT
|
|
tthe_print(cd, NULL, 0, "enter startup");
|
|
#endif
|
|
pt_debug(cd->dev, DL_INFO, "%s: Start enum... 0x%04X, reset=%d\n",
|
|
__func__, cd->startup_status, reset);
|
|
pt_stop_wd_timer(cd);
|
|
|
|
reset:
|
|
if (try > 1)
|
|
pt_debug(cd->dev, DL_WARN, "%s: DUT Enum Attempt %d\n",
|
|
__func__, try);
|
|
pt_flush_bus_if_irq_asserted(cd, PT_FLUSH_BUS_BASED_ON_LEN);
|
|
|
|
if (cd->active_dut_generation == DUT_PIP1_ONLY) {
|
|
pt_debug(cd->dev, DL_INFO,
|
|
"%s: PIP1 Enumeration start\n", __func__);
|
|
|
|
/* Only reset the DUT after the first try */
|
|
if (reset || (try > 1)) {
|
|
/*
|
|
* Reset hardware only for Legacy parts. Skip for TT/TC
|
|
* parts because if the FW image was loaded directly
|
|
* to SRAM issueing a reset ill wipe out what was just
|
|
* loaded.
|
|
*/
|
|
rc = pt_dut_reset_and_wait(cd);
|
|
if (rc < 0) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: Error on h/w reset r=%d\n",
|
|
__func__, rc);
|
|
if (try++ < PT_CORE_STARTUP_RETRY_COUNT)
|
|
goto reset;
|
|
goto exit;
|
|
}
|
|
/* sleep to allow FW to be launched if available */
|
|
msleep(120);
|
|
}
|
|
|
|
rc = pt_get_hid_descriptor_(cd, &hid_desc);
|
|
if (rc < 0) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: Error getting HID Descriptor r=%d\n",
|
|
__func__, rc);
|
|
if (try++ < PT_CORE_STARTUP_RETRY_COUNT)
|
|
goto reset;
|
|
rc = -EIO;
|
|
goto exit;
|
|
}
|
|
detected = true;
|
|
cd->mode = pt_get_mode(cd, &hid_desc);
|
|
|
|
/*
|
|
* Most systems do not use an XY pin as the panel_id and so
|
|
* the BL is used to retrieve the panel_id, however for
|
|
* systems that do use an XY pin, the panel_id MUST be
|
|
* retrieved from the system information when running FW
|
|
* (done below) and so this section of code is skipped.
|
|
* Entering the BL here is only needed on XY_PIN systems.
|
|
*/
|
|
if (cd->panel_id_support & PT_PANEL_ID_BY_BL) {
|
|
if (cd->mode == PT_MODE_OPERATIONAL) {
|
|
rc = pt_pip_start_bootloader_(cd);
|
|
if (rc < 0) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: Error on start bootloader r=%d\n",
|
|
__func__, rc);
|
|
if (try++ < PT_CORE_STARTUP_RETRY_COUNT)
|
|
goto reset;
|
|
goto exit;
|
|
}
|
|
cd->mode = PT_MODE_BOOTLOADER;
|
|
pt_debug(cd->dev, DL_INFO, "%s: Bootloader mode\n",
|
|
__func__);
|
|
}
|
|
|
|
rc = pt_hid_output_bl_get_information_(cd, return_data);
|
|
if (!rc) {
|
|
cd->bl_info.ready = true;
|
|
cd->bl_info.chip_id =
|
|
get_unaligned_le16(&return_data[2]);
|
|
pt_debug(cd->dev, DL_INFO, "%s: chip ID %04X\n",
|
|
__func__, cd->bl_info.chip_id);
|
|
} else {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: failed to get chip ID, r=%d\n",
|
|
__func__, rc);
|
|
}
|
|
|
|
rc = pt_hid_output_bl_get_panel_id_(cd, &pid);
|
|
mutex_lock(&cd->system_lock);
|
|
if (!rc) {
|
|
cd->pid_for_loader = pid;
|
|
pt_debug(cd->dev, DL_INFO, "%s: Panel ID: 0x%02X\n",
|
|
__func__, cd->pid_for_loader);
|
|
} else {
|
|
cd->pid_for_loader = PANEL_ID_NOT_ENABLED;
|
|
pt_debug(cd->dev, DL_WARN,
|
|
"%s: Read Failed, disable Panel ID: 0x%02X\n",
|
|
__func__, cd->pid_for_loader);
|
|
}
|
|
mutex_unlock(&cd->system_lock);
|
|
}
|
|
|
|
|
|
/* Exit BL due to XY_PIN case or any other cause to be in BL */
|
|
if (cd->mode == PT_MODE_BOOTLOADER) {
|
|
rc = pt_hid_output_bl_launch_app_(cd);
|
|
if (rc < 0) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: Error on launch app r=%d\n",
|
|
__func__, rc);
|
|
if (try++ < PT_CORE_STARTUP_RETRY_COUNT)
|
|
goto reset;
|
|
rc = -ENODEV;
|
|
goto exit;
|
|
}
|
|
|
|
/* sleep to allow FW to be launched if available */
|
|
msleep(120);
|
|
|
|
/* Ensure the DUT is now in Application mode */
|
|
rc = pt_get_hid_descriptor_(cd, &hid_desc);
|
|
if (rc < 0) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: Error getting HID Desc r=%d\n",
|
|
__func__, rc);
|
|
if (try++ < PT_CORE_STARTUP_RETRY_COUNT)
|
|
goto reset;
|
|
rc = -EIO;
|
|
goto exit;
|
|
}
|
|
cd->mode = pt_get_mode(cd, &hid_desc);
|
|
if (cd->mode == PT_MODE_BOOTLOADER) {
|
|
pt_debug(cd->dev, DL_WARN,
|
|
"%s: Error confiming exit BL\n",
|
|
__func__);
|
|
if (try++ < PT_CORE_STARTUP_RETRY_COUNT)
|
|
goto reset;
|
|
rc = -ENODEV;
|
|
goto exit;
|
|
}
|
|
}
|
|
pt_debug(cd->dev, DL_INFO, "%s: Operational mode\n", __func__);
|
|
cd->mode = PT_MODE_OPERATIONAL;
|
|
*enum_status |= STARTUP_STATUS_GET_DESC;
|
|
*enum_status |= STARTUP_STATUS_FW_OUT_OF_BOOT;
|
|
} else {
|
|
/* Generation is PIP2 Capable */
|
|
pt_debug(cd->dev, DL_INFO,
|
|
"%s: PIP2 Enumeration start\n", __func__);
|
|
rc = pt_pip2_get_mode_sysmode_(cd, &mode, NULL);
|
|
if (rc) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: Get mode failed, mode unknown\n",
|
|
__func__);
|
|
mode = PT_MODE_UNKNOWN;
|
|
} else
|
|
detected = true;
|
|
|
|
cd->mode = mode;
|
|
|
|
switch (cd->mode) {
|
|
case PT_MODE_OPERATIONAL:
|
|
pt_debug(cd->dev, DL_INFO,
|
|
"%s: Operational mode\n", __func__);
|
|
if (cd->app_pip_ver_ready == false) {
|
|
rc = pt_pip2_get_version_(cd);
|
|
if (!rc)
|
|
cd->app_pip_ver_ready = true;
|
|
else {
|
|
if (try++ < PT_CORE_STARTUP_RETRY_COUNT)
|
|
goto reset;
|
|
goto exit;
|
|
}
|
|
}
|
|
break;
|
|
case PT_MODE_BOOTLOADER:
|
|
pt_debug(cd->dev, DL_INFO,
|
|
"%s: Bootloader mode\n", __func__);
|
|
if (cd->panel_id_support & PT_PANEL_ID_BY_BL) {
|
|
rc = _pt_pip2_get_panel_id_by_gpio(cd, &pid);
|
|
mutex_lock(&cd->system_lock);
|
|
if (!rc) {
|
|
cd->pid_for_loader = pid;
|
|
pt_debug(cd->dev, DL_INFO,
|
|
"%s: Panel ID: 0x%02X\n",
|
|
__func__, cd->pid_for_loader);
|
|
} else {
|
|
cd->pid_for_loader =
|
|
PANEL_ID_NOT_ENABLED;
|
|
pt_debug(cd->dev, DL_WARN,
|
|
"%s: Read Failed, disable Panel ID: 0x%02X\n",
|
|
__func__, cd->pid_for_loader);
|
|
}
|
|
mutex_unlock(&cd->system_lock);
|
|
}
|
|
|
|
if (cd->bl_pip_ver_ready == false) {
|
|
rc = pt_pip2_get_version_(cd);
|
|
if (!rc)
|
|
cd->bl_pip_ver_ready = true;
|
|
else {
|
|
if (try++ < PT_CORE_STARTUP_RETRY_COUNT)
|
|
goto reset;
|
|
goto exit;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Launch app command will fail in flashless mode.
|
|
* Skip launch app command here to save time for
|
|
* enumeration flow.
|
|
*/
|
|
if (cd->flashless_dut)
|
|
goto exit;
|
|
|
|
/*
|
|
* pt_pip2_launch_app() is needed here instead of
|
|
* pt_pip2_exit_bl() because exit_bl will cause several
|
|
* hw_resets to occur and the auto BL on a flashless
|
|
* DUT will fail.
|
|
*/
|
|
rc = pt_pip2_launch_app(cd->dev,
|
|
PT_CORE_CMD_UNPROTECTED);
|
|
if (rc) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: Error on launch app r=%d\n",
|
|
__func__, rc);
|
|
msleep(50);
|
|
if (try++ < PT_CORE_STARTUP_RETRY_COUNT)
|
|
goto reset;
|
|
goto exit;
|
|
}
|
|
|
|
/*
|
|
* IRQ thread can be delayed if the serial log print is
|
|
* enabled. It causes next command to get wrong response
|
|
* Here the delay is to ensure pt_parse_input() to be
|
|
* finished.
|
|
*/
|
|
msleep(60);
|
|
/* Check and update the mode */
|
|
rc = pt_pip2_get_mode_sysmode_(cd, &mode, NULL);
|
|
if (rc) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: Get mode failed, mode unknown\n",
|
|
__func__);
|
|
mode = PT_MODE_UNKNOWN;
|
|
}
|
|
cd->mode = mode;
|
|
if (cd->mode == PT_MODE_OPERATIONAL) {
|
|
pt_debug(cd->dev, DL_INFO,
|
|
"%s: Launched to Operational mode\n",
|
|
__func__);
|
|
} else if (cd->mode == PT_MODE_BOOTLOADER) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: Launch failed, Bootloader mode\n",
|
|
__func__);
|
|
goto exit;
|
|
} else if (cd->mode == PT_MODE_UNKNOWN) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: Launch failed, Unknown mode\n",
|
|
__func__);
|
|
if (try++ < PT_CORE_STARTUP_RETRY_COUNT)
|
|
goto reset;
|
|
goto exit;
|
|
}
|
|
|
|
if (cd->app_pip_ver_ready == false) {
|
|
rc = pt_pip2_get_version_(cd);
|
|
if (!rc)
|
|
cd->app_pip_ver_ready = true;
|
|
else {
|
|
if (try++ < PT_CORE_STARTUP_RETRY_COUNT)
|
|
goto reset;
|
|
goto exit;
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: Unknown mode\n", __func__);
|
|
if (try++ < PT_CORE_STARTUP_RETRY_COUNT)
|
|
goto reset;
|
|
goto exit;
|
|
}
|
|
*enum_status |= STARTUP_STATUS_GET_DESC;
|
|
}
|
|
|
|
pt_init_pip_report_fields(cd);
|
|
*enum_status |= STARTUP_STATUS_GET_RPT_DESC;
|
|
if (!cd->features.easywake)
|
|
cd->easy_wakeup_gesture = PT_CORE_EWG_NONE;
|
|
|
|
pt_debug(cd->dev, DL_INFO, "%s: Reading sysinfo\n", __func__);
|
|
rc = pt_hid_output_get_sysinfo_(cd);
|
|
if (rc) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: Error on getting sysinfo r=%d\n", __func__, rc);
|
|
if (try++ < PT_CORE_STARTUP_RETRY_COUNT)
|
|
goto reset;
|
|
goto exit;
|
|
}
|
|
*enum_status |= STARTUP_STATUS_GET_SYS_INFO;
|
|
|
|
/* FW cannot handle most PIP cmds when it is still in BOOT mode */
|
|
rc = _pt_poll_for_fw_exit_boot_mode(cd, 10000, &wait_time);
|
|
if (!rc) {
|
|
*enum_status |= STARTUP_STATUS_FW_OUT_OF_BOOT;
|
|
pt_debug(cd->dev, DL_WARN,
|
|
"%s: Exit FW BOOT Mode after %dms\n",
|
|
__func__, wait_time);
|
|
} else {
|
|
pt_debug(cd->dev, DL_WARN,
|
|
"%s: FW stuck in BOOT Mode after %dms\n",
|
|
__func__, wait_time);
|
|
goto exit;
|
|
}
|
|
|
|
pt_debug(cd->dev, DL_INFO, "%s pt Prot Version: %d.%d\n",
|
|
__func__,
|
|
cd->sysinfo.ttdata.pip_ver_major,
|
|
cd->sysinfo.ttdata.pip_ver_minor);
|
|
|
|
rc = pt_get_ic_crc_(cd, PT_TCH_PARM_EBID);
|
|
if (rc) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: DUT Config block CRC failure rc=%d\n",
|
|
__func__, rc);
|
|
if (try++ < PT_CORE_STARTUP_RETRY_COUNT)
|
|
goto reset;
|
|
} else {
|
|
_pt_get_fw_sys_mode(cd, &sys_mode, NULL);
|
|
if (sys_mode != FW_SYS_MODE_SCANNING) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: scan state: %d, retry: %d\n",
|
|
__func__, sys_mode, try);
|
|
if (try++ < PT_CORE_STARTUP_RETRY_COUNT)
|
|
goto reset;
|
|
} else
|
|
*enum_status |= STARTUP_STATUS_GET_CFG_CRC;
|
|
}
|
|
|
|
rc = pt_restore_parameters_(cd);
|
|
if (rc) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: Failed to restore parameters rc=%d\n",
|
|
__func__, rc);
|
|
} else
|
|
*enum_status |= STARTUP_STATUS_RESTORE_PARM;
|
|
|
|
call_atten_cb(cd, PT_ATTEN_STARTUP, 0);
|
|
cd->watchdog_interval = PT_WATCHDOG_TIMEOUT;
|
|
cd->startup_retry_count = 0;
|
|
|
|
exit:
|
|
/* Generate the HW Version of the connected DUT and store in cd */
|
|
pt_generate_hw_version(cd, cd->hw_version);
|
|
pt_debug(cd->dev, DL_WARN, "%s: HW Version: %s\n", __func__,
|
|
cd->hw_version);
|
|
|
|
pt_start_wd_timer(cd);
|
|
|
|
if (!detected)
|
|
rc = -ENODEV;
|
|
|
|
#ifdef TTHE_TUNER_SUPPORT
|
|
tthe_print(cd, NULL, 0, "exit startup");
|
|
#endif
|
|
|
|
pt_debug(cd->dev, DL_WARN,
|
|
"%s: Completed Enumeration rc=%d On Attempt %d\n",
|
|
__func__, rc, try);
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_enum_with_dut
|
|
*
|
|
* SUMMARY: This is the safe function wrapper for pt_enum_with_dut_() by
|
|
* requesting exclusive access around the call.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer the core data structure
|
|
* reset - Flag to reset the DUT before attempting to enumerate
|
|
* *status - pointer to store the enum status bitmask flags
|
|
******************************************************************************/
|
|
static int pt_enum_with_dut(struct pt_core_data *cd, bool reset, u32 *status)
|
|
{
|
|
int rc = 0;
|
|
|
|
mutex_lock(&cd->system_lock);
|
|
cd->startup_state = STARTUP_RUNNING;
|
|
mutex_unlock(&cd->system_lock);
|
|
|
|
rc = request_exclusive(cd, cd->dev, PT_REQUEST_EXCLUSIVE_TIMEOUT);
|
|
if (rc) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail get exclusive ex=%p own=%p\n",
|
|
__func__, cd->exclusive_dev, cd->dev);
|
|
goto exit;
|
|
}
|
|
|
|
rc = pt_enum_with_dut_(cd, reset, status);
|
|
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
|
/* Don't return fail code, mode is already changed. */
|
|
pt_debug(cd->dev, DL_ERROR, "%s: fail to release exclusive\n",
|
|
__func__);
|
|
else
|
|
pt_debug(cd->dev, DL_DEBUG, "%s: pass release exclusive\n",
|
|
__func__);
|
|
|
|
exit:
|
|
mutex_lock(&cd->system_lock);
|
|
/* Clear startup state for any tasks waiting for startup completion */
|
|
cd->startup_state = STARTUP_NONE;
|
|
mutex_unlock(&cd->system_lock);
|
|
|
|
/* Set STATUS_COMPLETE bit to indicate the status is ready to be read */
|
|
*status |= STARTUP_STATUS_COMPLETE;
|
|
|
|
/* Wake the waiters for end of startup */
|
|
wake_up(&cd->wait_q);
|
|
|
|
return rc;
|
|
}
|
|
|
|
static int add_sysfs_interfaces(struct device *dev);
|
|
static void remove_sysfs_interfaces(struct device *dev);
|
|
static void remove_sysfs_and_modules(struct device *dev);
|
|
static void pt_release_modules(struct pt_core_data *cd);
|
|
static void pt_probe_modules(struct pt_core_data *cd);
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_ttdl_restart
|
|
*
|
|
* SUMMARY: Restarts TTDL enumeration with the DUT and re-probes all modules
|
|
*
|
|
* NOTE: The function DOSE NOT remove sysfs and modulues. Trying to create
|
|
* existing sysfs nodes will produce an error.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to core device
|
|
******************************************************************************/
|
|
static int _pt_ttdl_restart(struct device *dev)
|
|
{
|
|
int rc = 0;
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
#ifdef CONFIG_TOUCHSCREEN_PARADE_I2C
|
|
struct i2c_client *client =
|
|
(struct i2c_client *)container_of(dev, struct i2c_client, dev);
|
|
#endif
|
|
|
|
/*
|
|
* Make sure the device is awake, pt_mt_release function will
|
|
* cause pm sleep function and lead to deadlock.
|
|
*/
|
|
pm_runtime_get_sync(dev);
|
|
/* Use ttdl_restart_lock to avoid reentry */
|
|
mutex_lock(&cd->ttdl_restart_lock);
|
|
|
|
remove_sysfs_and_modules(cd->dev);
|
|
|
|
#ifdef CONFIG_TOUCHSCREEN_PARADE_I2C
|
|
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s I2C functionality not Supported\n", __func__);
|
|
rc = -EIO;
|
|
goto ttdl_no_error;
|
|
}
|
|
#endif
|
|
|
|
if (cd->active_dut_generation == DUT_UNKNOWN) {
|
|
rc = _pt_detect_dut_generation(cd->dev,
|
|
&cd->startup_status, &cd->active_dut_generation,
|
|
&cd->mode);
|
|
if ((cd->active_dut_generation == DUT_UNKNOWN) || (rc)) {
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s: Error, Unknown DUT Generation rc=%d\n",
|
|
__func__, rc);
|
|
}
|
|
}
|
|
|
|
rc = add_sysfs_interfaces(cd->dev);
|
|
if (rc < 0)
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: Error, failed sysfs nodes rc=%d\n",
|
|
__func__, rc);
|
|
|
|
if (!(cd->startup_status & STARTUP_STATUS_BL_RESET_SENTINEL)) {
|
|
pt_debug(dev, DL_INFO, "%s: Call pt_enum_with_dut\n", __func__);
|
|
rc = pt_enum_with_dut(cd, true, &cd->startup_status);
|
|
if (rc < 0)
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s: Error, Failed to Enumerate\n", __func__);
|
|
}
|
|
|
|
rc = pt_mt_probe(dev);
|
|
if (rc < 0) {
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s: Error, fail mt probe\n", __func__);
|
|
}
|
|
|
|
rc = pt_btn_probe(dev);
|
|
if (rc < 0) {
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s: Error, fail btn probe\n", __func__);
|
|
}
|
|
|
|
pt_probe_modules(cd);
|
|
|
|
pt_debug(cd->dev, DL_WARN,
|
|
"%s: Well Done! TTDL Restart Completed\n", __func__);
|
|
rc = 0;
|
|
|
|
#ifdef CONFIG_TOUCHSCREEN_PARADE_I2C
|
|
ttdl_no_error:
|
|
#endif
|
|
mutex_unlock(&cd->ttdl_restart_lock);
|
|
|
|
mutex_lock(&cd->system_lock);
|
|
cd->startup_status |= STARTUP_STATUS_COMPLETE;
|
|
cd->startup_state = STARTUP_NONE;
|
|
mutex_unlock(&cd->system_lock);
|
|
|
|
pm_runtime_put(dev);
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_restart_work_function
|
|
*
|
|
* SUMMARY: This is the wrapper function placed in a work queue to call
|
|
* _pt_ttdl_restart()
|
|
*
|
|
* RETURN: none
|
|
*
|
|
* PARAMETERS:
|
|
* *work - pointer to the work_struct
|
|
******************************************************************************/
|
|
static void pt_restart_work_function(struct work_struct *work)
|
|
{
|
|
struct pt_core_data *cd = container_of(work,
|
|
struct pt_core_data, ttdl_restart_work);
|
|
int rc = 0;
|
|
|
|
rc = _pt_ttdl_restart(cd->dev);
|
|
if (rc < 0)
|
|
pt_debug(cd->dev, DL_ERROR, "%s: Fail queued startup r=%d\n",
|
|
__func__, rc);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_enum_work_function
|
|
*
|
|
* SUMMARY: This is the wrapper function placed in a work queue to call
|
|
* pt_enum_with_dut()
|
|
*
|
|
* RETURN: none
|
|
*
|
|
* PARAMETERS:
|
|
* *work - pointer to the work_struct
|
|
******************************************************************************/
|
|
static void pt_enum_work_function(struct work_struct *work)
|
|
{
|
|
struct pt_core_data *cd = container_of(work,
|
|
struct pt_core_data, enum_work);
|
|
int rc;
|
|
|
|
rc = pt_enum_with_dut(cd, false, &cd->startup_status);
|
|
if (rc < 0)
|
|
pt_debug(cd->dev, DL_ERROR, "%s: Fail queued startup r=%d\n",
|
|
__func__, rc);
|
|
}
|
|
|
|
#if (KERNEL_VERSION(3, 19, 0) <= LINUX_VERSION_CODE)
|
|
#define KERNEL_VER_GT_3_19
|
|
#endif
|
|
|
|
#if defined(CONFIG_PM_RUNTIME) || defined(KERNEL_VER_GT_3_19)
|
|
/* CONFIG_PM_RUNTIME option is removed in 3.19.0 */
|
|
#if defined(CONFIG_PM_SLEEP)
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_core_rt_suspend
|
|
*
|
|
* SUMMARY: Wrapper function with PM Runtime stratergy to call pt_core_sleep.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to core device
|
|
******************************************************************************/
|
|
static int pt_core_rt_suspend(struct device *dev)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
int rc = 0;
|
|
|
|
if (cd->cpdata->flags & PT_CORE_FLAG_SKIP_RUNTIME)
|
|
return 0;
|
|
|
|
rc = pt_core_sleep(cd);
|
|
if (rc < 0) {
|
|
pt_debug(dev, DL_ERROR, "%s: Error on sleep\n", __func__);
|
|
return -EAGAIN;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_core_rt_resume
|
|
*
|
|
* SUMMARY: Wrapper function with PM Runtime stratergy to call pt_core_wake.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to core device
|
|
******************************************************************************/
|
|
static int pt_core_rt_resume(struct device *dev)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
int rc = 0;
|
|
|
|
if (cd->cpdata->flags & PT_CORE_FLAG_SKIP_RUNTIME)
|
|
return 0;
|
|
|
|
rc = pt_core_wake(cd);
|
|
if (rc < 0) {
|
|
pt_debug(dev, DL_ERROR, "%s: Error on wake\n", __func__);
|
|
return -EAGAIN;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
#endif /* CONFIG_PM_SLEEP */
|
|
#endif /* CONFIG_PM_RUNTIME || LINUX_VERSION_CODE */
|
|
|
|
#if defined(CONFIG_PM_SLEEP)
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_core_suspend_
|
|
*
|
|
* SUMMARY: Wrapper function with device suspend/resume stratergy to call
|
|
* pt_core_sleep. This function may disable IRQ during sleep state.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to core device
|
|
******************************************************************************/
|
|
static int pt_core_suspend_(struct device *dev)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
|
|
pt_core_sleep(cd);
|
|
|
|
if (!IS_EASY_WAKE_CONFIGURED(cd->easy_wakeup_gesture))
|
|
return 0;
|
|
|
|
/* Required to prevent interrupts before bus awake */
|
|
disable_irq(cd->irq);
|
|
cd->irq_disabled = 1;
|
|
|
|
if (device_may_wakeup(dev)) {
|
|
pt_debug(dev, DL_WARN, "%s Device MAY wakeup\n",
|
|
__func__);
|
|
if (!enable_irq_wake(cd->irq))
|
|
cd->irq_wake = 1;
|
|
} else {
|
|
pt_debug(dev, DL_WARN, "%s Device MAY NOT wakeup\n",
|
|
__func__);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_core_suspend
|
|
*
|
|
* SUMMARY: Wrapper function of pt_core_suspend_() to help avoid TP from being
|
|
* woke up or put to sleep based on Kernel power state even when the display
|
|
* is off based on the check of TTDL core platform flag.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to core device
|
|
******************************************************************************/
|
|
static int pt_core_suspend(struct device *dev)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
|
|
if (cd->cpdata->flags & PT_CORE_FLAG_SKIP_SYS_SLEEP)
|
|
return 0;
|
|
|
|
return pt_core_suspend_(dev);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_core_resume_
|
|
*
|
|
* SUMMARY: Wrapper function with device suspend/resume stratergy to call
|
|
* pt_core_wake. This function may enable IRQ before wake up.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to core device
|
|
******************************************************************************/
|
|
static int pt_core_resume_(struct device *dev)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
|
|
if (!IS_EASY_WAKE_CONFIGURED(cd->easy_wakeup_gesture))
|
|
goto exit;
|
|
|
|
/*
|
|
* Bus pm does not call suspend if device runtime suspended
|
|
* This flag is covers that case
|
|
*/
|
|
if (cd->irq_disabled) {
|
|
enable_irq(cd->irq);
|
|
cd->irq_disabled = 0;
|
|
}
|
|
|
|
if (device_may_wakeup(dev)) {
|
|
pt_debug(dev, DL_WARN, "%s Device MAY wakeup\n",
|
|
__func__);
|
|
if (cd->irq_wake) {
|
|
disable_irq_wake(cd->irq);
|
|
cd->irq_wake = 0;
|
|
}
|
|
} else {
|
|
pt_debug(dev, DL_WARN, "%s Device MAY NOT wakeup\n",
|
|
__func__);
|
|
}
|
|
|
|
exit:
|
|
pt_core_wake(cd);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_core_resume
|
|
*
|
|
* SUMMARY: Wrapper function of pt_core_resume_() to avoid TP to be waken/slept
|
|
* along with kernel power state even the display is off based on the check of
|
|
* TTDL core platform flag.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to core device
|
|
******************************************************************************/
|
|
static int pt_core_resume(struct device *dev)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
|
|
if (cd->cpdata->flags & PT_CORE_FLAG_SKIP_SYS_SLEEP)
|
|
return 0;
|
|
|
|
return pt_core_resume_(dev);
|
|
}
|
|
#endif
|
|
|
|
#ifdef NEED_SUSPEND_NOTIFIER
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_pm_notifier
|
|
*
|
|
* SUMMARY: This function is registered to notifier chain and will perform
|
|
* suspend operation if match event PM_SUSPEND_PREPARE.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *nb - pointer to notifier_block structure
|
|
* action - notifier event type
|
|
* *data - void pointer
|
|
******************************************************************************/
|
|
static int pt_pm_notifier(struct notifier_block *nb,
|
|
unsigned long action, void *data)
|
|
{
|
|
struct pt_core_data *cd = container_of(nb,
|
|
struct pt_core_data, pm_notifier);
|
|
|
|
if (action == PM_SUSPEND_PREPARE) {
|
|
pt_debug(cd->dev, DL_INFO, "%s: Suspend prepare\n",
|
|
__func__);
|
|
|
|
/*
|
|
* If PM runtime is not suspended, either call runtime
|
|
* PM suspend callback or wait until it finishes
|
|
*/
|
|
if (!pm_runtime_suspended(cd->dev))
|
|
pm_runtime_suspend(cd->dev);
|
|
|
|
(void) pt_core_suspend(cd->dev);
|
|
}
|
|
|
|
return NOTIFY_DONE;
|
|
}
|
|
#endif
|
|
|
|
const struct dev_pm_ops pt_pm_ops = {
|
|
SET_SYSTEM_SLEEP_PM_OPS(pt_core_suspend, pt_core_resume)
|
|
SET_RUNTIME_PM_OPS(pt_core_rt_suspend, pt_core_rt_resume,
|
|
NULL)
|
|
};
|
|
EXPORT_SYMBOL_GPL(pt_pm_ops);
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_request_pip2_enter_bl
|
|
*
|
|
* SUMMARY: Force the DUT to enter the BL by resetting the DUT by use of the
|
|
* XRES pin or a soft reset.
|
|
*
|
|
* NOTE: The WD MUST be stopped/restarted by the calling Function. Having
|
|
* the WD active could cause this function to fail!
|
|
* NOTE: If start_mode is passed in as PT_MODE_IGNORE, this function
|
|
* will not try to determine the current mode but will proceed with
|
|
* resetting the DUT and entering the BL.
|
|
*
|
|
* NOTE: The definition of result code:
|
|
* PT_ENTER_BL_PASS (0)
|
|
* PT_ENTER_BL_ERROR (1)
|
|
* PT_ENTER_BL_RESET_FAIL (2)
|
|
* PT_ENTER_BL_HID_START_BL_FAIL (3)
|
|
* PT_ENTER_BL_CONFIRM_FAIL (4)
|
|
* PT_ENTER_BL_GET_FLASH_INFO_FAIL (5)
|
|
*
|
|
* RETURNS:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* *start_mode - pointer to the mode the DUT was in when this function
|
|
* starts
|
|
* *result - pointer to store the result when to enter BL
|
|
******************************************************************************/
|
|
int _pt_request_pip2_enter_bl(struct device *dev, u8 *start_mode, int *result)
|
|
{
|
|
int rc = 0;
|
|
int t;
|
|
int tmp_result = PT_ENTER_BL_ERROR;
|
|
int flash_info_retry = 2;
|
|
u8 mode = PT_MODE_UNKNOWN;
|
|
u8 sys_mode = FW_SYS_MODE_UNDEFINED;
|
|
u8 read_buf[32];
|
|
u16 actual_read_len;
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
u8 host_mode_cmd[4] = {0xA5, 0xA5, 0xA5, 0xA5};
|
|
u8 time = 0;
|
|
u8 saved_flashless_auto_bl_mode = cd->flashless_auto_bl;
|
|
|
|
if (cd->watchdog_enabled) {
|
|
pt_debug(dev, DL_WARN,
|
|
"%s: Watchdog must be stopped before entering BL\n",
|
|
__func__);
|
|
goto exit;
|
|
}
|
|
|
|
cancel_work_sync(&cd->enum_work);
|
|
cancel_work_sync(&cd->watchdog_work);
|
|
|
|
/* if undefined assume operational/test to bypass all checks */
|
|
if (*start_mode == PT_MODE_IGNORE) {
|
|
mode = PT_MODE_OPERATIONAL;
|
|
sys_mode = FW_SYS_MODE_TEST;
|
|
pt_debug(dev, DL_INFO, "%s: Assume Mode = %d", __func__, mode);
|
|
} else if (*start_mode == PT_MODE_UNKNOWN) {
|
|
rc = pt_pip2_get_mode_sysmode_(cd, &mode, &sys_mode);
|
|
if (rc) {
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s: Get mode failed, mode unknown\n",
|
|
__func__);
|
|
}
|
|
*start_mode = mode;
|
|
pt_debug(dev, DL_INFO, "%s: Get Mode = %d", __func__, mode);
|
|
} else if (*start_mode == PT_MODE_OPERATIONAL) {
|
|
/* Assume SCANNIING mode to avoid doing an extra get_mode */
|
|
sys_mode = FW_SYS_MODE_SCANNING;
|
|
}
|
|
|
|
_retry:
|
|
/* For Flashless DUTs - Supress auto BL on next BL sentinel */
|
|
pt_debug(dev, DL_INFO, "%s: Flashless Auto_BL - SUPPRESS\n", __func__);
|
|
cd->flashless_auto_bl = PT_SUPPRESS_AUTO_BL;
|
|
|
|
switch (mode) {
|
|
case PT_MODE_UNKNOWN:
|
|
/*
|
|
* When the mode could not be determined the DUT could be
|
|
* in App mode running corrupted FW or FW that is not
|
|
* responding to the mode request, assume no communication
|
|
* and do a hard reset
|
|
*/
|
|
mutex_lock(&cd->system_lock);
|
|
cd->startup_status = STARTUP_STATUS_START;
|
|
pt_debug(dev, DL_DEBUG, "%s: Startup Status Reset\n", __func__);
|
|
mutex_unlock(&cd->system_lock);
|
|
|
|
rc = pt_dut_reset(cd, PT_CORE_CMD_UNPROTECTED);
|
|
if (rc) {
|
|
tmp_result = PT_ENTER_BL_RESET_FAIL;
|
|
goto exit;
|
|
}
|
|
break;
|
|
|
|
case PT_MODE_OPERATIONAL:
|
|
if (sys_mode == FW_SYS_MODE_SCANNING) {
|
|
pt_debug(dev, DL_INFO, "%s: Suspend Scanning\n",
|
|
__func__);
|
|
rc = pt_pip_suspend_scanning_(cd);
|
|
if (rc) {
|
|
/*
|
|
* Print to log but don't exit, the FW could be
|
|
* running but be hung or fail to respond to
|
|
* this request
|
|
*/
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s Suspend Scan Failed\n", __func__);
|
|
}
|
|
/* sleep to allow the suspend scan to be processed */
|
|
usleep_range(1000, 2000);
|
|
}
|
|
|
|
mutex_lock(&cd->system_lock);
|
|
cd->startup_status = STARTUP_STATUS_START;
|
|
pt_debug(dev, DL_DEBUG, "%s: Startup Status Reset\n", __func__);
|
|
mutex_unlock(&cd->system_lock);
|
|
|
|
/* Reset device to enter the BL */
|
|
rc = pt_dut_reset(cd, PT_CORE_CMD_UNPROTECTED);
|
|
if (rc) {
|
|
tmp_result = PT_ENTER_BL_RESET_FAIL;
|
|
goto exit;
|
|
}
|
|
break;
|
|
|
|
case PT_MODE_BOOTLOADER:
|
|
/* Do nothing as we are already in the BL */
|
|
tmp_result = PT_ENTER_BL_PASS;
|
|
goto exit;
|
|
|
|
default:
|
|
/* Should NEVER get here */
|
|
tmp_result = PT_ENTER_BL_ERROR;
|
|
pt_debug(dev, DL_ERROR, "%s: Unknown mode code\n", __func__);
|
|
goto exit;
|
|
}
|
|
|
|
if (!cd->flashless_dut &&
|
|
(mode == PT_MODE_UNKNOWN || mode == PT_MODE_OPERATIONAL)) {
|
|
/*
|
|
* Sending the special "Host Mode" command will instruct the
|
|
* BL to not execute the FW it has loaded into RAM.
|
|
* The command must be sent within a 40ms window from releasing
|
|
* the XRES pin. If the messages is sent too early it will NAK,
|
|
* so keep sending it every 2ms until it is accepted by the BL.
|
|
* A no-flash DUT does not require this command as there is no
|
|
* FW for the BL to load and execute.
|
|
*/
|
|
usleep_range(4000, 6000);
|
|
pt_debug(cd->dev, DL_INFO,
|
|
">>> %s: Write Buffer Size[%d] Stay in BL\n",
|
|
__func__, (int)sizeof(host_mode_cmd));
|
|
pt_pr_buf(cd->dev, DL_DEBUG, host_mode_cmd,
|
|
(int)sizeof(host_mode_cmd), ">>> User CMD");
|
|
rc = 1;
|
|
while (rc && time < 34) {
|
|
rc = pt_adap_write_read_specific(cd, 4,
|
|
host_mode_cmd, NULL);
|
|
usleep_range(1800, 2000);
|
|
time += 2;
|
|
}
|
|
|
|
/* Sleep to allow the BL to come up */
|
|
usleep_range(1000, 2000);
|
|
}
|
|
|
|
/*
|
|
* To avoid the case that next PIP command can be confused by BL/FW
|
|
* sentinel's "wakeup" event, chekcing hid_reset_cmd_state which is
|
|
* followed by "wakeup event" function can lower the failure rate.
|
|
*/
|
|
t = wait_event_timeout(cd->wait_q,
|
|
((cd->startup_status != STARTUP_STATUS_START)
|
|
&& (cd->hid_reset_cmd_state == 0)),
|
|
msecs_to_jiffies(300));
|
|
if (IS_TMO(t)) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: TMO waiting for BL sentinel\n", __func__);
|
|
}
|
|
|
|
/* Check if device is now in BL mode */
|
|
rc = pt_pip2_get_mode_sysmode_(cd, &mode, NULL);
|
|
pt_debug(dev, DL_INFO, "%s: Mode=%d, Status=0x%04X\n", __func__, mode,
|
|
cd->startup_status);
|
|
if (!rc && mode == PT_MODE_BOOTLOADER) {
|
|
pt_debug(dev, DL_INFO, "%s In bootloader mode now\n", __func__);
|
|
mutex_lock(&cd->system_lock);
|
|
cd->pip2_prot_active = true;
|
|
cd->mode = PT_MODE_BOOTLOADER;
|
|
mutex_unlock(&cd->system_lock);
|
|
tmp_result = PT_ENTER_BL_PASS;
|
|
} else {
|
|
/*
|
|
* If the device doesn't enter BL mode as expected and rc is
|
|
* tested pass by above function pt_pip2_get_mode_sysmode_(),
|
|
* the function should return an error code to indicate this
|
|
* failure PT_ENTER_BL_CONFIRM_FAIL.
|
|
*/
|
|
if (!rc)
|
|
rc = -EINVAL;
|
|
tmp_result = PT_ENTER_BL_CONFIRM_FAIL;
|
|
mutex_lock(&cd->system_lock);
|
|
cd->mode = mode;
|
|
mutex_unlock(&cd->system_lock);
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s ERROR: Not in BL as expected", __func__);
|
|
}
|
|
|
|
exit:
|
|
if (!cd->flashless_dut && (tmp_result == PT_ENTER_BL_PASS)) {
|
|
/* Check to get (buffered) flash information */
|
|
rc = _pt_request_pip2_send_cmd(dev, PT_CORE_CMD_UNPROTECTED,
|
|
PIP2_CMD_ID_FLASH_INFO, NULL, 0,
|
|
read_buf, &actual_read_len);
|
|
if (!rc) {
|
|
if (read_buf[PIP2_RESP_BODY_OFFSET] == 0) {
|
|
pt_debug(
|
|
dev, DL_WARN,
|
|
"%s Unavailable Manufacturer ID: 0x%02x\n",
|
|
__func__,
|
|
read_buf[PIP2_RESP_BODY_OFFSET]);
|
|
/*
|
|
* If the BL was unable to cache the correct
|
|
* values when entering the first time due to
|
|
* the Flash part not having been powered up
|
|
* long enough, re-enter the BL to trigger the
|
|
* BL to re-attempt to cache the values.
|
|
*/
|
|
if (flash_info_retry-- > 0) {
|
|
mode = PT_MODE_UNKNOWN;
|
|
pt_debug(dev, DL_WARN,
|
|
"%s Assume mode to UNKNOWN to enter BL again, retry=%d\n",
|
|
__func__, flash_info_retry);
|
|
goto _retry;
|
|
} else {
|
|
pt_debug(dev, DL_WARN,
|
|
"%s Manufacturer ID Unknown\n",
|
|
__func__);
|
|
tmp_result = PT_ENTER_BL_PASS;
|
|
}
|
|
}
|
|
} else {
|
|
tmp_result = PT_ENTER_BL_GET_FLASH_INFO_FAIL;
|
|
pt_debug(
|
|
dev, DL_ERROR,
|
|
"%s: Failed to send PIP2 READ_FLASH_INFO cmd\n",
|
|
__func__);
|
|
}
|
|
}
|
|
|
|
pt_debug(dev, DL_INFO, "%s Flashless Auto_BL - %s\n", __func__,
|
|
saved_flashless_auto_bl_mode == PT_ALLOW_AUTO_BL ? "ALLOW" :
|
|
"SUPPRESS");
|
|
cd->flashless_auto_bl = saved_flashless_auto_bl_mode;
|
|
if (result)
|
|
*result = tmp_result;
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_pip2_file_open
|
|
*
|
|
* SUMMARY: Using the BL PIP2 commands open a file and return the file handle
|
|
*
|
|
* NOTE: The DUT must be in BL mode for this command to work
|
|
*
|
|
* RETURNS:
|
|
* <0 = Error
|
|
* >0 = file handle opened
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* file_no - PIP2 file number to open
|
|
******************************************************************************/
|
|
int _pt_pip2_file_open(struct device *dev, u8 file_no)
|
|
{
|
|
int ret = 0;
|
|
u16 status;
|
|
u16 actual_read_len;
|
|
u8 file_handle;
|
|
u8 data[2];
|
|
u8 read_buf[10];
|
|
|
|
pt_debug(dev, DL_DEBUG, "%s: OPEN file %d\n", __func__, file_no);
|
|
data[0] = file_no;
|
|
ret = _pt_request_pip2_send_cmd(dev,
|
|
PT_CORE_CMD_UNPROTECTED, PIP2_CMD_ID_FILE_OPEN,
|
|
data, 1, read_buf, &actual_read_len);
|
|
if (ret) {
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s ROM BL FILE_OPEN timeout for file = %d\n",
|
|
__func__, file_no);
|
|
return -PIP2_RSP_ERR_NOT_OPEN;
|
|
}
|
|
|
|
status = read_buf[PIP2_RESP_STATUS_OFFSET];
|
|
file_handle = read_buf[PIP2_RESP_BODY_OFFSET];
|
|
if (ret || ((status != 0x00) && (status != 0x03)) ||
|
|
(file_handle != file_no)) {
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s ROM BL FILE_OPEN failure: 0x%02X for file = %d\n",
|
|
__func__, status, file_handle);
|
|
return -status;
|
|
}
|
|
return file_handle;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_pip2_file_close
|
|
*
|
|
* SUMMARY: Using the BL PIP2 commands close a file
|
|
*
|
|
* NOTE: The DUT must be in BL mode for this command to work
|
|
*
|
|
* RETURNS:
|
|
* <0 = Error
|
|
* >0 = file handle closed
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* file_handle - handle to the file to be closed
|
|
******************************************************************************/
|
|
int _pt_pip2_file_close(struct device *dev, u8 file_handle)
|
|
{
|
|
int ret = 0;
|
|
u16 status;
|
|
u16 actual_read_len;
|
|
u8 data[2];
|
|
u8 read_buf[32];
|
|
|
|
pt_debug(dev, DL_DEBUG, "%s: CLOSE file %d\n", __func__, file_handle);
|
|
data[0] = file_handle;
|
|
ret = _pt_request_pip2_send_cmd(dev,
|
|
PT_CORE_CMD_UNPROTECTED, PIP2_CMD_ID_FILE_CLOSE,
|
|
data, 1, read_buf, &actual_read_len);
|
|
if (ret) {
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s ROM BL FILE_CLOSE timeout for file = %d\n",
|
|
__func__, file_handle);
|
|
return -ETIME;
|
|
}
|
|
|
|
status = read_buf[PIP2_RESP_STATUS_OFFSET];
|
|
if (status != 0x00) {
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s ROM BL FILE_CLOSE failure: 0x%02X for file = %d\n",
|
|
__func__, status, file_handle);
|
|
return -status;
|
|
}
|
|
return file_handle;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_pip2_file_erase
|
|
*
|
|
* SUMMARY: Using the BL PIP2 commands erase a file
|
|
*
|
|
* NOTE: The DUT must be in BL mode for this command to work
|
|
* NOTE: Some FLASH parts can time out while erasing one or more sectors,
|
|
* one retry is attempted for each sector in a file.
|
|
*
|
|
* RETURNS:
|
|
* <0 = Error
|
|
* >0 = file handle closed
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* file_handle - handle to the file to be erased
|
|
* *status - PIP2 erase status code
|
|
******************************************************************************/
|
|
int _pt_pip2_file_erase(struct device *dev, u8 file_handle, int *status)
|
|
{
|
|
int ret = 0;
|
|
int max_retry = PT_PIP2_MAX_FILE_SIZE/PT_PIP2_FILE_SECTOR_SIZE;
|
|
int retry = 1;
|
|
u16 actual_read_len;
|
|
u8 data[2];
|
|
u8 read_buf[10];
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
|
|
pt_debug(dev, DL_DEBUG, "%s: ERASE file %d\n", __func__, file_handle);
|
|
data[0] = file_handle;
|
|
data[1] = PIP2_FILE_IOCTL_CODE_ERASE_FILE;
|
|
*status = PIP2_RSP_ERR_TIMEOUT;
|
|
|
|
/* Increase waiting time for large file erase */
|
|
mutex_lock(&cd->system_lock);
|
|
cd->pip_cmd_timeout = PT_PIP2_CMD_FILE_ERASE_TIMEOUT;
|
|
mutex_unlock(&cd->system_lock);
|
|
while (*status == PIP2_RSP_ERR_TIMEOUT && retry < max_retry) {
|
|
ret = _pt_request_pip2_send_cmd(dev,
|
|
PT_CORE_CMD_UNPROTECTED, PIP2_CMD_ID_FILE_IOCTL,
|
|
data, 2, read_buf, &actual_read_len);
|
|
if (ret)
|
|
break;
|
|
*status = read_buf[PIP2_RESP_STATUS_OFFSET];
|
|
if (*status == PIP2_RSP_ERR_TIMEOUT) {
|
|
#ifdef TTDL_DIAGNOSTICS
|
|
cd->file_erase_timeout_count++;
|
|
#endif
|
|
pt_debug(dev, DL_WARN,
|
|
"%s: ERASE timeout %d for file = %d\n",
|
|
__func__, retry, file_handle);
|
|
}
|
|
retry++;
|
|
}
|
|
mutex_lock(&cd->system_lock);
|
|
cd->pip_cmd_timeout = cd->pip_cmd_timeout_default;
|
|
mutex_unlock(&cd->system_lock);
|
|
if (ret) {
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s ROM FILE_ERASE cmd failure: %d for file = %d\n",
|
|
__func__, ret, file_handle);
|
|
return -EIO;
|
|
}
|
|
|
|
if (*status != 0x00) {
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s ROM FILE_ERASE failure: 0x%02X for file = %d\n",
|
|
__func__, *status, file_handle);
|
|
return -EIO;
|
|
}
|
|
return file_handle;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_pip2_file_read
|
|
*
|
|
* SUMMARY: Using the BL PIP2 commands read n bytes from a already opened file
|
|
*
|
|
* NOTE: The DUT must be in BL mode for this command to work
|
|
*
|
|
* RETURNS:
|
|
* <0 = Error
|
|
* >0 = number of bytes read
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* file_handle - File handle to read from
|
|
* num_bytes - number of bytes to read
|
|
******************************************************************************/
|
|
int _pt_pip2_file_read(struct device *dev, u8 file_handle, u16 num_bytes,
|
|
u8 *read_buf)
|
|
{
|
|
int ret = 0;
|
|
u16 status;
|
|
u16 actual_read_len;
|
|
u8 data[3];
|
|
|
|
data[0] = file_handle;
|
|
data[1] = (num_bytes & 0x00FF);
|
|
data[2] = (num_bytes & 0xFF00) >> 8;
|
|
ret = _pt_request_pip2_send_cmd(dev,
|
|
PT_CORE_CMD_UNPROTECTED, PIP2_CMD_ID_FILE_READ,
|
|
data, 3, read_buf, &actual_read_len);
|
|
status = read_buf[PIP2_RESP_STATUS_OFFSET];
|
|
if (ret || ((status != 0x00) && (status != 0x03))) {
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s File open failure with error code = %d\n",
|
|
__func__, status);
|
|
return -1;
|
|
}
|
|
ret = num_bytes;
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_read_us_file
|
|
*
|
|
* SUMMARY: Open a user space file and read 'size' bytes into buf. If size = 0
|
|
* then read the entire file.
|
|
* NOTE: The file size must be less than PT_PIP2_MAX_FILE_SIZE
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *file_path - pointer to the file path
|
|
* *buf - pointer to the buffer to store the file contents
|
|
* *size - pointer to the size of the file
|
|
******************************************************************************/
|
|
int _pt_read_us_file(struct device *dev, u8 *file_path, u8 *buf, int *size)
|
|
{
|
|
struct file *filp = NULL;
|
|
struct inode *inode = NULL;
|
|
unsigned int file_len = 0;
|
|
unsigned int read_len = 0;
|
|
mm_segment_t oldfs;
|
|
int rc = 0;
|
|
|
|
if (file_path == NULL || buf == NULL) {
|
|
pt_debug(dev, DL_ERROR, "%s: path || buf is NULL.\n", __func__);
|
|
return -EINVAL;
|
|
}
|
|
|
|
pt_debug(dev, DL_WARN, "%s: path = %s\n", __func__, file_path);
|
|
|
|
oldfs = get_fs();
|
|
set_fs(KERNEL_DS);
|
|
filp = filp_open(file_path, O_RDONLY, 0400);
|
|
if (IS_ERR(filp)) {
|
|
pt_debug(dev, DL_WARN, "%s: Failed to open %s\n", __func__,
|
|
file_path);
|
|
rc = -ENOENT;
|
|
goto err;
|
|
}
|
|
|
|
if (filp->f_op == NULL) {
|
|
pt_debug(dev, DL_ERROR, "%s: File Operation Method Error\n",
|
|
__func__);
|
|
rc = -EINVAL;
|
|
goto exit;
|
|
}
|
|
inode = filp->f_path.dentry->d_inode;
|
|
if (inode == NULL) {
|
|
pt_debug(dev, DL_ERROR, "%s: Get inode from filp failed\n",
|
|
__func__);
|
|
rc = -EINVAL;
|
|
goto exit;
|
|
}
|
|
file_len = i_size_read(inode->i_mapping->host);
|
|
if (file_len == 0) {
|
|
pt_debug(dev, DL_ERROR, "%s: file size error,file_len = %d\n",
|
|
__func__, file_len);
|
|
rc = -EINVAL;
|
|
goto exit;
|
|
}
|
|
|
|
if (*size == 0)
|
|
read_len = file_len;
|
|
else
|
|
read_len = *size;
|
|
|
|
if (read_len > PT_PIP2_MAX_FILE_SIZE) {
|
|
pt_debug(dev, DL_ERROR, "%s: file size ( %d ) exception.\n",
|
|
__func__, read_len);
|
|
rc = -EINVAL;
|
|
goto exit;
|
|
}
|
|
filp->private_data = inode->i_private;
|
|
if (vfs_read(filp, buf, read_len, &(filp->f_pos)) != read_len) {
|
|
pt_debug(dev, DL_ERROR, "%s: file read error.\n", __func__);
|
|
rc = -EINVAL;
|
|
goto exit;
|
|
}
|
|
*size = read_len;
|
|
|
|
exit:
|
|
if (filp_close(filp, NULL) != 0)
|
|
pt_debug(dev, DL_ERROR, "%s: file close error.\n", __func__);
|
|
err:
|
|
set_fs(oldfs);
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_request_pip2_bin_hdr
|
|
*
|
|
* SUMMARY: Read the stored bin file header from Flash or the User Space file
|
|
* in the case of a flashless DUT, and parse the contents
|
|
*
|
|
* RETURNS:
|
|
* 0 = Success
|
|
* !0 = Error condition
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
******************************************************************************/
|
|
int _pt_request_pip2_bin_hdr(struct device *dev, struct pt_bin_file_hdr *hdr)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
u8 file_handle;
|
|
u8 read_buf[255];
|
|
u8 hdr_len = 0;
|
|
u8 i;
|
|
int bytes_read;
|
|
int read_size;
|
|
int ret = 0;
|
|
int rc = 0;
|
|
bool load_hdr_struct = false;
|
|
|
|
if (cd->flashless_dut) {
|
|
read_size = sizeof(read_buf);
|
|
rc = _pt_read_us_file(dev, cd->pip2_us_file_path,
|
|
read_buf, &read_size);
|
|
if (rc) {
|
|
ret = rc;
|
|
pt_debug(dev, DL_WARN,
|
|
"%s Failed to read fw image from US, rc=%d\n",
|
|
__func__, rc);
|
|
goto exit;
|
|
}
|
|
load_hdr_struct = true;
|
|
hdr_len = read_buf[0];
|
|
i = 0;
|
|
} else {
|
|
if (cd->mode != PT_MODE_BOOTLOADER) {
|
|
ret = -EPERM;
|
|
goto exit;
|
|
}
|
|
|
|
/* Open the bin file in Flash */
|
|
pt_debug(dev, DL_INFO, "%s Open File 1\n", __func__);
|
|
file_handle = _pt_pip2_file_open(dev, PIP2_FW_FILE);
|
|
if (file_handle != PIP2_FW_FILE) {
|
|
ret = -ENOENT;
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s Failed to open bin file\n", __func__);
|
|
goto exit;
|
|
}
|
|
|
|
/* Read the header length from the file */
|
|
pt_debug(dev, DL_INFO, "%s Read length of header\n", __func__);
|
|
read_size = 1;
|
|
bytes_read = _pt_pip2_file_read(dev, file_handle, read_size,
|
|
read_buf);
|
|
if (bytes_read != read_size) {
|
|
ret = -EX_ERR_FREAD;
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s Failed to bin file header len\n", __func__);
|
|
goto exit_close_file;
|
|
}
|
|
hdr_len = read_buf[PIP2_RESP_BODY_OFFSET];
|
|
if (hdr_len == 0xFF) {
|
|
ret = -EX_ERR_FLEN;
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s Bin header len is invalid\n", __func__);
|
|
goto exit_close_file;
|
|
}
|
|
|
|
/* Read the rest of the header from the bin file */
|
|
pt_debug(dev, DL_INFO, "%s Read bin file header\n", __func__);
|
|
memset(read_buf, 0, sizeof(read_buf));
|
|
bytes_read = _pt_pip2_file_read(dev, file_handle, hdr_len,
|
|
read_buf);
|
|
if (bytes_read != hdr_len) {
|
|
ret = -EX_ERR_FREAD;
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s Failed to read bin file\n", __func__);
|
|
goto exit_close_file;
|
|
}
|
|
load_hdr_struct = true;
|
|
|
|
exit_close_file:
|
|
/* Close the file */
|
|
if (file_handle != _pt_pip2_file_close(dev, file_handle)) {
|
|
ret = -EX_ERR_FCLOSE;
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s Failed to close bin file\n", __func__);
|
|
}
|
|
|
|
/*
|
|
* The length was already read so subtract 1 to make the rest of
|
|
* the offsets match the spec
|
|
*/
|
|
i = PIP2_RESP_BODY_OFFSET - 1;
|
|
}
|
|
|
|
if (load_hdr_struct) {
|
|
hdr->length = hdr_len;
|
|
hdr->ttpid = (read_buf[i+1] << 8) | read_buf[i+2];
|
|
hdr->fw_major = (read_buf[i+3]);
|
|
hdr->fw_minor = (read_buf[i+4]);
|
|
hdr->fw_crc = (read_buf[i+5] << 24) |
|
|
(read_buf[i+6] << 16) |
|
|
(read_buf[i+7] << 8) |
|
|
(read_buf[i+8]);
|
|
hdr->fw_rev_ctrl = (read_buf[i+9] << 24) |
|
|
(read_buf[i+10] << 16) |
|
|
(read_buf[i+11] << 8) |
|
|
(read_buf[i+12]);
|
|
hdr->si_rev = (read_buf[i+14] << 8) | (read_buf[i+13]);
|
|
hdr->si_id = (read_buf[i+16] << 8) | (read_buf[i+15]);
|
|
hdr->config_ver = (read_buf[i+17] << 8) | (read_buf[i+18]);
|
|
if (hdr_len >= 22) {
|
|
hdr->hex_file_size = (read_buf[i+19] << 24) |
|
|
(read_buf[i+20] << 16) |
|
|
(read_buf[i+21] << 8) |
|
|
(read_buf[i+22]);
|
|
} else {
|
|
hdr->hex_file_size = 0;
|
|
}
|
|
}
|
|
|
|
exit:
|
|
return ret;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_pip2_file_get_stats
|
|
*
|
|
* SUMMARY: Using the BL PIP2 commands get file information from an already
|
|
* opened file
|
|
*
|
|
* NOTE: The DUT must be in BL mode for this command to work
|
|
*
|
|
* RETURNS:
|
|
* !0 = Error
|
|
* 0 = Success
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* file_handle - File handle to read from
|
|
* *address - pointer to store address of file
|
|
* *file_size _ pointer to store size of file
|
|
******************************************************************************/
|
|
int _pt_pip2_file_get_stats(struct device *dev, u8 file_handle, u32 *address,
|
|
u32 *file_size)
|
|
{
|
|
int ret = 1;
|
|
u16 status;
|
|
u16 actual_read_len;
|
|
u8 data[2];
|
|
u8 read_buf[16];
|
|
|
|
data[0] = file_handle;
|
|
data[1] = PIP2_FILE_IOCTL_CODE_FILE_STATS;
|
|
|
|
ret = _pt_request_pip2_send_cmd(dev,
|
|
PT_CORE_CMD_UNPROTECTED, PIP2_CMD_ID_FILE_IOCTL,
|
|
data, 2, read_buf, &actual_read_len);
|
|
|
|
status = read_buf[PIP2_RESP_STATUS_OFFSET];
|
|
if (ret || (status != 0x00)) {
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s ROM FILE_STATS failure: 0x%02X for file = %d, ret = %d\n",
|
|
__func__, status, file_handle, ret);
|
|
ret = -EIO;
|
|
goto exit;
|
|
}
|
|
|
|
pt_debug(dev, DL_DEBUG,
|
|
"%s --- FILE %d Information ---\n", __func__, file_handle);
|
|
|
|
if (address) {
|
|
*address = read_buf[PIP2_RESP_BODY_OFFSET] +
|
|
(read_buf[PIP2_RESP_BODY_OFFSET + 1] << 8) +
|
|
(read_buf[PIP2_RESP_BODY_OFFSET + 2] << 16) +
|
|
(read_buf[PIP2_RESP_BODY_OFFSET + 3] << 24);
|
|
pt_debug(dev, DL_DEBUG, "%s Address: 0x%08x\n",
|
|
__func__, *address);
|
|
}
|
|
|
|
if (file_size) {
|
|
*file_size = read_buf[PIP2_RESP_BODY_OFFSET + 4] +
|
|
(read_buf[PIP2_RESP_BODY_OFFSET + 5] << 8) +
|
|
(read_buf[PIP2_RESP_BODY_OFFSET + 6] << 16) +
|
|
(read_buf[PIP2_RESP_BODY_OFFSET + 7] << 24);
|
|
pt_debug(dev, DL_DEBUG, "%s Size : 0x%08x\n",
|
|
__func__, *file_size);
|
|
}
|
|
|
|
exit:
|
|
return ret;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_pip2_file_seek_offset
|
|
*
|
|
* SUMMARY: Using the BL PIP2 commands seek read/write offset for an already
|
|
* opened file
|
|
*
|
|
* NOTE: The DUT must be in BL mode for this command to work
|
|
* NOTE: File open/erase command can reset the offset
|
|
*
|
|
* RETURNS:
|
|
* !0 = Error
|
|
* 0 = Success
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* file_handle - File handle to read from
|
|
* read_offset - read offset of file
|
|
* write_offset - write offset of file
|
|
******************************************************************************/
|
|
int _pt_pip2_file_seek_offset(struct device *dev, u8 file_handle,
|
|
u32 read_offset, u32 write_offset)
|
|
{
|
|
int ret = 1;
|
|
u16 status;
|
|
u16 actual_read_len;
|
|
u8 data[10];
|
|
u8 read_buf[16];
|
|
|
|
data[0] = file_handle;
|
|
data[1] = PIP2_FILE_IOCTL_CODE_SEEK_POINTER;
|
|
data[2] = 0xff & read_offset;
|
|
data[3] = 0xff & (read_offset >> 8);
|
|
data[4] = 0xff & (read_offset >> 16);
|
|
data[5] = 0xff & (read_offset >> 24);
|
|
data[6] = 0xff & write_offset;
|
|
data[7] = 0xff & (write_offset >> 8);
|
|
data[8] = 0xff & (write_offset >> 16);
|
|
data[9] = 0xff & (write_offset >> 24);
|
|
|
|
ret = _pt_request_pip2_send_cmd(dev,
|
|
PT_CORE_CMD_UNPROTECTED, PIP2_CMD_ID_FILE_IOCTL,
|
|
data, 10, read_buf, &actual_read_len);
|
|
|
|
status = read_buf[PIP2_RESP_STATUS_OFFSET];
|
|
if (ret || (status != 0x00)) {
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s ROM FILE_SEEK failure: 0x%02X for file = %d, ret = %d\n",
|
|
__func__, status, ret, file_handle);
|
|
ret = -EIO;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_pip2_file_crc
|
|
*
|
|
* SUMMARY: Using the BL PIP2 commands to calculate CRC for a file or portion of
|
|
* the file.
|
|
*
|
|
* NOTE: The DUT must be in BL mode for this command to work
|
|
* NOTE: This command only can be used for BL version 1.8 or greater.
|
|
* BL version 1.8 added this change according to PGV-173.
|
|
*
|
|
* RETURNS:
|
|
* !0 = Error
|
|
* 0 = Success
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* file_handle - File handle to read from
|
|
* offset - start offset for CRC calculation
|
|
* length - number of bytes to calculate CRC over
|
|
* read_buf - pointer to the read buffer
|
|
******************************************************************************/
|
|
int _pt_pip2_file_crc(struct device *dev, u8 file_handle,
|
|
u32 offset, u32 length, u8 *read_buf)
|
|
{
|
|
int rc = 1;
|
|
u16 actual_read_len;
|
|
u8 data[10];
|
|
|
|
data[0] = file_handle;
|
|
data[1] = PIP2_FILE_IOCTL_CODE_FILE_CRC;
|
|
data[2] = 0xff & offset;
|
|
data[3] = 0xff & (offset >> 8);
|
|
data[4] = 0xff & (offset >> 16);
|
|
data[5] = 0xff & (offset >> 24);
|
|
data[6] = 0xff & length;
|
|
data[7] = 0xff & (length >> 8);
|
|
data[8] = 0xff & (length >> 16);
|
|
data[9] = 0xff & (length >> 24);
|
|
|
|
rc = _pt_request_pip2_send_cmd(dev,
|
|
PT_CORE_CMD_UNPROTECTED, PIP2_CMD_ID_FILE_IOCTL,
|
|
data, 10, read_buf, &actual_read_len);
|
|
|
|
if (rc)
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s Return FILE_CRC failure, rc = %d\n",
|
|
__func__, rc);
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_pip2_ping_test
|
|
*
|
|
* SUMMARY: BIST type test that uses the PIP2 PING command and ramps up the
|
|
* optional payload from 0 bytes to max_bytes and ensures the PIP2
|
|
* response payload matches what was sent.
|
|
* The max payload size is 247:
|
|
* (255 - 2 byte reg address - 4 byte header - 2 byte CRC)
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* *attr - pointer to device attributes
|
|
* *buf - pointer to output buffer
|
|
******************************************************************************/
|
|
int pt_pip2_ping_test(struct device *dev, int max_bytes, int *last_packet_size)
|
|
{
|
|
u16 actual_read_len;
|
|
u8 *read_buf = NULL;
|
|
u8 *data = NULL;
|
|
int data_offset = PIP2_RESP_STATUS_OFFSET;
|
|
int i = 1;
|
|
int j = 0;
|
|
int rc = 0;
|
|
|
|
read_buf = kzalloc(PT_MAX_PIP2_MSG_SIZE, GFP_KERNEL);
|
|
if (!read_buf)
|
|
goto ping_test_exit;
|
|
|
|
data = kzalloc(PT_MAX_PIP2_MSG_SIZE, GFP_KERNEL);
|
|
if (!data)
|
|
goto ping_test_exit;
|
|
|
|
/* Load data payload with an array of walking 1's */
|
|
for (i = 0; i < 255; i++)
|
|
data[i] = 0x01 << (i % 8);
|
|
|
|
/* Send 'max_bytes' PING cmds using 'i' bytes as payload for each */
|
|
for (i = 0; i <= max_bytes; i++) {
|
|
rc = _pt_request_pip2_send_cmd(dev, PT_CORE_CMD_UNPROTECTED,
|
|
PIP2_CMD_ID_PING, data, i, read_buf,
|
|
&actual_read_len);
|
|
if (rc) {
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s: PING failed with %d byte payload\n",
|
|
__func__, i);
|
|
break;
|
|
}
|
|
/* Verify data returned matches data sent */
|
|
for (j = 0; j < i; j++) {
|
|
if (read_buf[data_offset + j] != data[j]) {
|
|
pt_debug(dev, DL_DEBUG,
|
|
"%s: PING packet size %d: sent[%d]=0x%02X recv[%d]=0x%02X\n",
|
|
__func__, i, j, data[j], j,
|
|
read_buf[data_offset + j]);
|
|
goto ping_test_exit;
|
|
}
|
|
}
|
|
}
|
|
|
|
ping_test_exit:
|
|
*last_packet_size = i - 1;
|
|
kfree(read_buf);
|
|
kfree(data);
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_ic_parse_input_hex
|
|
*
|
|
* SUMMARY: Parse a char data array as space delimited hex values into
|
|
* an int array.
|
|
*
|
|
* NOTE: _pt_ic_parse_input() function may have simliar work while the type of
|
|
* buffer to store data is "u32". This function is still needed by the
|
|
* "command" sysfs node because the buffer type to store data is "u8".
|
|
*
|
|
* RETURN: Length of parsed data
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* *buf - pointer to buffer that holds the input array to parse
|
|
* buf_size - size of buf
|
|
* *ic_buf - pointer to array to store parsed data
|
|
* ic_buf_size - max size of ic_buf
|
|
******************************************************************************/
|
|
static int _pt_ic_parse_input_hex(struct device *dev, const char *buf,
|
|
size_t buf_size, u8 *ic_buf, size_t ic_buf_size)
|
|
{
|
|
const char *pbuf = buf;
|
|
unsigned long value;
|
|
char scan_buf[PT_MAX_PIP2_MSG_SIZE + 1];
|
|
u32 i = 0;
|
|
u32 j;
|
|
int last = 0;
|
|
int ret;
|
|
|
|
pt_debug(dev, DL_DEBUG,
|
|
"%s: pbuf=%p buf=%p size=%zu %s=%d buf=%s\n",
|
|
__func__, pbuf, buf, buf_size, "scan buf size",
|
|
PT_MAX_PIP2_MSG_SIZE, buf);
|
|
|
|
while (pbuf <= (buf + buf_size)) {
|
|
if (i >= PT_MAX_PIP2_MSG_SIZE) {
|
|
pt_debug(dev, DL_ERROR, "%s: %s size=%d max=%d\n",
|
|
__func__, "Max cmd size exceeded", i,
|
|
PT_MAX_PIP2_MSG_SIZE);
|
|
return -EINVAL;
|
|
}
|
|
if (i >= ic_buf_size) {
|
|
pt_debug(dev, DL_ERROR, "%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, PT_MAX_PIP2_MSG_SIZE);
|
|
if ((last == ',') && (*pbuf == ',')) {
|
|
pt_debug(dev, DL_ERROR, "%s: %s \",,\" not allowed.\n",
|
|
__func__, "Invalid data format.");
|
|
return -EINVAL;
|
|
}
|
|
for (j = 0; j < (PT_MAX_PIP2_MSG_SIZE - 1)
|
|
&& (pbuf < (buf + buf_size))
|
|
&& (*pbuf != ' ')
|
|
&& (*pbuf != ','); j++) {
|
|
last = *pbuf;
|
|
scan_buf[j] = *pbuf++;
|
|
}
|
|
ret = kstrtoul(scan_buf, 16, &value);
|
|
if (ret < 0) {
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s: %s '%s' %s%s i=%d r=%d\n", __func__,
|
|
"Invalid data format. ", scan_buf,
|
|
"Use \"0xHH,...,0xHH\"", " instead.",
|
|
i, ret);
|
|
return ret;
|
|
}
|
|
|
|
ic_buf[i] = value;
|
|
pt_debug(dev, DL_DEBUG, "%s: item = %d, value = 0x%02lx",
|
|
__func__, i, value);
|
|
i++;
|
|
}
|
|
|
|
return i;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: _pt_ic_parse_input
|
|
*
|
|
* SUMMARY: Parse user sysfs input data as a space or comma delimited list of
|
|
* hex values or dec values into an int array with the following rules:
|
|
* 1) Hex values must have a "0x" prefix for each element or the first element
|
|
* only
|
|
* 2) Dec values do not have any prefix
|
|
* 3) It is not allowed to have a mix of dec and hex values in the user input
|
|
* string
|
|
*
|
|
* RETURN: Number of values parsed
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* *buf - pointer to buffer that holds the input array to parse
|
|
* buf_size - size of buf
|
|
* *out_buf - pointer to array to store parsed data
|
|
* out_buf_size - max size of buffer to be stored
|
|
******************************************************************************/
|
|
static int _pt_ic_parse_input(struct device *dev,
|
|
const char *buf, size_t buf_size,
|
|
u32 *out_buf, size_t out_buf_size)
|
|
{
|
|
const char *pbuf = buf;
|
|
unsigned long value;
|
|
char scan_buf[PT_MAX_PIP2_MSG_SIZE + 1];
|
|
u32 i = 0;
|
|
u32 j;
|
|
int last = 0;
|
|
int ret = 0;
|
|
u8 str_base = 0;
|
|
|
|
pt_debug(dev, DL_DEBUG,
|
|
"%s: in_buf_size=%zu out_buf_size=%zu %s=%d buf=%s\n",
|
|
__func__, buf_size, out_buf_size, "scan buf size",
|
|
PT_MAX_PIP2_MSG_SIZE, buf);
|
|
|
|
while (pbuf <= (buf + buf_size)) {
|
|
if (i >= PT_MAX_PIP2_MSG_SIZE) {
|
|
pt_debug(dev, DL_ERROR, "%s: %s size=%d max=%d\n",
|
|
__func__, "Max cmd size exceeded", i,
|
|
PT_MAX_PIP2_MSG_SIZE);
|
|
ret = -EINVAL;
|
|
goto error;
|
|
}
|
|
if (i >= out_buf_size) {
|
|
pt_debug(dev, DL_ERROR, "%s: %s size=%d buf_size=%zu\n",
|
|
__func__, "Buffer size exceeded", i,
|
|
out_buf_size);
|
|
ret = -EINVAL;
|
|
goto error;
|
|
}
|
|
while (((*pbuf == ' ') || (*pbuf == ','))
|
|
&& (pbuf < (buf + buf_size))) {
|
|
last = *pbuf;
|
|
pbuf++;
|
|
}
|
|
|
|
if (pbuf >= (buf + buf_size))
|
|
break;
|
|
|
|
memset(scan_buf, 0, PT_MAX_PIP2_MSG_SIZE);
|
|
if ((last == ',') && (*pbuf == ',')) {
|
|
pt_debug(dev, DL_ERROR, "%s: %s \",,\" not allowed.\n",
|
|
__func__, "Invalid data format.");
|
|
ret = -EINVAL;
|
|
goto error;
|
|
}
|
|
for (j = 0; j < (PT_MAX_PIP2_MSG_SIZE - 1)
|
|
&& (pbuf < (buf + buf_size))
|
|
&& (*pbuf != ' ')
|
|
&& (*pbuf != ','); j++) {
|
|
last = *pbuf;
|
|
scan_buf[j] = *pbuf++;
|
|
}
|
|
|
|
if (i == 0) {
|
|
if ((strncmp(scan_buf, "0x", 2) == 0) ||
|
|
(strncmp(scan_buf, "0X", 2) == 0))
|
|
str_base = 16;
|
|
else
|
|
str_base = 10;
|
|
} else {
|
|
if (((strncmp(scan_buf, "0x", 2) == 0) ||
|
|
(strncmp(scan_buf, "0X", 2) == 0)) &&
|
|
(str_base == 10)) {
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s: Decimal and Heximal data mixed\n",
|
|
__func__);
|
|
ret = -EINVAL;
|
|
goto error;
|
|
}
|
|
}
|
|
ret = kstrtoul(scan_buf, str_base, &value);
|
|
if (ret < 0) {
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s: %s '%s' %s%s i=%d r=%d\n", __func__,
|
|
"Invalid data format. ", scan_buf,
|
|
"Use \"0xHH,...,0xHH\" or \"DD DD DD ... DD\"",
|
|
" instead.", i, ret);
|
|
goto error;
|
|
}
|
|
|
|
out_buf[i] = value;
|
|
pt_debug(dev, DL_DEBUG, "%s: item = %d, value = 0x%02lx(%lu)",
|
|
__func__, i, value, value);
|
|
i++;
|
|
}
|
|
ret = i;
|
|
error:
|
|
return ret;
|
|
}
|
|
|
|
#ifdef TTHE_TUNER_SUPPORT
|
|
/*******************************************************************************
|
|
* FUNCTION: tthe_debugfs_open
|
|
*
|
|
* SUMMARY: Open method for tthe_tuner debugfs node. On some hosts the size of
|
|
* PT_MAX_PRBUF_SIZE (equal to PAGE_SIZE) is not large enough to handle
|
|
* printing a large number of fingers and sensor data without overflowing
|
|
* the buffer. tthe_tuner needs ~4K and so the buffer is sized to some
|
|
* even multiple of PAGE_SIZE
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *inode - file inode number
|
|
* *filp - file pointer to debugfs file
|
|
******************************************************************************/
|
|
static int tthe_debugfs_open(struct inode *inode, struct file *filp)
|
|
{
|
|
struct pt_core_data *cd = inode->i_private;
|
|
u32 buf_size = PT_MAX_PRBUF_SIZE;
|
|
|
|
filp->private_data = inode->i_private;
|
|
|
|
if (cd->tthe_buf)
|
|
return -EBUSY;
|
|
|
|
while (buf_size < 4096)
|
|
buf_size = buf_size << 1;
|
|
|
|
pt_debug(cd->dev, DL_INFO, "%s:PT_MAX_BRBUF_SIZE=%d buf_size=%d\n",
|
|
__func__, (int)PT_MAX_PRBUF_SIZE, (int)buf_size);
|
|
|
|
cd->tthe_buf_size = buf_size;
|
|
cd->tthe_buf = kzalloc(cd->tthe_buf_size, GFP_KERNEL);
|
|
if (!cd->tthe_buf)
|
|
return -ENOMEM;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: tthe_debugfs_close
|
|
*
|
|
* SUMMARY: Close method for tthe_tuner debugfs node.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *inode - file inode number
|
|
* *filp - file pointer to debugfs file
|
|
******************************************************************************/
|
|
static int tthe_debugfs_close(struct inode *inode, struct file *filp)
|
|
{
|
|
struct pt_core_data *cd = filp->private_data;
|
|
|
|
filp->private_data = NULL;
|
|
|
|
kfree(cd->tthe_buf);
|
|
cd->tthe_buf = NULL;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: tthe_debugfs_read
|
|
*
|
|
* SUMMARY: Read method for tthe_tuner debugfs node. This function prints
|
|
* tthe_buf to user buffer.
|
|
*
|
|
* RETURN: Size of debugfs data print
|
|
*
|
|
* PARAMETERS:
|
|
* *filp - file pointer to debugfs file
|
|
* *buf - the user space buffer to read to
|
|
* count - the maximum number of bytes to read
|
|
* *ppos - the current position in the buffer
|
|
******************************************************************************/
|
|
static ssize_t tthe_debugfs_read(struct file *filp, char __user *buf,
|
|
size_t count, loff_t *ppos)
|
|
{
|
|
struct pt_core_data *cd = filp->private_data;
|
|
int size;
|
|
int ret;
|
|
static int partial_read;
|
|
|
|
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;
|
|
}
|
|
|
|
if (partial_read) {
|
|
ret = copy_to_user(buf, cd->tthe_buf + partial_read, size);
|
|
partial_read = 0;
|
|
} else {
|
|
ret = copy_to_user(buf, cd->tthe_buf, size);
|
|
}
|
|
if (size == count)
|
|
partial_read = count;
|
|
|
|
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 pt_core_nonhid_cmd _pt_core_nonhid_cmd = {
|
|
.start_bl = _pt_request_pip_start_bl,
|
|
.suspend_scanning = _pt_request_pip_suspend_scanning,
|
|
.resume_scanning = _pt_request_pip_resume_scanning,
|
|
.get_param = _pt_request_pip_get_param,
|
|
.set_param = _pt_request_pip_set_param,
|
|
.verify_cfg_block_crc = _pt_request_pip_verify_config_block_crc,
|
|
.get_config_row_size = _pt_request_pip_get_config_row_size,
|
|
.get_data_structure = _pt_request_pip_get_data_structure,
|
|
.run_selftest = _pt_request_pip_run_selftest,
|
|
.get_selftest_result = _pt_request_pip_get_selftest_result,
|
|
.load_self_test_param = _pt_request_pip_load_self_test_param,
|
|
.calibrate_idacs = _pt_request_pip_calibrate_idacs,
|
|
.calibrate_ext = _pt_request_pip_calibrate_ext,
|
|
.initialize_baselines = _pt_request_pip_initialize_baselines,
|
|
.exec_panel_scan = _pt_request_pip_exec_panel_scan,
|
|
.retrieve_panel_scan = _pt_request_pip_retrieve_panel_scan,
|
|
.read_data_block = _pt_request_pip_read_data_block,
|
|
.write_data_block = _pt_request_pip_write_data_block,
|
|
.user_cmd = _pt_request_pip_user_cmd,
|
|
.get_bl_info = _pt_request_pip_bl_get_information,
|
|
.initiate_bl = _pt_request_pip_bl_initiate_bl,
|
|
.launch_app = _pt_request_pip_launch_app,
|
|
.prog_and_verify = _pt_request_pip_bl_program_and_verify,
|
|
.verify_app_integrity = _pt_request_pip_bl_verify_app_integrity,
|
|
.get_panel_id = _pt_request_pip_bl_get_panel_id,
|
|
.pip2_send_cmd = _pt_request_pip2_send_cmd,
|
|
.pip2_send_cmd_no_int = _pt_pip2_send_cmd_no_int,
|
|
.pip2_file_open = _pt_pip2_file_open,
|
|
.pip2_file_close = _pt_pip2_file_close,
|
|
.pip2_file_erase = _pt_pip2_file_erase,
|
|
.read_us_file = _pt_read_us_file,
|
|
.manage_cal_data = _pt_manage_local_cal_data,
|
|
.calc_crc = crc_ccitt_calculate,
|
|
#ifdef TTDL_DIAGNOSTICS
|
|
.pip2_file_read = _pt_pip2_file_read,
|
|
.pip2_file_seek_offset = _pt_pip2_file_seek_offset,
|
|
.pip2_file_get_stats = _pt_pip2_file_get_stats,
|
|
.pip2_file_crc = _pt_pip2_file_crc,
|
|
#endif
|
|
};
|
|
|
|
static struct pt_core_commands _pt_core_commands = {
|
|
.subscribe_attention = _pt_subscribe_attention,
|
|
.unsubscribe_attention = _pt_unsubscribe_attention,
|
|
.request_exclusive = _pt_request_exclusive,
|
|
.release_exclusive = _pt_release_exclusive,
|
|
.request_reset = _pt_request_reset,
|
|
.request_pip2_launch_app = _pt_request_pip2_launch_app,
|
|
.request_enum = _pt_request_enum,
|
|
.request_sysinfo = _pt_request_sysinfo,
|
|
.request_loader_pdata = _pt_request_loader_pdata,
|
|
.request_stop_wd = _pt_request_stop_wd,
|
|
.request_start_wd = _pt_request_start_wd,
|
|
.request_get_mode = _pt_request_get_mode,
|
|
.request_active_pip_prot = _pt_request_active_pip_protocol,
|
|
.request_pip2_get_mode_sysmode = _pt_request_pip2_get_mode_sysmode,
|
|
.request_pip2_enter_bl = _pt_request_pip2_enter_bl,
|
|
.request_pip2_bin_hdr = _pt_request_pip2_bin_hdr,
|
|
.request_dut_generation = _pt_request_dut_generation,
|
|
.request_hw_version = _pt_request_hw_version,
|
|
.parse_sysfs_input = _pt_ic_parse_input,
|
|
#ifdef TTHE_TUNER_SUPPORT
|
|
.request_tthe_print = _pt_request_tthe_print,
|
|
#endif
|
|
#ifdef TTDL_DIAGNOSTICS
|
|
.request_toggle_err_gpio = _pt_request_toggle_err_gpio,
|
|
#endif
|
|
.nonhid_cmd = &_pt_core_nonhid_cmd,
|
|
.request_get_fw_mode = _pt_request_get_fw_sys_mode,
|
|
};
|
|
|
|
struct pt_core_commands *pt_get_commands(void)
|
|
{
|
|
return &_pt_core_commands;
|
|
}
|
|
EXPORT_SYMBOL_GPL(pt_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;
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_probe_module
|
|
*
|
|
* SUMMARY: Add the module pointer to module_node and call the probe pointer.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* *module - pointer to module structure
|
|
******************************************************************************/
|
|
static int pt_probe_module(struct pt_core_data *cd,
|
|
struct pt_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;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_release_module
|
|
*
|
|
* SUMMARY: Call the release pointer and remove the module pointer from
|
|
* module_list.
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
* *module - pointer to module structure
|
|
******************************************************************************/
|
|
static void pt_release_module(struct pt_core_data *cd,
|
|
struct pt_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);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_probe_modules
|
|
*
|
|
* SUMMARY: Iterate module_list and probe each module.
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
******************************************************************************/
|
|
static void pt_probe_modules(struct pt_core_data *cd)
|
|
{
|
|
struct pt_module *m;
|
|
int rc = 0;
|
|
|
|
mutex_lock(&module_list_lock);
|
|
list_for_each_entry(m, &module_list, node) {
|
|
pt_debug(cd->dev, DL_WARN, "%s: Probe module %s\n",
|
|
__func__, m->name);
|
|
rc = pt_probe_module(cd, m);
|
|
if (rc)
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: Probe fails for module %s\n",
|
|
__func__, m->name);
|
|
}
|
|
mutex_unlock(&module_list_lock);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_release_modules
|
|
*
|
|
* SUMMARY: Iterate module_list and remove each module.
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
******************************************************************************/
|
|
static void pt_release_modules(struct pt_core_data *cd)
|
|
{
|
|
struct pt_module *m;
|
|
|
|
mutex_lock(&module_list_lock);
|
|
list_for_each_entry(m, &module_list, node)
|
|
pt_release_module(cd, m);
|
|
mutex_unlock(&module_list_lock);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_get_core_data
|
|
*
|
|
* SUMMARY: Iterate core_list and get core data.
|
|
*
|
|
* RETURN:
|
|
* pointer to core data or null pointer if fail
|
|
*
|
|
* PARAMETERS:
|
|
* *id - pointer to core id
|
|
******************************************************************************/
|
|
struct pt_core_data *pt_get_core_data(char *id)
|
|
{
|
|
struct pt_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(pt_get_core_data);
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_add_core
|
|
*
|
|
* SUMMARY: Add core data to the core_list.
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
******************************************************************************/
|
|
static void pt_add_core(struct device *dev)
|
|
{
|
|
struct pt_core_data *d;
|
|
struct pt_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);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_del_core
|
|
*
|
|
* SUMMARY: Remove core data from the core_list.
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
******************************************************************************/
|
|
static void pt_del_core(struct device *dev)
|
|
{
|
|
struct pt_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);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_register_module
|
|
*
|
|
* SUMMARY: Register the module to module_list and probe the module for each
|
|
* core.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *module - pointer to module structure
|
|
******************************************************************************/
|
|
int pt_register_module(struct pt_module *module)
|
|
{
|
|
struct pt_module *m;
|
|
struct pt_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)
|
|
pt_probe_module(cd, module);
|
|
mutex_unlock(&core_list_lock);
|
|
|
|
unlock:
|
|
mutex_unlock(&module_list_lock);
|
|
return rc;
|
|
}
|
|
EXPORT_SYMBOL_GPL(pt_register_module);
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_unregister_module
|
|
*
|
|
* SUMMARY: Release the module for each core and remove the module from
|
|
* module_list.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *module - pointer to module structure
|
|
******************************************************************************/
|
|
void pt_unregister_module(struct pt_module *module)
|
|
{
|
|
struct pt_module *m, *m_n;
|
|
struct pt_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)
|
|
pt_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(pt_unregister_module);
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_get_module_data
|
|
*
|
|
* SUMMARY: Get module data from module_node by module_list.
|
|
*
|
|
* RETURN:
|
|
* pointer to module data
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* *module - pointer to module structure
|
|
******************************************************************************/
|
|
void *pt_get_module_data(struct device *dev, struct pt_module *module)
|
|
{
|
|
struct pt_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(pt_get_module_data);
|
|
|
|
#ifdef CONFIG_HAS_EARLYSUSPEND
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_early_suspend
|
|
*
|
|
* SUMMARY: Android PM architecture function that will call "PT_ATTEN_SUSPEND"
|
|
* attention list.
|
|
*
|
|
* PARAMETERS:
|
|
* *h - pointer to early_suspend structure
|
|
******************************************************************************/
|
|
static void pt_early_suspend(struct early_suspend *h)
|
|
{
|
|
struct pt_core_data *cd =
|
|
container_of(h, struct pt_core_data, es);
|
|
|
|
call_atten_cb(cd, PT_ATTEN_SUSPEND, 0);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_late_resume
|
|
*
|
|
* SUMMARY: Android PM architecture function that will call "PT_ATTEN_RESUME"
|
|
* attention list.
|
|
*
|
|
* PARAMETERS:
|
|
* *h - pointer to early_suspend structure
|
|
******************************************************************************/
|
|
static void pt_late_resume(struct early_suspend *h)
|
|
{
|
|
struct pt_core_data *cd =
|
|
container_of(h, struct pt_core_data, es);
|
|
|
|
call_atten_cb(cd, PT_ATTEN_RESUME, 0);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_setup_early_suspend
|
|
*
|
|
* SUMMARY: Register early/suspend funtion to the system.
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
******************************************************************************/
|
|
static void pt_setup_early_suspend(struct pt_core_data *cd)
|
|
{
|
|
cd->es.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
|
|
cd->es.suspend = pt_early_suspend;
|
|
cd->es.resume = pt_late_resume;
|
|
|
|
register_early_suspend(&cd->es);
|
|
}
|
|
#elif defined(CONFIG_FB)
|
|
/*******************************************************************************
|
|
* FUNCTION: fb_notifier_callback
|
|
*
|
|
* SUMMARY: Call back function for FrameBuffer notifier to allow to call
|
|
* resume/suspend attention list.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
*
|
|
* PARAMETERS:
|
|
* *self - pointer to notifier_block structure
|
|
* event - event type of fb notifier
|
|
* *data - pointer to fb_event structure
|
|
******************************************************************************/
|
|
static int fb_notifier_callback(struct notifier_block *self,
|
|
unsigned long event, void *data)
|
|
{
|
|
struct pt_core_data *cd =
|
|
container_of(self, struct pt_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) {
|
|
pt_debug(cd->dev, DL_INFO, "%s: UNBLANK!\n", __func__);
|
|
if (cd->fb_state != FB_ON) {
|
|
call_atten_cb(cd, PT_ATTEN_RESUME, 0);
|
|
#if defined(CONFIG_PM_SLEEP)
|
|
if (cd->cpdata->flags & PT_CORE_FLAG_SKIP_RUNTIME)
|
|
pt_core_resume_(cd->dev);
|
|
#endif
|
|
cd->fb_state = FB_ON;
|
|
}
|
|
} else if (*blank == FB_BLANK_POWERDOWN) {
|
|
pt_debug(cd->dev, DL_INFO, "%s: POWERDOWN!\n", __func__);
|
|
if (cd->fb_state != FB_OFF) {
|
|
#if defined(CONFIG_PM_SLEEP)
|
|
if (cd->cpdata->flags & PT_CORE_FLAG_SKIP_RUNTIME)
|
|
pt_core_suspend_(cd->dev);
|
|
#endif
|
|
call_atten_cb(cd, PT_ATTEN_SUSPEND, 0);
|
|
cd->fb_state = FB_OFF;
|
|
}
|
|
}
|
|
|
|
exit:
|
|
return 0;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_setup_fb_notifier
|
|
*
|
|
* SUMMARY: Set up call back function into fb notifier.
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to core data
|
|
******************************************************************************/
|
|
static void pt_setup_fb_notifier(struct pt_core_data *cd)
|
|
{
|
|
int rc = 0;
|
|
|
|
cd->fb_state = FB_ON;
|
|
|
|
cd->fb_notifier.notifier_call = fb_notifier_callback;
|
|
|
|
rc = fb_register_client(&cd->fb_notifier);
|
|
if (rc)
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"Unable to register fb_notifier: %d\n", rc);
|
|
}
|
|
#endif
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_watchdog_work
|
|
*
|
|
* SUMMARY: This is where the watchdog work is done except if the DUT is
|
|
* sleeping then this function simply returns. If the DUT is awake the
|
|
* first thing is to ensure the IRQ is not stuck asserted meaning that
|
|
* somehow a response is waiting on the DUT that has not been read. If
|
|
* this occurs the message is simply consumed. If or once the IRQ is
|
|
* cleared, a PIP PING message is sent to the DUT and if the response
|
|
* is received the watchdog succeeds and exits, if no response is seen
|
|
* a startup is queued unless the maximum number of startups have already
|
|
* been attempted, in that case a BL is attempted.
|
|
*
|
|
* NOTE: pt_stop_wd_timer() cannot be called within the context of this
|
|
* work thread
|
|
*
|
|
* RETURN: void
|
|
*
|
|
* PARAMETERS:
|
|
* *work - pointer to a work structure for the watchdog work queue
|
|
******************************************************************************/
|
|
static void pt_watchdog_work(struct work_struct *work)
|
|
{
|
|
int rc = 0;
|
|
struct pt_core_data *cd = container_of(work,
|
|
struct pt_core_data, watchdog_work);
|
|
|
|
/*
|
|
* if found the current sleep_state is SS_SLEEPING
|
|
* then no need to request_exclusive, directly return
|
|
*/
|
|
if (cd->sleep_state == SS_SLEEPING)
|
|
return;
|
|
|
|
#ifdef TTDL_DIAGNOSTICS
|
|
cd->watchdog_count++;
|
|
#endif /* TTDL_DIAGNOSTICS */
|
|
|
|
/*
|
|
* The first WD interval was extended to allow DDI to come up.
|
|
* If the WD interval is not the default then adjust timer to the
|
|
* current setting. The user can override value with drv_debug sysfs.
|
|
*/
|
|
if (cd->watchdog_interval != PT_WATCHDOG_TIMEOUT) {
|
|
mod_timer_pending(&cd->watchdog_timer, jiffies +
|
|
msecs_to_jiffies(cd->watchdog_interval));
|
|
}
|
|
|
|
if (pt_check_irq_asserted(cd)) {
|
|
#ifdef TTDL_DIAGNOSTICS
|
|
cd->watchdog_irq_stuck_count++;
|
|
pt_toggle_err_gpio(cd, PT_ERR_GPIO_IRQ_STUCK);
|
|
#endif /* TTDL_DIAGNOSTICS */
|
|
pt_debug(cd->dev, DL_WARN,
|
|
"%s: TTDL WD found IRQ asserted, attempt to clear\n",
|
|
__func__);
|
|
pt_flush_bus(cd, PT_FLUSH_BUS_BASED_ON_LEN, NULL);
|
|
}
|
|
|
|
rc = request_exclusive(cd, cd->dev, PT_REQUEST_EXCLUSIVE_TIMEOUT);
|
|
if (rc < 0) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail get exclusive ex=%p own=%p\n",
|
|
__func__, cd->exclusive_dev, cd->dev);
|
|
goto queue_startup;
|
|
}
|
|
|
|
rc = pt_pip_null_(cd);
|
|
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail to release exclusive\n", __func__);
|
|
|
|
queue_startup:
|
|
if (rc) {
|
|
#ifdef TTDL_DIAGNOSTICS
|
|
cd->watchdog_failed_access_count++;
|
|
pt_toggle_err_gpio(cd, PT_ERR_GPIO_EXCLUSIVE_ACCESS);
|
|
#endif /* TTDL_DIAGNOSTICS */
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: failed to access device in WD, retry count=%d\n",
|
|
__func__, cd->startup_retry_count);
|
|
|
|
/* Already tried FW upgrade because of watchdog but failed */
|
|
if (cd->startup_retry_count > PT_WATCHDOG_RETRY_COUNT)
|
|
return;
|
|
|
|
if (cd->startup_retry_count++ < PT_WATCHDOG_RETRY_COUNT) {
|
|
/*
|
|
* Any wrapper function that trys to disable the
|
|
* WD killing this worker cannot be called here.
|
|
*/
|
|
rc = request_exclusive(cd, cd->dev,
|
|
PT_REQUEST_EXCLUSIVE_TIMEOUT);
|
|
if (rc < 0) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail get exclusive ex=%p own=%p\n",
|
|
__func__, cd->exclusive_dev, cd->dev);
|
|
goto exit;
|
|
}
|
|
|
|
cd->hw_detected = false;
|
|
cd->startup_status = STARTUP_STATUS_START;
|
|
pt_debug(cd->dev, DL_DEBUG,
|
|
"%s: Startup Status Reset\n", __func__);
|
|
rc = pt_dut_reset_and_wait(cd);
|
|
if (release_exclusive(cd, cd->dev) < 0)
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: fail to release exclusive\n",
|
|
__func__);
|
|
if (!rc) {
|
|
cd->hw_detected = true;
|
|
if (!cd->flashless_dut)
|
|
pt_queue_enum(cd);
|
|
}
|
|
#ifdef TTDL_DIAGNOSTICS
|
|
cd->wd_xres_count++;
|
|
pt_debug(cd->dev, DL_WARN,
|
|
"%s: Comm Failed - DUT reset [#%d]\n",
|
|
__func__, cd->wd_xres_count);
|
|
#endif /* TTDL_DIAGNOSTICS */
|
|
} else {
|
|
/*
|
|
* After trying PT_WATCHDOG_RETRY_COUNT times to
|
|
* reset the part to regain communications, try to BL
|
|
*/
|
|
pt_debug(cd->dev, DL_WARN,
|
|
"%s: WD DUT access failure, Start FW Upgrade\n",
|
|
__func__);
|
|
#ifdef TTDL_DIAGNOSTICS
|
|
/*
|
|
* When diagnostics is enabled allow TTDL to keep
|
|
* trying to find the DUT. This allows the DUT to be
|
|
* hot swap-able while the host stays running. In
|
|
* production this may not be wanted as a customer
|
|
* may have several touch drivers and any driver
|
|
* that doesn't match the current DUT should give
|
|
* up trying and give up using the bus.
|
|
*/
|
|
pt_debug(cd->dev, DL_INFO,
|
|
"%s: Resetting startup_retry_count\n",
|
|
__func__);
|
|
cd->startup_retry_count = 0;
|
|
#endif /* TTDL_DIAGNOSTICS */
|
|
/*
|
|
* Since fw may be broken,reset sysinfo ready flag
|
|
* to let upgrade function work.
|
|
*/
|
|
mutex_lock(&cd->system_lock);
|
|
cd->sysinfo.ready = false;
|
|
mutex_unlock(&cd->system_lock);
|
|
|
|
if (cd->active_dut_generation == DUT_UNKNOWN) {
|
|
pt_debug(cd->dev, DL_WARN,
|
|
"%s: Queue Restart\n", __func__);
|
|
pt_queue_restart(cd);
|
|
} else
|
|
kthread_run(start_fw_upgrade, cd, "pt_loader");
|
|
}
|
|
} else {
|
|
cd->hw_detected = true;
|
|
if (cd->startup_status <= (STARTUP_STATUS_FW_RESET_SENTINEL |
|
|
STARTUP_STATUS_BL_RESET_SENTINEL)) {
|
|
pt_debug(cd->dev, DL_WARN,
|
|
"%s: HW detected but not enumerated\n",
|
|
__func__);
|
|
pt_queue_enum(cd);
|
|
}
|
|
}
|
|
|
|
exit:
|
|
pt_start_wd_timer(cd);
|
|
}
|
|
|
|
#if (KERNEL_VERSION(4, 14, 0) > LINUX_VERSION_CODE)
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_watchdog_timer
|
|
*
|
|
* SUMMARY: The function that is called when the WD timer expires. If the
|
|
* watchdog work is not already busy schedule the watchdog work queue.
|
|
*
|
|
* RETURN: void
|
|
*
|
|
* PARAMETERS:
|
|
* handle - Handle to the watchdog timer
|
|
******************************************************************************/
|
|
static void pt_watchdog_timer(unsigned long handle)
|
|
{
|
|
struct pt_core_data *cd = (struct pt_core_data *)handle;
|
|
|
|
if (!cd)
|
|
return;
|
|
|
|
pt_debug(cd->dev, DL_DEBUG, "%s: Watchdog timer triggered\n",
|
|
__func__);
|
|
|
|
if (!work_pending(&cd->watchdog_work))
|
|
schedule_work(&cd->watchdog_work);
|
|
}
|
|
#else
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_watchdog_timer
|
|
*
|
|
* SUMMARY: The function that is called when the WD timer expires. If the
|
|
* watchdog work is not already busy schedule the watchdog work queue.
|
|
*
|
|
* RETURN: void
|
|
*
|
|
* PARAMETERS:
|
|
* *t - Pointer to timer list
|
|
******************************************************************************/
|
|
static void pt_watchdog_timer(struct timer_list *t)
|
|
{
|
|
struct pt_core_data *cd = from_timer(cd, t, watchdog_timer);
|
|
|
|
if (!cd)
|
|
return;
|
|
|
|
pt_debug(cd->dev, DL_DEBUG, "%s: Watchdog timer triggered\n",
|
|
__func__);
|
|
|
|
if (!work_pending(&cd->watchdog_work))
|
|
schedule_work(&cd->watchdog_work);
|
|
}
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/*******************************************************************************
|
|
* Core sysfs show and store functions
|
|
******************************************************************************/
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_hw_version_show
|
|
*
|
|
* SUMMARY: Gets the HW version for either PIP1.x or PIP2.x DUTS
|
|
* Output data format: [SiliconID].[RevID FamilyID].[PanelID]
|
|
*
|
|
* RETURN: size of data written to sysfs node
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* *attr - pointer to device attributes structure
|
|
* *buf - pointer to print output buffer
|
|
******************************************************************************/
|
|
static ssize_t pt_hw_version_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
|
|
_pt_request_hw_version(dev, cd->hw_version);
|
|
return snprintf(buf, PT_MAX_PRBUF_SIZE, "%s\n", cd->hw_version);
|
|
}
|
|
static DEVICE_ATTR(hw_version, 0444, pt_hw_version_show, NULL);
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_drv_version_show
|
|
*
|
|
* SUMMARY: Show method for the drv_version sysfs node that will show the
|
|
* TTDL version information
|
|
*
|
|
* RETURN: Char buffer with printed TTDL version information
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* *attr - pointer to device attributes
|
|
* *buf - pointer to output buffer
|
|
******************************************************************************/
|
|
static ssize_t pt_drv_version_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
return snprintf(buf, PT_MAX_PRBUF_SIZE,
|
|
"Driver: %s\nVersion: %s\nDate: %s\n",
|
|
pt_driver_core_name, pt_driver_core_version,
|
|
pt_driver_core_date);
|
|
}
|
|
static DEVICE_ATTR(drv_version, 0444, pt_drv_version_show, NULL);
|
|
static DEVICE_ATTR(drv_ver, 0444, pt_drv_version_show, NULL);
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_fw_version_show
|
|
*
|
|
* SUMMARY: Show method for the fw_version sysfs node that will
|
|
* show the firmware, bootloader and PIP version information
|
|
*
|
|
* RETURN: Size of printed buffer
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* *attr - pointer to device attributes
|
|
* *buf - pointer to output buffer
|
|
******************************************************************************/
|
|
static ssize_t pt_fw_version_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
struct pt_ttdata *ttdata;
|
|
int rc = 0;
|
|
|
|
if (cd->mode == PT_MODE_OPERATIONAL)
|
|
rc = pt_hid_output_get_sysinfo_(cd);
|
|
|
|
pt_debug(cd->dev, DL_INFO, "%s: mode = %d sysinfo.ready = %d\n",
|
|
__func__, cd->mode, cd->sysinfo.ready);
|
|
|
|
if (cd->sysinfo.ready)
|
|
ttdata = &cd->sysinfo.ttdata;
|
|
else
|
|
rc = -ENODATA;
|
|
|
|
if (!rc) {
|
|
return sprintf(buf,
|
|
"Status: %d\n"
|
|
"FW : %d.%d.%d\n"
|
|
"Config: %d\n"
|
|
"BL : %d.%d\n"
|
|
"PIP : %d.%d\n",
|
|
rc,
|
|
ttdata->fw_ver_major, ttdata->fw_ver_minor,
|
|
ttdata->revctrl,
|
|
ttdata->fw_ver_conf,
|
|
ttdata->bl_ver_major, ttdata->bl_ver_minor,
|
|
ttdata->pip_ver_major, ttdata->pip_ver_minor);
|
|
} else {
|
|
return sprintf(buf,
|
|
"Status: %d\n"
|
|
"FW : n/a\n"
|
|
"Config: n/a\n"
|
|
"BL : n/a\n"
|
|
"PIP : n/a\n",
|
|
rc);
|
|
}
|
|
}
|
|
static DEVICE_ATTR(fw_version, 0444, pt_fw_version_show, NULL);
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_sysinfo_show
|
|
*
|
|
* SUMMARY: Show method for the sysinfo sysfs node that will
|
|
* show all the infromation from get system information command.
|
|
*
|
|
* RETURN: Size of printed buffer
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* *attr - pointer to device attributes
|
|
* *buf - pointer to output buffer
|
|
******************************************************************************/
|
|
static ssize_t pt_sysinfo_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
struct pt_sysinfo *si;
|
|
struct pt_ttdata *ttdata = NULL;
|
|
struct pt_sensing_conf_data *scd = NULL;
|
|
int rc = 0;
|
|
|
|
if (cd->mode == PT_MODE_OPERATIONAL) {
|
|
rc = pt_hid_output_get_sysinfo_(cd);
|
|
if (cd->sysinfo.ready) {
|
|
si = &cd->sysinfo;
|
|
ttdata = &si->ttdata;
|
|
scd = &si->sensing_conf_data;
|
|
} else
|
|
rc = -ENODATA;
|
|
} else
|
|
rc = -EPERM;
|
|
|
|
pt_debug(cd->dev, DL_INFO, "%s: mode = %d sysinfo.ready = %d\n",
|
|
__func__, cd->mode, cd->sysinfo.ready);
|
|
|
|
if (!rc && ttdata && scd) {
|
|
return sprintf(buf,
|
|
"Status: %d\n"
|
|
"pip_ver_major: 0x%02X\n"
|
|
"pip_ver_minor: 0x%02X\n"
|
|
"fw_pid : 0x%04X\n"
|
|
"fw_ver_major : 0x%02X\n"
|
|
"fw_ver_minor : 0x%02X\n"
|
|
"revctrl : 0x%08X\n"
|
|
"fw_ver_conf : 0x%04X\n"
|
|
"bl_ver_major : 0x%02X\n"
|
|
"bl_ver_minor : 0x%02X\n"
|
|
"jtag_id_h : 0x%04X\n"
|
|
"jtag_id_l : 0x%04X\n"
|
|
"mfg_id[0] : 0x%02X\n"
|
|
"mfg_id[1] : 0x%02X\n"
|
|
"mfg_id[2] : 0x%02X\n"
|
|
"mfg_id[3] : 0x%02X\n"
|
|
"mfg_id[4] : 0x%02X\n"
|
|
"mfg_id[5] : 0x%02X\n"
|
|
"mfg_id[6] : 0x%02X\n"
|
|
"mfg_id[7] : 0x%02X\n"
|
|
"post_code : 0x%04X\n"
|
|
"electrodes_x : 0x%02X\n"
|
|
"electrodes_y : 0x%02X\n"
|
|
"len_x : 0x%04X\n"
|
|
"len_y : 0x%04X\n"
|
|
"res_x : 0x%04X\n"
|
|
"res_y : 0x%04X\n"
|
|
"max_z : 0x%04X\n"
|
|
"origin_x : 0x%02X\n"
|
|
"origin_y : 0x%02X\n"
|
|
"panel_id : 0x%02X\n"
|
|
"btn : 0x%02X\n"
|
|
"scan_mode : 0x%02X\n"
|
|
"max_num_of_tch_per_refresh_cycle: 0x%02X\n",
|
|
rc,
|
|
ttdata->pip_ver_major,
|
|
ttdata->pip_ver_minor,
|
|
ttdata->fw_pid,
|
|
ttdata->fw_ver_major,
|
|
ttdata->fw_ver_minor,
|
|
ttdata->revctrl,
|
|
ttdata->fw_ver_conf,
|
|
ttdata->bl_ver_major,
|
|
ttdata->bl_ver_minor,
|
|
ttdata->jtag_id_h,
|
|
ttdata->jtag_id_l,
|
|
ttdata->mfg_id[0],
|
|
ttdata->mfg_id[1],
|
|
ttdata->mfg_id[2],
|
|
ttdata->mfg_id[3],
|
|
ttdata->mfg_id[4],
|
|
ttdata->mfg_id[5],
|
|
ttdata->mfg_id[6],
|
|
ttdata->mfg_id[7],
|
|
ttdata->post_code,
|
|
scd->electrodes_x,
|
|
scd->electrodes_y,
|
|
scd->len_x,
|
|
scd->len_y,
|
|
scd->res_x,
|
|
scd->res_y,
|
|
scd->max_z,
|
|
scd->origin_x,
|
|
scd->origin_y,
|
|
scd->panel_id,
|
|
scd->btn,
|
|
scd->scan_mode,
|
|
scd->max_tch);
|
|
} else {
|
|
return sprintf(buf,
|
|
"Status: %d\n",
|
|
rc);
|
|
}
|
|
}
|
|
static DEVICE_ATTR(sysinfo, 0444, pt_sysinfo_show, NULL);
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_hw_reset_show
|
|
*
|
|
* SUMMARY: The show method for the hw_reset sysfs node that does a hw reset
|
|
* by toggling the XRES line and then calls the startup function to
|
|
* allow TTDL to re-enumerate the DUT.
|
|
* The printed value reflects the status of the full reset/enum.
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to Device structure
|
|
* *attr - pointer to the device attribute structure
|
|
* *buf - pointer to buffer to print
|
|
******************************************************************************/
|
|
static ssize_t pt_hw_reset_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
int rc = 0;
|
|
int time = 0;
|
|
u8 reset_status = 0;
|
|
int t;
|
|
struct pt_hid_desc hid_desc;
|
|
|
|
memset(&hid_desc, 0, sizeof(hid_desc));
|
|
|
|
/* Only allow DUT reset if no active BL in progress */
|
|
mutex_lock(&cd->firmware_class_lock);
|
|
|
|
mutex_lock(&cd->system_lock);
|
|
cd->startup_state = STARTUP_NONE;
|
|
mutex_unlock(&(cd->system_lock));
|
|
|
|
pt_stop_wd_timer(cd);
|
|
|
|
/* ensure no left over exclusive access is still locked */
|
|
release_exclusive(cd, cd->dev);
|
|
|
|
rc = pt_dut_reset(cd, PT_CORE_CMD_PROTECTED);
|
|
if (rc) {
|
|
mutex_unlock(&cd->firmware_class_lock);
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: HW reset failed rc = %d\n", __func__, rc);
|
|
goto exit_hw_reset;
|
|
}
|
|
reset_status |= 0x01 << 0;
|
|
|
|
if (cd->flashless_dut) {
|
|
mutex_unlock(&cd->firmware_class_lock);
|
|
|
|
t = wait_event_timeout(cd->wait_q, (cd->fw_updating == true),
|
|
msecs_to_jiffies(200));
|
|
if (IS_TMO(t)) {
|
|
pt_debug(dev, DL_WARN,
|
|
"%s: Timeout waiting for FW update",
|
|
__func__);
|
|
rc = -ETIME;
|
|
goto exit_hw_reset;
|
|
} else {
|
|
pt_debug(dev, DL_INFO,
|
|
"%s: ----- Wait FW Loading ----",
|
|
__func__);
|
|
rc = _pt_request_wait_for_enum_state(
|
|
dev, 4000, STARTUP_STATUS_FW_RESET_SENTINEL);
|
|
if (rc) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: No FW Sentinel detected rc = %d\n",
|
|
__func__, rc);
|
|
goto exit_hw_reset;
|
|
}
|
|
reset_status |= 0x01 << 1;
|
|
}
|
|
} else {
|
|
/* Wait for any sentinel */
|
|
rc = _pt_request_wait_for_enum_state(dev, 150,
|
|
STARTUP_STATUS_BL_RESET_SENTINEL |
|
|
STARTUP_STATUS_FW_RESET_SENTINEL);
|
|
if (rc) {
|
|
mutex_unlock(&cd->firmware_class_lock);
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: No Sentinel detected rc = %d\n",
|
|
__func__, rc);
|
|
goto exit_hw_reset;
|
|
}
|
|
|
|
/* sleep needed to ensure no cmd is sent while DUT will NAK */
|
|
msleep(30);
|
|
|
|
if (cd->active_dut_generation == DUT_PIP1_ONLY) {
|
|
rc = pt_get_hid_descriptor_(cd, &hid_desc);
|
|
if (rc < 0) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: Error on getting HID descriptor r=%d\n",
|
|
__func__, rc);
|
|
goto exit_hw_reset;
|
|
}
|
|
|
|
cd->mode = pt_get_mode(cd, &hid_desc);
|
|
if (cd->mode == PT_MODE_BOOTLOADER)
|
|
rc = pt_hid_output_bl_launch_app_(cd);
|
|
} else {
|
|
if (cd->mode == PT_MODE_BOOTLOADER)
|
|
rc = pt_pip2_launch_app(dev,
|
|
PT_CORE_CMD_UNPROTECTED);
|
|
}
|
|
|
|
if (rc) {
|
|
mutex_unlock(&cd->firmware_class_lock);
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: PIP launch app failed rc = %d\n",
|
|
__func__, rc);
|
|
goto exit_hw_reset;
|
|
}
|
|
mutex_unlock(&cd->firmware_class_lock);
|
|
|
|
reset_status |= 0x01 << 1;
|
|
msleep(20);
|
|
if ((cd->active_dut_generation == DUT_UNKNOWN) ||
|
|
(cd->mode != PT_MODE_OPERATIONAL))
|
|
pt_queue_restart(cd);
|
|
else
|
|
pt_queue_enum(cd);
|
|
}
|
|
|
|
while (!(cd->startup_status & STARTUP_STATUS_COMPLETE) && time < 2000) {
|
|
msleep(50);
|
|
pt_debug(cd->dev, DL_INFO,
|
|
"%s: wait %dms for 0x%04X, current enum=0x%04X\n",
|
|
__func__, time, STARTUP_STATUS_COMPLETE,
|
|
cd->startup_status);
|
|
time += 50;
|
|
}
|
|
if (!(cd->startup_status & STARTUP_STATUS_COMPLETE)) {
|
|
rc = -ETIME;
|
|
goto exit_hw_reset;
|
|
}
|
|
|
|
pt_debug(cd->dev, DL_INFO, "%s: HW Reset complete. enum=0x%04X\n",
|
|
__func__, cd->startup_status);
|
|
reset_status |= 0x01 << 2;
|
|
pt_start_wd_timer(cd);
|
|
|
|
exit_hw_reset:
|
|
return sprintf(buf,
|
|
"Status: %d\n"
|
|
"Reset Status: 0x%02X\n", rc, reset_status);
|
|
}
|
|
static DEVICE_ATTR(hw_reset, 0444, pt_hw_reset_show, NULL);
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_pip2_cmd_rsp_store
|
|
*
|
|
* SUMMARY: This is the store method for the raw PIP2 cmd/rsp sysfs node. Any
|
|
* raw PIP2 command echo'd to this node will be sent directly to the DUT.
|
|
* Command byte order:
|
|
* Byte [0] - PIP2 command ID
|
|
* Byte [1-n] - PIP2 command payload
|
|
*
|
|
* RETURN: Size of passed in buffer
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* *attr - pointer to device attributes
|
|
* *buf - pointer to buffer that hold the command parameters
|
|
* size - size of buf
|
|
******************************************************************************/
|
|
static ssize_t pt_pip2_cmd_rsp_store(struct device *dev,
|
|
struct device_attribute *attr, const char *buf, size_t size)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
u16 actual_read_len;
|
|
u8 input_data[PT_MAX_PIP2_MSG_SIZE + 1];
|
|
u8 read_buf[PT_MAX_PIP2_MSG_SIZE + 1];
|
|
u8 pip2_cmd_id = 0x00;
|
|
u8 *pip2_cmd_data = NULL;
|
|
int data_len = 0;
|
|
int length;
|
|
int rc = 0;
|
|
|
|
/* clear shared data */
|
|
mutex_lock(&cd->sysfs_lock);
|
|
cd->raw_cmd_status = 0;
|
|
cd->cmd_rsp_buf_len = 0;
|
|
memset(cd->cmd_rsp_buf, 0, sizeof(cd->cmd_rsp_buf));
|
|
mutex_unlock(&cd->sysfs_lock);
|
|
|
|
length = _pt_ic_parse_input_hex(dev, buf, size,
|
|
input_data, PT_MAX_PIP2_MSG_SIZE);
|
|
if (length <= 0 || length > PT_MAX_PIP2_MSG_SIZE) {
|
|
pt_debug(dev, DL_WARN, "%s: Invalid number of arguments\n",
|
|
__func__);
|
|
rc = -EINVAL;
|
|
goto exit;
|
|
}
|
|
|
|
/* Send PIP2 command if enough data was provided */
|
|
if (length >= 1) {
|
|
pip2_cmd_id = input_data[0];
|
|
pip2_cmd_data = &input_data[1];
|
|
data_len = length - 1;
|
|
rc = _pt_request_pip2_send_cmd(dev, PT_CORE_CMD_PROTECTED,
|
|
pip2_cmd_id, pip2_cmd_data, data_len,
|
|
read_buf, &actual_read_len);
|
|
cd->raw_cmd_status = rc;
|
|
if (rc) {
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s: PIP2 cmd 0x%02x failed rc = %d\n",
|
|
__func__, pip2_cmd_id, rc);
|
|
goto exit;
|
|
} else {
|
|
cd->cmd_rsp_buf_len = actual_read_len;
|
|
memcpy(cd->cmd_rsp_buf, read_buf, actual_read_len);
|
|
pt_debug(dev, DL_WARN,
|
|
"%s: PIP2 actual_read_len = %d\n",
|
|
__func__, actual_read_len);
|
|
}
|
|
} else {
|
|
rc = -EINVAL;
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s: Insufficent data provided for PIP2 cmd\n",
|
|
__func__);
|
|
}
|
|
|
|
exit:
|
|
if (rc)
|
|
return rc;
|
|
return size;
|
|
}
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_pip2_cmd_rsp_show
|
|
*
|
|
* SUMMARY: The show method for the raw pip2_cmd_rsp sysfs node. Any PIP2
|
|
* response generated after using the store method of the pip2_cmd_rsp
|
|
* sysfs node, are available to be read here.
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to Device structure
|
|
* *attr - pointer to the device attribute structure
|
|
* *buf - pointer to buffer to print
|
|
******************************************************************************/
|
|
static ssize_t pt_pip2_cmd_rsp_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
int i;
|
|
ssize_t data_len;
|
|
int index;
|
|
|
|
mutex_lock(&cd->sysfs_lock);
|
|
index = scnprintf(buf, PT_MAX_PRBUF_SIZE,
|
|
"Status: %d\n", cd->raw_cmd_status);
|
|
if (cd->raw_cmd_status)
|
|
goto error;
|
|
|
|
/* Remove the CRC from the length of the response */
|
|
data_len = cd->cmd_rsp_buf_len - 2;
|
|
|
|
/* Start printing from the data payload */
|
|
for (i = PIP1_RESP_COMMAND_ID_OFFSET; i < data_len; i++)
|
|
index += scnprintf(buf + index, PT_MAX_PRBUF_SIZE - index,
|
|
"%02X ", cd->cmd_rsp_buf[i]);
|
|
|
|
if (data_len >= PIP1_RESP_COMMAND_ID_OFFSET) {
|
|
index += scnprintf(buf + index, PT_MAX_PRBUF_SIZE - index,
|
|
"\n(%zd bytes)\n",
|
|
data_len - PIP1_RESP_COMMAND_ID_OFFSET);
|
|
} else {
|
|
index += scnprintf(buf + index, PT_MAX_PRBUF_SIZE - index,
|
|
"\n(%zd bytes)\n", 0);
|
|
}
|
|
|
|
error:
|
|
mutex_unlock(&cd->sysfs_lock);
|
|
return index;
|
|
}
|
|
static DEVICE_ATTR(pip2_cmd_rsp, 0644, pt_pip2_cmd_rsp_show,
|
|
pt_pip2_cmd_rsp_store);
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_command_store
|
|
*
|
|
* SUMMARY: This is the store method for the raw PIP command sysfs node. Any
|
|
* raw PIP command echo'd to this node will be sent directly to the DUT.
|
|
* TTDL will not parse the command.
|
|
*
|
|
* RETURN: Size of passed in buffer
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* *attr - pointer to device attributes
|
|
* *buf - pointer to buffer that hold the command parameters
|
|
* size - size of buf
|
|
******************************************************************************/
|
|
static ssize_t pt_command_store(struct device *dev,
|
|
struct device_attribute *attr, const char *buf, size_t size)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
unsigned short crc;
|
|
u16 actual_read_len;
|
|
u8 input_data[PT_MAX_PIP2_MSG_SIZE + 1];
|
|
int length;
|
|
int len_field;
|
|
int rc = 0;
|
|
|
|
mutex_lock(&cd->sysfs_lock);
|
|
cd->cmd_rsp_buf_len = 0;
|
|
memset(cd->cmd_rsp_buf, 0, sizeof(cd->cmd_rsp_buf));
|
|
mutex_unlock(&cd->sysfs_lock);
|
|
|
|
length = _pt_ic_parse_input_hex(dev, buf, size,
|
|
input_data, PT_MAX_PIP2_MSG_SIZE);
|
|
if (length <= 0 || length > PT_MAX_PIP2_MSG_SIZE) {
|
|
pt_debug(dev, DL_WARN, "%s: Invalid number of arguments\n",
|
|
__func__);
|
|
rc = -EINVAL;
|
|
goto pt_command_store_exit;
|
|
}
|
|
|
|
/* PIP2 messages begin with 01 01 */
|
|
if (length >= 2 && input_data[0] == 0x01 && input_data[1] == 0x01) {
|
|
cd->pip2_prot_active = 1;
|
|
/* Override next seq tag with what was sent */
|
|
cd->pip2_cmd_tag_seq = input_data[4] & 0x0F;
|
|
/* For PIP2 cmd if length does not include crc, add it */
|
|
len_field = (input_data[3] << 8) | input_data[2];
|
|
if (len_field == length && length <= 254) {
|
|
crc = crc_ccitt_calculate(&input_data[2],
|
|
length - 2);
|
|
pt_debug(dev, DL_WARN, "%s: len=%d crc=0x%02X\n",
|
|
__func__, length, crc);
|
|
input_data[length] = (crc & 0xFF00) >> 8;
|
|
input_data[length + 1] = crc & 0x00FF;
|
|
length = length + 2;
|
|
}
|
|
}
|
|
|
|
/* write PIP command to log */
|
|
pt_pr_buf(dev, DL_INFO, input_data, length, "command_buf");
|
|
|
|
pm_runtime_get_sync(dev);
|
|
|
|
rc = pt_hid_output_user_cmd(cd, PT_MAX_INPUT, cd->cmd_rsp_buf,
|
|
length, input_data, &actual_read_len);
|
|
pm_runtime_put(dev);
|
|
|
|
mutex_lock(&cd->sysfs_lock);
|
|
cd->raw_cmd_status = rc;
|
|
if (rc) {
|
|
cd->cmd_rsp_buf_len = 0;
|
|
pt_debug(dev, DL_ERROR, "%s: Failed to send command: %s\n",
|
|
__func__, buf);
|
|
} else {
|
|
cd->cmd_rsp_buf_len = actual_read_len;
|
|
}
|
|
cd->pip2_prot_active = 0;
|
|
mutex_unlock(&cd->sysfs_lock);
|
|
|
|
pt_command_store_exit:
|
|
if (rc)
|
|
return rc;
|
|
return size;
|
|
}
|
|
static DEVICE_ATTR(command, 0220, NULL, pt_command_store);
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_response_show
|
|
*
|
|
* SUMMARY: The show method for the raw PIP response sysfs node. Any PIP
|
|
* response generated after using the pt_command_store sysfs node, are
|
|
* available to be read here.
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to Device structure
|
|
* *attr - pointer to the device attribute structure
|
|
* *buf - pointer to buffer to print
|
|
******************************************************************************/
|
|
static ssize_t pt_response_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
int i;
|
|
ssize_t num_read;
|
|
int index;
|
|
|
|
mutex_lock(&cd->sysfs_lock);
|
|
index = scnprintf(buf, PT_MAX_PRBUF_SIZE,
|
|
"Status: %d\n", cd->raw_cmd_status);
|
|
if (cd->raw_cmd_status)
|
|
goto error;
|
|
|
|
num_read = cd->cmd_rsp_buf_len;
|
|
for (i = 0; i < num_read; i++)
|
|
index += scnprintf(buf + index, PT_MAX_PRBUF_SIZE - index,
|
|
"0x%02X\n", cd->cmd_rsp_buf[i]);
|
|
|
|
index += scnprintf(buf + index, PT_MAX_PRBUF_SIZE - index,
|
|
"(%zd bytes)\n", num_read);
|
|
|
|
error:
|
|
mutex_unlock(&cd->sysfs_lock);
|
|
return index;
|
|
}
|
|
static DEVICE_ATTR(response, 0444, pt_response_show, NULL);
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_dut_debug_show
|
|
*
|
|
* SUMMARY: Show method for the dut_debug sysfs node. Shows what parameters
|
|
* are available for the store method.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* *attr - pointer to device attributes
|
|
* *buf - pointer to output buffer
|
|
******************************************************************************/
|
|
static ssize_t pt_dut_debug_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
ssize_t ret;
|
|
|
|
ret = sprintf(buf,
|
|
"Status: 0\n"
|
|
"dut_debug sends the following commands to the DUT:\n"
|
|
"%d %s \t- %s\n"
|
|
"%d %s \t- %s\n"
|
|
"%d %s \t- %s\n"
|
|
"%d %s \t- %s\n"
|
|
"%d %s \t- %s\n"
|
|
"%d %s \t- %s\n"
|
|
"%d %s \t- %s\n"
|
|
"%d %s \t- %s\n"
|
|
"%d %s \t- %s\n"
|
|
"%d %s \t- %s\n"
|
|
"%d %s \t- %s\n"
|
|
"%d %s \t- %s\n"
|
|
"%d %s \t- %s\n"
|
|
"%d %s \t- %s\n"
|
|
"%d %s \t- %s\n"
|
|
"%d %s \t- %s\n"
|
|
"%d %s \t- %s\n"
|
|
,
|
|
PIP1_BL_CMD_ID_VERIFY_APP_INTEGRITY, "", "BL Verify APP",
|
|
PT_DUT_DBG_HID_RESET, "", "HID Reset",
|
|
PT_DUT_DBG_HID_SET_POWER_ON, "", "HID SET_POWER ON",
|
|
PT_DUT_DBG_HID_SET_POWER_SLEEP, "", "HID SET_POWER SLEEP",
|
|
PT_DUT_DBG_HID_SET_POWER_STANDBY, "", "HID SET_POWER STANDBY",
|
|
PIP1_BL_CMD_ID_GET_INFO, "", "BL Get Info",
|
|
PIP1_BL_CMD_ID_PROGRAM_AND_VERIFY, "", "BL Program & Verify",
|
|
PIP1_BL_CMD_ID_LAUNCH_APP, "", "BL Launch APP",
|
|
PIP1_BL_CMD_ID_INITIATE_BL, "", "BL Initiate BL",
|
|
PT_DUT_DBG_PIP_SOFT_RESET, "", "PIP Soft Reset",
|
|
PT_DUT_DBG_RESET, "", "Toggle the TP_XRES GPIO",
|
|
PT_DUT_DBG_PIP_NULL, "", "PIP NULL (PING)",
|
|
PT_DUT_DBG_PIP_ENTER_BL, "", "PIP enter BL",
|
|
PT_DUT_DBG_HID_SYSINFO, "", "HID system info",
|
|
PT_DUT_DBG_PIP_SUSPEND_SCAN, "", "Suspend Scan",
|
|
PT_DUT_DBG_PIP_RESUME_SCAN, "", "Resume Scan",
|
|
PT_DUT_DBG_HID_DESC, "", "Get HID Desc"
|
|
);
|
|
|
|
return ret;
|
|
}
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_drv_debug_show
|
|
*
|
|
* SUMMARY: Show method for the drv_debug sysfs node. Shows what parameters
|
|
* are available for the store method.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* *attr - pointer to device attributes
|
|
* *buf - pointer to output buffer
|
|
******************************************************************************/
|
|
static ssize_t pt_drv_debug_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
ssize_t ret;
|
|
|
|
ret = sprintf(buf,
|
|
"Status: 0\n"
|
|
"drv_debug supports the following values:\n"
|
|
"%d %s \t- %s\n"
|
|
"%d %s \t- %s\n"
|
|
"%d %s \t- %s\n"
|
|
"%d %s \t- %s\n"
|
|
"%d %s \t- %s\n"
|
|
"%d %s \t- %s\n"
|
|
"%d %s \t- %s\n"
|
|
"%d %s \t- %s\n"
|
|
"%d %s \t- %s\n"
|
|
"%d %s - %s\n"
|
|
"%d %s \t- %s\n"
|
|
"%d %s \t- %s\n"
|
|
#ifdef TTDL_DIAGNOSTICS
|
|
"%d %s \t- %s\n"
|
|
"%d %s \t- %s\n"
|
|
"%d %s \t- %s\n"
|
|
#endif /* TTDL_DIAGNOSTICS */
|
|
"%d %s \t- %s\n"
|
|
#ifdef TTDL_DIAGNOSTICS
|
|
"%d %s \t- %s\n"
|
|
"%d %s \t- %s\n"
|
|
"%d %s \t- %s\n"
|
|
"%d %s \t- %s\n"
|
|
"%d %s \t- %s\n"
|
|
"%d %s \t- %s\n"
|
|
"%d %s \t- %s\n"
|
|
"%d %s \t- %s\n"
|
|
"%d %s \t- %s\n"
|
|
#endif /* TTDL_DIAGNOSTICS */
|
|
,
|
|
PT_DRV_DBG_SUSPEND, " ", "Suspend TTDL responding to INT",
|
|
PT_DRV_DBG_RESUME, " ", "Resume TTDL responding to INT",
|
|
PT_DRV_DBG_STOP_WD, " ", "Stop TTDL WD",
|
|
PT_DRV_DBG_START_WD, " ", "Start TTDL WD",
|
|
PT_DRV_DBG_TTHE_TUNER_EXIT, " ", "Exit TTHE Tuner Logging",
|
|
PT_DRV_DBG_TTHE_BUF_CLEAN, " ", "Clear TTHE Tuner buffer",
|
|
PT_DRV_DBG_CLEAR_PARM_LIST, " ", "Clear RAM Param list",
|
|
PT_DRV_DBG_FORCE_BUS_READ, " ", "Force bus read",
|
|
PT_DRV_DBG_CLEAR_CAL_DATA, " ", "Clear CAL Cache",
|
|
PT_DRV_DBG_REPORT_LEVEL, "[0|1|2|3|4]", "Set TTDL Debug Level",
|
|
PT_DRV_DBG_WATCHDOG_INTERVAL, "[n] ", "TTDL WD Interval in ms",
|
|
PT_DRV_DBG_SHOW_TIMESTAMP, "[0|1]", "Show Timestamps"
|
|
#ifdef TTDL_DIAGNOSTICS
|
|
, PT_DRV_DBG_SETUP_PWR, "[0|1]", "Power DUT up/down",
|
|
PT_DRV_DBG_GET_PUT_SYNC, "[0|1]", "Get/Put Linux Sleep",
|
|
PT_DRV_DBG_SET_TT_DATA, "[0|1]", "Display TT_DATA"
|
|
#endif /* TTDL_DIAGNOSTICS */
|
|
, PT_DRV_DBG_SET_GENERATION, "[0|1|2]", "Set DUT generation"
|
|
#ifdef TTDL_DIAGNOSTICS
|
|
, PT_DRV_DBG_SET_BRIDGE_MODE, "[0|1]", "On/Off Bridge Mode",
|
|
PT_DRV_DBG_SET_I2C_ADDRESS, "[0-127]", "I2C DUT Address",
|
|
PT_DRV_DBG_SET_FLASHLESS_DUT, "[0|1]", "Flashless DUT yes/no",
|
|
PT_DRV_DBG_SET_FORCE_SEQ, "[8-15]", "Force PIP2 Sequence #",
|
|
PT_DRV_DBG_BL_WITH_NO_INT, "[0|1]", "BL with no INT",
|
|
PT_DRV_DBG_CAL_CACHE_IN_HOST, "[0|1]", "CAL Cache in host",
|
|
PT_DRV_DBG_MULTI_CHIP, "[0|1]", "Multi Chip Support",
|
|
PT_DRV_DBG_PIP_TIMEOUT, "[100-7000]", "PIP Resp Timeout (ms)",
|
|
PT_DRV_DBG_TTHE_HID_USB_FORMAT, "[0|1]",
|
|
"TTHE_TUNER HID USB Format"
|
|
#endif /* TTDL_DIAGNOSTICS */
|
|
);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_drv_debug_store
|
|
*
|
|
* SUMMARY: Currently the store method for both sysfs nodes: drv_debug and
|
|
* dut_debug. Drv_debug will contain all functionality that can be run
|
|
* without a DUT preset and is available anytime TTDL is running.
|
|
* Dut_debug requires a DUT to be available and will only be created after
|
|
* a DUT has been detected.
|
|
* This function will eventually be split into two but until the overlap
|
|
* has been depricated this function contains all commands that can be
|
|
* used for TTDL/DUT debugging status and control.
|
|
* All commands require at least one value to be passed in *buf with some
|
|
* requiring two.
|
|
*
|
|
* RETURN: Size of passed in buffer
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* *attr - pointer to device attributes
|
|
* *buf - pointer to buffer that hold the command parameters
|
|
* size - size of buf
|
|
******************************************************************************/
|
|
static ssize_t pt_drv_debug_store(struct device *dev,
|
|
struct device_attribute *attr, const char *buf, size_t size)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
unsigned long value;
|
|
int rc = 0;
|
|
u8 return_data[8];
|
|
static u8 wd_disabled;
|
|
u32 input_data[3];
|
|
int length;
|
|
#ifdef TTDL_DIAGNOSTICS
|
|
struct i2c_client *client = to_i2c_client(dev);
|
|
unsigned short crc = 0;
|
|
u16 cal_size;
|
|
#endif
|
|
|
|
input_data[0] = 0;
|
|
input_data[1] = 0;
|
|
|
|
/* Maximmum input is two elements */
|
|
length = _pt_ic_parse_input(dev, buf, size,
|
|
input_data, ARRAY_SIZE(input_data));
|
|
if (length < 1 || length > 2) {
|
|
pt_debug(dev, DL_WARN, "%s: Invalid number of arguments\n",
|
|
__func__);
|
|
rc = -EINVAL;
|
|
goto pt_drv_debug_store_exit;
|
|
}
|
|
value = input_data[0];
|
|
|
|
if (length == 1) {
|
|
pt_debug(dev, DL_DEBUG,
|
|
"%s: Debug Cmd Recieved (id=%d)\n",
|
|
__func__, input_data[0]);
|
|
} else if (length == 2) {
|
|
pt_debug(dev, DL_DEBUG,
|
|
"%s: Debug Cmd Recieved (id=%d, data=%d)\n",
|
|
__func__, input_data[0], input_data[1]);
|
|
} else {
|
|
pt_debug(dev, DL_DEBUG,
|
|
"%s: Invalid arguments recieved\n", __func__);
|
|
rc = -EINVAL;
|
|
goto pt_drv_debug_store_exit;
|
|
}
|
|
|
|
/* Start watchdog timer command */
|
|
if (value == PT_DRV_DBG_START_WD) {
|
|
pt_debug(dev, DL_INFO, "%s: Cmd: Start Watchdog\n", __func__);
|
|
wd_disabled = 0;
|
|
cd->watchdog_force_stop = false;
|
|
pt_start_wd_timer(cd);
|
|
goto pt_drv_debug_store_exit;
|
|
}
|
|
|
|
/* Stop watchdog timer temporarily */
|
|
pt_stop_wd_timer(cd);
|
|
|
|
if (value == PT_DRV_DBG_STOP_WD) {
|
|
pt_debug(dev, DL_INFO, "%s: Cmd: Stop Watchdog\n", __func__);
|
|
wd_disabled = 1;
|
|
cd->watchdog_force_stop = true;
|
|
goto pt_drv_debug_store_exit;
|
|
}
|
|
|
|
switch (value) {
|
|
case PT_DRV_DBG_SUSPEND: /* 4 */
|
|
pt_debug(dev, DL_INFO, "%s: TTDL: Core Sleep\n", __func__);
|
|
wd_disabled = 1;
|
|
rc = pt_core_sleep(cd);
|
|
if (rc)
|
|
pt_debug(dev, DL_ERROR, "%s: Suspend failed rc=%d\n",
|
|
__func__, rc);
|
|
else
|
|
pt_debug(dev, DL_INFO, "%s: Suspend succeeded\n",
|
|
__func__);
|
|
break;
|
|
|
|
case PT_DRV_DBG_RESUME: /* 5 */
|
|
pt_debug(dev, DL_INFO, "%s: TTDL: Wake\n", __func__);
|
|
rc = pt_core_wake(cd);
|
|
if (rc)
|
|
pt_debug(dev, DL_ERROR, "%s: Resume failed rc=%d\n",
|
|
__func__, rc);
|
|
else
|
|
pt_debug(dev, DL_INFO, "%s: Resume succeeded\n",
|
|
__func__);
|
|
break;
|
|
case PIP1_BL_CMD_ID_VERIFY_APP_INTEGRITY: /* BL - 49 */
|
|
pt_debug(dev, DL_INFO, "%s: Cmd: verify app integ\n", __func__);
|
|
pt_hid_output_bl_verify_app_integrity(cd, &return_data[0]);
|
|
break;
|
|
case PT_DUT_DBG_HID_RESET: /* 50 */
|
|
pt_debug(dev, DL_INFO, "%s: Cmd: hid_reset\n", __func__);
|
|
pt_hid_cmd_reset(cd);
|
|
break;
|
|
case PT_DUT_DBG_HID_SET_POWER_ON: /* 53 */
|
|
pt_debug(dev, DL_INFO, "%s: Cmd: hid_set_power_on\n", __func__);
|
|
pt_hid_cmd_set_power(cd, HID_POWER_ON);
|
|
wd_disabled = 0;
|
|
break;
|
|
case PT_DUT_DBG_HID_SET_POWER_SLEEP: /* 54 */
|
|
pt_debug(dev, DL_INFO, "%s: Cmd: hid_set_power_off\n",
|
|
__func__);
|
|
wd_disabled = 1;
|
|
pt_hid_cmd_set_power(cd, HID_POWER_SLEEP);
|
|
break;
|
|
case PT_DUT_DBG_HID_SET_POWER_STANDBY: /* 55 */
|
|
pt_debug(dev, DL_INFO, "%s: Cmd: hid_set_power_standby\n",
|
|
__func__);
|
|
wd_disabled = 1;
|
|
pt_hid_cmd_set_power(cd, HID_POWER_STANDBY);
|
|
break;
|
|
case PIP1_BL_CMD_ID_GET_INFO: /* BL - 56 */
|
|
pt_debug(dev, DL_INFO, "%s: Cmd: bl get info\n", __func__);
|
|
pt_hid_output_bl_get_information(cd, return_data);
|
|
break;
|
|
case PIP1_BL_CMD_ID_PROGRAM_AND_VERIFY: /* BL - 57 */
|
|
pt_debug(dev, DL_INFO, "%s: Cmd: program and verify\n",
|
|
__func__);
|
|
pt_hid_output_bl_program_and_verify(cd, 0, NULL);
|
|
break;
|
|
case PIP1_BL_CMD_ID_LAUNCH_APP: /* BL - 59 */
|
|
pt_debug(dev, DL_INFO, "%s: Cmd: launch app\n", __func__);
|
|
pt_hid_output_bl_launch_app(cd);
|
|
break;
|
|
case PIP1_BL_CMD_ID_INITIATE_BL: /* BL - 72 */
|
|
pt_debug(dev, DL_INFO, "%s: Cmd: initiate bl\n", __func__);
|
|
pt_hid_output_bl_initiate_bl(cd, 0, NULL, 0, NULL);
|
|
break;
|
|
case PT_DUT_DBG_PIP_SOFT_RESET: /* 97 */
|
|
pt_debug(dev, DL_INFO, "%s: Cmd: Soft Reset\n", __func__);
|
|
rc = pt_hw_soft_reset(cd, PT_CORE_CMD_PROTECTED);
|
|
break;
|
|
case PT_DUT_DBG_RESET: /* 98 */
|
|
pt_debug(dev, DL_INFO, "%s: Cmd: Hard Reset\n", __func__);
|
|
rc = pt_hw_hard_reset(cd);
|
|
break;
|
|
case PT_DUT_DBG_PIP_NULL: /* 100 */
|
|
pt_debug(dev, DL_INFO, "%s: Cmd: Ping (null)\n", __func__);
|
|
pt_pip_null(cd);
|
|
break;
|
|
case PT_DUT_DBG_PIP_ENTER_BL: /* 101 */
|
|
pt_debug(dev, DL_INFO, "%s: Cmd: start_bootloader\n", __func__);
|
|
rc = pt_pip_start_bootloader(cd);
|
|
if (!rc) {
|
|
cd->startup_status = STARTUP_STATUS_BL_RESET_SENTINEL;
|
|
cd->mode = PT_MODE_BOOTLOADER;
|
|
}
|
|
break;
|
|
case PT_DUT_DBG_HID_SYSINFO: /* 102 */
|
|
pt_debug(dev, DL_INFO, "%s: Cmd: get_sysinfo\n", __func__);
|
|
pt_hid_output_get_sysinfo(cd);
|
|
break;
|
|
case PT_DUT_DBG_PIP_SUSPEND_SCAN: /* 103 */
|
|
pt_debug(dev, DL_INFO, "%s: Cmd: suspend_scanning\n", __func__);
|
|
pt_pip_suspend_scanning(cd);
|
|
break;
|
|
case PT_DUT_DBG_PIP_RESUME_SCAN: /* 104 */
|
|
pt_debug(dev, DL_INFO, "%s: Cmd: resume_scanning\n", __func__);
|
|
pt_pip_resume_scanning(cd);
|
|
break;
|
|
#ifdef TTHE_TUNER_SUPPORT
|
|
case PT_DRV_DBG_TTHE_TUNER_EXIT: /* 107 */
|
|
cd->tthe_exit = 1;
|
|
wake_up(&cd->wait_q);
|
|
kfree(cd->tthe_buf);
|
|
cd->tthe_buf = NULL;
|
|
cd->tthe_exit = 0;
|
|
break;
|
|
case PT_DRV_DBG_TTHE_BUF_CLEAN: /* 108 */
|
|
if (cd->tthe_buf)
|
|
memset(cd->tthe_buf, 0, PT_MAX_PRBUF_SIZE);
|
|
else
|
|
pt_debug(dev, DL_INFO, "%s : tthe_buf not existed\n",
|
|
__func__);
|
|
break;
|
|
#endif
|
|
#ifdef TTDL_DIAGNOSTICS
|
|
case PT_DUT_DBG_HID_DESC: /* 109 */
|
|
pt_debug(dev, DL_INFO, "%s: Cmd: get_hid_desc\n", __func__);
|
|
pt_get_hid_descriptor(cd, &cd->hid_desc);
|
|
break;
|
|
case PT_DRV_DBG_CLEAR_PARM_LIST: /* 110 */
|
|
pt_debug(dev, DL_INFO, "%s: TTDL: Clear Parameter List\n",
|
|
__func__);
|
|
pt_erase_parameter_list(cd);
|
|
break;
|
|
case PT_DRV_DBG_FORCE_BUS_READ: /* 111 */
|
|
rc = pt_read_input(cd);
|
|
if (!rc)
|
|
pt_parse_input(cd);
|
|
break;
|
|
case PT_DRV_DBG_CLEAR_CAL_DATA: /* 112 */
|
|
rc = _pt_manage_local_cal_data(dev, PT_CAL_DATA_CLEAR,
|
|
&cal_size, &crc);
|
|
if (rc)
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s: CAL Data clear failed rc=%d\n",
|
|
__func__, rc);
|
|
else
|
|
pt_debug(dev, DL_INFO,
|
|
"%s: CAL Cleared, Chip ID=0x%04X size=%d\n",
|
|
__func__, crc, size);
|
|
break;
|
|
|
|
case PT_DRV_DBG_REPORT_LEVEL: /* 200 */
|
|
mutex_lock(&cd->system_lock);
|
|
if (input_data[1] >= 0 && input_data[1] < DL_MAX) {
|
|
cd->debug_level = input_data[1];
|
|
pt_debug(dev, DL_INFO, "%s: Set debug_level: %d\n",
|
|
__func__, cd->debug_level);
|
|
} else {
|
|
rc = -EINVAL;
|
|
pt_debug(dev, DL_ERROR, "%s: Invalid debug_level: %d\n",
|
|
__func__, input_data[1]);
|
|
}
|
|
mutex_unlock(&(cd->system_lock));
|
|
break;
|
|
#endif
|
|
case PT_DRV_DBG_WATCHDOG_INTERVAL: /* 201 */
|
|
mutex_lock(&cd->system_lock);
|
|
if (input_data[1] > 100) {
|
|
cd->watchdog_interval = input_data[1];
|
|
pt_debug(dev, DL_INFO,
|
|
"%s: Set watchdog_ interval to: %d\n",
|
|
__func__, cd->watchdog_interval);
|
|
pt_start_wd_timer(cd);
|
|
} else {
|
|
rc = -EINVAL;
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s: Invalid watchdog interval: %d\n",
|
|
__func__, input_data[1]);
|
|
}
|
|
mutex_unlock(&(cd->system_lock));
|
|
break;
|
|
#ifdef TTDL_DIAGNOSTICS
|
|
case PT_DRV_DBG_SHOW_TIMESTAMP: /* 202 */
|
|
mutex_lock(&cd->system_lock);
|
|
if (input_data[1] == 0) {
|
|
cd->show_timestamp = 0;
|
|
pt_debug(dev, DL_INFO, "%s: Disable show_timestamp\n",
|
|
__func__);
|
|
} else if (input_data[1] == 1) {
|
|
cd->show_timestamp = 1;
|
|
pt_debug(dev, DL_INFO, "%s: Enable show_timestamp\n",
|
|
__func__);
|
|
} else {
|
|
rc = -EINVAL;
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s: Invalid parameter: %d\n",
|
|
__func__, input_data[1]);
|
|
}
|
|
mutex_unlock(&(cd->system_lock));
|
|
break;
|
|
case PT_DRV_DBG_SETUP_PWR: /* 205 */
|
|
if (input_data[1] == 0) {
|
|
cd->cpdata->setup_power(cd->cpdata,
|
|
PT_MT_POWER_OFF, cd->dev);
|
|
pt_debug(dev, DL_INFO,
|
|
"%s: Initiate Power Off\n", __func__);
|
|
} else if (input_data[1] == 1) {
|
|
cd->cpdata->setup_power(cd->cpdata,
|
|
PT_MT_POWER_ON, cd->dev);
|
|
pt_debug(dev, DL_INFO,
|
|
"%s: Initiate Power On\n", __func__);
|
|
} else {
|
|
rc = -EINVAL;
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s: Invalid parameter: %d\n",
|
|
__func__, input_data[1]);
|
|
}
|
|
break;
|
|
case PT_DRV_DBG_GET_PUT_SYNC: /* 206 */
|
|
if (input_data[1] == 0) {
|
|
pm_runtime_put(dev);
|
|
pt_debug(dev, DL_WARN,
|
|
"%s: Force call pm_runtime_put()\n", __func__);
|
|
} else if (input_data[1] == 1) {
|
|
pm_runtime_get_sync(dev);
|
|
pt_debug(dev, DL_WARN,
|
|
"%s: Force call pm_runtime_get_sync()\n",
|
|
__func__);
|
|
} else {
|
|
rc = -EINVAL;
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s: WARNING: Invalid parameter: %d\n",
|
|
__func__, input_data[1]);
|
|
}
|
|
break;
|
|
case PT_DRV_DBG_SET_TT_DATA: /* 208 */
|
|
mutex_lock(&cd->system_lock);
|
|
if (input_data[1] == 0) {
|
|
cd->show_tt_data = false;
|
|
pt_debug(dev, DL_INFO,
|
|
"%s: Disable TT_DATA\n", __func__);
|
|
} else if (input_data[1] == 1) {
|
|
cd->show_tt_data = true;
|
|
pt_debug(dev, DL_INFO,
|
|
"%s: Enable TT_DATA\n", __func__);
|
|
} else {
|
|
rc = -EINVAL;
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s: Invalid parameter: %d\n",
|
|
__func__, input_data[1]);
|
|
}
|
|
mutex_unlock(&(cd->system_lock));
|
|
break;
|
|
case PT_DRV_DBG_SET_GENERATION: /* 210 */
|
|
if (input_data[1] == cd->active_dut_generation) {
|
|
mutex_lock(&cd->system_lock);
|
|
cd->set_dut_generation = true;
|
|
mutex_unlock(&(cd->system_lock));
|
|
} else {
|
|
mutex_lock(&cd->system_lock);
|
|
if (input_data[1] == 0) {
|
|
cd->active_dut_generation = DUT_UNKNOWN;
|
|
cd->set_dut_generation = false;
|
|
} else if (input_data[1] == 1) {
|
|
cd->active_dut_generation = DUT_PIP1_ONLY;
|
|
cd->set_dut_generation = true;
|
|
} else if (input_data[1] == 2) {
|
|
cd->active_dut_generation = DUT_PIP2_CAPABLE;
|
|
cd->set_dut_generation = true;
|
|
} else {
|
|
rc = -EINVAL;
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s: Invalid parameter: %d\n",
|
|
__func__, input_data[1]);
|
|
break;
|
|
}
|
|
cd->startup_status = STARTUP_STATUS_START;
|
|
pt_debug(cd->dev, DL_DEBUG,
|
|
"%s: Startup Status Reset\n", __func__);
|
|
mutex_unlock(&(cd->system_lock));
|
|
|
|
pt_debug(dev, DL_INFO,
|
|
"%s: Active DUT Generation Set to: %d\n",
|
|
__func__, cd->active_dut_generation);
|
|
|
|
/* Changing DUT generations full restart needed */
|
|
pt_queue_restart(cd);
|
|
}
|
|
break;
|
|
case PT_DRV_DBG_SET_BRIDGE_MODE: /* 211 */
|
|
mutex_lock(&cd->system_lock);
|
|
if (input_data[1] == 0) {
|
|
cd->bridge_mode = false;
|
|
pt_debug(dev, DL_INFO,
|
|
"%s: Disable Bridge Mode\n", __func__);
|
|
} else if (input_data[1] == 1) {
|
|
cd->bridge_mode = true;
|
|
pt_debug(dev, DL_INFO,
|
|
"%s: Enable Bridge Mode\n", __func__);
|
|
} else {
|
|
rc = -EINVAL;
|
|
pt_debug(dev, DL_ERROR, "%s: Invalid parameter: %d\n",
|
|
__func__, input_data[1]);
|
|
}
|
|
mutex_unlock(&(cd->system_lock));
|
|
break;
|
|
case PT_DRV_DBG_SET_I2C_ADDRESS: /* 212 */
|
|
mutex_lock(&cd->system_lock);
|
|
/* Only a 7bit address is valid */
|
|
if (input_data[1] >= 0 && input_data[1] <= 0x7F) {
|
|
client->addr = input_data[1];
|
|
pt_debug(dev, DL_INFO,
|
|
"%s: Set I2C Address: 0x%2X\n",
|
|
__func__, client->addr);
|
|
} else {
|
|
rc = -EINVAL;
|
|
pt_debug(dev, DL_ERROR, "%s: Invalid I2C Address %d\n",
|
|
__func__, input_data[1]);
|
|
client->addr = 0x24;
|
|
}
|
|
mutex_unlock(&(cd->system_lock));
|
|
break;
|
|
case PT_DRV_DBG_SET_FLASHLESS_DUT: /* 213 */
|
|
mutex_lock(&cd->system_lock);
|
|
if (input_data[1] == 0) {
|
|
cd->flashless_dut = 0;
|
|
cd->flashless_auto_bl = PT_SUPPRESS_AUTO_BL;
|
|
pt_debug(dev, DL_INFO, "%s: Disable FLAHLESS DUT\n",
|
|
__func__);
|
|
} else if (input_data[1] == 1) {
|
|
cd->flashless_dut = 1;
|
|
cd->flashless_auto_bl = PT_ALLOW_AUTO_BL;
|
|
pt_debug(dev, DL_INFO, "%s: Enable FLAHLESS DUT\n",
|
|
__func__);
|
|
}
|
|
mutex_unlock(&(cd->system_lock));
|
|
break;
|
|
case PT_DRV_DBG_SET_FORCE_SEQ: /* 214 */
|
|
mutex_lock(&cd->system_lock);
|
|
if (input_data[1] >= 0x8 && input_data[1] <= 0xF) {
|
|
cd->force_pip2_seq = input_data[1];
|
|
cd->pip2_cmd_tag_seq = input_data[1];
|
|
pt_debug(dev, DL_INFO,
|
|
"%s: Force PIP2 Seq to: 0x%02X\n",
|
|
__func__, input_data[1]);
|
|
} else {
|
|
cd->force_pip2_seq = 0;
|
|
pt_debug(dev, DL_INFO,
|
|
"%s: Clear Forced PIP2 Seq\n", __func__);
|
|
}
|
|
mutex_unlock(&(cd->system_lock));
|
|
break;
|
|
case PT_DRV_DBG_BL_WITH_NO_INT: /* 215 */
|
|
mutex_lock(&cd->system_lock);
|
|
if (input_data[1] == 0) {
|
|
cd->bl_with_no_int = 0;
|
|
pt_debug(dev, DL_INFO, "%s: BL using IRQ\n", __func__);
|
|
} else if (input_data[1] == 1) {
|
|
cd->bl_with_no_int = 1;
|
|
pt_debug(dev, DL_INFO, "%s: BL using Polling\n",
|
|
__func__);
|
|
} else {
|
|
rc = -EINVAL;
|
|
pt_debug(dev, DL_ERROR, "%s: Invalid parameter: %d\n",
|
|
__func__, input_data[1]);
|
|
}
|
|
mutex_unlock(&(cd->system_lock));
|
|
break;
|
|
case PT_DRV_DBG_CAL_CACHE_IN_HOST: /* 216 */
|
|
mutex_lock(&cd->system_lock);
|
|
if (input_data[1] == 0) {
|
|
cd->cal_cache_in_host = PT_FEATURE_DISABLE;
|
|
pt_debug(dev, DL_INFO,
|
|
"%s: Disable Calibration cache in host\n",
|
|
__func__);
|
|
} else if (input_data[1] == 1) {
|
|
cd->cal_cache_in_host = PT_FEATURE_ENABLE;
|
|
pt_debug(dev, DL_INFO,
|
|
"%s: Enable Calibration cache in host\n",
|
|
__func__);
|
|
} else {
|
|
rc = -EINVAL;
|
|
pt_debug(dev, DL_ERROR, "%s: Invalid parameter: %d\n",
|
|
__func__, input_data[1]);
|
|
}
|
|
mutex_unlock(&(cd->system_lock));
|
|
break;
|
|
case PT_DRV_DBG_MULTI_CHIP: /* 217 */
|
|
mutex_lock(&cd->system_lock);
|
|
if (input_data[1] == 0) {
|
|
cd->multi_chip = PT_FEATURE_DISABLE;
|
|
cd->ttdl_bist_select = 0x07;
|
|
pt_debug(dev, DL_INFO,
|
|
"%s: Disable Multi-chip support\n", __func__);
|
|
} else if (input_data[1] == 1) {
|
|
cd->multi_chip = PT_FEATURE_ENABLE;
|
|
cd->ttdl_bist_select = 0x3F;
|
|
pt_debug(dev, DL_INFO,
|
|
"%s: Enable Multi-chip support\n", __func__);
|
|
} else {
|
|
rc = -EINVAL;
|
|
pt_debug(dev, DL_ERROR, "%s: Invalid parameter: %d\n",
|
|
__func__, input_data[1]);
|
|
}
|
|
mutex_unlock(&(cd->system_lock));
|
|
break;
|
|
case PT_DRV_DBG_SET_PANEL_ID_TYPE: /* 218 */
|
|
mutex_lock(&cd->system_lock);
|
|
if (input_data[1] <= 0x07) {
|
|
cd->panel_id_support = input_data[1];
|
|
pt_debug(dev, DL_INFO,
|
|
"%s: Set panel_id_support to %d\n",
|
|
__func__, cd->panel_id_support);
|
|
} else {
|
|
rc = -EINVAL;
|
|
pt_debug(dev, DL_ERROR, "%s: Invalid parameter: %d\n",
|
|
__func__, input_data[1]);
|
|
}
|
|
mutex_unlock(&(cd->system_lock));
|
|
break;
|
|
case PT_DRV_DBG_PIP_TIMEOUT: /* 219 */
|
|
mutex_lock(&cd->system_lock);
|
|
if (input_data[1] >= 100 && input_data[1] <= 7000) {
|
|
/*
|
|
* The timeout is changed for some cases so the
|
|
* pip_cmd_timeout_default is used to retore back to
|
|
* what the user requested as the new timeout.
|
|
*/
|
|
cd->pip_cmd_timeout_default = input_data[1];
|
|
cd->pip_cmd_timeout = input_data[1];
|
|
pt_debug(dev, DL_INFO,
|
|
"%s: PIP Timeout = %d\n", __func__,
|
|
cd->pip_cmd_timeout_default);
|
|
} else {
|
|
rc = -EINVAL;
|
|
pt_debug(dev, DL_ERROR, "%s: Invalid parameter: %d\n",
|
|
__func__, input_data[1]);
|
|
}
|
|
mutex_unlock(&(cd->system_lock));
|
|
break;
|
|
case PT_DRV_DBG_TTHE_HID_USB_FORMAT: /* 220 */
|
|
mutex_lock(&cd->system_lock);
|
|
if (input_data[1] == 0) {
|
|
cd->tthe_hid_usb_format = PT_FEATURE_DISABLE;
|
|
pt_debug(dev, DL_INFO,
|
|
"%s: Disable tthe_tuner HID-USB format\n",
|
|
__func__);
|
|
} else if (input_data[1] == 1) {
|
|
cd->tthe_hid_usb_format = PT_FEATURE_ENABLE;
|
|
pt_debug(dev, DL_INFO,
|
|
"%s: Enable tthe_tuner HID-USB format\n",
|
|
__func__);
|
|
} else {
|
|
rc = -EINVAL;
|
|
pt_debug(dev, DL_ERROR, "%s: Invalid parameter: %d\n",
|
|
__func__, input_data[1]);
|
|
}
|
|
mutex_unlock(&(cd->system_lock));
|
|
break;
|
|
#endif /* TTDL_DIAGNOSTICS */
|
|
default:
|
|
rc = -EINVAL;
|
|
pt_debug(dev, DL_ERROR, "%s: Invalid value\n", __func__);
|
|
}
|
|
|
|
/* Enable watchdog timer */
|
|
if (!wd_disabled)
|
|
pt_start_wd_timer(cd);
|
|
|
|
pt_drv_debug_store_exit:
|
|
if (rc)
|
|
return rc;
|
|
return size;
|
|
}
|
|
static DEVICE_ATTR(drv_debug, 0644, pt_drv_debug_show,
|
|
pt_drv_debug_store);
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_sleep_status_show
|
|
*
|
|
* SUMMARY: Show method for the sleep_status sysfs node that will show the
|
|
* sleep status as either ON or OFF
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* *attr - pointer to device attributes
|
|
* *buf - pointer to output buffer
|
|
******************************************************************************/
|
|
static ssize_t pt_sleep_status_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct pt_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, PT_MAX_PRBUF_SIZE, "off\n");
|
|
else
|
|
ret = snprintf(buf, PT_MAX_PRBUF_SIZE, "on\n");
|
|
mutex_unlock(&cd->system_lock);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_panel_id_show
|
|
*
|
|
* SUMMARY: Show method for the panel_id sysfs node that will show the
|
|
* detected panel ID from the DUT
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* *attr - pointer to device attributes
|
|
* *buf - pointer to output buffer
|
|
******************************************************************************/
|
|
static ssize_t pt_panel_id_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
ssize_t ret;
|
|
u8 pid = PANEL_ID_NOT_ENABLED;
|
|
int rc = 0;
|
|
|
|
if (cd->active_dut_generation == DUT_PIP1_ONLY) {
|
|
/*
|
|
* The DUT should report the same panel ID from both the BL and
|
|
* the FW unless the panel_id feature is set to only
|
|
* PT_PANEL_ID_BY_SYS_INFO, in which case the BL is not able
|
|
* to retrieve the panel_id.
|
|
*/
|
|
if (cd->mode == PT_MODE_BOOTLOADER) {
|
|
/*
|
|
* Return the stored value if PT_PANEL_ID_BY_BL
|
|
* is not supported while other feature exits.
|
|
*/
|
|
if (cd->panel_id_support & PT_PANEL_ID_BY_BL) {
|
|
rc = pt_hid_output_bl_get_panel_id_(cd, &pid);
|
|
if (rc) {
|
|
pt_debug(dev, DL_WARN, "%s: %s %s\n",
|
|
"Failed to retrieve Panel ID. ",
|
|
"Using cached value\n",
|
|
__func__);
|
|
}
|
|
}
|
|
} else if (cd->mode == PT_MODE_OPERATIONAL) {
|
|
if (cd->panel_id_support &
|
|
(PT_PANEL_ID_BY_BL | PT_PANEL_ID_BY_SYS_INFO)) {
|
|
/* For all systems sysinfo has the panel_id */
|
|
rc = pt_hid_output_get_sysinfo(cd);
|
|
if (!rc)
|
|
pid =
|
|
cd->sysinfo.sensing_conf_data.panel_id;
|
|
pt_debug(dev, DL_WARN,
|
|
"%s: Gen6 FW mode rc=%d PID=0x%02X\n",
|
|
__func__, rc, pid);
|
|
}
|
|
} else {
|
|
pt_debug(dev, DL_WARN, "%s: Active mode unknown\n",
|
|
__func__);
|
|
rc = -EPERM;
|
|
}
|
|
} else if (cd->active_dut_generation == DUT_PIP2_CAPABLE) {
|
|
if (cd->mode == PT_MODE_BOOTLOADER) {
|
|
if (cd->panel_id_support & PT_PANEL_ID_BY_BL) {
|
|
rc = _pt_pip2_get_panel_id_by_gpio(cd, &pid);
|
|
if (rc) {
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s: BL get panel ID failed rc=%d\n",
|
|
__func__, rc);
|
|
}
|
|
}
|
|
} else if (cd->mode == PT_MODE_OPERATIONAL) {
|
|
if (cd->panel_id_support &
|
|
(PT_PANEL_ID_BY_BL | PT_PANEL_ID_BY_SYS_INFO)) {
|
|
rc = pt_hid_output_get_sysinfo(cd);
|
|
if (!rc)
|
|
pid =
|
|
cd->sysinfo.sensing_conf_data.panel_id;
|
|
pt_debug(dev, DL_WARN,
|
|
"%s: TT/TC FW mode rc=%d PID=0x%02X\n",
|
|
__func__, rc, pid);
|
|
}
|
|
} else {
|
|
pt_debug(dev, DL_WARN, "%s: Active mode unknown\n",
|
|
__func__);
|
|
rc = -EPERM;
|
|
}
|
|
} else {
|
|
pt_debug(dev, DL_WARN, "%s: Dut generation is unknown\n",
|
|
__func__);
|
|
rc = -EPERM;
|
|
}
|
|
|
|
ret = snprintf(buf, PT_MAX_PRBUF_SIZE, "Status: %d\n0x%02X\n",
|
|
rc, pid);
|
|
return ret;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_get_param_store
|
|
*
|
|
* SUMMARY: Store method for the get_param sysfs node. Stores what parameter
|
|
* ID to retrieve with the show method.
|
|
*
|
|
* NOTE: This sysfs node is only available after a DUT has been enumerated
|
|
*
|
|
* RETURN: Size of passed in buffer if successful
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* *attr - pointer to device attributes
|
|
* *buf - pointer to output buffer
|
|
* size - size of buf
|
|
******************************************************************************/
|
|
static ssize_t pt_get_param_store(struct device *dev,
|
|
struct device_attribute *attr, const char *buf, size_t size)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
u32 input_data[2];
|
|
int length;
|
|
int rc = 0;
|
|
|
|
/* Maximum input of one value */
|
|
length = _pt_ic_parse_input(dev, buf, size, input_data,
|
|
ARRAY_SIZE(input_data));
|
|
if (length != 1) {
|
|
pt_debug(dev, DL_WARN, "%s: Invalid number of arguments\n",
|
|
__func__);
|
|
rc = -EINVAL;
|
|
goto exit;
|
|
}
|
|
|
|
mutex_lock(&cd->system_lock);
|
|
cd->get_param_id = input_data[0];
|
|
mutex_unlock(&(cd->system_lock));
|
|
|
|
exit:
|
|
if (rc)
|
|
return rc;
|
|
return size;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_get_param_show
|
|
*
|
|
* SUMMARY: Show method for the get_param sysfs node. Retrieves the
|
|
* parameter data from the DUT based on the ID stored in the core
|
|
* data variable "get_param_id". If the ID is invalid, the DUT cannot
|
|
* communicate or some other error occures, an error status is returned
|
|
* with no value following.
|
|
* Output is in the form:
|
|
* Status: x
|
|
* 0xyyyyyyyy
|
|
* The 32bit data will only follow the status code if the status == 0
|
|
*
|
|
* NOTE: This sysfs node is only available after a DUT has been enumerated
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* *attr - pointer to device attributes
|
|
* *buf - pointer to output buffer
|
|
******************************************************************************/
|
|
static ssize_t pt_get_param_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
ssize_t ret = 0;
|
|
int status;
|
|
u32 value = 0;
|
|
|
|
status = pt_pip_get_param(cd, cd->get_param_id, &value);
|
|
if (status) {
|
|
pt_debug(dev, DL_ERROR, "%s: %s Failed, status = %d\n",
|
|
__func__, "pt_get_param", status);
|
|
ret = sprintf(buf,
|
|
"%s %d\n",
|
|
"Status:", status);
|
|
} else {
|
|
pt_debug(dev, DL_DEBUG, "%s: Param [%d] = 0x%04X\n",
|
|
__func__, cd->get_param_id, value);
|
|
ret = sprintf(buf,
|
|
"Status: %d\n"
|
|
"0x%04X\n",
|
|
status, value);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_ttdl_restart_show
|
|
*
|
|
* SUMMARY: Show method for ttdl_restart sysfs node. This node releases all
|
|
* probed modules, calls startup() and then re-probes modules.
|
|
*
|
|
* RETURN: size of data written to sysfs node
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* *attr - pointer to device attributes structure
|
|
* *buf - pointer to print output buffer
|
|
******************************************************************************/
|
|
static ssize_t pt_ttdl_restart_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
int t;
|
|
int rc = 0;
|
|
|
|
mutex_lock(&cd->system_lock);
|
|
cd->startup_state = STARTUP_NONE;
|
|
mutex_unlock(&(cd->system_lock));
|
|
|
|
/* ensure no left over exclusive access is still locked */
|
|
release_exclusive(cd, cd->dev);
|
|
|
|
pt_queue_restart(cd);
|
|
|
|
t = wait_event_timeout(cd->wait_q,
|
|
(cd->startup_status >= STARTUP_STATUS_COMPLETE),
|
|
msecs_to_jiffies(PT_REQUEST_ENUM_TIMEOUT));
|
|
if (IS_TMO(t)) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: TMO waiting for FW sentinel\n", __func__);
|
|
rc = -ETIME;
|
|
}
|
|
|
|
return sprintf(buf,
|
|
"Status: %d\n"
|
|
"Enum Status: 0x%04X\n", rc, cd->startup_status);
|
|
}
|
|
static DEVICE_ATTR(ttdl_restart, 0444, pt_ttdl_restart_show, NULL);
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_pip2_gpio_read_show
|
|
*
|
|
* SUMMARY: Sends a PIP2 READ_GPIO command to the DUT and prints the
|
|
* contents of the response to the passed in output buffer.
|
|
*
|
|
* RETURN: size of data written to sysfs node
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* *attr - pointer to device attributes structure
|
|
* *buf - pointer to print output buffer
|
|
******************************************************************************/
|
|
static ssize_t pt_pip2_gpio_read_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
u8 status = 0;
|
|
u32 gpio_value = 0;
|
|
int rc = 0;
|
|
|
|
/* This functionality is only available in the BL */
|
|
if (cd->mode == PT_MODE_BOOTLOADER)
|
|
rc = pt_pip2_read_gpio(dev, &status, &gpio_value);
|
|
else
|
|
rc = -EPERM;
|
|
|
|
if (!rc) {
|
|
if (status == 0)
|
|
return snprintf(buf, PT_MAX_PRBUF_SIZE,
|
|
"Status: %d\n"
|
|
"DUT GPIO Reg: 0x%08X\n",
|
|
rc, gpio_value);
|
|
else
|
|
return snprintf(buf, PT_MAX_PRBUF_SIZE,
|
|
"Status: %d\n"
|
|
"DUT GPIO Reg: n/a\n",
|
|
status);
|
|
} else
|
|
return snprintf(buf, PT_MAX_PRBUF_SIZE,
|
|
"Status: %d\n"
|
|
"DUT GPIO Reg: n/a\n",
|
|
rc);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_pip2_version_show
|
|
*
|
|
* SUMMARY: Sends a PIP2 VERSION command to the DUT and prints the
|
|
* contents of the response to the passed in output buffer.
|
|
*
|
|
* RETURN: size of data written to sysfs node
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* *attr - pointer to device attributes structure
|
|
* *buf - pointer to print output buffer
|
|
******************************************************************************/
|
|
static ssize_t pt_pip2_version_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
int rc = 0;
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
struct pt_ttdata *ttdata = &cd->sysinfo.ttdata;
|
|
|
|
rc = pt_pip2_get_version(cd);
|
|
if (!rc) {
|
|
return snprintf(buf, PT_MAX_PRBUF_SIZE,
|
|
"PIP VERSION : %02X.%02X\n"
|
|
"BL VERSION : %02X.%02X\n"
|
|
"FW VERSION : %02X.%02X\n"
|
|
"SILICON ID : %04X.%04X\n"
|
|
"UID : 0x%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X\n",
|
|
ttdata->pip_ver_major, ttdata->pip_ver_minor,
|
|
ttdata->bl_ver_major, ttdata->bl_ver_minor,
|
|
ttdata->fw_ver_major, ttdata->fw_ver_minor,
|
|
ttdata->chip_id, ttdata->chip_rev,
|
|
ttdata->uid[0], ttdata->uid[1],
|
|
ttdata->uid[2], ttdata->uid[3],
|
|
ttdata->uid[4], ttdata->uid[5],
|
|
ttdata->uid[6], ttdata->uid[7],
|
|
ttdata->uid[8], ttdata->uid[9],
|
|
ttdata->uid[10], ttdata->uid[11]);
|
|
} else {
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s: Failed to retriev PIP2 VERSION data\n", __func__);
|
|
|
|
return snprintf(buf, PT_MAX_PRBUF_SIZE,
|
|
"PIP VERSION : -\n"
|
|
"BL VERSION : -\n"
|
|
"FW VERSION : -\n"
|
|
"SILICON ID : -\n"
|
|
"UID : -\n");
|
|
}
|
|
}
|
|
|
|
#ifdef TTDL_DIAGNOSTICS
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_ttdl_status_show
|
|
*
|
|
* SUMMARY: Show method for the ttdl_status sysfs node. Displays TTDL internal
|
|
* variable states and GPIO levels. Additional information printed when
|
|
* TTDL_DIAGNOSTICS is enabled.
|
|
*
|
|
* NOTE: All counters will be reset to 0 when this function is called.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* *attr - pointer to device attributes
|
|
* *buf - pointer to output buffer
|
|
******************************************************************************/
|
|
static ssize_t pt_ttdl_status_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
struct pt_platform_data *pdata = dev_get_platdata(dev);
|
|
struct i2c_client *client = to_i2c_client(dev);
|
|
ssize_t ret;
|
|
u16 cal_size = 0;
|
|
unsigned short crc = 0;
|
|
|
|
if (cd->cal_cache_in_host)
|
|
_pt_manage_local_cal_data(dev,
|
|
PT_CAL_DATA_INFO, &cal_size, &crc);
|
|
|
|
ret = sprintf(buf,
|
|
"%s: 0x%04X\n"
|
|
"%s: %d\n"
|
|
"%s: %s\n"
|
|
"%s: %s %s\n"
|
|
"%s: %s\n"
|
|
"%s: 0x%02X\n"
|
|
"%s: %s\n"
|
|
"%s: %s\n"
|
|
"%s: %s\n"
|
|
"%s: %s\n"
|
|
"%s: %d\n"
|
|
"%s: %d\n"
|
|
"%s: %s\n"
|
|
"%s: %s\n"
|
|
"%s: %d\n"
|
|
#ifdef TTDL_DIAGNOSTICS
|
|
"%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: %s\n"
|
|
"%s: %s\n"
|
|
"%s: %s\n"
|
|
"%s: %d\n"
|
|
"%s: 0x%04X\n"
|
|
"%s: %s\n"
|
|
#endif /* TTDL_DIAGNOSTICS */
|
|
,
|
|
"Startup Status ", cd->startup_status,
|
|
"TTDL Debug Level ", cd->debug_level,
|
|
"Mode ",
|
|
cd->mode ? (cd->mode == PT_MODE_OPERATIONAL ?
|
|
"Operational" : "BL") : "Unknown",
|
|
"DUT Generation ",
|
|
cd->active_dut_generation ?
|
|
(cd->active_dut_generation == DUT_PIP2_CAPABLE ?
|
|
"PT TC/TT" : "Gen5/6") : "Unknown",
|
|
cd->active_dut_generation ?
|
|
(cd->set_dut_generation == true ?
|
|
"(Set)" : "(Detected)") : "",
|
|
"HW Detected ",
|
|
cd->hw_detected ? "True" : "False",
|
|
"I2C Address ",
|
|
cd->bus_ops->bustype == BUS_I2C ? client->addr : 0,
|
|
"Active Bus Module ",
|
|
cd->bus_ops->bustype == BUS_I2C ? "I2C" : "SPI",
|
|
"Flashless Mode ",
|
|
cd->flashless_dut == 1 ? "Yes" : "No",
|
|
"GPIO state - IRQ ",
|
|
cd->cpdata->irq_stat ?
|
|
(cd->cpdata->irq_stat(cd->cpdata, dev) ?
|
|
"High" : "Low") : "not defined",
|
|
"GPIO state - TP_XRES ",
|
|
pdata->core_pdata->rst_gpio ?
|
|
(gpio_get_value(pdata->core_pdata->rst_gpio) ?
|
|
"High" : "Low") : "not defined",
|
|
"RAM Parm restore list ", pt_count_parameter_list(cd),
|
|
"Startup Retry Count ", cd->startup_retry_count,
|
|
"WD - Manual Force Stop ",
|
|
cd->watchdog_force_stop ? "True" : "False",
|
|
"WD - Enabled ",
|
|
cd->watchdog_enabled ? "True" : "False",
|
|
"WD - Interval (ms) ", cd->watchdog_interval
|
|
#ifdef TTDL_DIAGNOSTICS
|
|
, "WD - Triggered Count ", cd->watchdog_count,
|
|
"WD - IRQ Stuck low count ", cd->watchdog_irq_stuck_count,
|
|
"WD - Device Access Errors ", cd->watchdog_failed_access_count,
|
|
"WD - XRES Count ", cd->wd_xres_count,
|
|
"IRQ Triggered Count ", cd->irq_count,
|
|
"BL Packet Retry Count ", cd->bl_retry_packet_count,
|
|
"PIP2 CRC Error Count ", cd->pip2_crc_error_count,
|
|
"Bus Transmit Error Count ", cd->bus_transmit_error_count,
|
|
"File Erase Timeout Count ", cd->file_erase_timeout_count,
|
|
"Error GPIO trigger type ", cd->err_gpio_type,
|
|
"Exclusive Access Lock ", cd->exclusive_dev ? "Set":"Free",
|
|
"Suppress No-Flash Auto BL ",
|
|
cd->flashless_auto_bl == PT_SUPPRESS_AUTO_BL ?
|
|
"Yes" : "No",
|
|
"Calibration Cache on host ",
|
|
cd->cal_cache_in_host == PT_FEATURE_ENABLE ?
|
|
"Yes" : "No",
|
|
"Calibration Cache size ", cal_size,
|
|
"Calibration Cache chip ID ", crc,
|
|
"Multi-Chip Support ",
|
|
cd->multi_chip == PT_FEATURE_ENABLE ? "Yes" : "No"
|
|
#endif /* TTDL_DIAGNOSTICS */
|
|
);
|
|
|
|
#ifdef TTDL_DIAGNOSTICS
|
|
/* Reset all diagnostic counters */
|
|
cd->watchdog_count = 0;
|
|
cd->watchdog_irq_stuck_count = 0;
|
|
cd->watchdog_failed_access_count = 0;
|
|
cd->wd_xres_count = 0;
|
|
cd->irq_count = 0;
|
|
cd->bl_retry_packet_count = 0;
|
|
cd->pip2_crc_error_count = 0;
|
|
cd->bus_transmit_error_count = 0;
|
|
#endif
|
|
|
|
return ret;
|
|
}
|
|
static DEVICE_ATTR(ttdl_status, 0444, pt_ttdl_status_show, NULL);
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_pip2_enter_bl_show
|
|
*
|
|
* SUMMARY: Show method for the pip2_enter_bl sysfs node that will force
|
|
* the DUT into the BL and show the success or failure of entering the BL
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* *attr - pointer to device attributes
|
|
* *buf - pointer to output buffer
|
|
******************************************************************************/
|
|
static ssize_t pt_pip2_enter_bl_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
ssize_t ret = 0;
|
|
int rc = 0;
|
|
int result = 0;
|
|
u8 mode = PT_MODE_UNKNOWN;
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
|
|
/* Turn off the TTDL WD befor enter bootloader */
|
|
pt_stop_wd_timer(cd);
|
|
|
|
/* Ensure NO enumeration work is queued or will be queued */
|
|
cancel_work_sync(&cd->enum_work);
|
|
mutex_lock(&cd->system_lock);
|
|
cd->bridge_mode = true;
|
|
mutex_unlock(&cd->system_lock);
|
|
|
|
/* set mode to operational to avoid any extra PIP traffic */
|
|
rc = _pt_request_pip2_enter_bl(dev, &mode, &result);
|
|
switch (result) {
|
|
case PT_ENTER_BL_PASS:
|
|
ret = snprintf(buf, PT_MAX_PRBUF_SIZE,
|
|
"Status: %d\nEntered BL\n", PT_ENTER_BL_PASS);
|
|
break;
|
|
case PT_ENTER_BL_ERROR:
|
|
ret = snprintf(buf, PT_MAX_PRBUF_SIZE, "Status: %d\n%s\n",
|
|
rc,
|
|
" Unknown Error");
|
|
break;
|
|
case PT_ENTER_BL_RESET_FAIL:
|
|
ret = snprintf(buf, PT_MAX_PRBUF_SIZE, "Status: %d\n%s\n",
|
|
rc,
|
|
" Soft Reset Failed");
|
|
break;
|
|
case PT_ENTER_BL_HID_START_BL_FAIL:
|
|
ret = snprintf(buf, PT_MAX_PRBUF_SIZE, "Status: %d\n%s\n",
|
|
rc,
|
|
" PIP Start BL Cmd Failed");
|
|
break;
|
|
case PT_ENTER_BL_CONFIRM_FAIL:
|
|
ret = snprintf(buf, PT_MAX_PRBUF_SIZE, "Status: %d\n%s\n",
|
|
rc,
|
|
" Error confirming DUT entered BL");
|
|
break;
|
|
default:
|
|
ret = snprintf(buf, PT_MAX_PRBUF_SIZE, "Status: %d\n%s\n",
|
|
rc, " Unknown Error");
|
|
break;
|
|
};
|
|
|
|
/* Allow enumeration work to be queued again */
|
|
cd->bridge_mode = false;
|
|
|
|
return ret;
|
|
}
|
|
static DEVICE_ATTR(pip2_enter_bl, 0444, pt_pip2_enter_bl_show, NULL);
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_pip2_exit_bl_show
|
|
*
|
|
* SUMMARY: Show method for the pip2_exit_bl sysfs node that will attempt to
|
|
* launch the APP and put the DUT Application mode
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* *attr - pointer to device attributes
|
|
* *buf - pointer to output buffer
|
|
******************************************************************************/
|
|
static ssize_t pt_pip2_exit_bl_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
ssize_t ret = 0;
|
|
int rc = 0;
|
|
int status_str_buf_len = 50;
|
|
u8 status_str[status_str_buf_len];
|
|
|
|
rc = pt_pip2_exit_bl_(cd, status_str, status_str_buf_len);
|
|
/*
|
|
* Perform enum if startup_status doesn't reach to
|
|
* STARTUP_STATUS_FW_OUT_OF_BOOT.
|
|
*/
|
|
if (!rc && (!(cd->startup_status & STARTUP_STATUS_FW_OUT_OF_BOOT))) {
|
|
rc = pt_enum_with_dut(cd, false, &cd->startup_status);
|
|
if (!(cd->startup_status & STARTUP_STATUS_FW_OUT_OF_BOOT)) {
|
|
strcpy(status_str,
|
|
"Already in APP mode - FW stuck in Boot mode");
|
|
}
|
|
}
|
|
ret = snprintf(buf, PT_MAX_PRBUF_SIZE, "Status: %d\n%s\n",
|
|
rc, status_str);
|
|
return ret;
|
|
}
|
|
static DEVICE_ATTR(pip2_exit_bl, 0444, pt_pip2_exit_bl_show, NULL);
|
|
#endif
|
|
|
|
#ifdef EASYWAKE_TSG6
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_easy_wakeup_gesture_show
|
|
*
|
|
* SUMMARY: Show method for the easy_wakeup_gesture sysfs node that will show
|
|
* current easy wakeup gesture
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* *attr - pointer to device attributes
|
|
* *buf - pointer to output buffer
|
|
******************************************************************************/
|
|
static ssize_t pt_easy_wakeup_gesture_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
ssize_t ret;
|
|
|
|
mutex_lock(&cd->system_lock);
|
|
ret = snprintf(buf, PT_MAX_PRBUF_SIZE, "0x%02X\n",
|
|
cd->easy_wakeup_gesture);
|
|
mutex_unlock(&cd->system_lock);
|
|
return ret;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_easy_wakeup_gesture_store
|
|
*
|
|
* SUMMARY: The store method for the easy_wakeup_gesture sysfs node that
|
|
* allows the wake gesture to be set to a custom value.
|
|
*
|
|
* RETURN: Size of passed in buffer is success
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* *attr - pointer to device attributes
|
|
* *buf - pointer to buffer that hold the command parameters
|
|
* size - size of buf
|
|
******************************************************************************/
|
|
static ssize_t pt_easy_wakeup_gesture_store(struct device *dev,
|
|
struct device_attribute *attr, const char *buf, size_t size)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
u32 input_data[2];
|
|
int length;
|
|
int rc = 0;
|
|
|
|
/* Maximum input of one value */
|
|
length = _pt_ic_parse_input(dev, buf, size, input_data,
|
|
ARRAY_SIZE(input_data));
|
|
if (length != 1) {
|
|
pt_debug(dev, DL_WARN, "%s: Invalid number of arguments\n",
|
|
__func__);
|
|
rc = -EINVAL;
|
|
goto exit;
|
|
}
|
|
|
|
pt_debug(dev, DL_INFO, "%s: features.easywake = 0x%02X\n",
|
|
__func__, cd->features.easywake);
|
|
|
|
if (!cd->features.easywake || input_data[0] > 0xFF) {
|
|
rc = -EINVAL;
|
|
goto exit;
|
|
}
|
|
|
|
|
|
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)input_data[0];
|
|
pt_debug(dev, DL_INFO,
|
|
"%s: Updated easy_wakeup_gesture = 0x%02X\n",
|
|
__func__, cd->easy_wakeup_gesture);
|
|
} else
|
|
rc = -ENODEV;
|
|
|
|
mutex_unlock(&cd->system_lock);
|
|
pm_runtime_put(dev);
|
|
|
|
exit:
|
|
if (rc)
|
|
return rc;
|
|
return size;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_easy_wakeup_gesture_id_show
|
|
*
|
|
* SUMMARY: Show method for the easy_wakeup_gesture_id sysfs node that will
|
|
* show the TSG6 easywake gesture ID
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* *attr - pointer to device attributes
|
|
* *buf - pointer to output buffer
|
|
******************************************************************************/
|
|
static ssize_t pt_easy_wakeup_gesture_id_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
ssize_t ret;
|
|
|
|
mutex_lock(&cd->system_lock);
|
|
ret = snprintf(buf, PT_MAX_PRBUF_SIZE, "Status: 0\n0x%02X\n",
|
|
cd->gesture_id);
|
|
mutex_unlock(&cd->system_lock);
|
|
return ret;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_easy_wakeup_gesture_data_show
|
|
*
|
|
* SUMMARY: Show method for the easy_wakeup_gesture_data sysfs node that will
|
|
* show the TSG6 easywake gesture data in the following format:
|
|
* x1(LSB),x1(MSB), y1(LSB),y1(MSB), x2(LSB),x2(MSB), y2(LSB),y2(MSB),...
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* *attr - pointer to device attributes
|
|
* *buf - pointer to output buffer
|
|
******************************************************************************/
|
|
static ssize_t pt_easy_wakeup_gesture_data_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
ssize_t ret = 0;
|
|
int i;
|
|
|
|
mutex_lock(&cd->system_lock);
|
|
|
|
ret += snprintf(buf + ret, PT_MAX_PRBUF_SIZE - ret, "Status: %d\n", 0);
|
|
for (i = 0; i < cd->gesture_data_length; i++)
|
|
ret += snprintf(buf + ret, PT_MAX_PRBUF_SIZE - ret,
|
|
"0x%02X\n", cd->gesture_data[i]);
|
|
|
|
ret += snprintf(buf + ret, PT_MAX_PRBUF_SIZE - ret,
|
|
"(%d bytes)\n", cd->gesture_data_length);
|
|
|
|
mutex_unlock(&cd->system_lock);
|
|
return ret;
|
|
}
|
|
#endif /* EASYWAKE_TSG6 */
|
|
|
|
#ifdef TTDL_DIAGNOSTICS
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_err_gpio_show
|
|
*
|
|
* SUMMARY: Show method for the err_gpio sysfs node that will show if
|
|
* setting up the gpio was successful
|
|
*
|
|
* RETURN: Char buffer with printed GPIO creation state
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* *attr - pointer to device attributes
|
|
* *buf - pointer to output buffer
|
|
******************************************************************************/
|
|
static ssize_t pt_err_gpio_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
|
|
return sprintf(buf, "Status: 0\n"
|
|
"Err GPIO (%d) : %s\n"
|
|
"Err GPIO trig type: %d\n",
|
|
cd->err_gpio,
|
|
(cd->err_gpio ? (gpio_get_value(cd->err_gpio) ?
|
|
"HIGH" : "low") : "not defined"),
|
|
cd->err_gpio_type);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_err_gpio_store
|
|
*
|
|
* SUMMARY: The store method for the err_gpio sysfs node that allows any
|
|
* available host GPIO to be used to trigger when TTDL detects a PIP
|
|
* command/response timeout.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* *attr - pointer to device attributes
|
|
* *buf - pointer to buffer that hold the command parameters
|
|
* size - size of buf
|
|
******************************************************************************/
|
|
static ssize_t pt_err_gpio_store(struct device *dev,
|
|
struct device_attribute *attr, const char *buf, size_t size)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
unsigned long gpio;
|
|
int rc = 0;
|
|
u32 input_data[3];
|
|
int length;
|
|
u8 err_type;
|
|
|
|
input_data[0] = 0;
|
|
input_data[1] = 0;
|
|
|
|
/* Maximmum input is two elements */
|
|
length = _pt_ic_parse_input(dev, buf, size,
|
|
input_data, ARRAY_SIZE(input_data));
|
|
if (length < 1 || length > 2) {
|
|
pt_debug(dev, DL_WARN, "%s: Invalid number of arguments\n",
|
|
__func__);
|
|
rc = -EINVAL;
|
|
goto exit;
|
|
}
|
|
|
|
gpio = input_data[0];
|
|
err_type = (u8)input_data[1];
|
|
if (err_type < 0 || err_type > PT_ERR_GPIO_MAX_TYPE) {
|
|
rc = -EINVAL;
|
|
goto exit;
|
|
}
|
|
|
|
mutex_lock(&cd->system_lock);
|
|
gpio_free(gpio);
|
|
rc = gpio_request(gpio, NULL);
|
|
if (rc) {
|
|
pt_debug(dev, DL_ERROR, "error requesting gpio %lu\n", gpio);
|
|
rc = -ENODEV;
|
|
} else {
|
|
cd->err_gpio = gpio;
|
|
cd->err_gpio_type = err_type;
|
|
gpio_direction_output(gpio, 0);
|
|
}
|
|
mutex_unlock(&cd->system_lock);
|
|
|
|
exit:
|
|
if (rc)
|
|
return rc;
|
|
return size;
|
|
}
|
|
static DEVICE_ATTR(err_gpio, 0644, pt_err_gpio_show,
|
|
pt_err_gpio_store);
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_drv_irq_show
|
|
*
|
|
* SUMMARY: Show method for the drv_irq sysfs node that will show if the
|
|
* TTDL interrupt is enabled/disabled
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* *attr - pointer to device attributes
|
|
* *buf - pointer to output buffer
|
|
******************************************************************************/
|
|
static ssize_t pt_drv_irq_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
ssize_t ret = 0;
|
|
|
|
mutex_lock(&cd->system_lock);
|
|
ret += snprintf(buf, PT_MAX_PRBUF_SIZE, "Status: %d\n", 0);
|
|
if (cd->irq_enabled)
|
|
ret += snprintf(buf + ret, PT_MAX_PRBUF_SIZE - ret,
|
|
"Driver interrupt: ENABLED\n");
|
|
else
|
|
ret += snprintf(buf + ret, PT_MAX_PRBUF_SIZE - ret,
|
|
"Driver interrupt: DISABLED\n");
|
|
mutex_unlock(&cd->system_lock);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_drv_irq_store
|
|
*
|
|
* SUMMARY: The store method for the drv_irq sysfs node that allows the TTDL
|
|
* IRQ to be enabled/disabled.
|
|
*
|
|
* RETURN: Size of passed in buffer
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* *attr - pointer to device attributes
|
|
* *buf - pointer to buffer that hold the command parameters
|
|
* size - size of buf
|
|
******************************************************************************/
|
|
static ssize_t pt_drv_irq_store(struct device *dev,
|
|
struct device_attribute *attr, const char *buf, size_t size)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
u32 input_data[2];
|
|
int length;
|
|
int rc = 0;
|
|
|
|
/* Maximum input of one value */
|
|
length = _pt_ic_parse_input(dev, buf, size, input_data,
|
|
ARRAY_SIZE(input_data));
|
|
if (length != 1) {
|
|
pt_debug(dev, DL_WARN, "%s: Invalid number of arguments\n",
|
|
__func__);
|
|
rc = -EINVAL;
|
|
goto exit;
|
|
}
|
|
|
|
mutex_lock(&cd->system_lock);
|
|
switch (input_data[0]) {
|
|
case 0:
|
|
if (cd->irq_enabled) {
|
|
cd->irq_enabled = false;
|
|
/* Disable IRQ has no return value to check */
|
|
disable_irq_nosync(cd->irq);
|
|
pt_debug(dev, DL_INFO,
|
|
"%s: Driver IRQ now disabled\n",
|
|
__func__);
|
|
} else
|
|
pt_debug(dev, DL_INFO,
|
|
"%s: Driver IRQ already disabled\n",
|
|
__func__);
|
|
break;
|
|
|
|
case 1:
|
|
if (cd->irq_enabled == false) {
|
|
cd->irq_enabled = true;
|
|
enable_irq(cd->irq);
|
|
pt_debug(dev, DL_INFO,
|
|
"%s: Driver IRQ now enabled\n",
|
|
__func__);
|
|
} else
|
|
pt_debug(dev, DL_INFO,
|
|
"%s: Driver IRQ already enabled\n",
|
|
__func__);
|
|
break;
|
|
|
|
default:
|
|
rc = -EINVAL;
|
|
pt_debug(dev, DL_ERROR, "%s: Invalid value\n", __func__);
|
|
}
|
|
mutex_unlock(&(cd->system_lock));
|
|
|
|
exit:
|
|
if (rc)
|
|
return rc;
|
|
return size;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_pip2_bin_hdr_show
|
|
*
|
|
* SUMMARY: Show method for the pip2_bin_hdr sysfs node that will read
|
|
* the bin file header from flash and show each field
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* *attr - pointer to device attributes
|
|
* *buf - pointer to output buffer
|
|
******************************************************************************/
|
|
static ssize_t pt_pip2_bin_hdr_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
ssize_t ret = 0;
|
|
struct pt_bin_file_hdr hdr = {0};
|
|
int rc;
|
|
|
|
rc = _pt_request_pip2_bin_hdr(dev, &hdr);
|
|
|
|
ret = sprintf(buf,
|
|
"%s: %d\n"
|
|
"%s: %d\n"
|
|
"%s: 0x%04X\n"
|
|
"%s: %d\n"
|
|
"%s: %d\n"
|
|
"%s: %d\n"
|
|
"%s: 0x%08X\n"
|
|
"%s: 0x%04X\n"
|
|
"%s: 0x%04X\n"
|
|
"%s: %d\n"
|
|
"%s: %d\n",
|
|
"Status", rc,
|
|
"Header Length ", hdr.length,
|
|
"TTPID ", hdr.ttpid,
|
|
"FW Major Ver ", hdr.fw_major,
|
|
"FW Minor Ver ", hdr.fw_minor,
|
|
"FW Rev Control ", hdr.fw_rev_ctrl,
|
|
"FW CRC ", hdr.fw_crc,
|
|
"Silicon Rev ", hdr.si_rev,
|
|
"Silicon ID ", hdr.si_id,
|
|
"Config Ver ", hdr.config_ver,
|
|
"HEX File Size ", hdr.hex_file_size
|
|
);
|
|
return ret;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_platform_data_show
|
|
*
|
|
* SUMMARY: Show method for the platform_data sysfs node that will show the
|
|
* active platform data including: GPIOs, Vendor and Product IDs,
|
|
* Virtual Key coordinates, Core/MT/Loader flags, Level trigger delay,
|
|
* HID registers, and Easy wake gesture
|
|
*
|
|
* RETURN: Size of printed data
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* *attr - pointer to device attributes
|
|
* *buf - pointer to output buffer
|
|
******************************************************************************/
|
|
static ssize_t pt_platform_data_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct pt_platform_data *pdata = dev_get_platdata(dev);
|
|
struct pt_core_data *cd = dev_get_drvdata(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"
|
|
"%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"
|
|
"%s: %d\n"
|
|
"%s: %d\n"
|
|
"%s: %d\n"
|
|
"%s: %s\n"
|
|
"%s: %s\n"
|
|
"%s: %d\n",
|
|
"Status", 0,
|
|
"Interrupt GPIO ", pdata->core_pdata->irq_gpio,
|
|
"Interrupt GPIO Value ",
|
|
pdata->core_pdata->irq_gpio ?
|
|
gpio_get_value(pdata->core_pdata->irq_gpio) : 0,
|
|
"Reset GPIO ", pdata->core_pdata->rst_gpio,
|
|
"Reset GPIO Value ",
|
|
pdata->core_pdata->rst_gpio ?
|
|
gpio_get_value(pdata->core_pdata->rst_gpio) : 0,
|
|
"DDI Reset GPIO ", pdata->core_pdata->ddi_rst_gpio,
|
|
"DDI Reset GPIO Value ",
|
|
pdata->core_pdata->ddi_rst_gpio ?
|
|
gpio_get_value(pdata->core_pdata->ddi_rst_gpio) : 0,
|
|
"VDDI GPIO ", pdata->core_pdata->vddi_gpio,
|
|
"VDDI GPIO Value ",
|
|
pdata->core_pdata->vddi_gpio ?
|
|
gpio_get_value(pdata->core_pdata->vddi_gpio) : 0,
|
|
"VCC GPIO ", pdata->core_pdata->vcc_gpio,
|
|
"VCC GPIO Value ",
|
|
pdata->core_pdata->vcc_gpio ?
|
|
gpio_get_value(pdata->core_pdata->vcc_gpio) : 0,
|
|
"AVDD GPIO ", pdata->core_pdata->avdd_gpio,
|
|
"AVDD GPIO Value ",
|
|
pdata->core_pdata->avdd_gpio ?
|
|
gpio_get_value(pdata->core_pdata->avdd_gpio) : 0,
|
|
"AVEE GPIO ", pdata->core_pdata->avee_gpio,
|
|
"AVEE GPIO Value ",
|
|
pdata->core_pdata->avee_gpio ?
|
|
gpio_get_value(pdata->core_pdata->avee_gpio) : 0,
|
|
"Vendor ID ", pdata->core_pdata->vendor_id,
|
|
"Product ID ", pdata->core_pdata->product_id,
|
|
"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,
|
|
"Level trigger delay (us) ",
|
|
pdata->core_pdata->level_irq_udelay,
|
|
"HID Descriptor Register ",
|
|
pdata->core_pdata->hid_desc_register,
|
|
"HID Output Register ",
|
|
cd->hid_desc.output_register,
|
|
"HID Command Register ",
|
|
cd->hid_desc.command_register,
|
|
"Easy wakeup gesture ",
|
|
pdata->core_pdata->easy_wakeup_gesture,
|
|
"Config DUT generation ",
|
|
pdata->core_pdata->config_dut_generation ?
|
|
(pdata->core_pdata->config_dut_generation ==
|
|
CONFIG_DUT_PIP2_CAPABLE ?
|
|
"PT TC/TT" : "Gen5/6") : "Auto",
|
|
"Watchdog Force Stop ",
|
|
pdata->core_pdata->watchdog_force_stop ?
|
|
"True" : "False",
|
|
"Panel ID Support ",
|
|
pdata->core_pdata->panel_id_support);
|
|
return ret;
|
|
}
|
|
|
|
#define PT_ERR_STR_SIZE 64
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_bist_bus_test
|
|
*
|
|
* SUMMARY: Tests the connectivity of the active bus pins:
|
|
* I2C - SDA and SCL
|
|
* SPI - MOSI, MISO, CLK
|
|
*
|
|
* Disable TTDL interrupts, send a PIP cmd and then manually read the
|
|
* bus. If any data is read we know the I2C/SPI pins are connected
|
|
*
|
|
* RETURN:
|
|
* 0 = Success
|
|
* !0 = Failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* *net_toggled - pointer to where to store if bus toggled
|
|
* *err_str - pointer to error string buffer
|
|
******************************************************************************/
|
|
static int pt_bist_bus_test(struct device *dev, u8 *net_toggled, u8 *err_str)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
u8 ver_cmd[8] = {0x01, 0x01, 0x06, 0x00, 0x0E, 0x07, 0xF0, 0xB1};
|
|
u8 *read_buf = NULL;
|
|
int bytes_read = 0;
|
|
int rc = 0;
|
|
|
|
read_buf = kzalloc(PT_MAX_PIP1_MSG_SIZE, GFP_KERNEL);
|
|
if (read_buf == NULL) {
|
|
rc = -ENOMEM;
|
|
goto exit;
|
|
}
|
|
|
|
bytes_read = pt_flush_bus(cd, PT_FLUSH_BUS_BASED_ON_LEN, NULL);
|
|
|
|
pt_debug(dev, DL_INFO, "%s: TTDL Core Suspend\n", __func__);
|
|
disable_irq(cd->irq);
|
|
mutex_lock(&cd->system_lock);
|
|
cd->irq_disabled = true;
|
|
mutex_unlock(&cd->system_lock);
|
|
|
|
/*
|
|
* Sleep >4ms to allow any pending TTDL IRQ to finish. Without this
|
|
* the disable_irq_nosync() could cause the IRQ to get stuck asserted
|
|
*/
|
|
usleep_range(5000, 6000);
|
|
|
|
pt_debug(cd->dev, DL_INFO, ">>> %s: Write Buffer Size[%d] VERSION\n",
|
|
__func__, (int)sizeof(ver_cmd));
|
|
pt_pr_buf(cd->dev, DL_DEBUG, ver_cmd, (int)sizeof(ver_cmd),
|
|
">>> User CMD");
|
|
rc = pt_adap_write_read_specific(cd, sizeof(ver_cmd), ver_cmd, NULL);
|
|
if (rc) {
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s: BUS Test - Failed to send VER cmd\n", __func__);
|
|
*net_toggled = 0;
|
|
strcpy(err_str,
|
|
"- Write failed, bus open or shorted or DUT in reset");
|
|
goto exit_enable_irq;
|
|
}
|
|
usleep_range(4000, 5000);
|
|
bytes_read = pt_flush_bus(cd, PT_FLUSH_BUS_BASED_ON_LEN, read_buf);
|
|
pt_debug(dev, DL_INFO, "%s: BUS Test - %d bytes forced read\n",
|
|
__func__, bytes_read);
|
|
if (bytes_read == 0) {
|
|
*net_toggled = 0;
|
|
pt_debug(dev, DL_INFO, "%s: BUS Read Failed, 0 bytes read\n",
|
|
__func__);
|
|
strcpy(err_str,
|
|
"- Bus open, shorted or DUT in reset");
|
|
rc = -EIO;
|
|
goto exit_enable_irq;
|
|
} else {
|
|
if (cd->bus_ops->bustype == BUS_I2C)
|
|
*net_toggled = 1;
|
|
else {
|
|
if ((bytes_read > 3) &&
|
|
(read_buf[3] & PIP2_CMD_COMMAND_ID_MASK) ==
|
|
PIP2_CMD_ID_VERSION)
|
|
*net_toggled = 1;
|
|
else {
|
|
*net_toggled = 0;
|
|
pt_debug(dev, DL_INFO,
|
|
"%s: BUS Read Failed, %d bytes read\n",
|
|
__func__, bytes_read);
|
|
strcpy(err_str,
|
|
"- Bus open, shorted or DUT in reset");
|
|
}
|
|
}
|
|
}
|
|
|
|
exit_enable_irq:
|
|
enable_irq(cd->irq);
|
|
usleep_range(5000, 6000);
|
|
mutex_lock(&cd->system_lock);
|
|
cd->irq_disabled = false;
|
|
mutex_unlock(&cd->system_lock);
|
|
pt_debug(dev, DL_INFO, "%s: TTDL Core Resumed\n", __func__);
|
|
|
|
exit:
|
|
kfree(read_buf);
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_bist_irq_test
|
|
*
|
|
* SUMMARY: Tests the connectivity of the IRQ net
|
|
*
|
|
* This test will ensure there is a good connection between the host
|
|
* and the DUT on the irq pin. First determine if the IRQ is stuck
|
|
* asserted and if so keep reading messages off of the bus until
|
|
* it de-asserts. Possible outcomes:
|
|
* - IRQ was already de-asserted: Send a PIP command and if an
|
|
* interrupt is generated the test passes.
|
|
* - IRQ was asserted: Reading off the bus de-assertes the IRQ,
|
|
* test passes.
|
|
* - IRQ stays asserted: After reading the bus multiple times
|
|
* the IRQ stays asserted. Likely open or shorted to GND
|
|
*
|
|
* RETURN:
|
|
* 0 = Success
|
|
* !0 = Failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* *bus_toggled - pointer to where to store if bus toggled
|
|
* *irq_toggled - pointer to where to store if IRQ toggled
|
|
* *xres_toggled - pointer to where to store if XRES toggled
|
|
* *err_str - pointer to error string buffer
|
|
******************************************************************************/
|
|
static int pt_bist_irq_test(struct device *dev,
|
|
u8 *bus_toggled, u8 *irq_toggled, u8 *xres_toggled, u8 *err_str)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
u8 *read_buf = NULL;
|
|
u8 mode = PT_MODE_UNKNOWN;
|
|
u16 actual_read_len;
|
|
int bytes_read = 0;
|
|
int count = 0;
|
|
int rc = 0;
|
|
|
|
read_buf = kzalloc(PT_MAX_PIP1_MSG_SIZE, GFP_KERNEL);
|
|
if (read_buf == NULL) {
|
|
rc = -ENOMEM;
|
|
goto exit;
|
|
}
|
|
|
|
/* Clear IRQ triggered count, and re-evaluate at the end of test */
|
|
cd->irq_count = 0;
|
|
|
|
/*
|
|
* Check if IRQ is stuck asserted, if so try a non forced flush of
|
|
* the bus based on the 2 byte initial length read. Try up to 5x.
|
|
*/
|
|
while (pt_check_irq_asserted(cd) && count < 5) {
|
|
count++;
|
|
bytes_read += pt_flush_bus(cd, PT_FLUSH_BUS_BASED_ON_LEN, NULL);
|
|
}
|
|
|
|
if (count > 1 && count < 5 && bytes_read > 0) {
|
|
/*
|
|
* IRQ was stuck but data was successfully read from the
|
|
* bus releasing the IRQ line.
|
|
*/
|
|
pt_debug(dev, DL_INFO, "%s: count=%d bytes_read=%d\n",
|
|
__func__, count, bytes_read);
|
|
*bus_toggled = 1;
|
|
*irq_toggled = 1;
|
|
goto exit;
|
|
}
|
|
|
|
if (count == 5 && bytes_read == 0) {
|
|
/*
|
|
* Looped 5x and read nothing off the bus yet the IRQ is still
|
|
* asserted. Possible conditions:
|
|
* - IRQ open circuit
|
|
* - IRQ shorted to GND
|
|
* - I2C/SPI bus is disconnected
|
|
* - FW holding the pin low
|
|
* Try entering the BL to see if communication works there.
|
|
*/
|
|
mode = PT_MODE_IGNORE;
|
|
rc = _pt_request_pip2_enter_bl(dev, &mode, NULL);
|
|
if (rc) {
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s Failed to enter BL\n", __func__);
|
|
strcpy(err_str,
|
|
"- likely shorted to GND or FW holding it.");
|
|
*irq_toggled = 0;
|
|
goto exit;
|
|
}
|
|
/*
|
|
* If original mode was operational and we successfully
|
|
* entered the BL, then the XRES net must have toggled
|
|
*/
|
|
if (mode == PT_MODE_OPERATIONAL)
|
|
*xres_toggled = 1;
|
|
|
|
rc = _pt_request_pip2_send_cmd(dev, PT_CORE_CMD_PROTECTED,
|
|
PIP2_CMD_ID_VERSION, NULL, 0, read_buf,
|
|
&actual_read_len);
|
|
if (rc) {
|
|
/*
|
|
* Could not communicate to DUT in BL mode. Save the
|
|
* error string, slim chance but the XRES test below may
|
|
* show the IRQ is actually working.
|
|
*/
|
|
strcpy(err_str, "- likely shorted to GND.");
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s: %s, count=%d bytes_read=%d\n",
|
|
__func__, err_str, count, bytes_read);
|
|
*irq_toggled = 0;
|
|
rc = pt_pip2_exit_bl_(cd, NULL, 0);
|
|
goto exit;
|
|
} else {
|
|
*bus_toggled = 1;
|
|
*irq_toggled = 1;
|
|
goto exit;
|
|
}
|
|
}
|
|
if (pt_check_irq_asserted(cd)) {
|
|
strcpy(err_str, "- likely shorted to GND");
|
|
rc = -EIO;
|
|
*irq_toggled = 0;
|
|
goto exit;
|
|
}
|
|
|
|
/* Try sending a PIP command to see if we get a response */
|
|
rc = _pt_request_pip2_send_cmd(dev, PT_CORE_CMD_PROTECTED,
|
|
PIP2_CMD_ID_VERSION, NULL, 0, read_buf, &actual_read_len);
|
|
if (rc) {
|
|
/*
|
|
* Potential IRQ issue, no communication in App mode, attempt
|
|
* the same command in the BL
|
|
*/
|
|
mode = PT_MODE_IGNORE;
|
|
rc = _pt_request_pip2_enter_bl(dev, &mode, NULL);
|
|
if (rc) {
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s Failed to enter BL\n", __func__);
|
|
*irq_toggled = 0;
|
|
strcpy(err_str, "- likely open or shorted to VDDI.");
|
|
goto exit;
|
|
}
|
|
/*
|
|
* If original mode was operational and we successfully
|
|
* entered the BL, this will be useful info for the tp_xres
|
|
* test below.
|
|
*/
|
|
if (mode == PT_MODE_OPERATIONAL)
|
|
*xres_toggled = 1;
|
|
|
|
rc = _pt_request_pip2_send_cmd(dev, PT_CORE_CMD_PROTECTED,
|
|
PIP2_CMD_ID_VERSION, NULL, 0, read_buf,
|
|
&actual_read_len);
|
|
if (rc) {
|
|
/*
|
|
* Could not communicate in FW mode or BL mode. Save the
|
|
* error string, slim chance but the XRES test below may
|
|
* show the IRQ is actually working.
|
|
*/
|
|
strcpy(err_str, "- likely open or shorted to VDDI.");
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s: request_active_pip_prot failed\n",
|
|
__func__);
|
|
*irq_toggled = 0;
|
|
goto exit;
|
|
}
|
|
}
|
|
|
|
if (cd->irq_count > 0) {
|
|
pt_debug(dev, DL_INFO, "%s: irq_count=%d\n", __func__,
|
|
cd->irq_count);
|
|
*bus_toggled = 1;
|
|
*irq_toggled = 1;
|
|
goto exit;
|
|
}
|
|
|
|
exit:
|
|
kfree(read_buf);
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_bist_xres_test
|
|
*
|
|
* SUMMARY: Tests the connectivity of the TP_XRES net
|
|
*
|
|
* This test will ensure there is a good connection between the host
|
|
* and the DUT on the tp_xres pin. The pin will be toggled to
|
|
* generate a TP reset which will cause the DUT to output a reset
|
|
* sentinel. If the reset sentinel is seen the test passes. If it is
|
|
* not seen the test will attempt to send a soft reset to simply gain
|
|
* some additonal information on the failure:
|
|
* - soft reset fails to send: XRES and IRQ likely open
|
|
* - soft reset passes: XRES likely open or stuck de-asserted
|
|
* - soft reset fails: XRES likely stuck asserted
|
|
*
|
|
* RETURN:
|
|
* 0 = Success
|
|
* !0 = Failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* *bus_toggled - pointer to where to store if bus toggled
|
|
* *irq_toggled - pointer to where to store if IRQ toggled
|
|
* *xres_toggled - pointer to where to store if XRES toggled
|
|
* *err_str - pointer to error string buffer
|
|
******************************************************************************/
|
|
static int pt_bist_xres_test(struct device *dev,
|
|
u8 *bus_toggled, u8 *irq_toggled, u8 *xres_toggled, u8 *err_str)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
struct pt_platform_data *pdata = dev_get_platdata(dev);
|
|
u8 *read_buf = NULL;
|
|
u8 mode = PT_MODE_UNKNOWN;
|
|
int rc = 0;
|
|
int t = 0;
|
|
int timeout = 300;
|
|
|
|
read_buf = kzalloc(PT_MAX_PIP1_MSG_SIZE, GFP_KERNEL);
|
|
if (read_buf == NULL) {
|
|
rc = -ENOMEM;
|
|
goto exit;
|
|
}
|
|
|
|
/* Clear the startup bit mask, reset and enum will re-populate it */
|
|
cd->startup_status = STARTUP_STATUS_START;
|
|
pt_debug(dev, DL_DEBUG, "%s: Startup Status Reset\n", __func__);
|
|
|
|
if ((!pdata->core_pdata->rst_gpio) || (!pdata->core_pdata->xres)) {
|
|
strcpy(err_str, "- Net not configured or available");
|
|
rc = -ENODEV;
|
|
goto exit;
|
|
}
|
|
|
|
|
|
/* Ensure we have nothing pending on active bus */
|
|
pt_flush_bus_if_irq_asserted(cd, PT_FLUSH_BUS_BASED_ON_LEN);
|
|
|
|
/* Perform a hard XRES toggle and wait for reset sentinel */
|
|
mutex_lock(&cd->system_lock);
|
|
cd->hid_reset_cmd_state = 1;
|
|
mutex_unlock(&cd->system_lock);
|
|
pt_debug(dev, DL_INFO, "%s: Perform a hard reset\n", __func__);
|
|
rc = pt_hw_hard_reset(cd);
|
|
|
|
/* Set timeout to 1s for the flashless case where a BL could be done */
|
|
if (cd->flashless_dut)
|
|
timeout = 1000;
|
|
|
|
/*
|
|
* To avoid the case that next PIP command can be confused by BL/FW
|
|
* sentinel's "wakeup" event, chekcing hid_reset_cmd_state which is
|
|
* followed by "wakeup event" function can lower the failure rate.
|
|
*/
|
|
t = wait_event_timeout(cd->wait_q,
|
|
((cd->startup_status != STARTUP_STATUS_START)
|
|
&& (cd->hid_reset_cmd_state == 0)),
|
|
msecs_to_jiffies(timeout));
|
|
if (IS_TMO(t)) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: TMO waiting for sentinel\n", __func__);
|
|
*xres_toggled = 0;
|
|
strcpy(err_str, "- likely open. (No Reset Sentinel)");
|
|
|
|
/*
|
|
* Possibly bad FW, Try entering BL and wait for reset sentinel.
|
|
* To enter the BL we need to generate an XRES so first try to
|
|
* launch the applicaiton
|
|
*/
|
|
if (cd->mode == PT_MODE_BOOTLOADER)
|
|
pt_pip2_launch_app(dev, PT_CORE_CMD_PROTECTED);
|
|
pt_debug(dev, DL_INFO, "%s: Enter BL with a hard reset\n",
|
|
__func__);
|
|
mode = PT_MODE_IGNORE;
|
|
rc = _pt_request_pip2_enter_bl(dev, &mode, NULL);
|
|
if (rc) {
|
|
pt_debug(dev, DL_ERROR, "%s Failed to enter BL\n",
|
|
__func__);
|
|
*xres_toggled = 0;
|
|
strcpy(err_str, "- likely open or shorted to VDDI.");
|
|
goto exit;
|
|
} else {
|
|
/* Wait for the BL sentinel */
|
|
t = wait_event_timeout(cd->wait_q,
|
|
(cd->startup_status != STARTUP_STATUS_START),
|
|
msecs_to_jiffies(500));
|
|
if (IS_TMO(t)) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: TMO waiting for BL sentinel\n",
|
|
__func__);
|
|
*xres_toggled = 0;
|
|
strcpy(err_str,
|
|
"- likely open or shorted to VDDI.");
|
|
rc = -ETIME;
|
|
goto exit;
|
|
}
|
|
}
|
|
}
|
|
mutex_lock(&cd->system_lock);
|
|
cd->hid_reset_cmd_state = 0;
|
|
mutex_unlock(&cd->system_lock);
|
|
|
|
/* Look for BL or FW reset sentinels */
|
|
if (!rc && ((cd->startup_status & STARTUP_STATUS_BL_RESET_SENTINEL) ||
|
|
(cd->startup_status & STARTUP_STATUS_FW_RESET_SENTINEL))) {
|
|
pt_debug(dev, DL_INFO, "%s: hard XRES pass\n", __func__);
|
|
/* If a sentinel was seen, all nets are working */
|
|
*xres_toggled = 1;
|
|
*irq_toggled = 1;
|
|
/*
|
|
* For SPI test, bus read result can be confused as FW sentinel
|
|
* if MISO(slave) is connected to MISO(host).
|
|
*/
|
|
if (cd->bus_ops->bustype == BUS_I2C)
|
|
*bus_toggled = 1;
|
|
} else {
|
|
/*
|
|
* Hard reset failed, however some additional information
|
|
* could be determined. Try a soft reset to see if DUT resets
|
|
* with the possible outcomes:
|
|
* - if it resets the line is not stuck asserted
|
|
* - if it does not reset the line could be stuck asserted
|
|
*/
|
|
*xres_toggled = 0;
|
|
rc = pt_hw_soft_reset(cd, PT_CORE_CMD_PROTECTED);
|
|
msleep(30);
|
|
pt_debug(dev, DL_INFO, "%s: TP_XRES BIST soft reset rc=%d",
|
|
__func__, rc);
|
|
if (rc) {
|
|
strcpy(err_str, "- likely open.");
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s: Hard reset failed, soft reset failed %s\n",
|
|
__func__, err_str);
|
|
goto exit;
|
|
}
|
|
if (cd->startup_status & STARTUP_STATUS_BL_RESET_SENTINEL ||
|
|
cd->startup_status & STARTUP_STATUS_FW_RESET_SENTINEL) {
|
|
strcpy(err_str,
|
|
"- likely open or stuck high, soft reset OK");
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s: Hard reset failed, soft reset passed-%s\n",
|
|
__func__, err_str);
|
|
} else if (cd->startup_status == 0) {
|
|
strcpy(err_str, "- likely stuck high.");
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s: Hard reset failed, soft reset failed-%s\n",
|
|
__func__, err_str);
|
|
} else {
|
|
strcpy(err_str, "- open or stuck.");
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s: Hard and Soft reset failed - %s\n",
|
|
__func__, err_str);
|
|
}
|
|
}
|
|
|
|
exit:
|
|
kfree(read_buf);
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_bist_slave_irq_test
|
|
*
|
|
* SUMMARY: Tests the connectivity of the Master/Slave IRQ net
|
|
*
|
|
* This test will ensure there is a good IRQ connection between the master
|
|
* DUT and the slave DUT(s). After power up the STATUS command is sent
|
|
* and the 'Slave Detect' bits are verified to ensure the master DUT
|
|
* saw each slave trigger the IRQ with it's reset sentinel.
|
|
*
|
|
* RETURN:
|
|
* 0 = Success
|
|
* !0 = Failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* *slave_irq_toggled - pointer to where to store if slave IRQ toggled
|
|
* *slave_bus_toggled - pointer to where to store if slave Bus toggled
|
|
* *err_str - pointer to error string buffer
|
|
* *slave_detect - pointer to slave detect buffer
|
|
* *boot_err - pointer to boot_err buffer
|
|
******************************************************************************/
|
|
static int pt_bist_slave_irq_test(struct device *dev,
|
|
u8 *slave_irq_toggled, u8 *slave_bus_toggled, u8 *err_str,
|
|
u8 *slave_detect, u8 *boot_err)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
u8 mode = PT_MODE_UNKNOWN;
|
|
u8 status;
|
|
u8 boot;
|
|
u8 read_buf[12];
|
|
u8 detected = 0;
|
|
u8 last_err = -1;
|
|
u16 actual_read_len;
|
|
int result = 0;
|
|
int rc = 0;
|
|
|
|
/*
|
|
* Ensure DUT is in the BL where the STATUS cmd will report the slave
|
|
* detect bits. If the DUT was in FW, entering the BL will cause an
|
|
* XRES signal which will inadvertently test the XRES net as well
|
|
*/
|
|
rc = _pt_request_pip2_enter_bl(dev, &mode, &result);
|
|
if (rc) {
|
|
pt_debug(cd->dev, DL_WARN, "%s: Error entering BL rc=%d\n",
|
|
__func__, rc);
|
|
strcpy(err_str, "- State could not be determined.");
|
|
goto exit;
|
|
}
|
|
|
|
/* Use the STATUS command to retrieve the slave detect bit(s) */
|
|
rc = _pt_request_pip2_send_cmd(cd->dev, PT_CORE_CMD_UNPROTECTED,
|
|
PIP2_CMD_ID_STATUS, NULL, 0, read_buf,
|
|
&actual_read_len);
|
|
if (!rc) {
|
|
pt_pr_buf(cd->dev, DL_INFO, read_buf, actual_read_len,
|
|
"PIP2 STATUS");
|
|
status = read_buf[PIP2_RESP_STATUS_OFFSET];
|
|
boot = read_buf[PIP2_RESP_BODY_OFFSET] & 0x01;
|
|
|
|
/* Slave detect is only valid if status ok and in boot exec */
|
|
if (status == PIP2_RSP_ERR_NONE &&
|
|
boot == PIP2_STATUS_BOOT_EXEC) {
|
|
detected = read_buf[PIP2_RESP_BODY_OFFSET + 2] &
|
|
SLAVE_DETECT_MASK;
|
|
} else {
|
|
strcpy(err_str, "- State could not be determined");
|
|
rc = -EPERM;
|
|
}
|
|
} else {
|
|
pt_debug(cd->dev, DL_WARN, "%s: STATUS cmd failure\n",
|
|
__func__);
|
|
strcpy(err_str, "- State could not be determined.");
|
|
goto exit;
|
|
}
|
|
|
|
/*
|
|
* Retrieve boot error regardless of the state of the slave detect
|
|
* bit because the IRQ could have been stuck high or low.
|
|
*/
|
|
rc = _pt_request_pip2_send_cmd(cd->dev, PT_CORE_CMD_UNPROTECTED,
|
|
PIP2_CMD_ID_GET_LAST_ERRNO, NULL, 0,
|
|
read_buf, &actual_read_len);
|
|
if (!rc) {
|
|
pt_pr_buf(cd->dev, DL_INFO, read_buf, actual_read_len,
|
|
"PIP2 GET_LAST_ERRNO");
|
|
status = read_buf[PIP2_RESP_STATUS_OFFSET];
|
|
last_err = read_buf[PIP2_RESP_BODY_OFFSET];
|
|
if (last_err) {
|
|
pt_debug(cd->dev, DL_WARN,
|
|
"%s: Master Boot Last Err = 0x%02X\n",
|
|
__func__, last_err);
|
|
}
|
|
} else {
|
|
pt_debug(cd->dev, DL_WARN,
|
|
"%s: GET_LAST_ERRNO cmd failure\n", __func__);
|
|
strcpy(err_str, "- stuck, likely shorted to GND.");
|
|
}
|
|
|
|
exit:
|
|
pt_debug(cd->dev, DL_INFO,
|
|
"%s: rc=%d detected=0x%02X boot_err=0x%02X\n",
|
|
__func__, rc, detected, last_err);
|
|
if (err_str && last_err) {
|
|
if (detected)
|
|
sprintf(err_str, "%s 0x%02X",
|
|
"- Likely stuck low. Boot Error:",
|
|
last_err);
|
|
else
|
|
sprintf(err_str, "%s 0x%02X",
|
|
"- Likely stuck high. Boot Error:",
|
|
last_err);
|
|
}
|
|
|
|
/* Ignore an invalid image error as BIST doesn't need valid FW */
|
|
if (last_err == PIP2_RSP_ERR_INVALID_IMAGE)
|
|
last_err = PIP2_RSP_ERR_NONE;
|
|
|
|
if (slave_irq_toggled)
|
|
*slave_irq_toggled = (detected && !last_err) ? true : false;
|
|
if (slave_bus_toggled) {
|
|
/* Leave as UNTEST if slave not detected */
|
|
if (detected)
|
|
*slave_bus_toggled = !last_err ? true : false;
|
|
}
|
|
if (slave_detect)
|
|
*slave_detect = detected;
|
|
if (boot_err)
|
|
*boot_err = last_err;
|
|
|
|
pt_debug(cd->dev, DL_INFO, "%s: %s=0x%02X, %s=0x%02X, %s=0x%02X\n",
|
|
__func__,
|
|
"Detected", detected,
|
|
"slave_irq_toggled", *slave_irq_toggled,
|
|
"slave_bus_toggled", *slave_bus_toggled);
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_bist_slave_xres_test
|
|
*
|
|
* SUMMARY: Tests the connectivity of the Master/Slave TP_XRES net
|
|
*
|
|
* This test will ensure there is a good TP_XRES connection between the
|
|
* master DUT and the slave DUT(s). After toggling the XRES pin to the
|
|
* master, the STATUS command is sent and the 'Slave Detect' bits are
|
|
* verified to ensure the master DUT saw each slave trigger the IRQ with
|
|
* it's reset sentinel.
|
|
*
|
|
* RETURN:
|
|
* 0 = Success
|
|
* !0 = Failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* *slave_irq_toggled - pointer to where to store if slave IRQ toggled
|
|
* *slave_bus_toggled - pointer to where to store if slave Bus toggled
|
|
* *slave_xres_toggled - pointer to where to store if slave XRES toggled
|
|
* *err_str - pointer to error string buffer
|
|
******************************************************************************/
|
|
static int pt_bist_slave_xres_test(struct device *dev,
|
|
u8 *slave_irq_toggled, u8 *slave_bus_toggled, u8 *slave_xres_toggled,
|
|
u8 *err_str)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
u8 slave_detect = 0;
|
|
u8 boot_err = 0;
|
|
int rc = 0;
|
|
|
|
/* Force a reset to force the 'slave detect' bits to be re-aquired */
|
|
mutex_lock(&cd->system_lock);
|
|
cd->hid_reset_cmd_state = 1;
|
|
mutex_unlock(&cd->system_lock);
|
|
pt_debug(dev, DL_INFO, "%s: Perform a hard reset\n", __func__);
|
|
pt_hw_hard_reset(cd);
|
|
msleep(100);
|
|
|
|
rc = pt_bist_slave_irq_test(dev, slave_irq_toggled,
|
|
slave_bus_toggled, err_str, &slave_detect, &boot_err);
|
|
pt_debug(dev, DL_INFO, "%s: IRQ test rc = %d\n", __func__, rc);
|
|
|
|
if (!rc && *slave_irq_toggled == false) {
|
|
/*
|
|
* If the slave IRQ did not toggle, either the slave_detect
|
|
* bit was not set or we had a boot error. If the slave
|
|
* detect was not set the slave did not reset causing a boot
|
|
* error.
|
|
*/
|
|
if (!slave_detect)
|
|
strcpy(err_str, "- likely open.");
|
|
else
|
|
sprintf(err_str, "%s 0x%02X",
|
|
"- likely open or an IRQ issue. Boot Error:",
|
|
boot_err);
|
|
}
|
|
if (slave_xres_toggled) {
|
|
if (!rc)
|
|
*slave_xres_toggled = *slave_irq_toggled ? true : false;
|
|
else
|
|
*slave_xres_toggled = false;
|
|
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_bist_slave_bus_test
|
|
*
|
|
* SUMMARY: Tests the connectivity of the Master/Slave SPI bus net
|
|
*
|
|
* This test will ensure a good SPI bus connection between the
|
|
* master DUT and the slave DUT(s). This bus connection is ensured by
|
|
* opening file 0 (SRAM loader). If there is a slave and the open fails
|
|
* then there is a master/slave communication issue. Opening file 0 on
|
|
* the master will open it on the slave as well if the slave was detected.
|
|
*
|
|
* RETURN:
|
|
* 0 = Success
|
|
* !0 = Failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* *slave_irq_toggled - pointer to where to store if slave IRQ toggled
|
|
* *slave_bus_toggled - pointer to where to store if slave Bus toggled
|
|
* *err_str - pointer to error string buffer
|
|
******************************************************************************/
|
|
static int pt_bist_slave_bus_test(struct device *dev,
|
|
u8 *slave_irq_toggled, u8 *slave_bus_toggled, u8 *err_str)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
u8 mode = PT_MODE_UNKNOWN;
|
|
u8 bus_toggled = false;
|
|
u8 file_handle;
|
|
int result = 0;
|
|
int rc = 0;
|
|
|
|
rc = _pt_request_pip2_enter_bl(dev, &mode, &result);
|
|
if (rc) {
|
|
pt_debug(cd->dev, DL_WARN, "%s: Error entering BL rc=%d\n",
|
|
__func__, rc);
|
|
strcpy(err_str, "- State could not be determined.");
|
|
goto exit;
|
|
}
|
|
|
|
pt_debug(dev, DL_INFO, "%s Attempt open file 0\n", __func__);
|
|
file_handle = _pt_pip2_file_open(dev, PIP2_RAM_FILE);
|
|
if (file_handle != PIP2_RAM_FILE) {
|
|
rc = -ENOENT;
|
|
bus_toggled = false;
|
|
pt_debug(dev, DL_WARN,
|
|
"%s Failed to open bin file\n", __func__);
|
|
strcpy(err_str, "- Bus open, shorted or DUT in reset");
|
|
goto exit;
|
|
} else {
|
|
bus_toggled = true;
|
|
if (file_handle != _pt_pip2_file_close(dev, file_handle)) {
|
|
pt_debug(dev, DL_WARN,
|
|
"%s: File Close failed, file_handle=%d\n",
|
|
__func__, file_handle);
|
|
}
|
|
}
|
|
|
|
exit:
|
|
/* If the master was able to send/recv a PIP msg, the IRQ must be ok */
|
|
if (slave_irq_toggled)
|
|
*slave_irq_toggled = bus_toggled;
|
|
if (slave_bus_toggled)
|
|
*slave_bus_toggled = bus_toggled;
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_ttdl_bist_show
|
|
*
|
|
* SUMMARY: Show method for the ttdl_bist sysfs node. This built in self test
|
|
* will test that I2C/SPI, IRQ and TP_XRES pins are operational.
|
|
*
|
|
* NOTE: This function will reset the DUT and the startup_status bit
|
|
* mask. A pt_enum will be queued after completion.
|
|
*
|
|
* NOTE: The order of the net tests is done to optimize the time it takes
|
|
* to run. The first test is capable of verifying all nets, each subsequent
|
|
* test is only run if the previous was not able to see all nets toggle.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* *attr - pointer to device attributes
|
|
* *buf - pointer to output buffer
|
|
******************************************************************************/
|
|
static ssize_t pt_ttdl_bist_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
ssize_t ret;
|
|
char *bus_err_str = NULL;
|
|
char *irq_err_str = NULL;
|
|
char *xres_err_str = NULL;
|
|
char *slave_bus_err_str = NULL;
|
|
char *slave_irq_err_str = NULL;
|
|
char *slave_xres_err_str = NULL;
|
|
u8 tests;
|
|
int rc = 0;
|
|
int num_tests = 0;
|
|
int status = 1; /* 0 = Pass, !0 = fail */
|
|
u8 bus_toggled = 0x0F; /* default to untested */
|
|
u8 i2c_toggled = 0x0F; /* default to untested */
|
|
u8 spi_toggled = 0x0F; /* default to untested */
|
|
u8 irq_toggled = 0x0F; /* default to untested */
|
|
u8 xres_toggled = 0x0F; /* default to untested */
|
|
u8 slave_bus_toggled = 0x0F; /* default to untested */
|
|
u8 slave_irq_toggled = 0x0F; /* default to untested */
|
|
u8 slave_xres_toggled = 0x0F; /* default to untested */
|
|
|
|
bus_err_str = kzalloc(PT_ERR_STR_SIZE, GFP_KERNEL);
|
|
irq_err_str = kzalloc(PT_ERR_STR_SIZE, GFP_KERNEL);
|
|
xres_err_str = kzalloc(PT_ERR_STR_SIZE, GFP_KERNEL);
|
|
if (!bus_err_str || !irq_err_str || !xres_err_str)
|
|
goto print_results;
|
|
|
|
memset(xres_err_str, 0, PT_ERR_STR_SIZE);
|
|
memset(irq_err_str, 0, PT_ERR_STR_SIZE);
|
|
memset(bus_err_str, 0, PT_ERR_STR_SIZE);
|
|
|
|
if (cd->multi_chip) {
|
|
slave_bus_err_str = kzalloc(PT_ERR_STR_SIZE, GFP_KERNEL);
|
|
slave_irq_err_str = kzalloc(PT_ERR_STR_SIZE, GFP_KERNEL);
|
|
slave_xres_err_str = kzalloc(PT_ERR_STR_SIZE, GFP_KERNEL);
|
|
if (!slave_bus_err_str ||
|
|
!slave_irq_err_str ||
|
|
!slave_xres_err_str)
|
|
goto print_results;
|
|
memset(slave_bus_err_str, 0, PT_ERR_STR_SIZE);
|
|
memset(slave_irq_err_str, 0, PT_ERR_STR_SIZE);
|
|
memset(slave_xres_err_str, 0, PT_ERR_STR_SIZE);
|
|
}
|
|
|
|
/* Turn off the TTDL WD during the test */
|
|
pt_stop_wd_timer(cd);
|
|
|
|
/* Shorten default PIP cmd timeout while running BIST */
|
|
cd->pip_cmd_timeout = 200;
|
|
|
|
/* Count the number of tests to run */
|
|
tests = cd->ttdl_bist_select;
|
|
while (tests) {
|
|
num_tests += tests & 1;
|
|
tests >>= 1;
|
|
}
|
|
pt_debug(dev, DL_WARN, "%s: BIST select = 0x%02X, run %d tests\n",
|
|
__func__, cd->ttdl_bist_select, num_tests);
|
|
|
|
/* Suppress auto BL to avoid loader thread sending PIP during xres */
|
|
if (cd->flashless_dut) {
|
|
pt_debug(dev, DL_INFO, "%s Flashless Auto_BL - SUPPRESS\n",
|
|
__func__);
|
|
mutex_lock(&cd->system_lock);
|
|
cd->flashless_auto_bl = PT_SUPPRESS_AUTO_BL;
|
|
mutex_unlock(&cd->system_lock);
|
|
}
|
|
|
|
/* --------------- TP_XRES BIST TEST --------------- */
|
|
if ((cd->ttdl_bist_select & PT_TTDL_BIST_TP_XRES_TEST) != 0) {
|
|
pt_debug(dev, DL_INFO,
|
|
"%s: ----- Start TP_XRES BIST -----", __func__);
|
|
rc = pt_bist_xres_test(dev, &bus_toggled, &irq_toggled,
|
|
&xres_toggled, xres_err_str);
|
|
/* Done if the rest of all nets toggled */
|
|
if (bus_toggled == 1 && irq_toggled == 1 && xres_toggled == 1)
|
|
goto host_nets_complete;
|
|
}
|
|
|
|
/* Flush bus in case a PIP response is waiting from previous test */
|
|
pt_flush_bus(cd, PT_FLUSH_BUS_BASED_ON_LEN, NULL);
|
|
|
|
/* --------------- IRQ BIST TEST --------------- */
|
|
if ((cd->ttdl_bist_select & PT_TTDL_BIST_IRQ_TEST) != 0) {
|
|
pt_debug(dev, DL_INFO,
|
|
"%s: ----- Start IRQ BIST -----", __func__);
|
|
bus_toggled = 0xFF;
|
|
irq_toggled = 0xFF;
|
|
rc = pt_bist_irq_test(dev, &bus_toggled, &irq_toggled,
|
|
&xres_toggled, irq_err_str);
|
|
/* If this net failed clear results from previous net */
|
|
if (irq_toggled != 1) {
|
|
xres_toggled = 0x0F;
|
|
memset(xres_err_str, 0, PT_ERR_STR_SIZE);
|
|
}
|
|
if (bus_toggled == 1 && irq_toggled == 1)
|
|
goto host_nets_complete;
|
|
}
|
|
|
|
/* Flush bus in case a PIP response is waiting from previous test */
|
|
pt_flush_bus(cd, PT_FLUSH_BUS_BASED_ON_LEN, NULL);
|
|
|
|
/* --------------- BUS BIST TEST --------------- */
|
|
if ((cd->ttdl_bist_select & PT_TTDL_BIST_BUS_TEST) != 0) {
|
|
pt_debug(dev, DL_INFO,
|
|
"%s: ----- Start BUS BIST -----", __func__);
|
|
bus_toggled = 0xFF;
|
|
rc = pt_bist_bus_test(dev, &bus_toggled, bus_err_str);
|
|
/* If this net failed clear results from previous net */
|
|
if (bus_toggled == 0) {
|
|
irq_toggled = 0x0F;
|
|
memset(irq_err_str, 0, PT_ERR_STR_SIZE);
|
|
}
|
|
}
|
|
|
|
host_nets_complete:
|
|
/* --------------- SLAVE XRES BIST TEST --------------- */
|
|
if (cd->multi_chip &&
|
|
(cd->ttdl_bist_select & PT_TTDL_BIST_SLAVE_XRES_TEST) != 0) {
|
|
pt_debug(dev, DL_INFO,
|
|
"%s: ----- Start Slave XRES BIST -----", __func__);
|
|
slave_xres_toggled = 0xFF;
|
|
rc = pt_bist_slave_xres_test(dev, &slave_irq_toggled,
|
|
&slave_bus_toggled, &slave_xres_toggled,
|
|
slave_xres_err_str);
|
|
if ((slave_bus_toggled == 1 && slave_irq_toggled == 1 &&
|
|
slave_xres_toggled == 1) || slave_xres_toggled == 0)
|
|
goto print_results;
|
|
}
|
|
|
|
/* --------------- SLAVE IRQ BIST TEST --------------- */
|
|
if (cd->multi_chip &&
|
|
(cd->ttdl_bist_select & PT_TTDL_BIST_SLAVE_IRQ_TEST) != 0) {
|
|
pt_debug(dev, DL_INFO,
|
|
"%s: ----- Start Slave IRQ BIST -----", __func__);
|
|
slave_irq_toggled = 0xFF;
|
|
rc = pt_bist_slave_irq_test(dev, &slave_irq_toggled,
|
|
&slave_bus_toggled, slave_irq_err_str, NULL, NULL);
|
|
pt_debug(dev, DL_INFO, "%s: slave_irq_toggled = 0x%02X\n",
|
|
__func__, slave_irq_toggled);
|
|
if (slave_irq_toggled == 1) {
|
|
slave_bus_toggled = 1;
|
|
goto print_results;
|
|
}
|
|
}
|
|
|
|
/* --------------- SLAVE BUS BIST TEST --------------- */
|
|
if (cd->multi_chip &&
|
|
(cd->ttdl_bist_select & PT_TTDL_BIST_SLAVE_BUS_TEST) != 0) {
|
|
pt_debug(dev, DL_INFO,
|
|
"%s: ----- Start Slave BUS BIST -----", __func__);
|
|
slave_bus_toggled = 0xFF;
|
|
rc = pt_bist_slave_bus_test(dev, &slave_irq_toggled,
|
|
&slave_bus_toggled, slave_bus_err_str);
|
|
}
|
|
|
|
print_results:
|
|
/* Restore PIP command timeout */
|
|
cd->pip_cmd_timeout = cd->pip_cmd_timeout_default;
|
|
|
|
/*
|
|
* We're done! - Perform a hard XRES toggle, allowing BL
|
|
* to load FW if there is any in Flash
|
|
*/
|
|
mutex_lock(&cd->system_lock);
|
|
cd->hid_reset_cmd_state = 0;
|
|
mutex_unlock(&cd->system_lock);
|
|
|
|
pt_debug(dev, DL_INFO,
|
|
"%s: TTDL BIST Complete - Final reset\n", __func__);
|
|
|
|
if (cd->flashless_dut) {
|
|
/*
|
|
* For Flashless solution, FW update is triggered after BL is
|
|
* seen that several miliseconds delay is needed.
|
|
*/
|
|
pt_debug(dev, DL_INFO, "%s Flashless Auto_BL - ALLOW\n",
|
|
__func__);
|
|
mutex_lock(&cd->system_lock);
|
|
cd->flashless_auto_bl = PT_ALLOW_AUTO_BL;
|
|
mutex_unlock(&cd->system_lock);
|
|
|
|
/* Reset DUT and wait 100ms to see if loader started */
|
|
pt_hw_hard_reset(cd);
|
|
msleep(100);
|
|
if (cd->fw_updating) {
|
|
pt_debug(dev, DL_INFO,
|
|
"%s: ----- BIST Wait FW Loading ----",
|
|
__func__);
|
|
rc = _pt_request_wait_for_enum_state(
|
|
dev, 4000, STARTUP_STATUS_COMPLETE);
|
|
}
|
|
} else {
|
|
if (cd->mode == PT_MODE_BOOTLOADER) {
|
|
rc = pt_pip2_launch_app(dev, PT_CORE_CMD_PROTECTED);
|
|
if (rc) {
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s Failed to launch app\n", __func__);
|
|
rc = pt_hw_hard_reset(cd);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* If FW exists the BL may have just started or will start soon,
|
|
* so the FW sentinel may be on it's way but with no FW it will
|
|
* not arrive, wait for it before deciding if we need to queue
|
|
* an enum.
|
|
*/
|
|
rc = _pt_request_wait_for_enum_state(
|
|
dev, 400, STARTUP_STATUS_FW_RESET_SENTINEL);
|
|
if ((cd->startup_status & STARTUP_STATUS_FW_RESET_SENTINEL) &&
|
|
(cd->startup_status & STARTUP_STATUS_COMPLETE) == 0) {
|
|
pt_debug(dev, DL_INFO, "%s: ----- BIST Enum ----",
|
|
__func__);
|
|
pt_queue_enum(cd);
|
|
rc = _pt_request_wait_for_enum_state(
|
|
dev, 2000, STARTUP_STATUS_COMPLETE);
|
|
}
|
|
}
|
|
msleep(20);
|
|
|
|
/* --------------- PRINT OUT BIST RESULTS ---------------*/
|
|
pt_debug(dev, DL_INFO, "%s: ----- BIST Print Results ----", __func__);
|
|
pt_start_wd_timer(cd);
|
|
|
|
/* Canned print if any memory allocation issues */
|
|
if (!bus_err_str || !irq_err_str || !xres_err_str) {
|
|
ret = sprintf(buf,
|
|
"Status: %d\n"
|
|
"I2C (SDA,SCL): [UNTEST]\n"
|
|
"SPI (MISO,MOSI,CS,CLK): [UNTEST]\n"
|
|
"IRQ connection: [UNTEST]\n"
|
|
"TP_XRES connection: [UNTEST]\n", -ENOMEM);
|
|
if (cd->multi_chip) {
|
|
ret += sprintf(buf + ret,
|
|
"I/P SPI (MISO,MOSI,CS,CLK): [UNTEST]\n"
|
|
"I/P IRQ connection: [UNTEST]\n"
|
|
"I/P TP_XRES connection: [UNTEST]\n");
|
|
}
|
|
} else {
|
|
status = 0;
|
|
if (bus_toggled == 1)
|
|
memset(bus_err_str, 0, PT_ERR_STR_SIZE);
|
|
if (irq_toggled == 1)
|
|
memset(irq_err_str, 0, PT_ERR_STR_SIZE);
|
|
if (xres_toggled == 1)
|
|
memset(xres_err_str, 0, PT_ERR_STR_SIZE);
|
|
|
|
if (cd->ttdl_bist_select & PT_TTDL_BIST_BUS_TEST)
|
|
status += bus_toggled;
|
|
if (cd->ttdl_bist_select & PT_TTDL_BIST_IRQ_TEST)
|
|
status += irq_toggled;
|
|
if (cd->ttdl_bist_select & PT_TTDL_BIST_TP_XRES_TEST)
|
|
status += xres_toggled;
|
|
pt_debug(dev, DL_WARN, "%s: status = %d (%d,%d,%d)\n",
|
|
__func__, status, bus_toggled, irq_toggled,
|
|
xres_toggled);
|
|
|
|
if (cd->multi_chip) {
|
|
if (slave_irq_toggled == 1)
|
|
memset(slave_irq_err_str, 0, PT_ERR_STR_SIZE);
|
|
if (slave_xres_toggled == 1)
|
|
memset(slave_xres_err_str, 0, PT_ERR_STR_SIZE);
|
|
if (slave_bus_toggled == 1)
|
|
memset(slave_bus_err_str, 0, PT_ERR_STR_SIZE);
|
|
|
|
if (cd->ttdl_bist_select & PT_TTDL_BIST_SLAVE_BUS_TEST)
|
|
status += slave_bus_toggled;
|
|
if (cd->ttdl_bist_select & PT_TTDL_BIST_SLAVE_IRQ_TEST)
|
|
status += slave_irq_toggled;
|
|
if (cd->ttdl_bist_select & PT_TTDL_BIST_SLAVE_XRES_TEST)
|
|
status += slave_xres_toggled;
|
|
pt_debug(dev, DL_WARN,
|
|
"%s: status = %d (%d,%d,%d,%d,%d,%d)\n",
|
|
__func__, status, bus_toggled, irq_toggled,
|
|
xres_toggled, slave_bus_toggled,
|
|
slave_irq_toggled, slave_xres_toggled);
|
|
}
|
|
|
|
if (cd->bus_ops->bustype == BUS_I2C)
|
|
i2c_toggled = bus_toggled;
|
|
else
|
|
spi_toggled = bus_toggled;
|
|
|
|
ret = sprintf(buf,
|
|
"Status: %d\n"
|
|
"I2C (SDA,SCL): %s %s\n"
|
|
"SPI (MISO,MOSI,CS,CLK): %s %s\n"
|
|
"IRQ connection: %s %s\n"
|
|
"TP_XRES connection: %s %s\n",
|
|
status == num_tests ? 0 : 1,
|
|
i2c_toggled == 0x0F ? "[UNTEST]" :
|
|
i2c_toggled == 1 ? "[ OK ]" : "[FAILED]",
|
|
i2c_toggled == 0x0F ? "" : bus_err_str,
|
|
spi_toggled == 0x0F ? "[UNTEST]" :
|
|
spi_toggled == 1 ? "[ OK ]" : "[FAILED]",
|
|
spi_toggled == 0x0F ? "" : bus_err_str,
|
|
irq_toggled == 0x0F ? "[UNTEST]" :
|
|
irq_toggled == 1 ? "[ OK ]" : "[FAILED]",
|
|
irq_err_str,
|
|
xres_toggled == 0x0F ? "[UNTEST]" :
|
|
xres_toggled == 1 ? "[ OK ]" : "[FAILED]",
|
|
xres_err_str);
|
|
|
|
if (cd->multi_chip) {
|
|
ret += sprintf(buf + ret,
|
|
"I/P SPI (MISO,MOSI,CS,CLK): %s %s\n"
|
|
"I/P IRQ connection: %s %s\n"
|
|
"I/P TP_XRES connection: %s %s\n",
|
|
slave_bus_toggled == 0x0F ? "[UNTEST]" :
|
|
slave_bus_toggled == 1 ? "[ OK ]" :
|
|
"[FAILED]", slave_bus_err_str,
|
|
slave_irq_toggled == 0x0F ? "[UNTEST]" :
|
|
slave_irq_toggled == 1 ? "[ OK ]" :
|
|
"[FAILED]", slave_irq_err_str,
|
|
slave_xres_toggled == 0x0F ? "[UNTEST]" :
|
|
slave_xres_toggled == 1 ? "[ OK ]" :
|
|
"[FAILED]", slave_xres_err_str);
|
|
}
|
|
}
|
|
|
|
/* Put TTDL back into a known state, issue a ttdl enum if needed */
|
|
pt_debug(dev, DL_INFO, "%s: Startup_status = 0x%04X\n",
|
|
__func__, cd->startup_status);
|
|
kfree(bus_err_str);
|
|
kfree(irq_err_str);
|
|
kfree(xres_err_str);
|
|
return ret;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_ttdl_bist_store
|
|
*
|
|
* SUMMARY: Store method for the ttdl_bist sysfs node.
|
|
*
|
|
* RETURN: Size of passed in buffer if successful
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* *attr - pointer to device attributes
|
|
* *buf - pointer to command buffer
|
|
* size - size of buf
|
|
******************************************************************************/
|
|
static ssize_t pt_ttdl_bist_store(struct device *dev,
|
|
struct device_attribute *attr, const char *buf, size_t size)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
u32 input_data[2] = {0};
|
|
int length;
|
|
int rc = 0;
|
|
|
|
/* Maximum input of one value */
|
|
length = _pt_ic_parse_input(dev, buf, size, input_data,
|
|
ARRAY_SIZE(input_data));
|
|
if (length != 1) {
|
|
pt_debug(dev, DL_WARN, "%s: Invalid number of arguments\n",
|
|
__func__);
|
|
rc = -EINVAL;
|
|
goto exit;
|
|
} else {
|
|
mutex_lock(&cd->system_lock);
|
|
cd->ttdl_bist_select = input_data[0];
|
|
mutex_unlock(&cd->system_lock);
|
|
}
|
|
|
|
exit:
|
|
if (rc)
|
|
return rc;
|
|
return size;
|
|
}
|
|
static DEVICE_ATTR(ttdl_bist, 0644, pt_ttdl_bist_show,
|
|
pt_ttdl_bist_store);
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_flush_bus_store
|
|
*
|
|
* SUMMARY: Store method for the flush_bus sysfs node.
|
|
*
|
|
* RETURN: Size of passed in buffer if successful
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* *attr - pointer to device attributes
|
|
* *buf - pointer to command buffer
|
|
* size - size of buf
|
|
******************************************************************************/
|
|
static ssize_t pt_flush_bus_store(struct device *dev,
|
|
struct device_attribute *attr, const char *buf, size_t size)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
u32 input_data[2] = {0};
|
|
int length;
|
|
int rc = 0;
|
|
|
|
/* Maximum input of one value */
|
|
length = _pt_ic_parse_input(dev, buf, size, input_data,
|
|
ARRAY_SIZE(input_data));
|
|
if (length != 1) {
|
|
pt_debug(dev, DL_WARN, "%s: Invalid number of arguments\n",
|
|
__func__);
|
|
rc = -EINVAL;
|
|
goto exit;
|
|
}
|
|
|
|
mutex_lock(&cd->system_lock);
|
|
if (input_data[0] == 0)
|
|
cd->flush_bus_type = PT_FLUSH_BUS_BASED_ON_LEN;
|
|
else if (input_data[0] == 1)
|
|
cd->flush_bus_type = PT_FLUSH_BUS_FULL_256_READ;
|
|
else
|
|
rc = -EINVAL;
|
|
mutex_unlock(&cd->system_lock);
|
|
|
|
exit:
|
|
if (rc)
|
|
return rc;
|
|
return size;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_flush_bus_show
|
|
*
|
|
* SUMMARY: Show method for the flush_bus sysfs node that flushes the active bus
|
|
* based on either the size of the first two bytes or a blind 256 bytes.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* *attr - pointer to device attributes
|
|
* *buf - pointer to output buffer
|
|
******************************************************************************/
|
|
static ssize_t pt_flush_bus_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
ssize_t ret = 0;
|
|
ssize_t bytes = 0;
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
|
|
mutex_lock(&cd->system_lock);
|
|
bytes = pt_flush_bus(cd, cd->flush_bus_type, NULL);
|
|
|
|
ret = sprintf(buf,
|
|
"Status: 0\n"
|
|
"%s: %zd\n",
|
|
"Bytes flushed", bytes);
|
|
|
|
mutex_unlock(&cd->system_lock);
|
|
return ret;
|
|
}
|
|
static DEVICE_ATTR(flush_bus, 0644, pt_flush_bus_show,
|
|
pt_flush_bus_store);
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_pip2_ping_test_store
|
|
*
|
|
* SUMMARY: Store method for the pip2_ping_test sysfs node.
|
|
*
|
|
* NOTE: The max PIP2 packet size is 255 (payload for PING 247) however
|
|
* someone may want to test sending invalid packet lengths so any values
|
|
* up to 255 are allowed.
|
|
*
|
|
* RETURN: Size of passed in buffer if successful
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* *attr - pointer to device attributes
|
|
* *buf - pointer to command buffer
|
|
* size - size of buf
|
|
******************************************************************************/
|
|
static ssize_t pt_pip2_ping_test_store(struct device *dev,
|
|
struct device_attribute *attr, const char *buf, size_t size)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
u32 input_data[2];
|
|
int length;
|
|
int rc = 0;
|
|
|
|
/* Maximum input of one value */
|
|
length = _pt_ic_parse_input(dev, buf, size, input_data,
|
|
ARRAY_SIZE(input_data));
|
|
if (length != 1) {
|
|
pt_debug(dev, DL_WARN, "%s: Invalid number of arguments\n",
|
|
__func__);
|
|
rc = -EINVAL;
|
|
goto exit;
|
|
}
|
|
|
|
mutex_lock(&cd->system_lock);
|
|
if (input_data[1] >= 0 && input_data[0] <= PT_MAX_PIP2_MSG_SIZE)
|
|
cd->ping_test_size = input_data[0];
|
|
else
|
|
rc = -EINVAL;
|
|
mutex_unlock(&cd->system_lock);
|
|
|
|
exit:
|
|
if (rc)
|
|
return rc;
|
|
return size;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_ping_test_show
|
|
*
|
|
* SUMMARY: Show method for the ping_test_show sysfs node that sends the PIP2
|
|
* PING command and ramps up the optional payload from 0 to
|
|
* ping_test_size.
|
|
* The max payload size is 247:
|
|
* (255 - 2 byte reg address - 4 byte header - 2 byte CRC)
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* *attr - pointer to device attributes
|
|
* *buf - pointer to output buffer
|
|
******************************************************************************/
|
|
static ssize_t pt_pip2_ping_test_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
ssize_t ret;
|
|
int last_packet_size;
|
|
int rc = 0;
|
|
|
|
rc = pt_pip2_ping_test(dev, cd->ping_test_size, &last_packet_size);
|
|
|
|
if (rc) {
|
|
ret = sprintf(buf, "Status: %d\n", rc);
|
|
return ret;
|
|
}
|
|
ret = sprintf(buf,
|
|
"Status: %d\n"
|
|
"PING payload test passed with packet sizes 0 - %d\n",
|
|
(last_packet_size == cd->ping_test_size ? 0 : 1),
|
|
last_packet_size);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_t_refresh_store
|
|
*
|
|
* SUMMARY: Store method for the t-refresh sysfs node that will takes a passed
|
|
* in integer as the number of interrupts to count. A timer is started to
|
|
* calculate the total time it takes to see that number of interrupts.
|
|
*
|
|
* RETURN: Size of passed in buffer if successful
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* *attr - pointer to device attributes
|
|
* *buf - pointer to buffer that hold the command parameters
|
|
* size - size of buf
|
|
******************************************************************************/
|
|
static ssize_t pt_t_refresh_store(struct device *dev,
|
|
struct device_attribute *attr, const char *buf, size_t size)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
u32 input_data[2];
|
|
int length;
|
|
int rc = 0;
|
|
|
|
/* Maximum input of one value */
|
|
length = _pt_ic_parse_input(dev, buf, size, input_data,
|
|
ARRAY_SIZE(input_data));
|
|
if (length != 1) {
|
|
pt_debug(dev, DL_WARN, "%s: Invalid number of arguments\n",
|
|
__func__);
|
|
rc = -EINVAL;
|
|
goto exit;
|
|
}
|
|
|
|
mutex_lock(&cd->system_lock);
|
|
pt_debug(dev, DL_INFO, "%s: Input value: %d\n", __func__,
|
|
input_data[0]);
|
|
if (input_data[0] >= 0 && input_data[0] <= 1000) {
|
|
cd->t_refresh_total = input_data[0];
|
|
cd->t_refresh_count = 0;
|
|
cd->t_refresh_active = 1;
|
|
} else {
|
|
pt_debug(dev, DL_WARN, "%s: Invalid value\n", __func__);
|
|
rc = -EINVAL;
|
|
}
|
|
mutex_unlock(&cd->system_lock);
|
|
|
|
exit:
|
|
pt_debug(dev, DL_WARN, "%s: rc = %d\n", __func__, rc);
|
|
if (rc)
|
|
return rc;
|
|
return size;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_t_refresh_show
|
|
*
|
|
* SUMMARY: Show method for the t-refresh sysfs node that will show the results
|
|
* of the T-Refresh timer counting the time it takes to see a user defined
|
|
* number of interrupts.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* *attr - pointer to device attributes
|
|
* *buf - pointer to output buffer
|
|
******************************************************************************/
|
|
static ssize_t pt_t_refresh_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
ssize_t ret = 0;
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
u32 whole;
|
|
u16 fraction;
|
|
|
|
mutex_lock(&cd->system_lock);
|
|
|
|
/* Check if we have counted the number requested */
|
|
if (cd->t_refresh_count != cd->t_refresh_total) {
|
|
ret = sprintf(buf,
|
|
"Status: 0\n"
|
|
"%s: %d\n",
|
|
"Still counting... current IRQ count",
|
|
cd->t_refresh_count);
|
|
} else {
|
|
/* Ensure T-Refresh is de-activated */
|
|
cd->t_refresh_active = 0;
|
|
|
|
whole = cd->t_refresh_time / cd->t_refresh_count;
|
|
fraction = cd->t_refresh_time % cd->t_refresh_count;
|
|
fraction = fraction * 1000 / cd->t_refresh_count;
|
|
|
|
ret = sprintf(buf,
|
|
"Status: 0\n"
|
|
"%s: %d\n"
|
|
"%s: %d\n"
|
|
"%s: %d\n"
|
|
"%s: %d.%02d\n",
|
|
"Requested IRQ Count ", cd->t_refresh_total,
|
|
"IRQ Counted ", cd->t_refresh_count,
|
|
"Total Time Elapsed (ms) ", (int)cd->t_refresh_time,
|
|
"Average T-Refresh (ms) ", whole, fraction);
|
|
}
|
|
mutex_unlock(&cd->system_lock);
|
|
return ret;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_dut_status_show
|
|
*
|
|
* SUMMARY: Show method for DUT status sysfs node. Display DUT's scan state, and
|
|
* more items such as operation mode,easywake state are added in the future.
|
|
*
|
|
* RETURN: Char buffer with printed scan status information
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
* *attr - pointer to device attributes
|
|
* *buf - pointer to output buffer
|
|
******************************************************************************/
|
|
static ssize_t pt_dut_status_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
u8 sys_mode = FW_SYS_MODE_UNDEFINED;
|
|
u8 mode = PT_MODE_UNKNOWN;
|
|
char *outputstring[7] = {"BOOT", "SCANNING", "DEEP_SLEEP",
|
|
"TEST", "DEEP_STANDBY", "UNDEFINED", "n/a"};
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
ssize_t ret;
|
|
u16 calculated_crc = 0;
|
|
u16 stored_crc = 0;
|
|
u8 status;
|
|
int rc = 0;
|
|
|
|
/* In STANDBY the DUT will not repond to any PIP cmd */
|
|
if (cd->fw_sys_mode_in_standby_state) {
|
|
mode = PT_MODE_OPERATIONAL;
|
|
sys_mode = FW_SYS_MODE_DEEP_STANDBY;
|
|
goto print_limited_results;
|
|
}
|
|
|
|
/* Retrieve mode and FW system mode which can only be 0-4 */
|
|
rc = pt_get_fw_sys_mode(cd, &sys_mode, &mode);
|
|
if (rc || mode == PT_MODE_UNKNOWN) {
|
|
ret = snprintf(buf, PT_MAX_PRBUF_SIZE,
|
|
"%s: %d\n"
|
|
"%s: n/a\n"
|
|
"%s: n/a\n"
|
|
"%s: n/a\n"
|
|
"%s: n/a\n",
|
|
"Status", rc,
|
|
"Active Exec ",
|
|
"FW System Mode ",
|
|
"Stored CRC ",
|
|
"Calculated CRC ");
|
|
return ret;
|
|
} else {
|
|
if (mode == PT_MODE_OPERATIONAL) {
|
|
if (sys_mode > FW_SYS_MODE_MAX)
|
|
sys_mode = FW_SYS_MODE_UNDEFINED;
|
|
if (sys_mode != FW_SYS_MODE_TEST)
|
|
goto print_limited_results;
|
|
|
|
rc = pt_pip_verify_config_block_crc_(cd,
|
|
PT_TCH_PARM_EBID, &status,
|
|
&calculated_crc, &stored_crc);
|
|
if (rc)
|
|
goto print_limited_results;
|
|
|
|
ret = snprintf(buf, PT_MAX_PRBUF_SIZE,
|
|
"%s: %d\n"
|
|
"%s: %s\n"
|
|
"%s: %s\n"
|
|
"%s: 0x%04X\n"
|
|
"%s: 0x%04X\n",
|
|
"Status", rc,
|
|
"Active Exec ", "FW",
|
|
"FW System Mode ", outputstring[sys_mode],
|
|
"Stored CRC ", stored_crc,
|
|
"Calculated CRC ", calculated_crc);
|
|
return ret;
|
|
} else {
|
|
/* When in BL or unknon mode Active Exec is "n/a" */
|
|
sys_mode = FW_SYS_MODE_UNDEFINED + 1;
|
|
}
|
|
}
|
|
|
|
print_limited_results:
|
|
ret = snprintf(buf, PT_MAX_PRBUF_SIZE,
|
|
"%s: %d\n"
|
|
"%s: %s\n"
|
|
"%s: %s\n"
|
|
"%s: n/a\n"
|
|
"%s: n/a\n",
|
|
"Status", rc,
|
|
"Active Exec ",
|
|
mode == PT_MODE_OPERATIONAL ? "FW" : "BL",
|
|
"FW System Mode ", outputstring[sys_mode],
|
|
"Stored CRC ",
|
|
"Calculated CRC ");
|
|
|
|
return ret;
|
|
}
|
|
#endif /* TTDL_DIAGNOSTICS */
|
|
|
|
|
|
/*******************************************************************************
|
|
* Structures of sysfs attributes for all DUT dependent sysfs node
|
|
******************************************************************************/
|
|
static struct attribute *early_attrs[] = {
|
|
&dev_attr_hw_version.attr,
|
|
&dev_attr_drv_version.attr,
|
|
&dev_attr_drv_ver.attr,
|
|
&dev_attr_fw_version.attr,
|
|
&dev_attr_sysinfo.attr,
|
|
&dev_attr_pip2_cmd_rsp.attr,
|
|
&dev_attr_command.attr,
|
|
&dev_attr_drv_debug.attr,
|
|
&dev_attr_hw_reset.attr,
|
|
&dev_attr_response.attr,
|
|
&dev_attr_ttdl_restart.attr,
|
|
#ifdef TTDL_DIAGNOSTICS
|
|
&dev_attr_ttdl_status.attr,
|
|
&dev_attr_pip2_enter_bl.attr,
|
|
&dev_attr_pip2_exit_bl.attr,
|
|
&dev_attr_err_gpio.attr,
|
|
&dev_attr_flush_bus.attr,
|
|
&dev_attr_ttdl_bist.attr,
|
|
#endif /* TTDL_DIAGNOSTICS */
|
|
NULL,
|
|
};
|
|
|
|
static struct attribute_group early_attr_group = {
|
|
.attrs = early_attrs,
|
|
};
|
|
|
|
static struct device_attribute pip2_attributes[] = {
|
|
__ATTR(pip2_version, 0444, pt_pip2_version_show, NULL),
|
|
__ATTR(pip2_gpio_read, 0444, pt_pip2_gpio_read_show, NULL),
|
|
#ifdef TTDL_DIAGNOSTICS
|
|
__ATTR(pip2_bin_hdr, 0444, pt_pip2_bin_hdr_show, NULL),
|
|
__ATTR(pip2_ping_test, 0644, pt_pip2_ping_test_show,
|
|
pt_pip2_ping_test_store),
|
|
#endif
|
|
};
|
|
|
|
static struct device_attribute attributes[] = {
|
|
__ATTR(dut_debug, 0644,
|
|
pt_dut_debug_show, pt_drv_debug_store),
|
|
__ATTR(sleep_status, 0444, pt_sleep_status_show, NULL),
|
|
__ATTR(panel_id, 0444, pt_panel_id_show, NULL),
|
|
__ATTR(get_param, 0644,
|
|
pt_get_param_show, pt_get_param_store),
|
|
#ifdef EASYWAKE_TSG6
|
|
__ATTR(easy_wakeup_gesture, 0644, pt_easy_wakeup_gesture_show,
|
|
pt_easy_wakeup_gesture_store),
|
|
__ATTR(easy_wakeup_gesture_id, 0444,
|
|
pt_easy_wakeup_gesture_id_show, NULL),
|
|
__ATTR(easy_wakeup_gesture_data, 0444,
|
|
pt_easy_wakeup_gesture_data_show, NULL),
|
|
#endif
|
|
#ifdef TTDL_DIAGNOSTICS
|
|
__ATTR(platform_data, 0444, pt_platform_data_show, NULL),
|
|
__ATTR(drv_irq, 0644, pt_drv_irq_show, pt_drv_irq_store),
|
|
__ATTR(dut_status, 0444, pt_dut_status_show, NULL),
|
|
__ATTR(t_refresh, 0644, pt_t_refresh_show, pt_t_refresh_store),
|
|
#endif /* TTDL_DIAGNOSTICS */
|
|
};
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: add_sysfs_interfaces
|
|
*
|
|
* SUMMARY: Creates all DUT dependent sysfs nodes owned by the core
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
******************************************************************************/
|
|
static int add_sysfs_interfaces(struct device *dev)
|
|
{
|
|
int i;
|
|
int j = 0;
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
|
|
for (i = 0; i < ARRAY_SIZE(attributes); i++) {
|
|
if (device_create_file(dev, attributes + i))
|
|
goto undo;
|
|
}
|
|
|
|
pt_debug(dev, DL_INFO, "%s: Active DUT Generation: %d",
|
|
__func__, cd->active_dut_generation);
|
|
if (cd->active_dut_generation == DUT_PIP2_CAPABLE) {
|
|
for (j = 0; j < ARRAY_SIZE(pip2_attributes); j++) {
|
|
if (device_create_file(dev, pip2_attributes + j))
|
|
goto undo;
|
|
}
|
|
}
|
|
return 0;
|
|
undo:
|
|
for (i--; i >= 0; i--)
|
|
device_remove_file(dev, attributes + i);
|
|
for (j--; j >= 0; j--)
|
|
device_remove_file(dev, pip2_attributes + j);
|
|
pt_debug(dev, DL_ERROR, "%s: failed to create sysfs interface\n",
|
|
__func__);
|
|
return -ENODEV;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: remove_sysfs_interfaces
|
|
*
|
|
* SUMMARY: Removes all DUT dependent sysfs nodes owned by the core
|
|
*
|
|
* RETURN: void
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
******************************************************************************/
|
|
static void remove_sysfs_interfaces(struct device *dev)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(attributes); i++)
|
|
device_remove_file(dev, attributes + i);
|
|
for (i = 0; i < ARRAY_SIZE(pip2_attributes); i++)
|
|
device_remove_file(dev, pip2_attributes + i);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: remove_sysfs_and_modules
|
|
*
|
|
* SUMMARY: Removes all DUT dependent sysfs nodes and modules
|
|
*
|
|
* RETURN: void
|
|
*
|
|
* PARAMETERS:
|
|
* *dev - pointer to device structure
|
|
******************************************************************************/
|
|
static void remove_sysfs_and_modules(struct device *dev)
|
|
{
|
|
struct pt_core_data *cd = dev_get_drvdata(dev);
|
|
|
|
/* Queued work should be removed before to release loader module */
|
|
call_atten_cb(cd, PT_ATTEN_CANCEL_LOADER, 0);
|
|
pt_release_modules(cd);
|
|
pt_btn_release(dev);
|
|
pt_mt_release(dev);
|
|
remove_sysfs_interfaces(dev);
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
*******************************************************************************
|
|
* FUNCTION: pt_probe
|
|
*
|
|
* SUMMARY: Probe of the core module.
|
|
*
|
|
* NOTE: For the Parade Technologies development platform (PtSBC) the
|
|
* probe functionality is split into two functions; pt_probe() and
|
|
* pt_probe_complete(). the initial setup is done in this function which
|
|
* then creates a WORK task which runs after the probe timer expires. This
|
|
* ensures the I2C/SPI is up on the PtSBC in time for TTDL.
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *ops - pointer to the bus
|
|
* *dev - pointer to the device structure
|
|
* irq - IRQ
|
|
* xfer_buf_size - size of the buffer
|
|
******************************************************************************/
|
|
int pt_probe(const struct pt_bus_ops *ops, struct device *dev,
|
|
u16 irq, size_t xfer_buf_size)
|
|
{
|
|
struct pt_core_data *cd;
|
|
struct pt_platform_data *pdata = dev_get_platdata(dev);
|
|
enum pt_atten_type type;
|
|
int rc = 0;
|
|
u8 pip_ver_major;
|
|
u8 pip_ver_minor;
|
|
u32 status = STARTUP_STATUS_START;
|
|
|
|
if (!pdata || !pdata->core_pdata || !pdata->mt_pdata) {
|
|
pt_debug(dev, DL_ERROR, "%s: Missing platform data\n",
|
|
__func__);
|
|
rc = -ENODEV;
|
|
goto error_no_pdata;
|
|
}
|
|
|
|
if (pdata->core_pdata->flags & PT_CORE_FLAG_POWEROFF_ON_SLEEP) {
|
|
if (!pdata->core_pdata->power) {
|
|
pt_debug(dev, DL_ERROR,
|
|
"%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;
|
|
}
|
|
|
|
/* Initialize device info */
|
|
cd->dev = dev;
|
|
cd->pdata = pdata;
|
|
cd->cpdata = pdata->core_pdata;
|
|
cd->bus_ops = ops;
|
|
cd->debug_level = PT_INITIAL_DEBUG_LEVEL;
|
|
cd->show_timestamp = PT_INITIAL_SHOW_TIME_STAMP;
|
|
scnprintf(cd->core_id, 20, "%s%d", PT_CORE_NAME, core_number++);
|
|
cd->hw_detected = false;
|
|
cd->pip2_prot_active = false;
|
|
cd->pip2_send_user_cmd = false;
|
|
cd->bl_pip_ver_ready = false;
|
|
cd->app_pip_ver_ready = false;
|
|
cd->pip2_cmd_tag_seq = 0x08; /* PIP2 TAG=1 and 3 bit SEQ=0 */
|
|
cd->get_param_id = 0;
|
|
cd->watchdog_enabled = 0;
|
|
cd->startup_retry_count = 0;
|
|
cd->core_probe_complete = 0;
|
|
cd->fw_system_mode = FW_SYS_MODE_BOOT;
|
|
cd->pip_cmd_timeout = PT_PIP_CMD_DEFAULT_TIMEOUT;
|
|
cd->pip_cmd_timeout_default = PT_PIP_CMD_DEFAULT_TIMEOUT;
|
|
cd->flashless_dut = 0;
|
|
cd->flashless_auto_bl = PT_SUPPRESS_AUTO_BL;
|
|
cd->bl_with_no_int = 0;
|
|
cd->cal_cache_in_host = PT_FEATURE_DISABLE;
|
|
cd->multi_chip = PT_FEATURE_DISABLE;
|
|
cd->tthe_hid_usb_format = PT_FEATURE_DISABLE;
|
|
|
|
if (cd->cpdata->config_dut_generation == CONFIG_DUT_PIP2_CAPABLE) {
|
|
cd->set_dut_generation = true;
|
|
cd->active_dut_generation = DUT_PIP2_CAPABLE;
|
|
} else if (cd->cpdata->config_dut_generation == CONFIG_DUT_PIP1_ONLY) {
|
|
cd->set_dut_generation = true;
|
|
cd->active_dut_generation = DUT_PIP1_ONLY;
|
|
} else {
|
|
cd->set_dut_generation = false;
|
|
cd->active_dut_generation = DUT_UNKNOWN;
|
|
}
|
|
|
|
/* Initialize with platform data */
|
|
cd->watchdog_force_stop = cd->cpdata->watchdog_force_stop;
|
|
cd->watchdog_interval = PT_WATCHDOG_TIMEOUT;
|
|
cd->hid_cmd_state = 1;
|
|
cd->fw_updating = false;
|
|
cd->multi_chip = 0;
|
|
|
|
#ifdef TTDL_DIAGNOSTICS
|
|
cd->t_refresh_active = 0;
|
|
cd->t_refresh_count = 0;
|
|
cd->pip2_crc_error_count = 0;
|
|
cd->wd_xres_count = 0;
|
|
cd->bl_retry_packet_count = 0;
|
|
cd->file_erase_timeout_count = 0;
|
|
cd->show_tt_data = false;
|
|
cd->flush_bus_type = PT_FLUSH_BUS_BASED_ON_LEN;
|
|
cd->err_gpio = 0;
|
|
cd->err_gpio_type = PT_ERR_GPIO_NONE;
|
|
cd->ttdl_bist_select = 0x07;
|
|
cd->force_pip2_seq = 0;
|
|
#endif /* TTDL_DIAGNOSTICS */
|
|
|
|
|
|
memset(cd->pip2_us_file_path, 0, PT_MAX_PATH_SIZE);
|
|
memcpy(cd->pip2_us_file_path, PT_PIP2_BIN_FILE_PATH,
|
|
sizeof(PT_PIP2_BIN_FILE_PATH));
|
|
|
|
pt_init_hid_descriptor(&cd->hid_desc);
|
|
/* Read and store the 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);
|
|
|
|
/* Initialize mutexes and spinlocks */
|
|
mutex_init(&cd->module_list_lock);
|
|
mutex_init(&cd->system_lock);
|
|
mutex_init(&cd->sysfs_lock);
|
|
mutex_init(&cd->ttdl_restart_lock);
|
|
mutex_init(&cd->firmware_class_lock);
|
|
spin_lock_init(&cd->spinlock);
|
|
|
|
/* Initialize module list */
|
|
INIT_LIST_HEAD(&cd->module_list);
|
|
|
|
/* Initialize attention lists */
|
|
for (type = 0; type < PT_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->enum_work, pt_enum_work_function);
|
|
INIT_WORK(&cd->ttdl_restart_work, pt_restart_work_function);
|
|
INIT_WORK(&cd->watchdog_work, pt_watchdog_work);
|
|
|
|
/* Initialize HID specific data */
|
|
cd->hid_core.hid_vendor_id = (cd->cpdata->vendor_id) ?
|
|
cd->cpdata->vendor_id : HID_VENDOR_ID;
|
|
cd->hid_core.hid_product_id = (cd->cpdata->product_id) ?
|
|
cd->cpdata->product_id : 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 platform panel_id value */
|
|
cd->panel_id_support = cd->cpdata->panel_id_support;
|
|
|
|
if (cd->panel_id_support & PT_PANEL_ID_BY_SYS_INFO)
|
|
/* Set Panel ID to default to 0 */
|
|
cd->pid_for_loader = PT_PANEL_ID_DEFAULT;
|
|
else
|
|
/* Set Panel ID to Not Enabled */
|
|
cd->pid_for_loader = PANEL_ID_NOT_ENABLED;
|
|
/* Initialize hw_version default to FFFF.FFFF.FF */
|
|
snprintf(cd->hw_version, HW_VERSION_LEN_MAX, "FFFF.FFFF.FF");
|
|
|
|
dev_set_drvdata(dev, cd);
|
|
/* PtSBC builds will call this function in pt_probe_complete() */
|
|
pt_add_core(dev);
|
|
|
|
cd->vdd = regulator_get(cd->dev, "vdd");
|
|
if (IS_ERR(cd->vdd)) {
|
|
rc = PTR_ERR(cd->vdd);
|
|
goto error_vdd_get;
|
|
}
|
|
|
|
rc = regulator_enable(cd->vdd);
|
|
if (rc)
|
|
goto error_vdd_enable;
|
|
|
|
|
|
rc = sysfs_create_group(&dev->kobj, &early_attr_group);
|
|
if (rc)
|
|
pt_debug(cd->dev, DL_WARN, "%s:create early attrs failed\n",
|
|
__func__);
|
|
|
|
/*
|
|
* Save the pointer to a global value, which will be used
|
|
* in ttdl_restart function
|
|
*/
|
|
cd->bus_ops = ops;
|
|
|
|
/*
|
|
* When the IRQ GPIO is not direclty accessible and no function is
|
|
* defined to get the IRQ status, the IRQ passed in must be assigned
|
|
* directly as the gpio_to_irq will not work. e.g. CHROMEOS
|
|
*/
|
|
if (!cd->cpdata->irq_stat) {
|
|
cd->irq = irq;
|
|
pt_debug(cd->dev, DL_WARN, "%s:No irq_stat, Set cd->irq = %d\n",
|
|
__func__, cd->irq);
|
|
}
|
|
|
|
|
|
/* Call platform init function before setting up the GPIO's */
|
|
if (cd->cpdata->init) {
|
|
pt_debug(cd->dev, DL_INFO, "%s: Init HW\n", __func__);
|
|
rc = cd->cpdata->init(cd->cpdata, PT_MT_POWER_ON, cd->dev);
|
|
} else {
|
|
pt_debug(cd->dev, DL_WARN, "%s: No HW INIT function\n",
|
|
__func__);
|
|
rc = 0;
|
|
}
|
|
if (rc < 0) {
|
|
pt_debug(cd->dev, DL_ERROR, "%s: HW Init fail r=%d\n",
|
|
__func__, rc);
|
|
}
|
|
|
|
/* Power on any needed regulator(s) */
|
|
if (cd->cpdata->setup_power) {
|
|
pt_debug(cd->dev, DL_INFO, "%s: Device power on!\n", __func__);
|
|
rc = cd->cpdata->setup_power(cd->cpdata,
|
|
PT_MT_POWER_ON, cd->dev);
|
|
} else {
|
|
pt_debug(cd->dev, DL_WARN, "%s: No setup power function\n",
|
|
__func__);
|
|
rc = 0;
|
|
}
|
|
if (rc < 0)
|
|
pt_debug(cd->dev, DL_ERROR, "%s: Setup power on fail r=%d\n",
|
|
__func__, rc);
|
|
|
|
#ifdef TTDL_DIAGNOSTICS
|
|
cd->watchdog_irq_stuck_count = 0;
|
|
cd->bus_transmit_error_count = 0;
|
|
#endif /* TTDL_DIAGNOSTICS */
|
|
|
|
if (cd->cpdata->detect) {
|
|
pt_debug(cd->dev, DL_INFO, "%s: Detect HW\n", __func__);
|
|
rc = cd->cpdata->detect(cd->cpdata, cd->dev,
|
|
pt_platform_detect_read);
|
|
if (!rc) {
|
|
cd->hw_detected = true;
|
|
pt_debug(cd->dev, DL_INFO,
|
|
"%s: HW detected\n", __func__);
|
|
} else {
|
|
cd->hw_detected = false;
|
|
pt_debug(cd->dev, DL_INFO,
|
|
"%s: No HW detected\n", __func__);
|
|
rc = -ENODEV;
|
|
goto error_detect;
|
|
}
|
|
} else {
|
|
pt_debug(dev, DL_WARN,
|
|
"%s: PARADE No HW detect function pointer\n",
|
|
__func__);
|
|
/*
|
|
* "hw_reset" is not needed in the "if" statement,
|
|
* because "hw_reset" is already included in "hw_detect"
|
|
* function.
|
|
*/
|
|
rc = pt_hw_hard_reset(cd);
|
|
if (rc)
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: FAILED to execute HARD reset\n",
|
|
__func__);
|
|
}
|
|
|
|
if (cd->cpdata->setup_irq) {
|
|
pt_debug(cd->dev, DL_INFO, "%s: setup IRQ\n", __func__);
|
|
rc = cd->cpdata->setup_irq(cd->cpdata, PT_MT_IRQ_REG, cd->dev);
|
|
if (rc) {
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s: Error, couldn't setup IRQ\n", __func__);
|
|
goto error_setup_irq;
|
|
}
|
|
} else {
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s: IRQ function pointer not setup\n",
|
|
__func__);
|
|
goto error_setup_irq;
|
|
}
|
|
|
|
#if (KERNEL_VERSION(4, 14, 0) > LINUX_VERSION_CODE)
|
|
setup_timer(&cd->watchdog_timer, pt_watchdog_timer,
|
|
(unsigned long)cd);
|
|
#else
|
|
timer_setup(&cd->watchdog_timer, pt_watchdog_timer, 0);
|
|
#endif
|
|
pt_stop_wd_timer(cd);
|
|
|
|
#ifdef TTHE_TUNER_SUPPORT
|
|
mutex_init(&cd->tthe_lock);
|
|
cd->tthe_debugfs = debugfs_create_file(PT_TTHE_TUNER_FILE_NAME,
|
|
0644, NULL, cd, &tthe_debugfs_fops);
|
|
#endif
|
|
rc = device_init_wakeup(dev, 1);
|
|
if (rc < 0)
|
|
pt_debug(dev, DL_ERROR, "%s: Error, device_init_wakeup rc:%d\n",
|
|
__func__, rc);
|
|
|
|
pm_runtime_get_noresume(dev);
|
|
pm_runtime_set_active(dev);
|
|
pm_runtime_enable(dev);
|
|
|
|
/* If IRQ asserted, read out all from buffer to release INT pin */
|
|
if (cd->cpdata->irq_stat) {
|
|
pt_flush_bus_if_irq_asserted(cd, PT_FLUSH_BUS_BASED_ON_LEN);
|
|
} else {
|
|
/* Force a read in case the reset sentinel already arrived */
|
|
rc = pt_read_input(cd);
|
|
if (!rc)
|
|
pt_parse_input(cd);
|
|
}
|
|
|
|
/* Without sleep DUT is not ready and will NAK the first write */
|
|
msleep(150);
|
|
|
|
/* Attempt to set the DUT generation if not yet set */
|
|
if (cd->active_dut_generation == DUT_UNKNOWN) {
|
|
if (cd->bl_pip_ver_ready ||
|
|
(cd->app_pip_ver_ready &&
|
|
IS_PIP_VER_GE(&cd->sysinfo, 1, 12))) {
|
|
cd->active_dut_generation = DUT_PIP2_CAPABLE;
|
|
pt_debug(dev, DL_INFO, "%s: dut generation is %d\n",
|
|
__func__, cd->active_dut_generation);
|
|
} else {
|
|
rc = _pt_detect_dut_generation(cd->dev,
|
|
&status, &cd->active_dut_generation,
|
|
&cd->mode);
|
|
if ((cd->active_dut_generation == DUT_UNKNOWN)
|
|
|| rc) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
" === DUT Gen unknown, Skip Enum ===\n");
|
|
goto skip_enum;
|
|
}
|
|
}
|
|
}
|
|
|
|
_pt_request_active_pip_protocol(cd->dev, PT_CORE_CMD_PROTECTED,
|
|
&pip_ver_major, &pip_ver_minor);
|
|
if (pip_ver_major == 2) {
|
|
cd->bl_pip_ver_ready = true;
|
|
pt_debug(dev, DL_WARN,
|
|
" === PIP2.%d Detected, Attempt to launch APP ===\n",
|
|
pip_ver_minor);
|
|
cd->hw_detected = true;
|
|
} else if (pip_ver_major == 1) {
|
|
cd->app_pip_ver_ready = true;
|
|
pt_debug(dev, DL_WARN,
|
|
" === PIP1.%d Detected ===\n", pip_ver_minor);
|
|
cd->hw_detected = true;
|
|
} else {
|
|
cd->sysinfo.ttdata.pip_ver_major = 0;
|
|
cd->sysinfo.ttdata.pip_ver_minor = 0;
|
|
cd->app_pip_ver_ready = false;
|
|
cd->hw_detected = false;
|
|
pt_debug(dev, DL_ERROR,
|
|
" === PIP Version Not Detected, Skip Enum ===\n");
|
|
/* For legacy DUTS proceed, enum will attempt to launch app */
|
|
if (cd->active_dut_generation != DUT_PIP1_ONLY)
|
|
goto skip_enum;
|
|
}
|
|
|
|
rc = pt_enum_with_dut(cd, false, &status);
|
|
pt_debug(dev, DL_WARN, "%s: cd->startup_status=0x%04X status=0x%04X\n",
|
|
__func__, cd->startup_status, status);
|
|
if (rc == -ENODEV) {
|
|
pt_debug(cd->dev, DL_ERROR,
|
|
"%s: Enumeration Failed r=%d\n", __func__, rc);
|
|
/* For PtSBC don't error out, allow TTDL to stay up */
|
|
goto error_after_startup;
|
|
}
|
|
|
|
/* Suspend scanning until probe is complete to avoid asyc touches */
|
|
pt_pip_suspend_scanning_(cd);
|
|
|
|
if (cd->hw_detected) {
|
|
pt_debug(dev, DL_INFO, "%s: Add sysfs interfaces\n",
|
|
__func__);
|
|
rc = add_sysfs_interfaces(dev);
|
|
if (rc < 0) {
|
|
pt_debug(dev, DL_ERROR,
|
|
"%s: Error, fail sysfs init\n", __func__);
|
|
goto error_after_startup;
|
|
}
|
|
} else {
|
|
pt_debug(dev, DL_WARN,
|
|
"%s: No HW detected, sysfs interfaces not added\n",
|
|
__func__);
|
|
}
|
|
|
|
skip_enum:
|
|
pm_runtime_put_sync(dev);
|
|
|
|
pt_debug(dev, DL_INFO, "%s: Probe: MT, BTN\n", __func__);
|
|
rc = pt_mt_probe(dev);
|
|
if (rc < 0) {
|
|
pt_debug(dev, DL_ERROR, "%s: Error, fail mt probe\n",
|
|
__func__);
|
|
goto error_after_sysfs_create;
|
|
}
|
|
|
|
rc = pt_btn_probe(dev);
|
|
if (rc < 0) {
|
|
pt_debug(dev, DL_ERROR, "%s: Error, fail btn probe\n",
|
|
__func__);
|
|
goto error_after_startup_mt;
|
|
}
|
|
|
|
pt_probe_modules(cd);
|
|
|
|
#ifdef CONFIG_HAS_EARLYSUSPEND
|
|
pt_setup_early_suspend(cd);
|
|
#elif defined(CONFIG_FB)
|
|
if (!cd->cpdata->fb_blanking_disabled) {
|
|
pt_setup_fb_notifier(cd);
|
|
}
|
|
#endif
|
|
|
|
#ifdef NEED_SUSPEND_NOTIFIER
|
|
cd->pm_notifier.notifier_call = pt_pm_notifier;
|
|
register_pm_notifier(&cd->pm_notifier);
|
|
#endif
|
|
pt_pip_resume_scanning_(cd);
|
|
|
|
mutex_lock(&cd->system_lock);
|
|
cd->startup_status |= status;
|
|
cd->core_probe_complete = 1;
|
|
mutex_unlock(&cd->system_lock);
|
|
|
|
pt_debug(dev, DL_WARN, "%s: TTDL Core Probe Completed Successfully\n",
|
|
__func__);
|
|
return 0;
|
|
|
|
|
|
error_after_startup_mt:
|
|
pr_err("%s PARADE error_after_startup_mt\n", __func__);
|
|
pt_mt_release(dev);
|
|
error_after_sysfs_create:
|
|
pr_err("%s PARADE error_after_sysfs_create\n", __func__);
|
|
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->enum_work);
|
|
pt_stop_wd_timer(cd);
|
|
pt_free_si_ptrs(cd);
|
|
remove_sysfs_interfaces(dev);
|
|
|
|
error_after_startup:
|
|
pr_err("%s PARADE error_after_startup\n", __func__);
|
|
del_timer(&cd->watchdog_timer);
|
|
if (cd->cpdata->setup_irq)
|
|
cd->cpdata->setup_irq(cd->cpdata, PT_MT_IRQ_FREE, dev);
|
|
error_setup_irq:
|
|
error_detect:
|
|
if (cd->cpdata->init)
|
|
cd->cpdata->init(cd->cpdata, PT_MT_POWER_OFF, dev);
|
|
if (cd->cpdata->setup_power)
|
|
cd->cpdata->setup_power(cd->cpdata, PT_MT_POWER_OFF, dev);
|
|
sysfs_remove_group(&dev->kobj, &early_attr_group);
|
|
error_vdd_enable:
|
|
regulator_put(cd->vdd);
|
|
error_vdd_get:
|
|
pt_del_core(dev);
|
|
dev_set_drvdata(dev, NULL);
|
|
kfree(cd);
|
|
error_alloc_data:
|
|
error_no_pdata:
|
|
pr_err("%s failed.\n", __func__);
|
|
return rc;
|
|
}
|
|
EXPORT_SYMBOL_GPL(pt_probe);
|
|
|
|
/*******************************************************************************
|
|
* FUNCTION: pt_release
|
|
*
|
|
* SUMMARY: This function does the following cleanup:
|
|
* - Releases all probed modules
|
|
* - Stops the watchdog
|
|
* - Cancels all pending work tasks
|
|
* - Removes all created sysfs nodes
|
|
* - Removes all created debugfs nodes
|
|
* - Frees the IRQ
|
|
* - Deletes the core
|
|
* - Frees all pointers and HID reports
|
|
*
|
|
* RETURN:
|
|
* 0 = success
|
|
* !0 = failure
|
|
*
|
|
* PARAMETERS:
|
|
* *cd - pointer to the core data structure
|
|
******************************************************************************/
|
|
int pt_release(struct pt_core_data *cd)
|
|
{
|
|
struct device *dev = cd->dev;
|
|
|
|
/*
|
|
* 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);
|
|
|
|
/*
|
|
* Any 'work' that can trigger a new thread should be canceled first.
|
|
* The watchdog is also stopped again because another thread could have
|
|
* restarted it. The irq_work is cancelled last because it is used for
|
|
* all I2C/SPI communication.
|
|
*/
|
|
pt_stop_wd_timer(cd);
|
|
call_atten_cb(cd, PT_ATTEN_CANCEL_LOADER, 0);
|
|
cancel_work_sync(&cd->ttdl_restart_work);
|
|
cancel_work_sync(&cd->enum_work);
|
|
pt_stop_wd_timer(cd);
|
|
|
|
pt_release_modules(cd);
|
|
pt_proximity_release(dev);
|
|
pt_btn_release(dev);
|
|
pt_mt_release(dev);
|
|
|
|
#ifdef CONFIG_HAS_EARLYSUSPEND
|
|
unregister_early_suspend(&cd->es);
|
|
#elif defined(CONFIG_FB)
|
|
fb_unregister_client(&cd->fb_notifier);
|
|
#endif
|
|
|
|
#ifdef NEED_SUSPEND_NOTIFIER
|
|
unregister_pm_notifier(&cd->pm_notifier);
|
|
#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
|
|
|
|
sysfs_remove_group(&dev->kobj, &early_attr_group);
|
|
|
|
remove_sysfs_interfaces(dev);
|
|
|
|
disable_irq_nosync(cd->irq);
|
|
if (cd->cpdata->setup_irq)
|
|
cd->cpdata->setup_irq(cd->cpdata, PT_MT_IRQ_FREE, dev);
|
|
if (cd->cpdata->init)
|
|
cd->cpdata->init(cd->cpdata, PT_MT_POWER_OFF, dev);
|
|
if (cd->cpdata->setup_power)
|
|
cd->cpdata->setup_power(cd->cpdata, PT_MT_POWER_OFF, dev);
|
|
|
|
regulator_disable(cd->vdd);
|
|
regulator_put(cd->vdd);
|
|
dev_set_drvdata(dev, NULL);
|
|
pt_del_core(dev);
|
|
pt_free_si_ptrs(cd);
|
|
kfree(cd);
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL_GPL(pt_release);
|
|
|
|
|
|
MODULE_LICENSE("GPL");
|
|
MODULE_DESCRIPTION("Parade TrueTouch(R) Standard Product Core Driver");
|
|
MODULE_AUTHOR("Parade Technologies <ttdrivers@paradetech.com>");
|