diff options
author | davidycchen <davidycchen@google.com> | 2023-02-02 15:44:02 +0800 |
---|---|---|
committer | davidycchen <davidycchen@google.com> | 2023-02-02 15:44:02 +0800 |
commit | d2a3010da273bd6d0fd316ecce8c4721588dafa1 (patch) | |
tree | f4b6ddf9ecd35387d1d9cef14dbbe000d2c35436 | |
parent | b8e2ef7c54119774b2961205dad4009f45500d50 (diff) | |
parent | 6d6f95a605963369933367755ab84dc14acb819d (diff) | |
download | common-d2a3010da273bd6d0fd316ecce8c4721588dafa1.tar.gz |
Merge android13-gs-pixel-5.10-tm-qpr3 into android14-gs-pixel-5.15
Fixed build breaks and merge conflicts.
Change-Id: I7ab1f1889e6566c94a4d7fcf2431e33280c89cdc
Signed-off-by: davidycchen <davidycchen@google.com>
-rw-r--r-- | goog_touch_interface.c | 783 | ||||
-rw-r--r-- | goog_touch_interface.h | 35 |
2 files changed, 612 insertions, 206 deletions
diff --git a/goog_touch_interface.c b/goog_touch_interface.c index dcf20db..18d0f99 100644 --- a/goog_touch_interface.c +++ b/goog_touch_interface.c @@ -8,6 +8,8 @@ #include <linux/module.h> #include <linux/input/mt.h> #include <linux/of.h> +#include <linux/proc_fs.h> +#include <linux/seq_file.h> #include <samsung/exynos_drm_connector.h> #include "goog_touch_interface.h" @@ -28,10 +30,302 @@ static u8 gti_dev_num; */ static void goog_offload_set_running(struct goog_touch_interface *gti, bool running); static void goog_lookup_touch_report_rate(struct goog_touch_interface *gti); +static int goog_precheck_heatmap(struct goog_touch_interface *gti); static void goog_set_display_state(struct goog_touch_interface *gti, enum gti_display_state_setting display_state); /*----------------------------------------------------------------------------- + * GTI/proc: forward declarations, structures and functions. + */ +static int goog_proc_ms_base_show(struct seq_file *m, void *v); +static int goog_proc_ms_diff_show(struct seq_file *m, void *v); +static int goog_proc_ms_raw_show(struct seq_file *m, void *v); +static int goog_proc_ss_base_show(struct seq_file *m, void *v); +static int goog_proc_ss_diff_show(struct seq_file *m, void *v); +static int goog_proc_ss_raw_show(struct seq_file *m, void *v); +static struct proc_dir_entry *gti_proc_dir_root; +static char *gti_proc_name[GTI_PROC_NUM] = { + [GTI_PROC_MS_BASE] = "ms_base", + [GTI_PROC_MS_DIFF] = "ms_diff", + [GTI_PROC_MS_RAW] = "ms_raw", + [GTI_PROC_SS_BASE] = "ss_base", + [GTI_PROC_SS_DIFF] = "ss_diff", + [GTI_PROC_SS_RAW] = "ss_raw", +}; +static int (*gti_proc_show[GTI_PROC_NUM]) (struct seq_file *, void *) = { + [GTI_PROC_MS_BASE] = goog_proc_ms_base_show, + [GTI_PROC_MS_DIFF] = goog_proc_ms_diff_show, + [GTI_PROC_MS_RAW] = goog_proc_ms_raw_show, + [GTI_PROC_SS_BASE] = goog_proc_ss_base_show, + [GTI_PROC_SS_DIFF] = goog_proc_ss_diff_show, + [GTI_PROC_SS_RAW] = goog_proc_ss_raw_show, +}; +DEFINE_PROC_SHOW_ATTRIBUTE(goog_proc_ms_base); +DEFINE_PROC_SHOW_ATTRIBUTE(goog_proc_ms_diff); +DEFINE_PROC_SHOW_ATTRIBUTE(goog_proc_ms_raw); +DEFINE_PROC_SHOW_ATTRIBUTE(goog_proc_ss_base); +DEFINE_PROC_SHOW_ATTRIBUTE(goog_proc_ss_diff); +DEFINE_PROC_SHOW_ATTRIBUTE(goog_proc_ss_raw); + +static void goog_proc_heatmap_show(struct seq_file *m, void *v) +{ + struct goog_touch_interface *gti = m->private; + struct gti_sensor_data_cmd *cmd = >i->cmd.manual_sensor_data_cmd; + u16 tx = gti->offload.caps.tx_size; + u16 rx = gti->offload.caps.rx_size; + int x, y; + + if (cmd->size == 0 || cmd->buffer == NULL) { + seq_puts(m, "result: N/A!\n"); + GOOG_WARN(gti, "result: N/A!\n"); + return; + } + + switch (cmd->type) { + case GTI_SENSOR_DATA_TYPE_MS_BASELINE: + case GTI_SENSOR_DATA_TYPE_MS_DIFF: + case GTI_SENSOR_DATA_TYPE_MS_RAW: + if (cmd->size == TOUCH_OFFLOAD_DATA_SIZE_2D(rx, tx)) { + seq_puts(m, "result:\n"); + for (y = 0; y < rx; y++) { + for (x = 0; x < tx; x++) + seq_printf(m, "%5d,", ((s16 *)cmd->buffer)[y * tx + x]); + seq_puts(m, "\n"); + } + } else { + seq_printf(m, "error: invalid buffer %p or size %d!\n", + cmd->buffer, cmd->size); + GOOG_WARN(gti, "error: invalid buffer %p or size %d!\n", + cmd->buffer, cmd->size); + } + break; + + case GTI_SENSOR_DATA_TYPE_SS_BASELINE: + case GTI_SENSOR_DATA_TYPE_SS_DIFF: + case GTI_SENSOR_DATA_TYPE_SS_RAW: + if (cmd->size == TOUCH_OFFLOAD_DATA_SIZE_1D(rx, tx)) { + seq_puts(m, "result:\n"); + seq_puts(m, "TX:"); + for (x = 0; x < tx; x++) + seq_printf(m, "%5d,", ((s16 *)cmd->buffer)[x]); + seq_puts(m, "\nRX:"); + for (y = 0; y < rx; y++) + seq_printf(m, "%5d,", ((s16 *)cmd->buffer)[tx + y]); + seq_puts(m, "\n"); + } else { + seq_printf(m, "error: invalid buffer %p or size %d!\n", + cmd->buffer, cmd->size); + GOOG_WARN(gti, "error: invalid buffer %p or size %d!\n", + cmd->buffer, cmd->size); + } + break; + + default: + seq_printf(m, "error: invalid type %#x!\n", cmd->type); + GOOG_ERR(gti, "error: invalid type %#x!\n", cmd->type); + break; + } +} + +static int goog_proc_heatmap_process(struct seq_file *m, void *v, enum gti_sensor_data_type type) +{ + struct goog_touch_interface *gti = m->private; + struct gti_sensor_data_cmd *cmd = >i->cmd.manual_sensor_data_cmd; + int ret = 0; + + ret = goog_precheck_heatmap(gti); + if (ret) { + seq_puts(m, "N/A!\n"); + goto heatmap_process_err; + } + + switch (type) { + case GTI_SENSOR_DATA_TYPE_MS_BASELINE: + case GTI_SENSOR_DATA_TYPE_MS_DIFF: + case GTI_SENSOR_DATA_TYPE_MS_RAW: + case GTI_SENSOR_DATA_TYPE_SS_BASELINE: + case GTI_SENSOR_DATA_TYPE_SS_DIFF: + case GTI_SENSOR_DATA_TYPE_SS_RAW: + cmd->type = type; + break; + + default: + seq_printf(m, "error: invalid type %#x!\n", type); + GOOG_ERR(gti, "error: invalid type %#x!\n", type); + ret = -EINVAL; + break; + } + + if (ret) + goto heatmap_process_err; + + cmd->buffer = NULL; + cmd->size = 0; + ret = goog_process_vendor_cmd(gti, GTI_CMD_GET_SENSOR_DATA_MANUAL); + if (ret) { + seq_printf(m, "error: %d!\n", ret); + GOOG_ERR(gti, "error: %d!\n", ret); + } else { + GOOG_INFO(gti, "type %#x.\n", type); + } + +heatmap_process_err: + if (ret) { + cmd->buffer = NULL; + cmd->size = 0; + } + return ret; +} + +static int goog_proc_ms_base_show(struct seq_file *m, void *v) +{ + struct goog_touch_interface *gti = m->private; + int ret; + + ret = mutex_lock_interruptible(>i->input_process_lock); + if (ret) { + seq_puts(m, "error: has been interrupted!\n"); + GOOG_WARN(gti, "error: has been interrupted!\n"); + return ret; + } + + ret = goog_proc_heatmap_process(m, v, GTI_SENSOR_DATA_TYPE_MS_BASELINE); + if (!ret) + goog_proc_heatmap_show(m, v); + mutex_unlock(>i->input_process_lock); + + return ret; +} + +static int goog_proc_ms_diff_show(struct seq_file *m, void *v) +{ + struct goog_touch_interface *gti = m->private; + int ret; + + ret = mutex_lock_interruptible(>i->input_process_lock); + if (ret) { + seq_puts(m, "error: has been interrupted!\n"); + GOOG_WARN(gti, "error: has been interrupted!\n"); + return ret; + } + ret = goog_proc_heatmap_process(m, v, GTI_SENSOR_DATA_TYPE_MS_DIFF); + if (!ret) + goog_proc_heatmap_show(m, v); + mutex_unlock(>i->input_process_lock); + + return ret; +} + +static int goog_proc_ms_raw_show(struct seq_file *m, void *v) +{ + struct goog_touch_interface *gti = m->private; + int ret; + + ret = mutex_lock_interruptible(>i->input_process_lock); + if (ret) { + seq_puts(m, "error: has been interrupted!\n"); + GOOG_WARN(gti, "error: has been interrupted!\n"); + return ret; + } + + ret = goog_proc_heatmap_process(m, v, GTI_SENSOR_DATA_TYPE_MS_RAW); + if (!ret) + goog_proc_heatmap_show(m, v); + mutex_unlock(>i->input_process_lock); + + return ret; +} + +static int goog_proc_ss_base_show(struct seq_file *m, void *v) +{ + struct goog_touch_interface *gti = m->private; + int ret; + + ret = mutex_lock_interruptible(>i->input_process_lock); + if (ret) { + seq_puts(m, "error: has been interrupted!\n"); + GOOG_WARN(gti, "error: has been interrupted!\n"); + return ret; + } + + ret = goog_proc_heatmap_process(m, v, GTI_SENSOR_DATA_TYPE_SS_BASELINE); + if (!ret) + goog_proc_heatmap_show(m, v); + mutex_unlock(>i->input_process_lock); + + return ret; +} + +static int goog_proc_ss_diff_show(struct seq_file *m, void *v) +{ + struct goog_touch_interface *gti = m->private; + int ret; + + ret = mutex_lock_interruptible(>i->input_process_lock); + if (ret) { + seq_puts(m, "error: has been interrupted!\n"); + GOOG_WARN(gti, "error: has been interrupted!\n"); + return ret; + } + + ret = goog_proc_heatmap_process(m, v, GTI_SENSOR_DATA_TYPE_SS_DIFF); + if (!ret) + goog_proc_heatmap_show(m, v); + mutex_unlock(>i->input_process_lock); + + return ret; +} + +static int goog_proc_ss_raw_show(struct seq_file *m, void *v) +{ + struct goog_touch_interface *gti = m->private; + int ret; + + ret = mutex_lock_interruptible(>i->input_process_lock); + if (ret) { + seq_puts(m, "error: has been interrupted!\n"); + GOOG_WARN(gti, "error: has been interrupted!\n"); + return ret; + } + + ret = goog_proc_heatmap_process(m, v, GTI_SENSOR_DATA_TYPE_SS_RAW); + if (!ret) + goog_proc_heatmap_show(m, v); + mutex_unlock(>i->input_process_lock); + + return ret; +} + +static void goog_init_proc(struct goog_touch_interface *gti) +{ + int type; + + if (!gti_proc_dir_root) { + gti_proc_dir_root = proc_mkdir(GTI_NAME, NULL); + if (!gti_proc_dir_root) { + pr_err("%s: proc_mkdir failed for %s!\n", __func__, GTI_NAME); + return; + } + } + + gti->proc_dir = proc_mkdir_data(dev_name(gti->dev), 0555, gti_proc_dir_root, gti); + if (!gti->proc_dir) { + GOOG_ERR(gti, "proc_mkdir_data failed!\n"); + return; + } + + for (type = GTI_PROC_MS_BASE; type < GTI_PROC_NUM; type++) { + char *name = gti_proc_name[type]; + + if (gti_proc_show[type]) + gti->proc_heatmap[type] = proc_create_single_data( + name, 0555, gti->proc_dir, gti_proc_show[type], gti); + if (!gti->proc_heatmap[type]) + GOOG_ERR(gti, "proc_create_single_data failed for %s!\n", name); + } +} + +/*----------------------------------------------------------------------------- * GTI/sysfs: forward declarations, structures and functions. */ static ssize_t force_active_show( @@ -159,10 +453,15 @@ static ssize_t force_active_show( ssize_t buf_idx = 0; bool locked = false; + if (gti->ignore_force_active) { + GOOG_WARN(gti, "operation not supported!\n"); + return -EOPNOTSUPP; + } + locked = goog_pm_wake_check_locked(gti, GTI_PM_WAKELOCK_TYPE_FORCE_ACTIVE); buf_idx += scnprintf(buf, PAGE_SIZE - buf_idx, "result: %s\n", locked ? "locked" : "unlocked"); - GOOG_INFO("%s", buf); + GOOG_INFO(gti, "%s", buf); return buf_idx; } @@ -175,39 +474,36 @@ static ssize_t force_active_store(struct device *dev, int ret = 0; if (buf == NULL || size < 0) { - GOOG_INFO("error: invalid input!\n"); + GOOG_INFO(gti, "error: invalid input!\n"); return -EINVAL; } if (kstrtou32(buf, 10, &locked)) { - GOOG_INFO("error: invalid input!\n"); + GOOG_INFO(gti, "error: invalid input!\n"); return -EINVAL; } if (locked > 1) { - GOOG_INFO("error: invalid input!\n"); + GOOG_INFO(gti, "error: invalid input!\n"); return -EINVAL; } if (locked) { - if (gti->wakeup_before_force_active_enabled) { - input_report_key(gti->vendor_input_dev, KEY_WAKEUP, true); - input_sync(gti->vendor_input_dev); - input_report_key(gti->vendor_input_dev, KEY_WAKEUP, false); - input_sync(gti->vendor_input_dev); - GOOG_INFO("KEY_WAKEUP triggered with %u ms delay.\n", - gti->wakeup_before_force_active_delay); - msleep(gti->wakeup_before_force_active_delay); - } gti_debug_hc_dump(gti); gti_debug_input_dump(gti); - ret = goog_pm_wake_lock(gti, GTI_PM_WAKELOCK_TYPE_FORCE_ACTIVE, false); + if (gti->ignore_force_active) + GOOG_WARN(gti, "operation not supported!\n"); + else + ret = goog_pm_wake_lock(gti, GTI_PM_WAKELOCK_TYPE_FORCE_ACTIVE, false); } else { - ret = goog_pm_wake_unlock(gti, GTI_PM_WAKELOCK_TYPE_FORCE_ACTIVE); + if (gti->ignore_force_active) + GOOG_WARN(gti, "operation not supported!\n"); + else + ret = goog_pm_wake_unlock(gti, GTI_PM_WAKELOCK_TYPE_FORCE_ACTIVE); } if (ret < 0) { - GOOG_INFO("error: %d!\n", ret); + GOOG_INFO(gti, "error: %d!\n", ret); return ret; } return size; @@ -233,7 +529,7 @@ static ssize_t fw_grip_show(struct device *dev, buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE - buf_idx, "result: %u\n", cmd->setting | (gti->ignore_grip_update << 1)); } - GOOG_INFO("%s", buf); + GOOG_INFO(gti, "%s", buf); return buf_idx; } @@ -247,7 +543,7 @@ static ssize_t fw_grip_store(struct device *dev, bool enabled = false; if (kstrtou32(buf, 10, &fw_grip_mode)) { - GOOG_INFO("error: invalid input!\n"); + GOOG_INFO(gti, "error: invalid input!\n"); return size; } @@ -256,11 +552,11 @@ static ssize_t fw_grip_store(struct device *dev, gti->cmd.grip_cmd.setting = enabled ? GTI_GRIP_ENABLE : GTI_GRIP_DISABLE; ret = goog_process_vendor_cmd(gti, GTI_CMD_SET_GRIP_MODE); if (ret == -EOPNOTSUPP) - GOOG_INFO("error: not supported!\n"); + GOOG_INFO(gti, "error: not supported!\n"); else if (ret) - GOOG_INFO("error: %d!\n", ret); + GOOG_INFO(gti, "error: %d!\n", ret); else - GOOG_INFO("fw_grip_mode: %u\n", fw_grip_mode); + GOOG_INFO(gti, "fw_grip_mode: %u\n", fw_grip_mode); return size; } @@ -285,7 +581,7 @@ static ssize_t fw_palm_show(struct device *dev, buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE - buf_idx, "result: %u\n", cmd->setting | (gti->ignore_palm_update << 1)); } - GOOG_INFO("%s", buf); + GOOG_INFO(gti, "%s", buf); return buf_idx; } @@ -299,7 +595,7 @@ static ssize_t fw_palm_store(struct device *dev, bool enabled; if (kstrtou32(buf, 10, &fw_palm_mode)) { - GOOG_INFO("error: invalid input!\n"); + GOOG_INFO(gti, "error: invalid input!\n"); return -EINVAL; } @@ -308,11 +604,11 @@ static ssize_t fw_palm_store(struct device *dev, gti->cmd.palm_cmd.setting = enabled ? GTI_PALM_ENABLE : GTI_PALM_DISABLE; ret = goog_process_vendor_cmd(gti, GTI_CMD_SET_PALM_MODE); if (ret == -EOPNOTSUPP) - GOOG_INFO("error: not supported!\n"); + GOOG_INFO(gti, "error: not supported!\n"); else if (ret) - GOOG_INFO("error: %d!\n", ret); + GOOG_INFO(gti, "error: %d!\n", ret); else - GOOG_INFO("fw_palm_mode= %u\n", fw_palm_mode); + GOOG_INFO(gti, "fw_palm_mode= %u\n", fw_palm_mode); return size; } @@ -336,7 +632,7 @@ static ssize_t fw_ver_show(struct device *dev, buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE - buf_idx, "result: %s\n", gti->cmd.fw_version_cmd.buffer); } - GOOG_INFO("%s", buf); + GOOG_INFO(gti, "%s", buf); return buf_idx; } @@ -360,7 +656,7 @@ static ssize_t irq_enabled_show(struct device *dev, buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE - buf_idx, "result: %u\n", gti->cmd.irq_cmd.setting); } - GOOG_INFO("%s", buf); + GOOG_INFO(gti, "%s", buf); return buf_idx; } @@ -373,18 +669,18 @@ static ssize_t irq_enabled_store(struct device *dev, struct goog_touch_interface *gti = dev_get_drvdata(dev); if (kstrtobool(buf, &enabled)) { - GOOG_ERR("error: invalid input!\n"); + GOOG_ERR(gti, "error: invalid input!\n"); return size; } gti->cmd.irq_cmd.setting = enabled; ret = goog_process_vendor_cmd(gti, GTI_CMD_SET_IRQ_MODE); if (ret == -EOPNOTSUPP) - GOOG_INFO("error: not supported!\n"); + GOOG_INFO(gti, "error: not supported!\n"); else if (ret) - GOOG_INFO("error: %d!\n", ret); + GOOG_INFO(gti, "error: %d!\n", ret); else - GOOG_INFO("irq_enabled= %u\n", gti->cmd.irq_cmd.setting); + GOOG_INFO(gti, "irq_enabled= %u\n", gti->cmd.irq_cmd.setting); return size; } @@ -397,7 +693,7 @@ static ssize_t mf_mode_show(struct device *dev, buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE - buf_idx, "result: %u\n", gti->mf_mode); - GOOG_INFO("%s", buf); + GOOG_INFO(gti, "%s", buf); return buf_idx; } @@ -409,23 +705,23 @@ static ssize_t mf_mode_store(struct device *dev, enum gti_mf_mode mode = 0; if (buf == NULL || size < 0) { - GOOG_INFO("error: invalid input!\n"); + GOOG_INFO(gti, "error: invalid input!\n"); return size; } if (kstrtou32(buf, 10, &mode)) { - GOOG_INFO("error: invalid input!\n"); + GOOG_INFO(gti, "error: invalid input!\n"); return size; } if (mode < GTI_MF_MODE_UNFILTER || mode > GTI_MF_MODE_AUTO_REPORT) { - GOOG_INFO("error: invalid input!\n"); + GOOG_INFO(gti, "error: invalid input!\n"); return size; } gti->mf_mode = mode; - GOOG_INFO("mf_mode= %u\n", gti->mf_mode); + GOOG_INFO(gti, "mf_mode= %u\n", gti->mf_mode); return size; } @@ -441,6 +737,13 @@ static ssize_t ms_base_show(struct device *dev, u16 rx = gti->offload.caps.rx_size; int x, y; + ret = goog_precheck_heatmap(gti); + if (ret) { + buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE - buf_idx, + "result: N/A!\n"); + return buf_idx; + } + ret = mutex_lock_interruptible(>i->input_process_lock); if (ret != 0) { buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE - buf_idx, @@ -470,7 +773,7 @@ static ssize_t ms_base_show(struct device *dev, } buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE - buf_idx, "\n"); } - GOOG_INFO("%s", buf); + GOOG_INFO(gti, "%s", buf); } } @@ -489,6 +792,13 @@ static ssize_t ms_diff_show(struct device *dev, u16 rx = gti->offload.caps.rx_size; int x, y; + ret = goog_precheck_heatmap(gti); + if (ret) { + buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE - buf_idx, + "result: N/A!\n"); + return buf_idx; + } + ret = mutex_lock_interruptible(>i->input_process_lock); if (ret != 0) { buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE - buf_idx, @@ -518,7 +828,7 @@ static ssize_t ms_diff_show(struct device *dev, } buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE - buf_idx, "\n"); } - GOOG_INFO("%s", buf); + GOOG_INFO(gti, "%s", buf); } } @@ -537,6 +847,13 @@ static ssize_t ms_raw_show(struct device *dev, u16 rx = gti->offload.caps.rx_size; int x, y; + ret = goog_precheck_heatmap(gti); + if (ret) { + buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE - buf_idx, + "result: N/A!\n"); + return buf_idx; + } + ret = mutex_lock_interruptible(>i->input_process_lock); if (ret != 0) { buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE - buf_idx, @@ -566,7 +883,7 @@ static ssize_t ms_raw_show(struct device *dev, } buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE - buf_idx, "\n"); } - GOOG_INFO("%s", buf); + GOOG_INFO(gti, "%s", buf); } } @@ -582,7 +899,7 @@ static ssize_t offload_enabled_show(struct device *dev, buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE - buf_idx, "result: %d\n", gti->offload_enabled); - GOOG_INFO("%s", buf); + GOOG_INFO(gti, "%s", buf); return buf_idx; } @@ -593,9 +910,9 @@ static ssize_t offload_enabled_store(struct device *dev, struct goog_touch_interface *gti = dev_get_drvdata(dev); if (kstrtobool(buf, >i->offload_enabled)) { - GOOG_INFO("error: invalid input!\n"); + GOOG_INFO(gti, "error: invalid input!\n"); } else { - GOOG_INFO("offload_enabled= %d\n", gti->offload_enabled); + GOOG_INFO(gti, "offload_enabled= %d\n", gti->offload_enabled); /* Force to turn off offload by request. */ if (!gti->offload_enabled) goog_offload_set_running(gti, false); @@ -625,7 +942,7 @@ static ssize_t ping_show(struct device *dev, buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE - buf_idx, "result: success.\n"); } - GOOG_INFO("%s", buf); + GOOG_INFO(gti, "%s", buf); return buf_idx; } @@ -644,7 +961,7 @@ static ssize_t reset_show(struct device *dev, buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE - buf_idx, "result: success.\n"); } - GOOG_INFO("%s", buf); + GOOG_INFO(gti, "%s", buf); return buf_idx; } @@ -657,31 +974,31 @@ static ssize_t reset_store(struct device *dev, enum gti_reset_mode mode = 0; if (buf == NULL || size < 0) { - GOOG_INFO("error: invalid input!\n"); + GOOG_INFO(gti, "error: invalid input!\n"); return -EINVAL; } if (kstrtou32(buf, 10, &mode)) { - GOOG_INFO("error: invalid input!\n"); + GOOG_INFO(gti, "error: invalid input!\n"); return -EINVAL; } if (mode <= GTI_RESET_MODE_NOP || mode > GTI_RESET_MODE_AUTO) { - GOOG_INFO("error: invalid input!\n"); + GOOG_INFO(gti, "error: invalid input!\n"); return -EINVAL; } gti->cmd.reset_cmd.setting = mode; ret = goog_process_vendor_cmd(gti, GTI_CMD_RESET); if (ret == -EOPNOTSUPP) { - GOOG_INFO("error: not supported!\n"); + GOOG_INFO(gti, "error: not supported!\n"); gti->cmd.reset_cmd.setting = GTI_RESET_MODE_NA; } else if (ret) { - GOOG_INFO("error: %d!\n", ret); + GOOG_INFO(gti, "error: %d!\n", ret); gti->cmd.reset_cmd.setting = GTI_RESET_MODE_NA; } else { - GOOG_INFO("reset= 0x%x\n", mode); + GOOG_INFO(gti, "reset= 0x%x\n", mode); } return size; @@ -706,7 +1023,7 @@ static ssize_t scan_mode_show(struct device *dev, buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE - buf_idx, "result: %u\n", gti->cmd.scan_cmd.setting); } - GOOG_INFO("%s", buf); + GOOG_INFO(gti, "%s", buf); return buf_idx; } @@ -719,29 +1036,29 @@ static ssize_t scan_mode_store(struct device *dev, enum gti_scan_mode mode = 0; if (buf == NULL || size < 0) { - GOOG_INFO("error: invalid input!\n"); + GOOG_INFO(gti, "error: invalid input!\n"); return size; } if (kstrtou32(buf, 10, &mode)) { - GOOG_ERR("error: invalid input!\n"); + GOOG_ERR(gti, "error: invalid input!\n"); return size; } if (mode < GTI_SCAN_MODE_AUTO || mode > GTI_SCAN_MODE_LP_IDLE) { - GOOG_INFO("error: invalid input!\n"); + GOOG_INFO(gti, "error: invalid input!\n"); return size; } gti->cmd.scan_cmd.setting = mode; ret = goog_process_vendor_cmd(gti, GTI_CMD_SET_SCAN_MODE); if (ret == -EOPNOTSUPP) - GOOG_ERR("error: not supported!\n"); + GOOG_ERR(gti, "error: not supported!\n"); else if (ret) - GOOG_ERR("error: %d!\n", ret); + GOOG_ERR(gti, "error: %d!\n", ret); else - GOOG_INFO("scan_mode= %u\n", mode); + GOOG_INFO(gti, "scan_mode= %u\n", mode); return size; } @@ -755,18 +1072,18 @@ static ssize_t screen_protector_mode_enabled_store(struct device *dev, bool enabled = false; if (kstrtobool(buf, &enabled)) { - GOOG_ERR("invalid input!\n"); + GOOG_ERR(gti, "invalid input!\n"); return -EINVAL; } cmd->setting = enabled ? GTI_SCREEN_PROTECTOR_MODE_ENABLE : GTI_SCREEN_PROTECTOR_MODE_DISABLE; ret = goog_process_vendor_cmd(gti, GTI_CMD_SET_SCREEN_PROTECTOR_MODE); if (ret == -EOPNOTSUPP) - GOOG_ERR("error: not supported!\n"); + GOOG_ERR(gti, "error: not supported!\n"); else if (ret) - GOOG_ERR("error: %d!\n", ret); + GOOG_ERR(gti, "error: %d!\n", ret); else - GOOG_INFO("enabled= %u\n", enabled); + GOOG_INFO(gti, "enabled= %u\n", enabled); gti->screen_protector_mode_setting = enabled ? GTI_SCREEN_PROTECTOR_MODE_ENABLE : GTI_SCREEN_PROTECTOR_MODE_DISABLE; return size; @@ -788,7 +1105,7 @@ static ssize_t screen_protector_mode_enabled_show(struct device *dev, } else { buf_idx += scnprintf(buf, PAGE_SIZE - buf_idx, "error: %d\n", ret); } - GOOG_INFO("%s", buf); + GOOG_INFO(gti, "%s", buf); return buf_idx; } @@ -820,7 +1137,7 @@ static ssize_t self_test_show(struct device *dev, buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE - buf_idx, "error: N/A!\n"); } } - GOOG_INFO("%s", buf); + GOOG_INFO(gti, "%s", buf); return buf_idx; } @@ -836,6 +1153,13 @@ static ssize_t ss_base_show(struct device *dev, u16 rx = gti->offload.caps.rx_size; int x, y; + ret = goog_precheck_heatmap(gti); + if (ret) { + buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE - buf_idx, + "result: N/A!\n"); + return buf_idx; + } + ret = mutex_lock_interruptible(>i->input_process_lock); if (ret != 0) { buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE - buf_idx, @@ -869,7 +1193,7 @@ static ssize_t ss_base_show(struct device *dev, "%5d,", ((s16 *)cmd->buffer)[tx + y]); } buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE - buf_idx, "\n"); - GOOG_INFO("%s", buf); + GOOG_INFO(gti, "%s", buf); } } @@ -888,6 +1212,13 @@ static ssize_t ss_diff_show(struct device *dev, u16 rx = gti->offload.caps.rx_size; int x, y; + ret = goog_precheck_heatmap(gti); + if (ret) { + buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE - buf_idx, + "result: N/A!\n"); + return buf_idx; + } + ret = mutex_lock_interruptible(>i->input_process_lock); if (ret != 0) { buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE - buf_idx, @@ -921,7 +1252,7 @@ static ssize_t ss_diff_show(struct device *dev, "%5d,", ((s16 *)cmd->buffer)[tx + y]); } buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE - buf_idx, "\n"); - GOOG_INFO("%s", buf); + GOOG_INFO(gti, "%s", buf); } } @@ -940,6 +1271,13 @@ static ssize_t ss_raw_show(struct device *dev, u16 rx = gti->offload.caps.rx_size; int x, y; + ret = goog_precheck_heatmap(gti); + if (ret) { + buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE - buf_idx, + "result: N/A!\n"); + return buf_idx; + } + ret = mutex_lock_interruptible(>i->input_process_lock); if (ret != 0) { buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE - buf_idx, @@ -973,7 +1311,7 @@ static ssize_t ss_raw_show(struct device *dev, "%5d,", ((s16 *)cmd->buffer)[tx + y]); } buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE - buf_idx, "\n"); - GOOG_INFO("%s", buf); + GOOG_INFO(gti, "%s", buf); } } @@ -1000,7 +1338,7 @@ static ssize_t sensing_enabled_show(struct device *dev, buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE - buf_idx, "result: %u\n", gti->cmd.sensing_cmd.setting); } - GOOG_INFO("%s", buf); + GOOG_INFO(gti, "%s", buf); return buf_idx; } @@ -1013,18 +1351,18 @@ static ssize_t sensing_enabled_store(struct device *dev, struct goog_touch_interface *gti = dev_get_drvdata(dev); if (kstrtobool(buf, &enabled)) { - GOOG_INFO("error: invalid input!\n"); + GOOG_INFO(gti, "error: invalid input!\n"); return size; } gti->cmd.sensing_cmd.setting = enabled; ret = goog_process_vendor_cmd(gti, GTI_CMD_SET_SENSING_MODE); if (ret == -EOPNOTSUPP) - GOOG_INFO("error: not supported!\n"); + GOOG_INFO(gti, "error: not supported!\n"); else if (ret) - GOOG_INFO("error: %d!\n", ret); + GOOG_INFO(gti, "error: %d!\n", ret); else - GOOG_INFO("sensing_enabled= %u\n", gti->cmd.sensing_cmd.setting); + GOOG_INFO(gti, "sensing_enabled= %u\n", gti->cmd.sensing_cmd.setting); return size; } @@ -1037,7 +1375,7 @@ static ssize_t v4l2_enabled_show(struct device *dev, buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE - buf_idx, "result: %d\n", gti->v4l2_enabled); - GOOG_INFO("%s", buf); + GOOG_INFO(gti, "%s", buf); return buf_idx; } @@ -1048,9 +1386,9 @@ static ssize_t v4l2_enabled_store(struct device *dev, struct goog_touch_interface *gti = dev_get_drvdata(dev); if (kstrtobool(buf, >i->v4l2_enabled)) - GOOG_INFO("error: invalid input!\n"); + GOOG_INFO(gti, "error: invalid input!\n"); else - GOOG_INFO("v4l2_enabled= %d\n", gti->v4l2_enabled); + GOOG_INFO(gti, "v4l2_enabled= %d\n", gti->v4l2_enabled); return size; } @@ -1063,7 +1401,7 @@ static ssize_t vrr_enabled_show(struct device *dev, buf_idx += scnprintf(buf + buf_idx, PAGE_SIZE, "result: %d\n", gti->vrr_enabled); - GOOG_INFO("%s", buf); + GOOG_INFO(gti, "%s", buf); return buf_idx; } @@ -1074,11 +1412,11 @@ static ssize_t vrr_enabled_store(struct device *dev, struct goog_touch_interface *gti = dev_get_drvdata(dev); if (kstrtobool(buf, >i->vrr_enabled)) { - GOOG_INFO("error: invalid input!\n"); + GOOG_INFO(gti, "error: invalid input!\n"); } else if (gti->report_rate_table_size == 0) { - GOOG_INFO("error: No valid report rate table!\n"); + GOOG_INFO(gti, "error: No valid report rate table!\n"); } else { - GOOG_INFO("vrr_enabled= %d\n", gti->vrr_enabled); + GOOG_INFO(gti, "vrr_enabled= %d\n", gti->vrr_enabled); if (gti->vrr_enabled) goog_lookup_touch_report_rate(gti); } @@ -1105,7 +1443,7 @@ inline int gti_debug_hc_pop(struct goog_touch_interface *gti, struct gti_debug_health_check *fifo, unsigned int len) { if (len > GTI_DEBUG_KFIFO_LEN) { - GOOG_ERR("invalid fifo pop len(%d)!\n", len); + GOOG_ERR(gti, "invalid fifo pop len(%d)!\n", len); return -EINVAL; } /* @@ -1140,7 +1478,7 @@ void gti_debug_hc_dump(struct goog_touch_interface *gti) count = min_t(u64, gti->irq_index, ARRAY_SIZE(last_fifo)); ret = gti_debug_hc_pop(gti, last_fifo, count); if (ret) { - GOOG_ERR("Failed to peek debug hc, err: %d\n", ret); + GOOG_ERR(gti, "Failed to peek debug hc, err: %d\n", ret); return; } for (i = 0 ; i < count ; i++) { @@ -1152,7 +1490,7 @@ void gti_debug_hc_dump(struct goog_touch_interface *gti) delta = ktime_ms_delta(current_time, last_fifo[i].irq_time); if (delta > 0) sec_delta = div_u64_rem(delta, MSEC_PER_SEC, &ms_delta); - GOOG_LOG("dump-int: #%llu(%lld.%u): C#%llu(0x%lx).\n", + GOOG_LOG(gti, "dump-int: #%llu(%lld.%u): C#%llu(0x%lx).\n", last_fifo[i].irq_index, sec_delta, ms_delta, last_fifo[i].input_index, last_fifo[i].slot_bit_active); } @@ -1163,7 +1501,7 @@ inline void gti_debug_input_push(struct goog_touch_interface *gti, int slot) struct gti_debug_input fifo; if (slot < 0 || slot >= MAX_SLOTS) { - GOOG_ERR("Invalid slot: %d\n", slot); + GOOG_ERR(gti, "Invalid slot: %d\n", slot); return; } @@ -1182,7 +1520,7 @@ inline int gti_debug_input_pop(struct goog_touch_interface *gti, struct gti_debug_input *fifo, unsigned int len) { if (len > GTI_DEBUG_KFIFO_LEN) { - GOOG_ERR("invalid fifo pop len(%d)!\n", len); + GOOG_ERR(gti, "invalid fifo pop len(%d)!\n", len); return -EINVAL; } @@ -1235,13 +1573,13 @@ void gti_debug_input_dump(struct goog_touch_interface *gti) count = min_t(u64, gti->released_index, ARRAY_SIZE(last_fifo)); ret = gti_debug_input_pop(gti, last_fifo, count); if (ret) { - GOOG_ERR("Failed to peek debug input, err: %d\n", ret); + GOOG_ERR(gti, "Failed to peek debug input, err: %d\n", ret); return; } for (i = 0 ; i < count ; i++) { if (last_fifo[i].slot < 0 || last_fifo[i].slot >= MAX_SLOTS) { - GOOG_INFO("dump: #%d: invalid slot #!\n", last_fifo[i].slot); + GOOG_INFO(gti, "dump: #%d: invalid slot #!\n", last_fifo[i].slot); continue; } sec_delta_down = -1; @@ -1274,20 +1612,20 @@ void gti_debug_input_dump(struct goog_touch_interface *gti) } } - GOOG_LOG("dump: #%d: %lld.%u(%lld.%u) D(%d, %d) I(%llu, %llu).\n", + GOOG_LOG(gti, "dump: #%d: %lld.%u(%lld.%u) D(%d, %d) I(%llu, %llu).\n", last_fifo[i].slot, sec_delta_down, ms_delta_down, sec_delta_duration, ms_delta_duration, px_delta_x, px_delta_y, last_fifo[i].pressed.irq_index, last_fifo[i].released.irq_index); - GOOG_DBG("dump-dbg: #%d: P(%u, %u) -> R(%u, %u).\n\n", + GOOG_DBG(gti, "dump-dbg: #%d: P(%u, %u) -> R(%u, %u).\n\n", last_fifo[i].slot, last_fifo[i].pressed.coord.x, last_fifo[i].pressed.coord.y, last_fifo[i].released.coord.x, last_fifo[i].released.coord.y); } /* Extra check for unexpected case. */ for_each_set_bit(slot, >i->slot_bit_active, MAX_SLOTS) { - GOOG_INFO("slot #%d is active!\n", slot); + GOOG_INFO(gti, "slot #%d is active!\n", slot); } } #endif /* GTI_DEBUG_KFIFO_LEN */ @@ -1301,7 +1639,7 @@ static void panel_bridge_enable(struct drm_bridge *bridge) container_of(bridge, struct goog_touch_interface, panel_bridge); if (gti->panel_is_lp_mode) { - GOOG_INFO("skip screen-on because of panel_is_lp_mode enabled!\n"); + GOOG_INFO(gti, "skip screen-on because of panel_is_lp_mode enabled!\n"); return; } @@ -1362,8 +1700,9 @@ static void panel_bridge_mode_set(struct drm_bridge *bridge, panel_is_lp_mode = panel_bridge_is_lp_mode(gti->connector); if (gti->panel_is_lp_mode != panel_is_lp_mode) { - GOOG_INFO("panel_is_lp_mode changed from %d to %d.\n", + GOOG_INFO(gti, "panel_is_lp_mode changed from %d to %d.\n", gti->panel_is_lp_mode, panel_is_lp_mode); + if (panel_is_lp_mode) goog_set_display_state(gti, GTI_DISPLAY_STATE_OFF); else @@ -1375,13 +1714,13 @@ static void panel_bridge_mode_set(struct drm_bridge *bridge, int vrefresh = drm_mode_vrefresh(mode); if (gti->display_vrefresh != vrefresh) { - GOOG_DBG("display_vrefresh(Hz) changed to %d from %d.\n", + GOOG_DBG(gti, "display_vrefresh(Hz) changed to %d from %d.\n", vrefresh, gti->display_vrefresh); gti->display_vrefresh = vrefresh; gti->cmd.display_vrefresh_cmd.setting = vrefresh; ret = goog_process_vendor_cmd(gti, GTI_CMD_NOTIFY_DISPLAY_VREFRESH); if (ret && ret != -EOPNOTSUPP) - GOOG_WARN("unexpected return(%d)!", ret); + GOOG_WARN(gti, "unexpected return(%d)!", ret); if (gti->vrr_enabled) goog_lookup_touch_report_rate(gti); @@ -1397,7 +1736,7 @@ static const struct drm_bridge_funcs panel_bridge_funcs = { static int register_panel_bridge(struct goog_touch_interface *gti) { - GOOG_INFO("\n"); + GOOG_INFO(gti, "\n"); #ifdef CONFIG_OF gti->panel_bridge.of_node = gti->vendor_dev->of_node; #endif @@ -1409,9 +1748,11 @@ static int register_panel_bridge(struct goog_touch_interface *gti) static void unregister_panel_bridge(struct drm_bridge *bridge) { + struct goog_touch_interface *gti = + container_of(bridge, struct goog_touch_interface, panel_bridge); struct drm_bridge *node; - GOOG_INFO("\n"); + GOOG_INFO(gti, "\n"); drm_bridge_remove(bridge); if (!bridge->dev) /* not attached */ @@ -1433,6 +1774,33 @@ static void unregister_panel_bridge(struct drm_bridge *bridge) /*----------------------------------------------------------------------------- * GTI: functions. */ +static int goog_precheck_heatmap(struct goog_touch_interface *gti) +{ + int ret = 0; + + if (gti->display_state == GTI_DISPLAY_STATE_OFF) { + /* + * Ignore request on heatamp if project correlates closely with + * display for touch scanning or I/O transaction. + */ + if (gti->ignore_screenoff_heatmap) { + GOOG_WARN(gti, "N/A for screen-off!\n"); + ret = -ENODATA; + } + + /* + * Check the PM wakelock state for bus ownership before data + * request. + */ + if (!goog_pm_wake_get_locks(gti)) { + GOOG_WARN(gti, "N/A during inactive bus!\n"); + ret = -ENODATA; + } + } + + return ret; +} + static void goog_set_display_state(struct goog_touch_interface *gti, enum gti_display_state_setting display_state) { @@ -1443,19 +1811,21 @@ static void goog_set_display_state(struct goog_touch_interface *gti, switch (display_state) { case GTI_DISPLAY_STATE_OFF: - GOOG_INFO("screen-off.\n"); + GOOG_INFO(gti, "screen-off.\n"); ret = goog_pm_wake_unlock_nosync(gti, GTI_PM_WAKELOCK_TYPE_SCREEN_ON); - if (ret < 0) GOOG_INFO("Error while obtaining screen_on wakelock: %d!\n", ret); + if (ret < 0) + GOOG_INFO(gti, "Error while obtaining screen-off wakelock: %d!\n", ret); break; case GTI_DISPLAY_STATE_ON: - GOOG_INFO("screen-on.\n"); + GOOG_INFO(gti, "screen-on.\n"); ret = goog_pm_wake_lock_nosync(gti, GTI_PM_WAKELOCK_TYPE_SCREEN_ON, false); - if (ret < 0) GOOG_INFO("Error while obtaining screen_on wakelock: %d!\n", ret); + if (ret < 0) + GOOG_INFO(gti, "Error while obtaining screen-on wakelock: %d!\n", ret); break; default: - GOOG_ERR("Unexpected value(0x%X) of display state parameter.\n", + GOOG_ERR(gti, "Unexpected value(0x%X) of display state parameter.\n", display_state); return; } @@ -1463,7 +1833,7 @@ static void goog_set_display_state(struct goog_touch_interface *gti, gti->cmd.display_state_cmd.setting = display_state; ret = goog_process_vendor_cmd(gti, GTI_CMD_NOTIFY_DISPLAY_STATE); if (ret && ret != -EOPNOTSUPP) - GOOG_WARN("Unexpected vendor_cmd return(%d)!\n", ret); + GOOG_WARN(gti, "Unexpected vendor_cmd return(%d)!\n", ret); } bool goog_check_spi_dma_enabled(struct spi_device *spi_dev) @@ -1593,10 +1963,10 @@ int goog_process_vendor_cmd(struct goog_touch_interface *gti, enum gti_cmd_type /* Take unsupported cmd_type as debug logs for compatibility check. */ if (ret == -EOPNOTSUPP) { - GOOG_DBG("Unsupported request cmd_type %#x!\n", cmd_type); + GOOG_DBG(gti, "unsupported request cmd_type %#x!\n", cmd_type); ret = 0; } else if (ret == -ESRCH) { - GOOG_WARN("No handler for cmd_type %#x!\n", cmd_type); + GOOG_WARN(gti, "No handler for cmd_type %#x!\n", cmd_type); ret = 0; } @@ -1661,7 +2031,7 @@ void goog_update_motion_filter(struct goog_touch_interface *gti, unsigned long s ret = goog_process_vendor_cmd(gti, GTI_CMD_SET_CONTINUOUS_REPORT); if (ret) - GOOG_WARN("unexpected return(%d)!", ret); + GOOG_WARN(gti, "unexpected return(%d)!", ret); } gti->mf_state = next_state; @@ -1677,7 +2047,7 @@ bool goog_v4l2_read_frame_cb(struct v4l2_heatmap *v4l2) memcpy(v4l2->frame, gti->heatmap_buf, v4l2_size); ret = true; } else { - GOOG_ERR("wrong pointer(%p) or size (W: %lu, H: %lu) vs %u\n", + GOOG_ERR(gti, "wrong pointer(%p) or size (W: %lu, H: %lu) vs %u\n", gti->heatmap_buf, gti->v4l2.width, gti->v4l2.height, gti->heatmap_buf_size); } @@ -1697,7 +2067,7 @@ void goog_offload_populate_coordinate_channel(struct goog_touch_interface *gti, struct TouchOffloadDataCoord *dc; if (channel < 0 || channel >= MAX_CHANNELS) { - GOOG_ERR("Invalid channel: %d\n", channel); + GOOG_ERR(gti, "Invalid channel: %d\n", channel); return; } @@ -1723,7 +2093,7 @@ void goog_offload_populate_mutual_channel(struct goog_touch_interface *gti, struct TouchOffloadData2d *mutual; if (channel < 0 || channel >= MAX_CHANNELS) { - GOOG_ERR("Invalid channel: %d\n", channel); + GOOG_ERR(gti, "Invalid channel: %d\n", channel); return; } @@ -1743,7 +2113,7 @@ void goog_offload_populate_self_channel(struct goog_touch_interface *gti, struct TouchOffloadData1d *self; if (channel < 0 || channel >= MAX_CHANNELS) { - GOOG_ERR("Invalid channel: %d\n", channel); + GOOG_ERR(gti, "Invalid channel: %d\n", channel); return; } @@ -1820,7 +2190,8 @@ void goog_offload_populate_frame(struct goog_touch_interface *gti, u16 rx = gti->offload.caps.rx_size; struct gti_sensor_data_cmd *cmd = >i->cmd.sensor_data_cmd; - scnprintf(trace_tag, sizeof(trace_tag), "%s: index=%llu\n", __func__, index); + scnprintf(trace_tag, sizeof(trace_tag), "%s: IDX=%llu IN_TS=%lld.\n", + __func__, index, gti->input_timestamp); ATRACE_BEGIN(trace_tag); frame->header.index = index++; @@ -1835,7 +2206,7 @@ void goog_offload_populate_frame(struct goog_touch_interface *gti, /* Populate all channels */ for (i = 0; i < frame->num_channels; i++) { channel_type = frame->channel_type[i]; - GOOG_DBG("#%d: get data(type %#x) from vendor driver", i, channel_type); + GOOG_DBG(gti, "#%d: get data(type %#x) from vendor driver", i, channel_type); ret = 0; cmd->buffer = NULL; cmd->size = 0; @@ -1897,11 +2268,11 @@ void goog_offload_populate_frame(struct goog_touch_interface *gti, } ATRACE_END(); } else { - GOOG_ERR("%s - unrecognized channel_type = %u\n", __func__, channel_type); + GOOG_ERR(gti, "unrecognized channel_type %#x.\n", channel_type); } if (ret) { - GOOG_DBG("skip to populate data(type %#x, ret %d)!\n", + GOOG_DBG(gti, "skip to populate data(type %#x, ret %d)!\n", channel_type, ret); } } @@ -1919,7 +2290,7 @@ void goog_update_fw_settings(struct goog_touch_interface *gti) gti->cmd.grip_cmd.setting = gti->default_grip_enabled; ret = goog_process_vendor_cmd(gti, GTI_CMD_SET_GRIP_MODE); if (ret) - GOOG_WARN("unexpected return(%d)!", ret); + GOOG_WARN(gti, "unexpected return(%d)!", ret); } if(!gti->ignore_palm_update) { @@ -1929,33 +2300,33 @@ void goog_update_fw_settings(struct goog_touch_interface *gti) gti->cmd.palm_cmd.setting = gti->default_palm_enabled; ret = goog_process_vendor_cmd(gti, GTI_CMD_SET_PALM_MODE); if (ret) - GOOG_WARN("unexpected return(%d)!", ret); + GOOG_WARN(gti, "unexpected return(%d)!", ret); } gti->cmd.screen_protector_mode_cmd.setting = gti->screen_protector_mode_setting; ret = goog_process_vendor_cmd(gti, GTI_CMD_SET_SCREEN_PROTECTOR_MODE); if (ret != 0) - GOOG_ERR("Failed to %s screen protector mode!\n", + GOOG_ERR(gti, "Failed to %s screen protector mode!\n", gti->screen_protector_mode_setting == GTI_SCREEN_PROTECTOR_MODE_ENABLE ? "enable" : "disable"); gti->cmd.heatmap_cmd.setting = GTI_HEATMAP_ENABLE; ret = goog_process_vendor_cmd(gti, GTI_CMD_SET_HEATMAP_ENABLED); if (ret != 0) - GOOG_ERR("Failed to enable heatmap!\n"); + GOOG_ERR(gti, "Failed to enable heatmap!\n"); if (gti->vrr_enabled) { gti->cmd.report_rate_cmd.setting = gti->report_rate_setting_next; ret = goog_process_vendor_cmd(gti, GTI_CMD_SET_REPORT_RATE); if (ret != 0) - GOOG_ERR("Failed to set report rate!\n"); + GOOG_ERR(gti, "Failed to set report rate!\n"); } } static void goog_offload_set_running(struct goog_touch_interface *gti, bool running) { if (gti->offload.offload_running != running) { - GOOG_INFO("Set offload_running=%d, irq_index=%d, input_index=%d\n", + GOOG_INFO(gti, "Set offload_running=%d, irq_index=%d, input_index=%d\n", running, gti->irq_index, gti->input_index); gti->offload.offload_running = running; @@ -1972,8 +2343,15 @@ void goog_offload_input_report(void *handle, int i; int error; unsigned long slot_bit_active = 0; + char trace_tag[128]; + ktime_t ktime = ktime_get(); - ATRACE_BEGIN(__func__); + scnprintf(trace_tag, sizeof(trace_tag), + "%s: IDX=%lld IN_TS=%lld TS=%lld DELTA=%lld ns.\n", + __func__, report->index, + ktime_to_ns(report->timestamp), ktime_to_ns(ktime), + ktime_to_ns(ktime_sub(ktime, report->timestamp))); + ATRACE_BEGIN(trace_tag); goog_input_lock(gti); input_set_timestamp(gti->vendor_input_dev, report->timestamp); @@ -2026,14 +2404,14 @@ void goog_offload_input_report(void *handle, error = goog_pm_wake_lock(gti, GTI_PM_WAKELOCK_TYPE_OFFLOAD_REPORT, true); if (error < 0) { - GOOG_WARN("Error while obtaining OFFLOAD_REPORT wakelock: %d!\n", error); + GOOG_WARN(gti, "Error while obtaining OFFLOAD_REPORT wakelock: %d!\n", error); ATRACE_END(); return; } goog_update_motion_filter(gti, slot_bit_active); error = goog_pm_wake_unlock(gti, GTI_PM_WAKELOCK_TYPE_OFFLOAD_REPORT); if (error < 0) - GOOG_WARN("Error while releasing OFFLOAD_REPORT wakelock: %d!\n", error); + GOOG_WARN(gti, "Error while releasing OFFLOAD_REPORT wakelock: %d!\n", error); ATRACE_END(); } @@ -2042,19 +2420,19 @@ int goog_offload_probe(struct goog_touch_interface *gti) int ret; u16 values[2]; struct device_node *np = gti->vendor_dev->of_node; - const char *dev_name = NULL; + const char *offload_dev_name = NULL; /* * TODO(b/201610482): rename DEVICE_NAME in touch_offload.h for more specific. */ - if (!of_property_read_string(np, "goog,offload-device-name", &dev_name)) { + if (!of_property_read_string(np, "goog,offload-device-name", &offload_dev_name)) { scnprintf(gti->offload.device_name, sizeof(gti->offload.device_name), - "%s_%s", DEVICE_NAME, dev_name); + "%s_%s", DEVICE_NAME, offload_dev_name); } if (of_property_read_u8_array(np, "goog,touch_offload_id", gti->offload_id_byte, 4)) { - GOOG_INFO("set default offload id: GOOG!\n"); + GOOG_INFO(gti, "set default offload id: GOOG!\n"); gti->offload_id_byte[0] = 'G'; gti->offload_id_byte[1] = 'O'; gti->offload_id_byte[2] = 'O'; @@ -2070,7 +2448,7 @@ int goog_offload_probe(struct goog_touch_interface *gti) gti->offload.caps.display_width = values[0]; gti->offload.caps.display_height = values[1]; } else { - GOOG_ERR("Please set \"goog,display-resolution\" in dts!"); + GOOG_ERR(gti, "Please set \"goog,display-resolution\" in dts!"); } if (of_property_read_u16_array(np, "goog,channel-num", @@ -2078,7 +2456,7 @@ int goog_offload_probe(struct goog_touch_interface *gti) gti->offload.caps.tx_size = values[0]; gti->offload.caps.rx_size = values[1]; } else { - GOOG_ERR("Please set \"goog,channel-num\" in dts!"); + GOOG_ERR(gti, "Please set \"goog,channel-num\" in dts!"); ret = -EINVAL; goto err_offload_probe; } @@ -2107,7 +2485,7 @@ int goog_offload_probe(struct goog_touch_interface *gti) >i->offload.caps.context_channel_types)) { gti->offload.caps.context_channel_types = 0; } - GOOG_INFO("offload.caps: data_types %#x, scan_types %#x, context_channel_types %#x.\n", + GOOG_INFO(gti, "offload.caps: data_types %#x, scan_types %#x, context_channel_types %#x.\n", gti->offload.caps.touch_data_types, gti->offload.caps.touch_scan_types, gti->offload.caps.context_channel_types); @@ -2127,16 +2505,16 @@ int goog_offload_probe(struct goog_touch_interface *gti) gti->offload.report_cb = goog_offload_input_report; ret = touch_offload_init(>i->offload); if (ret) { - GOOG_ERR("offload init failed, ret %d!\n", ret); + GOOG_ERR(gti, "offload init failed, ret %d!\n", ret); goto err_offload_probe; } gti->offload_enabled = of_property_read_bool(np, "goog,offload-enabled"); - GOOG_INFO("offload.caps: display W/H: %d * %d (Tx/Rx: %d * %d).\n", + GOOG_INFO(gti, "offload.caps: display W/H: %d * %d (Tx/Rx: %d * %d).\n", gti->offload.caps.display_width, gti->offload.caps.display_height, gti->offload.caps.tx_size, gti->offload.caps.rx_size); - GOOG_INFO("offload ID: \"%c%c%c%c\" / 0x%08X, offload_enabled=%d.\n", + GOOG_INFO(gti, "offload ID: \"%c%c%c%c\" / 0x%08X, offload_enabled=%d.\n", gti->offload_id_byte[0], gti->offload_id_byte[1], gti->offload_id_byte[2], gti->offload_id_byte[3], gti->offload_id, gti->offload_enabled); @@ -2148,7 +2526,7 @@ int goog_offload_probe(struct goog_touch_interface *gti) gti->heatmap_buf_size = gti->offload.caps.tx_size * gti->offload.caps.rx_size * sizeof(u16); gti->heatmap_buf = devm_kzalloc(gti->vendor_dev, gti->heatmap_buf_size, GFP_KERNEL); if (!gti->heatmap_buf) { - GOOG_ERR("heamap alloc failed!\n"); + GOOG_ERR(gti, "heamap alloc failed!\n"); ret = -ENOMEM; goto err_offload_probe; } @@ -2173,11 +2551,11 @@ int goog_offload_probe(struct goog_touch_interface *gti) ret = heatmap_probe(>i->v4l2); if (ret) { - GOOG_ERR("v4l2 init failed, ret %d!\n", ret); + GOOG_ERR(gti, "v4l2 init failed, ret %d!\n", ret); goto err_offload_probe; } gti->v4l2_enabled = of_property_read_bool(np, "goog,v4l2-enabled"); - GOOG_INFO("v4l2 W/H=(%lu, %lu), v4l2_enabled=%d.\n", + GOOG_INFO(gti, "v4l2 W/H=(%lu, %lu), v4l2_enabled=%d.\n", gti->v4l2.width, gti->v4l2.height, gti->v4l2_enabled); err_offload_probe: @@ -2220,7 +2598,8 @@ int goog_input_process(struct goog_touch_interface *gti, bool report_from_irq) if (gti->offload_enabled) { ret = touch_offload_reserve_frame(>i->offload, frame); if (ret != 0 || frame == NULL) { - GOOG_DBG("could not reserve a frame(ret %d)!\n", ret); + GOOG_DBG(gti, "could not reserve a frame(ret %d)!\n", ret); + /* Stop offload when there are no buffers available. */ goog_offload_set_running(gti, false); /* @@ -2234,7 +2613,7 @@ int goog_input_process(struct goog_touch_interface *gti, bool report_from_irq) goog_offload_populate_frame(gti, *frame, report_from_irq); ret = touch_offload_queue_frame(>i->offload, *frame); if (ret) - GOOG_ERR("failed to queue reserved frame(ret %d)!\n", ret); + GOOG_ERR(gti, "failed to queue reserved frame(ret %d)!\n", ret); else gti->offload_frame = NULL; } @@ -2297,7 +2676,7 @@ void goog_input_mt_slot( struct input_dev *dev, int slot) { if (slot < 0 || slot >= MAX_SLOTS) { - GOOG_ERR("Invalid slot: %d\n", slot); + GOOG_ERR(gti, "Invalid slot: %d\n", slot); return; } @@ -2310,7 +2689,7 @@ void goog_input_mt_slot( * This is for input report switch between offload and legacy. */ if (!gti->slot_bit_in_use && !gti->input_timestamp_changed) - GOOG_ERR("please exec goog_input_set_timestamp before %s!\n", __func__); + GOOG_ERR(gti, "please exec goog_input_set_timestamp before %s!\n", __func__); set_bit(slot, >i->slot_bit_in_use); } EXPORT_SYMBOL(goog_input_mt_slot); @@ -2322,7 +2701,8 @@ void goog_input_mt_report_slot_state( if (goog_input_legacy_report(gti)) input_mt_report_slot_state(dev, tool_type, active); - if (tool_type == MT_TOOL_FINGER) { + switch (tool_type) { + case MT_TOOL_FINGER: if (active) { gti->offload.coords[gti->slot].status = COORD_STATUS_FINGER; if (!test_and_set_bit(gti->slot, @@ -2336,7 +2716,16 @@ void goog_input_mt_report_slot_state( set_bit(gti->slot, >i->slot_bit_changed); } } + break; + + default: + if (!goog_input_legacy_report(gti)) { + GOOG_WARN(gti, "unexcepted input tool_type(%#x) active(%d)!\n", + tool_type, active); + } + break; } + } EXPORT_SYMBOL(goog_input_mt_report_slot_state); @@ -2417,10 +2806,10 @@ void goog_register_tbn(struct goog_touch_interface *gti) gti->tbn_enabled = of_property_read_bool(np, "goog,tbn-enabled"); if (gti->tbn_enabled) { if (register_tbn(>i->tbn_register_mask)) { - GOOG_ERR("failed to register tbn context!\n"); + GOOG_ERR(gti, "failed to register tbn context!\n"); gti->tbn_enabled = false; } else { - GOOG_INFO("tbn_register_mask = %#x.\n", gti->tbn_register_mask); + GOOG_INFO(gti, "tbn_register_mask = %#x.\n", gti->tbn_register_mask); } } } @@ -2588,8 +2977,6 @@ void goog_init_input(struct goog_touch_interface *gti) gti->debug_input[i].slot = i; if (gti->vendor_dev && gti->vendor_input_dev) { - struct device_node *np = gti->vendor_dev->of_node; - /* * Initialize the ABS_MT_ORIENTATION to support orientation reporting. * Initialize the ABS_MT_TOUCH_MAJOR and ABS_MT_TOUCH_MINOR depending on @@ -2630,25 +3017,21 @@ void goog_init_input(struct goog_touch_interface *gti) */ input_set_abs_params(gti->vendor_input_dev, ABS_MT_TOOL_TYPE, MT_TOOL_FINGER, MT_TOOL_PALM, 0, 0); - - /* - * Initialize the EV_KEY capability. - */ - gti->wakeup_before_force_active_enabled = - of_property_read_bool(np, "goog,wakeup-before-force-active-enabled"); - if (gti->wakeup_before_force_active_enabled) { - if (of_property_read_u32(np, "goog,wakeup-before-force-active-delay", - >i->wakeup_before_force_active_delay)) { - gti->wakeup_before_force_active_delay = 50; - } - input_set_capability(gti->vendor_input_dev, EV_KEY, KEY_WAKEUP); - } } } void goog_init_options(struct goog_touch_interface *gti, struct gti_optional_configuration *options) { + /* Initialize the common features. */ + if (gti->vendor_dev) { + struct device_node *np = gti->vendor_dev->of_node; + + gti->ignore_force_active = of_property_read_bool(np, "goog,ignore-force-active"); + gti->ignore_screenoff_heatmap = + of_property_read_bool(np, "goog,ignore-screenoff-heatmap"); + } + /* Initialize default functions. */ gti->options.get_context_driver = goog_get_context_driver_nop; gti->options.get_context_stylus = goog_get_context_stylus_nop; @@ -2745,7 +3128,7 @@ int goog_pm_wake_lock_nosync(struct goog_touch_interface *gti, mutex_lock(&pm->lock_mutex); if (pm->locks & type) { - GOOG_DBG("unexpectedly lock: locks=0x%04X, type=0x%04X\n", + GOOG_DBG(gti, "unexpectedly lock: locks=0x%04X, type=0x%04X\n", pm->locks, type); mutex_unlock(&pm->lock_mutex); return -EINVAL; @@ -2806,7 +3189,7 @@ int goog_pm_wake_unlock_nosync(struct goog_touch_interface *gti, mutex_lock(&pm->lock_mutex); if (!(pm->locks & type)) { - GOOG_DBG("unexpectedly unlock: locks=0x%04X, type=0x%04X\n", + GOOG_DBG(gti, "unexpectedly unlock: locks=0x%04X, type=0x%04X\n", pm->locks, type); mutex_unlock(&pm->lock_mutex); return -EINVAL; @@ -2869,11 +3252,11 @@ static void goog_pm_suspend(struct gti_pm *pm) /* exit directly if device is already in suspend state */ if (pm->state == GTI_PM_SUSPEND) { - GOOG_WARN("GTI already suspended!\n"); + GOOG_WARN(gti, "GTI already suspended!\n"); return; } - GOOG_INFO("irq_index: %llu, input_index: %llu.\n", gti->irq_index, gti->input_index); + GOOG_INFO(gti, "irq_index: %llu, input_index: %llu.\n", gti->irq_index, gti->input_index); pm->state = GTI_PM_SUSPEND; if (pm->suspend) @@ -2882,7 +3265,7 @@ static void goog_pm_suspend(struct gti_pm *pm) if (gti->tbn_register_mask) { ret = tbn_release_bus(gti->tbn_register_mask); if (ret) - GOOG_ERR("tbn_release_bus failed, ret %d!\n", ret); + GOOG_ERR(gti, "tbn_release_bus failed, ret %d!\n", ret); } gti_debug_hc_dump(gti); gti_debug_input_dump(gti); @@ -2901,7 +3284,7 @@ static void goog_pm_resume(struct gti_pm *pm) /* exit directly if device isn't in suspend state */ if (pm->state == GTI_PM_RESUME) { - GOOG_WARN("GTI already resumed!\n"); + GOOG_WARN(gti, "GTI already resumed!\n"); return; } pm->state = GTI_PM_RESUME; @@ -2912,7 +3295,7 @@ static void goog_pm_resume(struct gti_pm *pm) gti->lptw_triggered = false; ret = tbn_request_bus_with_result(gti->tbn_register_mask, >i->lptw_triggered); if (ret) - GOOG_ERR("tbn_request_bus failed, ret %d!\n", ret); + GOOG_ERR(gti, "tbn_request_bus failed, ret %d!\n", ret); } if (pm->resume) @@ -2967,30 +3350,30 @@ void goog_notify_fw_status_changed(struct goog_touch_interface *gti, { switch (status) { case GTI_FW_STATUS_RESET: - GOOG_INFO("Firmware has been reset\n"); + GOOG_INFO(gti, "Firmware has been reset\n"); goog_input_release_all_fingers(gti); goog_update_fw_settings(gti); break; case GTI_FW_STATUS_PALM_ENTER: - GOOG_INFO("Enter palm mode\n"); + GOOG_INFO(gti, "Enter palm mode\n"); break; case GTI_FW_STATUS_PALM_EXIT: - GOOG_INFO("Exit palm mode\n"); + GOOG_INFO(gti, "Exit palm mode\n"); break; case GTI_FW_STATUS_GRIP_ENTER: - GOOG_INFO("Enter grip mode\n"); + GOOG_INFO(gti, "Enter grip mode\n"); break; case GTI_FW_STATUS_GRIP_EXIT: - GOOG_INFO("Exit grip mode\n"); + GOOG_INFO(gti, "Exit grip mode\n"); break; case GTI_FW_STATUS_NOISE_MODE: if (data == NULL) { - GOOG_INFO("Noise level is changed, level: unknown\n"); + GOOG_INFO(gti, "Noise level is changed, level: unknown\n"); } else { if (data->noise_level == GTI_NOISE_MODE_EXIT) { - GOOG_INFO("Exit noise mode\n"); + GOOG_INFO(gti, "Exit noise mode\n"); } else { - GOOG_INFO("Enter noise mode, level: %d\n", data->noise_level); + GOOG_INFO(gti, "Enter noise mode, level: %d\n", data->noise_level); } } break; @@ -3010,7 +3393,7 @@ static int goog_pm_probe(struct goog_touch_interface *gti) pm->event_wq = alloc_workqueue( "gti_pm_wq", WQ_UNBOUND | WQ_HIGHPRI | WQ_CPU_INTENSIVE, 1); if (!pm->event_wq) { - GOOG_ERR("Failed to create work thread for pm!\n"); + GOOG_ERR(gti, "Failed to create work thread for pm!\n"); ret = -ENOMEM; goto err_alloc_workqueue; } @@ -3097,7 +3480,7 @@ static void goog_set_report_rate_work(struct work_struct *work) gti->cmd.report_rate_cmd.setting = gti->report_rate_setting_next; ret = goog_process_vendor_cmd(gti, GTI_CMD_SET_REPORT_RATE); if (ret != 0) { - GOOG_ERR("Failed to set report rate!\n"); + GOOG_ERR(gti, "Failed to set report rate!\n"); return; } @@ -3109,7 +3492,7 @@ static int goog_init_variable_report_rate(struct goog_touch_interface *gti) int table_size = 0; if (!gti->pm.event_wq) { - GOOG_ERR("No workqueue for variable report rate.\n"); + GOOG_ERR(gti, "No workqueue for variable report rate.\n"); return -ENODEV; } @@ -3122,7 +3505,7 @@ static int goog_init_variable_report_rate(struct goog_touch_interface *gti) "goog,vrr-display-rate"); if (table_size != of_property_count_u32_elems(gti->vendor_dev->of_node, "goog,vrr-touch-rate")) { - GOOG_ERR("Table size mismatch!\n"); + GOOG_ERR(gti, "Table size mismatch!\n"); goto init_variable_report_rate_failed; } @@ -3131,26 +3514,26 @@ static int goog_init_variable_report_rate(struct goog_touch_interface *gti) gti->display_refresh_rate_table = devm_kzalloc(gti->vendor_dev, sizeof(u32) * table_size, GFP_KERNEL); if (!gti->display_refresh_rate_table) { - GOOG_ERR("display_refresh_rate_table alloc failed.\n"); + GOOG_ERR(gti, "display_refresh_rate_table alloc failed.\n"); goto init_variable_report_rate_failed; } gti->touch_report_rate_table = devm_kzalloc(gti->vendor_dev, sizeof(u32) * table_size, GFP_KERNEL); if (!gti->touch_report_rate_table) { - GOOG_ERR("touch_report_rate_table alloc failed.\n"); + GOOG_ERR(gti, "touch_report_rate_table alloc failed.\n"); goto init_variable_report_rate_failed; } if (of_property_read_u32_array(gti->vendor_dev->of_node, "goog,vrr-display-rate", gti->display_refresh_rate_table, table_size)) { - GOOG_ERR("Failed to parse goog,display-vrr-table.\n"); + GOOG_ERR(gti, "Failed to parse goog,display-vrr-table.\n"); goto init_variable_report_rate_failed; } if (of_property_read_u32_array(gti->vendor_dev->of_node, "goog,vrr-touch-rate", gti->touch_report_rate_table, table_size)) { - GOOG_ERR("Failed to parse goog,touch-vrr-table.\n"); + GOOG_ERR(gti, "Failed to parse goog,touch-vrr-table.\n"); goto init_variable_report_rate_failed; } @@ -3164,7 +3547,7 @@ static int goog_init_variable_report_rate(struct goog_touch_interface *gti) gti->decrease_report_rate_delay = 0; } - GOOG_INFO("Default report rate: %uHz, report rate delay %u/%u)", + GOOG_INFO(gti, "Default report rate: %uHz, report rate delay %u/%u)", gti->touch_report_rate_table[0], gti->increase_report_rate_delay, gti->decrease_report_rate_delay); @@ -3290,7 +3673,7 @@ struct goog_touch_interface *goog_touch_interface_probe( struct goog_touch_interface *gti; if (!dev || !input_dev || !default_handler) { - GOOG_ERR("invalid dev/input_dev or default_handler!\n"); + pr_err("%s: error: invalid dev/input_dev or default_handler!\n", __func__); return NULL; } @@ -3305,18 +3688,10 @@ struct goog_touch_interface *goog_touch_interface_probe( gti->display_state = GTI_DISPLAY_STATE_ON; mutex_init(>i->input_lock); mutex_init(>i->input_process_lock); - goog_init_options(gti, options); - goog_offload_probe(gti); - goog_init_input(gti); - goog_register_tbn(gti); - goog_pm_probe(gti); - register_panel_bridge(gti); - goog_init_variable_report_rate(gti); - goog_update_fw_settings(gti); } if (!gti_class) - gti_class = class_create(THIS_MODULE, "goog_touch_interface"); + gti_class = class_create(THIS_MODULE, GTI_NAME); if (gti && gti_class) { char *name = kasprintf(GFP_KERNEL, "gti.%d", gti_dev_num); @@ -3327,19 +3702,22 @@ struct goog_touch_interface *goog_touch_interface_probe( gti->dev_id, gti, name); if (gti->dev) { gti_dev_num++; - GOOG_INFO("device create \"%s\".\n", name); + GOOG_INFO(gti, "device create \"%s\".\n", name); if (gti->vendor_dev) { ret = sysfs_create_link(>i->dev->kobj, >i->vendor_dev->kobj, "vendor"); - if (ret) - GOOG_ERR("sysfs_create_link() failed for vendor, ret=%d!\n", ret); + if (ret) { + GOOG_ERR(gti, "sysfs_create_link() failed for vendor, ret=%d!\n", + ret); + } } if (gti->vendor_input_dev) { ret = sysfs_create_link(>i->dev->kobj, >i->vendor_input_dev->dev.kobj, "vendor_input"); - if (ret) - GOOG_ERR("sysfs_create_link() failed for vendor_input, ret=%d!\n", + if (ret) { + GOOG_ERR(gti, "sysfs_create_link() failed for vendor_input, ret=%d!\n", ret); + } } } } @@ -3347,9 +3725,20 @@ struct goog_touch_interface *goog_touch_interface_probe( } if (gti && gti->dev) { + goog_init_input(gti); + goog_init_proc(gti); + goog_init_options(gti, options); + goog_offload_probe(gti); + goog_update_fw_settings(gti); + goog_register_tbn(gti); + goog_pm_probe(gti); + register_panel_bridge(gti); + goog_init_variable_report_rate(gti); + goog_update_fw_settings(gti); + ret = sysfs_create_group(>i->dev->kobj, &goog_attr_group); if (ret) - GOOG_ERR("sysfs_create_group() failed, ret= %d!\n", ret); + GOOG_ERR(gti, "sysfs_create_group() failed, ret= %d!\n", ret); } return gti; @@ -3375,6 +3764,8 @@ int goog_touch_interface_remove(struct goog_touch_interface *gti) if (gti_class) { unregister_chrdev_region(gti->dev_id, 1); if (!gti_dev_num) { + proc_remove(gti_proc_dir_root); + gti_proc_dir_root = NULL; class_destroy(gti_class); gti_class = NULL; } diff --git a/goog_touch_interface.h b/goog_touch_interface.h index 35357b6..d515098 100644 --- a/goog_touch_interface.h +++ b/goog_touch_interface.h @@ -18,15 +18,16 @@ #include "touch_offload.h" #include "uapi/input/touch_offload.h" -#define GOOG_LOG_NAME "GTI" -#define GOOG_DBG(fmt, args...) pr_debug("[%s] %s: " fmt, GOOG_LOG_NAME,\ +#define GTI_NAME "goog_touch_interface" +#define GOOG_LOG_NAME(gti) ((gti && gti->dev) ? dev_name(gti->dev) : "GTI") +#define GOOG_DBG(gti, fmt, args...) pr_debug("[%s] %s: " fmt, GOOG_LOG_NAME(gti),\ __func__, ##args) -#define GOOG_LOG(fmt, args...) pr_info("[%s] " fmt, GOOG_LOG_NAME, ##args) -#define GOOG_INFO(fmt, args...) pr_info("[%s] %s: " fmt, GOOG_LOG_NAME,\ +#define GOOG_LOG(gti, fmt, args...) pr_info("[%s] " fmt, GOOG_LOG_NAME(gti), ##args) +#define GOOG_INFO(gti, fmt, args...) pr_info("[%s] %s: " fmt, GOOG_LOG_NAME(gti),\ __func__, ##args) -#define GOOG_WARN(fmt, args...) pr_warn("[%s] %s: " fmt, GOOG_LOG_NAME,\ +#define GOOG_WARN(gti, fmt, args...) pr_warn("[%s] %s: " fmt, GOOG_LOG_NAME(gti),\ __func__, ##args) -#define GOOG_ERR(fmt, args...) pr_err("[%s] %s: " fmt, GOOG_LOG_NAME,\ +#define GOOG_ERR(gti, fmt, args...) pr_err("[%s] %s: " fmt, GOOG_LOG_NAME(gti),\ __func__, ##args) #define MAX_SLOTS 10 @@ -161,6 +162,16 @@ enum gti_pm_wakelock_type : u32 { GTI_PM_WAKELOCK_TYPE_OFFLOAD_REPORT = (1 << 6), }; +enum gti_proc_type : u32 { + GTI_PROC_MS_BASE, + GTI_PROC_MS_DIFF, + GTI_PROC_MS_RAW, + GTI_PROC_SS_BASE, + GTI_PROC_SS_DIFF, + GTI_PROC_SS_RAW, + GTI_PROC_NUM, +}; + enum gti_reset_mode : u32 { GTI_RESET_MODE_NOP = 0, GTI_RESET_MODE_SW = (1 << 0), @@ -521,6 +532,8 @@ struct gti_pm { * @panel_bridge: struct that used to register panel bridge notification. * @connector: struct that used to get panel status. * @cmd: struct that used by vendor default handler. + * @proc_dir: struct that used for procfs. + * @proc_heatmap: struct that used for heatmap procfs. * @input_timestamp: input timestamp from touch vendor driver. * @mf_downtime: timestamp for motion filter control. * @display_vrefresh: display vrefresh in Hz. @@ -548,9 +561,9 @@ struct gti_pm { * @default_grip_enabled: the grip default setting. * @ignore_palm_update: Ignore fw_palm status updates made on offload state change. * @default_palm_enabled: the palm default setting. - * @wakeup_before_force_active_enabled: waking up the screen to force active. * @lptw_triggered: LPTW is triggered or not. - * @wakeup_before_force_active_delay: the ms delay after waking up screen to force active. + * @ignore_force_active: Ignore the force_active sysfs request. + * @ignore_screenoff_heatmap: Ignore the heatmap request during screen-off. * @offload_id: id that used by touch offload. * @heatmap_buf: heatmap buffer that used by v4l2. * @heatmap_buf_size: heatmap buffer size that used by v4l2. @@ -586,6 +599,8 @@ struct goog_touch_interface { struct drm_bridge panel_bridge; struct drm_connector *connector; struct gti_union_cmd_data cmd; + struct proc_dir_entry *proc_dir; + struct proc_dir_entry *proc_heatmap[GTI_PROC_NUM]; ktime_t input_timestamp; ktime_t mf_downtime; @@ -617,9 +632,9 @@ struct goog_touch_interface { bool default_grip_enabled; bool ignore_palm_update; bool default_palm_enabled; - bool wakeup_before_force_active_enabled; bool lptw_triggered; - unsigned int wakeup_before_force_active_delay; + bool ignore_force_active; + bool ignore_screenoff_heatmap; union { u8 offload_id_byte[4]; u32 offload_id; |