forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2910 lines
83 KiB
2910 lines
83 KiB
/* |
|
* Cypress APA trackpad with I2C interface |
|
* |
|
* Author: Dudley Du <[email protected]> |
|
* |
|
* Copyright (C) 2014-2015 Cypress Semiconductor, Inc. |
|
* |
|
* This file is subject to the terms and conditions of the GNU General Public |
|
* License. See the file COPYING in the main directory of this archive for |
|
* more details. |
|
*/ |
|
|
|
#include <linux/delay.h> |
|
#include <linux/i2c.h> |
|
#include <linux/input.h> |
|
#include <linux/input/mt.h> |
|
#include <linux/mutex.h> |
|
#include <linux/completion.h> |
|
#include <linux/slab.h> |
|
#include <asm/unaligned.h> |
|
#include <linux/crc-itu-t.h> |
|
#include <linux/pm_runtime.h> |
|
#include "cyapa.h" |
|
|
|
|
|
/* Macro of TSG firmware image */ |
|
#define CYAPA_TSG_FLASH_MAP_BLOCK_SIZE 0x80 |
|
#define CYAPA_TSG_IMG_FW_HDR_SIZE 13 |
|
#define CYAPA_TSG_FW_ROW_SIZE (CYAPA_TSG_FLASH_MAP_BLOCK_SIZE) |
|
#define CYAPA_TSG_IMG_START_ROW_NUM 0x002e |
|
#define CYAPA_TSG_IMG_END_ROW_NUM 0x01fe |
|
#define CYAPA_TSG_IMG_APP_INTEGRITY_ROW_NUM 0x01ff |
|
#define CYAPA_TSG_IMG_MAX_RECORDS (CYAPA_TSG_IMG_END_ROW_NUM - \ |
|
CYAPA_TSG_IMG_START_ROW_NUM + 1 + 1) |
|
#define CYAPA_TSG_IMG_READ_SIZE (CYAPA_TSG_FLASH_MAP_BLOCK_SIZE / 2) |
|
#define CYAPA_TSG_START_OF_APPLICATION 0x1700 |
|
#define CYAPA_TSG_APP_INTEGRITY_SIZE 60 |
|
#define CYAPA_TSG_FLASH_MAP_METADATA_SIZE 60 |
|
#define CYAPA_TSG_BL_KEY_SIZE 8 |
|
|
|
#define CYAPA_TSG_MAX_CMD_SIZE 256 |
|
|
|
/* Macro of PIP interface */ |
|
#define PIP_BL_INITIATE_RESP_LEN 11 |
|
#define PIP_BL_FAIL_EXIT_RESP_LEN 11 |
|
#define PIP_BL_FAIL_EXIT_STATUS_CODE 0x0c |
|
#define PIP_BL_VERIFY_INTEGRITY_RESP_LEN 12 |
|
#define PIP_BL_INTEGRITY_CHEKC_PASS 0x00 |
|
#define PIP_BL_BLOCK_WRITE_RESP_LEN 11 |
|
|
|
#define PIP_TOUCH_REPORT_ID 0x01 |
|
#define PIP_BTN_REPORT_ID 0x03 |
|
#define PIP_WAKEUP_EVENT_REPORT_ID 0x04 |
|
#define PIP_PUSH_BTN_REPORT_ID 0x06 |
|
#define GEN5_OLD_PUSH_BTN_REPORT_ID 0x05 /* Special for old Gen5 TP. */ |
|
#define PIP_PROXIMITY_REPORT_ID 0x07 |
|
|
|
#define PIP_PROXIMITY_REPORT_SIZE 6 |
|
#define PIP_PROXIMITY_DISTANCE_OFFSET 0x05 |
|
#define PIP_PROXIMITY_DISTANCE_MASK 0x01 |
|
|
|
#define PIP_TOUCH_REPORT_HEAD_SIZE 7 |
|
#define PIP_TOUCH_REPORT_MAX_SIZE 127 |
|
#define PIP_BTN_REPORT_HEAD_SIZE 6 |
|
#define PIP_BTN_REPORT_MAX_SIZE 14 |
|
#define PIP_WAKEUP_EVENT_SIZE 4 |
|
|
|
#define PIP_NUMBER_OF_TOUCH_OFFSET 5 |
|
#define PIP_NUMBER_OF_TOUCH_MASK 0x1f |
|
#define PIP_BUTTONS_OFFSET 5 |
|
#define PIP_BUTTONS_MASK 0x0f |
|
#define PIP_GET_EVENT_ID(reg) (((reg) >> 5) & 0x03) |
|
#define PIP_GET_TOUCH_ID(reg) ((reg) & 0x1f) |
|
#define PIP_TOUCH_TYPE_FINGER 0x00 |
|
#define PIP_TOUCH_TYPE_PROXIMITY 0x01 |
|
#define PIP_TOUCH_TYPE_HOVER 0x02 |
|
#define PIP_GET_TOUCH_TYPE(reg) ((reg) & 0x07) |
|
|
|
#define RECORD_EVENT_NONE 0 |
|
#define RECORD_EVENT_TOUCHDOWN 1 |
|
#define RECORD_EVENT_DISPLACE 2 |
|
#define RECORD_EVENT_LIFTOFF 3 |
|
|
|
#define PIP_SENSING_MODE_MUTUAL_CAP_FINE 0x00 |
|
#define PIP_SENSING_MODE_SELF_CAP 0x02 |
|
|
|
#define PIP_SET_PROXIMITY 0x49 |
|
|
|
/* Macro of Gen5 */ |
|
#define GEN5_BL_MAX_OUTPUT_LENGTH 0x0100 |
|
#define GEN5_APP_MAX_OUTPUT_LENGTH 0x00fe |
|
|
|
#define GEN5_POWER_STATE_ACTIVE 0x01 |
|
#define GEN5_POWER_STATE_LOOK_FOR_TOUCH 0x02 |
|
#define GEN5_POWER_STATE_READY 0x03 |
|
#define GEN5_POWER_STATE_IDLE 0x04 |
|
#define GEN5_POWER_STATE_BTN_ONLY 0x05 |
|
#define GEN5_POWER_STATE_OFF 0x06 |
|
|
|
#define GEN5_POWER_READY_MAX_INTRVL_TIME 50 /* Unit: ms */ |
|
#define GEN5_POWER_IDLE_MAX_INTRVL_TIME 250 /* Unit: ms */ |
|
|
|
#define GEN5_CMD_GET_PARAMETER 0x05 |
|
#define GEN5_CMD_SET_PARAMETER 0x06 |
|
#define GEN5_PARAMETER_ACT_INTERVL_ID 0x4d |
|
#define GEN5_PARAMETER_ACT_INTERVL_SIZE 1 |
|
#define GEN5_PARAMETER_ACT_LFT_INTERVL_ID 0x4f |
|
#define GEN5_PARAMETER_ACT_LFT_INTERVL_SIZE 2 |
|
#define GEN5_PARAMETER_LP_INTRVL_ID 0x4c |
|
#define GEN5_PARAMETER_LP_INTRVL_SIZE 2 |
|
|
|
#define GEN5_PARAMETER_DISABLE_PIP_REPORT 0x08 |
|
|
|
#define GEN5_BL_REPORT_DESCRIPTOR_SIZE 0x1d |
|
#define GEN5_BL_REPORT_DESCRIPTOR_ID 0xfe |
|
#define GEN5_APP_REPORT_DESCRIPTOR_SIZE 0xee |
|
#define GEN5_APP_CONTRACT_REPORT_DESCRIPTOR_SIZE 0xfa |
|
#define GEN5_APP_REPORT_DESCRIPTOR_ID 0xf6 |
|
|
|
#define GEN5_RETRIEVE_MUTUAL_PWC_DATA 0x00 |
|
#define GEN5_RETRIEVE_SELF_CAP_PWC_DATA 0x01 |
|
|
|
#define GEN5_RETRIEVE_DATA_ELEMENT_SIZE_MASK 0x07 |
|
|
|
#define GEN5_CMD_EXECUTE_PANEL_SCAN 0x2a |
|
#define GEN5_CMD_RETRIEVE_PANEL_SCAN 0x2b |
|
#define GEN5_PANEL_SCAN_MUTUAL_RAW_DATA 0x00 |
|
#define GEN5_PANEL_SCAN_MUTUAL_BASELINE 0x01 |
|
#define GEN5_PANEL_SCAN_MUTUAL_DIFFCOUNT 0x02 |
|
#define GEN5_PANEL_SCAN_SELF_RAW_DATA 0x03 |
|
#define GEN5_PANEL_SCAN_SELF_BASELINE 0x04 |
|
#define GEN5_PANEL_SCAN_SELF_DIFFCOUNT 0x05 |
|
|
|
/* The offset only valid for retrieve PWC and panel scan commands */ |
|
#define GEN5_RESP_DATA_STRUCTURE_OFFSET 10 |
|
#define GEN5_PWC_DATA_ELEMENT_SIZE_MASK 0x07 |
|
|
|
|
|
struct cyapa_pip_touch_record { |
|
/* |
|
* Bit 7 - 3: reserved |
|
* Bit 2 - 0: touch type; |
|
* 0 : standard finger; |
|
* 1 : proximity (Start supported in Gen5 TP). |
|
* 2 : finger hover (defined, but not used yet.) |
|
* 3 - 15 : reserved. |
|
*/ |
|
u8 touch_type; |
|
|
|
/* |
|
* Bit 7: indicates touch liftoff status. |
|
* 0 : touch is currently on the panel. |
|
* 1 : touch record indicates a liftoff. |
|
* Bit 6 - 5: indicates an event associated with this touch instance |
|
* 0 : no event |
|
* 1 : touchdown |
|
* 2 : significant displacement (> active distance) |
|
* 3 : liftoff (record reports last known coordinates) |
|
* Bit 4 - 0: An arbitrary ID tag associated with a finger |
|
* to allow tracking a touch as it moves around the panel. |
|
*/ |
|
u8 touch_tip_event_id; |
|
|
|
/* Bit 7 - 0 of X-axis coordinate of the touch in pixel. */ |
|
u8 x_lo; |
|
|
|
/* Bit 15 - 8 of X-axis coordinate of the touch in pixel. */ |
|
u8 x_hi; |
|
|
|
/* Bit 7 - 0 of Y-axis coordinate of the touch in pixel. */ |
|
u8 y_lo; |
|
|
|
/* Bit 15 - 8 of Y-axis coordinate of the touch in pixel. */ |
|
u8 y_hi; |
|
|
|
/* |
|
* The meaning of this value is different when touch_type is different. |
|
* For standard finger type: |
|
* Touch intensity in counts, pressure value. |
|
* For proximity type (Start supported in Gen5 TP): |
|
* The distance, in surface units, between the contact and |
|
* the surface. |
|
**/ |
|
u8 z; |
|
|
|
/* |
|
* The length of the major axis of the ellipse of contact between |
|
* the finger and the panel (ABS_MT_TOUCH_MAJOR). |
|
*/ |
|
u8 major_axis_len; |
|
|
|
/* |
|
* The length of the minor axis of the ellipse of contact between |
|
* the finger and the panel (ABS_MT_TOUCH_MINOR). |
|
*/ |
|
u8 minor_axis_len; |
|
|
|
/* |
|
* The length of the major axis of the approaching tool. |
|
* (ABS_MT_WIDTH_MAJOR) |
|
*/ |
|
u8 major_tool_len; |
|
|
|
/* |
|
* The length of the minor axis of the approaching tool. |
|
* (ABS_MT_WIDTH_MINOR) |
|
*/ |
|
u8 minor_tool_len; |
|
|
|
/* |
|
* The angle between the panel vertical axis and |
|
* the major axis of the contact ellipse. This value is an 8-bit |
|
* signed integer. The range is -127 to +127 (corresponding to |
|
* -90 degree and +90 degree respectively). |
|
* The positive direction is clockwise from the vertical axis. |
|
* If the ellipse of contact degenerates into a circle, |
|
* orientation is reported as 0. |
|
*/ |
|
u8 orientation; |
|
} __packed; |
|
|
|
struct cyapa_pip_report_data { |
|
u8 report_head[PIP_TOUCH_REPORT_HEAD_SIZE]; |
|
struct cyapa_pip_touch_record touch_records[10]; |
|
} __packed; |
|
|
|
struct cyapa_tsg_bin_image_head { |
|
u8 head_size; /* Unit: bytes, including itself. */ |
|
u8 ttda_driver_major_version; /* Reserved as 0. */ |
|
u8 ttda_driver_minor_version; /* Reserved as 0. */ |
|
u8 fw_major_version; |
|
u8 fw_minor_version; |
|
u8 fw_revision_control_number[8]; |
|
u8 silicon_id_hi; |
|
u8 silicon_id_lo; |
|
u8 chip_revision; |
|
u8 family_id; |
|
u8 bl_ver_maj; |
|
u8 bl_ver_min; |
|
} __packed; |
|
|
|
struct cyapa_tsg_bin_image_data_record { |
|
u8 flash_array_id; |
|
__be16 row_number; |
|
/* The number of bytes of flash data contained in this record. */ |
|
__be16 record_len; |
|
/* The flash program data. */ |
|
u8 record_data[CYAPA_TSG_FW_ROW_SIZE]; |
|
} __packed; |
|
|
|
struct cyapa_tsg_bin_image { |
|
struct cyapa_tsg_bin_image_head image_head; |
|
struct cyapa_tsg_bin_image_data_record records[]; |
|
} __packed; |
|
|
|
struct pip_bl_packet_start { |
|
u8 sop; /* Start of packet, must be 01h */ |
|
u8 cmd_code; |
|
__le16 data_length; /* Size of data parameter start from data[0] */ |
|
} __packed; |
|
|
|
struct pip_bl_packet_end { |
|
__le16 crc; |
|
u8 eop; /* End of packet, must be 17h */ |
|
} __packed; |
|
|
|
struct pip_bl_cmd_head { |
|
__le16 addr; /* Output report register address, must be 0004h */ |
|
/* Size of packet not including output report register address */ |
|
__le16 length; |
|
u8 report_id; /* Bootloader output report id, must be 40h */ |
|
u8 rsvd; /* Reserved, must be 0 */ |
|
struct pip_bl_packet_start packet_start; |
|
u8 data[]; /* Command data variable based on commands */ |
|
} __packed; |
|
|
|
/* Initiate bootload command data structure. */ |
|
struct pip_bl_initiate_cmd_data { |
|
/* Key must be "A5h 01h 02h 03h FFh FEh FDh 5Ah" */ |
|
u8 key[CYAPA_TSG_BL_KEY_SIZE]; |
|
u8 metadata_raw_parameter[CYAPA_TSG_FLASH_MAP_METADATA_SIZE]; |
|
__le16 metadata_crc; |
|
} __packed; |
|
|
|
struct tsg_bl_metadata_row_params { |
|
__le16 size; |
|
__le16 maximum_size; |
|
__le32 app_start; |
|
__le16 app_len; |
|
__le16 app_crc; |
|
__le32 app_entry; |
|
__le32 upgrade_start; |
|
__le16 upgrade_len; |
|
__le16 entry_row_crc; |
|
u8 padding[36]; /* Padding data must be 0 */ |
|
__le16 metadata_crc; /* CRC starts at offset of 60 */ |
|
} __packed; |
|
|
|
/* Bootload program and verify row command data structure */ |
|
struct tsg_bl_flash_row_head { |
|
u8 flash_array_id; |
|
__le16 flash_row_id; |
|
u8 flash_data[]; |
|
} __packed; |
|
|
|
struct pip_app_cmd_head { |
|
__le16 addr; /* Output report register address, must be 0004h */ |
|
/* Size of packet not including output report register address */ |
|
__le16 length; |
|
u8 report_id; /* Application output report id, must be 2Fh */ |
|
u8 rsvd; /* Reserved, must be 0 */ |
|
/* |
|
* Bit 7: reserved, must be 0. |
|
* Bit 6-0: command code. |
|
*/ |
|
u8 cmd_code; |
|
u8 parameter_data[]; /* Parameter data variable based on cmd_code */ |
|
} __packed; |
|
|
|
/* Application get/set parameter command data structure */ |
|
struct gen5_app_set_parameter_data { |
|
u8 parameter_id; |
|
u8 parameter_size; |
|
__le32 value; |
|
} __packed; |
|
|
|
struct gen5_app_get_parameter_data { |
|
u8 parameter_id; |
|
} __packed; |
|
|
|
struct gen5_retrieve_panel_scan_data { |
|
__le16 read_offset; |
|
__le16 read_elements; |
|
u8 data_id; |
|
} __packed; |
|
|
|
u8 pip_read_sys_info[] = { 0x04, 0x00, 0x05, 0x00, 0x2f, 0x00, 0x02 }; |
|
u8 pip_bl_read_app_info[] = { 0x04, 0x00, 0x0b, 0x00, 0x40, 0x00, |
|
0x01, 0x3c, 0x00, 0x00, 0xb0, 0x42, 0x17 |
|
}; |
|
|
|
static u8 cyapa_pip_bl_cmd_key[] = { 0xa5, 0x01, 0x02, 0x03, |
|
0xff, 0xfe, 0xfd, 0x5a }; |
|
|
|
static int cyapa_pip_event_process(struct cyapa *cyapa, |
|
struct cyapa_pip_report_data *report_data); |
|
|
|
int cyapa_pip_cmd_state_initialize(struct cyapa *cyapa) |
|
{ |
|
struct cyapa_pip_cmd_states *pip = &cyapa->cmd_states.pip; |
|
|
|
init_completion(&pip->cmd_ready); |
|
atomic_set(&pip->cmd_issued, 0); |
|
mutex_init(&pip->cmd_lock); |
|
|
|
mutex_init(&pip->pm_stage_lock); |
|
pip->pm_stage = CYAPA_PM_DEACTIVE; |
|
|
|
pip->resp_sort_func = NULL; |
|
pip->in_progress_cmd = PIP_INVALID_CMD; |
|
pip->resp_data = NULL; |
|
pip->resp_len = NULL; |
|
|
|
cyapa->dev_pwr_mode = UNINIT_PWR_MODE; |
|
cyapa->dev_sleep_time = UNINIT_SLEEP_TIME; |
|
|
|
return 0; |
|
} |
|
|
|
/* Return negative errno, or else the number of bytes read. */ |
|
ssize_t cyapa_i2c_pip_read(struct cyapa *cyapa, u8 *buf, size_t size) |
|
{ |
|
int ret; |
|
|
|
if (size == 0) |
|
return 0; |
|
|
|
if (!buf || size > CYAPA_REG_MAP_SIZE) |
|
return -EINVAL; |
|
|
|
ret = i2c_master_recv(cyapa->client, buf, size); |
|
|
|
if (ret != size) |
|
return (ret < 0) ? ret : -EIO; |
|
return size; |
|
} |
|
|
|
/* |
|
* Return a negative errno code else zero on success. |
|
*/ |
|
ssize_t cyapa_i2c_pip_write(struct cyapa *cyapa, u8 *buf, size_t size) |
|
{ |
|
int ret; |
|
|
|
if (!buf || !size) |
|
return -EINVAL; |
|
|
|
ret = i2c_master_send(cyapa->client, buf, size); |
|
|
|
if (ret != size) |
|
return (ret < 0) ? ret : -EIO; |
|
|
|
return 0; |
|
} |
|
|
|
static void cyapa_set_pip_pm_state(struct cyapa *cyapa, |
|
enum cyapa_pm_stage pm_stage) |
|
{ |
|
struct cyapa_pip_cmd_states *pip = &cyapa->cmd_states.pip; |
|
|
|
mutex_lock(&pip->pm_stage_lock); |
|
pip->pm_stage = pm_stage; |
|
mutex_unlock(&pip->pm_stage_lock); |
|
} |
|
|
|
static void cyapa_reset_pip_pm_state(struct cyapa *cyapa) |
|
{ |
|
struct cyapa_pip_cmd_states *pip = &cyapa->cmd_states.pip; |
|
|
|
/* Indicates the pip->pm_stage is not valid. */ |
|
mutex_lock(&pip->pm_stage_lock); |
|
pip->pm_stage = CYAPA_PM_DEACTIVE; |
|
mutex_unlock(&pip->pm_stage_lock); |
|
} |
|
|
|
static enum cyapa_pm_stage cyapa_get_pip_pm_state(struct cyapa *cyapa) |
|
{ |
|
struct cyapa_pip_cmd_states *pip = &cyapa->cmd_states.pip; |
|
enum cyapa_pm_stage pm_stage; |
|
|
|
mutex_lock(&pip->pm_stage_lock); |
|
pm_stage = pip->pm_stage; |
|
mutex_unlock(&pip->pm_stage_lock); |
|
|
|
return pm_stage; |
|
} |
|
|
|
/* |
|
* This function is aimed to dump all not read data in Gen5 trackpad |
|
* before send any command, otherwise, the interrupt line will be blocked. |
|
*/ |
|
int cyapa_empty_pip_output_data(struct cyapa *cyapa, |
|
u8 *buf, int *len, cb_sort func) |
|
{ |
|
struct input_dev *input = cyapa->input; |
|
struct cyapa_pip_cmd_states *pip = &cyapa->cmd_states.pip; |
|
enum cyapa_pm_stage pm_stage = cyapa_get_pip_pm_state(cyapa); |
|
int length; |
|
int report_count; |
|
int empty_count; |
|
int buf_len; |
|
int error; |
|
|
|
buf_len = 0; |
|
if (len) { |
|
buf_len = (*len < CYAPA_REG_MAP_SIZE) ? |
|
*len : CYAPA_REG_MAP_SIZE; |
|
*len = 0; |
|
} |
|
|
|
report_count = 8; /* max 7 pending data before command response data */ |
|
empty_count = 0; |
|
do { |
|
/* |
|
* Depending on testing in cyapa driver, there are max 5 "02 00" |
|
* packets between two valid buffered data report in firmware. |
|
* So in order to dump all buffered data out and |
|
* make interrupt line release for reassert again, |
|
* we must set the empty_count check value bigger than 5 to |
|
* make it work. Otherwise, in some situation, |
|
* the interrupt line may unable to reactive again, |
|
* which will cause trackpad device unable to |
|
* report data any more. |
|
* for example, it may happen in EFT and ESD testing. |
|
*/ |
|
if (empty_count > 5) |
|
return 0; |
|
|
|
error = cyapa_i2c_pip_read(cyapa, pip->empty_buf, |
|
PIP_RESP_LENGTH_SIZE); |
|
if (error < 0) |
|
return error; |
|
|
|
length = get_unaligned_le16(pip->empty_buf); |
|
if (length == PIP_RESP_LENGTH_SIZE) { |
|
empty_count++; |
|
continue; |
|
} else if (length > CYAPA_REG_MAP_SIZE) { |
|
/* Should not happen */ |
|
return -EINVAL; |
|
} else if (length == 0) { |
|
/* Application or bootloader launch data polled out. */ |
|
length = PIP_RESP_LENGTH_SIZE; |
|
if (buf && buf_len && func && |
|
func(cyapa, pip->empty_buf, length)) { |
|
length = min(buf_len, length); |
|
memcpy(buf, pip->empty_buf, length); |
|
*len = length; |
|
/* Response found, success. */ |
|
return 0; |
|
} |
|
continue; |
|
} |
|
|
|
error = cyapa_i2c_pip_read(cyapa, pip->empty_buf, length); |
|
if (error < 0) |
|
return error; |
|
|
|
report_count--; |
|
empty_count = 0; |
|
length = get_unaligned_le16(pip->empty_buf); |
|
if (length <= PIP_RESP_LENGTH_SIZE) { |
|
empty_count++; |
|
} else if (buf && buf_len && func && |
|
func(cyapa, pip->empty_buf, length)) { |
|
length = min(buf_len, length); |
|
memcpy(buf, pip->empty_buf, length); |
|
*len = length; |
|
/* Response found, success. */ |
|
return 0; |
|
} else if (cyapa->operational && |
|
input && input_device_enabled(input) && |
|
(pm_stage == CYAPA_PM_RUNTIME_RESUME || |
|
pm_stage == CYAPA_PM_RUNTIME_SUSPEND)) { |
|
/* Parse the data and report it if it's valid. */ |
|
cyapa_pip_event_process(cyapa, |
|
(struct cyapa_pip_report_data *)pip->empty_buf); |
|
} |
|
|
|
error = -EINVAL; |
|
} while (report_count); |
|
|
|
return error; |
|
} |
|
|
|
static int cyapa_do_i2c_pip_cmd_irq_sync( |
|
struct cyapa *cyapa, |
|
u8 *cmd, size_t cmd_len, |
|
unsigned long timeout) |
|
{ |
|
struct cyapa_pip_cmd_states *pip = &cyapa->cmd_states.pip; |
|
int error; |
|
|
|
/* Wait for interrupt to set ready completion */ |
|
init_completion(&pip->cmd_ready); |
|
|
|
atomic_inc(&pip->cmd_issued); |
|
error = cyapa_i2c_pip_write(cyapa, cmd, cmd_len); |
|
if (error) { |
|
atomic_dec(&pip->cmd_issued); |
|
return (error < 0) ? error : -EIO; |
|
} |
|
|
|
/* Wait for interrupt to indicate command is completed. */ |
|
timeout = wait_for_completion_timeout(&pip->cmd_ready, |
|
msecs_to_jiffies(timeout)); |
|
if (timeout == 0) { |
|
atomic_dec(&pip->cmd_issued); |
|
return -ETIMEDOUT; |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
static int cyapa_do_i2c_pip_cmd_polling( |
|
struct cyapa *cyapa, |
|
u8 *cmd, size_t cmd_len, |
|
u8 *resp_data, int *resp_len, |
|
unsigned long timeout, |
|
cb_sort func) |
|
{ |
|
struct cyapa_pip_cmd_states *pip = &cyapa->cmd_states.pip; |
|
int tries; |
|
int length; |
|
int error; |
|
|
|
atomic_inc(&pip->cmd_issued); |
|
error = cyapa_i2c_pip_write(cyapa, cmd, cmd_len); |
|
if (error) { |
|
atomic_dec(&pip->cmd_issued); |
|
return error < 0 ? error : -EIO; |
|
} |
|
|
|
length = resp_len ? *resp_len : 0; |
|
if (resp_data && resp_len && length != 0 && func) { |
|
tries = timeout / 5; |
|
do { |
|
usleep_range(3000, 5000); |
|
*resp_len = length; |
|
error = cyapa_empty_pip_output_data(cyapa, |
|
resp_data, resp_len, func); |
|
if (error || *resp_len == 0) |
|
continue; |
|
else |
|
break; |
|
} while (--tries > 0); |
|
if ((error || *resp_len == 0) || tries <= 0) |
|
error = error ? error : -ETIMEDOUT; |
|
} |
|
|
|
atomic_dec(&pip->cmd_issued); |
|
return error; |
|
} |
|
|
|
int cyapa_i2c_pip_cmd_irq_sync( |
|
struct cyapa *cyapa, |
|
u8 *cmd, int cmd_len, |
|
u8 *resp_data, int *resp_len, |
|
unsigned long timeout, |
|
cb_sort func, |
|
bool irq_mode) |
|
{ |
|
struct cyapa_pip_cmd_states *pip = &cyapa->cmd_states.pip; |
|
int error; |
|
|
|
if (!cmd || !cmd_len) |
|
return -EINVAL; |
|
|
|
/* Commands must be serialized. */ |
|
error = mutex_lock_interruptible(&pip->cmd_lock); |
|
if (error) |
|
return error; |
|
|
|
pip->resp_sort_func = func; |
|
pip->resp_data = resp_data; |
|
pip->resp_len = resp_len; |
|
|
|
if (cmd_len >= PIP_MIN_APP_CMD_LENGTH && |
|
cmd[4] == PIP_APP_CMD_REPORT_ID) { |
|
/* Application command */ |
|
pip->in_progress_cmd = cmd[6] & 0x7f; |
|
} else if (cmd_len >= PIP_MIN_BL_CMD_LENGTH && |
|
cmd[4] == PIP_BL_CMD_REPORT_ID) { |
|
/* Bootloader command */ |
|
pip->in_progress_cmd = cmd[7]; |
|
} |
|
|
|
/* Send command data, wait and read output response data's length. */ |
|
if (irq_mode) { |
|
pip->is_irq_mode = true; |
|
error = cyapa_do_i2c_pip_cmd_irq_sync(cyapa, cmd, cmd_len, |
|
timeout); |
|
if (error == -ETIMEDOUT && resp_data && |
|
resp_len && *resp_len != 0 && func) { |
|
/* |
|
* For some old version, there was no interrupt for |
|
* the command response data, so need to poll here |
|
* to try to get the response data. |
|
*/ |
|
error = cyapa_empty_pip_output_data(cyapa, |
|
resp_data, resp_len, func); |
|
if (error || *resp_len == 0) |
|
error = error ? error : -ETIMEDOUT; |
|
} |
|
} else { |
|
pip->is_irq_mode = false; |
|
error = cyapa_do_i2c_pip_cmd_polling(cyapa, cmd, cmd_len, |
|
resp_data, resp_len, timeout, func); |
|
} |
|
|
|
pip->resp_sort_func = NULL; |
|
pip->resp_data = NULL; |
|
pip->resp_len = NULL; |
|
pip->in_progress_cmd = PIP_INVALID_CMD; |
|
|
|
mutex_unlock(&pip->cmd_lock); |
|
return error; |
|
} |
|
|
|
bool cyapa_sort_tsg_pip_bl_resp_data(struct cyapa *cyapa, |
|
u8 *data, int len) |
|
{ |
|
if (!data || len < PIP_MIN_BL_RESP_LENGTH) |
|
return false; |
|
|
|
/* Bootloader input report id 30h */ |
|
if (data[PIP_RESP_REPORT_ID_OFFSET] == PIP_BL_RESP_REPORT_ID && |
|
data[PIP_RESP_RSVD_OFFSET] == PIP_RESP_RSVD_KEY && |
|
data[PIP_RESP_BL_SOP_OFFSET] == PIP_SOP_KEY) |
|
return true; |
|
|
|
return false; |
|
} |
|
|
|
bool cyapa_sort_tsg_pip_app_resp_data(struct cyapa *cyapa, |
|
u8 *data, int len) |
|
{ |
|
struct cyapa_pip_cmd_states *pip = &cyapa->cmd_states.pip; |
|
int resp_len; |
|
|
|
if (!data || len < PIP_MIN_APP_RESP_LENGTH) |
|
return false; |
|
|
|
if (data[PIP_RESP_REPORT_ID_OFFSET] == PIP_APP_RESP_REPORT_ID && |
|
data[PIP_RESP_RSVD_OFFSET] == PIP_RESP_RSVD_KEY) { |
|
resp_len = get_unaligned_le16(&data[PIP_RESP_LENGTH_OFFSET]); |
|
if (GET_PIP_CMD_CODE(data[PIP_RESP_APP_CMD_OFFSET]) == 0x00 && |
|
resp_len == PIP_UNSUPPORTED_CMD_RESP_LENGTH && |
|
data[5] == pip->in_progress_cmd) { |
|
/* Unsupported command code */ |
|
return false; |
|
} else if (GET_PIP_CMD_CODE(data[PIP_RESP_APP_CMD_OFFSET]) == |
|
pip->in_progress_cmd) { |
|
/* Correct command response received */ |
|
return true; |
|
} |
|
} |
|
|
|
return false; |
|
} |
|
|
|
static bool cyapa_sort_pip_application_launch_data(struct cyapa *cyapa, |
|
u8 *buf, int len) |
|
{ |
|
if (buf == NULL || len < PIP_RESP_LENGTH_SIZE) |
|
return false; |
|
|
|
/* |
|
* After reset or power on, trackpad device always sets to 0x00 0x00 |
|
* to indicate a reset or power on event. |
|
*/ |
|
if (buf[0] == 0 && buf[1] == 0) |
|
return true; |
|
|
|
return false; |
|
} |
|
|
|
static bool cyapa_sort_gen5_hid_descriptor_data(struct cyapa *cyapa, |
|
u8 *buf, int len) |
|
{ |
|
int resp_len; |
|
int max_output_len; |
|
|
|
/* Check hid descriptor. */ |
|
if (len != PIP_HID_DESCRIPTOR_SIZE) |
|
return false; |
|
|
|
resp_len = get_unaligned_le16(&buf[PIP_RESP_LENGTH_OFFSET]); |
|
max_output_len = get_unaligned_le16(&buf[16]); |
|
if (resp_len == PIP_HID_DESCRIPTOR_SIZE) { |
|
if (buf[PIP_RESP_REPORT_ID_OFFSET] == PIP_HID_BL_REPORT_ID && |
|
max_output_len == GEN5_BL_MAX_OUTPUT_LENGTH) { |
|
/* BL mode HID Descriptor */ |
|
return true; |
|
} else if ((buf[PIP_RESP_REPORT_ID_OFFSET] == |
|
PIP_HID_APP_REPORT_ID) && |
|
max_output_len == GEN5_APP_MAX_OUTPUT_LENGTH) { |
|
/* APP mode HID Descriptor */ |
|
return true; |
|
} |
|
} |
|
|
|
return false; |
|
} |
|
|
|
static bool cyapa_sort_pip_deep_sleep_data(struct cyapa *cyapa, |
|
u8 *buf, int len) |
|
{ |
|
if (len == PIP_DEEP_SLEEP_RESP_LENGTH && |
|
buf[PIP_RESP_REPORT_ID_OFFSET] == |
|
PIP_APP_DEEP_SLEEP_REPORT_ID && |
|
(buf[4] & PIP_DEEP_SLEEP_OPCODE_MASK) == |
|
PIP_DEEP_SLEEP_OPCODE) |
|
return true; |
|
return false; |
|
} |
|
|
|
static int gen5_idle_state_parse(struct cyapa *cyapa) |
|
{ |
|
u8 resp_data[PIP_HID_DESCRIPTOR_SIZE]; |
|
int max_output_len; |
|
int length; |
|
u8 cmd[2]; |
|
int ret; |
|
int error; |
|
|
|
/* |
|
* Dump all buffered data firstly for the situation |
|
* when the trackpad is just power on the cyapa go here. |
|
*/ |
|
cyapa_empty_pip_output_data(cyapa, NULL, NULL, NULL); |
|
|
|
memset(resp_data, 0, sizeof(resp_data)); |
|
ret = cyapa_i2c_pip_read(cyapa, resp_data, 3); |
|
if (ret != 3) |
|
return ret < 0 ? ret : -EIO; |
|
|
|
length = get_unaligned_le16(&resp_data[PIP_RESP_LENGTH_OFFSET]); |
|
if (length == PIP_RESP_LENGTH_SIZE) { |
|
/* Normal state of Gen5 with no data to response */ |
|
cyapa->gen = CYAPA_GEN5; |
|
|
|
cyapa_empty_pip_output_data(cyapa, NULL, NULL, NULL); |
|
|
|
/* Read description from trackpad device */ |
|
cmd[0] = 0x01; |
|
cmd[1] = 0x00; |
|
length = PIP_HID_DESCRIPTOR_SIZE; |
|
error = cyapa_i2c_pip_cmd_irq_sync(cyapa, |
|
cmd, PIP_RESP_LENGTH_SIZE, |
|
resp_data, &length, |
|
300, |
|
cyapa_sort_gen5_hid_descriptor_data, |
|
false); |
|
if (error) |
|
return error; |
|
|
|
length = get_unaligned_le16( |
|
&resp_data[PIP_RESP_LENGTH_OFFSET]); |
|
max_output_len = get_unaligned_le16(&resp_data[16]); |
|
if ((length == PIP_HID_DESCRIPTOR_SIZE || |
|
length == PIP_RESP_LENGTH_SIZE) && |
|
(resp_data[PIP_RESP_REPORT_ID_OFFSET] == |
|
PIP_HID_BL_REPORT_ID) && |
|
max_output_len == GEN5_BL_MAX_OUTPUT_LENGTH) { |
|
/* BL mode HID Description read */ |
|
cyapa->state = CYAPA_STATE_GEN5_BL; |
|
} else if ((length == PIP_HID_DESCRIPTOR_SIZE || |
|
length == PIP_RESP_LENGTH_SIZE) && |
|
(resp_data[PIP_RESP_REPORT_ID_OFFSET] == |
|
PIP_HID_APP_REPORT_ID) && |
|
max_output_len == GEN5_APP_MAX_OUTPUT_LENGTH) { |
|
/* APP mode HID Description read */ |
|
cyapa->state = CYAPA_STATE_GEN5_APP; |
|
} else { |
|
/* Should not happen!!! */ |
|
cyapa->state = CYAPA_STATE_NO_DEVICE; |
|
} |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
static int gen5_hid_description_header_parse(struct cyapa *cyapa, u8 *reg_data) |
|
{ |
|
int length; |
|
u8 resp_data[32]; |
|
int max_output_len; |
|
int ret; |
|
|
|
/* 0x20 0x00 0xF7 is Gen5 Application HID Description Header; |
|
* 0x20 0x00 0xFF is Gen5 Bootloader HID Description Header. |
|
* |
|
* Must read HID Description content through out, |
|
* otherwise Gen5 trackpad cannot response next command |
|
* or report any touch or button data. |
|
*/ |
|
ret = cyapa_i2c_pip_read(cyapa, resp_data, |
|
PIP_HID_DESCRIPTOR_SIZE); |
|
if (ret != PIP_HID_DESCRIPTOR_SIZE) |
|
return ret < 0 ? ret : -EIO; |
|
length = get_unaligned_le16(&resp_data[PIP_RESP_LENGTH_OFFSET]); |
|
max_output_len = get_unaligned_le16(&resp_data[16]); |
|
if (length == PIP_RESP_LENGTH_SIZE) { |
|
if (reg_data[PIP_RESP_REPORT_ID_OFFSET] == |
|
PIP_HID_BL_REPORT_ID) { |
|
/* |
|
* BL mode HID Description has been previously |
|
* read out. |
|
*/ |
|
cyapa->gen = CYAPA_GEN5; |
|
cyapa->state = CYAPA_STATE_GEN5_BL; |
|
} else { |
|
/* |
|
* APP mode HID Description has been previously |
|
* read out. |
|
*/ |
|
cyapa->gen = CYAPA_GEN5; |
|
cyapa->state = CYAPA_STATE_GEN5_APP; |
|
} |
|
} else if (length == PIP_HID_DESCRIPTOR_SIZE && |
|
resp_data[2] == PIP_HID_BL_REPORT_ID && |
|
max_output_len == GEN5_BL_MAX_OUTPUT_LENGTH) { |
|
/* BL mode HID Description read. */ |
|
cyapa->gen = CYAPA_GEN5; |
|
cyapa->state = CYAPA_STATE_GEN5_BL; |
|
} else if (length == PIP_HID_DESCRIPTOR_SIZE && |
|
(resp_data[PIP_RESP_REPORT_ID_OFFSET] == |
|
PIP_HID_APP_REPORT_ID) && |
|
max_output_len == GEN5_APP_MAX_OUTPUT_LENGTH) { |
|
/* APP mode HID Description read. */ |
|
cyapa->gen = CYAPA_GEN5; |
|
cyapa->state = CYAPA_STATE_GEN5_APP; |
|
} else { |
|
/* Should not happen!!! */ |
|
cyapa->state = CYAPA_STATE_NO_DEVICE; |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
static int gen5_report_data_header_parse(struct cyapa *cyapa, u8 *reg_data) |
|
{ |
|
int length; |
|
|
|
length = get_unaligned_le16(®_data[PIP_RESP_LENGTH_OFFSET]); |
|
switch (reg_data[PIP_RESP_REPORT_ID_OFFSET]) { |
|
case PIP_TOUCH_REPORT_ID: |
|
if (length < PIP_TOUCH_REPORT_HEAD_SIZE || |
|
length > PIP_TOUCH_REPORT_MAX_SIZE) |
|
return -EINVAL; |
|
break; |
|
case PIP_BTN_REPORT_ID: |
|
case GEN5_OLD_PUSH_BTN_REPORT_ID: |
|
case PIP_PUSH_BTN_REPORT_ID: |
|
if (length < PIP_BTN_REPORT_HEAD_SIZE || |
|
length > PIP_BTN_REPORT_MAX_SIZE) |
|
return -EINVAL; |
|
break; |
|
case PIP_WAKEUP_EVENT_REPORT_ID: |
|
if (length != PIP_WAKEUP_EVENT_SIZE) |
|
return -EINVAL; |
|
break; |
|
default: |
|
return -EINVAL; |
|
} |
|
|
|
cyapa->gen = CYAPA_GEN5; |
|
cyapa->state = CYAPA_STATE_GEN5_APP; |
|
return 0; |
|
} |
|
|
|
static int gen5_cmd_resp_header_parse(struct cyapa *cyapa, u8 *reg_data) |
|
{ |
|
struct cyapa_pip_cmd_states *pip = &cyapa->cmd_states.pip; |
|
int length; |
|
int ret; |
|
|
|
/* |
|
* Must read report data through out, |
|
* otherwise Gen5 trackpad cannot response next command |
|
* or report any touch or button data. |
|
*/ |
|
length = get_unaligned_le16(®_data[PIP_RESP_LENGTH_OFFSET]); |
|
ret = cyapa_i2c_pip_read(cyapa, pip->empty_buf, length); |
|
if (ret != length) |
|
return ret < 0 ? ret : -EIO; |
|
|
|
if (length == PIP_RESP_LENGTH_SIZE) { |
|
/* Previous command has read the data through out. */ |
|
if (reg_data[PIP_RESP_REPORT_ID_OFFSET] == |
|
PIP_BL_RESP_REPORT_ID) { |
|
/* Gen5 BL command response data detected */ |
|
cyapa->gen = CYAPA_GEN5; |
|
cyapa->state = CYAPA_STATE_GEN5_BL; |
|
} else { |
|
/* Gen5 APP command response data detected */ |
|
cyapa->gen = CYAPA_GEN5; |
|
cyapa->state = CYAPA_STATE_GEN5_APP; |
|
} |
|
} else if ((pip->empty_buf[PIP_RESP_REPORT_ID_OFFSET] == |
|
PIP_BL_RESP_REPORT_ID) && |
|
(pip->empty_buf[PIP_RESP_RSVD_OFFSET] == |
|
PIP_RESP_RSVD_KEY) && |
|
(pip->empty_buf[PIP_RESP_BL_SOP_OFFSET] == |
|
PIP_SOP_KEY) && |
|
(pip->empty_buf[length - 1] == |
|
PIP_EOP_KEY)) { |
|
/* Gen5 BL command response data detected */ |
|
cyapa->gen = CYAPA_GEN5; |
|
cyapa->state = CYAPA_STATE_GEN5_BL; |
|
} else if (pip->empty_buf[PIP_RESP_REPORT_ID_OFFSET] == |
|
PIP_APP_RESP_REPORT_ID && |
|
pip->empty_buf[PIP_RESP_RSVD_OFFSET] == |
|
PIP_RESP_RSVD_KEY) { |
|
/* Gen5 APP command response data detected */ |
|
cyapa->gen = CYAPA_GEN5; |
|
cyapa->state = CYAPA_STATE_GEN5_APP; |
|
} else { |
|
/* Should not happen!!! */ |
|
cyapa->state = CYAPA_STATE_NO_DEVICE; |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
static int cyapa_gen5_state_parse(struct cyapa *cyapa, u8 *reg_data, int len) |
|
{ |
|
int length; |
|
|
|
if (!reg_data || len < 3) |
|
return -EINVAL; |
|
|
|
cyapa->state = CYAPA_STATE_NO_DEVICE; |
|
|
|
/* Parse based on Gen5 characteristic registers and bits */ |
|
length = get_unaligned_le16(®_data[PIP_RESP_LENGTH_OFFSET]); |
|
if (length == 0 || length == PIP_RESP_LENGTH_SIZE) { |
|
gen5_idle_state_parse(cyapa); |
|
} else if (length == PIP_HID_DESCRIPTOR_SIZE && |
|
(reg_data[2] == PIP_HID_BL_REPORT_ID || |
|
reg_data[2] == PIP_HID_APP_REPORT_ID)) { |
|
gen5_hid_description_header_parse(cyapa, reg_data); |
|
} else if ((length == GEN5_APP_REPORT_DESCRIPTOR_SIZE || |
|
length == GEN5_APP_CONTRACT_REPORT_DESCRIPTOR_SIZE) && |
|
reg_data[2] == GEN5_APP_REPORT_DESCRIPTOR_ID) { |
|
/* 0xEE 0x00 0xF6 is Gen5 APP report description header. */ |
|
cyapa->gen = CYAPA_GEN5; |
|
cyapa->state = CYAPA_STATE_GEN5_APP; |
|
} else if (length == GEN5_BL_REPORT_DESCRIPTOR_SIZE && |
|
reg_data[2] == GEN5_BL_REPORT_DESCRIPTOR_ID) { |
|
/* 0x1D 0x00 0xFE is Gen5 BL report descriptor header. */ |
|
cyapa->gen = CYAPA_GEN5; |
|
cyapa->state = CYAPA_STATE_GEN5_BL; |
|
} else if (reg_data[2] == PIP_TOUCH_REPORT_ID || |
|
reg_data[2] == PIP_BTN_REPORT_ID || |
|
reg_data[2] == GEN5_OLD_PUSH_BTN_REPORT_ID || |
|
reg_data[2] == PIP_PUSH_BTN_REPORT_ID || |
|
reg_data[2] == PIP_WAKEUP_EVENT_REPORT_ID) { |
|
gen5_report_data_header_parse(cyapa, reg_data); |
|
} else if (reg_data[2] == PIP_BL_RESP_REPORT_ID || |
|
reg_data[2] == PIP_APP_RESP_REPORT_ID) { |
|
gen5_cmd_resp_header_parse(cyapa, reg_data); |
|
} |
|
|
|
if (cyapa->gen == CYAPA_GEN5) { |
|
/* |
|
* Must read the content (e.g.: report description and so on) |
|
* from trackpad device throughout. Otherwise, |
|
* Gen5 trackpad cannot response to next command or |
|
* report any touch or button data later. |
|
*/ |
|
cyapa_empty_pip_output_data(cyapa, NULL, NULL, NULL); |
|
|
|
if (cyapa->state == CYAPA_STATE_GEN5_APP || |
|
cyapa->state == CYAPA_STATE_GEN5_BL) |
|
return 0; |
|
} |
|
|
|
return -EAGAIN; |
|
} |
|
|
|
static struct cyapa_tsg_bin_image_data_record * |
|
cyapa_get_image_record_data_num(const struct firmware *fw, |
|
int *record_num) |
|
{ |
|
int head_size; |
|
|
|
head_size = fw->data[0] + 1; |
|
*record_num = (fw->size - head_size) / |
|
sizeof(struct cyapa_tsg_bin_image_data_record); |
|
return (struct cyapa_tsg_bin_image_data_record *)&fw->data[head_size]; |
|
} |
|
|
|
int cyapa_pip_bl_initiate(struct cyapa *cyapa, const struct firmware *fw) |
|
{ |
|
struct cyapa_tsg_bin_image_data_record *image_records; |
|
struct pip_bl_cmd_head *bl_cmd_head; |
|
struct pip_bl_packet_start *bl_packet_start; |
|
struct pip_bl_initiate_cmd_data *cmd_data; |
|
struct pip_bl_packet_end *bl_packet_end; |
|
u8 cmd[CYAPA_TSG_MAX_CMD_SIZE]; |
|
int cmd_len; |
|
u16 cmd_data_len; |
|
u16 cmd_crc = 0; |
|
u16 meta_data_crc = 0; |
|
u8 resp_data[11]; |
|
int resp_len; |
|
int records_num; |
|
u8 *data; |
|
int error; |
|
|
|
/* Try to dump all buffered report data before any send command. */ |
|
cyapa_empty_pip_output_data(cyapa, NULL, NULL, NULL); |
|
|
|
memset(cmd, 0, CYAPA_TSG_MAX_CMD_SIZE); |
|
bl_cmd_head = (struct pip_bl_cmd_head *)cmd; |
|
cmd_data_len = CYAPA_TSG_BL_KEY_SIZE + CYAPA_TSG_FLASH_MAP_BLOCK_SIZE; |
|
cmd_len = sizeof(struct pip_bl_cmd_head) + cmd_data_len + |
|
sizeof(struct pip_bl_packet_end); |
|
|
|
put_unaligned_le16(PIP_OUTPUT_REPORT_ADDR, &bl_cmd_head->addr); |
|
put_unaligned_le16(cmd_len - 2, &bl_cmd_head->length); |
|
bl_cmd_head->report_id = PIP_BL_CMD_REPORT_ID; |
|
|
|
bl_packet_start = &bl_cmd_head->packet_start; |
|
bl_packet_start->sop = PIP_SOP_KEY; |
|
bl_packet_start->cmd_code = PIP_BL_CMD_INITIATE_BL; |
|
/* 8 key bytes and 128 bytes block size */ |
|
put_unaligned_le16(cmd_data_len, &bl_packet_start->data_length); |
|
|
|
cmd_data = (struct pip_bl_initiate_cmd_data *)bl_cmd_head->data; |
|
memcpy(cmd_data->key, cyapa_pip_bl_cmd_key, CYAPA_TSG_BL_KEY_SIZE); |
|
|
|
image_records = cyapa_get_image_record_data_num(fw, &records_num); |
|
|
|
/* APP_INTEGRITY row is always the last row block */ |
|
data = image_records[records_num - 1].record_data; |
|
memcpy(cmd_data->metadata_raw_parameter, data, |
|
CYAPA_TSG_FLASH_MAP_METADATA_SIZE); |
|
|
|
meta_data_crc = crc_itu_t(0xffff, cmd_data->metadata_raw_parameter, |
|
CYAPA_TSG_FLASH_MAP_METADATA_SIZE); |
|
put_unaligned_le16(meta_data_crc, &cmd_data->metadata_crc); |
|
|
|
bl_packet_end = (struct pip_bl_packet_end *)(bl_cmd_head->data + |
|
cmd_data_len); |
|
cmd_crc = crc_itu_t(0xffff, (u8 *)bl_packet_start, |
|
sizeof(struct pip_bl_packet_start) + cmd_data_len); |
|
put_unaligned_le16(cmd_crc, &bl_packet_end->crc); |
|
bl_packet_end->eop = PIP_EOP_KEY; |
|
|
|
resp_len = sizeof(resp_data); |
|
error = cyapa_i2c_pip_cmd_irq_sync(cyapa, |
|
cmd, cmd_len, |
|
resp_data, &resp_len, 12000, |
|
cyapa_sort_tsg_pip_bl_resp_data, true); |
|
if (error || resp_len != PIP_BL_INITIATE_RESP_LEN || |
|
resp_data[2] != PIP_BL_RESP_REPORT_ID || |
|
!PIP_CMD_COMPLETE_SUCCESS(resp_data)) |
|
return error ? error : -EAGAIN; |
|
|
|
return 0; |
|
} |
|
|
|
static bool cyapa_sort_pip_bl_exit_data(struct cyapa *cyapa, u8 *buf, int len) |
|
{ |
|
if (buf == NULL || len < PIP_RESP_LENGTH_SIZE) |
|
return false; |
|
|
|
if (buf[0] == 0 && buf[1] == 0) |
|
return true; |
|
|
|
/* Exit bootloader failed for some reason. */ |
|
if (len == PIP_BL_FAIL_EXIT_RESP_LEN && |
|
buf[PIP_RESP_REPORT_ID_OFFSET] == |
|
PIP_BL_RESP_REPORT_ID && |
|
buf[PIP_RESP_RSVD_OFFSET] == PIP_RESP_RSVD_KEY && |
|
buf[PIP_RESP_BL_SOP_OFFSET] == PIP_SOP_KEY && |
|
buf[10] == PIP_EOP_KEY) |
|
return true; |
|
|
|
return false; |
|
} |
|
|
|
int cyapa_pip_bl_exit(struct cyapa *cyapa) |
|
{ |
|
|
|
u8 bl_gen5_bl_exit[] = { 0x04, 0x00, |
|
0x0B, 0x00, 0x40, 0x00, 0x01, 0x3b, 0x00, 0x00, |
|
0x20, 0xc7, 0x17 |
|
}; |
|
u8 resp_data[11]; |
|
int resp_len; |
|
int error; |
|
|
|
resp_len = sizeof(resp_data); |
|
error = cyapa_i2c_pip_cmd_irq_sync(cyapa, |
|
bl_gen5_bl_exit, sizeof(bl_gen5_bl_exit), |
|
resp_data, &resp_len, |
|
5000, cyapa_sort_pip_bl_exit_data, false); |
|
if (error) |
|
return error; |
|
|
|
if (resp_len == PIP_BL_FAIL_EXIT_RESP_LEN || |
|
resp_data[PIP_RESP_REPORT_ID_OFFSET] == |
|
PIP_BL_RESP_REPORT_ID) |
|
return -EAGAIN; |
|
|
|
if (resp_data[0] == 0x00 && resp_data[1] == 0x00) |
|
return 0; |
|
|
|
return -ENODEV; |
|
} |
|
|
|
int cyapa_pip_bl_enter(struct cyapa *cyapa) |
|
{ |
|
u8 cmd[] = { 0x04, 0x00, 0x05, 0x00, 0x2F, 0x00, 0x01 }; |
|
u8 resp_data[2]; |
|
int resp_len; |
|
int error; |
|
|
|
error = cyapa_poll_state(cyapa, 500); |
|
if (error < 0) |
|
return error; |
|
|
|
/* Already in bootloader mode, Skipping exit. */ |
|
if (cyapa_is_pip_bl_mode(cyapa)) |
|
return 0; |
|
else if (!cyapa_is_pip_app_mode(cyapa)) |
|
return -EINVAL; |
|
|
|
/* Try to dump all buffered report data before any send command. */ |
|
cyapa_empty_pip_output_data(cyapa, NULL, NULL, NULL); |
|
|
|
/* |
|
* Send bootloader enter command to trackpad device, |
|
* after enter bootloader, the response data is two bytes of 0x00 0x00. |
|
*/ |
|
resp_len = sizeof(resp_data); |
|
memset(resp_data, 0, resp_len); |
|
error = cyapa_i2c_pip_cmd_irq_sync(cyapa, |
|
cmd, sizeof(cmd), |
|
resp_data, &resp_len, |
|
5000, cyapa_sort_pip_application_launch_data, |
|
true); |
|
if (error || resp_data[0] != 0x00 || resp_data[1] != 0x00) |
|
return error < 0 ? error : -EAGAIN; |
|
|
|
cyapa->operational = false; |
|
if (cyapa->gen == CYAPA_GEN5) |
|
cyapa->state = CYAPA_STATE_GEN5_BL; |
|
else if (cyapa->gen == CYAPA_GEN6) |
|
cyapa->state = CYAPA_STATE_GEN6_BL; |
|
return 0; |
|
} |
|
|
|
static int cyapa_pip_fw_head_check(struct cyapa *cyapa, |
|
struct cyapa_tsg_bin_image_head *image_head) |
|
{ |
|
if (image_head->head_size != 0x0C && image_head->head_size != 0x12) |
|
return -EINVAL; |
|
|
|
switch (cyapa->gen) { |
|
case CYAPA_GEN6: |
|
if (image_head->family_id != 0x9B || |
|
image_head->silicon_id_hi != 0x0B) |
|
return -EINVAL; |
|
break; |
|
case CYAPA_GEN5: |
|
/* Gen5 without proximity support. */ |
|
if (cyapa->platform_ver < 2) { |
|
if (image_head->head_size == 0x0C) |
|
break; |
|
return -EINVAL; |
|
} |
|
|
|
if (image_head->family_id != 0x91 || |
|
image_head->silicon_id_hi != 0x02) |
|
return -EINVAL; |
|
break; |
|
default: |
|
return -EINVAL; |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
int cyapa_pip_check_fw(struct cyapa *cyapa, const struct firmware *fw) |
|
{ |
|
struct device *dev = &cyapa->client->dev; |
|
struct cyapa_tsg_bin_image_data_record *image_records; |
|
const struct cyapa_tsg_bin_image_data_record *app_integrity; |
|
const struct tsg_bl_metadata_row_params *metadata; |
|
int flash_records_count; |
|
u32 fw_app_start, fw_upgrade_start; |
|
u16 fw_app_len, fw_upgrade_len; |
|
u16 app_crc; |
|
u16 app_integrity_crc; |
|
int i; |
|
|
|
/* Verify the firmware image not miss-used for Gen5 and Gen6. */ |
|
if (cyapa_pip_fw_head_check(cyapa, |
|
(struct cyapa_tsg_bin_image_head *)fw->data)) { |
|
dev_err(dev, "%s: firmware image not match TP device.\n", |
|
__func__); |
|
return -EINVAL; |
|
} |
|
|
|
image_records = |
|
cyapa_get_image_record_data_num(fw, &flash_records_count); |
|
|
|
/* |
|
* APP_INTEGRITY row is always the last row block, |
|
* and the row id must be 0x01ff. |
|
*/ |
|
app_integrity = &image_records[flash_records_count - 1]; |
|
|
|
if (app_integrity->flash_array_id != 0x00 || |
|
get_unaligned_be16(&app_integrity->row_number) != 0x01ff) { |
|
dev_err(dev, "%s: invalid app_integrity data.\n", __func__); |
|
return -EINVAL; |
|
} |
|
|
|
metadata = (const void *)app_integrity->record_data; |
|
|
|
/* Verify app_integrity crc */ |
|
app_integrity_crc = crc_itu_t(0xffff, app_integrity->record_data, |
|
CYAPA_TSG_APP_INTEGRITY_SIZE); |
|
if (app_integrity_crc != get_unaligned_le16(&metadata->metadata_crc)) { |
|
dev_err(dev, "%s: invalid app_integrity crc.\n", __func__); |
|
return -EINVAL; |
|
} |
|
|
|
fw_app_start = get_unaligned_le32(&metadata->app_start); |
|
fw_app_len = get_unaligned_le16(&metadata->app_len); |
|
fw_upgrade_start = get_unaligned_le32(&metadata->upgrade_start); |
|
fw_upgrade_len = get_unaligned_le16(&metadata->upgrade_len); |
|
|
|
if (fw_app_start % CYAPA_TSG_FW_ROW_SIZE || |
|
fw_app_len % CYAPA_TSG_FW_ROW_SIZE || |
|
fw_upgrade_start % CYAPA_TSG_FW_ROW_SIZE || |
|
fw_upgrade_len % CYAPA_TSG_FW_ROW_SIZE) { |
|
dev_err(dev, "%s: invalid image alignment.\n", __func__); |
|
return -EINVAL; |
|
} |
|
|
|
/* Verify application image CRC. */ |
|
app_crc = 0xffffU; |
|
for (i = 0; i < fw_app_len / CYAPA_TSG_FW_ROW_SIZE; i++) { |
|
const u8 *data = image_records[i].record_data; |
|
|
|
app_crc = crc_itu_t(app_crc, data, CYAPA_TSG_FW_ROW_SIZE); |
|
} |
|
|
|
if (app_crc != get_unaligned_le16(&metadata->app_crc)) { |
|
dev_err(dev, "%s: invalid firmware app crc check.\n", __func__); |
|
return -EINVAL; |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
static int cyapa_pip_write_fw_block(struct cyapa *cyapa, |
|
struct cyapa_tsg_bin_image_data_record *flash_record) |
|
{ |
|
struct pip_bl_cmd_head *bl_cmd_head; |
|
struct pip_bl_packet_start *bl_packet_start; |
|
struct tsg_bl_flash_row_head *flash_row_head; |
|
struct pip_bl_packet_end *bl_packet_end; |
|
u8 cmd[CYAPA_TSG_MAX_CMD_SIZE]; |
|
u16 cmd_len; |
|
u8 flash_array_id; |
|
u16 flash_row_id; |
|
u16 record_len; |
|
u8 *record_data; |
|
u16 data_len; |
|
u16 crc; |
|
u8 resp_data[11]; |
|
int resp_len; |
|
int error; |
|
|
|
flash_array_id = flash_record->flash_array_id; |
|
flash_row_id = get_unaligned_be16(&flash_record->row_number); |
|
record_len = get_unaligned_be16(&flash_record->record_len); |
|
record_data = flash_record->record_data; |
|
|
|
memset(cmd, 0, CYAPA_TSG_MAX_CMD_SIZE); |
|
bl_cmd_head = (struct pip_bl_cmd_head *)cmd; |
|
bl_packet_start = &bl_cmd_head->packet_start; |
|
cmd_len = sizeof(struct pip_bl_cmd_head) + |
|
sizeof(struct tsg_bl_flash_row_head) + |
|
CYAPA_TSG_FLASH_MAP_BLOCK_SIZE + |
|
sizeof(struct pip_bl_packet_end); |
|
|
|
put_unaligned_le16(PIP_OUTPUT_REPORT_ADDR, &bl_cmd_head->addr); |
|
/* Don't include 2 bytes register address */ |
|
put_unaligned_le16(cmd_len - 2, &bl_cmd_head->length); |
|
bl_cmd_head->report_id = PIP_BL_CMD_REPORT_ID; |
|
bl_packet_start->sop = PIP_SOP_KEY; |
|
bl_packet_start->cmd_code = PIP_BL_CMD_PROGRAM_VERIFY_ROW; |
|
|
|
/* 1 (Flash Array ID) + 2 (Flash Row ID) + 128 (flash data) */ |
|
data_len = sizeof(struct tsg_bl_flash_row_head) + record_len; |
|
put_unaligned_le16(data_len, &bl_packet_start->data_length); |
|
|
|
flash_row_head = (struct tsg_bl_flash_row_head *)bl_cmd_head->data; |
|
flash_row_head->flash_array_id = flash_array_id; |
|
put_unaligned_le16(flash_row_id, &flash_row_head->flash_row_id); |
|
memcpy(flash_row_head->flash_data, record_data, record_len); |
|
|
|
bl_packet_end = (struct pip_bl_packet_end *)(bl_cmd_head->data + |
|
data_len); |
|
crc = crc_itu_t(0xffff, (u8 *)bl_packet_start, |
|
sizeof(struct pip_bl_packet_start) + data_len); |
|
put_unaligned_le16(crc, &bl_packet_end->crc); |
|
bl_packet_end->eop = PIP_EOP_KEY; |
|
|
|
resp_len = sizeof(resp_data); |
|
error = cyapa_i2c_pip_cmd_irq_sync(cyapa, cmd, cmd_len, |
|
resp_data, &resp_len, |
|
500, cyapa_sort_tsg_pip_bl_resp_data, true); |
|
if (error || resp_len != PIP_BL_BLOCK_WRITE_RESP_LEN || |
|
resp_data[2] != PIP_BL_RESP_REPORT_ID || |
|
!PIP_CMD_COMPLETE_SUCCESS(resp_data)) |
|
return error < 0 ? error : -EAGAIN; |
|
|
|
return 0; |
|
} |
|
|
|
int cyapa_pip_do_fw_update(struct cyapa *cyapa, |
|
const struct firmware *fw) |
|
{ |
|
struct device *dev = &cyapa->client->dev; |
|
struct cyapa_tsg_bin_image_data_record *image_records; |
|
int flash_records_count; |
|
int i; |
|
int error; |
|
|
|
cyapa_empty_pip_output_data(cyapa, NULL, NULL, NULL); |
|
|
|
image_records = |
|
cyapa_get_image_record_data_num(fw, &flash_records_count); |
|
|
|
/* |
|
* The last flash row 0x01ff has been written through bl_initiate |
|
* command, so DO NOT write flash 0x01ff to trackpad device. |
|
*/ |
|
for (i = 0; i < (flash_records_count - 1); i++) { |
|
error = cyapa_pip_write_fw_block(cyapa, &image_records[i]); |
|
if (error) { |
|
dev_err(dev, "%s: Gen5 FW update aborted: %d\n", |
|
__func__, error); |
|
return error; |
|
} |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
static int cyapa_gen5_change_power_state(struct cyapa *cyapa, u8 power_state) |
|
{ |
|
u8 cmd[8] = { 0x04, 0x00, 0x06, 0x00, 0x2f, 0x00, 0x08, 0x01 }; |
|
u8 resp_data[6]; |
|
int resp_len; |
|
int error; |
|
|
|
cmd[7] = power_state; |
|
resp_len = sizeof(resp_data); |
|
error = cyapa_i2c_pip_cmd_irq_sync(cyapa, cmd, sizeof(cmd), |
|
resp_data, &resp_len, |
|
500, cyapa_sort_tsg_pip_app_resp_data, false); |
|
if (error || !VALID_CMD_RESP_HEADER(resp_data, 0x08) || |
|
!PIP_CMD_COMPLETE_SUCCESS(resp_data)) |
|
return error < 0 ? error : -EINVAL; |
|
|
|
return 0; |
|
} |
|
|
|
static int cyapa_gen5_set_interval_time(struct cyapa *cyapa, |
|
u8 parameter_id, u16 interval_time) |
|
{ |
|
struct pip_app_cmd_head *app_cmd_head; |
|
struct gen5_app_set_parameter_data *parameter_data; |
|
u8 cmd[CYAPA_TSG_MAX_CMD_SIZE]; |
|
int cmd_len; |
|
u8 resp_data[7]; |
|
int resp_len; |
|
u8 parameter_size; |
|
int error; |
|
|
|
memset(cmd, 0, CYAPA_TSG_MAX_CMD_SIZE); |
|
app_cmd_head = (struct pip_app_cmd_head *)cmd; |
|
parameter_data = (struct gen5_app_set_parameter_data *) |
|
app_cmd_head->parameter_data; |
|
cmd_len = sizeof(struct pip_app_cmd_head) + |
|
sizeof(struct gen5_app_set_parameter_data); |
|
|
|
switch (parameter_id) { |
|
case GEN5_PARAMETER_ACT_INTERVL_ID: |
|
parameter_size = GEN5_PARAMETER_ACT_INTERVL_SIZE; |
|
break; |
|
case GEN5_PARAMETER_ACT_LFT_INTERVL_ID: |
|
parameter_size = GEN5_PARAMETER_ACT_LFT_INTERVL_SIZE; |
|
break; |
|
case GEN5_PARAMETER_LP_INTRVL_ID: |
|
parameter_size = GEN5_PARAMETER_LP_INTRVL_SIZE; |
|
break; |
|
default: |
|
return -EINVAL; |
|
} |
|
|
|
put_unaligned_le16(PIP_OUTPUT_REPORT_ADDR, &app_cmd_head->addr); |
|
/* |
|
* Don't include unused parameter value bytes and |
|
* 2 bytes register address. |
|
*/ |
|
put_unaligned_le16(cmd_len - (4 - parameter_size) - 2, |
|
&app_cmd_head->length); |
|
app_cmd_head->report_id = PIP_APP_CMD_REPORT_ID; |
|
app_cmd_head->cmd_code = GEN5_CMD_SET_PARAMETER; |
|
parameter_data->parameter_id = parameter_id; |
|
parameter_data->parameter_size = parameter_size; |
|
put_unaligned_le32((u32)interval_time, ¶meter_data->value); |
|
resp_len = sizeof(resp_data); |
|
error = cyapa_i2c_pip_cmd_irq_sync(cyapa, cmd, cmd_len, |
|
resp_data, &resp_len, |
|
500, cyapa_sort_tsg_pip_app_resp_data, false); |
|
if (error || resp_data[5] != parameter_id || |
|
resp_data[6] != parameter_size || |
|
!VALID_CMD_RESP_HEADER(resp_data, GEN5_CMD_SET_PARAMETER)) |
|
return error < 0 ? error : -EINVAL; |
|
|
|
return 0; |
|
} |
|
|
|
static int cyapa_gen5_get_interval_time(struct cyapa *cyapa, |
|
u8 parameter_id, u16 *interval_time) |
|
{ |
|
struct pip_app_cmd_head *app_cmd_head; |
|
struct gen5_app_get_parameter_data *parameter_data; |
|
u8 cmd[CYAPA_TSG_MAX_CMD_SIZE]; |
|
int cmd_len; |
|
u8 resp_data[11]; |
|
int resp_len; |
|
u8 parameter_size; |
|
u16 mask, i; |
|
int error; |
|
|
|
memset(cmd, 0, CYAPA_TSG_MAX_CMD_SIZE); |
|
app_cmd_head = (struct pip_app_cmd_head *)cmd; |
|
parameter_data = (struct gen5_app_get_parameter_data *) |
|
app_cmd_head->parameter_data; |
|
cmd_len = sizeof(struct pip_app_cmd_head) + |
|
sizeof(struct gen5_app_get_parameter_data); |
|
|
|
*interval_time = 0; |
|
switch (parameter_id) { |
|
case GEN5_PARAMETER_ACT_INTERVL_ID: |
|
parameter_size = GEN5_PARAMETER_ACT_INTERVL_SIZE; |
|
break; |
|
case GEN5_PARAMETER_ACT_LFT_INTERVL_ID: |
|
parameter_size = GEN5_PARAMETER_ACT_LFT_INTERVL_SIZE; |
|
break; |
|
case GEN5_PARAMETER_LP_INTRVL_ID: |
|
parameter_size = GEN5_PARAMETER_LP_INTRVL_SIZE; |
|
break; |
|
default: |
|
return -EINVAL; |
|
} |
|
|
|
put_unaligned_le16(PIP_OUTPUT_REPORT_ADDR, &app_cmd_head->addr); |
|
/* Don't include 2 bytes register address */ |
|
put_unaligned_le16(cmd_len - 2, &app_cmd_head->length); |
|
app_cmd_head->report_id = PIP_APP_CMD_REPORT_ID; |
|
app_cmd_head->cmd_code = GEN5_CMD_GET_PARAMETER; |
|
parameter_data->parameter_id = parameter_id; |
|
|
|
resp_len = sizeof(resp_data); |
|
error = cyapa_i2c_pip_cmd_irq_sync(cyapa, cmd, cmd_len, |
|
resp_data, &resp_len, |
|
500, cyapa_sort_tsg_pip_app_resp_data, false); |
|
if (error || resp_data[5] != parameter_id || resp_data[6] == 0 || |
|
!VALID_CMD_RESP_HEADER(resp_data, GEN5_CMD_GET_PARAMETER)) |
|
return error < 0 ? error : -EINVAL; |
|
|
|
mask = 0; |
|
for (i = 0; i < parameter_size; i++) |
|
mask |= (0xff << (i * 8)); |
|
*interval_time = get_unaligned_le16(&resp_data[7]) & mask; |
|
|
|
return 0; |
|
} |
|
|
|
static int cyapa_gen5_disable_pip_report(struct cyapa *cyapa) |
|
{ |
|
struct pip_app_cmd_head *app_cmd_head; |
|
u8 cmd[10]; |
|
u8 resp_data[7]; |
|
int resp_len; |
|
int error; |
|
|
|
memset(cmd, 0, sizeof(cmd)); |
|
app_cmd_head = (struct pip_app_cmd_head *)cmd; |
|
|
|
put_unaligned_le16(PIP_OUTPUT_REPORT_ADDR, &app_cmd_head->addr); |
|
put_unaligned_le16(sizeof(cmd) - 2, &app_cmd_head->length); |
|
app_cmd_head->report_id = PIP_APP_CMD_REPORT_ID; |
|
app_cmd_head->cmd_code = GEN5_CMD_SET_PARAMETER; |
|
app_cmd_head->parameter_data[0] = GEN5_PARAMETER_DISABLE_PIP_REPORT; |
|
app_cmd_head->parameter_data[1] = 0x01; |
|
app_cmd_head->parameter_data[2] = 0x01; |
|
resp_len = sizeof(resp_data); |
|
error = cyapa_i2c_pip_cmd_irq_sync(cyapa, cmd, sizeof(cmd), |
|
resp_data, &resp_len, |
|
500, cyapa_sort_tsg_pip_app_resp_data, false); |
|
if (error || resp_data[5] != GEN5_PARAMETER_DISABLE_PIP_REPORT || |
|
!VALID_CMD_RESP_HEADER(resp_data, GEN5_CMD_SET_PARAMETER) || |
|
resp_data[6] != 0x01) |
|
return error < 0 ? error : -EINVAL; |
|
|
|
return 0; |
|
} |
|
|
|
int cyapa_pip_set_proximity(struct cyapa *cyapa, bool enable) |
|
{ |
|
u8 cmd[] = { 0x04, 0x00, 0x06, 0x00, 0x2f, 0x00, PIP_SET_PROXIMITY, |
|
(u8)!!enable |
|
}; |
|
u8 resp_data[6]; |
|
int resp_len; |
|
int error; |
|
|
|
resp_len = sizeof(resp_data); |
|
error = cyapa_i2c_pip_cmd_irq_sync(cyapa, cmd, sizeof(cmd), |
|
resp_data, &resp_len, |
|
500, cyapa_sort_tsg_pip_app_resp_data, false); |
|
if (error || !VALID_CMD_RESP_HEADER(resp_data, PIP_SET_PROXIMITY) || |
|
!PIP_CMD_COMPLETE_SUCCESS(resp_data)) { |
|
error = (error == -ETIMEDOUT) ? -EOPNOTSUPP : error; |
|
return error < 0 ? error : -EINVAL; |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
int cyapa_pip_deep_sleep(struct cyapa *cyapa, u8 state) |
|
{ |
|
u8 cmd[] = { 0x05, 0x00, 0x00, 0x08}; |
|
u8 resp_data[5]; |
|
int resp_len; |
|
int error; |
|
|
|
cmd[2] = state & PIP_DEEP_SLEEP_STATE_MASK; |
|
resp_len = sizeof(resp_data); |
|
error = cyapa_i2c_pip_cmd_irq_sync(cyapa, cmd, sizeof(cmd), |
|
resp_data, &resp_len, |
|
500, cyapa_sort_pip_deep_sleep_data, false); |
|
if (error || ((resp_data[3] & PIP_DEEP_SLEEP_STATE_MASK) != state)) |
|
return -EINVAL; |
|
|
|
return 0; |
|
} |
|
|
|
static int cyapa_gen5_set_power_mode(struct cyapa *cyapa, |
|
u8 power_mode, u16 sleep_time, enum cyapa_pm_stage pm_stage) |
|
{ |
|
struct device *dev = &cyapa->client->dev; |
|
u8 power_state; |
|
int error = 0; |
|
|
|
if (cyapa->state != CYAPA_STATE_GEN5_APP) |
|
return 0; |
|
|
|
cyapa_set_pip_pm_state(cyapa, pm_stage); |
|
|
|
if (PIP_DEV_GET_PWR_STATE(cyapa) == UNINIT_PWR_MODE) { |
|
/* |
|
* Assume TP in deep sleep mode when driver is loaded, |
|
* avoid driver unload and reload command IO issue caused by TP |
|
* has been set into deep sleep mode when unloading. |
|
*/ |
|
PIP_DEV_SET_PWR_STATE(cyapa, PWR_MODE_OFF); |
|
} |
|
|
|
if (PIP_DEV_UNINIT_SLEEP_TIME(cyapa) && |
|
PIP_DEV_GET_PWR_STATE(cyapa) != PWR_MODE_OFF) |
|
if (cyapa_gen5_get_interval_time(cyapa, |
|
GEN5_PARAMETER_LP_INTRVL_ID, |
|
&cyapa->dev_sleep_time) != 0) |
|
PIP_DEV_SET_SLEEP_TIME(cyapa, UNINIT_SLEEP_TIME); |
|
|
|
if (PIP_DEV_GET_PWR_STATE(cyapa) == power_mode) { |
|
if (power_mode == PWR_MODE_OFF || |
|
power_mode == PWR_MODE_FULL_ACTIVE || |
|
power_mode == PWR_MODE_BTN_ONLY || |
|
PIP_DEV_GET_SLEEP_TIME(cyapa) == sleep_time) { |
|
/* Has in correct power mode state, early return. */ |
|
goto out; |
|
} |
|
} |
|
|
|
if (power_mode == PWR_MODE_OFF) { |
|
error = cyapa_pip_deep_sleep(cyapa, PIP_DEEP_SLEEP_STATE_OFF); |
|
if (error) { |
|
dev_err(dev, "enter deep sleep fail: %d\n", error); |
|
goto out; |
|
} |
|
|
|
PIP_DEV_SET_PWR_STATE(cyapa, PWR_MODE_OFF); |
|
goto out; |
|
} |
|
|
|
/* |
|
* When trackpad in power off mode, it cannot change to other power |
|
* state directly, must be wake up from sleep firstly, then |
|
* continue to do next power sate change. |
|
*/ |
|
if (PIP_DEV_GET_PWR_STATE(cyapa) == PWR_MODE_OFF) { |
|
error = cyapa_pip_deep_sleep(cyapa, PIP_DEEP_SLEEP_STATE_ON); |
|
if (error) { |
|
dev_err(dev, "deep sleep wake fail: %d\n", error); |
|
goto out; |
|
} |
|
} |
|
|
|
if (power_mode == PWR_MODE_FULL_ACTIVE) { |
|
error = cyapa_gen5_change_power_state(cyapa, |
|
GEN5_POWER_STATE_ACTIVE); |
|
if (error) { |
|
dev_err(dev, "change to active fail: %d\n", error); |
|
goto out; |
|
} |
|
|
|
PIP_DEV_SET_PWR_STATE(cyapa, PWR_MODE_FULL_ACTIVE); |
|
} else if (power_mode == PWR_MODE_BTN_ONLY) { |
|
error = cyapa_gen5_change_power_state(cyapa, |
|
GEN5_POWER_STATE_BTN_ONLY); |
|
if (error) { |
|
dev_err(dev, "fail to button only mode: %d\n", error); |
|
goto out; |
|
} |
|
|
|
PIP_DEV_SET_PWR_STATE(cyapa, PWR_MODE_BTN_ONLY); |
|
} else { |
|
/* |
|
* Continue to change power mode even failed to set |
|
* interval time, it won't affect the power mode change. |
|
* except the sleep interval time is not correct. |
|
*/ |
|
if (PIP_DEV_UNINIT_SLEEP_TIME(cyapa) || |
|
sleep_time != PIP_DEV_GET_SLEEP_TIME(cyapa)) |
|
if (cyapa_gen5_set_interval_time(cyapa, |
|
GEN5_PARAMETER_LP_INTRVL_ID, |
|
sleep_time) == 0) |
|
PIP_DEV_SET_SLEEP_TIME(cyapa, sleep_time); |
|
|
|
if (sleep_time <= GEN5_POWER_READY_MAX_INTRVL_TIME) |
|
power_state = GEN5_POWER_STATE_READY; |
|
else |
|
power_state = GEN5_POWER_STATE_IDLE; |
|
error = cyapa_gen5_change_power_state(cyapa, power_state); |
|
if (error) { |
|
dev_err(dev, "set power state to 0x%02x failed: %d\n", |
|
power_state, error); |
|
goto out; |
|
} |
|
|
|
/* |
|
* Disable pip report for a little time, firmware will |
|
* re-enable it automatically. It's used to fix the issue |
|
* that trackpad unable to report signal to wake system up |
|
* in the special situation that system is in suspending, and |
|
* at the same time, user touch trackpad to wake system up. |
|
* This function can avoid the data to be buffered when system |
|
* is suspending which may cause interrupt line unable to be |
|
* asserted again. |
|
*/ |
|
if (pm_stage == CYAPA_PM_SUSPEND) |
|
cyapa_gen5_disable_pip_report(cyapa); |
|
|
|
PIP_DEV_SET_PWR_STATE(cyapa, |
|
cyapa_sleep_time_to_pwr_cmd(sleep_time)); |
|
} |
|
|
|
out: |
|
cyapa_reset_pip_pm_state(cyapa); |
|
return error; |
|
} |
|
|
|
int cyapa_pip_resume_scanning(struct cyapa *cyapa) |
|
{ |
|
u8 cmd[] = { 0x04, 0x00, 0x05, 0x00, 0x2f, 0x00, 0x04 }; |
|
u8 resp_data[6]; |
|
int resp_len; |
|
int error; |
|
|
|
/* Try to dump all buffered data before doing command. */ |
|
cyapa_empty_pip_output_data(cyapa, NULL, NULL, NULL); |
|
|
|
resp_len = sizeof(resp_data); |
|
error = cyapa_i2c_pip_cmd_irq_sync(cyapa, |
|
cmd, sizeof(cmd), |
|
resp_data, &resp_len, |
|
500, cyapa_sort_tsg_pip_app_resp_data, true); |
|
if (error || !VALID_CMD_RESP_HEADER(resp_data, 0x04)) |
|
return -EINVAL; |
|
|
|
/* Try to dump all buffered data when resuming scanning. */ |
|
cyapa_empty_pip_output_data(cyapa, NULL, NULL, NULL); |
|
|
|
return 0; |
|
} |
|
|
|
int cyapa_pip_suspend_scanning(struct cyapa *cyapa) |
|
{ |
|
u8 cmd[] = { 0x04, 0x00, 0x05, 0x00, 0x2f, 0x00, 0x03 }; |
|
u8 resp_data[6]; |
|
int resp_len; |
|
int error; |
|
|
|
/* Try to dump all buffered data before doing command. */ |
|
cyapa_empty_pip_output_data(cyapa, NULL, NULL, NULL); |
|
|
|
resp_len = sizeof(resp_data); |
|
error = cyapa_i2c_pip_cmd_irq_sync(cyapa, |
|
cmd, sizeof(cmd), |
|
resp_data, &resp_len, |
|
500, cyapa_sort_tsg_pip_app_resp_data, true); |
|
if (error || !VALID_CMD_RESP_HEADER(resp_data, 0x03)) |
|
return -EINVAL; |
|
|
|
/* Try to dump all buffered data when suspending scanning. */ |
|
cyapa_empty_pip_output_data(cyapa, NULL, NULL, NULL); |
|
|
|
return 0; |
|
} |
|
|
|
static int cyapa_pip_calibrate_pwcs(struct cyapa *cyapa, |
|
u8 calibrate_sensing_mode_type) |
|
{ |
|
struct pip_app_cmd_head *app_cmd_head; |
|
u8 cmd[8]; |
|
u8 resp_data[6]; |
|
int resp_len; |
|
int error; |
|
|
|
/* Try to dump all buffered data before doing command. */ |
|
cyapa_empty_pip_output_data(cyapa, NULL, NULL, NULL); |
|
|
|
memset(cmd, 0, sizeof(cmd)); |
|
app_cmd_head = (struct pip_app_cmd_head *)cmd; |
|
put_unaligned_le16(PIP_OUTPUT_REPORT_ADDR, &app_cmd_head->addr); |
|
put_unaligned_le16(sizeof(cmd) - 2, &app_cmd_head->length); |
|
app_cmd_head->report_id = PIP_APP_CMD_REPORT_ID; |
|
app_cmd_head->cmd_code = PIP_CMD_CALIBRATE; |
|
app_cmd_head->parameter_data[0] = calibrate_sensing_mode_type; |
|
resp_len = sizeof(resp_data); |
|
error = cyapa_i2c_pip_cmd_irq_sync(cyapa, |
|
cmd, sizeof(cmd), |
|
resp_data, &resp_len, |
|
5000, cyapa_sort_tsg_pip_app_resp_data, true); |
|
if (error || !VALID_CMD_RESP_HEADER(resp_data, PIP_CMD_CALIBRATE) || |
|
!PIP_CMD_COMPLETE_SUCCESS(resp_data)) |
|
return error < 0 ? error : -EAGAIN; |
|
|
|
return 0; |
|
} |
|
|
|
ssize_t cyapa_pip_do_calibrate(struct device *dev, |
|
struct device_attribute *attr, |
|
const char *buf, size_t count) |
|
{ |
|
struct cyapa *cyapa = dev_get_drvdata(dev); |
|
int error, calibrate_error; |
|
|
|
/* 1. Suspend Scanning*/ |
|
error = cyapa_pip_suspend_scanning(cyapa); |
|
if (error) |
|
return error; |
|
|
|
/* 2. Do mutual capacitance fine calibrate. */ |
|
calibrate_error = cyapa_pip_calibrate_pwcs(cyapa, |
|
PIP_SENSING_MODE_MUTUAL_CAP_FINE); |
|
if (calibrate_error) |
|
goto resume_scanning; |
|
|
|
/* 3. Do self capacitance calibrate. */ |
|
calibrate_error = cyapa_pip_calibrate_pwcs(cyapa, |
|
PIP_SENSING_MODE_SELF_CAP); |
|
if (calibrate_error) |
|
goto resume_scanning; |
|
|
|
resume_scanning: |
|
/* 4. Resume Scanning*/ |
|
error = cyapa_pip_resume_scanning(cyapa); |
|
if (error || calibrate_error) |
|
return error ? error : calibrate_error; |
|
|
|
return count; |
|
} |
|
|
|
static s32 twos_complement_to_s32(s32 value, int num_bits) |
|
{ |
|
if (value >> (num_bits - 1)) |
|
value |= -1 << num_bits; |
|
return value; |
|
} |
|
|
|
static s32 cyapa_parse_structure_data(u8 data_format, u8 *buf, int buf_len) |
|
{ |
|
int data_size; |
|
bool big_endian; |
|
bool unsigned_type; |
|
s32 value; |
|
|
|
data_size = (data_format & 0x07); |
|
big_endian = ((data_format & 0x10) == 0x00); |
|
unsigned_type = ((data_format & 0x20) == 0x00); |
|
|
|
if (buf_len < data_size) |
|
return 0; |
|
|
|
switch (data_size) { |
|
case 1: |
|
value = buf[0]; |
|
break; |
|
case 2: |
|
if (big_endian) |
|
value = get_unaligned_be16(buf); |
|
else |
|
value = get_unaligned_le16(buf); |
|
break; |
|
case 4: |
|
if (big_endian) |
|
value = get_unaligned_be32(buf); |
|
else |
|
value = get_unaligned_le32(buf); |
|
break; |
|
default: |
|
/* Should not happen, just as default case here. */ |
|
value = 0; |
|
break; |
|
} |
|
|
|
if (!unsigned_type) |
|
value = twos_complement_to_s32(value, data_size * 8); |
|
|
|
return value; |
|
} |
|
|
|
static void cyapa_gen5_guess_electrodes(struct cyapa *cyapa, |
|
int *electrodes_rx, int *electrodes_tx) |
|
{ |
|
if (cyapa->electrodes_rx != 0) { |
|
*electrodes_rx = cyapa->electrodes_rx; |
|
*electrodes_tx = (cyapa->electrodes_x == *electrodes_rx) ? |
|
cyapa->electrodes_y : cyapa->electrodes_x; |
|
} else { |
|
*electrodes_tx = min(cyapa->electrodes_x, cyapa->electrodes_y); |
|
*electrodes_rx = max(cyapa->electrodes_x, cyapa->electrodes_y); |
|
} |
|
} |
|
|
|
/* |
|
* Read all the global mutual or self idac data or mutual or self local PWC |
|
* data based on the @idac_data_type. |
|
* If the input value of @data_size is 0, then means read global mutual or |
|
* self idac data. For read global mutual idac data, @idac_max, @idac_min and |
|
* @idac_ave are in order used to return the max value of global mutual idac |
|
* data, the min value of global mutual idac and the average value of the |
|
* global mutual idac data. For read global self idac data, @idac_max is used |
|
* to return the global self cap idac data in Rx direction, @idac_min is used |
|
* to return the global self cap idac data in Tx direction. @idac_ave is not |
|
* used. |
|
* If the input value of @data_size is not 0, than means read the mutual or |
|
* self local PWC data. The @idac_max, @idac_min and @idac_ave are used to |
|
* return the max, min and average value of the mutual or self local PWC data. |
|
* Note, in order to read mutual local PWC data, must read invoke this function |
|
* to read the mutual global idac data firstly to set the correct Rx number |
|
* value, otherwise, the read mutual idac and PWC data may not correct. |
|
*/ |
|
static int cyapa_gen5_read_idac_data(struct cyapa *cyapa, |
|
u8 cmd_code, u8 idac_data_type, int *data_size, |
|
int *idac_max, int *idac_min, int *idac_ave) |
|
{ |
|
struct pip_app_cmd_head *cmd_head; |
|
u8 cmd[12]; |
|
u8 resp_data[256]; |
|
int resp_len; |
|
int read_len; |
|
int value; |
|
u16 offset; |
|
int read_elements; |
|
bool read_global_idac; |
|
int sum, count, max_element_cnt; |
|
int tmp_max, tmp_min, tmp_ave, tmp_sum, tmp_count; |
|
int electrodes_rx, electrodes_tx; |
|
int i; |
|
int error; |
|
|
|
if (cmd_code != PIP_RETRIEVE_DATA_STRUCTURE || |
|
(idac_data_type != GEN5_RETRIEVE_MUTUAL_PWC_DATA && |
|
idac_data_type != GEN5_RETRIEVE_SELF_CAP_PWC_DATA) || |
|
!data_size || !idac_max || !idac_min || !idac_ave) |
|
return -EINVAL; |
|
|
|
*idac_max = INT_MIN; |
|
*idac_min = INT_MAX; |
|
sum = count = tmp_count = 0; |
|
electrodes_rx = electrodes_tx = 0; |
|
if (*data_size == 0) { |
|
/* |
|
* Read global idac values firstly. |
|
* Currently, no idac data exceed 4 bytes. |
|
*/ |
|
read_global_idac = true; |
|
offset = 0; |
|
*data_size = 4; |
|
tmp_max = INT_MIN; |
|
tmp_min = INT_MAX; |
|
tmp_ave = tmp_sum = tmp_count = 0; |
|
|
|
if (idac_data_type == GEN5_RETRIEVE_MUTUAL_PWC_DATA) { |
|
if (cyapa->aligned_electrodes_rx == 0) { |
|
cyapa_gen5_guess_electrodes(cyapa, |
|
&electrodes_rx, &electrodes_tx); |
|
cyapa->aligned_electrodes_rx = |
|
(electrodes_rx + 3) & ~3u; |
|
} |
|
max_element_cnt = |
|
(cyapa->aligned_electrodes_rx + 7) & ~7u; |
|
} else { |
|
max_element_cnt = 2; |
|
} |
|
} else { |
|
read_global_idac = false; |
|
if (*data_size > 4) |
|
*data_size = 4; |
|
/* Calculate the start offset in bytes of local PWC data. */ |
|
if (idac_data_type == GEN5_RETRIEVE_MUTUAL_PWC_DATA) { |
|
offset = cyapa->aligned_electrodes_rx * (*data_size); |
|
if (cyapa->electrodes_rx == cyapa->electrodes_x) |
|
electrodes_tx = cyapa->electrodes_y; |
|
else |
|
electrodes_tx = cyapa->electrodes_x; |
|
max_element_cnt = ((cyapa->aligned_electrodes_rx + 7) & |
|
~7u) * electrodes_tx; |
|
} else { |
|
offset = 2; |
|
max_element_cnt = cyapa->electrodes_x + |
|
cyapa->electrodes_y; |
|
max_element_cnt = (max_element_cnt + 3) & ~3u; |
|
} |
|
} |
|
|
|
memset(cmd, 0, sizeof(cmd)); |
|
cmd_head = (struct pip_app_cmd_head *)cmd; |
|
put_unaligned_le16(PIP_OUTPUT_REPORT_ADDR, &cmd_head->addr); |
|
put_unaligned_le16(sizeof(cmd) - 2, &cmd_head->length); |
|
cmd_head->report_id = PIP_APP_CMD_REPORT_ID; |
|
cmd_head->cmd_code = cmd_code; |
|
do { |
|
read_elements = (256 - GEN5_RESP_DATA_STRUCTURE_OFFSET) / |
|
(*data_size); |
|
read_elements = min(read_elements, max_element_cnt - count); |
|
read_len = read_elements * (*data_size); |
|
|
|
put_unaligned_le16(offset, &cmd_head->parameter_data[0]); |
|
put_unaligned_le16(read_len, &cmd_head->parameter_data[2]); |
|
cmd_head->parameter_data[4] = idac_data_type; |
|
resp_len = GEN5_RESP_DATA_STRUCTURE_OFFSET + read_len; |
|
error = cyapa_i2c_pip_cmd_irq_sync(cyapa, |
|
cmd, sizeof(cmd), |
|
resp_data, &resp_len, |
|
500, cyapa_sort_tsg_pip_app_resp_data, |
|
true); |
|
if (error || resp_len < GEN5_RESP_DATA_STRUCTURE_OFFSET || |
|
!VALID_CMD_RESP_HEADER(resp_data, cmd_code) || |
|
!PIP_CMD_COMPLETE_SUCCESS(resp_data) || |
|
resp_data[6] != idac_data_type) |
|
return (error < 0) ? error : -EAGAIN; |
|
read_len = get_unaligned_le16(&resp_data[7]); |
|
if (read_len == 0) |
|
break; |
|
|
|
*data_size = (resp_data[9] & GEN5_PWC_DATA_ELEMENT_SIZE_MASK); |
|
if (read_len < *data_size) |
|
return -EINVAL; |
|
|
|
if (read_global_idac && |
|
idac_data_type == GEN5_RETRIEVE_SELF_CAP_PWC_DATA) { |
|
/* Rx's self global idac data. */ |
|
*idac_max = cyapa_parse_structure_data( |
|
resp_data[9], |
|
&resp_data[GEN5_RESP_DATA_STRUCTURE_OFFSET], |
|
*data_size); |
|
/* Tx's self global idac data. */ |
|
*idac_min = cyapa_parse_structure_data( |
|
resp_data[9], |
|
&resp_data[GEN5_RESP_DATA_STRUCTURE_OFFSET + |
|
*data_size], |
|
*data_size); |
|
break; |
|
} |
|
|
|
/* Read mutual global idac or local mutual/self PWC data. */ |
|
offset += read_len; |
|
for (i = 10; i < (read_len + GEN5_RESP_DATA_STRUCTURE_OFFSET); |
|
i += *data_size) { |
|
value = cyapa_parse_structure_data(resp_data[9], |
|
&resp_data[i], *data_size); |
|
*idac_min = min(value, *idac_min); |
|
*idac_max = max(value, *idac_max); |
|
|
|
if (idac_data_type == GEN5_RETRIEVE_MUTUAL_PWC_DATA && |
|
tmp_count < cyapa->aligned_electrodes_rx && |
|
read_global_idac) { |
|
/* |
|
* The value gap between global and local mutual |
|
* idac data must bigger than 50%. |
|
* Normally, global value bigger than 50, |
|
* local values less than 10. |
|
*/ |
|
if (!tmp_ave || value > tmp_ave / 2) { |
|
tmp_min = min(value, tmp_min); |
|
tmp_max = max(value, tmp_max); |
|
tmp_sum += value; |
|
tmp_count++; |
|
|
|
tmp_ave = tmp_sum / tmp_count; |
|
} |
|
} |
|
|
|
sum += value; |
|
count++; |
|
|
|
if (count >= max_element_cnt) |
|
goto out; |
|
} |
|
} while (true); |
|
|
|
out: |
|
*idac_ave = count ? (sum / count) : 0; |
|
|
|
if (read_global_idac && |
|
idac_data_type == GEN5_RETRIEVE_MUTUAL_PWC_DATA) { |
|
if (tmp_count == 0) |
|
return 0; |
|
|
|
if (tmp_count == cyapa->aligned_electrodes_rx) { |
|
cyapa->electrodes_rx = cyapa->electrodes_rx ? |
|
cyapa->electrodes_rx : electrodes_rx; |
|
} else if (tmp_count == electrodes_rx) { |
|
cyapa->electrodes_rx = cyapa->electrodes_rx ? |
|
cyapa->electrodes_rx : electrodes_rx; |
|
cyapa->aligned_electrodes_rx = electrodes_rx; |
|
} else { |
|
cyapa->electrodes_rx = cyapa->electrodes_rx ? |
|
cyapa->electrodes_rx : electrodes_tx; |
|
cyapa->aligned_electrodes_rx = tmp_count; |
|
} |
|
|
|
*idac_min = tmp_min; |
|
*idac_max = tmp_max; |
|
*idac_ave = tmp_ave; |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
static int cyapa_gen5_read_mutual_idac_data(struct cyapa *cyapa, |
|
int *gidac_mutual_max, int *gidac_mutual_min, int *gidac_mutual_ave, |
|
int *lidac_mutual_max, int *lidac_mutual_min, int *lidac_mutual_ave) |
|
{ |
|
int data_size; |
|
int error; |
|
|
|
*gidac_mutual_max = *gidac_mutual_min = *gidac_mutual_ave = 0; |
|
*lidac_mutual_max = *lidac_mutual_min = *lidac_mutual_ave = 0; |
|
|
|
data_size = 0; |
|
error = cyapa_gen5_read_idac_data(cyapa, |
|
PIP_RETRIEVE_DATA_STRUCTURE, |
|
GEN5_RETRIEVE_MUTUAL_PWC_DATA, |
|
&data_size, |
|
gidac_mutual_max, gidac_mutual_min, gidac_mutual_ave); |
|
if (error) |
|
return error; |
|
|
|
error = cyapa_gen5_read_idac_data(cyapa, |
|
PIP_RETRIEVE_DATA_STRUCTURE, |
|
GEN5_RETRIEVE_MUTUAL_PWC_DATA, |
|
&data_size, |
|
lidac_mutual_max, lidac_mutual_min, lidac_mutual_ave); |
|
return error; |
|
} |
|
|
|
static int cyapa_gen5_read_self_idac_data(struct cyapa *cyapa, |
|
int *gidac_self_rx, int *gidac_self_tx, |
|
int *lidac_self_max, int *lidac_self_min, int *lidac_self_ave) |
|
{ |
|
int data_size; |
|
int error; |
|
|
|
*gidac_self_rx = *gidac_self_tx = 0; |
|
*lidac_self_max = *lidac_self_min = *lidac_self_ave = 0; |
|
|
|
data_size = 0; |
|
error = cyapa_gen5_read_idac_data(cyapa, |
|
PIP_RETRIEVE_DATA_STRUCTURE, |
|
GEN5_RETRIEVE_SELF_CAP_PWC_DATA, |
|
&data_size, |
|
lidac_self_max, lidac_self_min, lidac_self_ave); |
|
if (error) |
|
return error; |
|
*gidac_self_rx = *lidac_self_max; |
|
*gidac_self_tx = *lidac_self_min; |
|
|
|
error = cyapa_gen5_read_idac_data(cyapa, |
|
PIP_RETRIEVE_DATA_STRUCTURE, |
|
GEN5_RETRIEVE_SELF_CAP_PWC_DATA, |
|
&data_size, |
|
lidac_self_max, lidac_self_min, lidac_self_ave); |
|
return error; |
|
} |
|
|
|
static ssize_t cyapa_gen5_execute_panel_scan(struct cyapa *cyapa) |
|
{ |
|
struct pip_app_cmd_head *app_cmd_head; |
|
u8 cmd[7]; |
|
u8 resp_data[6]; |
|
int resp_len; |
|
int error; |
|
|
|
memset(cmd, 0, sizeof(cmd)); |
|
app_cmd_head = (struct pip_app_cmd_head *)cmd; |
|
put_unaligned_le16(PIP_OUTPUT_REPORT_ADDR, &app_cmd_head->addr); |
|
put_unaligned_le16(sizeof(cmd) - 2, &app_cmd_head->length); |
|
app_cmd_head->report_id = PIP_APP_CMD_REPORT_ID; |
|
app_cmd_head->cmd_code = GEN5_CMD_EXECUTE_PANEL_SCAN; |
|
resp_len = sizeof(resp_data); |
|
error = cyapa_i2c_pip_cmd_irq_sync(cyapa, |
|
cmd, sizeof(cmd), |
|
resp_data, &resp_len, |
|
500, cyapa_sort_tsg_pip_app_resp_data, true); |
|
if (error || resp_len != sizeof(resp_data) || |
|
!VALID_CMD_RESP_HEADER(resp_data, |
|
GEN5_CMD_EXECUTE_PANEL_SCAN) || |
|
!PIP_CMD_COMPLETE_SUCCESS(resp_data)) |
|
return error ? error : -EAGAIN; |
|
|
|
return 0; |
|
} |
|
|
|
static int cyapa_gen5_read_panel_scan_raw_data(struct cyapa *cyapa, |
|
u8 cmd_code, u8 raw_data_type, int raw_data_max_num, |
|
int *raw_data_max, int *raw_data_min, int *raw_data_ave, |
|
u8 *buffer) |
|
{ |
|
struct pip_app_cmd_head *app_cmd_head; |
|
struct gen5_retrieve_panel_scan_data *panel_sacn_data; |
|
u8 cmd[12]; |
|
u8 resp_data[256]; /* Max bytes can transfer one time. */ |
|
int resp_len; |
|
int read_elements; |
|
int read_len; |
|
u16 offset; |
|
s32 value; |
|
int sum, count; |
|
int data_size; |
|
s32 *intp; |
|
int i; |
|
int error; |
|
|
|
if (cmd_code != GEN5_CMD_RETRIEVE_PANEL_SCAN || |
|
(raw_data_type > GEN5_PANEL_SCAN_SELF_DIFFCOUNT) || |
|
!raw_data_max || !raw_data_min || !raw_data_ave) |
|
return -EINVAL; |
|
|
|
intp = (s32 *)buffer; |
|
*raw_data_max = INT_MIN; |
|
*raw_data_min = INT_MAX; |
|
sum = count = 0; |
|
offset = 0; |
|
/* Assume max element size is 4 currently. */ |
|
read_elements = (256 - GEN5_RESP_DATA_STRUCTURE_OFFSET) / 4; |
|
read_len = read_elements * 4; |
|
app_cmd_head = (struct pip_app_cmd_head *)cmd; |
|
put_unaligned_le16(PIP_OUTPUT_REPORT_ADDR, &app_cmd_head->addr); |
|
put_unaligned_le16(sizeof(cmd) - 2, &app_cmd_head->length); |
|
app_cmd_head->report_id = PIP_APP_CMD_REPORT_ID; |
|
app_cmd_head->cmd_code = cmd_code; |
|
panel_sacn_data = (struct gen5_retrieve_panel_scan_data *) |
|
app_cmd_head->parameter_data; |
|
do { |
|
put_unaligned_le16(offset, &panel_sacn_data->read_offset); |
|
put_unaligned_le16(read_elements, |
|
&panel_sacn_data->read_elements); |
|
panel_sacn_data->data_id = raw_data_type; |
|
|
|
resp_len = GEN5_RESP_DATA_STRUCTURE_OFFSET + read_len; |
|
error = cyapa_i2c_pip_cmd_irq_sync(cyapa, |
|
cmd, sizeof(cmd), |
|
resp_data, &resp_len, |
|
500, cyapa_sort_tsg_pip_app_resp_data, true); |
|
if (error || resp_len < GEN5_RESP_DATA_STRUCTURE_OFFSET || |
|
!VALID_CMD_RESP_HEADER(resp_data, cmd_code) || |
|
!PIP_CMD_COMPLETE_SUCCESS(resp_data) || |
|
resp_data[6] != raw_data_type) |
|
return error ? error : -EAGAIN; |
|
|
|
read_elements = get_unaligned_le16(&resp_data[7]); |
|
if (read_elements == 0) |
|
break; |
|
|
|
data_size = (resp_data[9] & GEN5_PWC_DATA_ELEMENT_SIZE_MASK); |
|
offset += read_elements; |
|
if (read_elements) { |
|
for (i = GEN5_RESP_DATA_STRUCTURE_OFFSET; |
|
i < (read_elements * data_size + |
|
GEN5_RESP_DATA_STRUCTURE_OFFSET); |
|
i += data_size) { |
|
value = cyapa_parse_structure_data(resp_data[9], |
|
&resp_data[i], data_size); |
|
*raw_data_min = min(value, *raw_data_min); |
|
*raw_data_max = max(value, *raw_data_max); |
|
|
|
if (intp) |
|
put_unaligned_le32(value, &intp[count]); |
|
|
|
sum += value; |
|
count++; |
|
|
|
} |
|
} |
|
|
|
if (count >= raw_data_max_num) |
|
break; |
|
|
|
read_elements = (sizeof(resp_data) - |
|
GEN5_RESP_DATA_STRUCTURE_OFFSET) / data_size; |
|
read_len = read_elements * data_size; |
|
} while (true); |
|
|
|
*raw_data_ave = count ? (sum / count) : 0; |
|
|
|
return 0; |
|
} |
|
|
|
static ssize_t cyapa_gen5_show_baseline(struct device *dev, |
|
struct device_attribute *attr, char *buf) |
|
{ |
|
struct cyapa *cyapa = dev_get_drvdata(dev); |
|
int gidac_mutual_max, gidac_mutual_min, gidac_mutual_ave; |
|
int lidac_mutual_max, lidac_mutual_min, lidac_mutual_ave; |
|
int gidac_self_rx, gidac_self_tx; |
|
int lidac_self_max, lidac_self_min, lidac_self_ave; |
|
int raw_cap_mutual_max, raw_cap_mutual_min, raw_cap_mutual_ave; |
|
int raw_cap_self_max, raw_cap_self_min, raw_cap_self_ave; |
|
int mutual_diffdata_max, mutual_diffdata_min, mutual_diffdata_ave; |
|
int self_diffdata_max, self_diffdata_min, self_diffdata_ave; |
|
int mutual_baseline_max, mutual_baseline_min, mutual_baseline_ave; |
|
int self_baseline_max, self_baseline_min, self_baseline_ave; |
|
int error, resume_error; |
|
int size; |
|
|
|
if (!cyapa_is_pip_app_mode(cyapa)) |
|
return -EBUSY; |
|
|
|
/* 1. Suspend Scanning*/ |
|
error = cyapa_pip_suspend_scanning(cyapa); |
|
if (error) |
|
return error; |
|
|
|
/* 2. Read global and local mutual IDAC data. */ |
|
gidac_self_rx = gidac_self_tx = 0; |
|
error = cyapa_gen5_read_mutual_idac_data(cyapa, |
|
&gidac_mutual_max, &gidac_mutual_min, |
|
&gidac_mutual_ave, &lidac_mutual_max, |
|
&lidac_mutual_min, &lidac_mutual_ave); |
|
if (error) |
|
goto resume_scanning; |
|
|
|
/* 3. Read global and local self IDAC data. */ |
|
error = cyapa_gen5_read_self_idac_data(cyapa, |
|
&gidac_self_rx, &gidac_self_tx, |
|
&lidac_self_max, &lidac_self_min, |
|
&lidac_self_ave); |
|
if (error) |
|
goto resume_scanning; |
|
|
|
/* 4. Execute panel scan. It must be executed before read data. */ |
|
error = cyapa_gen5_execute_panel_scan(cyapa); |
|
if (error) |
|
goto resume_scanning; |
|
|
|
/* 5. Retrieve panel scan, mutual cap raw data. */ |
|
error = cyapa_gen5_read_panel_scan_raw_data(cyapa, |
|
GEN5_CMD_RETRIEVE_PANEL_SCAN, |
|
GEN5_PANEL_SCAN_MUTUAL_RAW_DATA, |
|
cyapa->electrodes_x * cyapa->electrodes_y, |
|
&raw_cap_mutual_max, &raw_cap_mutual_min, |
|
&raw_cap_mutual_ave, |
|
NULL); |
|
if (error) |
|
goto resume_scanning; |
|
|
|
/* 6. Retrieve panel scan, self cap raw data. */ |
|
error = cyapa_gen5_read_panel_scan_raw_data(cyapa, |
|
GEN5_CMD_RETRIEVE_PANEL_SCAN, |
|
GEN5_PANEL_SCAN_SELF_RAW_DATA, |
|
cyapa->electrodes_x + cyapa->electrodes_y, |
|
&raw_cap_self_max, &raw_cap_self_min, |
|
&raw_cap_self_ave, |
|
NULL); |
|
if (error) |
|
goto resume_scanning; |
|
|
|
/* 7. Retrieve panel scan, mutual cap diffcount raw data. */ |
|
error = cyapa_gen5_read_panel_scan_raw_data(cyapa, |
|
GEN5_CMD_RETRIEVE_PANEL_SCAN, |
|
GEN5_PANEL_SCAN_MUTUAL_DIFFCOUNT, |
|
cyapa->electrodes_x * cyapa->electrodes_y, |
|
&mutual_diffdata_max, &mutual_diffdata_min, |
|
&mutual_diffdata_ave, |
|
NULL); |
|
if (error) |
|
goto resume_scanning; |
|
|
|
/* 8. Retrieve panel scan, self cap diffcount raw data. */ |
|
error = cyapa_gen5_read_panel_scan_raw_data(cyapa, |
|
GEN5_CMD_RETRIEVE_PANEL_SCAN, |
|
GEN5_PANEL_SCAN_SELF_DIFFCOUNT, |
|
cyapa->electrodes_x + cyapa->electrodes_y, |
|
&self_diffdata_max, &self_diffdata_min, |
|
&self_diffdata_ave, |
|
NULL); |
|
if (error) |
|
goto resume_scanning; |
|
|
|
/* 9. Retrieve panel scan, mutual cap baseline raw data. */ |
|
error = cyapa_gen5_read_panel_scan_raw_data(cyapa, |
|
GEN5_CMD_RETRIEVE_PANEL_SCAN, |
|
GEN5_PANEL_SCAN_MUTUAL_BASELINE, |
|
cyapa->electrodes_x * cyapa->electrodes_y, |
|
&mutual_baseline_max, &mutual_baseline_min, |
|
&mutual_baseline_ave, |
|
NULL); |
|
if (error) |
|
goto resume_scanning; |
|
|
|
/* 10. Retrieve panel scan, self cap baseline raw data. */ |
|
error = cyapa_gen5_read_panel_scan_raw_data(cyapa, |
|
GEN5_CMD_RETRIEVE_PANEL_SCAN, |
|
GEN5_PANEL_SCAN_SELF_BASELINE, |
|
cyapa->electrodes_x + cyapa->electrodes_y, |
|
&self_baseline_max, &self_baseline_min, |
|
&self_baseline_ave, |
|
NULL); |
|
if (error) |
|
goto resume_scanning; |
|
|
|
resume_scanning: |
|
/* 11. Resume Scanning*/ |
|
resume_error = cyapa_pip_resume_scanning(cyapa); |
|
if (resume_error || error) |
|
return resume_error ? resume_error : error; |
|
|
|
/* 12. Output data strings */ |
|
size = scnprintf(buf, PAGE_SIZE, "%d %d %d %d %d %d %d %d %d %d %d ", |
|
gidac_mutual_min, gidac_mutual_max, gidac_mutual_ave, |
|
lidac_mutual_min, lidac_mutual_max, lidac_mutual_ave, |
|
gidac_self_rx, gidac_self_tx, |
|
lidac_self_min, lidac_self_max, lidac_self_ave); |
|
size += scnprintf(buf + size, PAGE_SIZE - size, |
|
"%d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d\n", |
|
raw_cap_mutual_min, raw_cap_mutual_max, raw_cap_mutual_ave, |
|
raw_cap_self_min, raw_cap_self_max, raw_cap_self_ave, |
|
mutual_diffdata_min, mutual_diffdata_max, mutual_diffdata_ave, |
|
self_diffdata_min, self_diffdata_max, self_diffdata_ave, |
|
mutual_baseline_min, mutual_baseline_max, mutual_baseline_ave, |
|
self_baseline_min, self_baseline_max, self_baseline_ave); |
|
return size; |
|
} |
|
|
|
bool cyapa_pip_sort_system_info_data(struct cyapa *cyapa, |
|
u8 *buf, int len) |
|
{ |
|
/* Check the report id and command code */ |
|
if (VALID_CMD_RESP_HEADER(buf, 0x02)) |
|
return true; |
|
|
|
return false; |
|
} |
|
|
|
static int cyapa_gen5_bl_query_data(struct cyapa *cyapa) |
|
{ |
|
u8 resp_data[PIP_BL_APP_INFO_RESP_LENGTH]; |
|
int resp_len; |
|
int error; |
|
|
|
resp_len = sizeof(resp_data); |
|
error = cyapa_i2c_pip_cmd_irq_sync(cyapa, |
|
pip_bl_read_app_info, PIP_BL_READ_APP_INFO_CMD_LENGTH, |
|
resp_data, &resp_len, |
|
500, cyapa_sort_tsg_pip_bl_resp_data, false); |
|
if (error || resp_len < PIP_BL_APP_INFO_RESP_LENGTH || |
|
!PIP_CMD_COMPLETE_SUCCESS(resp_data)) |
|
return error ? error : -EIO; |
|
|
|
memcpy(&cyapa->product_id[0], &resp_data[8], 5); |
|
cyapa->product_id[5] = '-'; |
|
memcpy(&cyapa->product_id[6], &resp_data[13], 6); |
|
cyapa->product_id[12] = '-'; |
|
memcpy(&cyapa->product_id[13], &resp_data[19], 2); |
|
cyapa->product_id[15] = '\0'; |
|
|
|
cyapa->fw_maj_ver = resp_data[22]; |
|
cyapa->fw_min_ver = resp_data[23]; |
|
|
|
cyapa->platform_ver = (resp_data[26] >> PIP_BL_PLATFORM_VER_SHIFT) & |
|
PIP_BL_PLATFORM_VER_MASK; |
|
|
|
return 0; |
|
} |
|
|
|
static int cyapa_gen5_get_query_data(struct cyapa *cyapa) |
|
{ |
|
u8 resp_data[PIP_READ_SYS_INFO_RESP_LENGTH]; |
|
int resp_len; |
|
u16 product_family; |
|
int error; |
|
|
|
resp_len = sizeof(resp_data); |
|
error = cyapa_i2c_pip_cmd_irq_sync(cyapa, |
|
pip_read_sys_info, PIP_READ_SYS_INFO_CMD_LENGTH, |
|
resp_data, &resp_len, |
|
2000, cyapa_pip_sort_system_info_data, false); |
|
if (error || resp_len < sizeof(resp_data)) |
|
return error ? error : -EIO; |
|
|
|
product_family = get_unaligned_le16(&resp_data[7]); |
|
if ((product_family & PIP_PRODUCT_FAMILY_MASK) != |
|
PIP_PRODUCT_FAMILY_TRACKPAD) |
|
return -EINVAL; |
|
|
|
cyapa->platform_ver = (resp_data[49] >> PIP_BL_PLATFORM_VER_SHIFT) & |
|
PIP_BL_PLATFORM_VER_MASK; |
|
if (cyapa->gen == CYAPA_GEN5 && cyapa->platform_ver < 2) { |
|
/* Gen5 firmware that does not support proximity. */ |
|
cyapa->fw_maj_ver = resp_data[15]; |
|
cyapa->fw_min_ver = resp_data[16]; |
|
} else { |
|
cyapa->fw_maj_ver = resp_data[9]; |
|
cyapa->fw_min_ver = resp_data[10]; |
|
} |
|
|
|
cyapa->electrodes_x = resp_data[52]; |
|
cyapa->electrodes_y = resp_data[53]; |
|
|
|
cyapa->physical_size_x = get_unaligned_le16(&resp_data[54]) / 100; |
|
cyapa->physical_size_y = get_unaligned_le16(&resp_data[56]) / 100; |
|
|
|
cyapa->max_abs_x = get_unaligned_le16(&resp_data[58]); |
|
cyapa->max_abs_y = get_unaligned_le16(&resp_data[60]); |
|
|
|
cyapa->max_z = get_unaligned_le16(&resp_data[62]); |
|
|
|
cyapa->x_origin = resp_data[64] & 0x01; |
|
cyapa->y_origin = resp_data[65] & 0x01; |
|
|
|
cyapa->btn_capability = (resp_data[70] << 3) & CAPABILITY_BTN_MASK; |
|
|
|
memcpy(&cyapa->product_id[0], &resp_data[33], 5); |
|
cyapa->product_id[5] = '-'; |
|
memcpy(&cyapa->product_id[6], &resp_data[38], 6); |
|
cyapa->product_id[12] = '-'; |
|
memcpy(&cyapa->product_id[13], &resp_data[44], 2); |
|
cyapa->product_id[15] = '\0'; |
|
|
|
if (!cyapa->electrodes_x || !cyapa->electrodes_y || |
|
!cyapa->physical_size_x || !cyapa->physical_size_y || |
|
!cyapa->max_abs_x || !cyapa->max_abs_y || !cyapa->max_z) |
|
return -EINVAL; |
|
|
|
return 0; |
|
} |
|
|
|
static int cyapa_gen5_do_operational_check(struct cyapa *cyapa) |
|
{ |
|
struct device *dev = &cyapa->client->dev; |
|
int error; |
|
|
|
if (cyapa->gen != CYAPA_GEN5) |
|
return -ENODEV; |
|
|
|
switch (cyapa->state) { |
|
case CYAPA_STATE_GEN5_BL: |
|
error = cyapa_pip_bl_exit(cyapa); |
|
if (error) { |
|
/* Try to update trackpad product information. */ |
|
cyapa_gen5_bl_query_data(cyapa); |
|
goto out; |
|
} |
|
|
|
cyapa->state = CYAPA_STATE_GEN5_APP; |
|
fallthrough; |
|
|
|
case CYAPA_STATE_GEN5_APP: |
|
/* |
|
* If trackpad device in deep sleep mode, |
|
* the app command will fail. |
|
* So always try to reset trackpad device to full active when |
|
* the device state is required. |
|
*/ |
|
error = cyapa_gen5_set_power_mode(cyapa, |
|
PWR_MODE_FULL_ACTIVE, 0, CYAPA_PM_ACTIVE); |
|
if (error) |
|
dev_warn(dev, "%s: failed to set power active mode.\n", |
|
__func__); |
|
|
|
/* By default, the trackpad proximity function is enabled. */ |
|
if (cyapa->platform_ver >= 2) { |
|
error = cyapa_pip_set_proximity(cyapa, true); |
|
if (error) |
|
dev_warn(dev, |
|
"%s: failed to enable proximity.\n", |
|
__func__); |
|
} |
|
|
|
/* Get trackpad product information. */ |
|
error = cyapa_gen5_get_query_data(cyapa); |
|
if (error) |
|
goto out; |
|
/* Only support product ID starting with CYTRA */ |
|
if (memcmp(cyapa->product_id, product_id, |
|
strlen(product_id)) != 0) { |
|
dev_err(dev, "%s: unknown product ID (%s)\n", |
|
__func__, cyapa->product_id); |
|
error = -EINVAL; |
|
} |
|
break; |
|
default: |
|
error = -EINVAL; |
|
} |
|
|
|
out: |
|
return error; |
|
} |
|
|
|
/* |
|
* Return false, do not continue process |
|
* Return true, continue process. |
|
*/ |
|
bool cyapa_pip_irq_cmd_handler(struct cyapa *cyapa) |
|
{ |
|
struct cyapa_pip_cmd_states *pip = &cyapa->cmd_states.pip; |
|
int length; |
|
|
|
if (atomic_read(&pip->cmd_issued)) { |
|
/* Polling command response data. */ |
|
if (pip->is_irq_mode == false) |
|
return false; |
|
|
|
/* |
|
* Read out all none command response data. |
|
* these output data may caused by user put finger on |
|
* trackpad when host waiting the command response. |
|
*/ |
|
cyapa_i2c_pip_read(cyapa, pip->irq_cmd_buf, |
|
PIP_RESP_LENGTH_SIZE); |
|
length = get_unaligned_le16(pip->irq_cmd_buf); |
|
length = (length <= PIP_RESP_LENGTH_SIZE) ? |
|
PIP_RESP_LENGTH_SIZE : length; |
|
if (length > PIP_RESP_LENGTH_SIZE) |
|
cyapa_i2c_pip_read(cyapa, |
|
pip->irq_cmd_buf, length); |
|
if (!(pip->resp_sort_func && |
|
pip->resp_sort_func(cyapa, |
|
pip->irq_cmd_buf, length))) { |
|
/* |
|
* Cover the Gen5 V1 firmware issue. |
|
* The issue is no interrupt would be asserted from |
|
* trackpad device to host for the command response |
|
* ready event. Because when there was a finger touch |
|
* on trackpad device, and the firmware output queue |
|
* won't be empty (always with touch report data), so |
|
* the interrupt signal won't be asserted again until |
|
* the output queue was previous emptied. |
|
* This issue would happen in the scenario that |
|
* user always has his/her fingers touched on the |
|
* trackpad device during system booting/rebooting. |
|
*/ |
|
length = 0; |
|
if (pip->resp_len) |
|
length = *pip->resp_len; |
|
cyapa_empty_pip_output_data(cyapa, |
|
pip->resp_data, |
|
&length, |
|
pip->resp_sort_func); |
|
if (pip->resp_len && length != 0) { |
|
*pip->resp_len = length; |
|
atomic_dec(&pip->cmd_issued); |
|
complete(&pip->cmd_ready); |
|
} |
|
return false; |
|
} |
|
|
|
if (pip->resp_data && pip->resp_len) { |
|
*pip->resp_len = (*pip->resp_len < length) ? |
|
*pip->resp_len : length; |
|
memcpy(pip->resp_data, pip->irq_cmd_buf, |
|
*pip->resp_len); |
|
} |
|
atomic_dec(&pip->cmd_issued); |
|
complete(&pip->cmd_ready); |
|
return false; |
|
} |
|
|
|
return true; |
|
} |
|
|
|
static void cyapa_pip_report_buttons(struct cyapa *cyapa, |
|
const struct cyapa_pip_report_data *report_data) |
|
{ |
|
struct input_dev *input = cyapa->input; |
|
u8 buttons = report_data->report_head[PIP_BUTTONS_OFFSET]; |
|
|
|
buttons = (buttons << CAPABILITY_BTN_SHIFT) & CAPABILITY_BTN_MASK; |
|
|
|
if (cyapa->btn_capability & CAPABILITY_LEFT_BTN_MASK) { |
|
input_report_key(input, BTN_LEFT, |
|
!!(buttons & CAPABILITY_LEFT_BTN_MASK)); |
|
} |
|
if (cyapa->btn_capability & CAPABILITY_MIDDLE_BTN_MASK) { |
|
input_report_key(input, BTN_MIDDLE, |
|
!!(buttons & CAPABILITY_MIDDLE_BTN_MASK)); |
|
} |
|
if (cyapa->btn_capability & CAPABILITY_RIGHT_BTN_MASK) { |
|
input_report_key(input, BTN_RIGHT, |
|
!!(buttons & CAPABILITY_RIGHT_BTN_MASK)); |
|
} |
|
|
|
input_sync(input); |
|
} |
|
|
|
static void cyapa_pip_report_proximity(struct cyapa *cyapa, |
|
const struct cyapa_pip_report_data *report_data) |
|
{ |
|
struct input_dev *input = cyapa->input; |
|
u8 distance = report_data->report_head[PIP_PROXIMITY_DISTANCE_OFFSET] & |
|
PIP_PROXIMITY_DISTANCE_MASK; |
|
|
|
input_report_abs(input, ABS_DISTANCE, distance); |
|
input_sync(input); |
|
} |
|
|
|
static void cyapa_pip_report_slot_data(struct cyapa *cyapa, |
|
const struct cyapa_pip_touch_record *touch) |
|
{ |
|
struct input_dev *input = cyapa->input; |
|
u8 event_id = PIP_GET_EVENT_ID(touch->touch_tip_event_id); |
|
int slot = PIP_GET_TOUCH_ID(touch->touch_tip_event_id); |
|
int x, y; |
|
|
|
if (event_id == RECORD_EVENT_LIFTOFF) |
|
return; |
|
|
|
input_mt_slot(input, slot); |
|
input_mt_report_slot_state(input, MT_TOOL_FINGER, true); |
|
x = (touch->x_hi << 8) | touch->x_lo; |
|
if (cyapa->x_origin) |
|
x = cyapa->max_abs_x - x; |
|
y = (touch->y_hi << 8) | touch->y_lo; |
|
if (cyapa->y_origin) |
|
y = cyapa->max_abs_y - y; |
|
input_report_abs(input, ABS_MT_POSITION_X, x); |
|
input_report_abs(input, ABS_MT_POSITION_Y, y); |
|
input_report_abs(input, ABS_DISTANCE, 0); |
|
input_report_abs(input, ABS_MT_PRESSURE, |
|
touch->z); |
|
input_report_abs(input, ABS_MT_TOUCH_MAJOR, |
|
touch->major_axis_len); |
|
input_report_abs(input, ABS_MT_TOUCH_MINOR, |
|
touch->minor_axis_len); |
|
|
|
input_report_abs(input, ABS_MT_WIDTH_MAJOR, |
|
touch->major_tool_len); |
|
input_report_abs(input, ABS_MT_WIDTH_MINOR, |
|
touch->minor_tool_len); |
|
|
|
input_report_abs(input, ABS_MT_ORIENTATION, |
|
touch->orientation); |
|
} |
|
|
|
static void cyapa_pip_report_touches(struct cyapa *cyapa, |
|
const struct cyapa_pip_report_data *report_data) |
|
{ |
|
struct input_dev *input = cyapa->input; |
|
unsigned int touch_num; |
|
int i; |
|
|
|
touch_num = report_data->report_head[PIP_NUMBER_OF_TOUCH_OFFSET] & |
|
PIP_NUMBER_OF_TOUCH_MASK; |
|
|
|
for (i = 0; i < touch_num; i++) |
|
cyapa_pip_report_slot_data(cyapa, |
|
&report_data->touch_records[i]); |
|
|
|
input_mt_sync_frame(input); |
|
input_sync(input); |
|
} |
|
|
|
int cyapa_pip_irq_handler(struct cyapa *cyapa) |
|
{ |
|
struct device *dev = &cyapa->client->dev; |
|
struct cyapa_pip_report_data report_data; |
|
unsigned int report_len; |
|
int ret; |
|
|
|
if (!cyapa_is_pip_app_mode(cyapa)) { |
|
dev_err(dev, "invalid device state, gen=%d, state=0x%02x\n", |
|
cyapa->gen, cyapa->state); |
|
return -EINVAL; |
|
} |
|
|
|
ret = cyapa_i2c_pip_read(cyapa, (u8 *)&report_data, |
|
PIP_RESP_LENGTH_SIZE); |
|
if (ret != PIP_RESP_LENGTH_SIZE) { |
|
dev_err(dev, "failed to read length bytes, (%d)\n", ret); |
|
return -EINVAL; |
|
} |
|
|
|
report_len = get_unaligned_le16( |
|
&report_data.report_head[PIP_RESP_LENGTH_OFFSET]); |
|
if (report_len < PIP_RESP_LENGTH_SIZE) { |
|
/* Invalid length or internal reset happened. */ |
|
dev_err(dev, "invalid report_len=%d. bytes: %02x %02x\n", |
|
report_len, report_data.report_head[0], |
|
report_data.report_head[1]); |
|
return -EINVAL; |
|
} |
|
|
|
/* Idle, no data for report. */ |
|
if (report_len == PIP_RESP_LENGTH_SIZE) |
|
return 0; |
|
|
|
ret = cyapa_i2c_pip_read(cyapa, (u8 *)&report_data, report_len); |
|
if (ret != report_len) { |
|
dev_err(dev, "failed to read %d bytes report data, (%d)\n", |
|
report_len, ret); |
|
return -EINVAL; |
|
} |
|
|
|
return cyapa_pip_event_process(cyapa, &report_data); |
|
} |
|
|
|
static int cyapa_pip_event_process(struct cyapa *cyapa, |
|
struct cyapa_pip_report_data *report_data) |
|
{ |
|
struct device *dev = &cyapa->client->dev; |
|
unsigned int report_len; |
|
u8 report_id; |
|
|
|
report_len = get_unaligned_le16( |
|
&report_data->report_head[PIP_RESP_LENGTH_OFFSET]); |
|
/* Idle, no data for report. */ |
|
if (report_len == PIP_RESP_LENGTH_SIZE) |
|
return 0; |
|
|
|
report_id = report_data->report_head[PIP_RESP_REPORT_ID_OFFSET]; |
|
if (report_id == PIP_WAKEUP_EVENT_REPORT_ID && |
|
report_len == PIP_WAKEUP_EVENT_SIZE) { |
|
/* |
|
* Device wake event from deep sleep mode for touch. |
|
* This interrupt event is used to wake system up. |
|
* |
|
* Note: |
|
* It will introduce about 20~40 ms additional delay |
|
* time in receiving for first valid touch report data. |
|
* The time is used to execute device runtime resume |
|
* process. |
|
*/ |
|
pm_runtime_get_sync(dev); |
|
pm_runtime_mark_last_busy(dev); |
|
pm_runtime_put_sync_autosuspend(dev); |
|
return 0; |
|
} else if (report_id != PIP_TOUCH_REPORT_ID && |
|
report_id != PIP_BTN_REPORT_ID && |
|
report_id != GEN5_OLD_PUSH_BTN_REPORT_ID && |
|
report_id != PIP_PUSH_BTN_REPORT_ID && |
|
report_id != PIP_PROXIMITY_REPORT_ID) { |
|
/* Running in BL mode or unknown response data read. */ |
|
dev_err(dev, "invalid report_id=0x%02x\n", report_id); |
|
return -EINVAL; |
|
} |
|
|
|
if (report_id == PIP_TOUCH_REPORT_ID && |
|
(report_len < PIP_TOUCH_REPORT_HEAD_SIZE || |
|
report_len > PIP_TOUCH_REPORT_MAX_SIZE)) { |
|
/* Invalid report data length for finger packet. */ |
|
dev_err(dev, "invalid touch packet length=%d\n", report_len); |
|
return 0; |
|
} |
|
|
|
if ((report_id == PIP_BTN_REPORT_ID || |
|
report_id == GEN5_OLD_PUSH_BTN_REPORT_ID || |
|
report_id == PIP_PUSH_BTN_REPORT_ID) && |
|
(report_len < PIP_BTN_REPORT_HEAD_SIZE || |
|
report_len > PIP_BTN_REPORT_MAX_SIZE)) { |
|
/* Invalid report data length of button packet. */ |
|
dev_err(dev, "invalid button packet length=%d\n", report_len); |
|
return 0; |
|
} |
|
|
|
if (report_id == PIP_PROXIMITY_REPORT_ID && |
|
report_len != PIP_PROXIMITY_REPORT_SIZE) { |
|
/* Invalid report data length of proximity packet. */ |
|
dev_err(dev, "invalid proximity data, length=%d\n", report_len); |
|
return 0; |
|
} |
|
|
|
if (report_id == PIP_TOUCH_REPORT_ID) |
|
cyapa_pip_report_touches(cyapa, report_data); |
|
else if (report_id == PIP_PROXIMITY_REPORT_ID) |
|
cyapa_pip_report_proximity(cyapa, report_data); |
|
else |
|
cyapa_pip_report_buttons(cyapa, report_data); |
|
|
|
return 0; |
|
} |
|
|
|
int cyapa_pip_bl_activate(struct cyapa *cyapa) { return 0; } |
|
int cyapa_pip_bl_deactivate(struct cyapa *cyapa) { return 0; } |
|
|
|
|
|
const struct cyapa_dev_ops cyapa_gen5_ops = { |
|
.check_fw = cyapa_pip_check_fw, |
|
.bl_enter = cyapa_pip_bl_enter, |
|
.bl_initiate = cyapa_pip_bl_initiate, |
|
.update_fw = cyapa_pip_do_fw_update, |
|
.bl_activate = cyapa_pip_bl_activate, |
|
.bl_deactivate = cyapa_pip_bl_deactivate, |
|
|
|
.show_baseline = cyapa_gen5_show_baseline, |
|
.calibrate_store = cyapa_pip_do_calibrate, |
|
|
|
.initialize = cyapa_pip_cmd_state_initialize, |
|
|
|
.state_parse = cyapa_gen5_state_parse, |
|
.operational_check = cyapa_gen5_do_operational_check, |
|
|
|
.irq_handler = cyapa_pip_irq_handler, |
|
.irq_cmd_handler = cyapa_pip_irq_cmd_handler, |
|
.sort_empty_output_data = cyapa_empty_pip_output_data, |
|
.set_power_mode = cyapa_gen5_set_power_mode, |
|
|
|
.set_proximity = cyapa_pip_set_proximity, |
|
};
|
|
|