* [PATCH v16 00/12] input: cyapa: instruction of cyapa patches
@ 2014-12-18 10:00 Dudley Du
2014-12-18 10:00 ` [PATCH v16 01/12] input: cyapa: re-design driver to support multi-trackpad in one driver Dudley Du
` (13 more replies)
0 siblings, 14 replies; 28+ messages in thread
From: Dudley Du @ 2014-12-18 10:00 UTC (permalink / raw)
To: dmitry.torokhov, jmmahler, rydberg
Cc: Dudley Du, bleung, dso, linux-input, linux-kernel
V16 patches have below updates, details of other updates see history list:
1) Fix all miss-spelling and space issue.
2) Rename variables and functions with much more clearer names.
3) Initialize and document tries near where it will be used.
4) Modify cmd buffer to struct for more descriptive way.
This patch series is aimed to re-design the cyapa driver to support
old gen3 trackpad devices and new gen5 trackpad devices in one
cyapa driver, it's for easily productions support based on
customers' requirements. And add sysfs functions and interfaces
supported that required by users and customers.
Since the earlier gen3 and the latest gen5 trackpad devices using
two different chipsets, and have different protocols and interfaces,
so if supported these two type trackpad devices in two different drivers,
then it will be difficult to manage productions and later firmware updates.
e.g.: It will cause customer don't know which one trackpad device firmware
image to use and update when it has been used and integrated
in same one productions, so here we support these two trackpad
devices in same on driver.
Dudley Du (12):
input: cyapa: re-design driver to support multi-trackpad in one driver
input: cyapa: add gen5 trackpad device basic functions support
input: cyapa: add power management interfaces support for the device
input: cyapa: add runtime power management interfaces support for the
device
input: cyapa: add sysfs interfaces support in the cyapa driver
input: cyapa: add gen3 trackpad device firmware update function
support
input: cyapa: add gen3 trackpad device read baseline function support
input: cyapa: add gen3 trackpad device force re-calibrate function
support
input: cyapa: add gen5 trackpad device firmware update function
support
input: cyapa: add gen5 trackpad device read baseline function support
input: cyapa: add gen5 trackpad device force re-calibrate function
support
input: cyapa: add acpi device id support
drivers/input/mouse/Kconfig | 1 +
drivers/input/mouse/Makefile | 3 +-
drivers/input/mouse/cyapa.c | 1692 ++++++++++++++---------
drivers/input/mouse/cyapa.h | 314 +++++
drivers/input/mouse/cyapa_gen3.c | 1220 +++++++++++++++++
drivers/input/mouse/cyapa_gen5.c | 2767 ++++++++++++++++++++++++++++++++++++++
6 files changed, 5325 insertions(+), 672 deletions(-)
create mode 100644 drivers/input/mouse/cyapa.h
create mode 100644 drivers/input/mouse/cyapa_gen3.c
create mode 100644 drivers/input/mouse/cyapa_gen5.c
History patch series modifications list:
V15 patches have below main updates compared with v14 patches:
1) Fix all warning errors of sparse tool when running with "make C=1".
2) Change variable name "unique_str" to "product_id" for clearer meanings.
3) Update cyapa_i2c_write function to return error directly when length > 31.
V14 patches have below main updates compared with v13 patches:
1) Correct 9 miss spelling issues of "bufferred" to "buffered".
2) Fix the upgrade issue of removing MOUSE_CYAPA config when make oldconfig
by replase "depends on I2C && CRC_ITU_T" with
"depends on I2C"
"select CRC_ITU_T"
in patch 9.
V13 patches have below main updates compared with v12 patches:
1) Remove all debugfs interface, including read_fw and raw_data interfaces.
2) This patches are made based linux next-20141208.
V12 patches have below main updates compared with v11 patches:
1) Add check that when TP is detected but not operational, do not exit driver
immediately, but wait and export the update_fw interface for recovering.
2) Re-arrange the function codes, remove unnesseary protype definitions in
the header file.
V11 patches have below main updates compared with v10 patches:
1) Add add acpi device id supported for old gen3 and new gen5 trackpad devices.
2) Fix the unable to update firmware issue when cyapa_open is not called
which means the irq for firwmare update process is not enabled. This fix
by checking if the irq is enabled, if not then enable irq before start to
do firmware update.
V10 patches have below main updates compared with v9 patches:
1) Modify code to following kernel code style.
e.g.: correct to use error as return name when there is only error path,
and fix the checkpatch.sh wanting in the driver.
2) Remove cyapa_remove method and use input open and close interface to
following device resouse management infrastructure.
3) Modify cyapa_detect method to return tristate issue to make the return value
much more consistent and clear.
4) Use platform supplied functions as possible instead of driver
specific rewritten version.
V9 patches have below updates compared with v8 patches:
1) Removed all async thread stuff from the driver.
2) Split driver into 18 patches for each function change one patch.
V8 patches have below updates compared with v7 patches:
1) [PATCH v8 01/13] - Remove the async thread for device detect in
probe routine, now the device detect process is completely done within
the device probe routine.
2) [PATCH v8 01/13] - Split the irq cmd hander function to separated
function cyapa_default_irq_cmd_handler() and set it to interface
cyapa_default_ops.irq_cmd_handler.
3) [PATCH v8 06/13] - Add cyapa->gen check in cyapa_gen3_irq_cmd_handler()
to avoid miss-enter when device protocol is still in detecting.
V7 patches have below updates compared with v6 patches:
1) [PATCH v7 01/13] - Split the irq cmd hander function to separated
function cyapa_default_irq_cmd_handler() and set it to interface
cyapa_default_ops.irq_cmd_handler.
2) [PATCH v7 06/13] - Add cyapa->gen check in cyapa_gen3_irq_cmd_handler()
to avoid miss-enter when device protocol is still in detecting.
V6 patches have below updates compared with v5 patches:
1) Remove patch 14 of the lid filtering from the cyapa driver.
V5 patches have below updates compared with v4 patches:
1) Uses get_device()/put_device() instead of kobject_get()/kobject_put();
2) Fix memories freed before debugfs entries issue;
3) Make cyapa_debugs_root valid in driver module level
in module_init()/moudle_exit() ;
4) Fix i2c_transfer() may return partial transfer issues.
5) Add cyapa->removed flag to avoid detecting thread may still running
when driver module is removed.
6) Fix the meanings of some comments and return error code not clear issue.
^ permalink raw reply [flat|nested] 28+ messages in thread
* [PATCH v16 01/12] input: cyapa: re-design driver to support multi-trackpad in one driver
2014-12-18 10:00 [PATCH v16 00/12] input: cyapa: instruction of cyapa patches Dudley Du
@ 2014-12-18 10:00 ` Dudley Du
2014-12-30 1:06 ` Dmitry Torokhov
2014-12-18 10:00 ` [PATCH v16 02/12] input: cyapa: add gen5 trackpad device basic functions support Dudley Du
` (12 subsequent siblings)
13 siblings, 1 reply; 28+ messages in thread
From: Dudley Du @ 2014-12-18 10:00 UTC (permalink / raw)
To: dmitry.torokhov, jmmahler, rydberg
Cc: Dudley Du, bleung, linux-input, linux-kernel
In order to support multiple different chipsets and communication protocols
trackpad devices in one cyapa driver, the new cyapa driver is re-designed
with one cyapa driver core and multiple device specific functions component.
The cyapa driver core is contained in this patch, it supplies basic functions
that working with kernel and input subsystem, and also supplies the interfaces
that the specific devices' component can connect and work together with as
one driver.
TEST=test on Chromebooks.
Signed-off-by: Dudley Du <dudl@cypress.com>
---
drivers/input/mouse/Makefile | 3 +-
drivers/input/mouse/cyapa.c | 1047 ++++++++++++++------------------------
drivers/input/mouse/cyapa.h | 307 +++++++++++
drivers/input/mouse/cyapa_gen3.c | 801 +++++++++++++++++++++++++++++
4 files changed, 1492 insertions(+), 666 deletions(-)
create mode 100644 drivers/input/mouse/cyapa.h
create mode 100644 drivers/input/mouse/cyapa_gen3.c
diff --git a/drivers/input/mouse/Makefile b/drivers/input/mouse/Makefile
index 560003d..8bd950d 100644
--- a/drivers/input/mouse/Makefile
+++ b/drivers/input/mouse/Makefile
@@ -8,7 +8,7 @@ obj-$(CONFIG_MOUSE_AMIGA) += amimouse.o
obj-$(CONFIG_MOUSE_APPLETOUCH) += appletouch.o
obj-$(CONFIG_MOUSE_ATARI) += atarimouse.o
obj-$(CONFIG_MOUSE_BCM5974) += bcm5974.o
-obj-$(CONFIG_MOUSE_CYAPA) += cyapa.o
+obj-$(CONFIG_MOUSE_CYAPA) += cyapatp.o
obj-$(CONFIG_MOUSE_ELAN_I2C) += elan_i2c.o
obj-$(CONFIG_MOUSE_GPIO) += gpio_mouse.o
obj-$(CONFIG_MOUSE_INPORT) += inport.o
@@ -24,6 +24,7 @@ obj-$(CONFIG_MOUSE_SYNAPTICS_I2C) += synaptics_i2c.o
obj-$(CONFIG_MOUSE_SYNAPTICS_USB) += synaptics_usb.o
obj-$(CONFIG_MOUSE_VSXXXAA) += vsxxxaa.o
+cyapatp-objs := cyapa.o cyapa_gen3.o
psmouse-objs := psmouse-base.o synaptics.o focaltech.o
psmouse-$(CONFIG_MOUSE_PS2_ALPS) += alps.o
diff --git a/drivers/input/mouse/cyapa.c b/drivers/input/mouse/cyapa.c
index 1bece8c..ae1df15 100644
--- a/drivers/input/mouse/cyapa.c
+++ b/drivers/input/mouse/cyapa.c
@@ -20,408 +20,100 @@
#include <linux/input/mt.h>
#include <linux/interrupt.h>
#include <linux/module.h>
+#include <linux/mutex.h>
#include <linux/slab.h>
+#include <linux/uaccess.h>
+#include "cyapa.h"
-/* APA trackpad firmware generation */
-#define CYAPA_GEN3 0x03 /* support MT-protocol B with tracking ID. */
-
-#define CYAPA_NAME "Cypress APA Trackpad (cyapa)"
-
-/* commands for read/write registers of Cypress trackpad */
-#define CYAPA_CMD_SOFT_RESET 0x00
-#define CYAPA_CMD_POWER_MODE 0x01
-#define CYAPA_CMD_DEV_STATUS 0x02
-#define CYAPA_CMD_GROUP_DATA 0x03
-#define CYAPA_CMD_GROUP_CMD 0x04
-#define CYAPA_CMD_GROUP_QUERY 0x05
-#define CYAPA_CMD_BL_STATUS 0x06
-#define CYAPA_CMD_BL_HEAD 0x07
-#define CYAPA_CMD_BL_CMD 0x08
-#define CYAPA_CMD_BL_DATA 0x09
-#define CYAPA_CMD_BL_ALL 0x0a
-#define CYAPA_CMD_BLK_PRODUCT_ID 0x0b
-#define CYAPA_CMD_BLK_HEAD 0x0c
-
-/* report data start reg offset address. */
-#define DATA_REG_START_OFFSET 0x0000
-
-#define BL_HEAD_OFFSET 0x00
-#define BL_DATA_OFFSET 0x10
-
-/*
- * Operational Device Status Register
- *
- * bit 7: Valid interrupt source
- * bit 6 - 4: Reserved
- * bit 3 - 2: Power status
- * bit 1 - 0: Device status
- */
-#define REG_OP_STATUS 0x00
-#define OP_STATUS_SRC 0x80
-#define OP_STATUS_POWER 0x0c
-#define OP_STATUS_DEV 0x03
-#define OP_STATUS_MASK (OP_STATUS_SRC | OP_STATUS_POWER | OP_STATUS_DEV)
-
-/*
- * Operational Finger Count/Button Flags Register
- *
- * bit 7 - 4: Number of touched finger
- * bit 3: Valid data
- * bit 2: Middle Physical Button
- * bit 1: Right Physical Button
- * bit 0: Left physical Button
- */
-#define REG_OP_DATA1 0x01
-#define OP_DATA_VALID 0x08
-#define OP_DATA_MIDDLE_BTN 0x04
-#define OP_DATA_RIGHT_BTN 0x02
-#define OP_DATA_LEFT_BTN 0x01
-#define OP_DATA_BTN_MASK (OP_DATA_MIDDLE_BTN | OP_DATA_RIGHT_BTN | \
- OP_DATA_LEFT_BTN)
-
-/*
- * Bootloader Status Register
- *
- * bit 7: Busy
- * bit 6 - 5: Reserved
- * bit 4: Bootloader running
- * bit 3 - 1: Reserved
- * bit 0: Checksum valid
- */
-#define REG_BL_STATUS 0x01
-#define BL_STATUS_BUSY 0x80
-#define BL_STATUS_RUNNING 0x10
-#define BL_STATUS_DATA_VALID 0x08
-#define BL_STATUS_CSUM_VALID 0x01
-
-/*
- * Bootloader Error Register
- *
- * bit 7: Invalid
- * bit 6: Invalid security key
- * bit 5: Bootloading
- * bit 4: Command checksum
- * bit 3: Flash protection error
- * bit 2: Flash checksum error
- * bit 1 - 0: Reserved
- */
-#define REG_BL_ERROR 0x02
-#define BL_ERROR_INVALID 0x80
-#define BL_ERROR_INVALID_KEY 0x40
-#define BL_ERROR_BOOTLOADING 0x20
-#define BL_ERROR_CMD_CSUM 0x10
-#define BL_ERROR_FLASH_PROT 0x08
-#define BL_ERROR_FLASH_CSUM 0x04
-
-#define BL_STATUS_SIZE 3 /* length of bootloader status registers */
-#define BLK_HEAD_BYTES 32
-
-#define PRODUCT_ID_SIZE 16
-#define QUERY_DATA_SIZE 27
-#define REG_PROTOCOL_GEN_QUERY_OFFSET 20
-
-#define REG_OFFSET_DATA_BASE 0x0000
-#define REG_OFFSET_COMMAND_BASE 0x0028
-#define REG_OFFSET_QUERY_BASE 0x002a
-
-#define CAPABILITY_LEFT_BTN_MASK (0x01 << 3)
-#define CAPABILITY_RIGHT_BTN_MASK (0x01 << 4)
-#define CAPABILITY_MIDDLE_BTN_MASK (0x01 << 5)
-#define CAPABILITY_BTN_MASK (CAPABILITY_LEFT_BTN_MASK | \
- CAPABILITY_RIGHT_BTN_MASK | \
- CAPABILITY_MIDDLE_BTN_MASK)
-
-#define CYAPA_OFFSET_SOFT_RESET REG_OFFSET_COMMAND_BASE
-
-#define REG_OFFSET_POWER_MODE (REG_OFFSET_COMMAND_BASE + 1)
-
-#define PWR_MODE_MASK 0xfc
-#define PWR_MODE_FULL_ACTIVE (0x3f << 2)
-#define PWR_MODE_IDLE (0x05 << 2) /* default sleep time is 50 ms. */
-#define PWR_MODE_OFF (0x00 << 2)
-
-#define PWR_STATUS_MASK 0x0c
-#define PWR_STATUS_ACTIVE (0x03 << 2)
-#define PWR_STATUS_IDLE (0x02 << 2)
-#define PWR_STATUS_OFF (0x00 << 2)
-
-/*
- * CYAPA trackpad device states.
- * Used in register 0x00, bit1-0, DeviceStatus field.
- * Other values indicate device is in an abnormal state and must be reset.
- */
-#define CYAPA_DEV_NORMAL 0x03
-#define CYAPA_DEV_BUSY 0x01
-
-enum cyapa_state {
- CYAPA_STATE_OP,
- CYAPA_STATE_BL_IDLE,
- CYAPA_STATE_BL_ACTIVE,
- CYAPA_STATE_BL_BUSY,
- CYAPA_STATE_NO_DEVICE,
-};
-
-
-struct cyapa_touch {
- /*
- * high bits or x/y position value
- * bit 7 - 4: high 4 bits of x position value
- * bit 3 - 0: high 4 bits of y position value
- */
- u8 xy_hi;
- u8 x_lo; /* low 8 bits of x position value. */
- u8 y_lo; /* low 8 bits of y position value. */
- u8 pressure;
- /* id range is 1 - 15. It is incremented with every new touch. */
- u8 id;
-} __packed;
-
-/* The touch.id is used as the MT slot id, thus max MT slot is 15 */
-#define CYAPA_MAX_MT_SLOTS 15
-
-struct cyapa_reg_data {
- /*
- * bit 0 - 1: device status
- * bit 3 - 2: power mode
- * bit 6 - 4: reserved
- * bit 7: interrupt valid bit
- */
- u8 device_status;
- /*
- * bit 7 - 4: number of fingers currently touching pad
- * bit 3: valid data check bit
- * bit 2: middle mechanism button state if exists
- * bit 1: right mechanism button state if exists
- * bit 0: left mechanism button state if exists
- */
- u8 finger_btn;
- /* CYAPA reports up to 5 touches per packet. */
- struct cyapa_touch touches[5];
-} __packed;
-
-/* The main device structure */
-struct cyapa {
- enum cyapa_state state;
-
- struct i2c_client *client;
- struct input_dev *input;
- char phys[32]; /* device physical location */
- bool irq_wake; /* irq wake is enabled */
- bool smbus;
-
- /* read from query data region. */
- char product_id[16];
- u8 btn_capability;
- u8 gen;
- int max_abs_x;
- int max_abs_y;
- int physical_size_x;
- int physical_size_y;
-};
-
-static const u8 bl_deactivate[] = { 0x00, 0xff, 0x3b, 0x00, 0x01, 0x02, 0x03,
- 0x04, 0x05, 0x06, 0x07 };
-static const u8 bl_exit[] = { 0x00, 0xff, 0xa5, 0x00, 0x01, 0x02, 0x03, 0x04,
- 0x05, 0x06, 0x07 };
-
-struct cyapa_cmd_len {
- u8 cmd;
- u8 len;
-};
#define CYAPA_ADAPTER_FUNC_NONE 0
#define CYAPA_ADAPTER_FUNC_I2C 1
#define CYAPA_ADAPTER_FUNC_SMBUS 2
#define CYAPA_ADAPTER_FUNC_BOTH 3
-/*
- * macros for SMBus communication
- */
-#define SMBUS_READ 0x01
-#define SMBUS_WRITE 0x00
-#define SMBUS_ENCODE_IDX(cmd, idx) ((cmd) | (((idx) & 0x03) << 1))
-#define SMBUS_ENCODE_RW(cmd, rw) ((cmd) | ((rw) & 0x01))
-#define SMBUS_BYTE_BLOCK_CMD_MASK 0x80
-#define SMBUS_GROUP_BLOCK_CMD_MASK 0x40
-
- /* for byte read/write command */
-#define CMD_RESET 0
-#define CMD_POWER_MODE 1
-#define CMD_DEV_STATUS 2
-#define SMBUS_BYTE_CMD(cmd) (((cmd) & 0x3f) << 1)
-#define CYAPA_SMBUS_RESET SMBUS_BYTE_CMD(CMD_RESET)
-#define CYAPA_SMBUS_POWER_MODE SMBUS_BYTE_CMD(CMD_POWER_MODE)
-#define CYAPA_SMBUS_DEV_STATUS SMBUS_BYTE_CMD(CMD_DEV_STATUS)
-
- /* for group registers read/write command */
-#define REG_GROUP_DATA 0
-#define REG_GROUP_CMD 2
-#define REG_GROUP_QUERY 3
-#define SMBUS_GROUP_CMD(grp) (0x80 | (((grp) & 0x07) << 3))
-#define CYAPA_SMBUS_GROUP_DATA SMBUS_GROUP_CMD(REG_GROUP_DATA)
-#define CYAPA_SMBUS_GROUP_CMD SMBUS_GROUP_CMD(REG_GROUP_CMD)
-#define CYAPA_SMBUS_GROUP_QUERY SMBUS_GROUP_CMD(REG_GROUP_QUERY)
-
- /* for register block read/write command */
-#define CMD_BL_STATUS 0
-#define CMD_BL_HEAD 1
-#define CMD_BL_CMD 2
-#define CMD_BL_DATA 3
-#define CMD_BL_ALL 4
-#define CMD_BLK_PRODUCT_ID 5
-#define CMD_BLK_HEAD 6
-#define SMBUS_BLOCK_CMD(cmd) (0xc0 | (((cmd) & 0x1f) << 1))
-
-/* register block read/write command in bootloader mode */
-#define CYAPA_SMBUS_BL_STATUS SMBUS_BLOCK_CMD(CMD_BL_STATUS)
-#define CYAPA_SMBUS_BL_HEAD SMBUS_BLOCK_CMD(CMD_BL_HEAD)
-#define CYAPA_SMBUS_BL_CMD SMBUS_BLOCK_CMD(CMD_BL_CMD)
-#define CYAPA_SMBUS_BL_DATA SMBUS_BLOCK_CMD(CMD_BL_DATA)
-#define CYAPA_SMBUS_BL_ALL SMBUS_BLOCK_CMD(CMD_BL_ALL)
-
-/* register block read/write command in operational mode */
-#define CYAPA_SMBUS_BLK_PRODUCT_ID SMBUS_BLOCK_CMD(CMD_BLK_PRODUCT_ID)
-#define CYAPA_SMBUS_BLK_HEAD SMBUS_BLOCK_CMD(CMD_BLK_HEAD)
-
-static const struct cyapa_cmd_len cyapa_i2c_cmds[] = {
- { CYAPA_OFFSET_SOFT_RESET, 1 },
- { REG_OFFSET_COMMAND_BASE + 1, 1 },
- { REG_OFFSET_DATA_BASE, 1 },
- { REG_OFFSET_DATA_BASE, sizeof(struct cyapa_reg_data) },
- { REG_OFFSET_COMMAND_BASE, 0 },
- { REG_OFFSET_QUERY_BASE, QUERY_DATA_SIZE },
- { BL_HEAD_OFFSET, 3 },
- { BL_HEAD_OFFSET, 16 },
- { BL_HEAD_OFFSET, 16 },
- { BL_DATA_OFFSET, 16 },
- { BL_HEAD_OFFSET, 32 },
- { REG_OFFSET_QUERY_BASE, PRODUCT_ID_SIZE },
- { REG_OFFSET_DATA_BASE, 32 }
-};
+const char product_id[] = "CYTRA";
-static const struct cyapa_cmd_len cyapa_smbus_cmds[] = {
- { CYAPA_SMBUS_RESET, 1 },
- { CYAPA_SMBUS_POWER_MODE, 1 },
- { CYAPA_SMBUS_DEV_STATUS, 1 },
- { CYAPA_SMBUS_GROUP_DATA, sizeof(struct cyapa_reg_data) },
- { CYAPA_SMBUS_GROUP_CMD, 2 },
- { CYAPA_SMBUS_GROUP_QUERY, QUERY_DATA_SIZE },
- { CYAPA_SMBUS_BL_STATUS, 3 },
- { CYAPA_SMBUS_BL_HEAD, 16 },
- { CYAPA_SMBUS_BL_CMD, 16 },
- { CYAPA_SMBUS_BL_DATA, 16 },
- { CYAPA_SMBUS_BL_ALL, 32 },
- { CYAPA_SMBUS_BLK_PRODUCT_ID, PRODUCT_ID_SIZE },
- { CYAPA_SMBUS_BLK_HEAD, 16 },
-};
+static int cyapa_reinitialize(struct cyapa *cyapa);
-static ssize_t cyapa_i2c_reg_read_block(struct cyapa *cyapa, u8 reg, size_t len,
+/* Returns 0 on success, else negative errno on failure. */
+static ssize_t cyapa_i2c_read(struct cyapa *cyapa, u8 reg, size_t len,
u8 *values)
{
- return i2c_smbus_read_i2c_block_data(cyapa->client, reg, len, values);
-}
+ int ret;
+ struct i2c_client *client = cyapa->client;
+ struct i2c_msg msgs[] = {
+ {
+ .addr = client->addr,
+ .flags = 0,
+ .len = 1,
+ .buf = ®,
+ },
+ {
+ .addr = client->addr,
+ .flags = I2C_M_RD,
+ .len = len,
+ .buf = values,
+ },
+ };
+
+ ret = i2c_transfer(client->adapter, msgs, 2);
+
+ if (ret != ARRAY_SIZE(msgs))
+ return ret < 0 ? ret : -EIO;
-static ssize_t cyapa_i2c_reg_write_block(struct cyapa *cyapa, u8 reg,
- size_t len, const u8 *values)
-{
- return i2c_smbus_write_i2c_block_data(cyapa->client, reg, len, values);
+ return 0;
}
-/*
- * cyapa_smbus_read_block - perform smbus block read command
- * @cyapa - private data structure of the driver
- * @cmd - the properly encoded smbus command
- * @len - expected length of smbus command result
- * @values - buffer to store smbus command result
- *
- * Returns negative errno, else the number of bytes written.
+/**
+ * cyapa_i2c_write - Execute i2c block data write operation
+ * @cyapa: Handle to this driver
+ * @ret: Offset of the data to written in the register map
+ * @len: number of bytes to write
+ * @values: Data to be written
*
- * Note:
- * In trackpad device, the memory block allocated for I2C register map
- * is 256 bytes, so the max read block for I2C bus is 256 bytes.
+ * Return negative errno code on error; return zero when success.
*/
-static ssize_t cyapa_smbus_read_block(struct cyapa *cyapa, u8 cmd, size_t len,
- u8 *values)
+static ssize_t cyapa_i2c_write(struct cyapa *cyapa, u8 reg,
+ size_t len, const void *values)
{
- ssize_t ret;
- u8 index;
- u8 smbus_cmd;
- u8 *buf;
+ int ret;
struct i2c_client *client = cyapa->client;
+ char buf[32];
- if (!(SMBUS_BYTE_BLOCK_CMD_MASK & cmd))
- return -EINVAL;
-
- if (SMBUS_GROUP_BLOCK_CMD_MASK & cmd) {
- /* read specific block registers command. */
- smbus_cmd = SMBUS_ENCODE_RW(cmd, SMBUS_READ);
- ret = i2c_smbus_read_block_data(client, smbus_cmd, values);
- goto out;
- }
-
- ret = 0;
- for (index = 0; index * I2C_SMBUS_BLOCK_MAX < len; index++) {
- smbus_cmd = SMBUS_ENCODE_IDX(cmd, index);
- smbus_cmd = SMBUS_ENCODE_RW(smbus_cmd, SMBUS_READ);
- buf = values + I2C_SMBUS_BLOCK_MAX * index;
- ret = i2c_smbus_read_block_data(client, smbus_cmd, buf);
- if (ret < 0)
- goto out;
- }
-
-out:
- return ret > 0 ? len : ret;
-}
-
-static s32 cyapa_read_byte(struct cyapa *cyapa, u8 cmd_idx)
-{
- u8 cmd;
-
- if (cyapa->smbus) {
- cmd = cyapa_smbus_cmds[cmd_idx].cmd;
- cmd = SMBUS_ENCODE_RW(cmd, SMBUS_READ);
- } else {
- cmd = cyapa_i2c_cmds[cmd_idx].cmd;
- }
- return i2c_smbus_read_byte_data(cyapa->client, cmd);
-}
+ if (len > 31)
+ return -ENOMEM;
-static s32 cyapa_write_byte(struct cyapa *cyapa, u8 cmd_idx, u8 value)
-{
- u8 cmd;
+ buf[0] = reg;
+ memcpy(&buf[1], values, len);
+ ret = i2c_master_send(client, buf, len + 1);
- if (cyapa->smbus) {
- cmd = cyapa_smbus_cmds[cmd_idx].cmd;
- cmd = SMBUS_ENCODE_RW(cmd, SMBUS_WRITE);
- } else {
- cmd = cyapa_i2c_cmds[cmd_idx].cmd;
- }
- return i2c_smbus_write_byte_data(cyapa->client, cmd, value);
+ return (ret == (len + 1)) ? 0 : ((ret < 0) ? ret : -EIO);
}
-static ssize_t cyapa_read_block(struct cyapa *cyapa, u8 cmd_idx, u8 *values)
+static u8 cyapa_check_adapter_functionality(struct i2c_client *client)
{
- u8 cmd;
- size_t len;
+ u8 ret = CYAPA_ADAPTER_FUNC_NONE;
- if (cyapa->smbus) {
- cmd = cyapa_smbus_cmds[cmd_idx].cmd;
- len = cyapa_smbus_cmds[cmd_idx].len;
- return cyapa_smbus_read_block(cyapa, cmd, len, values);
- } else {
- cmd = cyapa_i2c_cmds[cmd_idx].cmd;
- len = cyapa_i2c_cmds[cmd_idx].len;
- return cyapa_i2c_reg_read_block(cyapa, cmd, len, values);
- }
+ if (i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
+ ret |= CYAPA_ADAPTER_FUNC_I2C;
+ if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA |
+ I2C_FUNC_SMBUS_BLOCK_DATA |
+ I2C_FUNC_SMBUS_I2C_BLOCK))
+ ret |= CYAPA_ADAPTER_FUNC_SMBUS;
+ return ret;
}
/*
* Query device for its current operating state.
- *
*/
static int cyapa_get_state(struct cyapa *cyapa)
{
u8 status[BL_STATUS_SIZE];
+ u8 cmd[32];
+ /* The i2c address of gen4 and gen5 trackpad device must be even. */
+ bool even_addr = ((cyapa->client->addr & 0x0001) == 0);
+ bool smbus = false;
+ int retries = 2;
int error;
cyapa->state = CYAPA_STATE_NO_DEVICE;
@@ -433,39 +125,64 @@ static int cyapa_get_state(struct cyapa *cyapa)
*
*/
error = cyapa_i2c_reg_read_block(cyapa, BL_HEAD_OFFSET, BL_STATUS_SIZE,
- status);
+ status);
/*
* On smbus systems in OP mode, the i2c_reg_read will fail with
* -ETIMEDOUT. In this case, try again using the smbus equivalent
* command. This should return a BL_HEAD indicating CYAPA_STATE_OP.
*/
- if (cyapa->smbus && (error == -ETIMEDOUT || error == -ENXIO))
- error = cyapa_read_block(cyapa, CYAPA_CMD_BL_STATUS, status);
+ if (cyapa->smbus && (error == -ETIMEDOUT || error == -ENXIO)) {
+ if (!even_addr)
+ error = cyapa_read_block(cyapa,
+ CYAPA_CMD_BL_STATUS, status);
+ smbus = true;
+ }
if (error != BL_STATUS_SIZE)
goto error;
- if ((status[REG_OP_STATUS] & OP_STATUS_SRC) == OP_STATUS_SRC) {
- switch (status[REG_OP_STATUS] & OP_STATUS_DEV) {
- case CYAPA_DEV_NORMAL:
- case CYAPA_DEV_BUSY:
- cyapa->state = CYAPA_STATE_OP;
- break;
- default:
- error = -EAGAIN;
- goto error;
+ /*
+ * Detect trackpad protocol based on characristic registers and bits.
+ */
+ do {
+ cyapa->status[REG_OP_STATUS] = status[REG_OP_STATUS];
+ cyapa->status[REG_BL_STATUS] = status[REG_BL_STATUS];
+ cyapa->status[REG_BL_ERROR] = status[REG_BL_ERROR];
+
+ if (cyapa->gen == CYAPA_GEN_UNKNOWN ||
+ cyapa->gen == CYAPA_GEN3) {
+ error = cyapa_gen3_ops.state_parse(cyapa,
+ status, BL_STATUS_SIZE);
+ if (!error)
+ goto out_detected;
}
- } else {
- if (status[REG_BL_STATUS] & BL_STATUS_BUSY)
- cyapa->state = CYAPA_STATE_BL_BUSY;
- else if (status[REG_BL_ERROR] & BL_ERROR_BOOTLOADING)
- cyapa->state = CYAPA_STATE_BL_ACTIVE;
- else
- cyapa->state = CYAPA_STATE_BL_IDLE;
- }
+ /*
+ * Write 0x00 0x00 to trackpad device to force update its
+ * status, then redo the detection again.
+ */
+ if (!smbus) {
+ cmd[0] = 0x00;
+ cmd[1] = 0x00;
+ error = cyapa_i2c_write(cyapa, 0, 2, cmd);
+ if (error)
+ goto error;
+
+ msleep(50);
+
+ error = cyapa_i2c_read(cyapa, BL_HEAD_OFFSET,
+ BL_STATUS_SIZE, status);
+ if (error)
+ goto error;
+ }
+ } while (--retries > 0 && !smbus);
+
+ goto error;
+
+out_detected:
return 0;
+
error:
return (error < 0) ? error : -EAGAIN;
}
@@ -484,141 +201,18 @@ error:
* -ETIMEDOUT if device never responds (too many -EAGAIN)
* < 0 other errors
*/
-static int cyapa_poll_state(struct cyapa *cyapa, unsigned int timeout)
+int cyapa_poll_state(struct cyapa *cyapa, unsigned int timeout)
{
int error;
int tries = timeout / 100;
error = cyapa_get_state(cyapa);
- while ((error || cyapa->state >= CYAPA_STATE_BL_BUSY) && tries--) {
+ while ((error || cyapa->state <= CYAPA_STATE_BL_BUSY) && tries--) {
msleep(100);
error = cyapa_get_state(cyapa);
}
- return (error == -EAGAIN || error == -ETIMEDOUT) ? -ETIMEDOUT : error;
-}
-
-static int cyapa_bl_deactivate(struct cyapa *cyapa)
-{
- int error;
-
- error = cyapa_i2c_reg_write_block(cyapa, 0, sizeof(bl_deactivate),
- bl_deactivate);
- if (error)
- return error;
-
- /* wait for bootloader to switch to idle state; should take < 100ms */
- msleep(100);
- error = cyapa_poll_state(cyapa, 500);
- if (error)
- return error;
- if (cyapa->state != CYAPA_STATE_BL_IDLE)
- return -EAGAIN;
- return 0;
-}
-/*
- * Exit bootloader
- *
- * Send bl_exit command, then wait 50 - 100 ms to let device transition to
- * operational mode. If this is the first time the device's firmware is
- * running, it can take up to 2 seconds to calibrate its sensors. So, poll
- * the device's new state for up to 2 seconds.
- *
- * Returns:
- * -EIO failure while reading from device
- * -EAGAIN device is stuck in bootloader, b/c it has invalid firmware
- * 0 device is supported and in operational mode
- */
-static int cyapa_bl_exit(struct cyapa *cyapa)
-{
- int error;
-
- error = cyapa_i2c_reg_write_block(cyapa, 0, sizeof(bl_exit), bl_exit);
- if (error)
- return error;
-
- /*
- * Wait for bootloader to exit, and operation mode to start.
- * Normally, this takes at least 50 ms.
- */
- usleep_range(50000, 100000);
- /*
- * In addition, when a device boots for the first time after being
- * updated to new firmware, it must first calibrate its sensors, which
- * can take up to an additional 2 seconds.
- */
- error = cyapa_poll_state(cyapa, 2000);
- if (error < 0)
- return error;
- if (cyapa->state != CYAPA_STATE_OP)
- return -EAGAIN;
-
- return 0;
-}
-
-/*
- * Set device power mode
- *
- */
-static int cyapa_set_power_mode(struct cyapa *cyapa, u8 power_mode)
-{
- struct device *dev = &cyapa->client->dev;
- int ret;
- u8 power;
-
- if (cyapa->state != CYAPA_STATE_OP)
- return 0;
-
- ret = cyapa_read_byte(cyapa, CYAPA_CMD_POWER_MODE);
- if (ret < 0)
- return ret;
-
- power = ret & ~PWR_MODE_MASK;
- power |= power_mode & PWR_MODE_MASK;
- ret = cyapa_write_byte(cyapa, CYAPA_CMD_POWER_MODE, power);
- if (ret < 0) {
- dev_err(dev, "failed to set power_mode 0x%02x err = %d\n",
- power_mode, ret);
- return ret;
- }
-
- return 0;
-}
-
-static int cyapa_get_query_data(struct cyapa *cyapa)
-{
- u8 query_data[QUERY_DATA_SIZE];
- int ret;
-
- if (cyapa->state != CYAPA_STATE_OP)
- return -EBUSY;
-
- ret = cyapa_read_block(cyapa, CYAPA_CMD_GROUP_QUERY, query_data);
- if (ret < 0)
- return ret;
- if (ret != QUERY_DATA_SIZE)
- return -EIO;
-
- memcpy(&cyapa->product_id[0], &query_data[0], 5);
- cyapa->product_id[5] = '-';
- memcpy(&cyapa->product_id[6], &query_data[5], 6);
- cyapa->product_id[12] = '-';
- memcpy(&cyapa->product_id[13], &query_data[11], 2);
- cyapa->product_id[15] = '\0';
-
- cyapa->btn_capability = query_data[19] & CAPABILITY_BTN_MASK;
-
- cyapa->gen = query_data[20] & 0x0f;
-
- cyapa->max_abs_x = ((query_data[21] & 0xf0) << 4) | query_data[22];
- cyapa->max_abs_y = ((query_data[21] & 0x0f) << 8) | query_data[23];
-
- cyapa->physical_size_x =
- ((query_data[24] & 0xf0) << 4) | query_data[25];
- cyapa->physical_size_y =
- ((query_data[24] & 0x0f) << 8) | query_data[26];
-
- return 0;
+ return (error == -EAGAIN || error == -ETIMEDOUT) ? -ETIMEDOUT : error;
}
/*
@@ -628,8 +222,10 @@ static int cyapa_get_query_data(struct cyapa *cyapa)
* firmware supported by this driver.
*
* Returns:
+ * -ENODEV no device
* -EBUSY no device or in bootloader
* -EIO failure while reading from device
+ * -ETIMEDOUT timeout failure for bus idle or bus no response
* -EAGAIN device is still in bootloader
* if ->state = CYAPA_STATE_BL_IDLE, device has invalid firmware
* -EINVAL device is in operational mode, but not supported by this driver
@@ -637,122 +233,55 @@ static int cyapa_get_query_data(struct cyapa *cyapa)
*/
static int cyapa_check_is_operational(struct cyapa *cyapa)
{
- struct device *dev = &cyapa->client->dev;
- static const char unique_str[] = "CYTRA";
int error;
- error = cyapa_poll_state(cyapa, 2000);
+ error = cyapa_poll_state(cyapa, 4000);
if (error)
return error;
- switch (cyapa->state) {
- case CYAPA_STATE_BL_ACTIVE:
- error = cyapa_bl_deactivate(cyapa);
- if (error)
- return error;
-
- /* Fallthrough state */
- case CYAPA_STATE_BL_IDLE:
- error = cyapa_bl_exit(cyapa);
- if (error)
- return error;
- /* Fallthrough state */
- case CYAPA_STATE_OP:
- error = cyapa_get_query_data(cyapa);
- if (error)
- return error;
+ switch (cyapa->gen) {
+ case CYAPA_GEN3:
+ cyapa->ops = &cyapa_gen3_ops;
+ break;
+ default:
+ return -ENODEV;
+ }
- /* only support firmware protocol gen3 */
- if (cyapa->gen != CYAPA_GEN3) {
- dev_err(dev, "unsupported protocol version (%d)",
- cyapa->gen);
- return -EINVAL;
- }
+ if (cyapa->ops->operational_check)
+ error = cyapa->ops->operational_check(cyapa);
- /* only support product ID starting with CYTRA */
- if (memcmp(cyapa->product_id, unique_str,
- sizeof(unique_str) - 1) != 0) {
- dev_err(dev, "unsupported product ID (%s)\n",
- cyapa->product_id);
- return -EINVAL;
- }
- return 0;
+ if (!error && CYAPA_OPERATIONAL(cyapa))
+ cyapa->operational = true;
+ else
+ cyapa->operational = false;
- default:
- return -EIO;
- }
- return 0;
+ return error;
}
-static irqreturn_t cyapa_irq(int irq, void *dev_id)
+
+/*
+ * Returns 0 on device detected, negative errno on no device detected.
+ * And when the device is detected and opertaional, it will be reset to
+ * full power active mode automatically.
+ */
+static int cyapa_detect(struct cyapa *cyapa)
{
- struct cyapa *cyapa = dev_id;
struct device *dev = &cyapa->client->dev;
- struct input_dev *input = cyapa->input;
- struct cyapa_reg_data data;
- int i;
- int ret;
- int num_fingers;
-
- if (device_may_wakeup(dev))
- pm_wakeup_event(dev, 0);
-
- ret = cyapa_read_block(cyapa, CYAPA_CMD_GROUP_DATA, (u8 *)&data);
- if (ret != sizeof(data))
- goto out;
+ int error;
- if ((data.device_status & OP_STATUS_SRC) != OP_STATUS_SRC ||
- (data.device_status & OP_STATUS_DEV) != CYAPA_DEV_NORMAL ||
- (data.finger_btn & OP_DATA_VALID) != OP_DATA_VALID) {
- goto out;
- }
+ error = cyapa_check_is_operational(cyapa);
+ if (error) {
+ if (error != -ETIMEDOUT && error != -ENODEV &&
+ CYAPA_BOOTLOADER(cyapa)) {
+ dev_warn(dev, "device detected but not operational\n");
+ return 0;
+ }
- num_fingers = (data.finger_btn >> 4) & 0x0f;
- for (i = 0; i < num_fingers; i++) {
- const struct cyapa_touch *touch = &data.touches[i];
- /* Note: touch->id range is 1 to 15; slots are 0 to 14. */
- int slot = touch->id - 1;
-
- input_mt_slot(input, slot);
- input_mt_report_slot_state(input, MT_TOOL_FINGER, true);
- input_report_abs(input, ABS_MT_POSITION_X,
- ((touch->xy_hi & 0xf0) << 4) | touch->x_lo);
- input_report_abs(input, ABS_MT_POSITION_Y,
- ((touch->xy_hi & 0x0f) << 8) | touch->y_lo);
- input_report_abs(input, ABS_MT_PRESSURE, touch->pressure);
+ dev_err(dev, "no device detected, (%d)\n", error);
+ return error;
}
- input_mt_sync_frame(input);
-
- if (cyapa->btn_capability & CAPABILITY_LEFT_BTN_MASK)
- input_report_key(input, BTN_LEFT,
- data.finger_btn & OP_DATA_LEFT_BTN);
-
- if (cyapa->btn_capability & CAPABILITY_MIDDLE_BTN_MASK)
- input_report_key(input, BTN_MIDDLE,
- data.finger_btn & OP_DATA_MIDDLE_BTN);
-
- if (cyapa->btn_capability & CAPABILITY_RIGHT_BTN_MASK)
- input_report_key(input, BTN_RIGHT,
- data.finger_btn & OP_DATA_RIGHT_BTN);
-
- input_sync(input);
-
-out:
- return IRQ_HANDLED;
-}
-
-static u8 cyapa_check_adapter_functionality(struct i2c_client *client)
-{
- u8 ret = CYAPA_ADAPTER_FUNC_NONE;
-
- if (i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
- ret |= CYAPA_ADAPTER_FUNC_I2C;
- if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA |
- I2C_FUNC_SMBUS_BLOCK_DATA |
- I2C_FUNC_SMBUS_I2C_BLOCK))
- ret |= CYAPA_ADAPTER_FUNC_SMBUS;
- return ret;
+ return 0;
}
static int cyapa_open(struct input_dev *input)
@@ -761,22 +290,49 @@ static int cyapa_open(struct input_dev *input)
struct i2c_client *client = cyapa->client;
int error;
- error = cyapa_set_power_mode(cyapa, PWR_MODE_FULL_ACTIVE);
- if (error) {
- dev_err(&client->dev, "set active power failed: %d\n", error);
+ error = mutex_lock_interruptible(&cyapa->state_sync_lock);
+ if (error)
return error;
+
+ if (cyapa->operational && cyapa->ops->set_power_mode) {
+ /*
+ * though failed to set active power mode,
+ * but still may be able to work in lower scan rate
+ * when in operational mode.
+ */
+ error = cyapa->ops->set_power_mode(cyapa,
+ PWR_MODE_FULL_ACTIVE, 0);
+ if (error) {
+ dev_warn(&client->dev,
+ "set active power failed: %d\n", error);
+ goto out;
+ }
+ } else {
+ error = cyapa_reinitialize(cyapa);
+ if (error || !cyapa->operational) {
+ error = error ? error : -EAGAIN;
+ goto out;
+ }
}
enable_irq(client->irq);
- return 0;
+out:
+ mutex_unlock(&cyapa->state_sync_lock);
+ return error;
}
static void cyapa_close(struct input_dev *input)
{
struct cyapa *cyapa = input_get_drvdata(input);
+ struct i2c_client *client = cyapa->client;
+
+ mutex_lock(&cyapa->state_sync_lock);
- disable_irq(cyapa->client->irq);
- cyapa_set_power_mode(cyapa, PWR_MODE_OFF);
+ disable_irq(client->irq);
+ if (!CYAPA_BOOTLOADER(cyapa) && cyapa->ops->set_power_mode)
+ cyapa->ops->set_power_mode(cyapa, PWR_MODE_OFF, 0);
+
+ mutex_unlock(&cyapa->state_sync_lock);
}
static int cyapa_create_input_dev(struct cyapa *cyapa)
@@ -813,7 +369,28 @@ static int cyapa_create_input_dev(struct cyapa *cyapa)
0);
input_set_abs_params(input, ABS_MT_POSITION_Y, 0, cyapa->max_abs_y, 0,
0);
- input_set_abs_params(input, ABS_MT_PRESSURE, 0, 255, 0, 0);
+ input_set_abs_params(input, ABS_MT_PRESSURE, 0, cyapa->max_z, 0, 0);
+ if (cyapa->gen > CYAPA_GEN3) {
+ input_set_abs_params(input, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
+ input_set_abs_params(input, ABS_MT_TOUCH_MINOR, 0, 255, 0, 0);
+ /*
+ * Orientation is the angle between the vertical axis and
+ * the major axis of the contact ellipse.
+ * The range is -127 to 127.
+ * the positive direction is clockwise form the vertical axis.
+ * If the ellipse of contact degenerates into a circle,
+ * orientation is reported as 0.
+ *
+ * Also, for Gen5 trackpad the accurate of this orientation
+ * value is value + (-30 ~ 30).
+ */
+ input_set_abs_params(input, ABS_MT_ORIENTATION,
+ -127, 127, 0, 0);
+ }
+ if (cyapa->gen >= CYAPA_GEN5) {
+ input_set_abs_params(input, ABS_MT_WIDTH_MAJOR, 0, 255, 0, 0);
+ input_set_abs_params(input, ABS_MT_WIDTH_MINOR, 0, 255, 0, 0);
+ }
input_abs_set_res(input, ABS_MT_POSITION_X,
cyapa->max_abs_x / cyapa->physical_size_x);
@@ -838,16 +415,160 @@ static int cyapa_create_input_dev(struct cyapa *cyapa)
return error;
}
+ /* Register the device in input subsystem */
+ error = input_register_device(input);
+ if (error) {
+ dev_err(dev, "failed to register input device: %d\n", error);
+ return error;
+ }
+
cyapa->input = input;
return 0;
}
+/*
+ * cyapa_sleep_time_to_pwr_cmd and cyapa_pwr_cmd_to_sleep_time
+ *
+ * These are helper functions that convert to and from integer idle
+ * times and register settings to write to the PowerMode register.
+ * The trackpad supports between 20ms to 1000ms scan intervals.
+ * The time will be increased in increments of 10ms from 20ms to 100ms.
+ * From 100ms to 1000ms, time will be increased in increments of 20ms.
+ *
+ * When Idle_Time < 100, the format to convert Idle_Time to Idle_Command is:
+ * Idle_Command = Idle Time / 10;
+ * When Idle_Time >= 100, the format to convert Idle_Time to Idle_Command is:
+ * Idle_Command = Idle Time / 20 + 5;
+ */
+u8 cyapa_sleep_time_to_pwr_cmd(u16 sleep_time)
+{
+ u16 encoded_time;
+
+ sleep_time = clamp_val(sleep_time, 20, 1000);
+ encoded_time = sleep_time < 100 ? sleep_time / 10 : sleep_time / 20 + 5;
+ return (encoded_time << 2) & PWR_MODE_MASK;
+}
+
+u16 cyapa_pwr_cmd_to_sleep_time(u8 pwr_mode)
+{
+ u8 encoded_time = pwr_mode >> 2;
+
+ return (encoded_time < 10) ? encoded_time * 10
+ : (encoded_time - 5) * 20;
+}
+
+/* 0 on driver initialize and detected successfully, negative on failure. */
+static int cyapa_initialize(struct cyapa *cyapa)
+{
+ int error = 0;
+
+ cyapa->state = CYAPA_STATE_NO_DEVICE;
+ cyapa->gen = CYAPA_GEN_UNKNOWN;
+ mutex_init(&cyapa->state_sync_lock);
+
+ /*
+ * Set to hard code default, they will be updated with trackpad set
+ * default values after probe and initialized.
+ */
+ cyapa->suspend_power_mode = PWR_MODE_SLEEP;
+ cyapa->suspend_sleep_time =
+ cyapa_pwr_cmd_to_sleep_time(cyapa->suspend_power_mode);
+
+ if (cyapa_gen3_ops.initialize)
+ error = cyapa_gen3_ops.initialize(cyapa);
+ if (error)
+ return error;
+
+ error = cyapa_detect(cyapa);
+ if (error)
+ return error;
+
+ /* Power down the device until we need it. */
+ if (!CYAPA_BOOTLOADER(cyapa) && cyapa->ops->set_power_mode)
+ cyapa->ops->set_power_mode(cyapa, PWR_MODE_OFF, 0);
+
+ return 0;
+}
+
+static int cyapa_reinitialize(struct cyapa *cyapa)
+{
+ struct device *dev = &cyapa->client->dev;
+ struct input_dev *input = cyapa->input;
+ int error;
+
+ /* Avoid command failures when TP was in OFF state. */
+ if (!CYAPA_BOOTLOADER(cyapa) && cyapa->ops->set_power_mode)
+ cyapa->ops->set_power_mode(cyapa, PWR_MODE_FULL_ACTIVE, 0);
+
+ error = cyapa_detect(cyapa);
+ if (error)
+ goto out;
+
+ if (!input && cyapa->operational) {
+ error = cyapa_create_input_dev(cyapa);
+ if (error) {
+ dev_err(dev, "create input_dev instance failed: %d\n",
+ error);
+ goto out;
+ }
+ }
+
+out:
+ if (!input || !input->users) {
+ /* Reset to power OFF state to save power when no user open. */
+ if (!CYAPA_BOOTLOADER(cyapa) && cyapa->ops->set_power_mode)
+ cyapa->ops->set_power_mode(cyapa, PWR_MODE_OFF, 0);
+ }
+
+ return error;
+}
+
+static irqreturn_t cyapa_irq(int irq, void *dev_id)
+{
+ struct cyapa *cyapa = dev_id;
+ struct device *dev = &cyapa->client->dev;
+ bool cont;
+
+ if (device_may_wakeup(dev))
+ pm_wakeup_event(dev, 0);
+
+ /* Interrupt event maybe cuased by host command to trackpad device. */
+ cont = true;
+ if (cyapa->ops->irq_cmd_handler)
+ cont = cyapa->ops->irq_cmd_handler(cyapa);
+
+ /* Interrupt event maybe from trackpad device input reporting. */
+ if (cont && cyapa->ops->irq_handler) {
+ /* Still in probling or in firware image udpating or reading. */
+ if (!cyapa->input && cyapa->ops->sort_empty_output_data) {
+ cyapa->ops->sort_empty_output_data(cyapa,
+ NULL, NULL, NULL);
+ goto out;
+ }
+
+ if (!cyapa->operational || cyapa->ops->irq_handler(cyapa)) {
+ if (!mutex_trylock(&cyapa->state_sync_lock) &&
+ cyapa->ops->sort_empty_output_data) {
+ cyapa->ops->sort_empty_output_data(cyapa,
+ NULL, NULL, NULL);
+ goto out;
+ }
+ cyapa_reinitialize(cyapa);
+ mutex_unlock(&cyapa->state_sync_lock);
+ }
+ }
+
+out:
+ return IRQ_HANDLED;
+}
+
static int cyapa_probe(struct i2c_client *client,
const struct i2c_device_id *dev_id)
{
struct device *dev = &client->dev;
struct cyapa *cyapa;
u8 adapter_func;
+ union i2c_smbus_data dummy;
int error;
adapter_func = cyapa_check_adapter_functionality(client);
@@ -856,39 +577,30 @@ static int cyapa_probe(struct i2c_client *client,
return -EIO;
}
+ /* Make sure there is something at this address */
+ if (i2c_smbus_xfer(client->adapter, client->addr, 0,
+ I2C_SMBUS_READ, 0, I2C_SMBUS_BYTE, &dummy) < 0)
+ return -ENODEV;
+
cyapa = devm_kzalloc(dev, sizeof(struct cyapa), GFP_KERNEL);
if (!cyapa)
return -ENOMEM;
- cyapa->gen = CYAPA_GEN3;
- cyapa->client = client;
- i2c_set_clientdata(client, cyapa);
- sprintf(cyapa->phys, "i2c-%d-%04x/input0", client->adapter->nr,
- client->addr);
-
/* i2c isn't supported, use smbus */
if (adapter_func == CYAPA_ADAPTER_FUNC_SMBUS)
cyapa->smbus = true;
- cyapa->state = CYAPA_STATE_NO_DEVICE;
-
- error = cyapa_check_is_operational(cyapa);
- if (error) {
- dev_err(dev, "device not operational, %d\n", error);
- return error;
- }
+ cyapa->client = client;
+ i2c_set_clientdata(client, cyapa);
+ sprintf(cyapa->phys, "i2c-%d-%04x/input0", client->adapter->nr,
+ client->addr);
- /* Power down the device until we need it */
- error = cyapa_set_power_mode(cyapa, PWR_MODE_OFF);
+ error = cyapa_initialize(cyapa);
if (error) {
- dev_err(dev, "failed to quiesce the device: %d\n", error);
+ dev_err(dev, "failed to detect and initialize tp device.\n");
return error;
}
- error = cyapa_create_input_dev(cyapa);
- if (error)
- return error;
-
error = devm_request_threaded_irq(dev, client->irq,
NULL, cyapa_irq,
IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
@@ -901,11 +613,18 @@ static int cyapa_probe(struct i2c_client *client,
/* Disable IRQ until the device is opened */
disable_irq(client->irq);
- /* Register the device in input subsystem */
- error = input_register_device(cyapa->input);
- if (error) {
- dev_err(dev, "failed to register input device: %d\n", error);
- return error;
+ /*
+ * Register the device in the input subsystem when it's operational.
+ * Otherwise, keep in this driver, so it can be be recovered or updated
+ * through the sysfs mode and update_fw interfaces by user or apps.
+ */
+ if (cyapa->operational) {
+ error = cyapa_create_input_dev(cyapa);
+ if (error) {
+ dev_err(dev, "create input_dev instance failed: %d\n",
+ error);
+ return error;
+ }
}
return 0;
@@ -915,11 +634,10 @@ static int __maybe_unused cyapa_suspend(struct device *dev)
{
struct i2c_client *client = to_i2c_client(dev);
struct cyapa *cyapa = i2c_get_clientdata(client);
- struct input_dev *input = cyapa->input;
u8 power_mode;
int error;
- error = mutex_lock_interruptible(&input->mutex);
+ error = mutex_lock_interruptible(&cyapa->state_sync_lock);
if (error)
return error;
@@ -929,18 +647,20 @@ static int __maybe_unused cyapa_suspend(struct device *dev)
* Set trackpad device to idle mode if wakeup is allowed,
* otherwise turn off.
*/
- power_mode = device_may_wakeup(dev) ? PWR_MODE_IDLE
+ power_mode = device_may_wakeup(dev) ? cyapa->suspend_power_mode
: PWR_MODE_OFF;
- error = cyapa_set_power_mode(cyapa, power_mode);
- if (error)
- dev_err(dev, "resume: set power mode to %d failed: %d\n",
- power_mode, error);
+ if (!CYAPA_BOOTLOADER(cyapa) && cyapa->ops->set_power_mode) {
+ error = cyapa->ops->set_power_mode(cyapa, power_mode,
+ cyapa->suspend_sleep_time);
+ if (error)
+ dev_err(dev, "suspend set power mode failed: %d\n",
+ error);
+ }
if (device_may_wakeup(dev))
cyapa->irq_wake = (enable_irq_wake(client->irq) == 0);
- mutex_unlock(&input->mutex);
-
+ mutex_unlock(&cyapa->state_sync_lock);
return 0;
}
@@ -948,25 +668,22 @@ static int __maybe_unused cyapa_resume(struct device *dev)
{
struct i2c_client *client = to_i2c_client(dev);
struct cyapa *cyapa = i2c_get_clientdata(client);
- struct input_dev *input = cyapa->input;
- u8 power_mode;
int error;
- mutex_lock(&input->mutex);
+ mutex_lock(&cyapa->state_sync_lock);
- if (device_may_wakeup(dev) && cyapa->irq_wake)
+ if (device_may_wakeup(dev) && cyapa->irq_wake) {
disable_irq_wake(client->irq);
+ cyapa->irq_wake = false;
+ }
- power_mode = input->users ? PWR_MODE_FULL_ACTIVE : PWR_MODE_OFF;
- error = cyapa_set_power_mode(cyapa, PWR_MODE_FULL_ACTIVE);
+ error = cyapa_reinitialize(cyapa);
if (error)
- dev_warn(dev, "resume: set power mode to %d failed: %d\n",
- power_mode, error);
+ dev_warn(dev, "failed to reinitialize TP device: %d\n", error);
enable_irq(client->irq);
- mutex_unlock(&input->mutex);
-
+ mutex_unlock(&cyapa->state_sync_lock);
return 0;
}
diff --git a/drivers/input/mouse/cyapa.h b/drivers/input/mouse/cyapa.h
new file mode 100644
index 0000000..8a75c52
--- /dev/null
+++ b/drivers/input/mouse/cyapa.h
@@ -0,0 +1,307 @@
+/*
+ * Cypress APA trackpad with I2C interface
+ *
+ * Author: Dudley Du <dudl@cypress.com>
+ *
+ * Copyright (C) 2014 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.
+ */
+
+#ifndef _CYAPA_H
+#define _CYAPA_H
+
+#include <linux/firmware.h>
+
+/* APA trackpad firmware generation number. */
+#define CYAPA_GEN_UNKNOWN 0x00 /* unknown protocol. */
+#define CYAPA_GEN3 0x03 /* support MT-protocol B with tracking ID. */
+#define CYAPA_GEN5 0x05 /* support TrueTouch GEN5 trackpad device. */
+
+#define CYAPA_NAME "Cypress APA Trackpad (cyapa)"
+
+/*
+ * Macros for SMBus communication
+ */
+#define SMBUS_READ 0x01
+#define SMBUS_WRITE 0x00
+#define SMBUS_ENCODE_IDX(cmd, idx) ((cmd) | (((idx) & 0x03) << 1))
+#define SMBUS_ENCODE_RW(cmd, rw) ((cmd) | ((rw) & 0x01))
+#define SMBUS_BYTE_BLOCK_CMD_MASK 0x80
+#define SMBUS_GROUP_BLOCK_CMD_MASK 0x40
+
+/* Commands for read/write registers of Cypress trackpad */
+#define CYAPA_CMD_SOFT_RESET 0x00
+#define CYAPA_CMD_POWER_MODE 0x01
+#define CYAPA_CMD_DEV_STATUS 0x02
+#define CYAPA_CMD_GROUP_DATA 0x03
+#define CYAPA_CMD_GROUP_CMD 0x04
+#define CYAPA_CMD_GROUP_QUERY 0x05
+#define CYAPA_CMD_BL_STATUS 0x06
+#define CYAPA_CMD_BL_HEAD 0x07
+#define CYAPA_CMD_BL_CMD 0x08
+#define CYAPA_CMD_BL_DATA 0x09
+#define CYAPA_CMD_BL_ALL 0x0a
+#define CYAPA_CMD_BLK_PRODUCT_ID 0x0b
+#define CYAPA_CMD_BLK_HEAD 0x0c
+#define CYAPA_CMD_MAX_BASELINE 0x0d
+#define CYAPA_CMD_MIN_BASELINE 0x0e
+
+#define BL_HEAD_OFFSET 0x00
+#define BL_DATA_OFFSET 0x10
+
+#define BL_STATUS_SIZE 3 /* Length of gen3 bootloader status registers */
+#define CYAPA_REG_MAP_SIZE 256
+
+/*
+ * Gen3 Operational Device Status Register
+ *
+ * bit 7: Valid interrupt source
+ * bit 6 - 4: Reserved
+ * bit 3 - 2: Power status
+ * bit 1 - 0: Device status
+ */
+#define REG_OP_STATUS 0x00
+#define OP_STATUS_SRC 0x80
+#define OP_STATUS_POWER 0x0c
+#define OP_STATUS_DEV 0x03
+#define OP_STATUS_MASK (OP_STATUS_SRC | OP_STATUS_POWER | OP_STATUS_DEV)
+
+/*
+ * Operational Finger Count/Button Flags Register
+ *
+ * bit 7 - 4: Number of touched finger
+ * bit 3: Valid data
+ * bit 2: Middle Physical Button
+ * bit 1: Right Physical Button
+ * bit 0: Left physical Button
+ */
+#define REG_OP_DATA1 0x01
+#define OP_DATA_VALID 0x08
+#define OP_DATA_MIDDLE_BTN 0x04
+#define OP_DATA_RIGHT_BTN 0x02
+#define OP_DATA_LEFT_BTN 0x01
+#define OP_DATA_BTN_MASK (OP_DATA_MIDDLE_BTN | OP_DATA_RIGHT_BTN | \
+ OP_DATA_LEFT_BTN)
+
+/*
+ * Write-only command file register used to issue commands and
+ * parameters to the bootloader.
+ * The default value read from it is always 0x00.
+ */
+#define REG_BL_FILE 0x00
+#define BL_FILE 0x00
+
+/*
+ * Bootloader Status Register
+ *
+ * bit 7: Busy
+ * bit 6 - 5: Reserved
+ * bit 4: Bootloader running
+ * bit 3 - 2: Reserved
+ * bit 1: Watchdog Reset
+ * bit 0: Checksum valid
+ */
+#define REG_BL_STATUS 0x01
+#define BL_STATUS_REV_6_5 0x60
+#define BL_STATUS_BUSY 0x80
+#define BL_STATUS_RUNNING 0x10
+#define BL_STATUS_REV_3_2 0x0c
+#define BL_STATUS_WATCHDOG 0x02
+#define BL_STATUS_CSUM_VALID 0x01
+#define BL_STATUS_REV_MASK (BL_STATUS_WATCHDOG | BL_STATUS_REV_3_2 | \
+ BL_STATUS_REV_6_5)
+
+/*
+ * Bootloader Error Register
+ *
+ * bit 7: Invalid
+ * bit 6: Invalid security key
+ * bit 5: Bootloading
+ * bit 4: Command checksum
+ * bit 3: Flash protection error
+ * bit 2: Flash checksum error
+ * bit 1 - 0: Reserved
+ */
+#define REG_BL_ERROR 0x02
+#define BL_ERROR_INVALID 0x80
+#define BL_ERROR_INVALID_KEY 0x40
+#define BL_ERROR_BOOTLOADING 0x20
+#define BL_ERROR_CMD_CSUM 0x10
+#define BL_ERROR_FLASH_PROT 0x08
+#define BL_ERROR_FLASH_CSUM 0x04
+#define BL_ERROR_RESERVED 0x03
+#define BL_ERROR_NO_ERR_IDLE 0x00
+#define BL_ERROR_NO_ERR_ACTIVE (BL_ERROR_BOOTLOADING)
+
+#define CAPABILITY_BTN_SHIFT 3
+#define CAPABILITY_LEFT_BTN_MASK (0x01 << 3)
+#define CAPABILITY_RIGHT_BTN_MASK (0x01 << 4)
+#define CAPABILITY_MIDDLE_BTN_MASK (0x01 << 5)
+#define CAPABILITY_BTN_MASK (CAPABILITY_LEFT_BTN_MASK | \
+ CAPABILITY_RIGHT_BTN_MASK | \
+ CAPABILITY_MIDDLE_BTN_MASK)
+
+#define PWR_MODE_MASK 0xfc
+#define PWR_MODE_FULL_ACTIVE (0x3f << 2)
+#define PWR_MODE_IDLE (0x03 << 2) /* Default rt suspend scanrate: 30ms */
+#define PWR_MODE_SLEEP (0x05 << 2) /* Default suspend scanrate: 50ms */
+#define PWR_MODE_BTN_ONLY (0x01 << 2)
+#define PWR_MODE_OFF (0x00 << 2)
+
+#define PWR_STATUS_MASK 0x0c
+#define PWR_STATUS_ACTIVE (0x03 << 2)
+#define PWR_STATUS_IDLE (0x02 << 2)
+#define PWR_STATUS_BTN_ONLY (0x01 << 2)
+#define PWR_STATUS_OFF (0x00 << 2)
+
+#define AUTOSUSPEND_DELAY 2000 /* unit : ms */
+
+#define UNINIT_SLEEP_TIME 0xFFFF
+#define UNINIT_PWR_MODE 0xFF
+
+#define BTN_ONLY_MODE_NAME "buttononly"
+#define OFF_MODE_NAME "off"
+
+/* The touch.id is used as the MT slot id, thus max MT slot is 15 */
+#define CYAPA_MAX_MT_SLOTS 15
+
+struct cyapa;
+
+typedef bool (*cb_sort)(struct cyapa *, u8 *, int);
+
+struct cyapa_dev_ops {
+ int (*check_fw)(struct cyapa *, const struct firmware *);
+ int (*bl_enter)(struct cyapa *);
+ int (*bl_activate)(struct cyapa *);
+ int (*bl_initiate)(struct cyapa *, const struct firmware *);
+ int (*update_fw)(struct cyapa *, const struct firmware *);
+ int (*bl_verify_app_integrity)(struct cyapa *);
+ int (*bl_deactivate)(struct cyapa *);
+
+ ssize_t (*show_baseline)(struct device *,
+ struct device_attribute *, char *);
+ ssize_t (*calibrate_store)(struct device *,
+ struct device_attribute *, const char *, size_t);
+
+ int (*initialize)(struct cyapa *cyapa);
+
+ int (*state_parse)(struct cyapa *cyapa, u8 *reg_status, int len);
+ int (*operational_check)(struct cyapa *cyapa);
+
+ int (*irq_handler)(struct cyapa *);
+ bool (*irq_cmd_handler)(struct cyapa *);
+ int (*sort_empty_output_data)(struct cyapa *,
+ u8 *, int *, cb_sort);
+
+ int (*set_power_mode)(struct cyapa *, u8, u16);
+};
+
+struct cyapa_gen5_cmd_states {
+ struct mutex cmd_lock;
+ struct completion cmd_ready;
+ atomic_t cmd_issued;
+ u8 in_progress_cmd;
+ bool is_irq_mode;
+
+ cb_sort resp_sort_func;
+ u8 *resp_data;
+ int *resp_len;
+
+ u8 irq_cmd_buf[CYAPA_REG_MAP_SIZE];
+ u8 empty_buf[CYAPA_REG_MAP_SIZE];
+};
+
+union cyapa_cmd_states {
+ struct cyapa_gen5_cmd_states gen5;
+};
+
+enum cyapa_state {
+ CYAPA_STATE_NO_DEVICE,
+ CYAPA_STATE_BL_BUSY,
+ CYAPA_STATE_BL_IDLE,
+ CYAPA_STATE_BL_ACTIVE,
+ CYAPA_STATE_OP,
+ CYAPA_STATE_GEN5_BL,
+ CYAPA_STATE_GEN5_APP,
+};
+#define CYAPA_OPERATIONAL(cyapa) \
+ (((cyapa)->gen == CYAPA_GEN5 && \
+ (cyapa)->state == CYAPA_STATE_GEN5_APP) || \
+ ((cyapa->gen) == CYAPA_GEN3 && (cyapa)->state == CYAPA_STATE_OP))
+#define CYAPA_BOOTLOADER(cyapa) \
+ ((((cyapa)->gen == CYAPA_GEN5 && \
+ (cyapa)->state == CYAPA_STATE_GEN5_BL)) || \
+ (((cyapa)->gen == CYAPA_GEN3 && \
+ (cyapa)->state >= CYAPA_STATE_BL_BUSY && \
+ (cyapa)->state <= CYAPA_STATE_BL_ACTIVE)))
+
+/* The main device structure */
+struct cyapa {
+ enum cyapa_state state;
+ u8 status[BL_STATUS_SIZE];
+ bool operational; /* true: ready for data reporting; false: not. */
+
+ struct i2c_client *client;
+ struct input_dev *input;
+ char phys[32]; /* Device physical location */
+ bool irq_wake; /* Irq wake is enabled */
+ bool smbus;
+
+ /* power mode settings */
+ u8 suspend_power_mode;
+ u16 suspend_sleep_time;
+ u8 dev_pwr_mode;
+ u16 dev_sleep_time;
+
+ /* Read from query data region. */
+ char product_id[16];
+ u8 fw_maj_ver; /* Firmware major version. */
+ u8 fw_min_ver; /* Firmware minor version. */
+ u8 btn_capability;
+ u8 gen;
+ int max_abs_x;
+ int max_abs_y;
+ int physical_size_x;
+ int physical_size_y;
+
+ /* Used in ttsp and truetouch based trackpad devices. */
+ u8 x_origin; /* X Axis Origin: 0 = left side; 1 = rigth side. */
+ u8 y_origin; /* Y Axis Origin: 0 = top; 1 = bottom. */
+ int electrodes_x; /* Number of electrodes on the X Axis*/
+ int electrodes_y; /* Number of electrodes on the Y Axis*/
+ int max_z;
+
+ /*
+ * Used to synchronize the access or update the device state.
+ * And since update firmware and read firmware image process will take
+ * quite long time, maybe more than 10 seconds, so use mutex_lock
+ * to sync and wait other interface and detecting are done or ready.
+ */
+ struct mutex state_sync_lock;
+
+ const struct cyapa_dev_ops *ops;
+
+ union cyapa_cmd_states cmd_states;
+};
+
+
+ssize_t cyapa_i2c_reg_read_block(struct cyapa *cyapa, u8 reg, size_t len,
+ u8 *values);
+ssize_t cyapa_smbus_read_block(struct cyapa *cyapa, u8 cmd, size_t len,
+ u8 *values);
+
+ssize_t cyapa_read_block(struct cyapa *cyapa, u8 cmd_idx, u8 *values);
+
+int cyapa_poll_state(struct cyapa *cyapa, unsigned int timeout);
+
+u8 cyapa_sleep_time_to_pwr_cmd(u16 sleep_time);
+u16 cyapa_pwr_cmd_to_sleep_time(u8 pwr_mode);
+
+
+extern const char product_id[];
+extern const struct cyapa_dev_ops cyapa_gen3_ops;
+
+#endif
diff --git a/drivers/input/mouse/cyapa_gen3.c b/drivers/input/mouse/cyapa_gen3.c
new file mode 100644
index 0000000..228fd2d
--- /dev/null
+++ b/drivers/input/mouse/cyapa_gen3.c
@@ -0,0 +1,801 @@
+/*
+ * Cypress APA trackpad with I2C interface
+ *
+ * Author: Dudley Du <dudl@cypress.com>
+ * Further cleanup and restructuring by:
+ * Daniel Kurtz <djkurtz@chromium.org>
+ * Benson Leung <bleung@chromium.org>
+ *
+ * Copyright (C) 2011-2014 Cypress Semiconductor, Inc.
+ * Copyright (C) 2011-2012 Google, 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/module.h>
+#include <linux/slab.h>
+#include "cyapa.h"
+
+
+#define GEN3_MAX_FINGERS 5
+#define GEN3_FINGER_NUM(x) (((x) >> 4) & 0x07)
+
+#define BLK_HEAD_BYTES 32
+
+/* Macro for register map group offset. */
+#define PRODUCT_ID_SIZE 16
+#define QUERY_DATA_SIZE 27
+#define REG_PROTOCOL_GEN_QUERY_OFFSET 20
+
+#define REG_OFFSET_DATA_BASE 0x0000
+#define REG_OFFSET_COMMAND_BASE 0x0028
+#define REG_OFFSET_QUERY_BASE 0x002a
+
+#define CYAPA_OFFSET_SOFT_RESET REG_OFFSET_COMMAND_BASE
+#define OP_RECALIBRATION_MASK 0x80
+#define OP_REPORT_BASELINE_MASK 0x40
+#define REG_OFFSET_MAX_BASELINE 0x0026
+#define REG_OFFSET_MIN_BASELINE 0x0027
+
+#define REG_OFFSET_POWER_MODE (REG_OFFSET_COMMAND_BASE + 1)
+#define SET_POWER_MODE_DELAY 10000 /* Unit: us */
+#define SET_POWER_MODE_TRIES 5
+
+#define GEN3_BL_CMD_CHECKSUM_SEED 0xff
+#define GEN3_BL_CMD_INITIATE_BL 0x38
+#define GEN3_BL_CMD_WRITE_BLOCK 0x39
+#define GEN3_BL_CMD_VERIFY_BLOCK 0x3a
+#define GEN3_BL_CMD_TERMINATE_BL 0x3b
+#define GEN3_BL_CMD_LAUNCH_APP 0xa5
+
+/*
+ * CYAPA trackpad device states.
+ * Used in register 0x00, bit1-0, DeviceStatus field.
+ * Other values indicate device is in an abnormal state and must be reset.
+ */
+#define CYAPA_DEV_NORMAL 0x03
+#define CYAPA_DEV_BUSY 0x01
+
+#define CYAPA_FW_BLOCK_SIZE 64
+#define CYAPA_FW_READ_SIZE 16
+#define CYAPA_FW_HDR_START 0x0780
+#define CYAPA_FW_HDR_BLOCK_COUNT 2
+#define CYAPA_FW_HDR_BLOCK_START (CYAPA_FW_HDR_START / CYAPA_FW_BLOCK_SIZE)
+#define CYAPA_FW_HDR_SIZE (CYAPA_FW_HDR_BLOCK_COUNT * \
+ CYAPA_FW_BLOCK_SIZE)
+#define CYAPA_FW_DATA_START 0x0800
+#define CYAPA_FW_DATA_BLOCK_COUNT 480
+#define CYAPA_FW_DATA_BLOCK_START (CYAPA_FW_DATA_START / CYAPA_FW_BLOCK_SIZE)
+#define CYAPA_FW_DATA_SIZE (CYAPA_FW_DATA_BLOCK_COUNT * \
+ CYAPA_FW_BLOCK_SIZE)
+#define CYAPA_FW_SIZE (CYAPA_FW_HDR_SIZE + CYAPA_FW_DATA_SIZE)
+#define CYAPA_CMD_LEN 16
+
+#define GEN3_BL_IDLE_FW_MAJ_VER_OFFSET 0x0b
+#define GEN3_BL_IDLE_FW_MIN_VER_OFFSET (GEN3_BL_IDLE_FW_MAJ_VER_OFFSET + 1)
+
+
+struct cyapa_touch {
+ /*
+ * high bits or x/y position value
+ * bit 7 - 4: high 4 bits of x position value
+ * bit 3 - 0: high 4 bits of y position value
+ */
+ u8 xy_hi;
+ u8 x_lo; /* low 8 bits of x position value. */
+ u8 y_lo; /* low 8 bits of y position value. */
+ u8 pressure;
+ /* id range is 1 - 15. It is incremented with every new touch. */
+ u8 id;
+} __packed;
+
+struct cyapa_reg_data {
+ /*
+ * bit 0 - 1: device status
+ * bit 3 - 2: power mode
+ * bit 6 - 4: reserved
+ * bit 7: interrupt valid bit
+ */
+ u8 device_status;
+ /*
+ * bit 7 - 4: number of fingers currently touching pad
+ * bit 3: valid data check bit
+ * bit 2: middle mechanism button state if exists
+ * bit 1: right mechanism button state if exists
+ * bit 0: left mechanism button state if exists
+ */
+ u8 finger_btn;
+ /* CYAPA reports up to 5 touches per packet. */
+ struct cyapa_touch touches[5];
+} __packed;
+
+static const u8 bl_activate[] = { 0x00, 0xff, 0x38, 0x00, 0x01, 0x02, 0x03,
+ 0x04, 0x05, 0x06, 0x07 };
+static const u8 bl_deactivate[] = { 0x00, 0xff, 0x3b, 0x00, 0x01, 0x02, 0x03,
+ 0x04, 0x05, 0x06, 0x07 };
+static const u8 bl_exit[] = { 0x00, 0xff, 0xa5, 0x00, 0x01, 0x02, 0x03, 0x04,
+ 0x05, 0x06, 0x07 };
+
+
+ /* for byte read/write command */
+#define CMD_RESET 0
+#define CMD_POWER_MODE 1
+#define CMD_DEV_STATUS 2
+#define CMD_REPORT_MAX_BASELINE 3
+#define CMD_REPORT_MIN_BASELINE 4
+#define SMBUS_BYTE_CMD(cmd) (((cmd) & 0x3f) << 1)
+#define CYAPA_SMBUS_RESET SMBUS_BYTE_CMD(CMD_RESET)
+#define CYAPA_SMBUS_POWER_MODE SMBUS_BYTE_CMD(CMD_POWER_MODE)
+#define CYAPA_SMBUS_DEV_STATUS SMBUS_BYTE_CMD(CMD_DEV_STATUS)
+#define CYAPA_SMBUS_MAX_BASELINE SMBUS_BYTE_CMD(CMD_REPORT_MAX_BASELINE)
+#define CYAPA_SMBUS_MIN_BASELINE SMBUS_BYTE_CMD(CMD_REPORT_MIN_BASELINE)
+
+ /* for group registers read/write command */
+#define REG_GROUP_DATA 0
+#define REG_GROUP_CMD 2
+#define REG_GROUP_QUERY 3
+#define SMBUS_GROUP_CMD(grp) (0x80 | (((grp) & 0x07) << 3))
+#define CYAPA_SMBUS_GROUP_DATA SMBUS_GROUP_CMD(REG_GROUP_DATA)
+#define CYAPA_SMBUS_GROUP_CMD SMBUS_GROUP_CMD(REG_GROUP_CMD)
+#define CYAPA_SMBUS_GROUP_QUERY SMBUS_GROUP_CMD(REG_GROUP_QUERY)
+
+ /* for register block read/write command */
+#define CMD_BL_STATUS 0
+#define CMD_BL_HEAD 1
+#define CMD_BL_CMD 2
+#define CMD_BL_DATA 3
+#define CMD_BL_ALL 4
+#define CMD_BLK_PRODUCT_ID 5
+#define CMD_BLK_HEAD 6
+#define SMBUS_BLOCK_CMD(cmd) (0xc0 | (((cmd) & 0x1f) << 1))
+
+/* register block read/write command in bootloader mode */
+#define CYAPA_SMBUS_BL_STATUS SMBUS_BLOCK_CMD(CMD_BL_STATUS)
+#define CYAPA_SMBUS_BL_HEAD SMBUS_BLOCK_CMD(CMD_BL_HEAD)
+#define CYAPA_SMBUS_BL_CMD SMBUS_BLOCK_CMD(CMD_BL_CMD)
+#define CYAPA_SMBUS_BL_DATA SMBUS_BLOCK_CMD(CMD_BL_DATA)
+#define CYAPA_SMBUS_BL_ALL SMBUS_BLOCK_CMD(CMD_BL_ALL)
+
+/* register block read/write command in operational mode */
+#define CYAPA_SMBUS_BLK_PRODUCT_ID SMBUS_BLOCK_CMD(CMD_BLK_PRODUCT_ID)
+#define CYAPA_SMBUS_BLK_HEAD SMBUS_BLOCK_CMD(CMD_BLK_HEAD)
+
+ /* for byte read/write command */
+#define CMD_RESET 0
+#define CMD_POWER_MODE 1
+#define CMD_DEV_STATUS 2
+#define CMD_REPORT_MAX_BASELINE 3
+#define CMD_REPORT_MIN_BASELINE 4
+#define SMBUS_BYTE_CMD(cmd) (((cmd) & 0x3f) << 1)
+#define CYAPA_SMBUS_RESET SMBUS_BYTE_CMD(CMD_RESET)
+#define CYAPA_SMBUS_POWER_MODE SMBUS_BYTE_CMD(CMD_POWER_MODE)
+#define CYAPA_SMBUS_DEV_STATUS SMBUS_BYTE_CMD(CMD_DEV_STATUS)
+#define CYAPA_SMBUS_MAX_BASELINE SMBUS_BYTE_CMD(CMD_REPORT_MAX_BASELINE)
+#define CYAPA_SMBUS_MIN_BASELINE SMBUS_BYTE_CMD(CMD_REPORT_MIN_BASELINE)
+
+ /* for group registers read/write command */
+#define REG_GROUP_DATA 0
+#define REG_GROUP_CMD 2
+#define REG_GROUP_QUERY 3
+#define SMBUS_GROUP_CMD(grp) (0x80 | (((grp) & 0x07) << 3))
+#define CYAPA_SMBUS_GROUP_DATA SMBUS_GROUP_CMD(REG_GROUP_DATA)
+#define CYAPA_SMBUS_GROUP_CMD SMBUS_GROUP_CMD(REG_GROUP_CMD)
+#define CYAPA_SMBUS_GROUP_QUERY SMBUS_GROUP_CMD(REG_GROUP_QUERY)
+
+ /* for register block read/write command */
+#define CMD_BL_STATUS 0
+#define CMD_BL_HEAD 1
+#define CMD_BL_CMD 2
+#define CMD_BL_DATA 3
+#define CMD_BL_ALL 4
+#define CMD_BLK_PRODUCT_ID 5
+#define CMD_BLK_HEAD 6
+#define SMBUS_BLOCK_CMD(cmd) (0xc0 | (((cmd) & 0x1f) << 1))
+
+/* register block read/write command in bootloader mode */
+#define CYAPA_SMBUS_BL_STATUS SMBUS_BLOCK_CMD(CMD_BL_STATUS)
+#define CYAPA_SMBUS_BL_HEAD SMBUS_BLOCK_CMD(CMD_BL_HEAD)
+#define CYAPA_SMBUS_BL_CMD SMBUS_BLOCK_CMD(CMD_BL_CMD)
+#define CYAPA_SMBUS_BL_DATA SMBUS_BLOCK_CMD(CMD_BL_DATA)
+#define CYAPA_SMBUS_BL_ALL SMBUS_BLOCK_CMD(CMD_BL_ALL)
+
+/* register block read/write command in operational mode */
+#define CYAPA_SMBUS_BLK_PRODUCT_ID SMBUS_BLOCK_CMD(CMD_BLK_PRODUCT_ID)
+#define CYAPA_SMBUS_BLK_HEAD SMBUS_BLOCK_CMD(CMD_BLK_HEAD)
+
+struct cyapa_cmd_len {
+ u8 cmd;
+ u8 len;
+};
+
+/* maps generic CYAPA_CMD_* code to the I2C equivalent */
+static const struct cyapa_cmd_len cyapa_i2c_cmds[] = {
+ { CYAPA_OFFSET_SOFT_RESET, 1 }, /* CYAPA_CMD_SOFT_RESET */
+ { REG_OFFSET_COMMAND_BASE + 1, 1 }, /* CYAPA_CMD_POWER_MODE */
+ { REG_OFFSET_DATA_BASE, 1 }, /* CYAPA_CMD_DEV_STATUS */
+ { REG_OFFSET_DATA_BASE, sizeof(struct cyapa_reg_data) },
+ /* CYAPA_CMD_GROUP_DATA */
+ { REG_OFFSET_COMMAND_BASE, 0 }, /* CYAPA_CMD_GROUP_CMD */
+ { REG_OFFSET_QUERY_BASE, QUERY_DATA_SIZE }, /* CYAPA_CMD_GROUP_QUERY */
+ { BL_HEAD_OFFSET, 3 }, /* CYAPA_CMD_BL_STATUS */
+ { BL_HEAD_OFFSET, 16 }, /* CYAPA_CMD_BL_HEAD */
+ { BL_HEAD_OFFSET, 16 }, /* CYAPA_CMD_BL_CMD */
+ { BL_DATA_OFFSET, 16 }, /* CYAPA_CMD_BL_DATA */
+ { BL_HEAD_OFFSET, 32 }, /* CYAPA_CMD_BL_ALL */
+ { REG_OFFSET_QUERY_BASE, PRODUCT_ID_SIZE },
+ /* CYAPA_CMD_BLK_PRODUCT_ID */
+ { REG_OFFSET_DATA_BASE, 32 }, /* CYAPA_CMD_BLK_HEAD */
+ { REG_OFFSET_MAX_BASELINE, 1 }, /* CYAPA_CMD_MAX_BASELINE */
+ { REG_OFFSET_MIN_BASELINE, 1 }, /* CYAPA_CMD_MIN_BASELINE */
+};
+
+static const struct cyapa_cmd_len cyapa_smbus_cmds[] = {
+ { CYAPA_SMBUS_RESET, 1 }, /* CYAPA_CMD_SOFT_RESET */
+ { CYAPA_SMBUS_POWER_MODE, 1 }, /* CYAPA_CMD_POWER_MODE */
+ { CYAPA_SMBUS_DEV_STATUS, 1 }, /* CYAPA_CMD_DEV_STATUS */
+ { CYAPA_SMBUS_GROUP_DATA, sizeof(struct cyapa_reg_data) },
+ /* CYAPA_CMD_GROUP_DATA */
+ { CYAPA_SMBUS_GROUP_CMD, 2 }, /* CYAPA_CMD_GROUP_CMD */
+ { CYAPA_SMBUS_GROUP_QUERY, QUERY_DATA_SIZE },
+ /* CYAPA_CMD_GROUP_QUERY */
+ { CYAPA_SMBUS_BL_STATUS, 3 }, /* CYAPA_CMD_BL_STATUS */
+ { CYAPA_SMBUS_BL_HEAD, 16 }, /* CYAPA_CMD_BL_HEAD */
+ { CYAPA_SMBUS_BL_CMD, 16 }, /* CYAPA_CMD_BL_CMD */
+ { CYAPA_SMBUS_BL_DATA, 16 }, /* CYAPA_CMD_BL_DATA */
+ { CYAPA_SMBUS_BL_ALL, 32 }, /* CYAPA_CMD_BL_ALL */
+ { CYAPA_SMBUS_BLK_PRODUCT_ID, PRODUCT_ID_SIZE },
+ /* CYAPA_CMD_BLK_PRODUCT_ID */
+ { CYAPA_SMBUS_BLK_HEAD, 16 }, /* CYAPA_CMD_BLK_HEAD */
+ { CYAPA_SMBUS_MAX_BASELINE, 1 }, /* CYAPA_CMD_MAX_BASELINE */
+ { CYAPA_SMBUS_MIN_BASELINE, 1 }, /* CYAPA_CMD_MIN_BASELINE */
+};
+
+
+/*
+ * cyapa_smbus_read_block - perform smbus block read command
+ * @cyapa - private data structure of the driver
+ * @cmd - the properly encoded smbus command
+ * @len - expected length of smbus command result
+ * @values - buffer to store smbus command result
+ *
+ * Returns negative errno, else the number of bytes written.
+ *
+ * Note:
+ * In trackpad device, the memory block allocated for I2C register map
+ * is 256 bytes, so the max read block for I2C bus is 256 bytes.
+ */
+ssize_t cyapa_smbus_read_block(struct cyapa *cyapa, u8 cmd, size_t len,
+ u8 *values)
+{
+ ssize_t ret;
+ u8 index;
+ u8 smbus_cmd;
+ u8 *buf;
+ struct i2c_client *client = cyapa->client;
+
+ if (!(SMBUS_BYTE_BLOCK_CMD_MASK & cmd))
+ return -EINVAL;
+
+ if (SMBUS_GROUP_BLOCK_CMD_MASK & cmd) {
+ /* read specific block registers command. */
+ smbus_cmd = SMBUS_ENCODE_RW(cmd, SMBUS_READ);
+ ret = i2c_smbus_read_block_data(client, smbus_cmd, values);
+ goto out;
+ }
+
+ ret = 0;
+ for (index = 0; index * I2C_SMBUS_BLOCK_MAX < len; index++) {
+ smbus_cmd = SMBUS_ENCODE_IDX(cmd, index);
+ smbus_cmd = SMBUS_ENCODE_RW(smbus_cmd, SMBUS_READ);
+ buf = values + I2C_SMBUS_BLOCK_MAX * index;
+ ret = i2c_smbus_read_block_data(client, smbus_cmd, buf);
+ if (ret < 0)
+ goto out;
+ }
+
+out:
+ return ret > 0 ? len : ret;
+}
+
+static s32 cyapa_read_byte(struct cyapa *cyapa, u8 cmd_idx)
+{
+ u8 cmd;
+
+ if (cyapa->smbus) {
+ cmd = cyapa_smbus_cmds[cmd_idx].cmd;
+ cmd = SMBUS_ENCODE_RW(cmd, SMBUS_READ);
+ } else {
+ cmd = cyapa_i2c_cmds[cmd_idx].cmd;
+ }
+ return i2c_smbus_read_byte_data(cyapa->client, cmd);
+}
+
+static s32 cyapa_write_byte(struct cyapa *cyapa, u8 cmd_idx, u8 value)
+{
+ u8 cmd;
+
+ if (cyapa->smbus) {
+ cmd = cyapa_smbus_cmds[cmd_idx].cmd;
+ cmd = SMBUS_ENCODE_RW(cmd, SMBUS_WRITE);
+ } else {
+ cmd = cyapa_i2c_cmds[cmd_idx].cmd;
+ }
+ return i2c_smbus_write_byte_data(cyapa->client, cmd, value);
+}
+
+ssize_t cyapa_i2c_reg_read_block(struct cyapa *cyapa, u8 reg, size_t len,
+ u8 *values)
+{
+ return i2c_smbus_read_i2c_block_data(cyapa->client, reg, len, values);
+}
+
+static ssize_t cyapa_i2c_reg_write_block(struct cyapa *cyapa, u8 reg,
+ size_t len, const u8 *values)
+{
+ return i2c_smbus_write_i2c_block_data(cyapa->client, reg, len, values);
+}
+
+ssize_t cyapa_read_block(struct cyapa *cyapa, u8 cmd_idx, u8 *values)
+{
+ u8 cmd;
+ size_t len;
+
+ if (cyapa->smbus) {
+ cmd = cyapa_smbus_cmds[cmd_idx].cmd;
+ len = cyapa_smbus_cmds[cmd_idx].len;
+ return cyapa_smbus_read_block(cyapa, cmd, len, values);
+ }
+ cmd = cyapa_i2c_cmds[cmd_idx].cmd;
+ len = cyapa_i2c_cmds[cmd_idx].len;
+ return cyapa_i2c_reg_read_block(cyapa, cmd, len, values);
+}
+
+/*
+ * Determine the Gen3 trackpad device's current operating state.
+ *
+ */
+static int cyapa_gen3_state_parse(struct cyapa *cyapa, u8 *reg_data, int len)
+{
+ cyapa->state = CYAPA_STATE_NO_DEVICE;
+
+ /* Parse based on Gen3 characteristic registers and bits */
+ if (reg_data[REG_BL_FILE] == BL_FILE &&
+ reg_data[REG_BL_ERROR] == BL_ERROR_NO_ERR_IDLE &&
+ (reg_data[REG_BL_STATUS] ==
+ (BL_STATUS_RUNNING | BL_STATUS_CSUM_VALID) ||
+ reg_data[REG_BL_STATUS] == BL_STATUS_RUNNING)) {
+ /*
+ * Normal state after power on or reset,
+ * REG_BL_STATUS == 0x11, firmware image checksum is valid.
+ * REG_BL_STATUS == 0x10, firmware image checksum is invalid.
+ */
+ cyapa->gen = CYAPA_GEN3;
+ cyapa->state = CYAPA_STATE_BL_IDLE;
+ } else if (reg_data[REG_BL_FILE] == BL_FILE &&
+ (reg_data[REG_BL_STATUS] & BL_STATUS_RUNNING) ==
+ BL_STATUS_RUNNING) {
+ cyapa->gen = CYAPA_GEN3;
+ if (reg_data[REG_BL_STATUS] & BL_STATUS_BUSY) {
+ cyapa->state = CYAPA_STATE_BL_BUSY;
+ } else {
+ if ((reg_data[REG_BL_ERROR] & BL_ERROR_BOOTLOADING) ==
+ BL_ERROR_BOOTLOADING)
+ cyapa->state = CYAPA_STATE_BL_ACTIVE;
+ else
+ cyapa->state = CYAPA_STATE_BL_IDLE;
+ }
+ } else if ((reg_data[REG_OP_STATUS] & OP_STATUS_SRC) &&
+ (reg_data[REG_OP_DATA1] & OP_DATA_VALID)) {
+ /*
+ * Normal state when running in operational mode,
+ * may also not in full power state or
+ * busying in command process.
+ */
+ if (GEN3_FINGER_NUM(reg_data[REG_OP_DATA1]) <=
+ GEN3_MAX_FINGERS) {
+ /* Finger number data is valid. */
+ cyapa->gen = CYAPA_GEN3;
+ cyapa->state = CYAPA_STATE_OP;
+ }
+ } else if (reg_data[REG_OP_STATUS] == 0x0C &&
+ reg_data[REG_OP_DATA1] == 0x08) {
+ /* Op state when first two registers overwritten with 0x00 */
+ cyapa->gen = CYAPA_GEN3;
+ cyapa->state = CYAPA_STATE_OP;
+ } else if (reg_data[REG_BL_STATUS] &
+ (BL_STATUS_RUNNING | BL_STATUS_BUSY)) {
+ cyapa->gen = CYAPA_GEN3;
+ cyapa->state = CYAPA_STATE_BL_BUSY;
+ }
+
+ if (cyapa->gen == CYAPA_GEN3 && (cyapa->state == CYAPA_STATE_OP ||
+ cyapa->state == CYAPA_STATE_BL_IDLE ||
+ cyapa->state == CYAPA_STATE_BL_ACTIVE ||
+ cyapa->state == CYAPA_STATE_BL_BUSY))
+ return 0;
+
+ return -EAGAIN;
+}
+
+static int cyapa_gen3_bl_deactivate(struct cyapa *cyapa)
+{
+ int error;
+
+ error = cyapa_i2c_reg_write_block(cyapa, 0, sizeof(bl_deactivate),
+ bl_deactivate);
+ if (error)
+ return error;
+
+ /* Wait for bootloader to switch to idle state; should take < 100ms */
+ msleep(100);
+ error = cyapa_poll_state(cyapa, 500);
+ if (error)
+ return error;
+ if (cyapa->state != CYAPA_STATE_BL_IDLE)
+ return -EAGAIN;
+ return 0;
+}
+
+/*
+ * Exit bootloader
+ *
+ * Send bl_exit command, then wait 50 - 100 ms to let device transition to
+ * operational mode. If this is the first time the device's firmware is
+ * running, it can take up to 2 seconds to calibrate its sensors. So, poll
+ * the device's new state for up to 2 seconds.
+ *
+ * Returns:
+ * -EIO failure while reading from device
+ * -EAGAIN device is stuck in bootloader, b/c it has invalid firmware
+ * 0 device is supported and in operational mode
+ */
+static int cyapa_gen3_bl_exit(struct cyapa *cyapa)
+{
+ int error;
+
+ error = cyapa_i2c_reg_write_block(cyapa, 0, sizeof(bl_exit), bl_exit);
+ if (error)
+ return error;
+
+ /*
+ * Wait for bootloader to exit, and operation mode to start.
+ * Normally, this takes at least 50 ms.
+ */
+ usleep_range(50000, 100000);
+ /*
+ * In addition, when a device boots for the first time after being
+ * updated to new firmware, it must first calibrate its sensors, which
+ * can take up to an additional 2 seconds. If the device power is
+ * running low, this may take even longer.
+ */
+ error = cyapa_poll_state(cyapa, 4000);
+ if (error < 0)
+ return error;
+ if (cyapa->state != CYAPA_STATE_OP)
+ return -EAGAIN;
+
+ return 0;
+}
+
+/*
+ * cyapa_get_wait_time_for_pwr_cmd
+ *
+ * Compute the amount of time we need to wait after updating the touchpad
+ * power mode. The touchpad needs to consume the incoming power mode set
+ * command at the current clock rate.
+ */
+
+static u16 cyapa_get_wait_time_for_pwr_cmd(u8 pwr_mode)
+{
+ switch (pwr_mode) {
+ case PWR_MODE_FULL_ACTIVE: return 20;
+ case PWR_MODE_BTN_ONLY: return 20;
+ case PWR_MODE_OFF: return 20;
+ default: return cyapa_pwr_cmd_to_sleep_time(pwr_mode) + 50;
+ }
+}
+
+/*
+ * Set device power mode
+ *
+ * Write to the field to configure power state. Power states include :
+ * Full : Max scans and report rate.
+ * Idle : Report rate set by user specified time.
+ * ButtonOnly : No scans for fingers. When the button is triggered,
+ * a slave interrupt is asserted to notify host to wake up.
+ * Off : Only awake for i2c commands from host. No function for button
+ * or touch sensors.
+ *
+ * The power_mode command should conform to the following :
+ * Full : 0x3f
+ * Idle : Configurable from 20 to 1000ms. See note below for
+ * cyapa_sleep_time_to_pwr_cmd and cyapa_pwr_cmd_to_sleep_time
+ * ButtonOnly : 0x01
+ * Off : 0x00
+ *
+ * Device power mode can only be set when device is in operational mode.
+ */
+static int cyapa_gen3_set_power_mode(struct cyapa *cyapa, u8 power_mode,
+ u16 always_unused)
+{
+ int ret;
+ u8 power;
+ int tries;
+ u16 sleep_time;
+
+ always_unused = 0;
+ if (cyapa->state != CYAPA_STATE_OP)
+ return 0;
+
+ tries = SET_POWER_MODE_TRIES;
+ while (tries--) {
+ ret = cyapa_read_byte(cyapa, CYAPA_CMD_POWER_MODE);
+ if (ret >= 0)
+ break;
+ usleep_range(SET_POWER_MODE_DELAY, 2 * SET_POWER_MODE_DELAY);
+ }
+ if (ret < 0)
+ return ret;
+
+ /*
+ * Return early if the power mode to set is the same as the current
+ * one.
+ */
+ if ((ret & PWR_MODE_MASK) == power_mode)
+ return 0;
+
+ sleep_time = cyapa_get_wait_time_for_pwr_cmd(ret & PWR_MODE_MASK);
+ power = ret;
+ power &= ~PWR_MODE_MASK;
+ power |= power_mode & PWR_MODE_MASK;
+ tries = SET_POWER_MODE_TRIES;
+ while (tries--) {
+ ret = cyapa_write_byte(cyapa, CYAPA_CMD_POWER_MODE, power);
+ if (!ret)
+ break;
+ usleep_range(SET_POWER_MODE_DELAY, 2 * SET_POWER_MODE_DELAY);
+ }
+
+ /*
+ * Wait for the newly set power command to go in at the previous
+ * clock speed (scanrate) used by the touchpad firmware. Not
+ * doing so before issuing the next command may result in errors
+ * depending on the command's content.
+ */
+ msleep(sleep_time);
+ return ret;
+}
+
+static int cyapa_gen3_get_query_data(struct cyapa *cyapa)
+{
+ u8 query_data[QUERY_DATA_SIZE];
+ int ret;
+
+ if (cyapa->state != CYAPA_STATE_OP)
+ return -EBUSY;
+
+ ret = cyapa_read_block(cyapa, CYAPA_CMD_GROUP_QUERY, query_data);
+ if (ret != QUERY_DATA_SIZE)
+ return (ret < 0) ? ret : -EIO;
+
+ memcpy(&cyapa->product_id[0], &query_data[0], 5);
+ cyapa->product_id[5] = '-';
+ memcpy(&cyapa->product_id[6], &query_data[5], 6);
+ cyapa->product_id[12] = '-';
+ memcpy(&cyapa->product_id[13], &query_data[11], 2);
+ cyapa->product_id[15] = '\0';
+
+ cyapa->fw_maj_ver = query_data[15];
+ cyapa->fw_min_ver = query_data[16];
+
+ cyapa->btn_capability = query_data[19] & CAPABILITY_BTN_MASK;
+
+ cyapa->gen = query_data[20] & 0x0f;
+
+ cyapa->max_abs_x = ((query_data[21] & 0xf0) << 4) | query_data[22];
+ cyapa->max_abs_y = ((query_data[21] & 0x0f) << 8) | query_data[23];
+
+ cyapa->physical_size_x =
+ ((query_data[24] & 0xf0) << 4) | query_data[25];
+ cyapa->physical_size_y =
+ ((query_data[24] & 0x0f) << 8) | query_data[26];
+
+ cyapa->max_z = 255;
+
+ return 0;
+}
+
+static int cyapa_gen3_bl_query_data(struct cyapa *cyapa)
+{
+ u8 bl_data[CYAPA_CMD_LEN];
+ int ret;
+
+ ret = cyapa_i2c_reg_read_block(cyapa, 0, CYAPA_CMD_LEN, bl_data);
+ if (ret != CYAPA_CMD_LEN)
+ return (ret < 0) ? ret : -EIO;
+
+ /*
+ * This value will be updated again when entered application mode.
+ * If TP failed to enter application mode, this fw version values
+ * can be used as a reference.
+ * This firmware version valid when fw image checksum is valid.
+ */
+ if (bl_data[REG_BL_STATUS] ==
+ (BL_STATUS_RUNNING | BL_STATUS_CSUM_VALID)) {
+ cyapa->fw_maj_ver = bl_data[GEN3_BL_IDLE_FW_MAJ_VER_OFFSET];
+ cyapa->fw_min_ver = bl_data[GEN3_BL_IDLE_FW_MIN_VER_OFFSET];
+ }
+
+ return 0;
+}
+
+/*
+ * Check if device is operational.
+ *
+ * An operational device is responding, has exited bootloader, and has
+ * firmware supported by this driver.
+ *
+ * Returns:
+ * -EBUSY no device or in bootloader
+ * -EIO failure while reading from device
+ * -EAGAIN device is still in bootloader
+ * if ->state = CYAPA_STATE_BL_IDLE, device has invalid firmware
+ * -EINVAL device is in operational mode, but not supported by this driver
+ * 0 device is supported
+ */
+static int cyapa_gen3_do_operational_check(struct cyapa *cyapa)
+{
+ struct device *dev = &cyapa->client->dev;
+ int error;
+
+ switch (cyapa->state) {
+ case CYAPA_STATE_BL_ACTIVE:
+ error = cyapa_gen3_bl_deactivate(cyapa);
+ if (error) {
+ dev_err(dev, "failed to bl_deactivate: %d\n", error);
+ return error;
+ }
+
+ /* Fallthrough state */
+ case CYAPA_STATE_BL_IDLE:
+ /* Try to get firmware version in bootloader mode. */
+ cyapa_gen3_bl_query_data(cyapa);
+
+ error = cyapa_gen3_bl_exit(cyapa);
+ if (error) {
+ dev_err(dev, "failed to bl_exit: %d\n", error);
+ return error;
+ }
+
+ /* Fallthrough state */
+ case CYAPA_STATE_OP:
+ /*
+ * Reading query data before going back to the full mode
+ * may cause problems, so we set the power mode first here.
+ */
+ error = cyapa_gen3_set_power_mode(cyapa,
+ PWR_MODE_FULL_ACTIVE, 0);
+ if (error)
+ dev_err(dev, "%s: set full power mode failed: %d\n",
+ __func__, error);
+ error = cyapa_gen3_get_query_data(cyapa);
+ if (error < 0)
+ return error;
+
+ /* Only support firmware protocol gen3 */
+ if (cyapa->gen != CYAPA_GEN3) {
+ dev_err(dev, "unsupported protocol version (%d)",
+ cyapa->gen);
+ return -EINVAL;
+ }
+
+ /* Only support product ID starting with CYTRA */
+ if (memcmp(cyapa->product_id, product_id,
+ strlen(product_id)) != 0) {
+ dev_err(dev, "unsupported product ID (%s)\n",
+ cyapa->product_id);
+ return -EINVAL;
+ }
+
+ return 0;
+
+ default:
+ return -EIO;
+ }
+ return 0;
+}
+
+/*
+ * Return false, do not continue process
+ * Return true, continue process.
+ */
+static bool cyapa_gen3_irq_cmd_handler(struct cyapa *cyapa)
+{
+ /* Not gen3 irq command response, skip for continue. */
+ if (cyapa->gen != CYAPA_GEN3)
+ return true;
+
+ if (cyapa->operational)
+ return true;
+
+ /*
+ * Driver in detecting or other interface function processing,
+ * so, stop cyapa_gen3_irq_handler to continue process to
+ * avoid unwanted to error detecting and processing.
+ *
+ * And also, avoid the periodicly accerted interrupts to be processed
+ * as touch inputs when gen3 failed to launch into application mode,
+ * which will cause gen3 stays in bootloader mode.
+ */
+ return false;
+}
+
+static int cyapa_gen3_irq_handler(struct cyapa *cyapa)
+{
+ struct input_dev *input = cyapa->input;
+ struct device *dev = &cyapa->client->dev;
+ struct cyapa_reg_data data;
+ int num_fingers;
+ int ret;
+ int i;
+
+ ret = cyapa_read_block(cyapa, CYAPA_CMD_GROUP_DATA, (u8 *)&data);
+ if (ret != sizeof(data)) {
+ dev_err(dev, "failed to read report data, (%d)\n", ret);
+ return -EINVAL;
+ }
+
+ if ((data.device_status & OP_STATUS_SRC) != OP_STATUS_SRC ||
+ (data.device_status & OP_STATUS_DEV) != CYAPA_DEV_NORMAL ||
+ (data.finger_btn & OP_DATA_VALID) != OP_DATA_VALID) {
+ dev_err(dev, "invalid device state bytes, %02x %02x\n",
+ data.device_status, data.finger_btn);
+ return -EINVAL;
+ }
+
+ num_fingers = (data.finger_btn >> 4) & 0x0f;
+ for (i = 0; i < num_fingers; i++) {
+ const struct cyapa_touch *touch = &data.touches[i];
+ /* Note: touch->id range is 1 to 15; slots are 0 to 14. */
+ int slot = touch->id - 1;
+
+ input_mt_slot(input, slot);
+ input_mt_report_slot_state(input, MT_TOOL_FINGER, true);
+ input_report_abs(input, ABS_MT_POSITION_X,
+ ((touch->xy_hi & 0xf0) << 4) | touch->x_lo);
+ input_report_abs(input, ABS_MT_POSITION_Y,
+ ((touch->xy_hi & 0x0f) << 8) | touch->y_lo);
+ input_report_abs(input, ABS_MT_PRESSURE, touch->pressure);
+ }
+
+ input_mt_sync_frame(input);
+
+ if (cyapa->btn_capability & CAPABILITY_LEFT_BTN_MASK)
+ input_report_key(input, BTN_LEFT,
+ !!(data.finger_btn & OP_DATA_LEFT_BTN));
+ if (cyapa->btn_capability & CAPABILITY_MIDDLE_BTN_MASK)
+ input_report_key(input, BTN_MIDDLE,
+ !!(data.finger_btn & OP_DATA_MIDDLE_BTN));
+ if (cyapa->btn_capability & CAPABILITY_RIGHT_BTN_MASK)
+ input_report_key(input, BTN_RIGHT,
+ !!(data.finger_btn & OP_DATA_RIGHT_BTN));
+ input_sync(input);
+
+ return 0;
+}
+
+const struct cyapa_dev_ops cyapa_gen3_ops = {
+ .state_parse = cyapa_gen3_state_parse,
+ .operational_check = cyapa_gen3_do_operational_check,
+
+ .irq_handler = cyapa_gen3_irq_handler,
+ .irq_cmd_handler = cyapa_gen3_irq_cmd_handler,
+
+ .set_power_mode = cyapa_gen3_set_power_mode,
+};
--
1.9.1
^ permalink raw reply related [flat|nested] 28+ messages in thread
* [PATCH v16 02/12] input: cyapa: add gen5 trackpad device basic functions support
2014-12-18 10:00 [PATCH v16 00/12] input: cyapa: instruction of cyapa patches Dudley Du
2014-12-18 10:00 ` [PATCH v16 01/12] input: cyapa: re-design driver to support multi-trackpad in one driver Dudley Du
@ 2014-12-18 10:00 ` Dudley Du
2014-12-18 10:00 ` [PATCH v16 03/12] input: cyapa: add power management interfaces support for the device Dudley Du
` (11 subsequent siblings)
13 siblings, 0 replies; 28+ messages in thread
From: Dudley Du @ 2014-12-18 10:00 UTC (permalink / raw)
To: dmitry.torokhov, jmmahler, rydberg
Cc: Dudley Du, bleung, linux-input, linux-kernel
Based on the cyapa core, add the gen5 trackpad device's basic functions
supported, so gen5 trackpad device can work with kernel input system.
And also based on the state parse interface, the cyapa driver can
automatically determine the attached is gen3 or gen5 protocol trackpad
device, then set the correct protocol to work with the attached
trackpad device.
TEST=test on Chromebooks.
Signed-off-by: Dudley Du <dudl@cypress.com>
---
drivers/input/mouse/Makefile | 2 +-
drivers/input/mouse/cyapa.c | 13 +
drivers/input/mouse/cyapa.h | 1 +
drivers/input/mouse/cyapa_gen5.c | 1677 ++++++++++++++++++++++++++++++++++++++
4 files changed, 1692 insertions(+), 1 deletion(-)
create mode 100644 drivers/input/mouse/cyapa_gen5.c
diff --git a/drivers/input/mouse/Makefile b/drivers/input/mouse/Makefile
index 8bd950d..8a9c98e 100644
--- a/drivers/input/mouse/Makefile
+++ b/drivers/input/mouse/Makefile
@@ -24,7 +24,7 @@ obj-$(CONFIG_MOUSE_SYNAPTICS_I2C) += synaptics_i2c.o
obj-$(CONFIG_MOUSE_SYNAPTICS_USB) += synaptics_usb.o
obj-$(CONFIG_MOUSE_VSXXXAA) += vsxxxaa.o
-cyapatp-objs := cyapa.o cyapa_gen3.o
+cyapatp-objs := cyapa.o cyapa_gen3.o cyapa_gen5.o
psmouse-objs := psmouse-base.o synaptics.o focaltech.o
psmouse-$(CONFIG_MOUSE_PS2_ALPS) += alps.o
diff --git a/drivers/input/mouse/cyapa.c b/drivers/input/mouse/cyapa.c
index ae1df15..d4560a3 100644
--- a/drivers/input/mouse/cyapa.c
+++ b/drivers/input/mouse/cyapa.c
@@ -157,6 +157,14 @@ static int cyapa_get_state(struct cyapa *cyapa)
if (!error)
goto out_detected;
}
+ if ((cyapa->gen == CYAPA_GEN_UNKNOWN ||
+ cyapa->gen == CYAPA_GEN5) &&
+ !smbus && even_addr) {
+ error = cyapa_gen5_ops.state_parse(cyapa,
+ status, BL_STATUS_SIZE);
+ if (!error)
+ goto out_detected;
+ }
/*
* Write 0x00 0x00 to trackpad device to force update its
@@ -240,6 +248,9 @@ static int cyapa_check_is_operational(struct cyapa *cyapa)
return error;
switch (cyapa->gen) {
+ case CYAPA_GEN5:
+ cyapa->ops = &cyapa_gen5_ops;
+ break;
case CYAPA_GEN3:
cyapa->ops = &cyapa_gen3_ops;
break;
@@ -476,6 +487,8 @@ static int cyapa_initialize(struct cyapa *cyapa)
if (cyapa_gen3_ops.initialize)
error = cyapa_gen3_ops.initialize(cyapa);
+ if (!error && cyapa_gen5_ops.initialize)
+ error = cyapa_gen5_ops.initialize(cyapa);
if (error)
return error;
diff --git a/drivers/input/mouse/cyapa.h b/drivers/input/mouse/cyapa.h
index 8a75c52..4c09be4 100644
--- a/drivers/input/mouse/cyapa.h
+++ b/drivers/input/mouse/cyapa.h
@@ -303,5 +303,6 @@ u16 cyapa_pwr_cmd_to_sleep_time(u8 pwr_mode);
extern const char product_id[];
extern const struct cyapa_dev_ops cyapa_gen3_ops;
+extern const struct cyapa_dev_ops cyapa_gen5_ops;
#endif
diff --git a/drivers/input/mouse/cyapa_gen5.c b/drivers/input/mouse/cyapa_gen5.c
new file mode 100644
index 0000000..2ce0149
--- /dev/null
+++ b/drivers/input/mouse/cyapa_gen5.c
@@ -0,0 +1,1677 @@
+/*
+ * Cypress APA trackpad with I2C interface
+ *
+ * Author: Dudley Du <dudl@cypress.com>
+ *
+ * Copyright (C) 2014 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 <linux/unaligned/access_ok.h>
+#include "cyapa.h"
+
+
+/* Macro of Gen5 */
+#define RECORD_EVENT_NONE 0
+#define RECORD_EVENT_TOUCHDOWN 1
+#define RECORD_EVENT_DISPLACE 2
+#define RECORD_EVENT_LIFTOFF 3
+
+#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
+
+#define GEN5_BL_CMD_VERIFY_APP_INTEGRITY 0x31
+#define GEN5_BL_CMD_GET_BL_INFO 0x38
+#define GEN5_BL_CMD_PROGRAM_VERIFY_ROW 0x39
+#define GEN5_BL_CMD_LAUNCH_APP 0x3b
+#define GEN5_BL_CMD_INITIATE_BL 0x48
+
+#define GEN5_HID_DESCRIPTOR_ADDR 0x0001
+#define GEN5_REPORT_DESCRIPTOR_ADDR 0x0002
+#define GEN5_INPUT_REPORT_ADDR 0x0003
+#define GEN5_OUTPUT_REPORT_ADDR 0x0004
+#define GEN5_CMD_DATA_ADDR 0x0006
+
+#define GEN5_TOUCH_REPORT_HEAD_SIZE 7
+#define GEN5_TOUCH_REPORT_MAX_SIZE 127
+#define GEN5_BTN_REPORT_HEAD_SIZE 6
+#define GEN5_BTN_REPORT_MAX_SIZE 14
+#define GEN5_WAKEUP_EVENT_SIZE 4
+#define GEN5_RAW_DATA_HEAD_SIZE 24
+
+#define GEN5_BL_CMD_REPORT_ID 0x40
+#define GEN5_BL_RESP_REPORT_ID 0x30
+#define GEN5_APP_CMD_REPORT_ID 0x2f
+#define GEN5_APP_RESP_REPORT_ID 0x1f
+
+#define GEN5_APP_DEEP_SLEEP_REPORT_ID 0xf0
+#define GEN5_DEEP_SLEEP_RESP_LENGTH 5
+
+#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_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_DEEP_SLEEP_STATE_MASK 0x03
+#define GEN5_DEEP_SLEEP_STATE_ON 0x00
+#define GEN5_DEEP_SLEEP_STATE_OFF 0x01
+
+#define GEN5_DEEP_SLEEP_OPCODE 0x08
+#define GEN5_DEEP_SLEEP_OPCODE_MASK 0x0f
+
+#define GEN5_POWER_READY_MAX_INTRVL_TIME 50 /* Unit: ms */
+#define GEN5_POWER_IDLE_MAX_INTRVL_TIME 250 /* Unit: ms */
+
+#define GEN5_CMD_REPORT_ID_OFFSET 4
+
+#define GEN5_RESP_REPORT_ID_OFFSET 2
+#define GEN5_RESP_RSVD_OFFSET 3
+#define GEN5_RESP_RSVD_KEY 0x00
+#define GEN5_RESP_BL_SOP_OFFSET 4
+#define GEN5_SOP_KEY 0x01 /* Start of Packet */
+#define GEN5_EOP_KEY 0x17 /* End of Packet */
+#define GEN5_RESP_APP_CMD_OFFSET 4
+#define GET_GEN5_CMD_CODE(reg) ((reg) & 0x7f)
+
+#define VALID_CMD_RESP_HEADER(resp, cmd) \
+ (((resp)[GEN5_RESP_REPORT_ID_OFFSET] == GEN5_APP_RESP_REPORT_ID) && \
+ ((resp)[GEN5_RESP_RSVD_OFFSET] == GEN5_RESP_RSVD_KEY) && \
+ (GET_GEN5_CMD_CODE((resp)[GEN5_RESP_APP_CMD_OFFSET]) == (cmd)))
+
+#define GEN5_MIN_BL_CMD_LENGTH 13
+#define GEN5_MIN_BL_RESP_LENGTH 11
+#define GEN5_MIN_APP_CMD_LENGTH 7
+#define GEN5_MIN_APP_RESP_LENGTH 5
+#define GEN5_UNSUPPORTED_CMD_RESP_LENGTH 6
+
+#define GEN5_RESP_LENGTH_OFFSET 0x00
+#define GEN5_RESP_LENGTH_SIZE 2
+
+#define GEN5_HID_DESCRIPTOR_SIZE 32
+#define GEN5_BL_HID_REPORT_ID 0xff
+#define GEN5_APP_HID_REPORT_ID 0xf7
+#define GEN5_BL_MAX_OUTPUT_LENGTH 0x0100
+#define GEN5_APP_MAX_OUTPUT_LENGTH 0x00fe
+
+#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_TOUCH_REPORT_ID 0x01
+#define GEN5_BTN_REPORT_ID 0x03
+#define GEN5_WAKEUP_EVENT_REPORT_ID 0x04
+#define GEN5_OLD_PUSH_BTN_REPORT_ID 0x05
+#define GEN5_PUSH_BTN_REPORT_ID 0x06
+
+#define GEN5_CMD_COMPLETE_SUCCESS(status) ((status) == 0x00)
+
+#define GEN5_BL_INITIATE_RESP_LEN 11
+#define GEN5_BL_FAIL_EXIT_RESP_LEN 11
+#define GEN5_BL_FAIL_EXIT_STATUS_CODE 0x0c
+#define GEN5_BL_VERIFY_INTEGRITY_RESP_LEN 12
+#define GEN5_BL_INTEGRITY_CHEKC_PASS 0x00
+#define GEN5_BL_BLOCK_WRITE_RESP_LEN 11
+#define GEN5_BL_READ_APP_INFO_RESP_LEN 31
+#define GEN5_CMD_CALIBRATE 0x28
+#define CYAPA_SENSING_MODE_MUTUAL_CAP_FINE 0x00
+#define CYAPA_SENSING_MODE_SELF_CAP 0x02
+
+#define GEN5_CMD_RETRIEVE_DATA_STRUCTURE 0x24
+#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 reterive PWC and panel scan commands */
+#define GEN5_RESP_DATA_STRUCTURE_OFFSET 10
+#define GEN5_PWC_DATA_ELEMENT_SIZE_MASK 0x07
+
+#define GEN5_NUMBER_OF_TOUCH_OFFSET 5
+#define GEN5_NUMBER_OF_TOUCH_MASK 0x1f
+#define GEN5_BUTTONS_OFFSET 5
+#define GEN5_BUTTONS_MASK 0x0f
+#define GEN5_GET_EVENT_ID(reg) (((reg) >> 5) & 0x03)
+#define GEN5_GET_TOUCH_ID(reg) ((reg) & 0x1f)
+
+#define GEN5_PRODUCT_FAMILY_MASK 0xf000
+#define GEN5_PRODUCT_FAMILY_TRACKPAD 0x1000
+
+#define TSG_INVALID_CMD 0xff
+
+struct cyapa_gen5_touch_record {
+ /*
+ * Bit 7 - 3: reserved
+ * Bit 2 - 0: touch type;
+ * 0 : standard finger;
+ * 1 - 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;
+
+ /* Touch intensity in counts, pressure value. */
+ 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_gen5_report_data {
+ u8 report_head[GEN5_TOUCH_REPORT_HEAD_SIZE];
+ struct cyapa_gen5_touch_record touch_records[10];
+} __packed;
+
+struct gen5_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[0]; /* Parameter data variable based on cmd_code */
+} __packed;
+
+/* Applicaton 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;
+
+/* Variables to record latest gen5 trackpad power states. */
+#define GEN5_DEV_SET_PWR_STATE(cyapa, s) ((cyapa)->dev_pwr_mode = (s))
+#define GEN5_DEV_GET_PWR_STATE(cyapa) ((cyapa)->dev_pwr_mode)
+#define GEN5_DEV_SET_SLEEP_TIME(cyapa, t) ((cyapa)->dev_sleep_time = (t))
+#define GEN5_DEV_GET_SLEEP_TIME(cyapa) ((cyapa)->dev_sleep_time)
+#define GEN5_DEV_UNINIT_SLEEP_TIME(cyapa) \
+ (((cyapa)->dev_sleep_time) == UNINIT_SLEEP_TIME)
+
+static int cyapa_gen5_initialize(struct cyapa *cyapa)
+{
+ struct cyapa_gen5_cmd_states *gen5_pip = &cyapa->cmd_states.gen5;
+
+ init_completion(&gen5_pip->cmd_ready);
+ atomic_set(&gen5_pip->cmd_issued, 0);
+ mutex_init(&gen5_pip->cmd_lock);
+
+ gen5_pip->resp_sort_func = NULL;
+ gen5_pip->in_progress_cmd = TSG_INVALID_CMD;
+ gen5_pip->resp_data = NULL;
+ gen5_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. */
+static 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.
+ */
+static 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;
+}
+
+/**
+ * This function is aimed to dump all not read data in Gen5 trackpad
+ * before send any command, otherwise, the interrupt line will be blocked.
+ */
+static int cyapa_empty_pip_output_data(struct cyapa *cyapa,
+ u8 *buf, int *len, cb_sort func)
+{
+ struct cyapa_gen5_cmd_states *gen5_pip = &cyapa->cmd_states.gen5;
+ 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, gen5_pip->empty_buf,
+ GEN5_RESP_LENGTH_SIZE);
+ if (error < 0)
+ return error;
+
+ length = get_unaligned_le16(gen5_pip->empty_buf);
+ if (length == GEN5_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 = GEN5_RESP_LENGTH_SIZE;
+ if (buf && buf_len && func &&
+ func(cyapa, gen5_pip->empty_buf, length)) {
+ length = min(buf_len, length);
+ memcpy(buf, gen5_pip->empty_buf, length);
+ *len = length;
+ /* Response found, success. */
+ return 0;
+ }
+ continue;
+ }
+
+ error = cyapa_i2c_pip_read(cyapa, gen5_pip->empty_buf, length);
+ if (error < 0)
+ return error;
+
+ report_count--;
+ empty_count = 0;
+ length = get_unaligned_le16(gen5_pip->empty_buf);
+ if (length <= GEN5_RESP_LENGTH_SIZE) {
+ empty_count++;
+ } else if (buf && buf_len && func &&
+ func(cyapa, gen5_pip->empty_buf, length)) {
+ length = min(buf_len, length);
+ memcpy(buf, gen5_pip->empty_buf, length);
+ *len = length;
+ /* Response found, success. */
+ return 0;
+ }
+
+ 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)
+{
+ int error;
+ struct cyapa_gen5_cmd_states *gen5_pip = &cyapa->cmd_states.gen5;
+
+ /* Wait for interrupt to set ready completion */
+ init_completion(&gen5_pip->cmd_ready);
+
+ atomic_inc(&gen5_pip->cmd_issued);
+ error = cyapa_i2c_pip_write(cyapa, cmd, cmd_len);
+ if (error) {
+ atomic_dec(&gen5_pip->cmd_issued);
+ return (error < 0) ? error : -EIO;
+ }
+
+ /* Wait for interrupt to indicate command is completed. */
+ timeout = wait_for_completion_timeout(&gen5_pip->cmd_ready,
+ msecs_to_jiffies(timeout));
+ if (timeout == 0) {
+ atomic_dec(&gen5_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)
+{
+ int error;
+ int tries;
+ int length;
+ struct cyapa_gen5_cmd_states *gen5_pip = &cyapa->cmd_states.gen5;
+
+ atomic_inc(&gen5_pip->cmd_issued);
+ error = cyapa_i2c_pip_write(cyapa, cmd, cmd_len);
+ if (error) {
+ atomic_dec(&gen5_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(&gen5_pip->cmd_issued);
+ return error;
+}
+
+static 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)
+{
+ int error;
+ struct cyapa_gen5_cmd_states *gen5_pip = &cyapa->cmd_states.gen5;
+
+ if (!cmd || !cmd_len)
+ return -EINVAL;
+
+ /* Commands must be serialized. */
+ error = mutex_lock_interruptible(&gen5_pip->cmd_lock);
+ if (error)
+ return error;
+
+ gen5_pip->resp_sort_func = func;
+ gen5_pip->resp_data = resp_data;
+ gen5_pip->resp_len = resp_len;
+
+ if (cmd_len >= GEN5_MIN_APP_CMD_LENGTH &&
+ cmd[4] == GEN5_APP_CMD_REPORT_ID) {
+ /* Application command */
+ gen5_pip->in_progress_cmd = cmd[6] & 0x7f;
+ } else if (cmd_len >= GEN5_MIN_BL_CMD_LENGTH &&
+ cmd[4] == GEN5_BL_CMD_REPORT_ID) {
+ /* Bootloader command */
+ gen5_pip->in_progress_cmd = cmd[7];
+ }
+
+ /* Send command data, wait and read output response data's length. */
+ if (irq_mode) {
+ gen5_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 {
+ gen5_pip->is_irq_mode = false;
+ error = cyapa_do_i2c_pip_cmd_polling(cyapa, cmd, cmd_len,
+ resp_data, resp_len, timeout, func);
+ }
+
+ gen5_pip->resp_sort_func = NULL;
+ gen5_pip->resp_data = NULL;
+ gen5_pip->resp_len = NULL;
+ gen5_pip->in_progress_cmd = TSG_INVALID_CMD;
+
+ mutex_unlock(&gen5_pip->cmd_lock);
+ return error;
+}
+
+static bool cyapa_gen5_sort_tsg_pip_bl_resp_data(struct cyapa *cyapa,
+ u8 *data, int len)
+{
+ if (!data || len < GEN5_MIN_BL_RESP_LENGTH)
+ return false;
+
+ /* Bootloader input report id 30h */
+ if (data[GEN5_RESP_REPORT_ID_OFFSET] == GEN5_BL_RESP_REPORT_ID &&
+ data[GEN5_RESP_RSVD_OFFSET] == GEN5_RESP_RSVD_KEY &&
+ data[GEN5_RESP_BL_SOP_OFFSET] == GEN5_SOP_KEY)
+ return true;
+
+ return false;
+}
+
+static bool cyapa_gen5_sort_tsg_pip_app_resp_data(struct cyapa *cyapa,
+ u8 *data, int len)
+{
+ int resp_len;
+ struct cyapa_gen5_cmd_states *gen5_pip = &cyapa->cmd_states.gen5;
+
+ if (!data || len < GEN5_MIN_APP_RESP_LENGTH)
+ return false;
+
+ if (data[GEN5_RESP_REPORT_ID_OFFSET] == GEN5_APP_RESP_REPORT_ID &&
+ data[GEN5_RESP_RSVD_OFFSET] == GEN5_RESP_RSVD_KEY) {
+ resp_len = get_unaligned_le16(&data[GEN5_RESP_LENGTH_OFFSET]);
+ if (GET_GEN5_CMD_CODE(data[GEN5_RESP_APP_CMD_OFFSET]) == 0x00 &&
+ resp_len == GEN5_UNSUPPORTED_CMD_RESP_LENGTH &&
+ data[5] == gen5_pip->in_progress_cmd) {
+ /* Unsupported command code */
+ return false;
+ } else if (GET_GEN5_CMD_CODE(data[GEN5_RESP_APP_CMD_OFFSET]) ==
+ gen5_pip->in_progress_cmd) {
+ /* Correct command response received */
+ return true;
+ }
+ }
+
+ return false;
+}
+
+static bool cyapa_gen5_sort_hid_descriptor_data(struct cyapa *cyapa,
+ u8 *buf, int len)
+{
+ int resp_len;
+ int max_output_len;
+
+ /* Check hid descriptor. */
+ if (len != GEN5_HID_DESCRIPTOR_SIZE)
+ return false;
+
+ resp_len = get_unaligned_le16(&buf[GEN5_RESP_LENGTH_OFFSET]);
+ max_output_len = get_unaligned_le16(&buf[16]);
+ if (resp_len == GEN5_HID_DESCRIPTOR_SIZE) {
+ if (buf[GEN5_RESP_REPORT_ID_OFFSET] == GEN5_BL_HID_REPORT_ID &&
+ max_output_len == GEN5_BL_MAX_OUTPUT_LENGTH) {
+ /* BL mode HID Descriptor */
+ return true;
+ } else if ((buf[GEN5_RESP_REPORT_ID_OFFSET] ==
+ GEN5_APP_HID_REPORT_ID) &&
+ max_output_len == GEN5_APP_MAX_OUTPUT_LENGTH) {
+ /* APP mode HID Descriptor */
+ return true;
+ }
+ }
+
+ return false;
+}
+
+static bool cyapa_gen5_sort_deep_sleep_data(struct cyapa *cyapa,
+ u8 *buf, int len)
+{
+ if (len == GEN5_DEEP_SLEEP_RESP_LENGTH &&
+ buf[GEN5_RESP_REPORT_ID_OFFSET] ==
+ GEN5_APP_DEEP_SLEEP_REPORT_ID &&
+ (buf[4] & GEN5_DEEP_SLEEP_OPCODE_MASK) ==
+ GEN5_DEEP_SLEEP_OPCODE)
+ return true;
+ return false;
+}
+
+static int gen5_idle_state_parse(struct cyapa *cyapa)
+{
+ int ret;
+ int error;
+ int length;
+ u8 cmd[2];
+ u8 resp_data[GEN5_HID_DESCRIPTOR_SIZE];
+ int max_output_len;
+
+ /*
+ * 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[GEN5_RESP_LENGTH_OFFSET]);
+ if (length == GEN5_RESP_LENGTH_SIZE) {
+ /* Normal state of Gen5 with no data to respose */
+ 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 = GEN5_HID_DESCRIPTOR_SIZE;
+ error = cyapa_i2c_pip_cmd_irq_sync(cyapa,
+ cmd, GEN5_RESP_LENGTH_SIZE,
+ resp_data, &length,
+ 300,
+ cyapa_gen5_sort_hid_descriptor_data,
+ false);
+ if (error)
+ return error;
+
+ length = get_unaligned_le16(
+ &resp_data[GEN5_RESP_LENGTH_OFFSET]);
+ max_output_len = get_unaligned_le16(&resp_data[16]);
+ if ((length == GEN5_HID_DESCRIPTOR_SIZE ||
+ length == GEN5_RESP_LENGTH_SIZE) &&
+ (resp_data[GEN5_RESP_REPORT_ID_OFFSET] ==
+ GEN5_BL_HID_REPORT_ID) &&
+ max_output_len == GEN5_BL_MAX_OUTPUT_LENGTH) {
+ /* BL mode HID Description read */
+ cyapa->state = CYAPA_STATE_GEN5_BL;
+ } else if ((length == GEN5_HID_DESCRIPTOR_SIZE ||
+ length == GEN5_RESP_LENGTH_SIZE) &&
+ (resp_data[GEN5_RESP_REPORT_ID_OFFSET] ==
+ GEN5_APP_HID_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 ret;
+ int length;
+ u8 resp_data[32];
+ int max_output_len;
+
+ /* 0x20 0x00 0xF7 is Gen5 Application HID Description Header;
+ * 0x20 0x00 0xFF is Gen5 Booloader 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,
+ GEN5_HID_DESCRIPTOR_SIZE);
+ if (ret != GEN5_HID_DESCRIPTOR_SIZE)
+ return ret < 0 ? ret : -EIO;
+ length = get_unaligned_le16(&resp_data[GEN5_RESP_LENGTH_OFFSET]);
+ max_output_len = get_unaligned_le16(&resp_data[16]);
+ if (length == GEN5_RESP_LENGTH_SIZE) {
+ if (reg_data[GEN5_RESP_REPORT_ID_OFFSET] ==
+ GEN5_BL_HID_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 == GEN5_HID_DESCRIPTOR_SIZE &&
+ resp_data[2] == GEN5_BL_HID_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 == GEN5_HID_DESCRIPTOR_SIZE &&
+ (resp_data[GEN5_RESP_REPORT_ID_OFFSET] ==
+ GEN5_APP_HID_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[GEN5_RESP_LENGTH_OFFSET]);
+ switch (reg_data[GEN5_RESP_REPORT_ID_OFFSET]) {
+ case GEN5_TOUCH_REPORT_ID:
+ if (length < GEN5_TOUCH_REPORT_HEAD_SIZE ||
+ length > GEN5_TOUCH_REPORT_MAX_SIZE)
+ return -EINVAL;
+ break;
+ case GEN5_BTN_REPORT_ID:
+ case GEN5_OLD_PUSH_BTN_REPORT_ID:
+ case GEN5_PUSH_BTN_REPORT_ID:
+ if (length < GEN5_BTN_REPORT_HEAD_SIZE ||
+ length > GEN5_BTN_REPORT_MAX_SIZE)
+ return -EINVAL;
+ break;
+ case GEN5_WAKEUP_EVENT_REPORT_ID:
+ if (length != GEN5_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)
+{
+ int ret;
+ int length;
+ struct cyapa_gen5_cmd_states *gen5_pip = &cyapa->cmd_states.gen5;
+
+ /*
+ * 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[GEN5_RESP_LENGTH_OFFSET]);
+ ret = cyapa_i2c_pip_read(cyapa, gen5_pip->empty_buf, length);
+ if (ret != length)
+ return ret < 0 ? ret : -EIO;
+
+ if (length == GEN5_RESP_LENGTH_SIZE) {
+ /* Previous command has read the data through out. */
+ if (reg_data[GEN5_RESP_REPORT_ID_OFFSET] ==
+ GEN5_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 ((gen5_pip->empty_buf[GEN5_RESP_REPORT_ID_OFFSET] ==
+ GEN5_BL_RESP_REPORT_ID) &&
+ (gen5_pip->empty_buf[GEN5_RESP_RSVD_OFFSET] ==
+ GEN5_RESP_RSVD_KEY) &&
+ (gen5_pip->empty_buf[GEN5_RESP_BL_SOP_OFFSET] ==
+ GEN5_SOP_KEY) &&
+ (gen5_pip->empty_buf[length - 1] ==
+ GEN5_EOP_KEY)) {
+ /* Gen5 BL command response data detected */
+ cyapa->gen = CYAPA_GEN5;
+ cyapa->state = CYAPA_STATE_GEN5_BL;
+ } else if (gen5_pip->empty_buf[GEN5_RESP_REPORT_ID_OFFSET] ==
+ GEN5_APP_RESP_REPORT_ID &&
+ gen5_pip->empty_buf[GEN5_RESP_RSVD_OFFSET] ==
+ GEN5_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[GEN5_RESP_LENGTH_OFFSET]);
+ if (length == 0 || length == GEN5_RESP_LENGTH_SIZE) {
+ gen5_idle_state_parse(cyapa);
+ } else if (length == GEN5_HID_DESCRIPTOR_SIZE &&
+ (reg_data[2] == GEN5_BL_HID_REPORT_ID ||
+ reg_data[2] == GEN5_APP_HID_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 descriptior header. */
+ cyapa->gen = CYAPA_GEN5;
+ cyapa->state = CYAPA_STATE_GEN5_BL;
+ } else if (reg_data[2] == GEN5_TOUCH_REPORT_ID ||
+ reg_data[2] == GEN5_BTN_REPORT_ID ||
+ reg_data[2] == GEN5_OLD_PUSH_BTN_REPORT_ID ||
+ reg_data[2] == GEN5_PUSH_BTN_REPORT_ID ||
+ reg_data[2] == GEN5_WAKEUP_EVENT_REPORT_ID) {
+ gen5_report_data_header_parse(cyapa, reg_data);
+ } else if (reg_data[2] == GEN5_BL_RESP_REPORT_ID ||
+ reg_data[2] == GEN5_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 bool cyapa_gen5_sort_bl_exit_data(struct cyapa *cyapa, u8 *buf, int len)
+{
+ if (buf == NULL || len < GEN5_RESP_LENGTH_SIZE)
+ return false;
+
+ if (buf[0] == 0 && buf[1] == 0)
+ return true;
+
+ /* Exit bootloader failed for some reason. */
+ if (len == GEN5_BL_FAIL_EXIT_RESP_LEN &&
+ buf[GEN5_RESP_REPORT_ID_OFFSET] ==
+ GEN5_BL_RESP_REPORT_ID &&
+ buf[GEN5_RESP_RSVD_OFFSET] == GEN5_RESP_RSVD_KEY &&
+ buf[GEN5_RESP_BL_SOP_OFFSET] == GEN5_SOP_KEY &&
+ buf[10] == GEN5_EOP_KEY)
+ return true;
+
+ return false;
+}
+
+static int cyapa_gen5_bl_exit(struct cyapa *cyapa)
+{
+ int error;
+ u8 resp_data[11];
+ int resp_len;
+ u8 bl_gen5_bl_exit[] = { 0x04, 0x00,
+ 0x0B, 0x00, 0x40, 0x00, 0x01, 0x3b, 0x00, 0x00,
+ 0x20, 0xc7, 0x17
+ };
+
+ 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_gen5_sort_bl_exit_data, false);
+ if (error)
+ return error;
+
+ if (resp_len == GEN5_BL_FAIL_EXIT_RESP_LEN ||
+ resp_data[GEN5_RESP_REPORT_ID_OFFSET] ==
+ GEN5_BL_RESP_REPORT_ID)
+ return -EAGAIN;
+
+ if (resp_data[0] == 0x00 && resp_data[1] == 0x00)
+ return 0;
+
+ return -ENODEV;
+}
+
+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_gen5_sort_tsg_pip_app_resp_data, false);
+ if (error || !VALID_CMD_RESP_HEADER(resp_data, 0x08) ||
+ !GEN5_CMD_COMPLETE_SUCCESS(resp_data[5]))
+ return error < 0 ? error : -EINVAL;
+
+ return 0;
+}
+
+static int cyapa_gen5_set_interval_time(struct cyapa *cyapa,
+ u8 parameter_id, u16 interval_time)
+{
+ struct gen5_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 gen5_app_cmd_head *)cmd;
+ parameter_data = (struct gen5_app_set_parameter_data *)
+ app_cmd_head->parameter_data;
+ cmd_len = sizeof(struct gen5_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(GEN5_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 = GEN5_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_gen5_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 gen5_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 gen5_app_cmd_head *)cmd;
+ parameter_data = (struct gen5_app_get_parameter_data *)
+ app_cmd_head->parameter_data;
+ cmd_len = sizeof(struct gen5_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(GEN5_HID_DESCRIPTOR_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 = GEN5_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_gen5_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 gen5_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 gen5_app_cmd_head *)cmd;
+
+ put_unaligned_le16(GEN5_HID_DESCRIPTOR_ADDR, &app_cmd_head->addr);
+ put_unaligned_le16(sizeof(cmd) - 2, &app_cmd_head->length);
+ app_cmd_head->report_id = GEN5_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_gen5_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;
+}
+
+static int cyapa_gen5_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 & GEN5_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_gen5_sort_deep_sleep_data, false);
+ if (error || ((resp_data[3] & GEN5_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)
+{
+ struct device *dev = &cyapa->client->dev;
+ u8 power_state;
+ int error;
+
+ if (cyapa->state != CYAPA_STATE_GEN5_APP)
+ return 0;
+
+ /* Dump all the report data before do power mode commmands. */
+ cyapa_empty_pip_output_data(cyapa, NULL, NULL, NULL);
+
+ if (GEN5_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.
+ */
+ GEN5_DEV_SET_PWR_STATE(cyapa, PWR_MODE_OFF);
+ }
+
+ if (GEN5_DEV_UNINIT_SLEEP_TIME(cyapa) &&
+ GEN5_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)
+ GEN5_DEV_SET_SLEEP_TIME(cyapa, UNINIT_SLEEP_TIME);
+
+ if (GEN5_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 ||
+ GEN5_DEV_GET_SLEEP_TIME(cyapa) == sleep_time) {
+ /* Has in correct power mode state, early return. */
+ return 0;
+ }
+ }
+
+ if (power_mode == PWR_MODE_OFF) {
+ error = cyapa_gen5_deep_sleep(cyapa, GEN5_DEEP_SLEEP_STATE_OFF);
+ if (error) {
+ dev_err(dev, "enter deep sleep fail: %d\n", error);
+ return error;
+ }
+
+ GEN5_DEV_SET_PWR_STATE(cyapa, PWR_MODE_OFF);
+ return 0;
+ }
+
+ /*
+ * 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 (GEN5_DEV_GET_PWR_STATE(cyapa) == PWR_MODE_OFF) {
+ error = cyapa_gen5_deep_sleep(cyapa, GEN5_DEEP_SLEEP_STATE_ON);
+ if (error) {
+ dev_err(dev, "deep sleep wake fail: %d\n", error);
+ return error;
+ }
+ }
+
+ 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);
+ return error;
+ }
+
+ GEN5_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);
+ return error;
+ }
+
+ GEN5_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 (GEN5_DEV_UNINIT_SLEEP_TIME(cyapa) ||
+ sleep_time != GEN5_DEV_GET_SLEEP_TIME(cyapa))
+ if (cyapa_gen5_set_interval_time(cyapa,
+ GEN5_PARAMETER_LP_INTRVL_ID,
+ sleep_time) == 0)
+ GEN5_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);
+ return error;
+ }
+
+ /*
+ * 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 buffured when system
+ * is suspending which may cause interrput line unable to be
+ * asserted again.
+ */
+ cyapa_empty_pip_output_data(cyapa, NULL, NULL, NULL);
+ cyapa_gen5_disable_pip_report(cyapa);
+
+ GEN5_DEV_SET_PWR_STATE(cyapa,
+ cyapa_sleep_time_to_pwr_cmd(sleep_time));
+ }
+
+ return 0;
+}
+
+static bool cyapa_gen5_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 bl_query_data_cmd[] = { 0x04, 0x00, 0x0b, 0x00, 0x40, 0x00,
+ 0x01, 0x3c, 0x00, 0x00, 0xb0, 0x42, 0x17
+ };
+ u8 resp_data[GEN5_BL_READ_APP_INFO_RESP_LEN];
+ int resp_len;
+ int error;
+
+ resp_len = GEN5_BL_READ_APP_INFO_RESP_LEN;
+ error = cyapa_i2c_pip_cmd_irq_sync(cyapa,
+ bl_query_data_cmd, sizeof(bl_query_data_cmd),
+ resp_data, &resp_len,
+ 500, cyapa_gen5_sort_tsg_pip_bl_resp_data, false);
+ if (error || resp_len != GEN5_BL_READ_APP_INFO_RESP_LEN ||
+ !GEN5_CMD_COMPLETE_SUCCESS(resp_data[5]))
+ 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];
+
+ return 0;
+}
+
+static int cyapa_gen5_get_query_data(struct cyapa *cyapa)
+{
+ u8 resp_data[71];
+ int resp_len;
+ u8 get_system_information[] = {
+ 0x04, 0x00, 0x05, 0x00, 0x2f, 0x00, 0x02
+ };
+ u16 product_family;
+ int error;
+
+ resp_len = sizeof(resp_data);
+ error = cyapa_i2c_pip_cmd_irq_sync(cyapa,
+ get_system_information, sizeof(get_system_information),
+ resp_data, &resp_len,
+ 2000, cyapa_gen5_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 & GEN5_PRODUCT_FAMILY_MASK) !=
+ GEN5_PRODUCT_FAMILY_TRACKPAD)
+ return -EINVAL;
+
+ cyapa->fw_maj_ver = resp_data[15];
+ cyapa->fw_min_ver = resp_data[16];
+
+ 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_gen5_bl_exit(cyapa);
+ if (error) {
+ /* Rry to update trackpad product information. */
+ cyapa_gen5_bl_query_data(cyapa);
+ goto out;
+ }
+
+ cyapa->state = CYAPA_STATE_GEN5_APP;
+
+ 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 requeried.
+ */
+ error = cyapa_gen5_set_power_mode(cyapa,
+ PWR_MODE_FULL_ACTIVE, 0);
+ if (error)
+ dev_warn(dev, "%s: failed to set power active mode.\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.
+ */
+static bool cyapa_gen5_irq_cmd_handler(struct cyapa *cyapa)
+{
+ int length;
+ struct cyapa_gen5_cmd_states *gen5_pip = &cyapa->cmd_states.gen5;
+
+ if (atomic_read(&gen5_pip->cmd_issued)) {
+ /* Polling command response data. */
+ if (gen5_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, gen5_pip->irq_cmd_buf,
+ GEN5_RESP_LENGTH_SIZE);
+ length = get_unaligned_le16(gen5_pip->irq_cmd_buf);
+ length = (length <= GEN5_RESP_LENGTH_SIZE) ?
+ GEN5_RESP_LENGTH_SIZE : length;
+ if (length > GEN5_RESP_LENGTH_SIZE)
+ cyapa_i2c_pip_read(cyapa,
+ gen5_pip->irq_cmd_buf, length);
+
+ if (!(gen5_pip->resp_sort_func &&
+ gen5_pip->resp_sort_func(cyapa,
+ gen5_pip->irq_cmd_buf, length))) {
+ /*
+ * Cover the Gen5 V1 firmware issue.
+ * The issue is there is no interrut will be
+ * asserted to notityf host to read a command
+ * data out when always has finger touch on
+ * trackpad during the command is issued to
+ * trackad device.
+ * This issue has the scenario is that,
+ * user always has his fingers touched on
+ * trackpad device when booting/rebooting
+ * their chrome book.
+ */
+ length = *gen5_pip->resp_len;
+ cyapa_empty_pip_output_data(cyapa,
+ gen5_pip->resp_data,
+ &length,
+ gen5_pip->resp_sort_func);
+ if (gen5_pip->resp_len && length != 0) {
+ *gen5_pip->resp_len = length;
+ atomic_dec(&gen5_pip->cmd_issued);
+ complete(&gen5_pip->cmd_ready);
+ }
+ return false;
+ }
+
+ if (gen5_pip->resp_data && gen5_pip->resp_len) {
+ *gen5_pip->resp_len = (*gen5_pip->resp_len < length) ?
+ *gen5_pip->resp_len : length;
+ memcpy(gen5_pip->resp_data, gen5_pip->irq_cmd_buf,
+ *gen5_pip->resp_len);
+ }
+ atomic_dec(&gen5_pip->cmd_issued);
+ complete(&gen5_pip->cmd_ready);
+ return false;
+ }
+
+ return true;
+}
+
+static void cyapa_gen5_report_buttons(struct cyapa *cyapa,
+ const struct cyapa_gen5_report_data *report_data)
+{
+ struct input_dev *input = cyapa->input;
+ u8 buttons = report_data->report_head[GEN5_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_gen5_report_slot_data(struct cyapa *cyapa,
+ const struct cyapa_gen5_touch_record *touch)
+{
+ struct input_dev *input = cyapa->input;
+ u8 event_id = GEN5_GET_EVENT_ID(touch->touch_tip_event_id);
+ int slot = GEN5_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;
+ input_report_abs(input, ABS_MT_POSITION_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_Y, y);
+ 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_gen5_report_touches(struct cyapa *cyapa,
+ const struct cyapa_gen5_report_data *report_data)
+{
+ struct input_dev *input = cyapa->input;
+ unsigned int touch_num;
+ int i;
+
+ touch_num = report_data->report_head[GEN5_NUMBER_OF_TOUCH_OFFSET] &
+ GEN5_NUMBER_OF_TOUCH_MASK;
+
+ for (i = 0; i < touch_num; i++)
+ cyapa_gen5_report_slot_data(cyapa,
+ &report_data->touch_records[i]);
+
+ input_mt_sync_frame(input);
+ input_sync(input);
+}
+
+static int cyapa_gen5_irq_handler(struct cyapa *cyapa)
+{
+ struct device *dev = &cyapa->client->dev;
+ struct cyapa_gen5_report_data report_data;
+ int ret;
+ u8 report_id;
+ unsigned int report_len;
+
+ if (cyapa->gen != CYAPA_GEN5 ||
+ cyapa->state != CYAPA_STATE_GEN5_APP) {
+ 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,
+ GEN5_RESP_LENGTH_SIZE);
+ if (ret != GEN5_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[GEN5_RESP_LENGTH_OFFSET]);
+ if (report_len < GEN5_RESP_LENGTH_SIZE) {
+ /* Invliad 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 == GEN5_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;
+ }
+
+ report_id = report_data.report_head[GEN5_RESP_REPORT_ID_OFFSET];
+ if (report_id == GEN5_WAKEUP_EVENT_REPORT_ID &&
+ report_len == GEN5_WAKEUP_EVENT_SIZE) {
+ /*
+ * Device wake event from deep sleep mode for touch.
+ * This interrupt event is used to wake system up.
+ */
+ return 0;
+ } else if (report_id != GEN5_TOUCH_REPORT_ID &&
+ report_id != GEN5_BTN_REPORT_ID &&
+ report_id != GEN5_OLD_PUSH_BTN_REPORT_ID &&
+ report_id != GEN5_PUSH_BTN_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 == GEN5_TOUCH_REPORT_ID &&
+ (report_len < GEN5_TOUCH_REPORT_HEAD_SIZE ||
+ report_len > GEN5_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 == GEN5_BTN_REPORT_ID ||
+ report_id == GEN5_OLD_PUSH_BTN_REPORT_ID ||
+ report_id == GEN5_PUSH_BTN_REPORT_ID) &&
+ (report_len < GEN5_BTN_REPORT_HEAD_SIZE ||
+ report_len > GEN5_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 == GEN5_TOUCH_REPORT_ID)
+ cyapa_gen5_report_touches(cyapa, &report_data);
+ else
+ cyapa_gen5_report_buttons(cyapa, &report_data);
+
+ return 0;
+}
+
+const struct cyapa_dev_ops cyapa_gen5_ops = {
+ .initialize = cyapa_gen5_initialize,
+
+ .state_parse = cyapa_gen5_state_parse,
+ .operational_check = cyapa_gen5_do_operational_check,
+
+ .irq_handler = cyapa_gen5_irq_handler,
+ .irq_cmd_handler = cyapa_gen5_irq_cmd_handler,
+ .sort_empty_output_data = cyapa_empty_pip_output_data,
+ .set_power_mode = cyapa_gen5_set_power_mode,
+};
--
1.9.1
^ permalink raw reply related [flat|nested] 28+ messages in thread
* [PATCH v16 03/12] input: cyapa: add power management interfaces support for the device
2014-12-18 10:00 [PATCH v16 00/12] input: cyapa: instruction of cyapa patches Dudley Du
2014-12-18 10:00 ` [PATCH v16 01/12] input: cyapa: re-design driver to support multi-trackpad in one driver Dudley Du
2014-12-18 10:00 ` [PATCH v16 02/12] input: cyapa: add gen5 trackpad device basic functions support Dudley Du
@ 2014-12-18 10:00 ` Dudley Du
2014-12-30 0:51 ` Dmitry Torokhov
2014-12-18 10:00 ` [PATCH v16 04/12] input: cyapa: add runtime " Dudley Du
` (10 subsequent siblings)
13 siblings, 1 reply; 28+ messages in thread
From: Dudley Du @ 2014-12-18 10:00 UTC (permalink / raw)
To: dmitry.torokhov, jmmahler, rydberg
Cc: Dudley Du, bleung, linux-input, linux-kernel
Add suspend_scanrate_ms power management interfaces in device's
power group, so users or applications can control the power management
strategy of trackpad device as their requirements.
TEST=test on Chromebooks.
Signed-off-by: Dudley Du <dudl@cypress.com>
---
drivers/input/mouse/cyapa.c | 111 ++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 111 insertions(+)
diff --git a/drivers/input/mouse/cyapa.c b/drivers/input/mouse/cyapa.c
index d4560a3..73f6817 100644
--- a/drivers/input/mouse/cyapa.c
+++ b/drivers/input/mouse/cyapa.c
@@ -575,6 +575,96 @@ out:
return IRQ_HANDLED;
}
+/*
+ **************************************************************
+ * sysfs interface
+ **************************************************************
+*/
+#ifdef CONFIG_PM_SLEEP
+static ssize_t cyapa_show_suspend_scanrate(struct device *dev,
+ struct device_attribute *attr,
+ char *buf)
+{
+ struct cyapa *cyapa = dev_get_drvdata(dev);
+ u8 pwr_cmd = cyapa->suspend_power_mode;
+ u16 sleep_time;
+ int len;
+ int error;
+
+ error = mutex_lock_interruptible(&cyapa->state_sync_lock);
+ if (error)
+ return error;
+ pwr_cmd = cyapa->suspend_power_mode;
+ sleep_time = cyapa->suspend_sleep_time;
+ mutex_unlock(&cyapa->state_sync_lock);
+
+ if (pwr_cmd == PWR_MODE_BTN_ONLY) {
+ len = scnprintf(buf, PAGE_SIZE, "%s\n", BTN_ONLY_MODE_NAME);
+ } else if (pwr_cmd == PWR_MODE_OFF) {
+ len = scnprintf(buf, PAGE_SIZE, "%s\n", OFF_MODE_NAME);
+ } else {
+ if (cyapa->gen == CYAPA_GEN3)
+ sleep_time = cyapa_pwr_cmd_to_sleep_time(pwr_cmd);
+ len = scnprintf(buf, PAGE_SIZE, "%u\n", sleep_time);
+ }
+
+ return len;
+}
+
+static ssize_t cyapa_update_suspend_scanrate(struct device *dev,
+ struct device_attribute *attr,
+ const char *buf, size_t count)
+{
+ struct cyapa *cyapa = dev_get_drvdata(dev);
+ u16 sleep_time;
+ int error;
+
+ error = mutex_lock_interruptible(&cyapa->state_sync_lock);
+ if (error)
+ return error;
+
+ if (sysfs_streq(buf, BTN_ONLY_MODE_NAME)) {
+ cyapa->suspend_power_mode = PWR_MODE_BTN_ONLY;
+ } else if (sysfs_streq(buf, OFF_MODE_NAME)) {
+ cyapa->suspend_power_mode = PWR_MODE_OFF;
+ } else if (!kstrtou16(buf, 10, &sleep_time)) {
+ cyapa->suspend_sleep_time = max_t(u16, sleep_time, 1000);
+ cyapa->suspend_power_mode =
+ cyapa_sleep_time_to_pwr_cmd(cyapa->suspend_sleep_time);
+ } else {
+ count = 0;
+ }
+
+ mutex_unlock(&cyapa->state_sync_lock);
+
+ if (!count)
+ dev_err(dev, "invalid suspend scanrate ms parameters\n");
+ return count ? count : -EINVAL;
+}
+
+static DEVICE_ATTR(suspend_scanrate_ms, S_IRUGO|S_IWUSR,
+ cyapa_show_suspend_scanrate,
+ cyapa_update_suspend_scanrate);
+
+static struct attribute *cyapa_power_wakeup_entries[] = {
+ &dev_attr_suspend_scanrate_ms.attr,
+ NULL,
+};
+
+static const struct attribute_group cyapa_power_wakeup_group = {
+ .name = power_group_name,
+ .attrs = cyapa_power_wakeup_entries,
+};
+
+static void cyapa_remove_power_wakeup_group(void *data)
+{
+ struct cyapa *cyapa = data;
+
+ sysfs_unmerge_group(&cyapa->client->dev.kobj,
+ &cyapa_power_wakeup_group);
+}
+#endif /* CONFIG_PM_SLEEP */
+
static int cyapa_probe(struct i2c_client *client,
const struct i2c_device_id *dev_id)
{
@@ -614,6 +704,27 @@ static int cyapa_probe(struct i2c_client *client,
return error;
}
+#ifdef CONFIG_PM_SLEEP
+ if (device_can_wakeup(dev)) {
+ error = sysfs_merge_group(&client->dev.kobj,
+ &cyapa_power_wakeup_group);
+ if (error) {
+ dev_err(dev, "failed to add power wakeup group: %d\n",
+ error);
+ return error;
+ }
+
+ error = devm_add_action(dev,
+ cyapa_remove_power_wakeup_group, cyapa);
+ if (error) {
+ cyapa_remove_power_wakeup_group(cyapa);
+ dev_err(dev, "failed to add power cleanup action: %d\n",
+ error);
+ return error;
+ }
+ }
+#endif /* CONFIG_PM_SLEEP */
+
error = devm_request_threaded_irq(dev, client->irq,
NULL, cyapa_irq,
IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
--
1.9.1
^ permalink raw reply related [flat|nested] 28+ messages in thread
* [PATCH v16 04/12] input: cyapa: add runtime power management interfaces support for the device
2014-12-18 10:00 [PATCH v16 00/12] input: cyapa: instruction of cyapa patches Dudley Du
` (2 preceding siblings ...)
2014-12-18 10:00 ` [PATCH v16 03/12] input: cyapa: add power management interfaces support for the device Dudley Du
@ 2014-12-18 10:00 ` Dudley Du
2014-12-30 0:57 ` Dmitry Torokhov
2014-12-18 10:00 ` [PATCH v16 05/12] input: cyapa: add sysfs interfaces support in the cyapa driver Dudley Du
` (9 subsequent siblings)
13 siblings, 1 reply; 28+ messages in thread
From: Dudley Du @ 2014-12-18 10:00 UTC (permalink / raw)
To: dmitry.torokhov, jmmahler, rydberg
Cc: Dudley Du, bleung, linux-input, linux-kernel
Add runtime_suspend_scanrate_ms power management interfaces in device's
power group, so users or applications can control the runtime power
management strategy of trackpad device as their requirements.
TEST=test on Chromebooks.
Signed-off-by: Dudley Du <dudl@cypress.com>
---
drivers/input/mouse/cyapa.c | 171 +++++++++++++++++++++++++++++++++++++++++++-
drivers/input/mouse/cyapa.h | 4 ++
2 files changed, 174 insertions(+), 1 deletion(-)
diff --git a/drivers/input/mouse/cyapa.c b/drivers/input/mouse/cyapa.c
index 73f6817..3bcfce3 100644
--- a/drivers/input/mouse/cyapa.c
+++ b/drivers/input/mouse/cyapa.c
@@ -23,6 +23,7 @@
#include <linux/mutex.h>
#include <linux/slab.h>
#include <linux/uaccess.h>
+#include <linux/pm_runtime.h>
#include "cyapa.h"
@@ -327,6 +328,8 @@ static int cyapa_open(struct input_dev *input)
}
enable_irq(client->irq);
+ pm_runtime_set_active(&client->dev);
+ pm_runtime_enable(&client->dev);
out:
mutex_unlock(&cyapa->state_sync_lock);
return error;
@@ -340,8 +343,10 @@ static void cyapa_close(struct input_dev *input)
mutex_lock(&cyapa->state_sync_lock);
disable_irq(client->irq);
+ pm_runtime_disable(&client->dev);
if (!CYAPA_BOOTLOADER(cyapa) && cyapa->ops->set_power_mode)
cyapa->ops->set_power_mode(cyapa, PWR_MODE_OFF, 0);
+ pm_runtime_set_suspended(&client->dev);
mutex_unlock(&cyapa->state_sync_lock);
}
@@ -542,6 +547,7 @@ static irqreturn_t cyapa_irq(int irq, void *dev_id)
struct device *dev = &cyapa->client->dev;
bool cont;
+ pm_runtime_get_sync(dev);
if (device_may_wakeup(dev))
pm_wakeup_event(dev, 0);
@@ -572,6 +578,8 @@ static irqreturn_t cyapa_irq(int irq, void *dev_id)
}
out:
+ pm_runtime_mark_last_busy(dev);
+ pm_runtime_put_sync_autosuspend(dev);
return IRQ_HANDLED;
}
@@ -665,6 +673,116 @@ static void cyapa_remove_power_wakeup_group(void *data)
}
#endif /* CONFIG_PM_SLEEP */
+#ifdef CONFIG_PM_RUNTIME
+static ssize_t cyapa_show_rt_suspend_scanrate(struct device *dev,
+ struct device_attribute *attr,
+ char *buf)
+{
+ struct cyapa *cyapa = dev_get_drvdata(dev);
+ u8 pwr_cmd;
+ u16 sleep_time;
+ int error;
+
+ error = mutex_lock_interruptible(&cyapa->state_sync_lock);
+ if (error)
+ return error;
+ pwr_cmd = cyapa->runtime_suspend_power_mode;
+ sleep_time = cyapa->runtime_suspend_sleep_time;
+ mutex_unlock(&cyapa->state_sync_lock);
+
+ if (cyapa->gen == CYAPA_GEN3)
+ return scnprintf(buf, PAGE_SIZE, "%u\n",
+ cyapa_pwr_cmd_to_sleep_time(pwr_cmd));
+ return scnprintf(buf, PAGE_SIZE, "%u\n", sleep_time);
+}
+
+static ssize_t cyapa_update_rt_suspend_scanrate(struct device *dev,
+ struct device_attribute *attr,
+ const char *buf, size_t count)
+{
+ struct cyapa *cyapa = dev_get_drvdata(dev);
+ u16 time;
+ int error;
+
+ if (buf == NULL || count == 0 || kstrtou16(buf, 10, &time)) {
+ dev_err(dev, "invalid runtime suspend scanrate ms parameter\n");
+ return -EINVAL;
+ }
+
+ /*
+ * When the suspend scanrate is changed, pm_runtime_get to resume
+ * a potentially suspended device, update to the new pwr_cmd
+ * and then pm_runtime_put to suspend into the new power mode.
+ */
+ pm_runtime_get_sync(dev);
+ error = mutex_lock_interruptible(&cyapa->state_sync_lock);
+ if (error)
+ return error;
+ cyapa->runtime_suspend_sleep_time = max_t(u16, time, 1000);
+ cyapa->runtime_suspend_power_mode =
+ cyapa_sleep_time_to_pwr_cmd(cyapa->runtime_suspend_sleep_time);
+ mutex_unlock(&cyapa->state_sync_lock);
+ pm_runtime_put_sync_autosuspend(dev);
+
+ return count;
+}
+
+static DEVICE_ATTR(runtime_suspend_scanrate_ms, S_IRUGO|S_IWUSR,
+ cyapa_show_rt_suspend_scanrate,
+ cyapa_update_rt_suspend_scanrate);
+
+static struct attribute *cyapa_power_runtime_entries[] = {
+ &dev_attr_runtime_suspend_scanrate_ms.attr,
+ NULL,
+};
+
+static const struct attribute_group cyapa_power_runtime_group = {
+ .name = power_group_name,
+ .attrs = cyapa_power_runtime_entries,
+};
+
+static void cyapa_remove_power_runtime_group(void *data)
+{
+ struct cyapa *cyapa = data;
+
+ sysfs_unmerge_group(&cyapa->client->dev.kobj,
+ &cyapa_power_runtime_group);
+}
+
+static int cyapa_start_runtime(struct cyapa *cyapa)
+{
+ struct device *dev = &cyapa->client->dev;
+ int error;
+
+ cyapa->runtime_suspend_power_mode = PWR_MODE_IDLE;
+ cyapa->runtime_suspend_sleep_time =
+ cyapa_pwr_cmd_to_sleep_time(cyapa->runtime_suspend_power_mode);
+
+ error = sysfs_merge_group(&dev->kobj, &cyapa_power_runtime_group);
+ if (error) {
+ dev_err(dev,
+ "failed to create power runtime group: %d\n", error);
+ return error;
+ }
+
+ error = devm_add_action(dev, cyapa_remove_power_runtime_group, cyapa);
+ if (error) {
+ cyapa_remove_power_runtime_group(cyapa);
+ dev_err(dev,
+ "failed to add power runtime cleanup action: %d\n",
+ error);
+ return error;
+ }
+
+ /* runtime is enabled until device is operational and opened. */
+ pm_runtime_set_suspended(dev);
+ pm_runtime_use_autosuspend(dev);
+ pm_runtime_set_autosuspend_delay(dev, AUTOSUSPEND_DELAY);
+
+ return 0;
+}
+#endif /* CONFIG_PM_RUNTIME */
+
static int cyapa_probe(struct i2c_client *client,
const struct i2c_device_id *dev_id)
{
@@ -725,6 +843,14 @@ static int cyapa_probe(struct i2c_client *client,
}
#endif /* CONFIG_PM_SLEEP */
+#ifdef CONFIG_PM_RUNTIME
+ error = cyapa_start_runtime(cyapa);
+ if (error) {
+ dev_err(dev, "failed to start pm_runtime: %d\n", error);
+ return error;
+ }
+#endif /* CONFIG_PM_RUNTIME */
+
error = devm_request_threaded_irq(dev, client->irq,
NULL, cyapa_irq,
IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
@@ -765,6 +891,7 @@ static int __maybe_unused cyapa_suspend(struct device *dev)
if (error)
return error;
+ pm_runtime_disable(dev);
disable_irq(client->irq);
/*
@@ -781,6 +908,8 @@ static int __maybe_unused cyapa_suspend(struct device *dev)
error);
}
+ pm_runtime_set_suspended(dev);
+
if (device_may_wakeup(dev))
cyapa->irq_wake = (enable_irq_wake(client->irq) == 0);
@@ -801,17 +930,57 @@ static int __maybe_unused cyapa_resume(struct device *dev)
cyapa->irq_wake = false;
}
+ pm_runtime_set_active(dev);
+
error = cyapa_reinitialize(cyapa);
if (error)
dev_warn(dev, "failed to reinitialize TP device: %d\n", error);
enable_irq(client->irq);
+ pm_runtime_enable(dev);
+
mutex_unlock(&cyapa->state_sync_lock);
return 0;
}
-static SIMPLE_DEV_PM_OPS(cyapa_pm_ops, cyapa_suspend, cyapa_resume);
+#ifdef CONFIG_PM_RUNTIME
+static int cyapa_runtime_suspend(struct device *dev)
+{
+ struct cyapa *cyapa = dev_get_drvdata(dev);
+ int error;
+
+ if (!CYAPA_BOOTLOADER(cyapa) && cyapa->ops->set_power_mode) {
+ error = cyapa->ops->set_power_mode(cyapa,
+ cyapa->runtime_suspend_power_mode,
+ cyapa->runtime_suspend_sleep_time);
+ if (error)
+ dev_warn(dev, "runtime suspend failed: %d\n", error);
+ }
+
+ return 0;
+}
+
+static int cyapa_runtime_resume(struct device *dev)
+{
+ struct cyapa *cyapa = dev_get_drvdata(dev);
+ int error;
+
+ if (!CYAPA_BOOTLOADER(cyapa) && cyapa->ops->set_power_mode) {
+ error = cyapa->ops->set_power_mode(cyapa,
+ PWR_MODE_FULL_ACTIVE, 0);
+ if (error)
+ dev_warn(dev, "runtime resume failed: %d\n", error);
+ }
+
+ return 0;
+}
+#endif /* CONFIG_PM_RUNTIME */
+
+static const struct dev_pm_ops cyapa_pm_ops = {
+ SET_SYSTEM_SLEEP_PM_OPS(cyapa_suspend, cyapa_resume)
+ SET_RUNTIME_PM_OPS(cyapa_runtime_suspend, cyapa_runtime_resume, NULL)
+};
static const struct i2c_device_id cyapa_id_table[] = {
{ "cyapa", 0 },
diff --git a/drivers/input/mouse/cyapa.h b/drivers/input/mouse/cyapa.h
index 4c09be4..922a473 100644
--- a/drivers/input/mouse/cyapa.h
+++ b/drivers/input/mouse/cyapa.h
@@ -253,6 +253,10 @@ struct cyapa {
/* power mode settings */
u8 suspend_power_mode;
u16 suspend_sleep_time;
+#ifdef CONFIG_PM_RUNTIME
+ u8 runtime_suspend_power_mode;
+ u16 runtime_suspend_sleep_time;
+#endif /* CONFIG_PM_RUNTIME */
u8 dev_pwr_mode;
u16 dev_sleep_time;
--
1.9.1
^ permalink raw reply related [flat|nested] 28+ messages in thread
* [PATCH v16 05/12] input: cyapa: add sysfs interfaces support in the cyapa driver
2014-12-18 10:00 [PATCH v16 00/12] input: cyapa: instruction of cyapa patches Dudley Du
` (3 preceding siblings ...)
2014-12-18 10:00 ` [PATCH v16 04/12] input: cyapa: add runtime " Dudley Du
@ 2014-12-18 10:00 ` Dudley Du
2014-12-18 10:00 ` [PATCH v16 06/12] input: cyapa: add gen3 trackpad device firmware update function support Dudley Du
` (8 subsequent siblings)
13 siblings, 0 replies; 28+ messages in thread
From: Dudley Du @ 2014-12-18 10:00 UTC (permalink / raw)
To: dmitry.torokhov, jmmahler, rydberg
Cc: Dudley Du, bleung, linux-input, linux-kernel
Add device's basic control and features supported in cyapa driver through
sysfs file system interfaces. These interfaces are commonly used in
pre- and after production, for trackpad device state checking, managing
and firmware image updating.
These interfaces including mode, firmware_version and product_id interfaces
for reading firmware version and trackpad device product id values,
and including update_fw interface to command firmware image update
process. Also including baseline and calibrate interfaces for
reading and checking trackpad device's sensors states.
TEST=test on Chromebooks.
Signed-off-by: Dudley Du <dudl@cypress.com>
---
drivers/input/mouse/cyapa.c | 327 ++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 327 insertions(+)
diff --git a/drivers/input/mouse/cyapa.c b/drivers/input/mouse/cyapa.c
index 3bcfce3..406f38b 100644
--- a/drivers/input/mouse/cyapa.c
+++ b/drivers/input/mouse/cyapa.c
@@ -32,6 +32,8 @@
#define CYAPA_ADAPTER_FUNC_SMBUS 2
#define CYAPA_ADAPTER_FUNC_BOTH 3
+#define CYAPA_FW_NAME "cyapa.bin"
+
const char product_id[] = "CYTRA";
static int cyapa_reinitialize(struct cyapa *cyapa);
@@ -442,6 +444,29 @@ static int cyapa_create_input_dev(struct cyapa *cyapa)
return 0;
}
+static void cyapa_enable_irq_for_cmd(struct cyapa *cyapa)
+{
+ struct input_dev *input = cyapa->input;
+
+ if (!input || !input->users) {
+ if (!CYAPA_BOOTLOADER(cyapa) && cyapa->ops->set_power_mode)
+ cyapa->ops->set_power_mode(cyapa,
+ PWR_MODE_FULL_ACTIVE, 0);
+ enable_irq(cyapa->client->irq);
+ }
+}
+
+static void cyapa_disable_irq_for_cmd(struct cyapa *cyapa)
+{
+ struct input_dev *input = cyapa->input;
+
+ if (!input || !input->users) {
+ disable_irq(cyapa->client->irq);
+ if (!CYAPA_BOOTLOADER(cyapa) && cyapa->ops->set_power_mode)
+ cyapa->ops->set_power_mode(cyapa, PWR_MODE_OFF, 0);
+ }
+}
+
/*
* cyapa_sleep_time_to_pwr_cmd and cyapa_pwr_cmd_to_sleep_time
*
@@ -783,6 +808,295 @@ static int cyapa_start_runtime(struct cyapa *cyapa)
}
#endif /* CONFIG_PM_RUNTIME */
+static ssize_t cyapa_show_fm_ver(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ int error;
+ struct cyapa *cyapa = dev_get_drvdata(dev);
+
+ error = mutex_lock_interruptible(&cyapa->state_sync_lock);
+ if (error)
+ return error;
+ error = scnprintf(buf, PAGE_SIZE, "%d.%d\n", cyapa->fw_maj_ver,
+ cyapa->fw_min_ver);
+ mutex_unlock(&cyapa->state_sync_lock);
+ return error;
+}
+
+static ssize_t cyapa_show_product_id(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ struct cyapa *cyapa = dev_get_drvdata(dev);
+ int size;
+ int error;
+
+ error = mutex_lock_interruptible(&cyapa->state_sync_lock);
+ if (error)
+ return error;
+ size = scnprintf(buf, PAGE_SIZE, "%s\n", cyapa->product_id);
+ mutex_unlock(&cyapa->state_sync_lock);
+ return size;
+}
+
+static int cyapa_firmware(struct cyapa *cyapa, const char *fw_name)
+{
+ struct device *dev = &cyapa->client->dev;
+ const struct firmware *fw;
+ int error;
+
+ error = request_firmware(&fw, fw_name, dev);
+ if (error) {
+ dev_err(dev, "Could not load firmware from %s: %d\n",
+ fw_name, error);
+ return error;
+ }
+
+ if (cyapa->ops->check_fw) {
+ error = cyapa->ops->check_fw(cyapa, fw);
+ if (error) {
+ dev_err(dev, "Invalid CYAPA firmware image: %s\n",
+ fw_name);
+ goto done;
+ }
+ } else {
+ dev_err(dev, "No valid device ops->check_fw handler set.\n");
+ error = -ENODEV;
+ goto done;
+ }
+
+ /*
+ * Resume the potentially suspended device because doing FW
+ * update on a device not in the FULL mode has a chance to
+ * fail.
+ */
+ pm_runtime_get_sync(dev);
+
+ /* Require IRQ support for firmware update commands. */
+ cyapa_enable_irq_for_cmd(cyapa);
+
+ if (cyapa->ops->bl_enter) {
+ error = cyapa->ops->bl_enter(cyapa);
+ if (error) {
+ dev_err(dev, "bl_enter failed, %d\n", error);
+ goto err_detect;
+ }
+ }
+
+ if (cyapa->ops->bl_activate) {
+ error = cyapa->ops->bl_activate(cyapa);
+ if (error) {
+ dev_err(dev, "bl_activate failed, %d\n", error);
+ goto err_detect;
+ }
+ }
+
+ if (cyapa->ops->bl_initiate) {
+ error = cyapa->ops->bl_initiate(cyapa, fw);
+ if (error) {
+ dev_err(dev, "bl_initiate failed, %d\n", error);
+ goto err_detect;
+ }
+ }
+
+ if (cyapa->ops->update_fw) {
+ error = cyapa->ops->update_fw(cyapa, fw);
+ if (error) {
+ dev_err(dev, "update_fw failed, %d\n", error);
+ goto err_detect;
+ }
+ }
+
+ if (cyapa->ops->bl_verify_app_integrity) {
+ error = cyapa->ops->bl_verify_app_integrity(cyapa);
+ if (error) {
+ dev_err(dev, "bl_verify_app_integrity failed, %d\n",
+ error);
+ goto err_detect;
+ }
+ }
+
+err_detect:
+ cyapa_disable_irq_for_cmd(cyapa);
+ pm_runtime_put_noidle(dev);
+
+done:
+ release_firmware(fw);
+ return error;
+}
+
+static ssize_t cyapa_update_fw_store(struct device *dev,
+ struct device_attribute *attr,
+ const char *buf, size_t count)
+{
+ struct cyapa *cyapa = dev_get_drvdata(dev);
+ char fw_name[NAME_MAX];
+ int ret, error;
+
+ if (count > NAME_MAX) {
+ dev_err(dev, "File name too long\n");
+ return -EINVAL;
+ }
+
+ memcpy(fw_name, buf, count);
+ if (fw_name[count - 1] == '\n')
+ fw_name[count - 1] = '\0';
+ else
+ fw_name[count] = '\0';
+
+ if (cyapa->input) {
+ /*
+ * Force the input device to be registered after the firmware
+ * image is updated, so if the corresponding parameters updated
+ * in the new firmware image can taken effect immediately.
+ */
+ input_unregister_device(cyapa->input);
+ cyapa->operational = false;
+ cyapa->input = NULL;
+ }
+
+ error = mutex_lock_interruptible(&cyapa->state_sync_lock);
+ if (error) {
+ /*
+ * Whatever, do reinitialize to try to recover TP state to
+ * previous state just as it entered fw update entrance.
+ */
+ cyapa_reinitialize(cyapa);
+ return error;
+ }
+
+ error = cyapa_firmware(cyapa, fw_name);
+ if (error)
+ dev_err(dev, "firmware update failed: %d\n", error);
+ else
+ dev_dbg(dev, "firmware update successfully done.\n");
+
+ /*
+ * Redetect trackpad device states because firmware update process
+ * will reset trackpad device into bootloader mode.
+ */
+ ret = cyapa_reinitialize(cyapa);
+ if (ret) {
+ dev_err(dev, "failed to redetect after updated: %d\n", ret);
+ error = error ? error : ret;
+ }
+
+ mutex_unlock(&cyapa->state_sync_lock);
+
+ return error ? error : count;
+}
+
+static ssize_t cyapa_calibrate_store(struct device *dev,
+ struct device_attribute *attr,
+ const char *buf, size_t count)
+{
+ struct cyapa *cyapa = dev_get_drvdata(dev);
+ int error;
+
+ error = mutex_lock_interruptible(&cyapa->state_sync_lock);
+ if (error)
+ return error;
+
+ if (!cyapa->ops->calibrate_store) {
+ dev_err(dev, "Calibrate operation not supported.\n");
+ error = -ENOTSUPP;
+ } else {
+ cyapa_enable_irq_for_cmd(cyapa);
+ error = cyapa->ops->calibrate_store(dev, attr, buf, count);
+ cyapa_disable_irq_for_cmd(cyapa);
+ }
+
+ mutex_unlock(&cyapa->state_sync_lock);
+ return error < 0 ? error : count;
+}
+
+static ssize_t cyapa_show_baseline(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ struct cyapa *cyapa = dev_get_drvdata(dev);
+ ssize_t error;
+
+ error = mutex_lock_interruptible(&cyapa->state_sync_lock);
+ if (error)
+ return error;
+
+ if (!cyapa->ops->show_baseline) {
+ dev_err(dev, "Calibrate operation not supported.\n");
+ error = -ENOTSUPP;
+ } else {
+ cyapa_enable_irq_for_cmd(cyapa);
+ error = cyapa->ops->show_baseline(dev, attr, buf);
+ cyapa_disable_irq_for_cmd(cyapa);
+ }
+
+ mutex_unlock(&cyapa->state_sync_lock);
+ return error;
+}
+
+static char *cyapa_state_to_string(struct cyapa *cyapa)
+{
+ switch (cyapa->state) {
+ case CYAPA_STATE_BL_BUSY:
+ return "bootloader busy";
+ case CYAPA_STATE_BL_IDLE:
+ return "bootloader idle";
+ case CYAPA_STATE_BL_ACTIVE:
+ return "bootloader active";
+ case CYAPA_STATE_GEN5_BL:
+ return "bootloader";
+ case CYAPA_STATE_OP:
+ case CYAPA_STATE_GEN5_APP:
+ return "operational"; /* Normal valid state. */
+ default:
+ return "invalid mode";
+ }
+}
+
+static ssize_t cyapa_show_mode(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ struct cyapa *cyapa = dev_get_drvdata(dev);
+ int size;
+ int error;
+
+ error = mutex_lock_interruptible(&cyapa->state_sync_lock);
+ if (error)
+ return error;
+
+ size = scnprintf(buf, PAGE_SIZE, "gen%d %s\n",
+ cyapa->gen, cyapa_state_to_string(cyapa));
+
+ mutex_unlock(&cyapa->state_sync_lock);
+ return size;
+}
+
+static DEVICE_ATTR(firmware_version, S_IRUGO, cyapa_show_fm_ver, NULL);
+static DEVICE_ATTR(product_id, S_IRUGO, cyapa_show_product_id, NULL);
+static DEVICE_ATTR(update_fw, S_IWUSR, NULL, cyapa_update_fw_store);
+static DEVICE_ATTR(baseline, S_IRUGO, cyapa_show_baseline, NULL);
+static DEVICE_ATTR(calibrate, S_IWUSR, NULL, cyapa_calibrate_store);
+static DEVICE_ATTR(mode, S_IRUGO, cyapa_show_mode, NULL);
+
+static struct attribute *cyapa_sysfs_entries[] = {
+ &dev_attr_firmware_version.attr,
+ &dev_attr_product_id.attr,
+ &dev_attr_update_fw.attr,
+ &dev_attr_baseline.attr,
+ &dev_attr_calibrate.attr,
+ &dev_attr_mode.attr,
+ NULL,
+};
+
+static const struct attribute_group cyapa_sysfs_group = {
+ .attrs = cyapa_sysfs_entries,
+};
+
+static void cyapa_remove_sysfs_group(void *data)
+{
+ struct cyapa *cyapa = data;
+
+ sysfs_remove_group(&cyapa->client->dev.kobj, &cyapa_sysfs_group);
+}
+
static int cyapa_probe(struct i2c_client *client,
const struct i2c_device_id *dev_id)
{
@@ -822,6 +1136,19 @@ static int cyapa_probe(struct i2c_client *client,
return error;
}
+ error = sysfs_create_group(&client->dev.kobj, &cyapa_sysfs_group);
+ if (error) {
+ dev_err(dev, "failed to create sysfs entries: %d\n", error);
+ return error;
+ }
+
+ error = devm_add_action(dev, cyapa_remove_sysfs_group, cyapa);
+ if (error) {
+ cyapa_remove_sysfs_group(cyapa);
+ dev_err(dev, "failed to add sysfs cleanup action: %d\n", error);
+ return error;
+ }
+
#ifdef CONFIG_PM_SLEEP
if (device_can_wakeup(dev)) {
error = sysfs_merge_group(&client->dev.kobj,
--
1.9.1
^ permalink raw reply related [flat|nested] 28+ messages in thread
* [PATCH v16 06/12] input: cyapa: add gen3 trackpad device firmware update function support
2014-12-18 10:00 [PATCH v16 00/12] input: cyapa: instruction of cyapa patches Dudley Du
` (4 preceding siblings ...)
2014-12-18 10:00 ` [PATCH v16 05/12] input: cyapa: add sysfs interfaces support in the cyapa driver Dudley Du
@ 2014-12-18 10:00 ` Dudley Du
2014-12-18 10:00 ` [PATCH v16 07/12] input: cyapa: add gen3 trackpad device read baseline " Dudley Du
` (7 subsequent siblings)
13 siblings, 0 replies; 28+ messages in thread
From: Dudley Du @ 2014-12-18 10:00 UTC (permalink / raw)
To: dmitry.torokhov, jmmahler, rydberg
Cc: Dudley Du, bleung, linux-input, linux-kernel
Add firmware image update function supported for gen3 trackpad device,
it can be used through sysfs update_fw interface.
TEST=test on Chromebooks.
Signed-off-by: Dudley Du <dudl@cypress.com>
---
drivers/input/mouse/cyapa_gen3.c | 288 +++++++++++++++++++++++++++++++++++++++
1 file changed, 288 insertions(+)
diff --git a/drivers/input/mouse/cyapa_gen3.c b/drivers/input/mouse/cyapa_gen3.c
index 228fd2d..cd4f1db 100644
--- a/drivers/input/mouse/cyapa_gen3.c
+++ b/drivers/input/mouse/cyapa_gen3.c
@@ -20,6 +20,7 @@
#include <linux/input/mt.h>
#include <linux/module.h>
#include <linux/slab.h>
+#include <linux/unaligned/access_ok.h>
#include "cyapa.h"
@@ -115,6 +116,18 @@ struct cyapa_reg_data {
struct cyapa_touch touches[5];
} __packed;
+struct gen3_write_block_cmd {
+ u8 checksum_seed; /* Always be 0xff */
+ u8 cmd_code; /* command code: 0x39 */
+ u8 key[8]; /* 8-byte security key */
+ __be16 block_num;
+ u8 block_data[CYAPA_FW_BLOCK_SIZE];
+ u8 block_checksum; /* Calculated using bytes 12 - 75 */
+ u8 cmd_checksum; /* Calculated using bytes 0-76 */
+} __packed;
+
+static const u8 security_key[] = {
+ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 };
static const u8 bl_activate[] = { 0x00, 0xff, 0x38, 0x00, 0x01, 0x02, 0x03,
0x04, 0x05, 0x06, 0x07 };
static const u8 bl_deactivate[] = { 0x00, 0xff, 0x3b, 0x00, 0x01, 0x02, 0x03,
@@ -423,6 +436,69 @@ static int cyapa_gen3_state_parse(struct cyapa *cyapa, u8 *reg_data, int len)
return -EAGAIN;
}
+/*
+ * Enter bootloader by soft resetting the device.
+ *
+ * If device is already in the bootloader, the function just returns.
+ * Otherwise, reset the device; after reset, device enters bootloader idle
+ * state immediately.
+ *
+ * Returns:
+ * 0 on success
+ * -EAGAIN device was reset, but is not now in bootloader idle state
+ * < 0 if the device never responds within the timeout
+ */
+static int cyapa_gen3_bl_enter(struct cyapa *cyapa)
+{
+ int error;
+
+ error = cyapa_poll_state(cyapa, 500);
+ if (error)
+ return error;
+ if (cyapa->state == CYAPA_STATE_BL_IDLE) {
+ /* Already in BL_IDLE. Skipping reset. */
+ return 0;
+ }
+
+ if (cyapa->state != CYAPA_STATE_OP)
+ return -EAGAIN;
+
+ cyapa->state = CYAPA_STATE_NO_DEVICE;
+ error = cyapa_write_byte(cyapa, CYAPA_CMD_SOFT_RESET, 0x01);
+ if (error)
+ return -EIO;
+
+ usleep_range(25000, 50000);
+ error = cyapa_poll_state(cyapa, 500);
+ if (error)
+ return error;
+ if ((cyapa->state != CYAPA_STATE_BL_IDLE) ||
+ (cyapa->status[REG_BL_STATUS] & BL_STATUS_WATCHDOG))
+ return -EAGAIN;
+
+ return 0;
+}
+
+static int cyapa_gen3_bl_activate(struct cyapa *cyapa)
+{
+ int error;
+
+ error = cyapa_i2c_reg_write_block(cyapa, 0, sizeof(bl_activate),
+ bl_activate);
+ if (error)
+ return error;
+
+ /* Wait for bootloader to activate; takes between 2 and 12 seconds */
+ msleep(2000);
+ error = cyapa_poll_state(cyapa, 11000);
+ if (error)
+ return error;
+ if (cyapa->state != CYAPA_STATE_BL_ACTIVE)
+ return -EAGAIN;
+
+ return 0;
+}
+
static int cyapa_gen3_bl_deactivate(struct cyapa *cyapa)
{
int error;
@@ -483,6 +559,212 @@ static int cyapa_gen3_bl_exit(struct cyapa *cyapa)
return 0;
}
+static u16 cyapa_gen3_csum(const u8 *buf, size_t count)
+{
+ int i;
+ u16 csum = 0;
+
+ for (i = 0; i < count; i++)
+ csum += buf[i];
+
+ return csum;
+}
+
+/*
+ * Verify the integrity of a CYAPA firmware image file.
+ *
+ * The firmware image file is 30848 bytes, composed of 482 64-byte blocks.
+ *
+ * The first 2 blocks are the firmware header.
+ * The next 480 blocks are the firmware image.
+ *
+ * The first two bytes of the header hold the header checksum, computed by
+ * summing the other 126 bytes of the header.
+ * The last two bytes of the header hold the firmware image checksum, computed
+ * by summing the 30720 bytes of the image modulo 0xffff.
+ *
+ * Both checksums are stored little-endian.
+ */
+static int cyapa_gen3_check_fw(struct cyapa *cyapa, const struct firmware *fw)
+{
+ struct device *dev = &cyapa->client->dev;
+ u16 csum;
+ u16 csum_expected;
+
+ /* Firmware must match exact 30848 bytes = 482 64-byte blocks. */
+ if (fw->size != CYAPA_FW_SIZE) {
+ dev_err(dev, "invalid firmware size = %zu, expected %u.\n",
+ fw->size, CYAPA_FW_SIZE);
+ return -EINVAL;
+ }
+
+ /* Verify header block */
+ csum_expected = (fw->data[0] << 8) | fw->data[1];
+ csum = cyapa_gen3_csum(&fw->data[2], CYAPA_FW_HDR_SIZE - 2);
+ if (csum != csum_expected) {
+ dev_err(dev, "%s %04x, expected: %04x\n",
+ "invalid firmware header checksum = ",
+ csum, csum_expected);
+ return -EINVAL;
+ }
+
+ /* Verify firmware image */
+ csum_expected = (fw->data[CYAPA_FW_HDR_SIZE - 2] << 8) |
+ fw->data[CYAPA_FW_HDR_SIZE - 1];
+ csum = cyapa_gen3_csum(&fw->data[CYAPA_FW_HDR_SIZE],
+ CYAPA_FW_DATA_SIZE);
+ if (csum != csum_expected) {
+ dev_err(dev, "%s %04x, expected: %04x\n",
+ "invalid firmware header checksum = ",
+ csum, csum_expected);
+ return -EINVAL;
+ }
+ return 0;
+}
+
+/*
+ * Write a |len| byte long buffer |buf| to the device, by chopping it up into a
+ * sequence of smaller |CYAPA_CMD_LEN|-length write commands.
+ *
+ * The data bytes for a write command are prepended with the 1-byte offset
+ * of the data relative to the start of |buf|.
+ */
+static int cyapa_gen3_write_buffer(struct cyapa *cyapa,
+ const u8 *buf, size_t len)
+{
+ int error;
+ size_t i;
+ unsigned char cmd[CYAPA_CMD_LEN + 1];
+ size_t cmd_len;
+
+ for (i = 0; i < len; i += CYAPA_CMD_LEN) {
+ const u8 *payload = &buf[i];
+
+ cmd_len = (len - i >= CYAPA_CMD_LEN) ? CYAPA_CMD_LEN : len - i;
+ cmd[0] = i;
+ memcpy(&cmd[1], payload, cmd_len);
+
+ error = cyapa_i2c_reg_write_block(cyapa, 0, cmd_len + 1, cmd);
+ if (error)
+ return error;
+ }
+ return 0;
+}
+
+/*
+ * A firmware block write command writes 64 bytes of data to a single flash
+ * page in the device. The 78-byte block write command has the format:
+ * <0xff> <CMD> <Key> <Start> <Data> <Data-Checksum> <CMD Checksum>
+ *
+ * <0xff> - every command starts with 0xff
+ * <CMD> - the write command value is 0x39
+ * <Key> - write commands include an 8-byte key: { 00 01 02 03 04 05 06 07 }
+ * <Block> - Memory Block number (address / 64) (16-bit, big-endian)
+ * <Data> - 64 bytes of firmware image data
+ * <Data Checksum> - sum of 64 <Data> bytes, modulo 0xff
+ * <CMD Checksum> - sum of 77 bytes, from 0xff to <Data Checksum>
+ *
+ * Each write command is split into 5 i2c write transactions of up to 16 bytes.
+ * Each transaction starts with an i2c register offset: (00, 10, 20, 30, 40).
+ */
+static int cyapa_gen3_write_fw_block(struct cyapa *cyapa,
+ u16 block, const u8 *data)
+{
+ int ret;
+ struct gen3_write_block_cmd write_block_cmd;
+ u8 status[BL_STATUS_SIZE];
+ int tries;
+ u8 bl_status, bl_error;
+
+ /* Set write command and security key bytes. */
+ write_block_cmd.checksum_seed = GEN3_BL_CMD_CHECKSUM_SEED;
+ write_block_cmd.cmd_code = GEN3_BL_CMD_WRITE_BLOCK;
+ memcpy(write_block_cmd.key, security_key, sizeof(security_key));
+ put_unaligned_be16(block, &write_block_cmd.block_num);
+ memcpy(write_block_cmd.block_data, data, CYAPA_FW_BLOCK_SIZE);
+ write_block_cmd.block_checksum = cyapa_gen3_csum(
+ write_block_cmd.block_data, CYAPA_FW_BLOCK_SIZE);
+ write_block_cmd.cmd_checksum = cyapa_gen3_csum((u8 *)&write_block_cmd,
+ sizeof(write_block_cmd) - 1);
+
+ ret = cyapa_gen3_write_buffer(cyapa, (u8 *)&write_block_cmd,
+ sizeof(write_block_cmd));
+ if (ret)
+ return ret;
+
+ /* Wait for write to finish */
+ tries = 11; /* Programming for one block can take about 100ms. */
+ do {
+ usleep_range(10000, 20000);
+
+ /* Check block write command result status. */
+ ret = cyapa_i2c_reg_read_block(cyapa, BL_HEAD_OFFSET,
+ BL_STATUS_SIZE, status);
+ if (ret != BL_STATUS_SIZE)
+ return (ret < 0) ? ret : -EIO;
+ } while ((status[REG_BL_STATUS] & BL_STATUS_BUSY) && --tries);
+
+ /* Ignore WATCHDOG bit and reserved bits. */
+ bl_status = status[REG_BL_STATUS] & ~BL_STATUS_REV_MASK;
+ bl_error = status[REG_BL_ERROR] & ~BL_ERROR_RESERVED;
+
+ if (bl_status & BL_STATUS_BUSY)
+ ret = -ETIMEDOUT;
+ else if (bl_status != BL_STATUS_RUNNING ||
+ bl_error != BL_ERROR_BOOTLOADING)
+ ret = -EIO;
+ else
+ ret = 0;
+
+ return ret;
+}
+
+static int cyapa_gen3_write_blocks(struct cyapa *cyapa,
+ size_t start_block, size_t block_count,
+ const u8 *image_data)
+{
+ int error;
+ int i;
+
+ for (i = 0; i < block_count; i++) {
+ size_t block = start_block + i;
+ size_t addr = i * CYAPA_FW_BLOCK_SIZE;
+ const u8 *data = &image_data[addr];
+
+ error = cyapa_gen3_write_fw_block(cyapa, block, data);
+ if (error)
+ return error;
+ }
+ return 0;
+}
+
+static int cyapa_gen3_do_fw_update(struct cyapa *cyapa,
+ const struct firmware *fw)
+{
+ struct device *dev = &cyapa->client->dev;
+ int error;
+
+ /* First write data, starting at byte 128 of fw->data */
+ error = cyapa_gen3_write_blocks(cyapa,
+ CYAPA_FW_DATA_BLOCK_START, CYAPA_FW_DATA_BLOCK_COUNT,
+ &fw->data[CYAPA_FW_HDR_BLOCK_COUNT * CYAPA_FW_BLOCK_SIZE]);
+ if (error) {
+ dev_err(dev, "FW update aborted, write image: %d\n", error);
+ return error;
+ }
+
+ /* Then write checksum */
+ error = cyapa_gen3_write_blocks(cyapa,
+ CYAPA_FW_HDR_BLOCK_START, CYAPA_FW_HDR_BLOCK_COUNT,
+ &fw->data[0]);
+ if (error) {
+ dev_err(dev, "FW update aborted, write checksum: %d\n", error);
+ return error;
+ }
+
+ return 0;
+}
+
/*
* cyapa_get_wait_time_for_pwr_cmd
*
@@ -791,6 +1073,12 @@ static int cyapa_gen3_irq_handler(struct cyapa *cyapa)
}
const struct cyapa_dev_ops cyapa_gen3_ops = {
+ .check_fw = cyapa_gen3_check_fw,
+ .bl_enter = cyapa_gen3_bl_enter,
+ .bl_activate = cyapa_gen3_bl_activate,
+ .update_fw = cyapa_gen3_do_fw_update,
+ .bl_deactivate = cyapa_gen3_bl_deactivate,
+
.state_parse = cyapa_gen3_state_parse,
.operational_check = cyapa_gen3_do_operational_check,
--
1.9.1
^ permalink raw reply related [flat|nested] 28+ messages in thread
* [PATCH v16 07/12] input: cyapa: add gen3 trackpad device read baseline function support
2014-12-18 10:00 [PATCH v16 00/12] input: cyapa: instruction of cyapa patches Dudley Du
` (5 preceding siblings ...)
2014-12-18 10:00 ` [PATCH v16 06/12] input: cyapa: add gen3 trackpad device firmware update function support Dudley Du
@ 2014-12-18 10:00 ` Dudley Du
2014-12-18 10:00 ` [PATCH v16 08/12] input: cyapa: add gen3 trackpad device force re-calibrate " Dudley Du
` (6 subsequent siblings)
13 siblings, 0 replies; 28+ messages in thread
From: Dudley Du @ 2014-12-18 10:00 UTC (permalink / raw)
To: dmitry.torokhov, jmmahler, rydberg
Cc: Dudley Du, bleung, linux-input, linux-kernel
Add read baseline function supported for gen3 trackpad device,
it can be used through sysfs baseline interface.
TEST=test on Chromebooks.
Signed-off-by: Dudley Du <dudl@cypress.com>
---
drivers/input/mouse/cyapa_gen3.c | 72 ++++++++++++++++++++++++++++++++++++++++
1 file changed, 72 insertions(+)
diff --git a/drivers/input/mouse/cyapa_gen3.c b/drivers/input/mouse/cyapa_gen3.c
index cd4f1db..92b3d6d 100644
--- a/drivers/input/mouse/cyapa_gen3.c
+++ b/drivers/input/mouse/cyapa_gen3.c
@@ -765,6 +765,76 @@ static int cyapa_gen3_do_fw_update(struct cyapa *cyapa,
return 0;
}
+static ssize_t cyapa_gen3_show_baseline(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ struct cyapa *cyapa = dev_get_drvdata(dev);
+ int max_baseline, min_baseline;
+ int tries;
+ int ret;
+
+ ret = cyapa_read_byte(cyapa, CYAPA_CMD_DEV_STATUS);
+ if (ret < 0) {
+ dev_err(dev, "Error reading dev status. err = %d\n", ret);
+ goto out;
+ }
+ if ((ret & CYAPA_DEV_NORMAL) != CYAPA_DEV_NORMAL) {
+ dev_warn(dev, "Trackpad device is busy. device state = 0x%x\n",
+ ret);
+ ret = -EAGAIN;
+ goto out;
+ }
+
+ ret = cyapa_write_byte(cyapa, CYAPA_CMD_SOFT_RESET,
+ OP_REPORT_BASELINE_MASK);
+ if (ret < 0) {
+ dev_err(dev, "Failed to send report baseline command. %d\n",
+ ret);
+ goto out;
+ }
+
+ tries = 3; /* Try for 30 to 60 ms */
+ do {
+ usleep_range(10000, 20000);
+
+ ret = cyapa_read_byte(cyapa, CYAPA_CMD_DEV_STATUS);
+ if (ret < 0) {
+ dev_err(dev, "Error reading dev status. err = %d\n",
+ ret);
+ goto out;
+ }
+ if ((ret & CYAPA_DEV_NORMAL) == CYAPA_DEV_NORMAL)
+ break;
+ } while (--tries);
+
+ if (tries == 0) {
+ dev_err(dev, "Device timed out going to Normal state.\n");
+ ret = -ETIMEDOUT;
+ goto out;
+ }
+
+ ret = cyapa_read_byte(cyapa, CYAPA_CMD_MAX_BASELINE);
+ if (ret < 0) {
+ dev_err(dev, "Failed to read max baseline. err = %d\n", ret);
+ goto out;
+ }
+ max_baseline = ret;
+
+ ret = cyapa_read_byte(cyapa, CYAPA_CMD_MIN_BASELINE);
+ if (ret < 0) {
+ dev_err(dev, "Failed to read min baseline. err = %d\n", ret);
+ goto out;
+ }
+ min_baseline = ret;
+
+ dev_dbg(dev, "Baseline report successful. Max: %d Min: %d\n",
+ max_baseline, min_baseline);
+ ret = scnprintf(buf, PAGE_SIZE, "%d %d\n", max_baseline, min_baseline);
+
+out:
+ return ret;
+}
+
/*
* cyapa_get_wait_time_for_pwr_cmd
*
@@ -1079,6 +1149,8 @@ const struct cyapa_dev_ops cyapa_gen3_ops = {
.update_fw = cyapa_gen3_do_fw_update,
.bl_deactivate = cyapa_gen3_bl_deactivate,
+ .show_baseline = cyapa_gen3_show_baseline,
+
.state_parse = cyapa_gen3_state_parse,
.operational_check = cyapa_gen3_do_operational_check,
--
1.9.1
^ permalink raw reply related [flat|nested] 28+ messages in thread
* [PATCH v16 08/12] input: cyapa: add gen3 trackpad device force re-calibrate function support
2014-12-18 10:00 [PATCH v16 00/12] input: cyapa: instruction of cyapa patches Dudley Du
` (6 preceding siblings ...)
2014-12-18 10:00 ` [PATCH v16 07/12] input: cyapa: add gen3 trackpad device read baseline " Dudley Du
@ 2014-12-18 10:00 ` Dudley Du
2014-12-18 10:00 ` [PATCH v16 09/12] input: cyapa: add gen5 trackpad device firmware update " Dudley Du
` (5 subsequent siblings)
13 siblings, 0 replies; 28+ messages in thread
From: Dudley Du @ 2014-12-18 10:00 UTC (permalink / raw)
To: dmitry.torokhov, jmmahler, rydberg
Cc: Dudley Du, bleung, linux-input, linux-kernel
Add force re-calibrate function supported for gen3 trackpad device,
it can be used through sysfs calibrate interface.
TEST=test on Chromebooks.
Signed-off-by: Dudley Du <dudl@cypress.com>
---
drivers/input/mouse/cyapa_gen3.c | 59 ++++++++++++++++++++++++++++++++++++++++
1 file changed, 59 insertions(+)
diff --git a/drivers/input/mouse/cyapa_gen3.c b/drivers/input/mouse/cyapa_gen3.c
index 92b3d6d..7351fce 100644
--- a/drivers/input/mouse/cyapa_gen3.c
+++ b/drivers/input/mouse/cyapa_gen3.c
@@ -765,6 +765,64 @@ static int cyapa_gen3_do_fw_update(struct cyapa *cyapa,
return 0;
}
+static ssize_t cyapa_gen3_do_calibrate(struct device *dev,
+ struct device_attribute *attr,
+ const char *buf, size_t count)
+{
+ struct cyapa *cyapa = dev_get_drvdata(dev);
+ int tries;
+ int ret;
+
+ ret = cyapa_read_byte(cyapa, CYAPA_CMD_DEV_STATUS);
+ if (ret < 0) {
+ dev_err(dev, "Error reading dev status: %d\n", ret);
+ goto out;
+ }
+ if ((ret & CYAPA_DEV_NORMAL) != CYAPA_DEV_NORMAL) {
+ dev_warn(dev, "Trackpad device is busy, device state: 0x%02x\n",
+ ret);
+ ret = -EAGAIN;
+ goto out;
+ }
+
+ ret = cyapa_write_byte(cyapa, CYAPA_CMD_SOFT_RESET,
+ OP_RECALIBRATION_MASK);
+ if (ret < 0) {
+ dev_err(dev, "Failed to send calibrate command: %d\n",
+ ret);
+ goto out;
+ }
+
+ tries = 20; /* max recalibration timeout 2s. */
+ do {
+ /*
+ * For this recalibration, the max time will not exceed 2s.
+ * The average time is approximately 500 - 700 ms, and we
+ * will check the status every 100 - 200ms.
+ */
+ usleep_range(100000, 200000);
+
+ ret = cyapa_read_byte(cyapa, CYAPA_CMD_DEV_STATUS);
+ if (ret < 0) {
+ dev_err(dev, "Error reading dev status: %d\n",
+ ret);
+ goto out;
+ }
+ if ((ret & CYAPA_DEV_NORMAL) == CYAPA_DEV_NORMAL)
+ break;
+ } while (--tries);
+
+ if (tries == 0) {
+ dev_err(dev, "Failed to calibrate. Timeout.\n");
+ ret = -ETIMEDOUT;
+ goto out;
+ }
+ dev_dbg(dev, "Calibration successful.\n");
+
+out:
+ return ret < 0 ? ret : count;
+}
+
static ssize_t cyapa_gen3_show_baseline(struct device *dev,
struct device_attribute *attr, char *buf)
{
@@ -1150,6 +1208,7 @@ const struct cyapa_dev_ops cyapa_gen3_ops = {
.bl_deactivate = cyapa_gen3_bl_deactivate,
.show_baseline = cyapa_gen3_show_baseline,
+ .calibrate_store = cyapa_gen3_do_calibrate,
.state_parse = cyapa_gen3_state_parse,
.operational_check = cyapa_gen3_do_operational_check,
--
1.9.1
^ permalink raw reply related [flat|nested] 28+ messages in thread
* [PATCH v16 09/12] input: cyapa: add gen5 trackpad device firmware update function support
2014-12-18 10:00 [PATCH v16 00/12] input: cyapa: instruction of cyapa patches Dudley Du
` (7 preceding siblings ...)
2014-12-18 10:00 ` [PATCH v16 08/12] input: cyapa: add gen3 trackpad device force re-calibrate " Dudley Du
@ 2014-12-18 10:00 ` Dudley Du
2014-12-18 10:00 ` [PATCH v16 10/12] input: cyapa: add gen5 trackpad device read baseline " Dudley Du
` (4 subsequent siblings)
13 siblings, 0 replies; 28+ messages in thread
From: Dudley Du @ 2014-12-18 10:00 UTC (permalink / raw)
To: dmitry.torokhov, jmmahler, rydberg
Cc: Dudley Du, bleung, linux-input, linux-kernel
Add firmware image update function supported for gen5 trackpad device,
it can be used through sysfs update_fw interface.
TEST=test on Chromebooks.
Signed-off-by: Dudley Du <dudl@cypress.com>
---
drivers/input/mouse/Kconfig | 1 +
drivers/input/mouse/cyapa_gen5.c | 385 +++++++++++++++++++++++++++++++++++++++
2 files changed, 386 insertions(+)
diff --git a/drivers/input/mouse/Kconfig b/drivers/input/mouse/Kconfig
index d8b46b0..728490e 100644
--- a/drivers/input/mouse/Kconfig
+++ b/drivers/input/mouse/Kconfig
@@ -206,6 +206,7 @@ config MOUSE_BCM5974
config MOUSE_CYAPA
tristate "Cypress APA I2C Trackpad support"
depends on I2C
+ select CRC_ITU_T
help
This driver adds support for Cypress All Points Addressable (APA)
I2C Trackpads, including the ones used in 2012 Samsung Chromebooks.
diff --git a/drivers/input/mouse/cyapa_gen5.c b/drivers/input/mouse/cyapa_gen5.c
index 2ce0149..840f5d6 100644
--- a/drivers/input/mouse/cyapa_gen5.c
+++ b/drivers/input/mouse/cyapa_gen5.c
@@ -18,6 +18,7 @@
#include <linux/completion.h>
#include <linux/slab.h>
#include <linux/unaligned/access_ok.h>
+#include <linux/crc-itu-t.h>
#include "cyapa.h"
@@ -264,6 +265,79 @@ struct cyapa_gen5_report_data {
struct cyapa_gen5_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];
+} __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[0];
+} __packed;
+
+struct gen5_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 gen5_bl_packet_end {
+ __le16 crc;
+ u8 eop; /* End of packet, must be 17h */
+} __packed;
+
+struct gen5_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 gen5_bl_packet_start packet_start;
+ u8 data[0]; /* Command data variable based on commands */
+} __packed;
+
+/* Initiate bootload command data structure. */
+struct gen5_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 gen5_bl_metadata_row_params {
+ __le16 size;
+ __le16 maximun_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 gen5_bl_flash_row_head {
+ u8 flash_array_id;
+ __le16 flash_row_id;
+ u8 flash_data[0];
+} __packed;
+
struct gen5_app_cmd_head {
__le16 addr; /* Output report register address, must be 0004h */
/* Size of packet not including output report register address */
@@ -297,6 +371,10 @@ struct gen5_app_get_parameter_data {
#define GEN5_DEV_UNINIT_SLEEP_TIME(cyapa) \
(((cyapa)->dev_sleep_time) == UNINIT_SLEEP_TIME)
+
+static u8 cyapa_gen5_bl_cmd_key[] = { 0xa5, 0x01, 0x02, 0x03,
+ 0xff, 0xfe, 0xfd, 0x5a };
+
static int cyapa_gen5_initialize(struct cyapa *cyapa)
{
struct cyapa_gen5_cmd_states *gen5_pip = &cyapa->cmd_states.gen5;
@@ -618,6 +696,22 @@ static bool cyapa_gen5_sort_tsg_pip_app_resp_data(struct cyapa *cyapa,
return false;
}
+static bool cyapa_gen5_sort_application_launch_data(struct cyapa *cyapa,
+ u8 *buf, int len)
+{
+ if (buf == NULL || len < GEN5_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_gen5_sort_hid_descriptor_data(struct cyapa *cyapa,
u8 *buf, int len)
{
@@ -923,6 +1017,80 @@ static int cyapa_gen5_state_parse(struct cyapa *cyapa, u8 *reg_data, int len)
return -EAGAIN;
}
+static int cyapa_gen5_bl_initiate(struct cyapa *cyapa,
+ const struct firmware *fw)
+{
+ struct cyapa_tsg_bin_image *image;
+ struct gen5_bl_cmd_head *bl_cmd_head;
+ struct gen5_bl_packet_start *bl_packet_start;
+ struct gen5_bl_initiate_cmd_data *cmd_data;
+ struct gen5_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 gen5_bl_cmd_head *)cmd;
+ cmd_data_len = CYAPA_TSG_BL_KEY_SIZE + CYAPA_TSG_FLASH_MAP_BLOCK_SIZE;
+ cmd_len = sizeof(struct gen5_bl_cmd_head) + cmd_data_len +
+ sizeof(struct gen5_bl_packet_end);
+
+ put_unaligned_le16(GEN5_OUTPUT_REPORT_ADDR, &bl_cmd_head->addr);
+ put_unaligned_le16(cmd_len - 2, &bl_cmd_head->length);
+ bl_cmd_head->report_id = GEN5_BL_CMD_REPORT_ID;
+
+ bl_packet_start = &bl_cmd_head->packet_start;
+ bl_packet_start->sop = GEN5_SOP_KEY;
+ bl_packet_start->cmd_code = GEN5_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 gen5_bl_initiate_cmd_data *)bl_cmd_head->data;
+ memcpy(cmd_data->key, cyapa_gen5_bl_cmd_key, CYAPA_TSG_BL_KEY_SIZE);
+
+ /* Copy 60 bytes Meta Data Row Parameters */
+ image = (struct cyapa_tsg_bin_image *)fw->data;
+ records_num = (fw->size - sizeof(struct cyapa_tsg_bin_image_head)) /
+ sizeof(struct cyapa_tsg_bin_image_data_record);
+ /* 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 gen5_bl_packet_end *)(bl_cmd_head->data +
+ cmd_data_len);
+ cmd_crc = crc_itu_t(0xffff, (u8 *)bl_packet_start,
+ sizeof(struct gen5_bl_packet_start) + cmd_data_len);
+ put_unaligned_le16(cmd_crc, &bl_packet_end->crc);
+ bl_packet_end->eop = GEN5_EOP_KEY;
+
+ resp_len = sizeof(resp_data);
+ error = cyapa_i2c_pip_cmd_irq_sync(cyapa,
+ cmd, cmd_len,
+ resp_data, &resp_len, 12000,
+ cyapa_gen5_sort_tsg_pip_bl_resp_data, true);
+ if (error || resp_len != GEN5_BL_INITIATE_RESP_LEN ||
+ resp_data[2] != GEN5_BL_RESP_REPORT_ID ||
+ !GEN5_CMD_COMPLETE_SUCCESS(resp_data[5]))
+ return error ? error : -EAGAIN;
+
+ return 0;
+}
+
static bool cyapa_gen5_sort_bl_exit_data(struct cyapa *cyapa, u8 *buf, int len)
{
if (buf == NULL || len < GEN5_RESP_LENGTH_SIZE)
@@ -972,6 +1140,218 @@ static int cyapa_gen5_bl_exit(struct cyapa *cyapa)
return -ENODEV;
}
+static int cyapa_gen5_bl_enter(struct cyapa *cyapa)
+{
+ int error;
+ u8 cmd[] = { 0x04, 0x00, 0x05, 0x00, 0x2F, 0x00, 0x01 };
+ u8 resp_data[2];
+ int resp_len;
+
+ error = cyapa_poll_state(cyapa, 500);
+ if (error < 0)
+ return error;
+ if (cyapa->gen != CYAPA_GEN5)
+ return -EINVAL;
+
+ /* Already in Gen5 BL. Skipping exit. */
+ if (cyapa->state == CYAPA_STATE_GEN5_BL)
+ return 0;
+
+ if (cyapa->state != CYAPA_STATE_GEN5_APP)
+ return -EAGAIN;
+
+ /* 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_gen5_sort_application_launch_data,
+ true);
+ if (error || resp_data[0] != 0x00 || resp_data[1] != 0x00)
+ return error < 0 ? error : -EAGAIN;
+
+ cyapa->state = CYAPA_STATE_GEN5_BL;
+ return 0;
+}
+
+static int cyapa_gen5_check_fw(struct cyapa *cyapa, const struct firmware *fw)
+{
+ struct device *dev = &cyapa->client->dev;
+ struct gen5_bl_metadata_row_params metadata;
+ struct cyapa_tsg_bin_image *image;
+ int flash_records_count;
+ u16 app_crc = 0;
+ u16 app_integrity_crc = 0;
+ u16 row_num;
+ u8 *data;
+ int record_index;
+ int i;
+
+ image = (struct cyapa_tsg_bin_image *)fw->data;
+ flash_records_count = (fw->size -
+ sizeof(struct cyapa_tsg_bin_image_head)) /
+ sizeof(struct cyapa_tsg_bin_image_data_record);
+
+ /* APP_INTEGRITY row is always the last row block,
+ * and the row id must be 0x01ff */
+ row_num = get_unaligned_be16(
+ &image->records[flash_records_count - 1].row_number);
+ if (image->records[flash_records_count - 1].flash_array_id != 0x00 &&
+ row_num != 0x01ff) {
+ dev_err(dev, "%s: invalid app_integrity data.\n", __func__);
+ return -EINVAL;
+ }
+ data = image->records[flash_records_count - 1].record_data;
+
+ metadata.app_start = get_unaligned_le32(&data[4]);
+ metadata.app_len = get_unaligned_le16(&data[8]);
+ metadata.app_crc = get_unaligned_le16(&data[10]);
+ metadata.upgrade_start = get_unaligned_le32(&data[16]);
+ metadata.upgrade_len = get_unaligned_le16(&data[20]);
+ metadata.metadata_crc = get_unaligned_le16(&data[60]);
+
+ if ((metadata.app_start + metadata.app_len +
+ metadata.upgrade_start + metadata.upgrade_len) %
+ CYAPA_TSG_FW_ROW_SIZE) {
+ dev_err(dev, "%s: invalid image alignment.\n", __func__);
+ return -EINVAL;
+ }
+
+ /* Verify app_integrity crc */
+ app_integrity_crc = crc_itu_t(0xffff, data,
+ CYAPA_TSG_APP_INTEGRITY_SIZE);
+ if (app_integrity_crc != metadata.metadata_crc) {
+ dev_err(dev, "%s: invalid app_integrity crc.\n", __func__);
+ return -EINVAL;
+ }
+
+ /*
+ * Verify application image CRC
+ */
+ record_index = metadata.app_start / CYAPA_TSG_FW_ROW_SIZE -
+ CYAPA_TSG_IMG_START_ROW_NUM;
+ data = (u8 *)&image->records[record_index].record_data;
+ app_crc = crc_itu_t(0xffff, data, CYAPA_TSG_FW_ROW_SIZE);
+ for (i = 1; i < (metadata.app_len / CYAPA_TSG_FW_ROW_SIZE); i++) {
+ data = (u8 *)&image->records[++record_index].record_data;
+ app_crc = crc_itu_t(app_crc, data, CYAPA_TSG_FW_ROW_SIZE);
+ }
+
+ if (app_crc != metadata.app_crc) {
+ dev_err(dev, "%s: invalid firmware app crc check.\n", __func__);
+ return -EINVAL;
+ }
+
+ return 0;
+}
+
+static int cyapa_gen5_write_fw_block(struct cyapa *cyapa,
+ struct cyapa_tsg_bin_image_data_record *flash_record)
+{
+ struct gen5_bl_cmd_head *bl_cmd_head;
+ struct gen5_bl_packet_start *bl_packet_start;
+ struct gen5_bl_flash_row_head *flash_row_head;
+ struct gen5_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 gen5_bl_cmd_head *)cmd;
+ bl_packet_start = &bl_cmd_head->packet_start;
+ cmd_len = sizeof(struct gen5_bl_cmd_head) +
+ sizeof(struct gen5_bl_flash_row_head) +
+ CYAPA_TSG_FLASH_MAP_BLOCK_SIZE +
+ sizeof(struct gen5_bl_packet_end);
+
+ put_unaligned_le16(GEN5_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 = GEN5_BL_CMD_REPORT_ID;
+ bl_packet_start->sop = GEN5_SOP_KEY;
+ bl_packet_start->cmd_code = GEN5_BL_CMD_PROGRAM_VERIFY_ROW;
+
+ /* 1 (Flash Array ID) + 2 (Flash Row ID) + 128 (flash data) */
+ data_len = sizeof(struct gen5_bl_flash_row_head) + record_len;
+ put_unaligned_le16(data_len, &bl_packet_start->data_length);
+
+ flash_row_head = (struct gen5_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 gen5_bl_packet_end *)(bl_cmd_head->data +
+ data_len);
+ crc = crc_itu_t(0xffff, (u8 *)bl_packet_start,
+ sizeof(struct gen5_bl_packet_start) + data_len);
+ put_unaligned_le16(crc, &bl_packet_end->crc);
+ bl_packet_end->eop = GEN5_EOP_KEY;
+
+ resp_len = sizeof(resp_data);
+ error = cyapa_i2c_pip_cmd_irq_sync(cyapa, cmd, cmd_len,
+ resp_data, &resp_len,
+ 500, cyapa_gen5_sort_tsg_pip_bl_resp_data, true);
+ if (error || resp_len != GEN5_BL_BLOCK_WRITE_RESP_LEN ||
+ resp_data[2] != GEN5_BL_RESP_REPORT_ID ||
+ !GEN5_CMD_COMPLETE_SUCCESS(resp_data[5]))
+ return error < 0 ? error : -EAGAIN;
+
+ return 0;
+}
+
+static int cyapa_gen5_do_fw_update(struct cyapa *cyapa,
+ const struct firmware *fw)
+{
+ struct device *dev = &cyapa->client->dev;
+ struct cyapa_tsg_bin_image *image =
+ (struct cyapa_tsg_bin_image *)fw->data;
+ struct cyapa_tsg_bin_image_data_record *flash_record;
+ int flash_records_count;
+ int i;
+ int error;
+
+ cyapa_empty_pip_output_data(cyapa, NULL, NULL, NULL);
+
+ flash_records_count =
+ (fw->size - sizeof(struct cyapa_tsg_bin_image_head)) /
+ sizeof(struct cyapa_tsg_bin_image_data_record);
+ /*
+ * 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++) {
+ flash_record = &image->records[i];
+ error = cyapa_gen5_write_fw_block(cyapa, flash_record);
+ 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 };
@@ -1665,6 +2045,11 @@ static int cyapa_gen5_irq_handler(struct cyapa *cyapa)
}
const struct cyapa_dev_ops cyapa_gen5_ops = {
+ .check_fw = cyapa_gen5_check_fw,
+ .bl_enter = cyapa_gen5_bl_enter,
+ .bl_initiate = cyapa_gen5_bl_initiate,
+ .update_fw = cyapa_gen5_do_fw_update,
+
.initialize = cyapa_gen5_initialize,
.state_parse = cyapa_gen5_state_parse,
--
1.9.1
^ permalink raw reply related [flat|nested] 28+ messages in thread
* [PATCH v16 10/12] input: cyapa: add gen5 trackpad device read baseline function support
2014-12-18 10:00 [PATCH v16 00/12] input: cyapa: instruction of cyapa patches Dudley Du
` (8 preceding siblings ...)
2014-12-18 10:00 ` [PATCH v16 09/12] input: cyapa: add gen5 trackpad device firmware update " Dudley Du
@ 2014-12-18 10:00 ` Dudley Du
2014-12-18 10:00 ` [PATCH v16 11/12] input: cyapa: add gen5 trackpad device force re-calibrate " Dudley Du
` (3 subsequent siblings)
13 siblings, 0 replies; 28+ messages in thread
From: Dudley Du @ 2014-12-18 10:00 UTC (permalink / raw)
To: dmitry.torokhov, jmmahler, rydberg
Cc: Dudley Du, bleung, linux-input, linux-kernel
Add read baseline function supported for gen5 trackpad device,
it can be used through sysfs baseline interface.
TEST=test on Chromebooks.
Signed-off-by: Dudley Du <dudl@cypress.com>
---
drivers/input/mouse/cyapa.h | 2 +
drivers/input/mouse/cyapa_gen5.c | 640 +++++++++++++++++++++++++++++++++++++++
2 files changed, 642 insertions(+)
diff --git a/drivers/input/mouse/cyapa.h b/drivers/input/mouse/cyapa.h
index 922a473..e5de0b2 100644
--- a/drivers/input/mouse/cyapa.h
+++ b/drivers/input/mouse/cyapa.h
@@ -276,6 +276,8 @@ struct cyapa {
u8 y_origin; /* Y Axis Origin: 0 = top; 1 = bottom. */
int electrodes_x; /* Number of electrodes on the X Axis*/
int electrodes_y; /* Number of electrodes on the Y Axis*/
+ int electrodes_rx; /* Number of Rx electrodes */
+ int aligned_electrodes_rx; /* 4 aligned */
int max_z;
/*
diff --git a/drivers/input/mouse/cyapa_gen5.c b/drivers/input/mouse/cyapa_gen5.c
index 840f5d6..2b800e3 100644
--- a/drivers/input/mouse/cyapa_gen5.c
+++ b/drivers/input/mouse/cyapa_gen5.c
@@ -363,6 +363,12 @@ 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;
+
/* Variables to record latest gen5 trackpad power states. */
#define GEN5_DEV_SET_PWR_STATE(cyapa, s) ((cyapa)->dev_pwr_mode = (s))
#define GEN5_DEV_GET_PWR_STATE(cyapa) ((cyapa)->dev_pwr_mode)
@@ -1659,6 +1665,638 @@ static int cyapa_gen5_set_power_mode(struct cyapa *cyapa,
return 0;
}
+static int cyapa_gen5_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_gen5_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;
+}
+
+static int cyapa_gen5_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_gen5_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 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 raed 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 gen5_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 != GEN5_CMD_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 if (idac_data_type == GEN5_RETRIEVE_SELF_CAP_PWC_DATA) {
+ 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 gen5_app_cmd_head *)cmd;
+ put_unaligned_le16(GEN5_OUTPUT_REPORT_ADDR, &cmd_head->addr);
+ put_unaligned_le16(sizeof(cmd) - 2, &cmd_head->length);
+ cmd_head->report_id = GEN5_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_gen5_sort_tsg_pip_app_resp_data,
+ true);
+ if (error || resp_len < GEN5_RESP_DATA_STRUCTURE_OFFSET ||
+ !VALID_CMD_RESP_HEADER(resp_data, cmd_code) ||
+ !GEN5_CMD_COMPLETE_SUCCESS(resp_data[5]) ||
+ 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 betwen 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 error;
+ int data_size;
+
+ *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,
+ GEN5_CMD_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,
+ GEN5_CMD_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 error;
+ int data_size;
+
+ *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,
+ GEN5_CMD_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,
+ GEN5_CMD_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 gen5_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 gen5_app_cmd_head *)cmd;
+ put_unaligned_le16(GEN5_OUTPUT_REPORT_ADDR, &app_cmd_head->addr);
+ put_unaligned_le16(sizeof(cmd) - 2, &app_cmd_head->length);
+ app_cmd_head->report_id = GEN5_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_gen5_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) ||
+ !GEN5_CMD_COMPLETE_SUCCESS(resp_data[5]))
+ 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 gen5_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 gen5_app_cmd_head *)cmd;
+ put_unaligned_le16(GEN5_OUTPUT_REPORT_ADDR, &app_cmd_head->addr);
+ put_unaligned_le16(sizeof(cmd) - 2, &app_cmd_head->length);
+ app_cmd_head->report_id = GEN5_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_gen5_sort_tsg_pip_app_resp_data, true);
+ if (error || resp_len < GEN5_RESP_DATA_STRUCTURE_OFFSET ||
+ !VALID_CMD_RESP_HEADER(resp_data, cmd_code) ||
+ !GEN5_CMD_COMPLETE_SUCCESS(resp_data[5]) ||
+ 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->state != CYAPA_STATE_GEN5_APP)
+ return -EBUSY;
+
+ /* 1. Suspend Scanning*/
+ error = cyapa_gen5_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. Execuate 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_gen5_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;
+}
+
static bool cyapa_gen5_sort_system_info_data(struct cyapa *cyapa,
u8 *buf, int len)
{
@@ -2050,6 +2688,8 @@ const struct cyapa_dev_ops cyapa_gen5_ops = {
.bl_initiate = cyapa_gen5_bl_initiate,
.update_fw = cyapa_gen5_do_fw_update,
+ .show_baseline = cyapa_gen5_show_baseline,
+
.initialize = cyapa_gen5_initialize,
.state_parse = cyapa_gen5_state_parse,
--
1.9.1
^ permalink raw reply related [flat|nested] 28+ messages in thread
* [PATCH v16 11/12] input: cyapa: add gen5 trackpad device force re-calibrate function support
2014-12-18 10:00 [PATCH v16 00/12] input: cyapa: instruction of cyapa patches Dudley Du
` (9 preceding siblings ...)
2014-12-18 10:00 ` [PATCH v16 10/12] input: cyapa: add gen5 trackpad device read baseline " Dudley Du
@ 2014-12-18 10:00 ` Dudley Du
2014-12-18 10:00 ` [PATCH v16 12/12] input: cyapa: add acpi device id support Dudley Du
` (2 subsequent siblings)
13 siblings, 0 replies; 28+ messages in thread
From: Dudley Du @ 2014-12-18 10:00 UTC (permalink / raw)
To: dmitry.torokhov, jmmahler, rydberg
Cc: Dudley Du, bleung, linux-input, linux-kernel
Add force re-calibrate function supported for gen5 trackpad device,
it can be used through sysfs calibrate interface.
TEST=test on Chromebooks.
Signed-off-by: Dudley Du <dudl@cypress.com>
---
drivers/input/mouse/cyapa_gen5.c | 65 ++++++++++++++++++++++++++++++++++++++++
1 file changed, 65 insertions(+)
diff --git a/drivers/input/mouse/cyapa_gen5.c b/drivers/input/mouse/cyapa_gen5.c
index 2b800e3..4bb6f34 100644
--- a/drivers/input/mouse/cyapa_gen5.c
+++ b/drivers/input/mouse/cyapa_gen5.c
@@ -1713,6 +1713,70 @@ static int cyapa_gen5_suspend_scanning(struct cyapa *cyapa)
return 0;
}
+static int cyapa_gen5_calibrate_pwcs(struct cyapa *cyapa,
+ u8 calibrate_sensing_mode_type)
+{
+ struct gen5_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 gen5_app_cmd_head *)cmd;
+ put_unaligned_le16(GEN5_OUTPUT_REPORT_ADDR, &app_cmd_head->addr);
+ put_unaligned_le16(sizeof(cmd) - 2, &app_cmd_head->length);
+ app_cmd_head->report_id = GEN5_APP_CMD_REPORT_ID;
+ app_cmd_head->cmd_code = GEN5_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_gen5_sort_tsg_pip_app_resp_data, true);
+ if (error || !VALID_CMD_RESP_HEADER(resp_data, GEN5_CMD_CALIBRATE) ||
+ !GEN5_CMD_COMPLETE_SUCCESS(resp_data[5]))
+ return error < 0 ? error : -EAGAIN;
+
+ return 0;
+}
+
+static ssize_t cyapa_gen5_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_gen5_suspend_scanning(cyapa);
+ if (error)
+ return error;
+
+ /* 2. Do mutual capacitance fine calibrate. */
+ calibrate_error = cyapa_gen5_calibrate_pwcs(cyapa,
+ CYAPA_SENSING_MODE_MUTUAL_CAP_FINE);
+ if (calibrate_error)
+ goto resume_scanning;
+
+ /* 3. Do self capacitance calibrate. */
+ calibrate_error = cyapa_gen5_calibrate_pwcs(cyapa,
+ CYAPA_SENSING_MODE_SELF_CAP);
+ if (calibrate_error)
+ goto resume_scanning;
+
+resume_scanning:
+ /* 4. Resume Scanning*/
+ error = cyapa_gen5_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))
@@ -2689,6 +2753,7 @@ const struct cyapa_dev_ops cyapa_gen5_ops = {
.update_fw = cyapa_gen5_do_fw_update,
.show_baseline = cyapa_gen5_show_baseline,
+ .calibrate_store = cyapa_gen5_do_calibrate,
.initialize = cyapa_gen5_initialize,
--
1.9.1
^ permalink raw reply related [flat|nested] 28+ messages in thread
* [PATCH v16 12/12] input: cyapa: add acpi device id support
2014-12-18 10:00 [PATCH v16 00/12] input: cyapa: instruction of cyapa patches Dudley Du
` (10 preceding siblings ...)
2014-12-18 10:00 ` [PATCH v16 11/12] input: cyapa: add gen5 trackpad device force re-calibrate " Dudley Du
@ 2014-12-18 10:00 ` Dudley Du
2014-12-18 11:06 ` [PATCH v16 00/12] input: cyapa: instruction of cyapa patches Dudley Du
2014-12-20 7:15 ` Jeremiah Mahler
13 siblings, 0 replies; 28+ messages in thread
From: Dudley Du @ 2014-12-18 10:00 UTC (permalink / raw)
To: dmitry.torokhov, jmmahler, rydberg
Cc: Dudley Du, bleung, linux-input, linux-kernel
Add acpi device tree support.
acpi device id "CYAP0000" is for old gen3 trackpad devices.
acpi device id "CYAP0001" is for new gen5 trackpad devices.
TEST=test on Chromebooks.
Signed-off-by: Dudley Du <dudl@cypress.com>
---
drivers/input/mouse/cyapa.c | 13 +++++++++++++
1 file changed, 13 insertions(+)
diff --git a/drivers/input/mouse/cyapa.c b/drivers/input/mouse/cyapa.c
index 406f38b..62ef19a 100644
--- a/drivers/input/mouse/cyapa.c
+++ b/drivers/input/mouse/cyapa.c
@@ -24,6 +24,7 @@
#include <linux/slab.h>
#include <linux/uaccess.h>
#include <linux/pm_runtime.h>
+#include <linux/acpi.h>
#include "cyapa.h"
@@ -1315,11 +1316,23 @@ static const struct i2c_device_id cyapa_id_table[] = {
};
MODULE_DEVICE_TABLE(i2c, cyapa_id_table);
+#ifdef CONFIG_ACPI
+static const struct acpi_device_id cyapa_acpi_id[] = {
+ { "CYAP0000", 0 }, /* Gen3 trackpad with 0x67 I2C address. */
+ { "CYAP0001", 0 }, /* Gen5 trackpad with 0x24 I2C address. */
+ { }
+};
+MODULE_DEVICE_TABLE(acpi, cyapa_acpi_id);
+#endif
+
static struct i2c_driver cyapa_driver = {
.driver = {
.name = "cyapa",
.owner = THIS_MODULE,
.pm = &cyapa_pm_ops,
+#ifdef CONFIG_ACPI
+ .acpi_match_table = ACPI_PTR(cyapa_acpi_id),
+#endif
},
.probe = cyapa_probe,
--
1.9.1
^ permalink raw reply related [flat|nested] 28+ messages in thread
* RE: [PATCH v16 00/12] input: cyapa: instruction of cyapa patches
2014-12-18 10:00 [PATCH v16 00/12] input: cyapa: instruction of cyapa patches Dudley Du
` (11 preceding siblings ...)
2014-12-18 10:00 ` [PATCH v16 12/12] input: cyapa: add acpi device id support Dudley Du
@ 2014-12-18 11:06 ` Dudley Du
2014-12-18 20:17 ` Benson Leung
2014-12-18 22:14 ` Jeremiah Mahler
2014-12-20 7:15 ` Jeremiah Mahler
13 siblings, 2 replies; 28+ messages in thread
From: Dudley Du @ 2014-12-18 11:06 UTC (permalink / raw)
To: Dudley Du, dmitry.torokhov, jmmahler, rydberg
Cc: bleung, David Solda, linux-input, linux-kernel
Jeremiah,
I re-sent the v16 patches through the new internal email server with my emal dudl@cypress.com.
Could you help check if all patches were fine and not broken.
Thanks,
Dudley
> -----Original Message-----
> From: Dudley Du [mailto:dudl@cypress.com]
> Sent: 2014?12?18? 18:01
> To: dmitry.torokhov@gmail.com; jmmahler@gmail.com; rydberg@euromail.se
> Cc: Dudley Du; bleung@google.com; David Solda; linux-input@vger.kernel.org;
> linux-kernel@vger.kernel.org
> Subject: [PATCH v16 00/12] input: cyapa: instruction of cyapa patches
>
> V16 patches have below updates, details of other updates see history list:
> 1) Fix all miss-spelling and space issue.
> 2) Rename variables and functions with much more clearer names.
> 3) Initialize and document tries near where it will be used.
> 4) Modify cmd buffer to struct for more descriptive way.
>
>
> This patch series is aimed to re-design the cyapa driver to support
> old gen3 trackpad devices and new gen5 trackpad devices in one
> cyapa driver, it's for easily productions support based on
> customers' requirements. And add sysfs functions and interfaces
> supported that required by users and customers.
>
> Since the earlier gen3 and the latest gen5 trackpad devices using
> two different chipsets, and have different protocols and interfaces,
> so if supported these two type trackpad devices in two different drivers,
> then it will be difficult to manage productions and later firmware updates.
> e.g.: It will cause customer don't know which one trackpad device firmware
> image to use and update when it has been used and integrated
> in same one productions, so here we support these two trackpad
> devices in same on driver.
>
>
> Dudley Du (12):
> input: cyapa: re-design driver to support multi-trackpad in one driver
> input: cyapa: add gen5 trackpad device basic functions support
> input: cyapa: add power management interfaces support for the device
> input: cyapa: add runtime power management interfaces support for the
> device
> input: cyapa: add sysfs interfaces support in the cyapa driver
> input: cyapa: add gen3 trackpad device firmware update function
> support
> input: cyapa: add gen3 trackpad device read baseline function support
> input: cyapa: add gen3 trackpad device force re-calibrate function
> support
> input: cyapa: add gen5 trackpad device firmware update function
> support
> input: cyapa: add gen5 trackpad device read baseline function support
> input: cyapa: add gen5 trackpad device force re-calibrate function
> support
> input: cyapa: add acpi device id support
>
> drivers/input/mouse/Kconfig | 1 +
> drivers/input/mouse/Makefile | 3 +-
> drivers/input/mouse/cyapa.c | 1692 ++++++++++++++---------
> drivers/input/mouse/cyapa.h | 314 +++++
> drivers/input/mouse/cyapa_gen3.c | 1220 +++++++++++++++++
> drivers/input/mouse/cyapa_gen5.c | 2767
> ++++++++++++++++++++++++++++++++++++++
> 6 files changed, 5325 insertions(+), 672 deletions(-)
> create mode 100644 drivers/input/mouse/cyapa.h
> create mode 100644 drivers/input/mouse/cyapa_gen3.c
> create mode 100644 drivers/input/mouse/cyapa_gen5.c
>
>
> History patch series modifications list:
> V15 patches have below main updates compared with v14 patches:
> 1) Fix all warning errors of sparse tool when running with "make C=1".
> 2) Change variable name "unique_str" to "product_id" for clearer meanings.
> 3) Update cyapa_i2c_write function to return error directly when length > 31.
>
> V14 patches have below main updates compared with v13 patches:
> 1) Correct 9 miss spelling issues of "bufferred" to "buffered".
> 2) Fix the upgrade issue of removing MOUSE_CYAPA config when make oldconfig
> by replase "depends on I2C && CRC_ITU_T" with
> "depends on I2C"
> "select CRC_ITU_T"
> in patch 9.
>
> V13 patches have below main updates compared with v12 patches:
> 1) Remove all debugfs interface, including read_fw and raw_data interfaces.
> 2) This patches are made based linux next-20141208.
>
> V12 patches have below main updates compared with v11 patches:
> 1) Add check that when TP is detected but not operational, do not exit driver
> immediately, but wait and export the update_fw interface for recovering.
> 2) Re-arrange the function codes, remove unnesseary protype definitions in
> the header file.
>
> V11 patches have below main updates compared with v10 patches:
> 1) Add add acpi device id supported for old gen3 and new gen5 trackpad devices.
> 2) Fix the unable to update firmware issue when cyapa_open is not called
> which means the irq for firwmare update process is not enabled. This fix
> by checking if the irq is enabled, if not then enable irq before start to
> do firmware update.
>
> V10 patches have below main updates compared with v9 patches:
> 1) Modify code to following kernel code style.
> e.g.: correct to use error as return name when there is only error path,
> and fix the checkpatch.sh wanting in the driver.
> 2) Remove cyapa_remove method and use input open and close interface to
> following device resouse management infrastructure.
> 3) Modify cyapa_detect method to return tristate issue to make the return value
> much more consistent and clear.
> 4) Use platform supplied functions as possible instead of driver
> specific rewritten version.
>
> V9 patches have below updates compared with v8 patches:
> 1) Removed all async thread stuff from the driver.
> 2) Split driver into 18 patches for each function change one patch.
>
> V8 patches have below updates compared with v7 patches:
> 1) [PATCH v8 01/13] - Remove the async thread for device detect in
> probe routine, now the device detect process is completely done within
> the device probe routine.
> 2) [PATCH v8 01/13] - Split the irq cmd hander function to separated
> function cyapa_default_irq_cmd_handler() and set it to interface
> cyapa_default_ops.irq_cmd_handler.
> 3) [PATCH v8 06/13] - Add cyapa->gen check in cyapa_gen3_irq_cmd_handler()
> to avoid miss-enter when device protocol is still in detecting.
>
> V7 patches have below updates compared with v6 patches:
> 1) [PATCH v7 01/13] - Split the irq cmd hander function to separated
> function cyapa_default_irq_cmd_handler() and set it to interface
> cyapa_default_ops.irq_cmd_handler.
> 2) [PATCH v7 06/13] - Add cyapa->gen check in cyapa_gen3_irq_cmd_handler()
> to avoid miss-enter when device protocol is still in detecting.
>
>
> V6 patches have below updates compared with v5 patches:
> 1) Remove patch 14 of the lid filtering from the cyapa driver.
>
> V5 patches have below updates compared with v4 patches:
> 1) Uses get_device()/put_device() instead of kobject_get()/kobject_put();
> 2) Fix memories freed before debugfs entries issue;
> 3) Make cyapa_debugs_root valid in driver module level
> in module_init()/moudle_exit() ;
> 4) Fix i2c_transfer() may return partial transfer issues.
> 5) Add cyapa->removed flag to avoid detecting thread may still running
> when driver module is removed.
> 6) Fix the meanings of some comments and return error code not clear issue.
This message and any attachments may contain Cypress (or its subsidiaries) confidential information. If it has been received in error, please advise the sender and immediately delete this message.
^ permalink raw reply [flat|nested] 28+ messages in thread
* Re: [PATCH v16 00/12] input: cyapa: instruction of cyapa patches
2014-12-18 11:06 ` [PATCH v16 00/12] input: cyapa: instruction of cyapa patches Dudley Du
@ 2014-12-18 20:17 ` Benson Leung
2014-12-18 22:14 ` Jeremiah Mahler
1 sibling, 0 replies; 28+ messages in thread
From: Benson Leung @ 2014-12-18 20:17 UTC (permalink / raw)
To: Dudley Du
Cc: dmitry.torokhov, jmmahler, rydberg, David Solda, linux-input,
linux-kernel
Hi Dudley,
On Thu, Dec 18, 2014 at 3:06 AM, Dudley Du <dudl@cypress.com> wrote:
> Jeremiah,
>
> I re-sent the v16 patches through the new internal email server with my emal dudl@cypress.com.
> Could you help check if all patches were fine and not broken.
I tried applying your patches onto dtor's input branch master, and it
applied clean for me. Thanks!
--
Benson Leung
Software Engineer, Chrome OS
Google Inc.
bleung@google.com
^ permalink raw reply [flat|nested] 28+ messages in thread
* Re: [PATCH v16 00/12] input: cyapa: instruction of cyapa patches
2014-12-18 11:06 ` [PATCH v16 00/12] input: cyapa: instruction of cyapa patches Dudley Du
2014-12-18 20:17 ` Benson Leung
@ 2014-12-18 22:14 ` Jeremiah Mahler
2014-12-19 1:45 ` Dudley Du
1 sibling, 1 reply; 28+ messages in thread
From: Jeremiah Mahler @ 2014-12-18 22:14 UTC (permalink / raw)
To: Dudley Du
Cc: dmitry.torokhov, rydberg, bleung, David Solda, linux-input, linux-kernel
Dudley,
On Thu, Dec 18, 2014 at 11:06:40AM +0000, Dudley Du wrote:
> Jeremiah,
>
> I re-sent the v16 patches through the new internal email server with my emal dudl@cypress.com.
> Could you help check if all patches were fine and not broken.
>
> Thanks,
> Dudley
>
[...]
These patches apply without any problems.
I will have a look and review them again.
--
- Jeremiah Mahler
^ permalink raw reply [flat|nested] 28+ messages in thread
* RE: [PATCH v16 00/12] input: cyapa: instruction of cyapa patches
2014-12-18 22:14 ` Jeremiah Mahler
@ 2014-12-19 1:45 ` Dudley Du
0 siblings, 0 replies; 28+ messages in thread
From: Dudley Du @ 2014-12-19 1:45 UTC (permalink / raw)
To: Jeremiah Mahler
Cc: dmitry.torokhov, rydberg, bleung, David Solda, linux-input, linux-kernel
Benson, Jeremiah,
Thank you for the help and confirm.
Dudley
> -----Original Message-----
> From: Jeremiah Mahler [mailto:jmmahler@gmail.com]
> Sent: 2014?12?19? 6:14
> To: Dudley Du
> Cc: dmitry.torokhov@gmail.com; rydberg@euromail.se; bleung@google.com;
> David Solda; linux-input@vger.kernel.org; linux-kernel@vger.kernel.org
> Subject: Re: [PATCH v16 00/12] input: cyapa: instruction of cyapa patches
>
> Dudley,
>
> On Thu, Dec 18, 2014 at 11:06:40AM +0000, Dudley Du wrote:
> > Jeremiah,
> >
> > I re-sent the v16 patches through the new internal email server with my emal
> dudl@cypress.com.
> > Could you help check if all patches were fine and not broken.
> >
> > Thanks,
> > Dudley
> >
> [...]
>
> These patches apply without any problems.
>
> I will have a look and review them again.
>
> --
> - Jeremiah Mahler
This message and any attachments may contain Cypress (or its subsidiaries) confidential information. If it has been received in error, please advise the sender and immediately delete this message.
^ permalink raw reply [flat|nested] 28+ messages in thread
* Re: [PATCH v16 00/12] input: cyapa: instruction of cyapa patches
2014-12-18 10:00 [PATCH v16 00/12] input: cyapa: instruction of cyapa patches Dudley Du
` (12 preceding siblings ...)
2014-12-18 11:06 ` [PATCH v16 00/12] input: cyapa: instruction of cyapa patches Dudley Du
@ 2014-12-20 7:15 ` Jeremiah Mahler
2014-12-20 7:31 ` Dmitry Torokhov
13 siblings, 1 reply; 28+ messages in thread
From: Jeremiah Mahler @ 2014-12-20 7:15 UTC (permalink / raw)
To: Dudley Du
Cc: dmitry.torokhov, rydberg, bleung, dso, linux-input, linux-kernel
Dudley,
On Thu, Dec 18, 2014 at 06:00:44PM +0800, Dudley Du wrote:
> V16 patches have below updates, details of other updates see history list:
[...]
This version has problems. I am getting an oops (below) and then things
quit working and usually my machine hangs.
[ 2.388284] input: HDA Intel PCH Headphone as /devices/pci0000:00/0000:00:1b.0/sound/card1/input10
[ 2.412938] FS-Cache: Netfs 'nfs' registered for caching
[ 2.427645] [drm] Initialized i915 1.6.0 20141121 for 0000:00:02.0 on minor 0
[ 2.428320] __add_probed_i2c_device failed to register device 1-4a
[ 2.428331] platform chromeos_laptop: Driver chromeos_laptop requests probe deferral
[ 2.429126] fbcon: inteldrmfb (fb0) is primary device
[ 2.449066] BUG: unable to handle kernel NULL pointer dereference at 0000000000000160
[ 2.449073] IP: [<ffffffff813f7b2b>] input_mt_sync_frame+0xb/0x60
[ 2.449075] PGD 0
[ 2.449077] Oops: 0000 [#1] SMP
[ 2.449112] Modules linked in: ath9k_hw auth_rpcgss oid_registry nfs_acl nfs ath mac80211 lockd i915 tpm_infineon grace cyapatp(+) crc_itu_t fscache iTCO_wdt sunrpc iTCO_vendor_support crct10dif_pclmul crc32_pclmul crc32c_intel cfg80211 chromeos_laptop ghash_clmulni_intel cryptd snd_hda_codec_realtek snd_hda_codec_generic i2c_algo_bit snd_hda_intel rfkill snd_hda_controller xhci_pci evdev snd_hda_codec serio_raw xhci_hcd pcspkr drm_kms_helper snd_hwdep snd_pcm i2c_i801 usbcore snd_timer snd shpchp i2c_designware_pci lpc_ich i2c_designware_core mfd_core drm usb_common soundcore tpm_tis battery tpm ac video i2c_core processor button fuse autofs4 ext4 crc16 mbcache jbd2 sg sd_mod sdhci_acpi sdhci mmc_core ahci thermal libahci libata scsi_mod fan thermal_sys
[ 2.449115] CPU: 0 PID: 448 Comm: irq/37-cyapa Not tainted 3.18.0-next-20141219+ #157
[ 2.449116] Hardware name: Acer Peppy, BIOS 04/30/2014
[ 2.449117] task: ffff8800364e6310 ti: ffff880068c9c000 task.ti: ffff880068c9c000
[ 2.449121] RIP: 0010:[<ffffffff813f7b2b>] [<ffffffff813f7b2b>] input_mt_sync_frame+0xb/0x60
[ 2.449122] RSP: 0018:ffff880068c9fd88 EFLAGS: 00010296
[ 2.449123] RAX: 0000000000000003 RBX: ffff88007050ac20 RCX: 0000000000000000
[ 2.449124] RDX: 0000000000000083 RSI: ffff880068c9fd6a RDI: 0000000000000000
[ 2.449125] RBP: 0000000000000000 R08: 0000000000000000 R09: 0000000000000001
[ 2.449126] R10: 000000000000007c R11: 0000000000000067 R12: ffff88007050ac20
[ 2.449127] R13: ffff880072fb2c18 R14: ffffffff810bd230 R15: ffff8800364e6310
[ 2.449128] FS: 0000000000000000(0000) GS:ffff880100200000(0000) knlGS:0000000000000000
[ 2.449129] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
[ 2.449130] CR2: 0000000000000160 CR3: 00000000749a9000 CR4: 00000000000407f0
[ 2.449131] Stack:
[ 2.449134] 0000000000000000 ffff88007050ac20 0000000000000000 ffffffffa03f2c59
[ 2.449135] 0008830000000092 0000000000000000 0000000000000000 0000000000000000
[ 2.449137] ffff88007541d000 ffff880072fb2c18 ffff88007050ac00 ffff88007050ac20
[ 2.449138] Call Trace:
[ 2.449146] [<ffffffffa03f2c59>] ? cyapa_gen3_irq_handler+0x119/0x200 [cyapatp]
[ 2.449151] [<ffffffffa03f1502>] ? cyapa_irq+0xb2/0x120 [cyapatp]
[ 2.449155] [<ffffffff810bd24b>] ? irq_thread_fn+0x1b/0x40
[ 2.449157] [<ffffffff810bd81b>] ? irq_thread+0x13b/0x160
[ 2.449160] [<ffffffff810bd310>] ? wake_threads_waitq+0x40/0x40
[ 2.449162] [<ffffffff810bd6e0>] ? irq_thread_check_affinity+0xb0/0xb0
[ 2.449165] [<ffffffff81089013>] ? kthread+0xd3/0xf0
[ 2.449168] [<ffffffff81088f40>] ? kthread_create_on_node+0x1a0/0x1a0
[ 2.449172] [<ffffffff8154583c>] ? ret_from_fork+0x7c/0xb0
[ 2.449174] [<ffffffff81088f40>] ? kthread_create_on_node+0x1a0/0x1a0
[ 2.449193] Code: 0f 1f 44 00 00 53 48 8b 9f 60 01 00 00 48 85 db 74 0c 48 89 de e8 76 ff ff ff 83 43 10 01 5b c3 0f 1f 44 00 00 55 53 48 83 ec 08 <48> 8b 9f 60 01 00 00 48 85 db 74 24 f6 43 0c 04 48 89 fd 75 28
[ 2.449195] RIP [<ffffffff813f7b2b>] input_mt_sync_frame+0xb/0x60
[ 2.449196] RSP <ffff880068c9fd88>
[ 2.449197] CR2: 0000000000000160
[ 2.449199] ---[ end trace 3561783fbbc1b06d ]---
[ 2.449211] BUG: unable to handle kernel paging request at ffffffffffffffc8
[ 2.449214] IP: [<ffffffff8108966c>] kthread_data+0xc/0x20
[ 2.449216] PGD 1816067 PUD 1818067 PMD 0
[ 2.449217] Oops: 0000 [#2] SMP
[ 2.449243] Modules linked in: ath9k_hw auth_rpcgss oid_registry nfs_acl nfs ath mac80211 lockd i915 tpm_infineon grace cyapatp(+) crc_itu_t fscache iTCO_wdt sunrpc iTCO_vendor_support crct10dif_pclmul crc32_pclmul crc32c_intel cfg80211 chromeos_laptop ghash_clmulni_intel cryptd snd_hda_codec_realtek snd_hda_codec_generic i2c_algo_bit snd_hda_intel rfkill snd_hda_controller xhci_pci evdev snd_hda_codec serio_raw xhci_hcd pcspkr drm_kms_helper snd_hwdep snd_pcm i2c_i801 usbcore snd_timer snd shpchp i2c_designware_pci lpc_ich i2c_designware_core mfd_core drm usb_common soundcore tpm_tis battery tpm ac video i2c_core processor button fuse autofs4 ext4 crc16 mbcache jbd2 sg sd_mod sdhci_acpi sdhci mmc_core ahci thermal libahci libata scsi_mod fan thermal_sys
[ 2.449245] CPU: 0 PID: 448 Comm: irq/37-cyapa Tainted: G D 3.18.0-next-20141219+ #157
[ 2.449246] Hardware name: Acer Peppy, BIOS 04/30/2014
[ 2.449247] task: ffff8800364e6310 ti: ffff880068c9c000 task.ti: ffff880068c9c000
[ 2.449250] RIP: 0010:[<ffffffff8108966c>] [<ffffffff8108966c>] kthread_data+0xc/0x20
[ 2.449251] RSP: 0018:ffff880068c9fa70 EFLAGS: 00010202
[ 2.449252] RAX: 0000000000000000 RBX: ffff8800364e6310 RCX: 000000000000000d
[ 2.449253] RDX: 0000000000000000 RSI: 000000000000000d RDI: ffff8800364e6310
[ 2.449254] RBP: ffffffff81a8ac30 R08: ffff880068c9ff28 R09: 0000000000000024
[ 2.449254] R10: ffffffff81a9ab30 R11: 000000000001463c R12: ffff8800364e6998
[ 2.449255] R13: ffff8800364e6310 R14: 0000000000000001 R15: 0000000000030001
[ 2.449256] FS: 0000000000000000(0000) GS:ffff880100200000(0000) knlGS:0000000000000000
[ 2.449257] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
[ 2.449258] CR2: ffffffffffffffc8 CR3: 00000000749a9000 CR4: 00000000000407f0
[ 2.449258] Stack:
[ 2.449260] ffffffff810bd33b ffff8800364e6310 0000000000000000 ffffffff81a8ac30
[ 2.449262] ffffffff81087707 ffff8800364e69c8 ffff8800364e6310 ffff880068c9faf8
[ 2.449264] ffff880068c9fcd8 0000000000000000 ffffffff8106e41d 0000000000030001
[ 2.449264] Call Trace:
[ 2.449267] [<ffffffff810bd33b>] ? irq_thread_dtor+0x2b/0xc0
[ 2.449269] [<ffffffff81087707>] ? task_work_run+0xa7/0xe0
[ 2.449271] [<ffffffff8106e41d>] ? do_exit+0x2ed/0xac0
[ 2.449276] [<ffffffff810178e6>] ? oops_end+0x96/0xe0
[ 2.449280] [<ffffffff8105b016>] ? no_context+0x106/0x380
[ 2.449283] [<ffffffff8105b77e>] ? __do_page_fault+0xae/0x550
[ 2.449289] [<ffffffffa01ae871>] ? i2c_transfer+0x81/0xd0 [i2c_core]
[ 2.449294] [<ffffffffa01aea7e>] ? i2c_smbus_xfer_emulated+0x11e/0x550 [i2c_core]
[ 2.449297] [<ffffffff810bd230>] ? irq_finalize_oneshot.part.30+0xd0/0xd0
[ 2.449301] [<ffffffff815479e8>] ? page_fault+0x28/0x30
[ 2.449303] [<ffffffff810bd230>] ? irq_finalize_oneshot.part.30+0xd0/0xd0
[ 2.449305] [<ffffffff813f7b2b>] ? input_mt_sync_frame+0xb/0x60
[ 2.449310] [<ffffffffa03f2c59>] ? cyapa_gen3_irq_handler+0x119/0x200 [cyapatp]
[ 2.449314] [<ffffffffa03f1502>] ? cyapa_irq+0xb2/0x120 [cyapatp]
[ 2.449316] [<ffffffff810bd24b>] ? irq_thread_fn+0x1b/0x40
[ 2.449318] [<ffffffff810bd81b>] ? irq_thread+0x13b/0x160
[ 2.449320] [<ffffffff810bd310>] ? wake_threads_waitq+0x40/0x40
[ 2.449322] [<ffffffff810bd6e0>] ? irq_thread_check_affinity+0xb0/0xb0
[ 2.449324] [<ffffffff81089013>] ? kthread+0xd3/0xf0
[ 2.449327] [<ffffffff81088f40>] ? kthread_create_on_node+0x1a0/0x1a0
[ 2.449329] [<ffffffff8154583c>] ? ret_from_fork+0x7c/0xb0
[ 2.449331] [<ffffffff81088f40>] ? kthread_create_on_node+0x1a0/0x1a0
[ 2.449349] Code: 40 04 00 00 48 8b 40 b8 48 c1 e8 02 83 e0 01 c3 66 66 66 66 66 66 2e 0f 1f 84 00 00 00 00 00 0f 1f 44 00 00 48 8b 87 40 04 00 00 <48> 8b 40 c8 c3 66 66 66 66 66 66 2e 0f 1f 84 00 00 00 00 00 0f
[ 2.449351] RIP [<ffffffff8108966c>] kthread_data+0xc/0x20
[ 2.449351] RSP <ffff880068c9fa70>
[ 2.449352] CR2: ffffffffffffffc8
[ 2.449353] ---[ end trace 3561783fbbc1b06e ]---
[ 2.449353] Fixing recursive fault but reboot is needed!
[ 2.467991] Installing knfsd (copyright (C) 1996 okir@monad.swb.de).
[ 2.471174] usb 1-3: new high-speed USB device number 2 using xhci_hcd
[ 2.486523] ath: phy0: ASPM enabled: 0x43
[ 2.486525] ath: EEPROM regdomain: 0x6c
[ 2.486526] ath: EEPROM indicates we should expect a direct regpair map
[ 2.486528] ath: Country alpha2 being used: 00
[ 2.486528] ath: Regpair used: 0x6c
[ 2.488258] cfg80211: World regulatory domain updated:
[ 2.488260] cfg80211: DFS Master region: unset
--
- Jeremiah Mahler
^ permalink raw reply [flat|nested] 28+ messages in thread
* Re: [PATCH v16 00/12] input: cyapa: instruction of cyapa patches
2014-12-20 7:15 ` Jeremiah Mahler
@ 2014-12-20 7:31 ` Dmitry Torokhov
2014-12-22 2:09 ` Dudley Du
0 siblings, 1 reply; 28+ messages in thread
From: Dmitry Torokhov @ 2014-12-20 7:31 UTC (permalink / raw)
To: Jeremiah Mahler, Dudley Du, rydberg, bleung, dso, linux-input,
linux-kernel
On Fri, Dec 19, 2014 at 11:15:33PM -0800, Jeremiah Mahler wrote:
> Dudley,
>
> On Thu, Dec 18, 2014 at 06:00:44PM +0800, Dudley Du wrote:
> > V16 patches have below updates, details of other updates see history list:
> [...]
>
> This version has problems. I am getting an oops (below) and then things
> quit working and usually my machine hangs.
>
> [ 2.388284] input: HDA Intel PCH Headphone as /devices/pci0000:00/0000:00:1b.0/sound/card1/input10
> [ 2.412938] FS-Cache: Netfs 'nfs' registered for caching
> [ 2.427645] [drm] Initialized i915 1.6.0 20141121 for 0000:00:02.0 on minor 0
> [ 2.428320] __add_probed_i2c_device failed to register device 1-4a
> [ 2.428331] platform chromeos_laptop: Driver chromeos_laptop requests probe deferral
> [ 2.429126] fbcon: inteldrmfb (fb0) is primary device
> [ 2.449066] BUG: unable to handle kernel NULL pointer dereference at 0000000000000160
> [ 2.449073] IP: [<ffffffff813f7b2b>] input_mt_sync_frame+0xb/0x60
Sounds like we got an interrupts before we had a chance to initialize
input device...
Thanks.
--
Dmitry
^ permalink raw reply [flat|nested] 28+ messages in thread
* RE: [PATCH v16 00/12] input: cyapa: instruction of cyapa patches
2014-12-20 7:31 ` Dmitry Torokhov
@ 2014-12-22 2:09 ` Dudley Du
2014-12-22 2:39 ` Dmitry Torokhov
0 siblings, 1 reply; 28+ messages in thread
From: Dudley Du @ 2014-12-22 2:09 UTC (permalink / raw)
To: Dmitry Torokhov, Jeremiah Mahler, rydberg, bleung, David Solda,
linux-input, linux-kernel
Thanks, Dmitry and Jeremiah,
I reproduced this issue in my side when putting fingers on trackpad when system booting up.
It only happened on gen3 trackpad device.
The root cause is, for gen3 TP, the cyapa->ops->sort_empty_output_data is not set, so when cyapa->input is not set,
the interrupt process should be passed, but since the logica error, it's not, so this issue happen.
The fix code should be as below.
I will correct it and resubmited the patches.
Code to fix this issue.
@@ -585,9 +585,10 @@ static irqreturn_t cyapa_irq(int irq, void *dev_id)
/* Interrupt event maybe from trackpad device input reporting. */
if (cont && cyapa->ops->irq_handler) {
/* Still in probling or in firware image udpating or reading. */
- if (!cyapa->input && cyapa->ops->sort_empty_output_data) {
- cyapa->ops->sort_empty_output_data(cyapa,
- NULL, NULL, NULL);
+ if (!cyapa->input) {
+ if (cyapa->ops->sort_empty_output_data)
+ cyapa->ops->sort_empty_output_data(cyapa,
+ NULL, NULL, NULL);
goto out;
}
Thanks,
Dudley
> -----Original Message-----
> From: Dmitry Torokhov [mailto:dmitry.torokhov@gmail.com]
> Sent: 2014?12?20? 15:32
> To: Jeremiah Mahler; Dudley Du; rydberg@euromail.se; bleung@google.com;
> David Solda; linux-input@vger.kernel.org; linux-kernel@vger.kernel.org
> Subject: Re: [PATCH v16 00/12] input: cyapa: instruction of cyapa patches
>
> On Fri, Dec 19, 2014 at 11:15:33PM -0800, Jeremiah Mahler wrote:
> > Dudley,
> >
> > On Thu, Dec 18, 2014 at 06:00:44PM +0800, Dudley Du wrote:
> > > V16 patches have below updates, details of other updates see history list:
> > [...]
> >
> > This version has problems. I am getting an oops (below) and then things
> > quit working and usually my machine hangs.
> >
> > [ 2.388284] input: HDA Intel PCH Headphone as
> /devices/pci0000:00/0000:00:1b.0/sound/card1/input10
> > [ 2.412938] FS-Cache: Netfs 'nfs' registered for caching
> > [ 2.427645] [drm] Initialized i915 1.6.0 20141121 for 0000:00:02.0 on minor 0
> > [ 2.428320] __add_probed_i2c_device failed to register device 1-4a
> > [ 2.428331] platform chromeos_laptop: Driver chromeos_laptop requests
> probe deferral
> > [ 2.429126] fbcon: inteldrmfb (fb0) is primary device
> > [ 2.449066] BUG: unable to handle kernel NULL pointer dereference at
> 0000000000000160
> > [ 2.449073] IP: [<ffffffff813f7b2b>] input_mt_sync_frame+0xb/0x60
>
> Sounds like we got an interrupts before we had a chance to initialize
> input device...
>
> Thanks.
>
> --
> Dmitry
This message and any attachments may contain Cypress (or its subsidiaries) confidential information. If it has been received in error, please advise the sender and immediately delete this message.
^ permalink raw reply [flat|nested] 28+ messages in thread
* Re: [PATCH v16 00/12] input: cyapa: instruction of cyapa patches
2014-12-22 2:09 ` Dudley Du
@ 2014-12-22 2:39 ` Dmitry Torokhov
2014-12-22 2:56 ` Dudley Du
0 siblings, 1 reply; 28+ messages in thread
From: Dmitry Torokhov @ 2014-12-22 2:39 UTC (permalink / raw)
To: Dudley Du
Cc: Jeremiah Mahler, rydberg, bleung, David Solda, linux-input, linux-kernel
Hi Dudley,
On Mon, Dec 22, 2014 at 02:09:36AM +0000, Dudley Du wrote:
> Thanks, Dmitry and Jeremiah,
>
> I reproduced this issue in my side when putting fingers on trackpad when system booting up.
> It only happened on gen3 trackpad device.
> The root cause is, for gen3 TP, the cyapa->ops->sort_empty_output_data is not set, so when cyapa->input is not set,
> the interrupt process should be passed, but since the logica error, it's not, so this issue happen.
>
> The fix code should be as below.
> I will correct it and resubmited the patches.
Please hold off resubmitting the patches just yet, let me go over the
last version you posted.
Thanks!
--
Dmitry
^ permalink raw reply [flat|nested] 28+ messages in thread
* RE: [PATCH v16 00/12] input: cyapa: instruction of cyapa patches
2014-12-22 2:39 ` Dmitry Torokhov
@ 2014-12-22 2:56 ` Dudley Du
0 siblings, 0 replies; 28+ messages in thread
From: Dudley Du @ 2014-12-22 2:56 UTC (permalink / raw)
To: Dmitry Torokhov
Cc: Jeremiah Mahler, rydberg, bleung, David Solda, linux-input, linux-kernel
Got it.
Thanks, Dmitry.
Dudley
> -----Original Message-----
> From: Dmitry Torokhov [mailto:dmitry.torokhov@gmail.com]
> Sent: 2014?12?22? 10:40
> To: Dudley Du
> Cc: Jeremiah Mahler; rydberg@euromail.se; bleung@google.com; David Solda;
> linux-input@vger.kernel.org; linux-kernel@vger.kernel.org
> Subject: Re: [PATCH v16 00/12] input: cyapa: instruction of cyapa patches
>
> Hi Dudley,
>
> On Mon, Dec 22, 2014 at 02:09:36AM +0000, Dudley Du wrote:
> > Thanks, Dmitry and Jeremiah,
> >
> > I reproduced this issue in my side when putting fingers on trackpad when system
> booting up.
> > It only happened on gen3 trackpad device.
> > The root cause is, for gen3 TP, the cyapa->ops->sort_empty_output_data is not
> set, so when cyapa->input is not set,
> > the interrupt process should be passed, but since the logica error, it's not, so this
> issue happen.
> >
> > The fix code should be as below.
> > I will correct it and resubmited the patches.
>
> Please hold off resubmitting the patches just yet, let me go over the
> last version you posted.
>
> Thanks!
>
>
> --
> Dmitry
This message and any attachments may contain Cypress (or its subsidiaries) confidential information. If it has been received in error, please advise the sender and immediately delete this message.
^ permalink raw reply [flat|nested] 28+ messages in thread
* Re: [PATCH v16 03/12] input: cyapa: add power management interfaces support for the device
2014-12-18 10:00 ` [PATCH v16 03/12] input: cyapa: add power management interfaces support for the device Dudley Du
@ 2014-12-30 0:51 ` Dmitry Torokhov
0 siblings, 0 replies; 28+ messages in thread
From: Dmitry Torokhov @ 2014-12-30 0:51 UTC (permalink / raw)
To: Dudley Du; +Cc: jmmahler, rydberg, bleung, linux-input, linux-kernel
Hi Dudley,
On Thu, Dec 18, 2014 at 06:00:47PM +0800, Dudley Du wrote:
> Add suspend_scanrate_ms power management interfaces in device's
> power group, so users or applications can control the power management
> strategy of trackpad device as their requirements.
> TEST=test on Chromebooks.
>
> Signed-off-by: Dudley Du <dudl@cypress.com>
> ---
> drivers/input/mouse/cyapa.c | 111 ++++++++++++++++++++++++++++++++++++++++++++
> 1 file changed, 111 insertions(+)
>
> diff --git a/drivers/input/mouse/cyapa.c b/drivers/input/mouse/cyapa.c
> index d4560a3..73f6817 100644
> --- a/drivers/input/mouse/cyapa.c
> +++ b/drivers/input/mouse/cyapa.c
> @@ -575,6 +575,96 @@ out:
> return IRQ_HANDLED;
> }
>
> +/*
> + **************************************************************
> + * sysfs interface
> + **************************************************************
> +*/
> +#ifdef CONFIG_PM_SLEEP
> +static ssize_t cyapa_show_suspend_scanrate(struct device *dev,
> + struct device_attribute *attr,
> + char *buf)
> +{
> + struct cyapa *cyapa = dev_get_drvdata(dev);
> + u8 pwr_cmd = cyapa->suspend_power_mode;
> + u16 sleep_time;
> + int len;
> + int error;
> +
> + error = mutex_lock_interruptible(&cyapa->state_sync_lock);
> + if (error)
> + return error;
> + pwr_cmd = cyapa->suspend_power_mode;
> + sleep_time = cyapa->suspend_sleep_time;
> + mutex_unlock(&cyapa->state_sync_lock);
> +
> + if (pwr_cmd == PWR_MODE_BTN_ONLY) {
> + len = scnprintf(buf, PAGE_SIZE, "%s\n", BTN_ONLY_MODE_NAME);
> + } else if (pwr_cmd == PWR_MODE_OFF) {
> + len = scnprintf(buf, PAGE_SIZE, "%s\n", OFF_MODE_NAME);
> + } else {
> + if (cyapa->gen == CYAPA_GEN3)
> + sleep_time = cyapa_pwr_cmd_to_sleep_time(pwr_cmd);
> + len = scnprintf(buf, PAGE_SIZE, "%u\n", sleep_time);
> + }
> +
> + return len;
> +}
> +
> +static ssize_t cyapa_update_suspend_scanrate(struct device *dev,
> + struct device_attribute *attr,
> + const char *buf, size_t count)
> +{
> + struct cyapa *cyapa = dev_get_drvdata(dev);
> + u16 sleep_time;
> + int error;
> +
> + error = mutex_lock_interruptible(&cyapa->state_sync_lock);
> + if (error)
> + return error;
> +
> + if (sysfs_streq(buf, BTN_ONLY_MODE_NAME)) {
> + cyapa->suspend_power_mode = PWR_MODE_BTN_ONLY;
> + } else if (sysfs_streq(buf, OFF_MODE_NAME)) {
> + cyapa->suspend_power_mode = PWR_MODE_OFF;
> + } else if (!kstrtou16(buf, 10, &sleep_time)) {
> + cyapa->suspend_sleep_time = max_t(u16, sleep_time, 1000);
> + cyapa->suspend_power_mode =
> + cyapa_sleep_time_to_pwr_cmd(cyapa->suspend_sleep_time);
> + } else {
> + count = 0;
> + }
> +
> + mutex_unlock(&cyapa->state_sync_lock);
> +
> + if (!count)
> + dev_err(dev, "invalid suspend scanrate ms parameters\n");
I'd rather we just return -EINVAL and not display the message so as to
not fill the logs.
> + return count ? count : -EINVAL;
> +}
> +
> +static DEVICE_ATTR(suspend_scanrate_ms, S_IRUGO|S_IWUSR,
> + cyapa_show_suspend_scanrate,
> + cyapa_update_suspend_scanrate);
> +
> +static struct attribute *cyapa_power_wakeup_entries[] = {
> + &dev_attr_suspend_scanrate_ms.attr,
> + NULL,
> +};
> +
> +static const struct attribute_group cyapa_power_wakeup_group = {
> + .name = power_group_name,
> + .attrs = cyapa_power_wakeup_entries,
> +};
> +
> +static void cyapa_remove_power_wakeup_group(void *data)
> +{
> + struct cyapa *cyapa = data;
> +
> + sysfs_unmerge_group(&cyapa->client->dev.kobj,
> + &cyapa_power_wakeup_group);
> +}
> +#endif /* CONFIG_PM_SLEEP */
> +
> static int cyapa_probe(struct i2c_client *client,
> const struct i2c_device_id *dev_id)
> {
> @@ -614,6 +704,27 @@ static int cyapa_probe(struct i2c_client *client,
> return error;
> }
>
> +#ifdef CONFIG_PM_SLEEP
> + if (device_can_wakeup(dev)) {
> + error = sysfs_merge_group(&client->dev.kobj,
> + &cyapa_power_wakeup_group);
> + if (error) {
> + dev_err(dev, "failed to add power wakeup group: %d\n",
> + error);
> + return error;
> + }
> +
> + error = devm_add_action(dev,
> + cyapa_remove_power_wakeup_group, cyapa);
> + if (error) {
> + cyapa_remove_power_wakeup_group(cyapa);
> + dev_err(dev, "failed to add power cleanup action: %d\n",
> + error);
> + return error;
> + }
> + }
> +#endif /* CONFIG_PM_SLEEP */
Please split out this code into cyapa_prepare_wakeup_controls() and
provide a stub for !CONFIG_PM_SLEEP. We are trying to avoid #ifdefs in
the middle of fucntion body.
Thanks!
> +
> error = devm_request_threaded_irq(dev, client->irq,
> NULL, cyapa_irq,
> IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
> --
> 1.9.1
>
--
Dmitry
^ permalink raw reply [flat|nested] 28+ messages in thread
* Re: [PATCH v16 04/12] input: cyapa: add runtime power management interfaces support for the device
2014-12-18 10:00 ` [PATCH v16 04/12] input: cyapa: add runtime " Dudley Du
@ 2014-12-30 0:57 ` Dmitry Torokhov
0 siblings, 0 replies; 28+ messages in thread
From: Dmitry Torokhov @ 2014-12-30 0:57 UTC (permalink / raw)
To: Dudley Du; +Cc: jmmahler, rydberg, bleung, linux-input, linux-kernel
Hi Dudley,
On Thu, Dec 18, 2014 at 06:00:48PM +0800, Dudley Du wrote:
> Add runtime_suspend_scanrate_ms power management interfaces in device's
> power group, so users or applications can control the runtime power
> management strategy of trackpad device as their requirements.
> TEST=test on Chromebooks.
>
> Signed-off-by: Dudley Du <dudl@cypress.com>
> ---
> drivers/input/mouse/cyapa.c | 171 +++++++++++++++++++++++++++++++++++++++++++-
> drivers/input/mouse/cyapa.h | 4 ++
> 2 files changed, 174 insertions(+), 1 deletion(-)
>
> diff --git a/drivers/input/mouse/cyapa.c b/drivers/input/mouse/cyapa.c
> index 73f6817..3bcfce3 100644
> --- a/drivers/input/mouse/cyapa.c
> +++ b/drivers/input/mouse/cyapa.c
> @@ -23,6 +23,7 @@
> #include <linux/mutex.h>
> #include <linux/slab.h>
> #include <linux/uaccess.h>
> +#include <linux/pm_runtime.h>
> #include "cyapa.h"
>
>
> @@ -327,6 +328,8 @@ static int cyapa_open(struct input_dev *input)
> }
>
> enable_irq(client->irq);
> + pm_runtime_set_active(&client->dev);
> + pm_runtime_enable(&client->dev);
> out:
> mutex_unlock(&cyapa->state_sync_lock);
> return error;
> @@ -340,8 +343,10 @@ static void cyapa_close(struct input_dev *input)
> mutex_lock(&cyapa->state_sync_lock);
>
> disable_irq(client->irq);
> + pm_runtime_disable(&client->dev);
> if (!CYAPA_BOOTLOADER(cyapa) && cyapa->ops->set_power_mode)
> cyapa->ops->set_power_mode(cyapa, PWR_MODE_OFF, 0);
> + pm_runtime_set_suspended(&client->dev);
>
> mutex_unlock(&cyapa->state_sync_lock);
> }
> @@ -542,6 +547,7 @@ static irqreturn_t cyapa_irq(int irq, void *dev_id)
> struct device *dev = &cyapa->client->dev;
> bool cont;
>
> + pm_runtime_get_sync(dev);
> if (device_may_wakeup(dev))
> pm_wakeup_event(dev, 0);
>
> @@ -572,6 +578,8 @@ static irqreturn_t cyapa_irq(int irq, void *dev_id)
> }
>
> out:
> + pm_runtime_mark_last_busy(dev);
> + pm_runtime_put_sync_autosuspend(dev);
> return IRQ_HANDLED;
> }
>
> @@ -665,6 +673,116 @@ static void cyapa_remove_power_wakeup_group(void *data)
> }
> #endif /* CONFIG_PM_SLEEP */
>
> +#ifdef CONFIG_PM_RUNTIME
> +static ssize_t cyapa_show_rt_suspend_scanrate(struct device *dev,
> + struct device_attribute *attr,
> + char *buf)
> +{
> + struct cyapa *cyapa = dev_get_drvdata(dev);
> + u8 pwr_cmd;
> + u16 sleep_time;
> + int error;
> +
> + error = mutex_lock_interruptible(&cyapa->state_sync_lock);
> + if (error)
> + return error;
> + pwr_cmd = cyapa->runtime_suspend_power_mode;
> + sleep_time = cyapa->runtime_suspend_sleep_time;
> + mutex_unlock(&cyapa->state_sync_lock);
> +
> + if (cyapa->gen == CYAPA_GEN3)
> + return scnprintf(buf, PAGE_SIZE, "%u\n",
> + cyapa_pwr_cmd_to_sleep_time(pwr_cmd));
> + return scnprintf(buf, PAGE_SIZE, "%u\n", sleep_time);
> +}
> +
> +static ssize_t cyapa_update_rt_suspend_scanrate(struct device *dev,
> + struct device_attribute *attr,
> + const char *buf, size_t count)
> +{
> + struct cyapa *cyapa = dev_get_drvdata(dev);
> + u16 time;
> + int error;
> +
> + if (buf == NULL || count == 0 || kstrtou16(buf, 10, &time)) {
> + dev_err(dev, "invalid runtime suspend scanrate ms parameter\n");
> + return -EINVAL;
> + }
> +
> + /*
> + * When the suspend scanrate is changed, pm_runtime_get to resume
> + * a potentially suspended device, update to the new pwr_cmd
> + * and then pm_runtime_put to suspend into the new power mode.
> + */
> + pm_runtime_get_sync(dev);
> + error = mutex_lock_interruptible(&cyapa->state_sync_lock);
> + if (error)
> + return error;
> + cyapa->runtime_suspend_sleep_time = max_t(u16, time, 1000);
> + cyapa->runtime_suspend_power_mode =
> + cyapa_sleep_time_to_pwr_cmd(cyapa->runtime_suspend_sleep_time);
> + mutex_unlock(&cyapa->state_sync_lock);
> + pm_runtime_put_sync_autosuspend(dev);
> +
> + return count;
> +}
> +
> +static DEVICE_ATTR(runtime_suspend_scanrate_ms, S_IRUGO|S_IWUSR,
> + cyapa_show_rt_suspend_scanrate,
> + cyapa_update_rt_suspend_scanrate);
> +
> +static struct attribute *cyapa_power_runtime_entries[] = {
> + &dev_attr_runtime_suspend_scanrate_ms.attr,
> + NULL,
> +};
> +
> +static const struct attribute_group cyapa_power_runtime_group = {
> + .name = power_group_name,
> + .attrs = cyapa_power_runtime_entries,
> +};
> +
> +static void cyapa_remove_power_runtime_group(void *data)
> +{
> + struct cyapa *cyapa = data;
> +
> + sysfs_unmerge_group(&cyapa->client->dev.kobj,
> + &cyapa_power_runtime_group);
> +}
> +
> +static int cyapa_start_runtime(struct cyapa *cyapa)
> +{
> + struct device *dev = &cyapa->client->dev;
> + int error;
> +
> + cyapa->runtime_suspend_power_mode = PWR_MODE_IDLE;
> + cyapa->runtime_suspend_sleep_time =
> + cyapa_pwr_cmd_to_sleep_time(cyapa->runtime_suspend_power_mode);
> +
> + error = sysfs_merge_group(&dev->kobj, &cyapa_power_runtime_group);
> + if (error) {
> + dev_err(dev,
> + "failed to create power runtime group: %d\n", error);
> + return error;
> + }
> +
> + error = devm_add_action(dev, cyapa_remove_power_runtime_group, cyapa);
> + if (error) {
> + cyapa_remove_power_runtime_group(cyapa);
> + dev_err(dev,
> + "failed to add power runtime cleanup action: %d\n",
> + error);
> + return error;
> + }
> +
> + /* runtime is enabled until device is operational and opened. */
> + pm_runtime_set_suspended(dev);
> + pm_runtime_use_autosuspend(dev);
> + pm_runtime_set_autosuspend_delay(dev, AUTOSUSPEND_DELAY);
> +
> + return 0;
> +}
> +#endif /* CONFIG_PM_RUNTIME */
> +
> static int cyapa_probe(struct i2c_client *client,
> const struct i2c_device_id *dev_id)
> {
> @@ -725,6 +843,14 @@ static int cyapa_probe(struct i2c_client *client,
> }
> #endif /* CONFIG_PM_SLEEP */
>
> +#ifdef CONFIG_PM_RUNTIME
> + error = cyapa_start_runtime(cyapa);
> + if (error) {
> + dev_err(dev, "failed to start pm_runtime: %d\n", error);
> + return error;
> + }
> +#endif /* CONFIG_PM_RUNTIME */
Instead of using #ifdef here please provide a stub cyapa_start_runtime()
for cases when !CONFIG_PM_RUNTIME.
> +
> error = devm_request_threaded_irq(dev, client->irq,
> NULL, cyapa_irq,
> IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
> @@ -765,6 +891,7 @@ static int __maybe_unused cyapa_suspend(struct device *dev)
> if (error)
> return error;
>
> + pm_runtime_disable(dev);
> disable_irq(client->irq);
>
> /*
> @@ -781,6 +908,8 @@ static int __maybe_unused cyapa_suspend(struct device *dev)
> error);
> }
>
> + pm_runtime_set_suspended(dev);
> +
I do not believe we should be touching runtime suspend state during
system state transition.
> if (device_may_wakeup(dev))
> cyapa->irq_wake = (enable_irq_wake(client->irq) == 0);
>
> @@ -801,17 +930,57 @@ static int __maybe_unused cyapa_resume(struct device *dev)
> cyapa->irq_wake = false;
> }
>
> + pm_runtime_set_active(dev);
> +
> error = cyapa_reinitialize(cyapa);
> if (error)
> dev_warn(dev, "failed to reinitialize TP device: %d\n", error);
>
> enable_irq(client->irq);
>
> + pm_runtime_enable(dev);
> +
> mutex_unlock(&cyapa->state_sync_lock);
> return 0;
> }
>
> -static SIMPLE_DEV_PM_OPS(cyapa_pm_ops, cyapa_suspend, cyapa_resume);
> +#ifdef CONFIG_PM_RUNTIME
> +static int cyapa_runtime_suspend(struct device *dev)
> +{
> + struct cyapa *cyapa = dev_get_drvdata(dev);
> + int error;
> +
> + if (!CYAPA_BOOTLOADER(cyapa) && cyapa->ops->set_power_mode) {
Why do we need to check bootloader state? I'd rather we did not enable
runtime PM until we make sure device is out of bootloader.
> + error = cyapa->ops->set_power_mode(cyapa,
> + cyapa->runtime_suspend_power_mode,
> + cyapa->runtime_suspend_sleep_time);
> + if (error)
> + dev_warn(dev, "runtime suspend failed: %d\n", error);
> + }
> +
> + return 0;
> +}
> +
> +static int cyapa_runtime_resume(struct device *dev)
> +{
> + struct cyapa *cyapa = dev_get_drvdata(dev);
> + int error;
> +
> + if (!CYAPA_BOOTLOADER(cyapa) && cyapa->ops->set_power_mode) {
> + error = cyapa->ops->set_power_mode(cyapa,
> + PWR_MODE_FULL_ACTIVE, 0);
> + if (error)
> + dev_warn(dev, "runtime resume failed: %d\n", error);
> + }
> +
> + return 0;
> +}
> +#endif /* CONFIG_PM_RUNTIME */
> +
> +static const struct dev_pm_ops cyapa_pm_ops = {
> + SET_SYSTEM_SLEEP_PM_OPS(cyapa_suspend, cyapa_resume)
> + SET_RUNTIME_PM_OPS(cyapa_runtime_suspend, cyapa_runtime_resume, NULL)
> +};
>
> static const struct i2c_device_id cyapa_id_table[] = {
> { "cyapa", 0 },
> diff --git a/drivers/input/mouse/cyapa.h b/drivers/input/mouse/cyapa.h
> index 4c09be4..922a473 100644
> --- a/drivers/input/mouse/cyapa.h
> +++ b/drivers/input/mouse/cyapa.h
> @@ -253,6 +253,10 @@ struct cyapa {
> /* power mode settings */
> u8 suspend_power_mode;
> u16 suspend_sleep_time;
> +#ifdef CONFIG_PM_RUNTIME
> + u8 runtime_suspend_power_mode;
> + u16 runtime_suspend_sleep_time;
> +#endif /* CONFIG_PM_RUNTIME */
> u8 dev_pwr_mode;
> u16 dev_sleep_time;
>
> --
> 1.9.1
>
--
Dmitry
^ permalink raw reply [flat|nested] 28+ messages in thread
* Re: [PATCH v16 01/12] input: cyapa: re-design driver to support multi-trackpad in one driver
2014-12-18 10:00 ` [PATCH v16 01/12] input: cyapa: re-design driver to support multi-trackpad in one driver Dudley Du
@ 2014-12-30 1:06 ` Dmitry Torokhov
2014-12-30 4:43 ` Dudley Du
0 siblings, 1 reply; 28+ messages in thread
From: Dmitry Torokhov @ 2014-12-30 1:06 UTC (permalink / raw)
To: Dudley Du; +Cc: jmmahler, rydberg, bleung, linux-input, linux-kernel
Hi Dudley,
On Thu, Dec 18, 2014 at 06:00:45PM +0800, Dudley Du wrote:
> In order to support multiple different chipsets and communication protocols
> trackpad devices in one cyapa driver, the new cyapa driver is re-designed
> with one cyapa driver core and multiple device specific functions component.
> The cyapa driver core is contained in this patch, it supplies basic functions
> that working with kernel and input subsystem, and also supplies the interfaces
> that the specific devices' component can connect and work together with as
> one driver.
> TEST=test on Chromebooks.
Thank you for making changes to the driver. It shapes up nicely, still
I have a few comments:
1. I'd rather we did not check for presence of various methods in ops
structure but rather rely on providers to supply stubs if they do not
need actual implementation (see a draft of a patch below).
2. Please consider changing CYAPA_BOOTLOADER() and friends to be static
inline functions (like cyapa_is_bootloader_mode())- it provides better
type checking.
3. The ops->initialize() method should be called after we determine the
generation of the device, not before.
4. I wonder why cyapa_read_block() is in gen3 file and not in main file
- it seems it is used by generic code?
5. Is bootloader mode different between gen3 and gen5 devices? Or should
you detect and handle bootloader mode directly in the core, maybe as a
"fake generation"?
Thanks!
>
> Signed-off-by: Dudley Du <dudl@cypress.com>
> ---
> drivers/input/mouse/Makefile | 3 +-
> drivers/input/mouse/cyapa.c | 1047 ++++++++++++++------------------------
> drivers/input/mouse/cyapa.h | 307 +++++++++++
> drivers/input/mouse/cyapa_gen3.c | 801 +++++++++++++++++++++++++++++
> 4 files changed, 1492 insertions(+), 666 deletions(-)
> create mode 100644 drivers/input/mouse/cyapa.h
> create mode 100644 drivers/input/mouse/cyapa_gen3.c
>
> diff --git a/drivers/input/mouse/Makefile b/drivers/input/mouse/Makefile
> index 560003d..8bd950d 100644
> --- a/drivers/input/mouse/Makefile
> +++ b/drivers/input/mouse/Makefile
> @@ -8,7 +8,7 @@ obj-$(CONFIG_MOUSE_AMIGA) += amimouse.o
> obj-$(CONFIG_MOUSE_APPLETOUCH) += appletouch.o
> obj-$(CONFIG_MOUSE_ATARI) += atarimouse.o
> obj-$(CONFIG_MOUSE_BCM5974) += bcm5974.o
> -obj-$(CONFIG_MOUSE_CYAPA) += cyapa.o
> +obj-$(CONFIG_MOUSE_CYAPA) += cyapatp.o
> obj-$(CONFIG_MOUSE_ELAN_I2C) += elan_i2c.o
> obj-$(CONFIG_MOUSE_GPIO) += gpio_mouse.o
> obj-$(CONFIG_MOUSE_INPORT) += inport.o
> @@ -24,6 +24,7 @@ obj-$(CONFIG_MOUSE_SYNAPTICS_I2C) += synaptics_i2c.o
> obj-$(CONFIG_MOUSE_SYNAPTICS_USB) += synaptics_usb.o
> obj-$(CONFIG_MOUSE_VSXXXAA) += vsxxxaa.o
>
> +cyapatp-objs := cyapa.o cyapa_gen3.o
> psmouse-objs := psmouse-base.o synaptics.o focaltech.o
>
> psmouse-$(CONFIG_MOUSE_PS2_ALPS) += alps.o
> diff --git a/drivers/input/mouse/cyapa.c b/drivers/input/mouse/cyapa.c
> index 1bece8c..ae1df15 100644
> --- a/drivers/input/mouse/cyapa.c
> +++ b/drivers/input/mouse/cyapa.c
> @@ -20,408 +20,100 @@
> #include <linux/input/mt.h>
> #include <linux/interrupt.h>
> #include <linux/module.h>
> +#include <linux/mutex.h>
> #include <linux/slab.h>
> +#include <linux/uaccess.h>
> +#include "cyapa.h"
>
> -/* APA trackpad firmware generation */
> -#define CYAPA_GEN3 0x03 /* support MT-protocol B with tracking ID. */
> -
> -#define CYAPA_NAME "Cypress APA Trackpad (cyapa)"
> -
> -/* commands for read/write registers of Cypress trackpad */
> -#define CYAPA_CMD_SOFT_RESET 0x00
> -#define CYAPA_CMD_POWER_MODE 0x01
> -#define CYAPA_CMD_DEV_STATUS 0x02
> -#define CYAPA_CMD_GROUP_DATA 0x03
> -#define CYAPA_CMD_GROUP_CMD 0x04
> -#define CYAPA_CMD_GROUP_QUERY 0x05
> -#define CYAPA_CMD_BL_STATUS 0x06
> -#define CYAPA_CMD_BL_HEAD 0x07
> -#define CYAPA_CMD_BL_CMD 0x08
> -#define CYAPA_CMD_BL_DATA 0x09
> -#define CYAPA_CMD_BL_ALL 0x0a
> -#define CYAPA_CMD_BLK_PRODUCT_ID 0x0b
> -#define CYAPA_CMD_BLK_HEAD 0x0c
> -
> -/* report data start reg offset address. */
> -#define DATA_REG_START_OFFSET 0x0000
> -
> -#define BL_HEAD_OFFSET 0x00
> -#define BL_DATA_OFFSET 0x10
> -
> -/*
> - * Operational Device Status Register
> - *
> - * bit 7: Valid interrupt source
> - * bit 6 - 4: Reserved
> - * bit 3 - 2: Power status
> - * bit 1 - 0: Device status
> - */
> -#define REG_OP_STATUS 0x00
> -#define OP_STATUS_SRC 0x80
> -#define OP_STATUS_POWER 0x0c
> -#define OP_STATUS_DEV 0x03
> -#define OP_STATUS_MASK (OP_STATUS_SRC | OP_STATUS_POWER | OP_STATUS_DEV)
> -
> -/*
> - * Operational Finger Count/Button Flags Register
> - *
> - * bit 7 - 4: Number of touched finger
> - * bit 3: Valid data
> - * bit 2: Middle Physical Button
> - * bit 1: Right Physical Button
> - * bit 0: Left physical Button
> - */
> -#define REG_OP_DATA1 0x01
> -#define OP_DATA_VALID 0x08
> -#define OP_DATA_MIDDLE_BTN 0x04
> -#define OP_DATA_RIGHT_BTN 0x02
> -#define OP_DATA_LEFT_BTN 0x01
> -#define OP_DATA_BTN_MASK (OP_DATA_MIDDLE_BTN | OP_DATA_RIGHT_BTN | \
> - OP_DATA_LEFT_BTN)
> -
> -/*
> - * Bootloader Status Register
> - *
> - * bit 7: Busy
> - * bit 6 - 5: Reserved
> - * bit 4: Bootloader running
> - * bit 3 - 1: Reserved
> - * bit 0: Checksum valid
> - */
> -#define REG_BL_STATUS 0x01
> -#define BL_STATUS_BUSY 0x80
> -#define BL_STATUS_RUNNING 0x10
> -#define BL_STATUS_DATA_VALID 0x08
> -#define BL_STATUS_CSUM_VALID 0x01
> -
> -/*
> - * Bootloader Error Register
> - *
> - * bit 7: Invalid
> - * bit 6: Invalid security key
> - * bit 5: Bootloading
> - * bit 4: Command checksum
> - * bit 3: Flash protection error
> - * bit 2: Flash checksum error
> - * bit 1 - 0: Reserved
> - */
> -#define REG_BL_ERROR 0x02
> -#define BL_ERROR_INVALID 0x80
> -#define BL_ERROR_INVALID_KEY 0x40
> -#define BL_ERROR_BOOTLOADING 0x20
> -#define BL_ERROR_CMD_CSUM 0x10
> -#define BL_ERROR_FLASH_PROT 0x08
> -#define BL_ERROR_FLASH_CSUM 0x04
> -
> -#define BL_STATUS_SIZE 3 /* length of bootloader status registers */
> -#define BLK_HEAD_BYTES 32
> -
> -#define PRODUCT_ID_SIZE 16
> -#define QUERY_DATA_SIZE 27
> -#define REG_PROTOCOL_GEN_QUERY_OFFSET 20
> -
> -#define REG_OFFSET_DATA_BASE 0x0000
> -#define REG_OFFSET_COMMAND_BASE 0x0028
> -#define REG_OFFSET_QUERY_BASE 0x002a
> -
> -#define CAPABILITY_LEFT_BTN_MASK (0x01 << 3)
> -#define CAPABILITY_RIGHT_BTN_MASK (0x01 << 4)
> -#define CAPABILITY_MIDDLE_BTN_MASK (0x01 << 5)
> -#define CAPABILITY_BTN_MASK (CAPABILITY_LEFT_BTN_MASK | \
> - CAPABILITY_RIGHT_BTN_MASK | \
> - CAPABILITY_MIDDLE_BTN_MASK)
> -
> -#define CYAPA_OFFSET_SOFT_RESET REG_OFFSET_COMMAND_BASE
> -
> -#define REG_OFFSET_POWER_MODE (REG_OFFSET_COMMAND_BASE + 1)
> -
> -#define PWR_MODE_MASK 0xfc
> -#define PWR_MODE_FULL_ACTIVE (0x3f << 2)
> -#define PWR_MODE_IDLE (0x05 << 2) /* default sleep time is 50 ms. */
> -#define PWR_MODE_OFF (0x00 << 2)
> -
> -#define PWR_STATUS_MASK 0x0c
> -#define PWR_STATUS_ACTIVE (0x03 << 2)
> -#define PWR_STATUS_IDLE (0x02 << 2)
> -#define PWR_STATUS_OFF (0x00 << 2)
> -
> -/*
> - * CYAPA trackpad device states.
> - * Used in register 0x00, bit1-0, DeviceStatus field.
> - * Other values indicate device is in an abnormal state and must be reset.
> - */
> -#define CYAPA_DEV_NORMAL 0x03
> -#define CYAPA_DEV_BUSY 0x01
> -
> -enum cyapa_state {
> - CYAPA_STATE_OP,
> - CYAPA_STATE_BL_IDLE,
> - CYAPA_STATE_BL_ACTIVE,
> - CYAPA_STATE_BL_BUSY,
> - CYAPA_STATE_NO_DEVICE,
> -};
> -
> -
> -struct cyapa_touch {
> - /*
> - * high bits or x/y position value
> - * bit 7 - 4: high 4 bits of x position value
> - * bit 3 - 0: high 4 bits of y position value
> - */
> - u8 xy_hi;
> - u8 x_lo; /* low 8 bits of x position value. */
> - u8 y_lo; /* low 8 bits of y position value. */
> - u8 pressure;
> - /* id range is 1 - 15. It is incremented with every new touch. */
> - u8 id;
> -} __packed;
> -
> -/* The touch.id is used as the MT slot id, thus max MT slot is 15 */
> -#define CYAPA_MAX_MT_SLOTS 15
> -
> -struct cyapa_reg_data {
> - /*
> - * bit 0 - 1: device status
> - * bit 3 - 2: power mode
> - * bit 6 - 4: reserved
> - * bit 7: interrupt valid bit
> - */
> - u8 device_status;
> - /*
> - * bit 7 - 4: number of fingers currently touching pad
> - * bit 3: valid data check bit
> - * bit 2: middle mechanism button state if exists
> - * bit 1: right mechanism button state if exists
> - * bit 0: left mechanism button state if exists
> - */
> - u8 finger_btn;
> - /* CYAPA reports up to 5 touches per packet. */
> - struct cyapa_touch touches[5];
> -} __packed;
> -
> -/* The main device structure */
> -struct cyapa {
> - enum cyapa_state state;
> -
> - struct i2c_client *client;
> - struct input_dev *input;
> - char phys[32]; /* device physical location */
> - bool irq_wake; /* irq wake is enabled */
> - bool smbus;
> -
> - /* read from query data region. */
> - char product_id[16];
> - u8 btn_capability;
> - u8 gen;
> - int max_abs_x;
> - int max_abs_y;
> - int physical_size_x;
> - int physical_size_y;
> -};
> -
> -static const u8 bl_deactivate[] = { 0x00, 0xff, 0x3b, 0x00, 0x01, 0x02, 0x03,
> - 0x04, 0x05, 0x06, 0x07 };
> -static const u8 bl_exit[] = { 0x00, 0xff, 0xa5, 0x00, 0x01, 0x02, 0x03, 0x04,
> - 0x05, 0x06, 0x07 };
> -
> -struct cyapa_cmd_len {
> - u8 cmd;
> - u8 len;
> -};
>
> #define CYAPA_ADAPTER_FUNC_NONE 0
> #define CYAPA_ADAPTER_FUNC_I2C 1
> #define CYAPA_ADAPTER_FUNC_SMBUS 2
> #define CYAPA_ADAPTER_FUNC_BOTH 3
>
> -/*
> - * macros for SMBus communication
> - */
> -#define SMBUS_READ 0x01
> -#define SMBUS_WRITE 0x00
> -#define SMBUS_ENCODE_IDX(cmd, idx) ((cmd) | (((idx) & 0x03) << 1))
> -#define SMBUS_ENCODE_RW(cmd, rw) ((cmd) | ((rw) & 0x01))
> -#define SMBUS_BYTE_BLOCK_CMD_MASK 0x80
> -#define SMBUS_GROUP_BLOCK_CMD_MASK 0x40
> -
> - /* for byte read/write command */
> -#define CMD_RESET 0
> -#define CMD_POWER_MODE 1
> -#define CMD_DEV_STATUS 2
> -#define SMBUS_BYTE_CMD(cmd) (((cmd) & 0x3f) << 1)
> -#define CYAPA_SMBUS_RESET SMBUS_BYTE_CMD(CMD_RESET)
> -#define CYAPA_SMBUS_POWER_MODE SMBUS_BYTE_CMD(CMD_POWER_MODE)
> -#define CYAPA_SMBUS_DEV_STATUS SMBUS_BYTE_CMD(CMD_DEV_STATUS)
> -
> - /* for group registers read/write command */
> -#define REG_GROUP_DATA 0
> -#define REG_GROUP_CMD 2
> -#define REG_GROUP_QUERY 3
> -#define SMBUS_GROUP_CMD(grp) (0x80 | (((grp) & 0x07) << 3))
> -#define CYAPA_SMBUS_GROUP_DATA SMBUS_GROUP_CMD(REG_GROUP_DATA)
> -#define CYAPA_SMBUS_GROUP_CMD SMBUS_GROUP_CMD(REG_GROUP_CMD)
> -#define CYAPA_SMBUS_GROUP_QUERY SMBUS_GROUP_CMD(REG_GROUP_QUERY)
> -
> - /* for register block read/write command */
> -#define CMD_BL_STATUS 0
> -#define CMD_BL_HEAD 1
> -#define CMD_BL_CMD 2
> -#define CMD_BL_DATA 3
> -#define CMD_BL_ALL 4
> -#define CMD_BLK_PRODUCT_ID 5
> -#define CMD_BLK_HEAD 6
> -#define SMBUS_BLOCK_CMD(cmd) (0xc0 | (((cmd) & 0x1f) << 1))
> -
> -/* register block read/write command in bootloader mode */
> -#define CYAPA_SMBUS_BL_STATUS SMBUS_BLOCK_CMD(CMD_BL_STATUS)
> -#define CYAPA_SMBUS_BL_HEAD SMBUS_BLOCK_CMD(CMD_BL_HEAD)
> -#define CYAPA_SMBUS_BL_CMD SMBUS_BLOCK_CMD(CMD_BL_CMD)
> -#define CYAPA_SMBUS_BL_DATA SMBUS_BLOCK_CMD(CMD_BL_DATA)
> -#define CYAPA_SMBUS_BL_ALL SMBUS_BLOCK_CMD(CMD_BL_ALL)
> -
> -/* register block read/write command in operational mode */
> -#define CYAPA_SMBUS_BLK_PRODUCT_ID SMBUS_BLOCK_CMD(CMD_BLK_PRODUCT_ID)
> -#define CYAPA_SMBUS_BLK_HEAD SMBUS_BLOCK_CMD(CMD_BLK_HEAD)
> -
> -static const struct cyapa_cmd_len cyapa_i2c_cmds[] = {
> - { CYAPA_OFFSET_SOFT_RESET, 1 },
> - { REG_OFFSET_COMMAND_BASE + 1, 1 },
> - { REG_OFFSET_DATA_BASE, 1 },
> - { REG_OFFSET_DATA_BASE, sizeof(struct cyapa_reg_data) },
> - { REG_OFFSET_COMMAND_BASE, 0 },
> - { REG_OFFSET_QUERY_BASE, QUERY_DATA_SIZE },
> - { BL_HEAD_OFFSET, 3 },
> - { BL_HEAD_OFFSET, 16 },
> - { BL_HEAD_OFFSET, 16 },
> - { BL_DATA_OFFSET, 16 },
> - { BL_HEAD_OFFSET, 32 },
> - { REG_OFFSET_QUERY_BASE, PRODUCT_ID_SIZE },
> - { REG_OFFSET_DATA_BASE, 32 }
> -};
> +const char product_id[] = "CYTRA";
>
> -static const struct cyapa_cmd_len cyapa_smbus_cmds[] = {
> - { CYAPA_SMBUS_RESET, 1 },
> - { CYAPA_SMBUS_POWER_MODE, 1 },
> - { CYAPA_SMBUS_DEV_STATUS, 1 },
> - { CYAPA_SMBUS_GROUP_DATA, sizeof(struct cyapa_reg_data) },
> - { CYAPA_SMBUS_GROUP_CMD, 2 },
> - { CYAPA_SMBUS_GROUP_QUERY, QUERY_DATA_SIZE },
> - { CYAPA_SMBUS_BL_STATUS, 3 },
> - { CYAPA_SMBUS_BL_HEAD, 16 },
> - { CYAPA_SMBUS_BL_CMD, 16 },
> - { CYAPA_SMBUS_BL_DATA, 16 },
> - { CYAPA_SMBUS_BL_ALL, 32 },
> - { CYAPA_SMBUS_BLK_PRODUCT_ID, PRODUCT_ID_SIZE },
> - { CYAPA_SMBUS_BLK_HEAD, 16 },
> -};
> +static int cyapa_reinitialize(struct cyapa *cyapa);
>
> -static ssize_t cyapa_i2c_reg_read_block(struct cyapa *cyapa, u8 reg, size_t len,
> +/* Returns 0 on success, else negative errno on failure. */
> +static ssize_t cyapa_i2c_read(struct cyapa *cyapa, u8 reg, size_t len,
> u8 *values)
> {
> - return i2c_smbus_read_i2c_block_data(cyapa->client, reg, len, values);
> -}
> + int ret;
> + struct i2c_client *client = cyapa->client;
> + struct i2c_msg msgs[] = {
> + {
> + .addr = client->addr,
> + .flags = 0,
> + .len = 1,
> + .buf = ®,
> + },
> + {
> + .addr = client->addr,
> + .flags = I2C_M_RD,
> + .len = len,
> + .buf = values,
> + },
> + };
> +
> + ret = i2c_transfer(client->adapter, msgs, 2);
> +
> + if (ret != ARRAY_SIZE(msgs))
> + return ret < 0 ? ret : -EIO;
>
> -static ssize_t cyapa_i2c_reg_write_block(struct cyapa *cyapa, u8 reg,
> - size_t len, const u8 *values)
> -{
> - return i2c_smbus_write_i2c_block_data(cyapa->client, reg, len, values);
> + return 0;
> }
>
> -/*
> - * cyapa_smbus_read_block - perform smbus block read command
> - * @cyapa - private data structure of the driver
> - * @cmd - the properly encoded smbus command
> - * @len - expected length of smbus command result
> - * @values - buffer to store smbus command result
> - *
> - * Returns negative errno, else the number of bytes written.
> +/**
> + * cyapa_i2c_write - Execute i2c block data write operation
> + * @cyapa: Handle to this driver
> + * @ret: Offset of the data to written in the register map
> + * @len: number of bytes to write
> + * @values: Data to be written
> *
> - * Note:
> - * In trackpad device, the memory block allocated for I2C register map
> - * is 256 bytes, so the max read block for I2C bus is 256 bytes.
> + * Return negative errno code on error; return zero when success.
> */
> -static ssize_t cyapa_smbus_read_block(struct cyapa *cyapa, u8 cmd, size_t len,
> - u8 *values)
> +static ssize_t cyapa_i2c_write(struct cyapa *cyapa, u8 reg,
> + size_t len, const void *values)
> {
> - ssize_t ret;
> - u8 index;
> - u8 smbus_cmd;
> - u8 *buf;
> + int ret;
> struct i2c_client *client = cyapa->client;
> + char buf[32];
>
> - if (!(SMBUS_BYTE_BLOCK_CMD_MASK & cmd))
> - return -EINVAL;
> -
> - if (SMBUS_GROUP_BLOCK_CMD_MASK & cmd) {
> - /* read specific block registers command. */
> - smbus_cmd = SMBUS_ENCODE_RW(cmd, SMBUS_READ);
> - ret = i2c_smbus_read_block_data(client, smbus_cmd, values);
> - goto out;
> - }
> -
> - ret = 0;
> - for (index = 0; index * I2C_SMBUS_BLOCK_MAX < len; index++) {
> - smbus_cmd = SMBUS_ENCODE_IDX(cmd, index);
> - smbus_cmd = SMBUS_ENCODE_RW(smbus_cmd, SMBUS_READ);
> - buf = values + I2C_SMBUS_BLOCK_MAX * index;
> - ret = i2c_smbus_read_block_data(client, smbus_cmd, buf);
> - if (ret < 0)
> - goto out;
> - }
> -
> -out:
> - return ret > 0 ? len : ret;
> -}
> -
> -static s32 cyapa_read_byte(struct cyapa *cyapa, u8 cmd_idx)
> -{
> - u8 cmd;
> -
> - if (cyapa->smbus) {
> - cmd = cyapa_smbus_cmds[cmd_idx].cmd;
> - cmd = SMBUS_ENCODE_RW(cmd, SMBUS_READ);
> - } else {
> - cmd = cyapa_i2c_cmds[cmd_idx].cmd;
> - }
> - return i2c_smbus_read_byte_data(cyapa->client, cmd);
> -}
> + if (len > 31)
> + return -ENOMEM;
>
> -static s32 cyapa_write_byte(struct cyapa *cyapa, u8 cmd_idx, u8 value)
> -{
> - u8 cmd;
> + buf[0] = reg;
> + memcpy(&buf[1], values, len);
> + ret = i2c_master_send(client, buf, len + 1);
>
> - if (cyapa->smbus) {
> - cmd = cyapa_smbus_cmds[cmd_idx].cmd;
> - cmd = SMBUS_ENCODE_RW(cmd, SMBUS_WRITE);
> - } else {
> - cmd = cyapa_i2c_cmds[cmd_idx].cmd;
> - }
> - return i2c_smbus_write_byte_data(cyapa->client, cmd, value);
> + return (ret == (len + 1)) ? 0 : ((ret < 0) ? ret : -EIO);
> }
>
> -static ssize_t cyapa_read_block(struct cyapa *cyapa, u8 cmd_idx, u8 *values)
> +static u8 cyapa_check_adapter_functionality(struct i2c_client *client)
> {
> - u8 cmd;
> - size_t len;
> + u8 ret = CYAPA_ADAPTER_FUNC_NONE;
>
> - if (cyapa->smbus) {
> - cmd = cyapa_smbus_cmds[cmd_idx].cmd;
> - len = cyapa_smbus_cmds[cmd_idx].len;
> - return cyapa_smbus_read_block(cyapa, cmd, len, values);
> - } else {
> - cmd = cyapa_i2c_cmds[cmd_idx].cmd;
> - len = cyapa_i2c_cmds[cmd_idx].len;
> - return cyapa_i2c_reg_read_block(cyapa, cmd, len, values);
> - }
> + if (i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
> + ret |= CYAPA_ADAPTER_FUNC_I2C;
> + if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA |
> + I2C_FUNC_SMBUS_BLOCK_DATA |
> + I2C_FUNC_SMBUS_I2C_BLOCK))
> + ret |= CYAPA_ADAPTER_FUNC_SMBUS;
> + return ret;
> }
>
> /*
> * Query device for its current operating state.
> - *
> */
> static int cyapa_get_state(struct cyapa *cyapa)
> {
> u8 status[BL_STATUS_SIZE];
> + u8 cmd[32];
> + /* The i2c address of gen4 and gen5 trackpad device must be even. */
> + bool even_addr = ((cyapa->client->addr & 0x0001) == 0);
> + bool smbus = false;
> + int retries = 2;
> int error;
>
> cyapa->state = CYAPA_STATE_NO_DEVICE;
> @@ -433,39 +125,64 @@ static int cyapa_get_state(struct cyapa *cyapa)
> *
> */
> error = cyapa_i2c_reg_read_block(cyapa, BL_HEAD_OFFSET, BL_STATUS_SIZE,
> - status);
> + status);
>
> /*
> * On smbus systems in OP mode, the i2c_reg_read will fail with
> * -ETIMEDOUT. In this case, try again using the smbus equivalent
> * command. This should return a BL_HEAD indicating CYAPA_STATE_OP.
> */
> - if (cyapa->smbus && (error == -ETIMEDOUT || error == -ENXIO))
> - error = cyapa_read_block(cyapa, CYAPA_CMD_BL_STATUS, status);
> + if (cyapa->smbus && (error == -ETIMEDOUT || error == -ENXIO)) {
> + if (!even_addr)
> + error = cyapa_read_block(cyapa,
> + CYAPA_CMD_BL_STATUS, status);
> + smbus = true;
> + }
>
> if (error != BL_STATUS_SIZE)
> goto error;
>
> - if ((status[REG_OP_STATUS] & OP_STATUS_SRC) == OP_STATUS_SRC) {
> - switch (status[REG_OP_STATUS] & OP_STATUS_DEV) {
> - case CYAPA_DEV_NORMAL:
> - case CYAPA_DEV_BUSY:
> - cyapa->state = CYAPA_STATE_OP;
> - break;
> - default:
> - error = -EAGAIN;
> - goto error;
> + /*
> + * Detect trackpad protocol based on characristic registers and bits.
> + */
> + do {
> + cyapa->status[REG_OP_STATUS] = status[REG_OP_STATUS];
> + cyapa->status[REG_BL_STATUS] = status[REG_BL_STATUS];
> + cyapa->status[REG_BL_ERROR] = status[REG_BL_ERROR];
> +
> + if (cyapa->gen == CYAPA_GEN_UNKNOWN ||
> + cyapa->gen == CYAPA_GEN3) {
> + error = cyapa_gen3_ops.state_parse(cyapa,
> + status, BL_STATUS_SIZE);
> + if (!error)
> + goto out_detected;
> }
> - } else {
> - if (status[REG_BL_STATUS] & BL_STATUS_BUSY)
> - cyapa->state = CYAPA_STATE_BL_BUSY;
> - else if (status[REG_BL_ERROR] & BL_ERROR_BOOTLOADING)
> - cyapa->state = CYAPA_STATE_BL_ACTIVE;
> - else
> - cyapa->state = CYAPA_STATE_BL_IDLE;
> - }
>
> + /*
> + * Write 0x00 0x00 to trackpad device to force update its
> + * status, then redo the detection again.
> + */
> + if (!smbus) {
> + cmd[0] = 0x00;
> + cmd[1] = 0x00;
> + error = cyapa_i2c_write(cyapa, 0, 2, cmd);
> + if (error)
> + goto error;
> +
> + msleep(50);
> +
> + error = cyapa_i2c_read(cyapa, BL_HEAD_OFFSET,
> + BL_STATUS_SIZE, status);
> + if (error)
> + goto error;
> + }
> + } while (--retries > 0 && !smbus);
> +
> + goto error;
> +
> +out_detected:
> return 0;
> +
> error:
> return (error < 0) ? error : -EAGAIN;
> }
> @@ -484,141 +201,18 @@ error:
> * -ETIMEDOUT if device never responds (too many -EAGAIN)
> * < 0 other errors
> */
> -static int cyapa_poll_state(struct cyapa *cyapa, unsigned int timeout)
> +int cyapa_poll_state(struct cyapa *cyapa, unsigned int timeout)
> {
> int error;
> int tries = timeout / 100;
>
> error = cyapa_get_state(cyapa);
> - while ((error || cyapa->state >= CYAPA_STATE_BL_BUSY) && tries--) {
> + while ((error || cyapa->state <= CYAPA_STATE_BL_BUSY) && tries--) {
> msleep(100);
> error = cyapa_get_state(cyapa);
> }
> - return (error == -EAGAIN || error == -ETIMEDOUT) ? -ETIMEDOUT : error;
> -}
> -
> -static int cyapa_bl_deactivate(struct cyapa *cyapa)
> -{
> - int error;
> -
> - error = cyapa_i2c_reg_write_block(cyapa, 0, sizeof(bl_deactivate),
> - bl_deactivate);
> - if (error)
> - return error;
> -
> - /* wait for bootloader to switch to idle state; should take < 100ms */
> - msleep(100);
> - error = cyapa_poll_state(cyapa, 500);
> - if (error)
> - return error;
> - if (cyapa->state != CYAPA_STATE_BL_IDLE)
> - return -EAGAIN;
> - return 0;
> -}
>
> -/*
> - * Exit bootloader
> - *
> - * Send bl_exit command, then wait 50 - 100 ms to let device transition to
> - * operational mode. If this is the first time the device's firmware is
> - * running, it can take up to 2 seconds to calibrate its sensors. So, poll
> - * the device's new state for up to 2 seconds.
> - *
> - * Returns:
> - * -EIO failure while reading from device
> - * -EAGAIN device is stuck in bootloader, b/c it has invalid firmware
> - * 0 device is supported and in operational mode
> - */
> -static int cyapa_bl_exit(struct cyapa *cyapa)
> -{
> - int error;
> -
> - error = cyapa_i2c_reg_write_block(cyapa, 0, sizeof(bl_exit), bl_exit);
> - if (error)
> - return error;
> -
> - /*
> - * Wait for bootloader to exit, and operation mode to start.
> - * Normally, this takes at least 50 ms.
> - */
> - usleep_range(50000, 100000);
> - /*
> - * In addition, when a device boots for the first time after being
> - * updated to new firmware, it must first calibrate its sensors, which
> - * can take up to an additional 2 seconds.
> - */
> - error = cyapa_poll_state(cyapa, 2000);
> - if (error < 0)
> - return error;
> - if (cyapa->state != CYAPA_STATE_OP)
> - return -EAGAIN;
> -
> - return 0;
> -}
> -
> -/*
> - * Set device power mode
> - *
> - */
> -static int cyapa_set_power_mode(struct cyapa *cyapa, u8 power_mode)
> -{
> - struct device *dev = &cyapa->client->dev;
> - int ret;
> - u8 power;
> -
> - if (cyapa->state != CYAPA_STATE_OP)
> - return 0;
> -
> - ret = cyapa_read_byte(cyapa, CYAPA_CMD_POWER_MODE);
> - if (ret < 0)
> - return ret;
> -
> - power = ret & ~PWR_MODE_MASK;
> - power |= power_mode & PWR_MODE_MASK;
> - ret = cyapa_write_byte(cyapa, CYAPA_CMD_POWER_MODE, power);
> - if (ret < 0) {
> - dev_err(dev, "failed to set power_mode 0x%02x err = %d\n",
> - power_mode, ret);
> - return ret;
> - }
> -
> - return 0;
> -}
> -
> -static int cyapa_get_query_data(struct cyapa *cyapa)
> -{
> - u8 query_data[QUERY_DATA_SIZE];
> - int ret;
> -
> - if (cyapa->state != CYAPA_STATE_OP)
> - return -EBUSY;
> -
> - ret = cyapa_read_block(cyapa, CYAPA_CMD_GROUP_QUERY, query_data);
> - if (ret < 0)
> - return ret;
> - if (ret != QUERY_DATA_SIZE)
> - return -EIO;
> -
> - memcpy(&cyapa->product_id[0], &query_data[0], 5);
> - cyapa->product_id[5] = '-';
> - memcpy(&cyapa->product_id[6], &query_data[5], 6);
> - cyapa->product_id[12] = '-';
> - memcpy(&cyapa->product_id[13], &query_data[11], 2);
> - cyapa->product_id[15] = '\0';
> -
> - cyapa->btn_capability = query_data[19] & CAPABILITY_BTN_MASK;
> -
> - cyapa->gen = query_data[20] & 0x0f;
> -
> - cyapa->max_abs_x = ((query_data[21] & 0xf0) << 4) | query_data[22];
> - cyapa->max_abs_y = ((query_data[21] & 0x0f) << 8) | query_data[23];
> -
> - cyapa->physical_size_x =
> - ((query_data[24] & 0xf0) << 4) | query_data[25];
> - cyapa->physical_size_y =
> - ((query_data[24] & 0x0f) << 8) | query_data[26];
> -
> - return 0;
> + return (error == -EAGAIN || error == -ETIMEDOUT) ? -ETIMEDOUT : error;
> }
>
> /*
> @@ -628,8 +222,10 @@ static int cyapa_get_query_data(struct cyapa *cyapa)
> * firmware supported by this driver.
> *
> * Returns:
> + * -ENODEV no device
> * -EBUSY no device or in bootloader
> * -EIO failure while reading from device
> + * -ETIMEDOUT timeout failure for bus idle or bus no response
> * -EAGAIN device is still in bootloader
> * if ->state = CYAPA_STATE_BL_IDLE, device has invalid firmware
> * -EINVAL device is in operational mode, but not supported by this driver
> @@ -637,122 +233,55 @@ static int cyapa_get_query_data(struct cyapa *cyapa)
> */
> static int cyapa_check_is_operational(struct cyapa *cyapa)
> {
> - struct device *dev = &cyapa->client->dev;
> - static const char unique_str[] = "CYTRA";
> int error;
>
> - error = cyapa_poll_state(cyapa, 2000);
> + error = cyapa_poll_state(cyapa, 4000);
> if (error)
> return error;
> - switch (cyapa->state) {
> - case CYAPA_STATE_BL_ACTIVE:
> - error = cyapa_bl_deactivate(cyapa);
> - if (error)
> - return error;
> -
> - /* Fallthrough state */
> - case CYAPA_STATE_BL_IDLE:
> - error = cyapa_bl_exit(cyapa);
> - if (error)
> - return error;
>
> - /* Fallthrough state */
> - case CYAPA_STATE_OP:
> - error = cyapa_get_query_data(cyapa);
> - if (error)
> - return error;
> + switch (cyapa->gen) {
> + case CYAPA_GEN3:
> + cyapa->ops = &cyapa_gen3_ops;
> + break;
> + default:
> + return -ENODEV;
> + }
>
> - /* only support firmware protocol gen3 */
> - if (cyapa->gen != CYAPA_GEN3) {
> - dev_err(dev, "unsupported protocol version (%d)",
> - cyapa->gen);
> - return -EINVAL;
> - }
> + if (cyapa->ops->operational_check)
> + error = cyapa->ops->operational_check(cyapa);
>
> - /* only support product ID starting with CYTRA */
> - if (memcmp(cyapa->product_id, unique_str,
> - sizeof(unique_str) - 1) != 0) {
> - dev_err(dev, "unsupported product ID (%s)\n",
> - cyapa->product_id);
> - return -EINVAL;
> - }
> - return 0;
> + if (!error && CYAPA_OPERATIONAL(cyapa))
> + cyapa->operational = true;
> + else
> + cyapa->operational = false;
>
> - default:
> - return -EIO;
> - }
> - return 0;
> + return error;
> }
>
> -static irqreturn_t cyapa_irq(int irq, void *dev_id)
> +
> +/*
> + * Returns 0 on device detected, negative errno on no device detected.
> + * And when the device is detected and opertaional, it will be reset to
> + * full power active mode automatically.
> + */
> +static int cyapa_detect(struct cyapa *cyapa)
> {
> - struct cyapa *cyapa = dev_id;
> struct device *dev = &cyapa->client->dev;
> - struct input_dev *input = cyapa->input;
> - struct cyapa_reg_data data;
> - int i;
> - int ret;
> - int num_fingers;
> -
> - if (device_may_wakeup(dev))
> - pm_wakeup_event(dev, 0);
> -
> - ret = cyapa_read_block(cyapa, CYAPA_CMD_GROUP_DATA, (u8 *)&data);
> - if (ret != sizeof(data))
> - goto out;
> + int error;
>
> - if ((data.device_status & OP_STATUS_SRC) != OP_STATUS_SRC ||
> - (data.device_status & OP_STATUS_DEV) != CYAPA_DEV_NORMAL ||
> - (data.finger_btn & OP_DATA_VALID) != OP_DATA_VALID) {
> - goto out;
> - }
> + error = cyapa_check_is_operational(cyapa);
> + if (error) {
> + if (error != -ETIMEDOUT && error != -ENODEV &&
> + CYAPA_BOOTLOADER(cyapa)) {
> + dev_warn(dev, "device detected but not operational\n");
> + return 0;
> + }
>
> - num_fingers = (data.finger_btn >> 4) & 0x0f;
> - for (i = 0; i < num_fingers; i++) {
> - const struct cyapa_touch *touch = &data.touches[i];
> - /* Note: touch->id range is 1 to 15; slots are 0 to 14. */
> - int slot = touch->id - 1;
> -
> - input_mt_slot(input, slot);
> - input_mt_report_slot_state(input, MT_TOOL_FINGER, true);
> - input_report_abs(input, ABS_MT_POSITION_X,
> - ((touch->xy_hi & 0xf0) << 4) | touch->x_lo);
> - input_report_abs(input, ABS_MT_POSITION_Y,
> - ((touch->xy_hi & 0x0f) << 8) | touch->y_lo);
> - input_report_abs(input, ABS_MT_PRESSURE, touch->pressure);
> + dev_err(dev, "no device detected, (%d)\n", error);
> + return error;
> }
>
> - input_mt_sync_frame(input);
> -
> - if (cyapa->btn_capability & CAPABILITY_LEFT_BTN_MASK)
> - input_report_key(input, BTN_LEFT,
> - data.finger_btn & OP_DATA_LEFT_BTN);
> -
> - if (cyapa->btn_capability & CAPABILITY_MIDDLE_BTN_MASK)
> - input_report_key(input, BTN_MIDDLE,
> - data.finger_btn & OP_DATA_MIDDLE_BTN);
> -
> - if (cyapa->btn_capability & CAPABILITY_RIGHT_BTN_MASK)
> - input_report_key(input, BTN_RIGHT,
> - data.finger_btn & OP_DATA_RIGHT_BTN);
> -
> - input_sync(input);
> -
> -out:
> - return IRQ_HANDLED;
> -}
> -
> -static u8 cyapa_check_adapter_functionality(struct i2c_client *client)
> -{
> - u8 ret = CYAPA_ADAPTER_FUNC_NONE;
> -
> - if (i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
> - ret |= CYAPA_ADAPTER_FUNC_I2C;
> - if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA |
> - I2C_FUNC_SMBUS_BLOCK_DATA |
> - I2C_FUNC_SMBUS_I2C_BLOCK))
> - ret |= CYAPA_ADAPTER_FUNC_SMBUS;
> - return ret;
> + return 0;
> }
>
> static int cyapa_open(struct input_dev *input)
> @@ -761,22 +290,49 @@ static int cyapa_open(struct input_dev *input)
> struct i2c_client *client = cyapa->client;
> int error;
>
> - error = cyapa_set_power_mode(cyapa, PWR_MODE_FULL_ACTIVE);
> - if (error) {
> - dev_err(&client->dev, "set active power failed: %d\n", error);
> + error = mutex_lock_interruptible(&cyapa->state_sync_lock);
> + if (error)
> return error;
> +
> + if (cyapa->operational && cyapa->ops->set_power_mode) {
> + /*
> + * though failed to set active power mode,
> + * but still may be able to work in lower scan rate
> + * when in operational mode.
> + */
> + error = cyapa->ops->set_power_mode(cyapa,
> + PWR_MODE_FULL_ACTIVE, 0);
> + if (error) {
> + dev_warn(&client->dev,
> + "set active power failed: %d\n", error);
> + goto out;
> + }
> + } else {
> + error = cyapa_reinitialize(cyapa);
> + if (error || !cyapa->operational) {
> + error = error ? error : -EAGAIN;
> + goto out;
> + }
> }
>
> enable_irq(client->irq);
> - return 0;
> +out:
> + mutex_unlock(&cyapa->state_sync_lock);
> + return error;
> }
>
> static void cyapa_close(struct input_dev *input)
> {
> struct cyapa *cyapa = input_get_drvdata(input);
> + struct i2c_client *client = cyapa->client;
> +
> + mutex_lock(&cyapa->state_sync_lock);
>
> - disable_irq(cyapa->client->irq);
> - cyapa_set_power_mode(cyapa, PWR_MODE_OFF);
> + disable_irq(client->irq);
> + if (!CYAPA_BOOTLOADER(cyapa) && cyapa->ops->set_power_mode)
> + cyapa->ops->set_power_mode(cyapa, PWR_MODE_OFF, 0);
> +
> + mutex_unlock(&cyapa->state_sync_lock);
> }
>
> static int cyapa_create_input_dev(struct cyapa *cyapa)
> @@ -813,7 +369,28 @@ static int cyapa_create_input_dev(struct cyapa *cyapa)
> 0);
> input_set_abs_params(input, ABS_MT_POSITION_Y, 0, cyapa->max_abs_y, 0,
> 0);
> - input_set_abs_params(input, ABS_MT_PRESSURE, 0, 255, 0, 0);
> + input_set_abs_params(input, ABS_MT_PRESSURE, 0, cyapa->max_z, 0, 0);
> + if (cyapa->gen > CYAPA_GEN3) {
> + input_set_abs_params(input, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
> + input_set_abs_params(input, ABS_MT_TOUCH_MINOR, 0, 255, 0, 0);
> + /*
> + * Orientation is the angle between the vertical axis and
> + * the major axis of the contact ellipse.
> + * The range is -127 to 127.
> + * the positive direction is clockwise form the vertical axis.
> + * If the ellipse of contact degenerates into a circle,
> + * orientation is reported as 0.
> + *
> + * Also, for Gen5 trackpad the accurate of this orientation
> + * value is value + (-30 ~ 30).
> + */
> + input_set_abs_params(input, ABS_MT_ORIENTATION,
> + -127, 127, 0, 0);
> + }
> + if (cyapa->gen >= CYAPA_GEN5) {
> + input_set_abs_params(input, ABS_MT_WIDTH_MAJOR, 0, 255, 0, 0);
> + input_set_abs_params(input, ABS_MT_WIDTH_MINOR, 0, 255, 0, 0);
> + }
>
> input_abs_set_res(input, ABS_MT_POSITION_X,
> cyapa->max_abs_x / cyapa->physical_size_x);
> @@ -838,16 +415,160 @@ static int cyapa_create_input_dev(struct cyapa *cyapa)
> return error;
> }
>
> + /* Register the device in input subsystem */
> + error = input_register_device(input);
> + if (error) {
> + dev_err(dev, "failed to register input device: %d\n", error);
> + return error;
> + }
> +
> cyapa->input = input;
> return 0;
> }
>
> +/*
> + * cyapa_sleep_time_to_pwr_cmd and cyapa_pwr_cmd_to_sleep_time
> + *
> + * These are helper functions that convert to and from integer idle
> + * times and register settings to write to the PowerMode register.
> + * The trackpad supports between 20ms to 1000ms scan intervals.
> + * The time will be increased in increments of 10ms from 20ms to 100ms.
> + * From 100ms to 1000ms, time will be increased in increments of 20ms.
> + *
> + * When Idle_Time < 100, the format to convert Idle_Time to Idle_Command is:
> + * Idle_Command = Idle Time / 10;
> + * When Idle_Time >= 100, the format to convert Idle_Time to Idle_Command is:
> + * Idle_Command = Idle Time / 20 + 5;
> + */
> +u8 cyapa_sleep_time_to_pwr_cmd(u16 sleep_time)
> +{
> + u16 encoded_time;
> +
> + sleep_time = clamp_val(sleep_time, 20, 1000);
> + encoded_time = sleep_time < 100 ? sleep_time / 10 : sleep_time / 20 + 5;
> + return (encoded_time << 2) & PWR_MODE_MASK;
> +}
> +
> +u16 cyapa_pwr_cmd_to_sleep_time(u8 pwr_mode)
> +{
> + u8 encoded_time = pwr_mode >> 2;
> +
> + return (encoded_time < 10) ? encoded_time * 10
> + : (encoded_time - 5) * 20;
> +}
> +
> +/* 0 on driver initialize and detected successfully, negative on failure. */
> +static int cyapa_initialize(struct cyapa *cyapa)
> +{
> + int error = 0;
> +
> + cyapa->state = CYAPA_STATE_NO_DEVICE;
> + cyapa->gen = CYAPA_GEN_UNKNOWN;
> + mutex_init(&cyapa->state_sync_lock);
> +
> + /*
> + * Set to hard code default, they will be updated with trackpad set
> + * default values after probe and initialized.
> + */
> + cyapa->suspend_power_mode = PWR_MODE_SLEEP;
> + cyapa->suspend_sleep_time =
> + cyapa_pwr_cmd_to_sleep_time(cyapa->suspend_power_mode);
> +
> + if (cyapa_gen3_ops.initialize)
> + error = cyapa_gen3_ops.initialize(cyapa);
> + if (error)
> + return error;
> +
> + error = cyapa_detect(cyapa);
> + if (error)
> + return error;
> +
> + /* Power down the device until we need it. */
> + if (!CYAPA_BOOTLOADER(cyapa) && cyapa->ops->set_power_mode)
> + cyapa->ops->set_power_mode(cyapa, PWR_MODE_OFF, 0);
> +
> + return 0;
> +}
> +
> +static int cyapa_reinitialize(struct cyapa *cyapa)
> +{
> + struct device *dev = &cyapa->client->dev;
> + struct input_dev *input = cyapa->input;
> + int error;
> +
> + /* Avoid command failures when TP was in OFF state. */
> + if (!CYAPA_BOOTLOADER(cyapa) && cyapa->ops->set_power_mode)
> + cyapa->ops->set_power_mode(cyapa, PWR_MODE_FULL_ACTIVE, 0);
> +
> + error = cyapa_detect(cyapa);
> + if (error)
> + goto out;
> +
> + if (!input && cyapa->operational) {
> + error = cyapa_create_input_dev(cyapa);
> + if (error) {
> + dev_err(dev, "create input_dev instance failed: %d\n",
> + error);
> + goto out;
> + }
> + }
> +
> +out:
> + if (!input || !input->users) {
> + /* Reset to power OFF state to save power when no user open. */
> + if (!CYAPA_BOOTLOADER(cyapa) && cyapa->ops->set_power_mode)
> + cyapa->ops->set_power_mode(cyapa, PWR_MODE_OFF, 0);
> + }
> +
> + return error;
> +}
> +
> +static irqreturn_t cyapa_irq(int irq, void *dev_id)
> +{
> + struct cyapa *cyapa = dev_id;
> + struct device *dev = &cyapa->client->dev;
> + bool cont;
> +
> + if (device_may_wakeup(dev))
> + pm_wakeup_event(dev, 0);
> +
> + /* Interrupt event maybe cuased by host command to trackpad device. */
> + cont = true;
> + if (cyapa->ops->irq_cmd_handler)
> + cont = cyapa->ops->irq_cmd_handler(cyapa);
> +
> + /* Interrupt event maybe from trackpad device input reporting. */
> + if (cont && cyapa->ops->irq_handler) {
> + /* Still in probling or in firware image udpating or reading. */
> + if (!cyapa->input && cyapa->ops->sort_empty_output_data) {
> + cyapa->ops->sort_empty_output_data(cyapa,
> + NULL, NULL, NULL);
> + goto out;
> + }
> +
> + if (!cyapa->operational || cyapa->ops->irq_handler(cyapa)) {
> + if (!mutex_trylock(&cyapa->state_sync_lock) &&
> + cyapa->ops->sort_empty_output_data) {
> + cyapa->ops->sort_empty_output_data(cyapa,
> + NULL, NULL, NULL);
> + goto out;
> + }
> + cyapa_reinitialize(cyapa);
> + mutex_unlock(&cyapa->state_sync_lock);
> + }
> + }
> +
> +out:
> + return IRQ_HANDLED;
> +}
> +
> static int cyapa_probe(struct i2c_client *client,
> const struct i2c_device_id *dev_id)
> {
> struct device *dev = &client->dev;
> struct cyapa *cyapa;
> u8 adapter_func;
> + union i2c_smbus_data dummy;
> int error;
>
> adapter_func = cyapa_check_adapter_functionality(client);
> @@ -856,39 +577,30 @@ static int cyapa_probe(struct i2c_client *client,
> return -EIO;
> }
>
> + /* Make sure there is something at this address */
> + if (i2c_smbus_xfer(client->adapter, client->addr, 0,
> + I2C_SMBUS_READ, 0, I2C_SMBUS_BYTE, &dummy) < 0)
> + return -ENODEV;
> +
> cyapa = devm_kzalloc(dev, sizeof(struct cyapa), GFP_KERNEL);
> if (!cyapa)
> return -ENOMEM;
>
> - cyapa->gen = CYAPA_GEN3;
> - cyapa->client = client;
> - i2c_set_clientdata(client, cyapa);
> - sprintf(cyapa->phys, "i2c-%d-%04x/input0", client->adapter->nr,
> - client->addr);
> -
> /* i2c isn't supported, use smbus */
> if (adapter_func == CYAPA_ADAPTER_FUNC_SMBUS)
> cyapa->smbus = true;
>
> - cyapa->state = CYAPA_STATE_NO_DEVICE;
> -
> - error = cyapa_check_is_operational(cyapa);
> - if (error) {
> - dev_err(dev, "device not operational, %d\n", error);
> - return error;
> - }
> + cyapa->client = client;
> + i2c_set_clientdata(client, cyapa);
> + sprintf(cyapa->phys, "i2c-%d-%04x/input0", client->adapter->nr,
> + client->addr);
>
> - /* Power down the device until we need it */
> - error = cyapa_set_power_mode(cyapa, PWR_MODE_OFF);
> + error = cyapa_initialize(cyapa);
> if (error) {
> - dev_err(dev, "failed to quiesce the device: %d\n", error);
> + dev_err(dev, "failed to detect and initialize tp device.\n");
> return error;
> }
>
> - error = cyapa_create_input_dev(cyapa);
> - if (error)
> - return error;
> -
> error = devm_request_threaded_irq(dev, client->irq,
> NULL, cyapa_irq,
> IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
> @@ -901,11 +613,18 @@ static int cyapa_probe(struct i2c_client *client,
> /* Disable IRQ until the device is opened */
> disable_irq(client->irq);
>
> - /* Register the device in input subsystem */
> - error = input_register_device(cyapa->input);
> - if (error) {
> - dev_err(dev, "failed to register input device: %d\n", error);
> - return error;
> + /*
> + * Register the device in the input subsystem when it's operational.
> + * Otherwise, keep in this driver, so it can be be recovered or updated
> + * through the sysfs mode and update_fw interfaces by user or apps.
> + */
> + if (cyapa->operational) {
> + error = cyapa_create_input_dev(cyapa);
> + if (error) {
> + dev_err(dev, "create input_dev instance failed: %d\n",
> + error);
> + return error;
> + }
> }
>
> return 0;
> @@ -915,11 +634,10 @@ static int __maybe_unused cyapa_suspend(struct device *dev)
> {
> struct i2c_client *client = to_i2c_client(dev);
> struct cyapa *cyapa = i2c_get_clientdata(client);
> - struct input_dev *input = cyapa->input;
> u8 power_mode;
> int error;
>
> - error = mutex_lock_interruptible(&input->mutex);
> + error = mutex_lock_interruptible(&cyapa->state_sync_lock);
> if (error)
> return error;
>
> @@ -929,18 +647,20 @@ static int __maybe_unused cyapa_suspend(struct device *dev)
> * Set trackpad device to idle mode if wakeup is allowed,
> * otherwise turn off.
> */
> - power_mode = device_may_wakeup(dev) ? PWR_MODE_IDLE
> + power_mode = device_may_wakeup(dev) ? cyapa->suspend_power_mode
> : PWR_MODE_OFF;
> - error = cyapa_set_power_mode(cyapa, power_mode);
> - if (error)
> - dev_err(dev, "resume: set power mode to %d failed: %d\n",
> - power_mode, error);
> + if (!CYAPA_BOOTLOADER(cyapa) && cyapa->ops->set_power_mode) {
> + error = cyapa->ops->set_power_mode(cyapa, power_mode,
> + cyapa->suspend_sleep_time);
> + if (error)
> + dev_err(dev, "suspend set power mode failed: %d\n",
> + error);
> + }
>
> if (device_may_wakeup(dev))
> cyapa->irq_wake = (enable_irq_wake(client->irq) == 0);
>
> - mutex_unlock(&input->mutex);
> -
> + mutex_unlock(&cyapa->state_sync_lock);
> return 0;
> }
>
> @@ -948,25 +668,22 @@ static int __maybe_unused cyapa_resume(struct device *dev)
> {
> struct i2c_client *client = to_i2c_client(dev);
> struct cyapa *cyapa = i2c_get_clientdata(client);
> - struct input_dev *input = cyapa->input;
> - u8 power_mode;
> int error;
>
> - mutex_lock(&input->mutex);
> + mutex_lock(&cyapa->state_sync_lock);
>
> - if (device_may_wakeup(dev) && cyapa->irq_wake)
> + if (device_may_wakeup(dev) && cyapa->irq_wake) {
> disable_irq_wake(client->irq);
> + cyapa->irq_wake = false;
> + }
>
> - power_mode = input->users ? PWR_MODE_FULL_ACTIVE : PWR_MODE_OFF;
> - error = cyapa_set_power_mode(cyapa, PWR_MODE_FULL_ACTIVE);
> + error = cyapa_reinitialize(cyapa);
> if (error)
> - dev_warn(dev, "resume: set power mode to %d failed: %d\n",
> - power_mode, error);
> + dev_warn(dev, "failed to reinitialize TP device: %d\n", error);
>
> enable_irq(client->irq);
>
> - mutex_unlock(&input->mutex);
> -
> + mutex_unlock(&cyapa->state_sync_lock);
> return 0;
> }
>
> diff --git a/drivers/input/mouse/cyapa.h b/drivers/input/mouse/cyapa.h
> new file mode 100644
> index 0000000..8a75c52
> --- /dev/null
> +++ b/drivers/input/mouse/cyapa.h
> @@ -0,0 +1,307 @@
> +/*
> + * Cypress APA trackpad with I2C interface
> + *
> + * Author: Dudley Du <dudl@cypress.com>
> + *
> + * Copyright (C) 2014 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.
> + */
> +
> +#ifndef _CYAPA_H
> +#define _CYAPA_H
> +
> +#include <linux/firmware.h>
> +
> +/* APA trackpad firmware generation number. */
> +#define CYAPA_GEN_UNKNOWN 0x00 /* unknown protocol. */
> +#define CYAPA_GEN3 0x03 /* support MT-protocol B with tracking ID. */
> +#define CYAPA_GEN5 0x05 /* support TrueTouch GEN5 trackpad device. */
> +
> +#define CYAPA_NAME "Cypress APA Trackpad (cyapa)"
> +
> +/*
> + * Macros for SMBus communication
> + */
> +#define SMBUS_READ 0x01
> +#define SMBUS_WRITE 0x00
> +#define SMBUS_ENCODE_IDX(cmd, idx) ((cmd) | (((idx) & 0x03) << 1))
> +#define SMBUS_ENCODE_RW(cmd, rw) ((cmd) | ((rw) & 0x01))
> +#define SMBUS_BYTE_BLOCK_CMD_MASK 0x80
> +#define SMBUS_GROUP_BLOCK_CMD_MASK 0x40
> +
> +/* Commands for read/write registers of Cypress trackpad */
> +#define CYAPA_CMD_SOFT_RESET 0x00
> +#define CYAPA_CMD_POWER_MODE 0x01
> +#define CYAPA_CMD_DEV_STATUS 0x02
> +#define CYAPA_CMD_GROUP_DATA 0x03
> +#define CYAPA_CMD_GROUP_CMD 0x04
> +#define CYAPA_CMD_GROUP_QUERY 0x05
> +#define CYAPA_CMD_BL_STATUS 0x06
> +#define CYAPA_CMD_BL_HEAD 0x07
> +#define CYAPA_CMD_BL_CMD 0x08
> +#define CYAPA_CMD_BL_DATA 0x09
> +#define CYAPA_CMD_BL_ALL 0x0a
> +#define CYAPA_CMD_BLK_PRODUCT_ID 0x0b
> +#define CYAPA_CMD_BLK_HEAD 0x0c
> +#define CYAPA_CMD_MAX_BASELINE 0x0d
> +#define CYAPA_CMD_MIN_BASELINE 0x0e
> +
> +#define BL_HEAD_OFFSET 0x00
> +#define BL_DATA_OFFSET 0x10
> +
> +#define BL_STATUS_SIZE 3 /* Length of gen3 bootloader status registers */
> +#define CYAPA_REG_MAP_SIZE 256
> +
> +/*
> + * Gen3 Operational Device Status Register
> + *
> + * bit 7: Valid interrupt source
> + * bit 6 - 4: Reserved
> + * bit 3 - 2: Power status
> + * bit 1 - 0: Device status
> + */
> +#define REG_OP_STATUS 0x00
> +#define OP_STATUS_SRC 0x80
> +#define OP_STATUS_POWER 0x0c
> +#define OP_STATUS_DEV 0x03
> +#define OP_STATUS_MASK (OP_STATUS_SRC | OP_STATUS_POWER | OP_STATUS_DEV)
> +
> +/*
> + * Operational Finger Count/Button Flags Register
> + *
> + * bit 7 - 4: Number of touched finger
> + * bit 3: Valid data
> + * bit 2: Middle Physical Button
> + * bit 1: Right Physical Button
> + * bit 0: Left physical Button
> + */
> +#define REG_OP_DATA1 0x01
> +#define OP_DATA_VALID 0x08
> +#define OP_DATA_MIDDLE_BTN 0x04
> +#define OP_DATA_RIGHT_BTN 0x02
> +#define OP_DATA_LEFT_BTN 0x01
> +#define OP_DATA_BTN_MASK (OP_DATA_MIDDLE_BTN | OP_DATA_RIGHT_BTN | \
> + OP_DATA_LEFT_BTN)
> +
> +/*
> + * Write-only command file register used to issue commands and
> + * parameters to the bootloader.
> + * The default value read from it is always 0x00.
> + */
> +#define REG_BL_FILE 0x00
> +#define BL_FILE 0x00
> +
> +/*
> + * Bootloader Status Register
> + *
> + * bit 7: Busy
> + * bit 6 - 5: Reserved
> + * bit 4: Bootloader running
> + * bit 3 - 2: Reserved
> + * bit 1: Watchdog Reset
> + * bit 0: Checksum valid
> + */
> +#define REG_BL_STATUS 0x01
> +#define BL_STATUS_REV_6_5 0x60
> +#define BL_STATUS_BUSY 0x80
> +#define BL_STATUS_RUNNING 0x10
> +#define BL_STATUS_REV_3_2 0x0c
> +#define BL_STATUS_WATCHDOG 0x02
> +#define BL_STATUS_CSUM_VALID 0x01
> +#define BL_STATUS_REV_MASK (BL_STATUS_WATCHDOG | BL_STATUS_REV_3_2 | \
> + BL_STATUS_REV_6_5)
> +
> +/*
> + * Bootloader Error Register
> + *
> + * bit 7: Invalid
> + * bit 6: Invalid security key
> + * bit 5: Bootloading
> + * bit 4: Command checksum
> + * bit 3: Flash protection error
> + * bit 2: Flash checksum error
> + * bit 1 - 0: Reserved
> + */
> +#define REG_BL_ERROR 0x02
> +#define BL_ERROR_INVALID 0x80
> +#define BL_ERROR_INVALID_KEY 0x40
> +#define BL_ERROR_BOOTLOADING 0x20
> +#define BL_ERROR_CMD_CSUM 0x10
> +#define BL_ERROR_FLASH_PROT 0x08
> +#define BL_ERROR_FLASH_CSUM 0x04
> +#define BL_ERROR_RESERVED 0x03
> +#define BL_ERROR_NO_ERR_IDLE 0x00
> +#define BL_ERROR_NO_ERR_ACTIVE (BL_ERROR_BOOTLOADING)
> +
> +#define CAPABILITY_BTN_SHIFT 3
> +#define CAPABILITY_LEFT_BTN_MASK (0x01 << 3)
> +#define CAPABILITY_RIGHT_BTN_MASK (0x01 << 4)
> +#define CAPABILITY_MIDDLE_BTN_MASK (0x01 << 5)
> +#define CAPABILITY_BTN_MASK (CAPABILITY_LEFT_BTN_MASK | \
> + CAPABILITY_RIGHT_BTN_MASK | \
> + CAPABILITY_MIDDLE_BTN_MASK)
> +
> +#define PWR_MODE_MASK 0xfc
> +#define PWR_MODE_FULL_ACTIVE (0x3f << 2)
> +#define PWR_MODE_IDLE (0x03 << 2) /* Default rt suspend scanrate: 30ms */
> +#define PWR_MODE_SLEEP (0x05 << 2) /* Default suspend scanrate: 50ms */
> +#define PWR_MODE_BTN_ONLY (0x01 << 2)
> +#define PWR_MODE_OFF (0x00 << 2)
> +
> +#define PWR_STATUS_MASK 0x0c
> +#define PWR_STATUS_ACTIVE (0x03 << 2)
> +#define PWR_STATUS_IDLE (0x02 << 2)
> +#define PWR_STATUS_BTN_ONLY (0x01 << 2)
> +#define PWR_STATUS_OFF (0x00 << 2)
> +
> +#define AUTOSUSPEND_DELAY 2000 /* unit : ms */
> +
> +#define UNINIT_SLEEP_TIME 0xFFFF
> +#define UNINIT_PWR_MODE 0xFF
> +
> +#define BTN_ONLY_MODE_NAME "buttononly"
> +#define OFF_MODE_NAME "off"
> +
> +/* The touch.id is used as the MT slot id, thus max MT slot is 15 */
> +#define CYAPA_MAX_MT_SLOTS 15
> +
> +struct cyapa;
> +
> +typedef bool (*cb_sort)(struct cyapa *, u8 *, int);
> +
> +struct cyapa_dev_ops {
> + int (*check_fw)(struct cyapa *, const struct firmware *);
> + int (*bl_enter)(struct cyapa *);
> + int (*bl_activate)(struct cyapa *);
> + int (*bl_initiate)(struct cyapa *, const struct firmware *);
> + int (*update_fw)(struct cyapa *, const struct firmware *);
> + int (*bl_verify_app_integrity)(struct cyapa *);
> + int (*bl_deactivate)(struct cyapa *);
> +
> + ssize_t (*show_baseline)(struct device *,
> + struct device_attribute *, char *);
> + ssize_t (*calibrate_store)(struct device *,
> + struct device_attribute *, const char *, size_t);
> +
> + int (*initialize)(struct cyapa *cyapa);
> +
> + int (*state_parse)(struct cyapa *cyapa, u8 *reg_status, int len);
> + int (*operational_check)(struct cyapa *cyapa);
> +
> + int (*irq_handler)(struct cyapa *);
> + bool (*irq_cmd_handler)(struct cyapa *);
> + int (*sort_empty_output_data)(struct cyapa *,
> + u8 *, int *, cb_sort);
> +
> + int (*set_power_mode)(struct cyapa *, u8, u16);
> +};
> +
> +struct cyapa_gen5_cmd_states {
> + struct mutex cmd_lock;
> + struct completion cmd_ready;
> + atomic_t cmd_issued;
> + u8 in_progress_cmd;
> + bool is_irq_mode;
> +
> + cb_sort resp_sort_func;
> + u8 *resp_data;
> + int *resp_len;
> +
> + u8 irq_cmd_buf[CYAPA_REG_MAP_SIZE];
> + u8 empty_buf[CYAPA_REG_MAP_SIZE];
> +};
> +
> +union cyapa_cmd_states {
> + struct cyapa_gen5_cmd_states gen5;
> +};
> +
> +enum cyapa_state {
> + CYAPA_STATE_NO_DEVICE,
> + CYAPA_STATE_BL_BUSY,
> + CYAPA_STATE_BL_IDLE,
> + CYAPA_STATE_BL_ACTIVE,
> + CYAPA_STATE_OP,
> + CYAPA_STATE_GEN5_BL,
> + CYAPA_STATE_GEN5_APP,
> +};
> +#define CYAPA_OPERATIONAL(cyapa) \
> + (((cyapa)->gen == CYAPA_GEN5 && \
> + (cyapa)->state == CYAPA_STATE_GEN5_APP) || \
> + ((cyapa->gen) == CYAPA_GEN3 && (cyapa)->state == CYAPA_STATE_OP))
> +#define CYAPA_BOOTLOADER(cyapa) \
> + ((((cyapa)->gen == CYAPA_GEN5 && \
> + (cyapa)->state == CYAPA_STATE_GEN5_BL)) || \
> + (((cyapa)->gen == CYAPA_GEN3 && \
> + (cyapa)->state >= CYAPA_STATE_BL_BUSY && \
> + (cyapa)->state <= CYAPA_STATE_BL_ACTIVE)))
> +
> +/* The main device structure */
> +struct cyapa {
> + enum cyapa_state state;
> + u8 status[BL_STATUS_SIZE];
> + bool operational; /* true: ready for data reporting; false: not. */
> +
> + struct i2c_client *client;
> + struct input_dev *input;
> + char phys[32]; /* Device physical location */
> + bool irq_wake; /* Irq wake is enabled */
> + bool smbus;
> +
> + /* power mode settings */
> + u8 suspend_power_mode;
> + u16 suspend_sleep_time;
> + u8 dev_pwr_mode;
> + u16 dev_sleep_time;
> +
> + /* Read from query data region. */
> + char product_id[16];
> + u8 fw_maj_ver; /* Firmware major version. */
> + u8 fw_min_ver; /* Firmware minor version. */
> + u8 btn_capability;
> + u8 gen;
> + int max_abs_x;
> + int max_abs_y;
> + int physical_size_x;
> + int physical_size_y;
> +
> + /* Used in ttsp and truetouch based trackpad devices. */
> + u8 x_origin; /* X Axis Origin: 0 = left side; 1 = rigth side. */
> + u8 y_origin; /* Y Axis Origin: 0 = top; 1 = bottom. */
> + int electrodes_x; /* Number of electrodes on the X Axis*/
> + int electrodes_y; /* Number of electrodes on the Y Axis*/
> + int max_z;
> +
> + /*
> + * Used to synchronize the access or update the device state.
> + * And since update firmware and read firmware image process will take
> + * quite long time, maybe more than 10 seconds, so use mutex_lock
> + * to sync and wait other interface and detecting are done or ready.
> + */
> + struct mutex state_sync_lock;
> +
> + const struct cyapa_dev_ops *ops;
> +
> + union cyapa_cmd_states cmd_states;
> +};
> +
> +
> +ssize_t cyapa_i2c_reg_read_block(struct cyapa *cyapa, u8 reg, size_t len,
> + u8 *values);
> +ssize_t cyapa_smbus_read_block(struct cyapa *cyapa, u8 cmd, size_t len,
> + u8 *values);
> +
> +ssize_t cyapa_read_block(struct cyapa *cyapa, u8 cmd_idx, u8 *values);
> +
> +int cyapa_poll_state(struct cyapa *cyapa, unsigned int timeout);
> +
> +u8 cyapa_sleep_time_to_pwr_cmd(u16 sleep_time);
> +u16 cyapa_pwr_cmd_to_sleep_time(u8 pwr_mode);
> +
> +
> +extern const char product_id[];
> +extern const struct cyapa_dev_ops cyapa_gen3_ops;
> +
> +#endif
> diff --git a/drivers/input/mouse/cyapa_gen3.c b/drivers/input/mouse/cyapa_gen3.c
> new file mode 100644
> index 0000000..228fd2d
> --- /dev/null
> +++ b/drivers/input/mouse/cyapa_gen3.c
> @@ -0,0 +1,801 @@
> +/*
> + * Cypress APA trackpad with I2C interface
> + *
> + * Author: Dudley Du <dudl@cypress.com>
> + * Further cleanup and restructuring by:
> + * Daniel Kurtz <djkurtz@chromium.org>
> + * Benson Leung <bleung@chromium.org>
> + *
> + * Copyright (C) 2011-2014 Cypress Semiconductor, Inc.
> + * Copyright (C) 2011-2012 Google, 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/module.h>
> +#include <linux/slab.h>
> +#include "cyapa.h"
> +
> +
> +#define GEN3_MAX_FINGERS 5
> +#define GEN3_FINGER_NUM(x) (((x) >> 4) & 0x07)
> +
> +#define BLK_HEAD_BYTES 32
> +
> +/* Macro for register map group offset. */
> +#define PRODUCT_ID_SIZE 16
> +#define QUERY_DATA_SIZE 27
> +#define REG_PROTOCOL_GEN_QUERY_OFFSET 20
> +
> +#define REG_OFFSET_DATA_BASE 0x0000
> +#define REG_OFFSET_COMMAND_BASE 0x0028
> +#define REG_OFFSET_QUERY_BASE 0x002a
> +
> +#define CYAPA_OFFSET_SOFT_RESET REG_OFFSET_COMMAND_BASE
> +#define OP_RECALIBRATION_MASK 0x80
> +#define OP_REPORT_BASELINE_MASK 0x40
> +#define REG_OFFSET_MAX_BASELINE 0x0026
> +#define REG_OFFSET_MIN_BASELINE 0x0027
> +
> +#define REG_OFFSET_POWER_MODE (REG_OFFSET_COMMAND_BASE + 1)
> +#define SET_POWER_MODE_DELAY 10000 /* Unit: us */
> +#define SET_POWER_MODE_TRIES 5
> +
> +#define GEN3_BL_CMD_CHECKSUM_SEED 0xff
> +#define GEN3_BL_CMD_INITIATE_BL 0x38
> +#define GEN3_BL_CMD_WRITE_BLOCK 0x39
> +#define GEN3_BL_CMD_VERIFY_BLOCK 0x3a
> +#define GEN3_BL_CMD_TERMINATE_BL 0x3b
> +#define GEN3_BL_CMD_LAUNCH_APP 0xa5
> +
> +/*
> + * CYAPA trackpad device states.
> + * Used in register 0x00, bit1-0, DeviceStatus field.
> + * Other values indicate device is in an abnormal state and must be reset.
> + */
> +#define CYAPA_DEV_NORMAL 0x03
> +#define CYAPA_DEV_BUSY 0x01
> +
> +#define CYAPA_FW_BLOCK_SIZE 64
> +#define CYAPA_FW_READ_SIZE 16
> +#define CYAPA_FW_HDR_START 0x0780
> +#define CYAPA_FW_HDR_BLOCK_COUNT 2
> +#define CYAPA_FW_HDR_BLOCK_START (CYAPA_FW_HDR_START / CYAPA_FW_BLOCK_SIZE)
> +#define CYAPA_FW_HDR_SIZE (CYAPA_FW_HDR_BLOCK_COUNT * \
> + CYAPA_FW_BLOCK_SIZE)
> +#define CYAPA_FW_DATA_START 0x0800
> +#define CYAPA_FW_DATA_BLOCK_COUNT 480
> +#define CYAPA_FW_DATA_BLOCK_START (CYAPA_FW_DATA_START / CYAPA_FW_BLOCK_SIZE)
> +#define CYAPA_FW_DATA_SIZE (CYAPA_FW_DATA_BLOCK_COUNT * \
> + CYAPA_FW_BLOCK_SIZE)
> +#define CYAPA_FW_SIZE (CYAPA_FW_HDR_SIZE + CYAPA_FW_DATA_SIZE)
> +#define CYAPA_CMD_LEN 16
> +
> +#define GEN3_BL_IDLE_FW_MAJ_VER_OFFSET 0x0b
> +#define GEN3_BL_IDLE_FW_MIN_VER_OFFSET (GEN3_BL_IDLE_FW_MAJ_VER_OFFSET + 1)
> +
> +
> +struct cyapa_touch {
> + /*
> + * high bits or x/y position value
> + * bit 7 - 4: high 4 bits of x position value
> + * bit 3 - 0: high 4 bits of y position value
> + */
> + u8 xy_hi;
> + u8 x_lo; /* low 8 bits of x position value. */
> + u8 y_lo; /* low 8 bits of y position value. */
> + u8 pressure;
> + /* id range is 1 - 15. It is incremented with every new touch. */
> + u8 id;
> +} __packed;
> +
> +struct cyapa_reg_data {
> + /*
> + * bit 0 - 1: device status
> + * bit 3 - 2: power mode
> + * bit 6 - 4: reserved
> + * bit 7: interrupt valid bit
> + */
> + u8 device_status;
> + /*
> + * bit 7 - 4: number of fingers currently touching pad
> + * bit 3: valid data check bit
> + * bit 2: middle mechanism button state if exists
> + * bit 1: right mechanism button state if exists
> + * bit 0: left mechanism button state if exists
> + */
> + u8 finger_btn;
> + /* CYAPA reports up to 5 touches per packet. */
> + struct cyapa_touch touches[5];
> +} __packed;
> +
> +static const u8 bl_activate[] = { 0x00, 0xff, 0x38, 0x00, 0x01, 0x02, 0x03,
> + 0x04, 0x05, 0x06, 0x07 };
> +static const u8 bl_deactivate[] = { 0x00, 0xff, 0x3b, 0x00, 0x01, 0x02, 0x03,
> + 0x04, 0x05, 0x06, 0x07 };
> +static const u8 bl_exit[] = { 0x00, 0xff, 0xa5, 0x00, 0x01, 0x02, 0x03, 0x04,
> + 0x05, 0x06, 0x07 };
> +
> +
> + /* for byte read/write command */
> +#define CMD_RESET 0
> +#define CMD_POWER_MODE 1
> +#define CMD_DEV_STATUS 2
> +#define CMD_REPORT_MAX_BASELINE 3
> +#define CMD_REPORT_MIN_BASELINE 4
> +#define SMBUS_BYTE_CMD(cmd) (((cmd) & 0x3f) << 1)
> +#define CYAPA_SMBUS_RESET SMBUS_BYTE_CMD(CMD_RESET)
> +#define CYAPA_SMBUS_POWER_MODE SMBUS_BYTE_CMD(CMD_POWER_MODE)
> +#define CYAPA_SMBUS_DEV_STATUS SMBUS_BYTE_CMD(CMD_DEV_STATUS)
> +#define CYAPA_SMBUS_MAX_BASELINE SMBUS_BYTE_CMD(CMD_REPORT_MAX_BASELINE)
> +#define CYAPA_SMBUS_MIN_BASELINE SMBUS_BYTE_CMD(CMD_REPORT_MIN_BASELINE)
> +
> + /* for group registers read/write command */
> +#define REG_GROUP_DATA 0
> +#define REG_GROUP_CMD 2
> +#define REG_GROUP_QUERY 3
> +#define SMBUS_GROUP_CMD(grp) (0x80 | (((grp) & 0x07) << 3))
> +#define CYAPA_SMBUS_GROUP_DATA SMBUS_GROUP_CMD(REG_GROUP_DATA)
> +#define CYAPA_SMBUS_GROUP_CMD SMBUS_GROUP_CMD(REG_GROUP_CMD)
> +#define CYAPA_SMBUS_GROUP_QUERY SMBUS_GROUP_CMD(REG_GROUP_QUERY)
> +
> + /* for register block read/write command */
> +#define CMD_BL_STATUS 0
> +#define CMD_BL_HEAD 1
> +#define CMD_BL_CMD 2
> +#define CMD_BL_DATA 3
> +#define CMD_BL_ALL 4
> +#define CMD_BLK_PRODUCT_ID 5
> +#define CMD_BLK_HEAD 6
> +#define SMBUS_BLOCK_CMD(cmd) (0xc0 | (((cmd) & 0x1f) << 1))
> +
> +/* register block read/write command in bootloader mode */
> +#define CYAPA_SMBUS_BL_STATUS SMBUS_BLOCK_CMD(CMD_BL_STATUS)
> +#define CYAPA_SMBUS_BL_HEAD SMBUS_BLOCK_CMD(CMD_BL_HEAD)
> +#define CYAPA_SMBUS_BL_CMD SMBUS_BLOCK_CMD(CMD_BL_CMD)
> +#define CYAPA_SMBUS_BL_DATA SMBUS_BLOCK_CMD(CMD_BL_DATA)
> +#define CYAPA_SMBUS_BL_ALL SMBUS_BLOCK_CMD(CMD_BL_ALL)
> +
> +/* register block read/write command in operational mode */
> +#define CYAPA_SMBUS_BLK_PRODUCT_ID SMBUS_BLOCK_CMD(CMD_BLK_PRODUCT_ID)
> +#define CYAPA_SMBUS_BLK_HEAD SMBUS_BLOCK_CMD(CMD_BLK_HEAD)
> +
> + /* for byte read/write command */
> +#define CMD_RESET 0
> +#define CMD_POWER_MODE 1
> +#define CMD_DEV_STATUS 2
> +#define CMD_REPORT_MAX_BASELINE 3
> +#define CMD_REPORT_MIN_BASELINE 4
> +#define SMBUS_BYTE_CMD(cmd) (((cmd) & 0x3f) << 1)
> +#define CYAPA_SMBUS_RESET SMBUS_BYTE_CMD(CMD_RESET)
> +#define CYAPA_SMBUS_POWER_MODE SMBUS_BYTE_CMD(CMD_POWER_MODE)
> +#define CYAPA_SMBUS_DEV_STATUS SMBUS_BYTE_CMD(CMD_DEV_STATUS)
> +#define CYAPA_SMBUS_MAX_BASELINE SMBUS_BYTE_CMD(CMD_REPORT_MAX_BASELINE)
> +#define CYAPA_SMBUS_MIN_BASELINE SMBUS_BYTE_CMD(CMD_REPORT_MIN_BASELINE)
> +
> + /* for group registers read/write command */
> +#define REG_GROUP_DATA 0
> +#define REG_GROUP_CMD 2
> +#define REG_GROUP_QUERY 3
> +#define SMBUS_GROUP_CMD(grp) (0x80 | (((grp) & 0x07) << 3))
> +#define CYAPA_SMBUS_GROUP_DATA SMBUS_GROUP_CMD(REG_GROUP_DATA)
> +#define CYAPA_SMBUS_GROUP_CMD SMBUS_GROUP_CMD(REG_GROUP_CMD)
> +#define CYAPA_SMBUS_GROUP_QUERY SMBUS_GROUP_CMD(REG_GROUP_QUERY)
> +
> + /* for register block read/write command */
> +#define CMD_BL_STATUS 0
> +#define CMD_BL_HEAD 1
> +#define CMD_BL_CMD 2
> +#define CMD_BL_DATA 3
> +#define CMD_BL_ALL 4
> +#define CMD_BLK_PRODUCT_ID 5
> +#define CMD_BLK_HEAD 6
> +#define SMBUS_BLOCK_CMD(cmd) (0xc0 | (((cmd) & 0x1f) << 1))
> +
> +/* register block read/write command in bootloader mode */
> +#define CYAPA_SMBUS_BL_STATUS SMBUS_BLOCK_CMD(CMD_BL_STATUS)
> +#define CYAPA_SMBUS_BL_HEAD SMBUS_BLOCK_CMD(CMD_BL_HEAD)
> +#define CYAPA_SMBUS_BL_CMD SMBUS_BLOCK_CMD(CMD_BL_CMD)
> +#define CYAPA_SMBUS_BL_DATA SMBUS_BLOCK_CMD(CMD_BL_DATA)
> +#define CYAPA_SMBUS_BL_ALL SMBUS_BLOCK_CMD(CMD_BL_ALL)
> +
> +/* register block read/write command in operational mode */
> +#define CYAPA_SMBUS_BLK_PRODUCT_ID SMBUS_BLOCK_CMD(CMD_BLK_PRODUCT_ID)
> +#define CYAPA_SMBUS_BLK_HEAD SMBUS_BLOCK_CMD(CMD_BLK_HEAD)
> +
> +struct cyapa_cmd_len {
> + u8 cmd;
> + u8 len;
> +};
> +
> +/* maps generic CYAPA_CMD_* code to the I2C equivalent */
> +static const struct cyapa_cmd_len cyapa_i2c_cmds[] = {
> + { CYAPA_OFFSET_SOFT_RESET, 1 }, /* CYAPA_CMD_SOFT_RESET */
> + { REG_OFFSET_COMMAND_BASE + 1, 1 }, /* CYAPA_CMD_POWER_MODE */
> + { REG_OFFSET_DATA_BASE, 1 }, /* CYAPA_CMD_DEV_STATUS */
> + { REG_OFFSET_DATA_BASE, sizeof(struct cyapa_reg_data) },
> + /* CYAPA_CMD_GROUP_DATA */
> + { REG_OFFSET_COMMAND_BASE, 0 }, /* CYAPA_CMD_GROUP_CMD */
> + { REG_OFFSET_QUERY_BASE, QUERY_DATA_SIZE }, /* CYAPA_CMD_GROUP_QUERY */
> + { BL_HEAD_OFFSET, 3 }, /* CYAPA_CMD_BL_STATUS */
> + { BL_HEAD_OFFSET, 16 }, /* CYAPA_CMD_BL_HEAD */
> + { BL_HEAD_OFFSET, 16 }, /* CYAPA_CMD_BL_CMD */
> + { BL_DATA_OFFSET, 16 }, /* CYAPA_CMD_BL_DATA */
> + { BL_HEAD_OFFSET, 32 }, /* CYAPA_CMD_BL_ALL */
> + { REG_OFFSET_QUERY_BASE, PRODUCT_ID_SIZE },
> + /* CYAPA_CMD_BLK_PRODUCT_ID */
> + { REG_OFFSET_DATA_BASE, 32 }, /* CYAPA_CMD_BLK_HEAD */
> + { REG_OFFSET_MAX_BASELINE, 1 }, /* CYAPA_CMD_MAX_BASELINE */
> + { REG_OFFSET_MIN_BASELINE, 1 }, /* CYAPA_CMD_MIN_BASELINE */
> +};
> +
> +static const struct cyapa_cmd_len cyapa_smbus_cmds[] = {
> + { CYAPA_SMBUS_RESET, 1 }, /* CYAPA_CMD_SOFT_RESET */
> + { CYAPA_SMBUS_POWER_MODE, 1 }, /* CYAPA_CMD_POWER_MODE */
> + { CYAPA_SMBUS_DEV_STATUS, 1 }, /* CYAPA_CMD_DEV_STATUS */
> + { CYAPA_SMBUS_GROUP_DATA, sizeof(struct cyapa_reg_data) },
> + /* CYAPA_CMD_GROUP_DATA */
> + { CYAPA_SMBUS_GROUP_CMD, 2 }, /* CYAPA_CMD_GROUP_CMD */
> + { CYAPA_SMBUS_GROUP_QUERY, QUERY_DATA_SIZE },
> + /* CYAPA_CMD_GROUP_QUERY */
> + { CYAPA_SMBUS_BL_STATUS, 3 }, /* CYAPA_CMD_BL_STATUS */
> + { CYAPA_SMBUS_BL_HEAD, 16 }, /* CYAPA_CMD_BL_HEAD */
> + { CYAPA_SMBUS_BL_CMD, 16 }, /* CYAPA_CMD_BL_CMD */
> + { CYAPA_SMBUS_BL_DATA, 16 }, /* CYAPA_CMD_BL_DATA */
> + { CYAPA_SMBUS_BL_ALL, 32 }, /* CYAPA_CMD_BL_ALL */
> + { CYAPA_SMBUS_BLK_PRODUCT_ID, PRODUCT_ID_SIZE },
> + /* CYAPA_CMD_BLK_PRODUCT_ID */
> + { CYAPA_SMBUS_BLK_HEAD, 16 }, /* CYAPA_CMD_BLK_HEAD */
> + { CYAPA_SMBUS_MAX_BASELINE, 1 }, /* CYAPA_CMD_MAX_BASELINE */
> + { CYAPA_SMBUS_MIN_BASELINE, 1 }, /* CYAPA_CMD_MIN_BASELINE */
> +};
> +
> +
> +/*
> + * cyapa_smbus_read_block - perform smbus block read command
> + * @cyapa - private data structure of the driver
> + * @cmd - the properly encoded smbus command
> + * @len - expected length of smbus command result
> + * @values - buffer to store smbus command result
> + *
> + * Returns negative errno, else the number of bytes written.
> + *
> + * Note:
> + * In trackpad device, the memory block allocated for I2C register map
> + * is 256 bytes, so the max read block for I2C bus is 256 bytes.
> + */
> +ssize_t cyapa_smbus_read_block(struct cyapa *cyapa, u8 cmd, size_t len,
> + u8 *values)
> +{
> + ssize_t ret;
> + u8 index;
> + u8 smbus_cmd;
> + u8 *buf;
> + struct i2c_client *client = cyapa->client;
> +
> + if (!(SMBUS_BYTE_BLOCK_CMD_MASK & cmd))
> + return -EINVAL;
> +
> + if (SMBUS_GROUP_BLOCK_CMD_MASK & cmd) {
> + /* read specific block registers command. */
> + smbus_cmd = SMBUS_ENCODE_RW(cmd, SMBUS_READ);
> + ret = i2c_smbus_read_block_data(client, smbus_cmd, values);
> + goto out;
> + }
> +
> + ret = 0;
> + for (index = 0; index * I2C_SMBUS_BLOCK_MAX < len; index++) {
> + smbus_cmd = SMBUS_ENCODE_IDX(cmd, index);
> + smbus_cmd = SMBUS_ENCODE_RW(smbus_cmd, SMBUS_READ);
> + buf = values + I2C_SMBUS_BLOCK_MAX * index;
> + ret = i2c_smbus_read_block_data(client, smbus_cmd, buf);
> + if (ret < 0)
> + goto out;
> + }
> +
> +out:
> + return ret > 0 ? len : ret;
> +}
> +
> +static s32 cyapa_read_byte(struct cyapa *cyapa, u8 cmd_idx)
> +{
> + u8 cmd;
> +
> + if (cyapa->smbus) {
> + cmd = cyapa_smbus_cmds[cmd_idx].cmd;
> + cmd = SMBUS_ENCODE_RW(cmd, SMBUS_READ);
> + } else {
> + cmd = cyapa_i2c_cmds[cmd_idx].cmd;
> + }
> + return i2c_smbus_read_byte_data(cyapa->client, cmd);
> +}
> +
> +static s32 cyapa_write_byte(struct cyapa *cyapa, u8 cmd_idx, u8 value)
> +{
> + u8 cmd;
> +
> + if (cyapa->smbus) {
> + cmd = cyapa_smbus_cmds[cmd_idx].cmd;
> + cmd = SMBUS_ENCODE_RW(cmd, SMBUS_WRITE);
> + } else {
> + cmd = cyapa_i2c_cmds[cmd_idx].cmd;
> + }
> + return i2c_smbus_write_byte_data(cyapa->client, cmd, value);
> +}
> +
> +ssize_t cyapa_i2c_reg_read_block(struct cyapa *cyapa, u8 reg, size_t len,
> + u8 *values)
> +{
> + return i2c_smbus_read_i2c_block_data(cyapa->client, reg, len, values);
> +}
> +
> +static ssize_t cyapa_i2c_reg_write_block(struct cyapa *cyapa, u8 reg,
> + size_t len, const u8 *values)
> +{
> + return i2c_smbus_write_i2c_block_data(cyapa->client, reg, len, values);
> +}
> +
> +ssize_t cyapa_read_block(struct cyapa *cyapa, u8 cmd_idx, u8 *values)
> +{
> + u8 cmd;
> + size_t len;
> +
> + if (cyapa->smbus) {
> + cmd = cyapa_smbus_cmds[cmd_idx].cmd;
> + len = cyapa_smbus_cmds[cmd_idx].len;
> + return cyapa_smbus_read_block(cyapa, cmd, len, values);
> + }
> + cmd = cyapa_i2c_cmds[cmd_idx].cmd;
> + len = cyapa_i2c_cmds[cmd_idx].len;
> + return cyapa_i2c_reg_read_block(cyapa, cmd, len, values);
> +}
> +
> +/*
> + * Determine the Gen3 trackpad device's current operating state.
> + *
> + */
> +static int cyapa_gen3_state_parse(struct cyapa *cyapa, u8 *reg_data, int len)
> +{
> + cyapa->state = CYAPA_STATE_NO_DEVICE;
> +
> + /* Parse based on Gen3 characteristic registers and bits */
> + if (reg_data[REG_BL_FILE] == BL_FILE &&
> + reg_data[REG_BL_ERROR] == BL_ERROR_NO_ERR_IDLE &&
> + (reg_data[REG_BL_STATUS] ==
> + (BL_STATUS_RUNNING | BL_STATUS_CSUM_VALID) ||
> + reg_data[REG_BL_STATUS] == BL_STATUS_RUNNING)) {
> + /*
> + * Normal state after power on or reset,
> + * REG_BL_STATUS == 0x11, firmware image checksum is valid.
> + * REG_BL_STATUS == 0x10, firmware image checksum is invalid.
> + */
> + cyapa->gen = CYAPA_GEN3;
> + cyapa->state = CYAPA_STATE_BL_IDLE;
> + } else if (reg_data[REG_BL_FILE] == BL_FILE &&
> + (reg_data[REG_BL_STATUS] & BL_STATUS_RUNNING) ==
> + BL_STATUS_RUNNING) {
> + cyapa->gen = CYAPA_GEN3;
> + if (reg_data[REG_BL_STATUS] & BL_STATUS_BUSY) {
> + cyapa->state = CYAPA_STATE_BL_BUSY;
> + } else {
> + if ((reg_data[REG_BL_ERROR] & BL_ERROR_BOOTLOADING) ==
> + BL_ERROR_BOOTLOADING)
> + cyapa->state = CYAPA_STATE_BL_ACTIVE;
> + else
> + cyapa->state = CYAPA_STATE_BL_IDLE;
> + }
> + } else if ((reg_data[REG_OP_STATUS] & OP_STATUS_SRC) &&
> + (reg_data[REG_OP_DATA1] & OP_DATA_VALID)) {
> + /*
> + * Normal state when running in operational mode,
> + * may also not in full power state or
> + * busying in command process.
> + */
> + if (GEN3_FINGER_NUM(reg_data[REG_OP_DATA1]) <=
> + GEN3_MAX_FINGERS) {
> + /* Finger number data is valid. */
> + cyapa->gen = CYAPA_GEN3;
> + cyapa->state = CYAPA_STATE_OP;
> + }
> + } else if (reg_data[REG_OP_STATUS] == 0x0C &&
> + reg_data[REG_OP_DATA1] == 0x08) {
> + /* Op state when first two registers overwritten with 0x00 */
> + cyapa->gen = CYAPA_GEN3;
> + cyapa->state = CYAPA_STATE_OP;
> + } else if (reg_data[REG_BL_STATUS] &
> + (BL_STATUS_RUNNING | BL_STATUS_BUSY)) {
> + cyapa->gen = CYAPA_GEN3;
> + cyapa->state = CYAPA_STATE_BL_BUSY;
> + }
> +
> + if (cyapa->gen == CYAPA_GEN3 && (cyapa->state == CYAPA_STATE_OP ||
> + cyapa->state == CYAPA_STATE_BL_IDLE ||
> + cyapa->state == CYAPA_STATE_BL_ACTIVE ||
> + cyapa->state == CYAPA_STATE_BL_BUSY))
> + return 0;
> +
> + return -EAGAIN;
> +}
> +
> +static int cyapa_gen3_bl_deactivate(struct cyapa *cyapa)
> +{
> + int error;
> +
> + error = cyapa_i2c_reg_write_block(cyapa, 0, sizeof(bl_deactivate),
> + bl_deactivate);
> + if (error)
> + return error;
> +
> + /* Wait for bootloader to switch to idle state; should take < 100ms */
> + msleep(100);
> + error = cyapa_poll_state(cyapa, 500);
> + if (error)
> + return error;
> + if (cyapa->state != CYAPA_STATE_BL_IDLE)
> + return -EAGAIN;
> + return 0;
> +}
> +
> +/*
> + * Exit bootloader
> + *
> + * Send bl_exit command, then wait 50 - 100 ms to let device transition to
> + * operational mode. If this is the first time the device's firmware is
> + * running, it can take up to 2 seconds to calibrate its sensors. So, poll
> + * the device's new state for up to 2 seconds.
> + *
> + * Returns:
> + * -EIO failure while reading from device
> + * -EAGAIN device is stuck in bootloader, b/c it has invalid firmware
> + * 0 device is supported and in operational mode
> + */
> +static int cyapa_gen3_bl_exit(struct cyapa *cyapa)
> +{
> + int error;
> +
> + error = cyapa_i2c_reg_write_block(cyapa, 0, sizeof(bl_exit), bl_exit);
> + if (error)
> + return error;
> +
> + /*
> + * Wait for bootloader to exit, and operation mode to start.
> + * Normally, this takes at least 50 ms.
> + */
> + usleep_range(50000, 100000);
> + /*
> + * In addition, when a device boots for the first time after being
> + * updated to new firmware, it must first calibrate its sensors, which
> + * can take up to an additional 2 seconds. If the device power is
> + * running low, this may take even longer.
> + */
> + error = cyapa_poll_state(cyapa, 4000);
> + if (error < 0)
> + return error;
> + if (cyapa->state != CYAPA_STATE_OP)
> + return -EAGAIN;
> +
> + return 0;
> +}
> +
> +/*
> + * cyapa_get_wait_time_for_pwr_cmd
> + *
> + * Compute the amount of time we need to wait after updating the touchpad
> + * power mode. The touchpad needs to consume the incoming power mode set
> + * command at the current clock rate.
> + */
> +
> +static u16 cyapa_get_wait_time_for_pwr_cmd(u8 pwr_mode)
> +{
> + switch (pwr_mode) {
> + case PWR_MODE_FULL_ACTIVE: return 20;
> + case PWR_MODE_BTN_ONLY: return 20;
> + case PWR_MODE_OFF: return 20;
> + default: return cyapa_pwr_cmd_to_sleep_time(pwr_mode) + 50;
> + }
> +}
> +
> +/*
> + * Set device power mode
> + *
> + * Write to the field to configure power state. Power states include :
> + * Full : Max scans and report rate.
> + * Idle : Report rate set by user specified time.
> + * ButtonOnly : No scans for fingers. When the button is triggered,
> + * a slave interrupt is asserted to notify host to wake up.
> + * Off : Only awake for i2c commands from host. No function for button
> + * or touch sensors.
> + *
> + * The power_mode command should conform to the following :
> + * Full : 0x3f
> + * Idle : Configurable from 20 to 1000ms. See note below for
> + * cyapa_sleep_time_to_pwr_cmd and cyapa_pwr_cmd_to_sleep_time
> + * ButtonOnly : 0x01
> + * Off : 0x00
> + *
> + * Device power mode can only be set when device is in operational mode.
> + */
> +static int cyapa_gen3_set_power_mode(struct cyapa *cyapa, u8 power_mode,
> + u16 always_unused)
> +{
> + int ret;
> + u8 power;
> + int tries;
> + u16 sleep_time;
> +
> + always_unused = 0;
> + if (cyapa->state != CYAPA_STATE_OP)
> + return 0;
> +
> + tries = SET_POWER_MODE_TRIES;
> + while (tries--) {
> + ret = cyapa_read_byte(cyapa, CYAPA_CMD_POWER_MODE);
> + if (ret >= 0)
> + break;
> + usleep_range(SET_POWER_MODE_DELAY, 2 * SET_POWER_MODE_DELAY);
> + }
> + if (ret < 0)
> + return ret;
> +
> + /*
> + * Return early if the power mode to set is the same as the current
> + * one.
> + */
> + if ((ret & PWR_MODE_MASK) == power_mode)
> + return 0;
> +
> + sleep_time = cyapa_get_wait_time_for_pwr_cmd(ret & PWR_MODE_MASK);
> + power = ret;
> + power &= ~PWR_MODE_MASK;
> + power |= power_mode & PWR_MODE_MASK;
> + tries = SET_POWER_MODE_TRIES;
> + while (tries--) {
> + ret = cyapa_write_byte(cyapa, CYAPA_CMD_POWER_MODE, power);
> + if (!ret)
> + break;
> + usleep_range(SET_POWER_MODE_DELAY, 2 * SET_POWER_MODE_DELAY);
> + }
> +
> + /*
> + * Wait for the newly set power command to go in at the previous
> + * clock speed (scanrate) used by the touchpad firmware. Not
> + * doing so before issuing the next command may result in errors
> + * depending on the command's content.
> + */
> + msleep(sleep_time);
> + return ret;
> +}
> +
> +static int cyapa_gen3_get_query_data(struct cyapa *cyapa)
> +{
> + u8 query_data[QUERY_DATA_SIZE];
> + int ret;
> +
> + if (cyapa->state != CYAPA_STATE_OP)
> + return -EBUSY;
> +
> + ret = cyapa_read_block(cyapa, CYAPA_CMD_GROUP_QUERY, query_data);
> + if (ret != QUERY_DATA_SIZE)
> + return (ret < 0) ? ret : -EIO;
> +
> + memcpy(&cyapa->product_id[0], &query_data[0], 5);
> + cyapa->product_id[5] = '-';
> + memcpy(&cyapa->product_id[6], &query_data[5], 6);
> + cyapa->product_id[12] = '-';
> + memcpy(&cyapa->product_id[13], &query_data[11], 2);
> + cyapa->product_id[15] = '\0';
> +
> + cyapa->fw_maj_ver = query_data[15];
> + cyapa->fw_min_ver = query_data[16];
> +
> + cyapa->btn_capability = query_data[19] & CAPABILITY_BTN_MASK;
> +
> + cyapa->gen = query_data[20] & 0x0f;
> +
> + cyapa->max_abs_x = ((query_data[21] & 0xf0) << 4) | query_data[22];
> + cyapa->max_abs_y = ((query_data[21] & 0x0f) << 8) | query_data[23];
> +
> + cyapa->physical_size_x =
> + ((query_data[24] & 0xf0) << 4) | query_data[25];
> + cyapa->physical_size_y =
> + ((query_data[24] & 0x0f) << 8) | query_data[26];
> +
> + cyapa->max_z = 255;
> +
> + return 0;
> +}
> +
> +static int cyapa_gen3_bl_query_data(struct cyapa *cyapa)
> +{
> + u8 bl_data[CYAPA_CMD_LEN];
> + int ret;
> +
> + ret = cyapa_i2c_reg_read_block(cyapa, 0, CYAPA_CMD_LEN, bl_data);
> + if (ret != CYAPA_CMD_LEN)
> + return (ret < 0) ? ret : -EIO;
> +
> + /*
> + * This value will be updated again when entered application mode.
> + * If TP failed to enter application mode, this fw version values
> + * can be used as a reference.
> + * This firmware version valid when fw image checksum is valid.
> + */
> + if (bl_data[REG_BL_STATUS] ==
> + (BL_STATUS_RUNNING | BL_STATUS_CSUM_VALID)) {
> + cyapa->fw_maj_ver = bl_data[GEN3_BL_IDLE_FW_MAJ_VER_OFFSET];
> + cyapa->fw_min_ver = bl_data[GEN3_BL_IDLE_FW_MIN_VER_OFFSET];
> + }
> +
> + return 0;
> +}
> +
> +/*
> + * Check if device is operational.
> + *
> + * An operational device is responding, has exited bootloader, and has
> + * firmware supported by this driver.
> + *
> + * Returns:
> + * -EBUSY no device or in bootloader
> + * -EIO failure while reading from device
> + * -EAGAIN device is still in bootloader
> + * if ->state = CYAPA_STATE_BL_IDLE, device has invalid firmware
> + * -EINVAL device is in operational mode, but not supported by this driver
> + * 0 device is supported
> + */
> +static int cyapa_gen3_do_operational_check(struct cyapa *cyapa)
> +{
> + struct device *dev = &cyapa->client->dev;
> + int error;
> +
> + switch (cyapa->state) {
> + case CYAPA_STATE_BL_ACTIVE:
> + error = cyapa_gen3_bl_deactivate(cyapa);
> + if (error) {
> + dev_err(dev, "failed to bl_deactivate: %d\n", error);
> + return error;
> + }
> +
> + /* Fallthrough state */
> + case CYAPA_STATE_BL_IDLE:
> + /* Try to get firmware version in bootloader mode. */
> + cyapa_gen3_bl_query_data(cyapa);
> +
> + error = cyapa_gen3_bl_exit(cyapa);
> + if (error) {
> + dev_err(dev, "failed to bl_exit: %d\n", error);
> + return error;
> + }
> +
> + /* Fallthrough state */
> + case CYAPA_STATE_OP:
> + /*
> + * Reading query data before going back to the full mode
> + * may cause problems, so we set the power mode first here.
> + */
> + error = cyapa_gen3_set_power_mode(cyapa,
> + PWR_MODE_FULL_ACTIVE, 0);
> + if (error)
> + dev_err(dev, "%s: set full power mode failed: %d\n",
> + __func__, error);
> + error = cyapa_gen3_get_query_data(cyapa);
> + if (error < 0)
> + return error;
> +
> + /* Only support firmware protocol gen3 */
> + if (cyapa->gen != CYAPA_GEN3) {
> + dev_err(dev, "unsupported protocol version (%d)",
> + cyapa->gen);
> + return -EINVAL;
> + }
> +
> + /* Only support product ID starting with CYTRA */
> + if (memcmp(cyapa->product_id, product_id,
> + strlen(product_id)) != 0) {
> + dev_err(dev, "unsupported product ID (%s)\n",
> + cyapa->product_id);
> + return -EINVAL;
> + }
> +
> + return 0;
> +
> + default:
> + return -EIO;
> + }
> + return 0;
> +}
> +
> +/*
> + * Return false, do not continue process
> + * Return true, continue process.
> + */
> +static bool cyapa_gen3_irq_cmd_handler(struct cyapa *cyapa)
> +{
> + /* Not gen3 irq command response, skip for continue. */
> + if (cyapa->gen != CYAPA_GEN3)
> + return true;
> +
> + if (cyapa->operational)
> + return true;
> +
> + /*
> + * Driver in detecting or other interface function processing,
> + * so, stop cyapa_gen3_irq_handler to continue process to
> + * avoid unwanted to error detecting and processing.
> + *
> + * And also, avoid the periodicly accerted interrupts to be processed
> + * as touch inputs when gen3 failed to launch into application mode,
> + * which will cause gen3 stays in bootloader mode.
> + */
> + return false;
> +}
> +
> +static int cyapa_gen3_irq_handler(struct cyapa *cyapa)
> +{
> + struct input_dev *input = cyapa->input;
> + struct device *dev = &cyapa->client->dev;
> + struct cyapa_reg_data data;
> + int num_fingers;
> + int ret;
> + int i;
> +
> + ret = cyapa_read_block(cyapa, CYAPA_CMD_GROUP_DATA, (u8 *)&data);
> + if (ret != sizeof(data)) {
> + dev_err(dev, "failed to read report data, (%d)\n", ret);
> + return -EINVAL;
> + }
> +
> + if ((data.device_status & OP_STATUS_SRC) != OP_STATUS_SRC ||
> + (data.device_status & OP_STATUS_DEV) != CYAPA_DEV_NORMAL ||
> + (data.finger_btn & OP_DATA_VALID) != OP_DATA_VALID) {
> + dev_err(dev, "invalid device state bytes, %02x %02x\n",
> + data.device_status, data.finger_btn);
> + return -EINVAL;
> + }
> +
> + num_fingers = (data.finger_btn >> 4) & 0x0f;
> + for (i = 0; i < num_fingers; i++) {
> + const struct cyapa_touch *touch = &data.touches[i];
> + /* Note: touch->id range is 1 to 15; slots are 0 to 14. */
> + int slot = touch->id - 1;
> +
> + input_mt_slot(input, slot);
> + input_mt_report_slot_state(input, MT_TOOL_FINGER, true);
> + input_report_abs(input, ABS_MT_POSITION_X,
> + ((touch->xy_hi & 0xf0) << 4) | touch->x_lo);
> + input_report_abs(input, ABS_MT_POSITION_Y,
> + ((touch->xy_hi & 0x0f) << 8) | touch->y_lo);
> + input_report_abs(input, ABS_MT_PRESSURE, touch->pressure);
> + }
> +
> + input_mt_sync_frame(input);
> +
> + if (cyapa->btn_capability & CAPABILITY_LEFT_BTN_MASK)
> + input_report_key(input, BTN_LEFT,
> + !!(data.finger_btn & OP_DATA_LEFT_BTN));
> + if (cyapa->btn_capability & CAPABILITY_MIDDLE_BTN_MASK)
> + input_report_key(input, BTN_MIDDLE,
> + !!(data.finger_btn & OP_DATA_MIDDLE_BTN));
> + if (cyapa->btn_capability & CAPABILITY_RIGHT_BTN_MASK)
> + input_report_key(input, BTN_RIGHT,
> + !!(data.finger_btn & OP_DATA_RIGHT_BTN));
> + input_sync(input);
> +
> + return 0;
> +}
> +
> +const struct cyapa_dev_ops cyapa_gen3_ops = {
> + .state_parse = cyapa_gen3_state_parse,
> + .operational_check = cyapa_gen3_do_operational_check,
> +
> + .irq_handler = cyapa_gen3_irq_handler,
> + .irq_cmd_handler = cyapa_gen3_irq_cmd_handler,
> +
> + .set_power_mode = cyapa_gen3_set_power_mode,
> +};
> --
> 1.9.1
>
--
Dmitry
Input: cyapa - misc changes
From: Dmitry Torokhov <dmitry.torokhov@gmail.com>
Signed-off-by: Dmitry Torokhov <dmitry.torokhov@gmail.com>
---
drivers/input/mouse/cyapa.c | 50 ++++++++++++++++++++++++-------------------
1 file changed, 28 insertions(+), 22 deletions(-)
diff --git a/drivers/input/mouse/cyapa.c b/drivers/input/mouse/cyapa.c
index ae1df15..27ae5e61 100644
--- a/drivers/input/mouse/cyapa.c
+++ b/drivers/input/mouse/cyapa.c
@@ -36,10 +36,8 @@ const char product_id[] = "CYTRA";
static int cyapa_reinitialize(struct cyapa *cyapa);
/* Returns 0 on success, else negative errno on failure. */
-static ssize_t cyapa_i2c_read(struct cyapa *cyapa, u8 reg, size_t len,
- u8 *values)
+static int cyapa_i2c_read(struct cyapa *cyapa, u8 reg, size_t len, u8 *values)
{
- int ret;
struct i2c_client *client = cyapa->client;
struct i2c_msg msgs[] = {
{
@@ -55,9 +53,9 @@ static ssize_t cyapa_i2c_read(struct cyapa *cyapa, u8 reg, size_t len,
.buf = values,
},
};
+ int ret;
- ret = i2c_transfer(client->adapter, msgs, 2);
-
+ ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
if (ret != ARRAY_SIZE(msgs))
return ret < 0 ? ret : -EIO;
@@ -73,21 +71,24 @@ static ssize_t cyapa_i2c_read(struct cyapa *cyapa, u8 reg, size_t len,
*
* Return negative errno code on error; return zero when success.
*/
-static ssize_t cyapa_i2c_write(struct cyapa *cyapa, u8 reg,
+static int cyapa_i2c_write(struct cyapa *cyapa, u8 reg,
size_t len, const void *values)
{
- int ret;
struct i2c_client *client = cyapa->client;
char buf[32];
+ int ret;
- if (len > 31)
+ if (len > sizeof(buf) - 1)
return -ENOMEM;
buf[0] = reg;
memcpy(&buf[1], values, len);
+
ret = i2c_master_send(client, buf, len + 1);
+ if (ret != len + 1)
+ return ret < 0 ? ret : -EIO;
- return (ret == (len + 1)) ? 0 : ((ret < 0) ? ret : -EIO);
+ return 0;
}
static u8 cyapa_check_adapter_functionality(struct i2c_client *client)
@@ -143,7 +144,7 @@ static int cyapa_get_state(struct cyapa *cyapa)
goto error;
/*
- * Detect trackpad protocol based on characristic registers and bits.
+ * Detect trackpad protocol based on characteristic registers and bits.
*/
do {
cyapa->status[REG_OP_STATUS] = status[REG_OP_STATUS];
@@ -206,11 +207,15 @@ int cyapa_poll_state(struct cyapa *cyapa, unsigned int timeout)
int error;
int tries = timeout / 100;
- error = cyapa_get_state(cyapa);
- while ((error || cyapa->state <= CYAPA_STATE_BL_BUSY) && tries--) {
- msleep(100);
+ do {
error = cyapa_get_state(cyapa);
- }
+ // FIXME: I think it would be better if cyapa_get_state()
+ // returned -EAGAIN when bootloader is busy
+ if (!error && cyapa->state > CYAPA_STATE_BL_BUSY)
+ return 0;
+
+ msleep(100);
+ } while (tries--);
return (error == -EAGAIN || error == -ETIMEDOUT) ? -ETIMEDOUT : error;
}
@@ -294,7 +299,7 @@ static int cyapa_open(struct input_dev *input)
if (error)
return error;
- if (cyapa->operational && cyapa->ops->set_power_mode) {
+ if (cyapa->operational) {
/*
* though failed to set active power mode,
* but still may be able to work in lower scan rate
@@ -329,7 +334,8 @@ static void cyapa_close(struct input_dev *input)
mutex_lock(&cyapa->state_sync_lock);
disable_irq(client->irq);
- if (!CYAPA_BOOTLOADER(cyapa) && cyapa->ops->set_power_mode)
+
+ if (!CYAPA_BOOTLOADER(cyapa))
cyapa->ops->set_power_mode(cyapa, PWR_MODE_OFF, 0);
mutex_unlock(&cyapa->state_sync_lock);
@@ -484,7 +490,7 @@ static int cyapa_initialize(struct cyapa *cyapa)
return error;
/* Power down the device until we need it. */
- if (!CYAPA_BOOTLOADER(cyapa) && cyapa->ops->set_power_mode)
+ if (!CYAPA_BOOTLOADER(cyapa))
cyapa->ops->set_power_mode(cyapa, PWR_MODE_OFF, 0);
return 0;
@@ -497,7 +503,7 @@ static int cyapa_reinitialize(struct cyapa *cyapa)
int error;
/* Avoid command failures when TP was in OFF state. */
- if (!CYAPA_BOOTLOADER(cyapa) && cyapa->ops->set_power_mode)
+ if (!CYAPA_BOOTLOADER(cyapa))
cyapa->ops->set_power_mode(cyapa, PWR_MODE_FULL_ACTIVE, 0);
error = cyapa_detect(cyapa);
@@ -516,7 +522,7 @@ static int cyapa_reinitialize(struct cyapa *cyapa)
out:
if (!input || !input->users) {
/* Reset to power OFF state to save power when no user open. */
- if (!CYAPA_BOOTLOADER(cyapa) && cyapa->ops->set_power_mode)
+ if (!CYAPA_BOOTLOADER(cyapa))
cyapa->ops->set_power_mode(cyapa, PWR_MODE_OFF, 0);
}
@@ -647,9 +653,9 @@ static int __maybe_unused cyapa_suspend(struct device *dev)
* Set trackpad device to idle mode if wakeup is allowed,
* otherwise turn off.
*/
- power_mode = device_may_wakeup(dev) ? cyapa->suspend_power_mode
- : PWR_MODE_OFF;
- if (!CYAPA_BOOTLOADER(cyapa) && cyapa->ops->set_power_mode) {
+ if (!CYAPA_BOOTLOADER(cyapa)) {
+ power_mode = device_may_wakeup(dev) ?
+ cyapa->suspend_power_mode : PWR_MODE_OFF;
error = cyapa->ops->set_power_mode(cyapa, power_mode,
cyapa->suspend_sleep_time);
if (error)
^ permalink raw reply related [flat|nested] 28+ messages in thread
* RE: [PATCH v16 01/12] input: cyapa: re-design driver to support multi-trackpad in one driver
2014-12-30 1:06 ` Dmitry Torokhov
@ 2014-12-30 4:43 ` Dudley Du
0 siblings, 0 replies; 28+ messages in thread
From: Dudley Du @ 2014-12-30 4:43 UTC (permalink / raw)
To: Dmitry Torokhov
Cc: jmmahler, rydberg, bleung, linux-input, linux-kernel, David Solda
Dmitry,
Thanks a lot for your review and detail comments.
Please see my replies below.
Thanks,
Dudley
> -----Original Message-----
> From: Dmitry Torokhov [mailto:dmitry.torokhov@gmail.com]
> Sent: 2014?12?30? 9:06
> To: Dudley Du
> Cc: jmmahler@gmail.com; rydberg@euromail.se; bleung@google.com;
> linux-input@vger.kernel.org; linux-kernel@vger.kernel.org
> Subject: Re: [PATCH v16 01/12] input: cyapa: re-design driver to support
> multi-trackpad in one driver
>
> Hi Dudley,
>
> On Thu, Dec 18, 2014 at 06:00:45PM +0800, Dudley Du wrote:
> > In order to support multiple different chipsets and communication protocols
> > trackpad devices in one cyapa driver, the new cyapa driver is re-designed
> > with one cyapa driver core and multiple device specific functions component.
> > The cyapa driver core is contained in this patch, it supplies basic functions
> > that working with kernel and input subsystem, and also supplies the interfaces
> > that the specific devices' component can connect and work together with as
> > one driver.
> > TEST=test on Chromebooks.
>
> Thank you for making changes to the driver. It shapes up nicely, still
> I have a few comments:
>
> 1. I'd rather we did not check for presence of various methods in ops
> structure but rather rely on providers to supply stubs if they do not
> need actual implementation (see a draft of a patch below).
>
I will supply stubs for both in the ops structure.
> 2. Please consider changing CYAPA_BOOTLOADER() and friends to be static
> inline functions (like cyapa_is_bootloader_mode())- it provides better
> type checking.
>
I will supply statci inlie function cyapa_is_bootloader_mode() and
cyapa_is_operational_mode() instead of CYAPA_BOOTLOADER() and CYAPA_OPERATIONAL()
> 3. The ops->initialize() method should be called after we determine the
> generation of the device, not before.
>
No, it cannot be called after we determine the generation of the device.
Because the ops->initialize() is used to prepare the communication status for the driver.
It will initialize and parpare the communication for gen5 command process which
will be used in cyapa_detect() when detecting gen5, so It cannot be called after
we determine the generation of the device.
> 4. I wonder why cyapa_read_block() is in gen3 file and not in main file
> - it seems it is used by generic code?
>
cyapa_read_block() is mainly used to read block data from gen3 TP.
It is used in both main file and gen3 file.
And this function will use static variables cyapa_smbus_cmd[] and cyapa_i2c_cmds[]
which are dedicated to gen3 TP and defined in gen3 file, so I think it should be put
in the gen3 file instead of in main file to avoid put the variables
cyapa_smbus_cmd[] and cyapa_i2c_cmds[] into main file.
That why put it in gen3 file.
> 5. Is bootloader mode different between gen3 and gen5 devices? Or should
> you detect and handle bootloader mode directly in the core, maybe as a
> "fake generation"?
>
Yes, the bootloader mode is completely different between gen3 and gen5 device.
No protocol or mechanism could be shared.
For detect and handle bootloader mode directly in the core,
do you mean add the function to exit bootloader mode as do for firmware update?
Currently, the bootloader operation porcess of firmware update is abstracted
into cyapa_firmware() and put it in the core, other operations that are dedicated to gen3/gen5
TP device are seperated in to gen3/gen5 file.
> Thanks!
>
> >
> > Signed-off-by: Dudley Du <dudl@cypress.com>
> > ---
> > drivers/input/mouse/Makefile | 3 +-
> > drivers/input/mouse/cyapa.c | 1047 ++++++++++++++------------------------
> > drivers/input/mouse/cyapa.h | 307 +++++++++++
> > drivers/input/mouse/cyapa_gen3.c | 801 +++++++++++++++++++++++++++++
> > 4 files changed, 1492 insertions(+), 666 deletions(-)
> > create mode 100644 drivers/input/mouse/cyapa.h
> > create mode 100644 drivers/input/mouse/cyapa_gen3.c
> >
> > diff --git a/drivers/input/mouse/Makefile b/drivers/input/mouse/Makefile
.......
> > +
> > +.irq_handler = cyapa_gen3_irq_handler,
> > +.irq_cmd_handler = cyapa_gen3_irq_cmd_handler,
> > +
> > +.set_power_mode = cyapa_gen3_set_power_mode,
> > +};
> > --
> > 1.9.1
> >
>
> --
> Dmitry
>
> Input: cyapa - misc changes
>
> From: Dmitry Torokhov <dmitry.torokhov@gmail.com>
>
> Signed-off-by: Dmitry Torokhov <dmitry.torokhov@gmail.com>
> ---
> drivers/input/mouse/cyapa.c | 50 ++++++++++++++++++++++++-------------------
> 1 file changed, 28 insertions(+), 22 deletions(-)
>
> diff --git a/drivers/input/mouse/cyapa.c b/drivers/input/mouse/cyapa.c
> index ae1df15..27ae5e61 100644
> --- a/drivers/input/mouse/cyapa.c
> +++ b/drivers/input/mouse/cyapa.c
> @@ -36,10 +36,8 @@ const char product_id[] = "CYTRA";
> static int cyapa_reinitialize(struct cyapa *cyapa);
>
> /* Returns 0 on success, else negative errno on failure. */
> -static ssize_t cyapa_i2c_read(struct cyapa *cyapa, u8 reg, size_t len,
> -u8 *values)
> +static int cyapa_i2c_read(struct cyapa *cyapa, u8 reg, size_t len, u8 *values)
> {
> -int ret;
> struct i2c_client *client = cyapa->client;
> struct i2c_msg msgs[] = {
> {
> @@ -55,9 +53,9 @@ static ssize_t cyapa_i2c_read(struct cyapa *cyapa, u8 reg,
> size_t len,
> .buf = values,
> },
> };
> +int ret;
>
> -ret = i2c_transfer(client->adapter, msgs, 2);
> -
> +ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
> if (ret != ARRAY_SIZE(msgs))
> return ret < 0 ? ret : -EIO;
>
> @@ -73,21 +71,24 @@ static ssize_t cyapa_i2c_read(struct cyapa *cyapa, u8 reg,
> size_t len,
> *
> * Return negative errno code on error; return zero when success.
> */
> -static ssize_t cyapa_i2c_write(struct cyapa *cyapa, u8 reg,
> +static int cyapa_i2c_write(struct cyapa *cyapa, u8 reg,
> size_t len, const void *values)
> {
> -int ret;
> struct i2c_client *client = cyapa->client;
> char buf[32];
> +int ret;
>
> -if (len > 31)
> +if (len > sizeof(buf) - 1)
> return -ENOMEM;
>
> buf[0] = reg;
> memcpy(&buf[1], values, len);
> +
> ret = i2c_master_send(client, buf, len + 1);
> +if (ret != len + 1)
> +return ret < 0 ? ret : -EIO;
>
> -return (ret == (len + 1)) ? 0 : ((ret < 0) ? ret : -EIO);
> +return 0;
> }
>
> static u8 cyapa_check_adapter_functionality(struct i2c_client *client)
> @@ -143,7 +144,7 @@ static int cyapa_get_state(struct cyapa *cyapa)
> goto error;
>
> /*
> - * Detect trackpad protocol based on characristic registers and bits.
> + * Detect trackpad protocol based on characteristic registers and bits.
> */
> do {
> cyapa->status[REG_OP_STATUS] = status[REG_OP_STATUS];
> @@ -206,11 +207,15 @@ int cyapa_poll_state(struct cyapa *cyapa, unsigned int
> timeout)
> int error;
> int tries = timeout / 100;
>
> -error = cyapa_get_state(cyapa);
> -while ((error || cyapa->state <= CYAPA_STATE_BL_BUSY) && tries--) {
> -msleep(100);
> +do {
> error = cyapa_get_state(cyapa);
> -}
> +// FIXME: I think it would be better if cyapa_get_state()
> +// returned -EAGAIN when bootloader is busy
Thanks, I would like to add below code to check the BL_BUSY state before cyapa_get_state() return.
out_detected:
if (cyapa->state <= CYAPA_STATE_BL_BUSY)
return -EAGAIN;
return 0;
> +if (!error && cyapa->state > CYAPA_STATE_BL_BUSY)
> +return 0;
> +
> +msleep(100);
> +} while (tries--);
>
> return (error == -EAGAIN || error == -ETIMEDOUT) ? -ETIMEDOUT : error;
> }
> @@ -294,7 +299,7 @@ static int cyapa_open(struct input_dev *input)
> if (error)
> return error;
>
> -if (cyapa->operational && cyapa->ops->set_power_mode) {
> +if (cyapa->operational) {
> /*
> * though failed to set active power mode,
> * but still may be able to work in lower scan rate
> @@ -329,7 +334,8 @@ static void cyapa_close(struct input_dev *input)
> mutex_lock(&cyapa->state_sync_lock);
>
> disable_irq(client->irq);
> -if (!CYAPA_BOOTLOADER(cyapa) && cyapa->ops->set_power_mode)
> +
> +if (!CYAPA_BOOTLOADER(cyapa))
> cyapa->ops->set_power_mode(cyapa, PWR_MODE_OFF, 0);
>
> mutex_unlock(&cyapa->state_sync_lock);
> @@ -484,7 +490,7 @@ static int cyapa_initialize(struct cyapa *cyapa)
> return error;
>
> /* Power down the device until we need it. */
> -if (!CYAPA_BOOTLOADER(cyapa) && cyapa->ops->set_power_mode)
> +if (!CYAPA_BOOTLOADER(cyapa))
> cyapa->ops->set_power_mode(cyapa, PWR_MODE_OFF, 0);
>
> return 0;
> @@ -497,7 +503,7 @@ static int cyapa_reinitialize(struct cyapa *cyapa)
> int error;
>
> /* Avoid command failures when TP was in OFF state. */
> -if (!CYAPA_BOOTLOADER(cyapa) && cyapa->ops->set_power_mode)
> +if (!CYAPA_BOOTLOADER(cyapa))
> cyapa->ops->set_power_mode(cyapa, PWR_MODE_FULL_ACTIVE, 0);
>
> error = cyapa_detect(cyapa);
> @@ -516,7 +522,7 @@ static int cyapa_reinitialize(struct cyapa *cyapa)
> out:
> if (!input || !input->users) {
> /* Reset to power OFF state to save power when no user open. */
> -if (!CYAPA_BOOTLOADER(cyapa) && cyapa->ops->set_power_mode)
> +if (!CYAPA_BOOTLOADER(cyapa))
> cyapa->ops->set_power_mode(cyapa, PWR_MODE_OFF, 0);
> }
>
> @@ -647,9 +653,9 @@ static int __maybe_unused cyapa_suspend(struct device
> *dev)
> * Set trackpad device to idle mode if wakeup is allowed,
> * otherwise turn off.
> */
> -power_mode = device_may_wakeup(dev) ? cyapa->suspend_power_mode
> - : PWR_MODE_OFF;
> -if (!CYAPA_BOOTLOADER(cyapa) && cyapa->ops->set_power_mode) {
> +if (!CYAPA_BOOTLOADER(cyapa)) {
> +power_mode = device_may_wakeup(dev) ?
> +cyapa->suspend_power_mode : PWR_MODE_OFF;
> error = cyapa->ops->set_power_mode(cyapa, power_mode,
> cyapa->suspend_sleep_time);
> if (error)
This message and any attachments may contain Cypress (or its subsidiaries) confidential information. If it has been received in error, please advise the sender and immediately delete this message.
^ permalink raw reply [flat|nested] 28+ messages in thread
* RE: [PATCH v16 00/12] input: cyapa: instruction of cyapa patches
2014-12-17 9:55 Dudley Du
@ 2014-12-17 10:03 ` Dudley Du
0 siblings, 0 replies; 28+ messages in thread
From: Dudley Du @ 2014-12-17 10:03 UTC (permalink / raw)
To: dmitry.torokhov, jmmahler, rydberg
Cc: bleung, 'David Solda', linux-input, linux-kernel, Dudley Du
Jmmahler,
Thank you very much for your review and comments based on v15 patches.
I have modified all points based on your comments and generate this v16 patches.
Could you please help review again when have time.
By the way, since gmail is blocked again in my side, so I use private email
dudlx@outlook.com instead to send these patches manually.
Thanks,
Dudley
> -----Original Message-----
> From: Dudley Du [mailto:dudlx@outlook.com]
> Sent: 2014年12月17日 17:55
> To: dmitry.torokhov@gmail.com; jmmahler@gmail.com; rydberg@euromail.se
> Cc: bleung@google.com; David Solda; linux-input@vger.kernel.org;
> linux-kernel@vger.kernel.org
> Subject: [PATCH v16 00/12] input: cyapa: instruction of cyapa patches
>
> V16 patches have below updates, details of other updates see history list:
> 1) Fix all miss-spelling and space issue.
> 2) Rename variables and functions with much more clearer names.
> 3) Initialize and document tries near where it will be used.
> 4) Modify cmd buffer to struct for more descriptive way.
>
>
> This patch series is aimed to re-design the cyapa driver to support
> old gen3 trackpad devices and new gen5 trackpad devices in one
> cyapa driver, it's for easily productions support based on
> customers' requirements. And add sysfs functions and interfaces
> supported that required by users and customers.
>
> Since the earlier gen3 and the latest gen5 trackpad devices using
> two different chipsets, and have different protocols and interfaces,
> so if supported these two type trackpad devices in two different drivers,
> then it will be difficult to manage productions and later firmware updates.
> e.g.: It will cause customer don't know which one trackpad device firmware
> image to use and update when it has been used and integrated
> in same one productions, so here we support these two trackpad
> devices in same on driver.
>
> The new design cyapa driver contains:
> cyapa.c - the core of the re-design, supply interfaces and
> functions to system and read trackpad devices.
> cyapa.h - header file including macros and data structure definitions.
> cyapa_gen3.c - functions support for gen3 trackpad devices,
> cyapa_gen5.c - functions support for gen5 trackpad devices.
>
> Beside this introduction patch, it has 12 patches listed as below.
> For these patches, each one is patched based on previous one.
>
> patch 1/12: re-design cyapa driver with core functions and interface
> to support multi-type trackpad devices.
>
> patch 2/12: add gen5 trackpad device basic functions support in the
> re-design cyapa driver.
>
> patch 3/12: add power management interfaces support for the device.
>
> patch 4/12: add runtime power management interfaces support for the device.
>
> patch 5/12: add sysfs interfaces supported in the cyapa driver.
> Including read firmware version, get production ID, read baseline,
> re-calibrate trackpad baselines and do trackpad firmware update.
>
> patch 6/12: add gen3 trackpad device's firmware update function support.
>
> patch 7/12: add gen3 trackpad device's read baseline function support.
>
> patch 8/12: add gen3 trackpad device's force re-calibrate function support.
>
> patch 9/12: add gen5 trackpad device's firmware update function support.
>
> patch 10/12: add gen5 trackpad device's read baseline function support.
>
> patch 11/12: add gen5 trackpad device's force re-calibrate function.
>
> patch 12/12: add acpi device id support.
>
>
> History patch series modifications list:
> V15 patches have below main updates compared with v14 patches:
> 1) Fix all warning errors of sparse tool when running with "make C=1".
> 2) Change variable name "unique_str" to "product_id" for clearer meanings.
> 3) Update cyapa_i2c_write function to return error directly when length > 31.
>
> V14 patches have below main updates compared with v13 patches:
> 1) Correct 9 miss spelling issues of "bufferred" to "buffered".
> 2) Fix the upgrade issue of removing MOUSE_CYAPA config when make oldconfig
> by replase "depends on I2C && CRC_ITU_T" with
> "depends on I2C"
> "select CRC_ITU_T"
> in patch 9.
>
> V13 patches have below main updates compared with v12 patches:
> 1) Remove all debugfs interface, including read_fw and raw_data interfaces.
> 2) This patches are made based linux next-20141208.
>
> V12 patches have below main updates compared with v11 patches:
> 1) Add check that when TP is detected but not operational, do not exit driver
> immediately, but wait and export the update_fw interface for recovering.
> 2) Re-arrange the function codes, remove unnesseary protype definitions in
> the header file.
>
> V11 patches have below main updates compared with v10 patches:
> 1) Add add acpi device id supported for old gen3 and new gen5 trackpad
devices.
> 2) Fix the unable to update firmware issue when cyapa_open is not called
> which means the irq for firwmare update process is not enabled. This fix
> by checking if the irq is enabled, if not then enable irq before start to
> do firmware update.
>
> V10 patches have below main updates compared with v9 patches:
> 1) Modify code to following kernel code style.
> e.g.: correct to use error as return name when there is only error path,
> and fix the checkpatch.sh wanting in the driver.
> 2) Remove cyapa_remove method and use input open and close interface to
> following device resouse management infrastructure.
> 3) Modify cyapa_detect method to return tristate issue to make the return
value
> much more consistent and clear.
> 4) Use platform supplied functions as possible instead of driver
> specific rewritten version.
>
> V9 patches have below updates compared with v8 patches:
> 1) Removed all async thread stuff from the driver.
> 2) Split driver into 18 patches for each function change one patch.
>
> V8 patches have below updates compared with v7 patches:
> 1) [PATCH v8 01/13] - Remove the async thread for device detect in
> probe routine, now the device detect process is completely done within
> the device probe routine.
> 2) [PATCH v8 01/13] - Split the irq cmd hander function to separated
> function cyapa_default_irq_cmd_handler() and set it to interface
> cyapa_default_ops.irq_cmd_handler.
> 3) [PATCH v8 06/13] - Add cyapa->gen check in cyapa_gen3_irq_cmd_handler()
> to avoid miss-enter when device protocol is still in detecting.
>
> V7 patches have below updates compared with v6 patches:
> 1) [PATCH v7 01/13] - Split the irq cmd hander function to separated
> function cyapa_default_irq_cmd_handler() and set it to interface
> cyapa_default_ops.irq_cmd_handler.
> 2) [PATCH v7 06/13] - Add cyapa->gen check in cyapa_gen3_irq_cmd_handler()
> to avoid miss-enter when device protocol is still in detecting.
>
>
> V6 patches have below updates compared with v5 patches:
> 1) Remove patch 14 of the lid filtering from the cyapa driver.
>
> V5 patches have below updates compared with v4 patches:
> 1) Uses get_device()/put_device() instead of kobject_get()/kobject_put();
> 2) Fix memories freed before debugfs entries issue;
> 3) Make cyapa_debugs_root valid in driver module level
> in module_init()/moudle_exit() ;
> 4) Fix i2c_transfer() may return partial transfer issues.
> 5) Add cyapa->removed flag to avoid detecting thread may still running
> when driver module is removed.
> 6) Fix the meanings of some comments and return error code not clear issue.
^ permalink raw reply [flat|nested] 28+ messages in thread
* [PATCH v16 00/12] input: cyapa: instruction of cyapa patches
@ 2014-12-17 9:55 Dudley Du
2014-12-17 10:03 ` Dudley Du
0 siblings, 1 reply; 28+ messages in thread
From: Dudley Du @ 2014-12-17 9:55 UTC (permalink / raw)
To: dmitry.torokhov, jmmahler, rydberg
Cc: bleung, David Solda, linux-input, linux-kernel
V16 patches have below updates, details of other updates see history list:
1) Fix all miss-spelling and space issue.
2) Rename variables and functions with much more clearer names.
3) Initialize and document tries near where it will be used.
4) Modify cmd buffer to struct for more descriptive way.
This patch series is aimed to re-design the cyapa driver to support
old gen3 trackpad devices and new gen5 trackpad devices in one
cyapa driver, it's for easily productions support based on
customers' requirements. And add sysfs functions and interfaces
supported that required by users and customers.
Since the earlier gen3 and the latest gen5 trackpad devices using
two different chipsets, and have different protocols and interfaces,
so if supported these two type trackpad devices in two different drivers,
then it will be difficult to manage productions and later firmware updates.
e.g.: It will cause customer don't know which one trackpad device firmware
image to use and update when it has been used and integrated
in same one productions, so here we support these two trackpad
devices in same on driver.
The new design cyapa driver contains:
cyapa.c - the core of the re-design, supply interfaces and
functions to system and read trackpad devices.
cyapa.h - header file including macros and data structure definitions.
cyapa_gen3.c - functions support for gen3 trackpad devices,
cyapa_gen5.c - functions support for gen5 trackpad devices.
Beside this introduction patch, it has 12 patches listed as below.
For these patches, each one is patched based on previous one.
patch 1/12: re-design cyapa driver with core functions and interface
to support multi-type trackpad devices.
patch 2/12: add gen5 trackpad device basic functions support in the
re-design cyapa driver.
patch 3/12: add power management interfaces support for the device.
patch 4/12: add runtime power management interfaces support for the device.
patch 5/12: add sysfs interfaces supported in the cyapa driver.
Including read firmware version, get production ID, read baseline,
re-calibrate trackpad baselines and do trackpad firmware update.
patch 6/12: add gen3 trackpad device's firmware update function support.
patch 7/12: add gen3 trackpad device's read baseline function support.
patch 8/12: add gen3 trackpad device's force re-calibrate function support.
patch 9/12: add gen5 trackpad device's firmware update function support.
patch 10/12: add gen5 trackpad device's read baseline function support.
patch 11/12: add gen5 trackpad device's force re-calibrate function.
patch 12/12: add acpi device id support.
History patch series modifications list:
V15 patches have below main updates compared with v14 patches:
1) Fix all warning errors of sparse tool when running with "make C=1".
2) Change variable name "unique_str" to "product_id" for clearer meanings.
3) Update cyapa_i2c_write function to return error directly when length > 31.
V14 patches have below main updates compared with v13 patches:
1) Correct 9 miss spelling issues of "bufferred" to "buffered".
2) Fix the upgrade issue of removing MOUSE_CYAPA config when make oldconfig
by replase "depends on I2C && CRC_ITU_T" with
"depends on I2C"
"select CRC_ITU_T"
in patch 9.
V13 patches have below main updates compared with v12 patches:
1) Remove all debugfs interface, including read_fw and raw_data interfaces.
2) This patches are made based linux next-20141208.
V12 patches have below main updates compared with v11 patches:
1) Add check that when TP is detected but not operational, do not exit driver
immediately, but wait and export the update_fw interface for recovering.
2) Re-arrange the function codes, remove unnesseary protype definitions in
the header file.
V11 patches have below main updates compared with v10 patches:
1) Add add acpi device id supported for old gen3 and new gen5 trackpad devices.
2) Fix the unable to update firmware issue when cyapa_open is not called
which means the irq for firwmare update process is not enabled. This fix
by checking if the irq is enabled, if not then enable irq before start to
do firmware update.
V10 patches have below main updates compared with v9 patches:
1) Modify code to following kernel code style.
e.g.: correct to use error as return name when there is only error path,
and fix the checkpatch.sh wanting in the driver.
2) Remove cyapa_remove method and use input open and close interface to
following device resouse management infrastructure.
3) Modify cyapa_detect method to return tristate issue to make the return value
much more consistent and clear.
4) Use platform supplied functions as possible instead of driver
specific rewritten version.
V9 patches have below updates compared with v8 patches:
1) Removed all async thread stuff from the driver.
2) Split driver into 18 patches for each function change one patch.
V8 patches have below updates compared with v7 patches:
1) [PATCH v8 01/13] - Remove the async thread for device detect in
probe routine, now the device detect process is completely done within
the device probe routine.
2) [PATCH v8 01/13] - Split the irq cmd hander function to separated
function cyapa_default_irq_cmd_handler() and set it to interface
cyapa_default_ops.irq_cmd_handler.
3) [PATCH v8 06/13] - Add cyapa->gen check in cyapa_gen3_irq_cmd_handler()
to avoid miss-enter when device protocol is still in detecting.
V7 patches have below updates compared with v6 patches:
1) [PATCH v7 01/13] - Split the irq cmd hander function to separated
function cyapa_default_irq_cmd_handler() and set it to interface
cyapa_default_ops.irq_cmd_handler.
2) [PATCH v7 06/13] - Add cyapa->gen check in cyapa_gen3_irq_cmd_handler()
to avoid miss-enter when device protocol is still in detecting.
V6 patches have below updates compared with v5 patches:
1) Remove patch 14 of the lid filtering from the cyapa driver.
V5 patches have below updates compared with v4 patches:
1) Uses get_device()/put_device() instead of kobject_get()/kobject_put();
2) Fix memories freed before debugfs entries issue;
3) Make cyapa_debugs_root valid in driver module level
in module_init()/moudle_exit() ;
4) Fix i2c_transfer() may return partial transfer issues.
5) Add cyapa->removed flag to avoid detecting thread may still running
when driver module is removed.
6) Fix the meanings of some comments and return error code not clear issue.
^ permalink raw reply [flat|nested] 28+ messages in thread
end of thread, other threads:[~2014-12-30 4:43 UTC | newest]
Thread overview: 28+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2014-12-18 10:00 [PATCH v16 00/12] input: cyapa: instruction of cyapa patches Dudley Du
2014-12-18 10:00 ` [PATCH v16 01/12] input: cyapa: re-design driver to support multi-trackpad in one driver Dudley Du
2014-12-30 1:06 ` Dmitry Torokhov
2014-12-30 4:43 ` Dudley Du
2014-12-18 10:00 ` [PATCH v16 02/12] input: cyapa: add gen5 trackpad device basic functions support Dudley Du
2014-12-18 10:00 ` [PATCH v16 03/12] input: cyapa: add power management interfaces support for the device Dudley Du
2014-12-30 0:51 ` Dmitry Torokhov
2014-12-18 10:00 ` [PATCH v16 04/12] input: cyapa: add runtime " Dudley Du
2014-12-30 0:57 ` Dmitry Torokhov
2014-12-18 10:00 ` [PATCH v16 05/12] input: cyapa: add sysfs interfaces support in the cyapa driver Dudley Du
2014-12-18 10:00 ` [PATCH v16 06/12] input: cyapa: add gen3 trackpad device firmware update function support Dudley Du
2014-12-18 10:00 ` [PATCH v16 07/12] input: cyapa: add gen3 trackpad device read baseline " Dudley Du
2014-12-18 10:00 ` [PATCH v16 08/12] input: cyapa: add gen3 trackpad device force re-calibrate " Dudley Du
2014-12-18 10:00 ` [PATCH v16 09/12] input: cyapa: add gen5 trackpad device firmware update " Dudley Du
2014-12-18 10:00 ` [PATCH v16 10/12] input: cyapa: add gen5 trackpad device read baseline " Dudley Du
2014-12-18 10:00 ` [PATCH v16 11/12] input: cyapa: add gen5 trackpad device force re-calibrate " Dudley Du
2014-12-18 10:00 ` [PATCH v16 12/12] input: cyapa: add acpi device id support Dudley Du
2014-12-18 11:06 ` [PATCH v16 00/12] input: cyapa: instruction of cyapa patches Dudley Du
2014-12-18 20:17 ` Benson Leung
2014-12-18 22:14 ` Jeremiah Mahler
2014-12-19 1:45 ` Dudley Du
2014-12-20 7:15 ` Jeremiah Mahler
2014-12-20 7:31 ` Dmitry Torokhov
2014-12-22 2:09 ` Dudley Du
2014-12-22 2:39 ` Dmitry Torokhov
2014-12-22 2:56 ` Dudley Du
-- strict thread matches above, loose matches on Subject: below --
2014-12-17 9:55 Dudley Du
2014-12-17 10:03 ` Dudley Du
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).