From f5fc300530637719a9fe8a90218524155ceb2ec3 Mon Sep 17 00:00:00 2001 From: Wendly Li Date: Fri, 12 Aug 2022 04:10:04 +0000 Subject: touch/gti: Support mutual and self sensing data for sysfs Bug: 214118904 Test: Check dumpstate works properly Change-Id: I17074fcf95e43173b79bc8d767904cf06801d8a3 Signed-off-by: Wendly Li --- goog_touch_interface.c | 264 ++++++++++++++++++++++++++++++++++++++++++++++++- goog_touch_interface.h | 23 ++++- 2 files changed, 284 insertions(+), 3 deletions(-) diff --git a/goog_touch_interface.c b/goog_touch_interface.c index ea4146c..60b3a8e 100644 --- a/goog_touch_interface.c +++ b/goog_touch_interface.c @@ -43,6 +43,12 @@ static ssize_t mf_mode_show(struct device *dev, struct device_attribute *attr, char *buf); static ssize_t mf_mode_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size); +static ssize_t ms_base_show(struct device *dev, + struct device_attribute *attr, char *buf); +static ssize_t ms_diff_show(struct device *dev, + struct device_attribute *attr, char *buf); +static ssize_t ms_raw_show(struct device *dev, + struct device_attribute *attr, char *buf); static ssize_t offload_enabled_show(struct device *dev, struct device_attribute *attr, char *buf); static ssize_t offload_enabled_store(struct device *dev, @@ -67,6 +73,12 @@ static ssize_t screen_protector_mode_enabled_show(struct device *dev, struct device_attribute *attr, char *buf); static ssize_t self_test_show(struct device *dev, struct device_attribute *attr, char *buf); +static ssize_t ss_base_show(struct device *dev, + struct device_attribute *attr, char *buf); +static ssize_t ss_diff_show(struct device *dev, + struct device_attribute *attr, char *buf); +static ssize_t ss_raw_show(struct device *dev, + struct device_attribute *attr, char *buf); static ssize_t sensing_enabled_show(struct device *dev, struct device_attribute *attr, char *buf); static ssize_t sensing_enabled_store(struct device *dev, @@ -81,6 +93,9 @@ static DEVICE_ATTR_RO(fw_ver); static DEVICE_ATTR_RW(grip_enabled); static DEVICE_ATTR_RW(irq_enabled); static DEVICE_ATTR_RW(mf_mode); +static DEVICE_ATTR_RO(ms_base); +static DEVICE_ATTR_RO(ms_diff); +static DEVICE_ATTR_RO(ms_raw); static DEVICE_ATTR_RW(offload_enabled); static DEVICE_ATTR_RW(palm_enabled); static DEVICE_ATTR_RO(ping); @@ -88,6 +103,9 @@ static DEVICE_ATTR_RW(reset); static DEVICE_ATTR_RW(scan_mode); static DEVICE_ATTR_RW(screen_protector_mode_enabled); static DEVICE_ATTR_RO(self_test); +static DEVICE_ATTR_RO(ss_base); +static DEVICE_ATTR_RO(ss_diff); +static DEVICE_ATTR_RO(ss_raw); static DEVICE_ATTR_RW(sensing_enabled); static DEVICE_ATTR_RW(v4l2_enabled); @@ -97,6 +115,9 @@ static struct attribute *goog_attributes[] = { &dev_attr_grip_enabled.attr, &dev_attr_irq_enabled.attr, &dev_attr_mf_mode.attr, + &dev_attr_ms_base.attr, + &dev_attr_ms_diff.attr, + &dev_attr_ms_raw.attr, &dev_attr_offload_enabled.attr, &dev_attr_palm_enabled.attr, &dev_attr_ping.attr, @@ -104,6 +125,9 @@ static struct attribute *goog_attributes[] = { &dev_attr_scan_mode.attr, &dev_attr_screen_protector_mode_enabled.attr, &dev_attr_self_test.attr, + &dev_attr_ss_base.attr, + &dev_attr_ss_diff.attr, + &dev_attr_ss_raw.attr, &dev_attr_sensing_enabled.attr, &dev_attr_v4l2_enabled.attr, NULL, @@ -325,6 +349,117 @@ static ssize_t mf_mode_store(struct device *dev, return size; } +static ssize_t ms_base_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + ssize_t buf_idx = 0; + struct goog_touch_interface *gti = dev_get_drvdata(dev); + struct gti_sensor_data_cmd *cmd = >i->cmd.sensor_data_cmd; + int ret = 0; + u16 tx = gti->offload.caps.tx_size; + u16 rx = gti->offload.caps.rx_size; + int x, y; + + cmd->type = GTI_SENSOR_DATA_TYPE_MS_BASELINE; + cmd->buffer = NULL; + cmd->size = 0; + ret = goog_process_vendor_cmd(gti, GTI_CMD_GET_SENSOR_DATA); + if (ret == -EOPNOTSUPP) { + buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE, + "error: not supported!\n"); + } else if (ret) { + buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE, + "error: %d!\n", ret); + } else { + buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE, "result:\n"); + if (cmd->buffer && cmd->size == TOUCH_OFFLOAD_DATA_SIZE_2D(rx, tx)) { + for (y = 0; y < rx; y++) { + for (x = 0; x < tx; x++) { + buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE, + "%5d,", ((s16 *)cmd->buffer)[y * tx + x]); + } + buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE, "\n"); + } + GOOG_LOG("%s", buf); + } + } + return buf_idx; +} + +static ssize_t ms_diff_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + ssize_t buf_idx = 0; + struct goog_touch_interface *gti = dev_get_drvdata(dev); + struct gti_sensor_data_cmd *cmd = >i->cmd.sensor_data_cmd; + int ret = 0; + u16 tx = gti->offload.caps.tx_size; + u16 rx = gti->offload.caps.rx_size; + int x, y; + + cmd->type = GTI_SENSOR_DATA_TYPE_MS_DIFF; + cmd->buffer = NULL; + cmd->size = 0; + ret = goog_process_vendor_cmd(gti, GTI_CMD_GET_SENSOR_DATA); + if (ret == -EOPNOTSUPP) { + buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE, + "error: not supported!\n"); + } else if (ret) { + buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE, + "error: %d!\n", ret); + } else { + buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE, "result:\n"); + if (cmd->buffer && cmd->size == TOUCH_OFFLOAD_DATA_SIZE_2D(rx, tx)) { + for (y = 0; y < rx; y++) { + for (x = 0; x < tx; x++) { + buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE, + "%5d,", ((s16 *)cmd->buffer)[y * tx + x]); + } + buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE, "\n"); + } + GOOG_LOG("%s", buf); + } + } + return buf_idx; +} + +static ssize_t ms_raw_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + ssize_t buf_idx = 0; + struct goog_touch_interface *gti = dev_get_drvdata(dev); + struct gti_sensor_data_cmd *cmd = >i->cmd.sensor_data_cmd; + int ret = 0; + u16 tx = gti->offload.caps.tx_size; + u16 rx = gti->offload.caps.rx_size; + int x, y; + + cmd->type = GTI_SENSOR_DATA_TYPE_MS_RAW; + cmd->buffer = NULL; + cmd->size = 0; + ret = goog_process_vendor_cmd(gti, GTI_CMD_GET_SENSOR_DATA); + if (ret == -EOPNOTSUPP) { + buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE, + "error: not supported!\n"); + } else if (ret) { + buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE, + "error: %d!\n", ret); + } else { + buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE, "result:\n"); + if (cmd->buffer && cmd->size == TOUCH_OFFLOAD_DATA_SIZE_2D(rx, tx)) { + for (y = 0; y < rx; y++) { + for (x = 0; x < tx; x++) { + buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE, + "%5d,", ((s16 *)cmd->buffer)[y * tx + x]); + } + buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE, "\n"); + } + GOOG_LOG("%s", buf); + } + } + return buf_idx; +} + static ssize_t offload_enabled_show(struct device *dev, struct device_attribute *attr, char *buf) { @@ -626,6 +761,132 @@ static ssize_t self_test_show(struct device *dev, return buf_idx; } +static ssize_t ss_base_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + ssize_t buf_idx = 0; + struct goog_touch_interface *gti = dev_get_drvdata(dev); + struct gti_sensor_data_cmd *cmd = >i->cmd.sensor_data_cmd; + int ret = 0; + u16 tx = gti->offload.caps.tx_size; + u16 rx = gti->offload.caps.rx_size; + int x, y; + + cmd->type = GTI_SENSOR_DATA_TYPE_SS_BASELINE; + cmd->buffer = NULL; + cmd->size = 0; + ret = goog_process_vendor_cmd(gti, GTI_CMD_GET_SENSOR_DATA); + if (ret == -EOPNOTSUPP) { + buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE, + "error: not supported!\n"); + } else if (ret) { + buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE, + "error: %d!\n", ret); + } else { + buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE, "result:\n"); + if (cmd->buffer && + cmd->size == TOUCH_OFFLOAD_DATA_SIZE_2D(rx, tx)) { + buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE, "TX:"); + for (x = 0; x < tx; x++) { + buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE, + "%5d,", ((s16 *)cmd->buffer)[x]); + } + + buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE, "\nRX:"); + for (y = 0; y < rx; y++) { + buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE, + "%5d,", ((s16 *)cmd->buffer)[tx + y]); + } + GOOG_LOG("%s", buf); + } + } + return buf_idx; +} + +static ssize_t ss_diff_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + ssize_t buf_idx = 0; + struct goog_touch_interface *gti = dev_get_drvdata(dev); + struct gti_sensor_data_cmd *cmd = >i->cmd.sensor_data_cmd; + int ret = 0; + u16 tx = gti->offload.caps.tx_size; + u16 rx = gti->offload.caps.rx_size; + int x, y; + + cmd->type = GTI_SENSOR_DATA_TYPE_SS_DIFF; + cmd->buffer = NULL; + cmd->size = 0; + ret = goog_process_vendor_cmd(gti, GTI_CMD_GET_SENSOR_DATA); + if (ret == -EOPNOTSUPP) { + buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE, + "error: not supported!\n"); + } else if (ret) { + buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE, + "error: %d!\n", ret); + } else { + buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE, "result:\n"); + if (cmd->buffer && + cmd->size == TOUCH_OFFLOAD_DATA_SIZE_2D(rx, tx)) { + buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE, "TX:"); + for (x = 0; x < tx; x++) { + buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE, + "%5d,", ((s16 *)cmd->buffer)[x]); + } + + buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE, "\nRX:"); + for (y = 0; y < rx; y++) { + buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE, + "%5d,", ((s16 *)cmd->buffer)[tx + y]); + } + GOOG_LOG("%s", buf); + } + } + return buf_idx; +} + +static ssize_t ss_raw_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + ssize_t buf_idx = 0; + struct goog_touch_interface *gti = dev_get_drvdata(dev); + struct gti_sensor_data_cmd *cmd = >i->cmd.sensor_data_cmd; + int ret = 0; + u16 tx = gti->offload.caps.tx_size; + u16 rx = gti->offload.caps.rx_size; + int x, y; + + cmd->type = GTI_SENSOR_DATA_TYPE_SS_RAW; + cmd->buffer = NULL; + cmd->size = 0; + ret = goog_process_vendor_cmd(gti, GTI_CMD_GET_SENSOR_DATA); + if (ret == -EOPNOTSUPP) { + buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE, + "error: not supported!\n"); + } else if (ret) { + buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE, + "error: %d!\n", ret); + } else { + buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE, "result:\n"); + if (cmd->buffer && + cmd->size == TOUCH_OFFLOAD_DATA_SIZE_2D(rx, tx)) { + buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE, "TX:"); + for (x = 0; x < tx; x++) { + buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE, + "%5d,", ((s16 *)cmd->buffer)[x]); + } + + buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE, "\nRX:"); + for (y = 0; y < rx; y++) { + buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE, + "%5d,", ((s16 *)cmd->buffer)[tx + y]); + } + GOOG_LOG("%s", buf); + } + } + return buf_idx; +} + static ssize_t sensing_enabled_show(struct device *dev, struct device_attribute *attr, char *buf) { @@ -1264,7 +1525,6 @@ void goog_offload_populate_frame(struct goog_touch_interface *gti, channel_type = frame->channel_type[i]; GOOG_DBG("#%d: get data(type %#x) from vendor driver", i, channel_type); ret = 0; - cmd->type = channel_type; cmd->buffer = NULL; cmd->size = 0; if (channel_type == TOUCH_DATA_TYPE_COORD) { @@ -1273,6 +1533,7 @@ void goog_offload_populate_frame(struct goog_touch_interface *gti, ATRACE_END(); } else if (channel_type & TOUCH_SCAN_TYPE_MUTUAL) { ATRACE_BEGIN("populate mutual data"); + cmd->type = GTI_SENSOR_DATA_TYPE_MS; ret = goog_process_vendor_cmd(gti, GTI_CMD_GET_SENSOR_DATA); if (ret == 0 && cmd->buffer && cmd->size == TOUCH_OFFLOAD_DATA_SIZE_2D(rx, tx)) { @@ -1285,6 +1546,7 @@ void goog_offload_populate_frame(struct goog_touch_interface *gti, ATRACE_END(); } else if (channel_type & TOUCH_SCAN_TYPE_SELF) { ATRACE_BEGIN("populate self data"); + cmd->type = GTI_SENSOR_DATA_TYPE_SS; ret = goog_process_vendor_cmd(gti, GTI_CMD_GET_SENSOR_DATA); if (ret == 0 && cmd->buffer && cmd->size == TOUCH_OFFLOAD_DATA_SIZE_1D(rx, tx)) { diff --git a/goog_touch_interface.h b/goog_touch_interface.h index efce26a..fed5fd5 100644 --- a/goog_touch_interface.h +++ b/goog_touch_interface.h @@ -189,10 +189,29 @@ enum gti_sensing_mode : u32 { GTI_SENSING_MODE_NA = 0xFFFFFFFF, }; +/* Touch read method for automatically reading data from interrupt */ +#define TOUCH_SENSOR_DATA_READ_METHOD_INT 0x10000 +/* Touch read method for manually reading data from command */ +#define TOUCH_SENSOR_DATA_READ_METHOD_COMMAND 0x20000 + enum gti_sensor_data_type : u32 { GTI_SENSOR_DATA_TYPE_COORD = TOUCH_DATA_TYPE_COORD, - GTI_SENSOR_DATA_TYPE_MS = TOUCH_SCAN_TYPE_MUTUAL | TOUCH_DATA_TYPE_STRENGTH, - GTI_SENSOR_DATA_TYPE_SS = TOUCH_SCAN_TYPE_SELF | TOUCH_DATA_TYPE_STRENGTH, + GTI_SENSOR_DATA_TYPE_MS = TOUCH_SENSOR_DATA_READ_METHOD_INT | + TOUCH_SCAN_TYPE_MUTUAL | TOUCH_DATA_TYPE_STRENGTH, + GTI_SENSOR_DATA_TYPE_MS_DIFF = TOUCH_SENSOR_DATA_READ_METHOD_COMMAND | + TOUCH_SCAN_TYPE_MUTUAL | TOUCH_DATA_TYPE_STRENGTH, + GTI_SENSOR_DATA_TYPE_MS_RAW = TOUCH_SENSOR_DATA_READ_METHOD_COMMAND | + TOUCH_SCAN_TYPE_MUTUAL | TOUCH_DATA_TYPE_RAW, + GTI_SENSOR_DATA_TYPE_MS_BASELINE = TOUCH_SENSOR_DATA_READ_METHOD_COMMAND | + TOUCH_SCAN_TYPE_MUTUAL | TOUCH_DATA_TYPE_BASELINE, + GTI_SENSOR_DATA_TYPE_SS = TOUCH_SENSOR_DATA_READ_METHOD_INT | + TOUCH_SCAN_TYPE_SELF | TOUCH_DATA_TYPE_STRENGTH, + GTI_SENSOR_DATA_TYPE_SS_DIFF = TOUCH_SENSOR_DATA_READ_METHOD_COMMAND | + TOUCH_SCAN_TYPE_SELF | TOUCH_DATA_TYPE_STRENGTH, + GTI_SENSOR_DATA_TYPE_SS_RAW = TOUCH_SENSOR_DATA_READ_METHOD_COMMAND | + TOUCH_SCAN_TYPE_SELF | TOUCH_DATA_TYPE_RAW, + GTI_SENSOR_DATA_TYPE_SS_BASELINE = TOUCH_SENSOR_DATA_READ_METHOD_COMMAND | + TOUCH_SCAN_TYPE_SELF | TOUCH_DATA_TYPE_BASELINE, }; enum gti_vendor_dev_pm_state : u32 { -- cgit v1.2.3