From 13a399d18762b5924142a43b93e369a1aff3c003 Mon Sep 17 00:00:00 2001 From: Jens Reidel Date: Sun, 20 Aug 2023 22:59:48 +0200 Subject: [PATCH 1/2] input: gtx8: Demote all logs except probe and cfg load to debug Signed-off-by: Jens Reidel --- .../input/touchscreen/gtx8/goodix_cfg_bin.c | 60 ++++++------ .../touchscreen/gtx8/goodix_gtx8_update.c | 94 +++++++++--------- .../input/touchscreen/gtx8/goodix_ts_core.c | 96 +++++++++---------- .../touchscreen/gtx8/goodix_ts_gesture.c | 28 +++--- .../input/touchscreen/gtx8/goodix_ts_i2c.c | 80 ++++++++-------- .../input/touchscreen/gtx8/goodix_ts_tools.c | 20 ++-- 6 files changed, 189 insertions(+), 189 deletions(-) diff --git a/drivers/input/touchscreen/gtx8/goodix_cfg_bin.c b/drivers/input/touchscreen/gtx8/goodix_cfg_bin.c index 0f7ccb99cf4cb1..b255ae51c06a65 100644 --- a/drivers/input/touchscreen/gtx8/goodix_cfg_bin.c +++ b/drivers/input/touchscreen/gtx8/goodix_cfg_bin.c @@ -113,7 +113,7 @@ static int goodix_parse_cfg_bin(struct goodix_cfg_bin *cfg_bin) } /*debug, print pkg information*/ - ts_info("Driver bin info: ver %s, len %d, pkgs %d", + ts_debug("Driver bin info: ver %s, len %d, pkgs %d", cfg_bin->head.bin_version, cfg_bin->head.bin_len, cfg_bin->head.pkg_num); for (i = 0; i < cfg_bin->head.pkg_num; i++) { @@ -206,7 +206,7 @@ static int goodix_cfg_bin_proc(struct goodix_ts_core *core_data) /*parse cfg bin*/ r = goodix_parse_cfg_bin(cfg_bin); if (!r) { - ts_info("parse cfg bin SUCCESS"); + ts_debug("parse cfg bin SUCCESS"); } else { ts_err("parse cfg bin FAILED"); goto exit; @@ -215,25 +215,25 @@ static int goodix_cfg_bin_proc(struct goodix_ts_core *core_data) /*get register address and configuration from cfg bin*/ r = goodix_get_reg_and_cfg(ts_dev, cfg_bin); if (!r) { - ts_info("success get reg and cfg info from cfg bin"); + ts_debug("success get reg and cfg info from cfg bin"); } else { ts_err("failed get cfg and reg info, update fw then retry"); } /*debug*/ - ts_info("cfg_send_flag:0x%04x", ts_dev->reg.cfg_send_flag); - ts_info("pid:0x%04x", ts_dev->reg.pid); - ts_info("vid:0x%04x", ts_dev->reg.vid); - ts_info("sensor_id:0x%04x", ts_dev->reg.sensor_id); - ts_info("fw_mask:0x%04x", ts_dev->reg.fw_mask); - ts_info("fw_status:0x%04x", ts_dev->reg.fw_status); - ts_info("cfg_addr:0x%04x", ts_dev->reg.cfg_addr); - ts_info("esd:0x%04x", ts_dev->reg.esd); - ts_info("command:0x%04x", ts_dev->reg.command); - ts_info("coor:0x%04x", ts_dev->reg.coor); - ts_info("gesture:0x%04x", ts_dev->reg.gesture); - ts_info("fw_request:0x%04x", ts_dev->reg.fw_request); - ts_info("proximity:0x%04x", ts_dev->reg.proximity); + ts_debug("cfg_send_flag:0x%04x", ts_dev->reg.cfg_send_flag); + ts_debug("pid:0x%04x", ts_dev->reg.pid); + ts_debug("vid:0x%04x", ts_dev->reg.vid); + ts_debug("sensor_id:0x%04x", ts_dev->reg.sensor_id); + ts_debug("fw_mask:0x%04x", ts_dev->reg.fw_mask); + ts_debug("fw_status:0x%04x", ts_dev->reg.fw_status); + ts_debug("cfg_addr:0x%04x", ts_dev->reg.cfg_addr); + ts_debug("esd:0x%04x", ts_dev->reg.esd); + ts_debug("command:0x%04x", ts_dev->reg.command); + ts_debug("coor:0x%04x", ts_dev->reg.coor); + ts_debug("gesture:0x%04x", ts_dev->reg.gesture); + ts_debug("fw_request:0x%04x", ts_dev->reg.fw_request); + ts_debug("proximity:0x%04x", ts_dev->reg.proximity); exit: kfree(cfg_bin->cfg_pkgs); @@ -244,7 +244,7 @@ static int goodix_cfg_bin_proc(struct goodix_ts_core *core_data) else goodix_ts_blocking_notify(NOTIFY_CFG_BIN_SUCCESS, &r); - ts_info("cfg bin state %d, ret %d", ts_dev->cfg_bin_state, r); + ts_debug("cfg bin state %d, ret %d", ts_dev->cfg_bin_state, r); return r; } @@ -269,13 +269,13 @@ static int goodix_extract_cfg_pkg(struct goodix_ts_device *ts_dev, return -EINVAL; } if (ts_cfg->length) { - ts_info("get config type %d, len %d", + ts_debug("get config type %d, len %d", cfg_pkg->cnst_info.cfg_type, ts_cfg->length); memcpy(ts_cfg->data, cfg_pkg->cfg, ts_cfg->length); ts_cfg->initialized = TS_CFG_STABLE; mutex_init(&ts_cfg->lock); } else { - ts_info("no config data"); + ts_debug("no config data"); } /*get register info*/ @@ -336,12 +336,12 @@ static int goodix_get_reg_and_cfg(struct goodix_ts_device *ts_dev, continue; } - ts_info("ic_type:%d", ts_dev->ic_type); + ts_debug("ic_type:%d", ts_dev->ic_type); /* contrast sensor id */ addr = cfg_bin->cfg_pkgs[i].reg_info.sensor_id.addr; if (!addr) { - ts_info("pkg:%d, sensor_id reg is NULL", i); + ts_debug("pkg:%d, sensor_id reg is NULL", i); continue; } @@ -351,7 +351,7 @@ static int goodix_get_reg_and_cfg(struct goodix_ts_device *ts_dev, addr); goto get_default_pkg; } - ts_info("sensor id is %d", temp_sensor_id); + ts_debug("sensor id is %d", temp_sensor_id); /*sensor.reserved1 is a mask, if it's not ZERO, use it*/ if (cfg_bin->cfg_pkgs[i].reg_info.sensor_id.reserved1 != 0) temp_sensor_id &= cfg_bin->cfg_pkgs[i] @@ -416,7 +416,7 @@ static int goodix_get_reg_and_cfg(struct goodix_ts_device *ts_dev, continue; } - ts_info("try get package info: ic type %s, cfg type %d", + ts_debug("try get package info: ic type %s, cfg type %d", cfg_bin->cfg_pkgs[i].cnst_info.ic_type, cfg_bin->cfg_pkgs[i].cnst_info.cfg_type); /* currently only support normal and high_sense config */ @@ -428,7 +428,7 @@ static int goodix_get_reg_and_cfg(struct goodix_ts_device *ts_dev, if (!r) { ts_dev->cfg_bin_state = CFG_BIN_STATE_INITIALIZED; - ts_info("success parse cfg bin"); + ts_debug("success parse cfg bin"); } else { ts_err("failed parse cfg bin"); break; @@ -449,7 +449,7 @@ static int goodix_get_reg_and_cfg(struct goodix_ts_device *ts_dev, ts_dev->cfg_bin_state = CFG_BIN_STATE_ERROR; } else { ts_dev->cfg_bin_state = CFG_BIN_STATE_TEMP; - ts_info("get temp config data"); + ts_debug("get temp config data"); } r = -EINVAL; @@ -468,7 +468,7 @@ static int goodix_read_cfg_bin(struct device *dev, /*get cfg_bin_name*/ strlcpy(cfg_bin_name, TS_DEFAULT_CFG_BIN, sizeof(cfg_bin_name)); - ts_info("cfg_bin_name:%s", cfg_bin_name); + ts_debug("cfg_bin_name:%s", cfg_bin_name); for (i = 0; i < TS_RQST_FW_RETRY_TIMES; i++) { r = request_firmware(&firmware, cfg_bin_name, dev); @@ -477,7 +477,7 @@ static int goodix_read_cfg_bin(struct device *dev, cfg_bin_name, r, i + 1); msleep(1000); } else { - ts_info("Cfg_bin image [%s] is ready, try_times:%d", + ts_debug("Cfg_bin image [%s] is ready, try_times:%d", cfg_bin_name, i + 1); break; } @@ -564,7 +564,7 @@ static int goodix_later_init_thread(void *data) if (ret) ts_err("parse cfg bin encounter error, %d", ret); else - ts_info("success get cfg bin"); + ts_debug("success get cfg bin"); if (ts_dev->cfg_bin_state == CFG_BIN_STATE_ERROR) { ts_err("parse cfg bin encounter fatal err"); @@ -580,7 +580,7 @@ static int goodix_later_init_thread(void *data) ts_err("fw update failed, %d", ret); goto release_core; } - ts_info("fw update success retry parse cfg bin"); + ts_debug("fw update success retry parse cfg bin"); ret = goodix_cfg_bin_proc(ts_core); if (ret) { ts_err("failed parse cfg bin after fw update"); @@ -598,7 +598,7 @@ static int goodix_later_init_thread(void *data) } ret = goodix_ts_stage2_init(ts_core); if (!ret) { - ts_info("stage2 init success"); + ts_debug("stage2 init success"); return ret; } ts_err("stage2 init failed, %d", ret); diff --git a/drivers/input/touchscreen/gtx8/goodix_gtx8_update.c b/drivers/input/touchscreen/gtx8/goodix_gtx8_update.c index 6e636ee0594fd9..83b33b2e2e8c33 100644 --- a/drivers/input/touchscreen/gtx8/goodix_gtx8_update.c +++ b/drivers/input/touchscreen/gtx8/goodix_gtx8_update.c @@ -249,13 +249,13 @@ static int goodix_parse_firmware(struct firmware_data *fw_data) fw_offset += fw_info->subsys[i].size; } - ts_info("Firmware package protocol: V%u", fw_info->protocol_ver); - ts_info("Firmware PID:GT%s", fw_info->fw_pid); - ts_info("Firmware VID:%02X%02X%02X%02x", fw_info->fw_vid[0], + ts_debug("Firmware package protocol: V%u", fw_info->protocol_ver); + ts_debug("Firmware PID:GT%s", fw_info->fw_pid); + ts_debug("Firmware VID:%02X%02X%02X%02x", fw_info->fw_vid[0], fw_info->fw_vid[1], fw_info->fw_vid[2], fw_info->fw_vid[3]); - ts_info("Firmware chip type:%02X", fw_info->chip_type); - ts_info("Firmware size:%u", fw_info->size); - ts_info("Firmware subsystem num:%u", fw_info->subsys_num); + ts_debug("Firmware chip type:%02X", fw_info->chip_type); + ts_debug("Firmware size:%u", fw_info->size); + ts_debug("Firmware subsystem num:%u", fw_info->subsys_num); #ifdef CONFIG_GOODIX_DEBUG for (i = 0; i < fw_info->subsys_num; i++) { ts_debug("------------------------------------------"); @@ -292,7 +292,7 @@ static int goodix_check_update(struct goodix_ts_device *dev, */ ret = dev->hw_ops->read_version(dev, &fw_ver); if (ret) { - ts_info("failed get active pid"); + ts_debug("failed get active pid"); return -EINVAL; } @@ -309,14 +309,14 @@ static int goodix_check_update(struct goodix_ts_device *dev, ret = memcmp(fw_ver.vid, fw_info->fw_vid, dev->reg.vid_len); if (ret == 0) { - ts_info("FW version is equal to the IC's"); + ts_debug("FW version is equal to the IC's"); return 0; } else if (ret > 0) { - ts_info("Warning: fw version is lower the IC's"); + ts_debug("Warning: fw version is lower the IC's"); } } /* else invalid firmware, update firmware */ - ts_info("Firmware needs to be updated"); + ts_debug("Firmware needs to be updated"); return ret; } @@ -357,11 +357,11 @@ static int goodix_reg_write_confirm(struct goodix_ts_device *dev, goto exit; if (memcmp(data, cfm, len)) { - ts_info("data[0]:0x%02x, data[1]:0x%02x," + ts_debug("data[0]:0x%02x, data[1]:0x%02x," "read cfm[0]:0x%02x, cfm[1]:0x%02x", data[0], data[1], cfm[0], cfm[1]); dev->hw_ops->read_trans(dev, 0x6022, cfm, 2); - ts_info("read 0x6022 data[0]:0x%02x, data[1]:0x%02x", + ts_debug("read 0x6022 data[0]:0x%02x, data[1]:0x%02x", cfm[0], cfm[1]); r = -EMEMCMP; continue; @@ -407,7 +407,7 @@ static int goodix_load_isp(struct goodix_ts_device *ts_dev, fw_isp = &fw_data->fw_info.subsys[0]; - ts_info("Loading ISP start"); + ts_debug("Loading ISP start"); reg_val[0] = 0x00; r = goodix_reg_write(ts_dev, HW_REG_BANK_SELECT, reg_val, 1); if (r < 0) { @@ -462,7 +462,7 @@ static int goodix_load_isp(struct goodix_ts_device *ts_dev, ts_err("Failed set HW_REG_CPU_RUN_FROM flag"); return r; } - ts_info("Success write [8]0x55 to HW_REG_CPU_RUN_FROM"); + ts_debug("Success write [8]0x55 to HW_REG_CPU_RUN_FROM"); reg_val[0] = 0x00; r = goodix_reg_write(ts_dev, HW_REG_CPU_CTRL, reg_val, 1); @@ -480,7 +480,7 @@ static int goodix_load_isp(struct goodix_ts_device *ts_dev, break; } if (reg_val[0] == 0xAA && reg_val[1] == 0xBB) { - ts_info("ISP working OK"); + ts_debug("ISP working OK"); return 0; } ts_err("ISP not work,0x%x=0x%x, 0x%x=0x%x", HW_REG_ISP_RUN_FLAG, @@ -510,7 +510,7 @@ static int goodix_update_prepare(struct fw_update_ctrl *fwu_ctrl) /*reset IC*/ fwu_ctrl->allow_reset = true; - ts_info("firmware update, reset"); + ts_debug("firmware update, reset"); gpio_direction_output(ts_dev->board_data.reset_gpio, 0); udelay(2000); gpio_direction_output(ts_dev->board_data.reset_gpio, 1); @@ -524,7 +524,7 @@ static int goodix_update_prepare(struct fw_update_ctrl *fwu_ctrl) reg_val[0] = 0x00; r = goodix_reg_write_confirm(ts_dev, HW_REG_GIO_YS, reg_val, 1); if (r < 0) - ts_info("Failed to remove GIO hold flag, retry %d", + ts_debug("Failed to remove GIO hold flag, retry %d", retry); else break; @@ -541,14 +541,14 @@ static int goodix_update_prepare(struct fw_update_ctrl *fwu_ctrl) r = goodix_reg_write(ts_dev, HW_REG_ESD_KEY_DIS, reg_val, 1); if (r < 0) { - ts_info("failed dis esd key"); + ts_debug("failed dis esd key"); continue; } reg_val[0] = 0x95; r = goodix_reg_write(ts_dev, HW_REG_ESD_KEY_EN, reg_val, 1); if (r < 0) { - ts_info("failed open esd key"); + ts_debug("failed open esd key"); continue; } } @@ -556,7 +556,7 @@ static int goodix_update_prepare(struct fw_update_ctrl *fwu_ctrl) r = goodix_reg_write_confirm(ts_dev, HW_REG_CPU_CTRL, reg_val, 1); if (r < 0) { - ts_info("Failed to hold ss51, retry"); + ts_debug("Failed to hold ss51, retry"); msleep(20); } else { break; @@ -603,7 +603,7 @@ static int goodix_update_prepare(struct fw_update_ctrl *fwu_ctrl) ts_err("Failed to disable watchdog"); return r; } - ts_info("Success disable watchdog"); + ts_debug("Success disable watchdog"); /* set scramble */ reg_val[0] = 0x00; @@ -669,7 +669,7 @@ static int goodix_send_fw_packet(struct goodix_ts_device *dev, u8 type, u8 *pkt, if (!pkt) return -EINVAL; - ts_info("target fw subsys type:0x%x, len %d", type, len); + ts_debug("target fw subsys type:0x%x, len %d", type, len); r = goodix_reg_write_confirm(dev, HW_REG_ISP_BUFFER, pkt, len); if (r < 0) { ts_err("Failed to write firmware packet"); @@ -713,7 +713,7 @@ static int goodix_send_fw_packet(struct goodix_ts_device *dev, u8 type, u8 *pkt, r = goodix_reg_read(dev, HW_REG_FLASH_FLAG, reg_val, 2); if (!r && reg_val[0] == ISP_FLASH_SUCCESS && reg_val[1] == ISP_FLASH_SUCCESS) { - ts_info("Flash subsystem ok"); + ts_debug("Flash subsystem ok"); return 0; } } @@ -771,7 +771,7 @@ static int goodix_flash_subsystem(struct goodix_ts_device *dev, data_size = total_size > ISP_MAX_BUFFERSIZE ? ISP_MAX_BUFFERSIZE : total_size; - ts_info("Flash firmware to %08x,size:%u bytes", + ts_debug("Flash firmware to %08x,size:%u bytes", subsys_base_addr + offset, data_size); /* format one firmware packet */ @@ -831,11 +831,11 @@ static int goodix_flash_firmware(struct goodix_ts_device *dev, prog_step = 80 / (fw_num - 1); for (i = 1; i < fw_num && retry;) { - ts_info("--- Start to flash subsystem[%d] ---", i); + ts_debug("--- Start to flash subsystem[%d] ---", i); fw_x = &fw_info->subsys[i]; r = goodix_flash_subsystem(dev, fw_x); if (r == 0) { - ts_info("--- End flash subsystem[%d]: OK ---", i); + ts_debug("--- End flash subsystem[%d]: OK ---", i); fw_ctrl->progress += prog_step; i++; } else if (r == -EAGAIN) { @@ -903,7 +903,7 @@ static int goodix_update_finish(struct goodix_ts_device *ts_dev, r = goodix_reg_write_confirm(ts_dev, HW_REG_GIO_YS, reg_val, 1); if (!r) break; - ts_info("failed set GIO flag, r %d", r); + ts_debug("failed set GIO flag, r %d", r); } if (i >= 100) ts_err("failed set GIO flag, %d", r); @@ -932,7 +932,7 @@ static int goodix_flash_config(struct goodix_ts_device *ts_dev) } memset(temp_data, 0xFF, ISP_MAX_BUFFERSIZE); - ts_info("normal config length %d", ts_dev->normal_cfg.length); + ts_debug("normal config length %d", ts_dev->normal_cfg.length); memcpy(temp_data, ts_dev->normal_cfg.data, ts_dev->normal_cfg.length); /* format one firmware packet */ @@ -943,13 +943,13 @@ static int goodix_flash_config(struct goodix_ts_device *ts_dev) goto exit; } ts_debug("fw_pack:%*ph", 10, fw_packet); - ts_info("try flash config"); + ts_debug("try flash config"); ret = goodix_send_fw_packet(ts_dev, FLASH_SUBSYS_TYPE_CONFIG, fw_packet, ISP_MAX_BUFFERSIZE + 6); if (ret) ts_err("failed flash config, ret %d", ret); else - ts_info("success flash config with isp"); + ts_debug("success flash config with isp"); exit: kfree(temp_data); @@ -991,11 +991,11 @@ static int goodix_fw_update_proc(struct fw_update_ctrl *fwu_ctrl) &fwu_ctrl->fw_data.fw_info); if (!r) { fwu_ctrl->status = UPSTA_ABORT; - ts_info("fw update skipped"); + ts_debug("fw update skipped"); goto err_check_update; } } else { - ts_info("force update mode"); + ts_debug("force update mode"); } start_update: @@ -1014,7 +1014,7 @@ static int goodix_fw_update_proc(struct fw_update_ctrl *fwu_ctrl) if (GOODIX_FLASH_CONFIG_WITH_ISP && fwu_ctrl->mode & UPDATE_MODE_FLASH_CFG) { - ts_info("need flash config with isp"); + ts_debug("need flash config with isp"); goodix_flash_config(fwu_ctrl->ts_dev); } @@ -1042,12 +1042,12 @@ static int goodix_fw_update_proc(struct fw_update_ctrl *fwu_ctrl) err_check_update: err_parse_fw: if (fwu_ctrl->status == UPSTA_SUCCESS) - ts_info("Firmware update successfully"); + ts_debug("Firmware update successfully"); else if (fwu_ctrl->status == UPSTA_FAILED) ts_err("Firmware update failed"); fwu_ctrl->progress = 100; /* 100% */ - ts_info("fw update ret %d", r); + ts_debug("fw update ret %d", r); return r; } @@ -1068,12 +1068,12 @@ static int goodix_request_firmware(struct firmware_data *fw_data, struct device *dev = fw_ctrl->ts_dev->dev; int r; - ts_info("Request firmware image [%s]", name); + ts_debug("Request firmware image [%s]", name); r = request_firmware(&fw_data->firmware, name, dev); if (r < 0) ts_err("Firmware image [%s] not available,errno:%d", name, r); else - ts_info("Firmware image [%s] is ready", name); + ts_debug("Firmware image [%s] is ready", name); return r; } @@ -1098,7 +1098,7 @@ static int goodix_fw_update_thread(void *data) mutex_lock(&fwu_ctrl->mutex); if (fwu_ctrl->mode & UPDATE_MODE_SRC_HEAD) { - ts_info("Firmware header update starts"); + ts_debug("Firmware header update starts"); temp_firmware = kzalloc(sizeof(struct firmware), GFP_KERNEL); if (!temp_firmware) { ts_err("Failed to allocate memory for firmware"); @@ -1108,7 +1108,7 @@ static int goodix_fw_update_thread(void *data) temp_firmware->data = goodix_default_fw; fwu_ctrl->fw_data.firmware = temp_firmware; } else if (fwu_ctrl->mode & UPDATE_MODE_SRC_REQUEST) { - ts_info("Firmware request update starts"); + ts_debug("Firmware request update starts"); r = goodix_request_firmware(&fwu_ctrl->fw_data, fwu_ctrl->fw_name); if (r < 0) { @@ -1168,7 +1168,7 @@ static int goodix_fw_update_thread(void *data) ts_err("fw update failed, %d", r); goodix_ts_blocking_notify(NOTIFY_FWUPDATE_FAILED, NULL); } else { - ts_info("fw update success"); + ts_debug("fw update success"); goodix_ts_blocking_notify(NOTIFY_FWUPDATE_SUCCESS, NULL); } return r; @@ -1197,7 +1197,7 @@ static ssize_t goodix_sysfs_update_en_store(struct goodix_ext_module *module, return -EINVAL; } - ts_info("set update mode:0x%x", buf[0]); + ts_debug("set update mode:0x%x", buf[0]); if (buf[0] == '1') { mode = UPDATE_MODE_FORCE | UPDATE_MODE_BLOCK | UPDATE_MODE_SRC_SYSFS; @@ -1215,7 +1215,7 @@ static ssize_t goodix_sysfs_update_en_store(struct goodix_ext_module *module, ret = goodix_do_fw_update(mode); if (!ret) { - ts_info("success start update work"); + ts_debug("success start update work"); return count; } ts_err("failed start fw update work"); @@ -1235,7 +1235,7 @@ static ssize_t goodix_sysfs_update_result_show(struct goodix_ext_module *module, char *result = NULL; struct fw_update_ctrl *fw_ctrl = module->priv_data; - ts_info("result show"); + ts_debug("result show"); switch (fw_ctrl->status) { case UPSTA_NOTWORK: result = "notwork"; @@ -1446,7 +1446,7 @@ int goodix_do_fw_update(int mode) ts_debug("fw update mode 0x%x", mode); if (fwu_ctrl->mode & UPDATE_MODE_BLOCK) { ret = goodix_fw_update_thread(fwu_ctrl); - ts_info("fw update return %d", ret); + ts_debug("fw update return %d", ret); return ret; } else { /* create and run update thread */ @@ -1457,7 +1457,7 @@ int goodix_do_fw_update(int mode) PTR_ERR(fwu_thrd)); return -EFAULT; } - ts_info("success create fw update thread"); + ts_debug("success create fw update thread"); return 0; } } @@ -1469,7 +1469,7 @@ static int goodix_fw_update_init(struct goodix_ts_core *core_data, struct goodix_ts_board_data *ts_bdata = board_data(core_data); if (goodix_fw_update_ctrl.initialized) { - ts_info("no need reinit"); + ts_debug("no need reinit"); return ret; } @@ -1572,7 +1572,7 @@ static struct goodix_ext_module goodix_fwu_module = { static int __init goodix_fwu_module_init(void) { - ts_info("goodix_fwupdate_module_ini IN"); + ts_debug("goodix_fwupdate_module_ini IN"); mutex_init(&goodix_fw_update_ctrl.mutex); return goodix_register_ext_module(&goodix_fwu_module); } diff --git a/drivers/input/touchscreen/gtx8/goodix_ts_core.c b/drivers/input/touchscreen/gtx8/goodix_ts_core.c index 6b867736e43ef8..dc87720cf5576e 100644 --- a/drivers/input/touchscreen/gtx8/goodix_ts_core.c +++ b/drivers/input/touchscreen/gtx8/goodix_ts_core.c @@ -63,7 +63,7 @@ static void __do_register_ext_module(struct work_struct *work) struct goodix_ext_module *ext_module, *next; struct list_head *insert_point = &goodix_modules.head; - ts_info("__do_register_ext_module IN"); + ts_debug("__do_register_ext_module IN"); if (core_module_prob_sate == CORE_MODULE_PROB_FAILED || core_module_prob_sate == CORE_MODULE_REMOVED) { @@ -86,7 +86,7 @@ static void __do_register_ext_module(struct work_struct *work) return; } - ts_info("start register ext_module"); + ts_debug("start register ext_module"); /* priority level *must* be set */ if (module->priority == EXTMOD_PRIO_RESERVED) { @@ -99,7 +99,7 @@ static void __do_register_ext_module(struct work_struct *work) list_for_each_entry_safe(ext_module, next, &goodix_modules.head, list) { if (ext_module == module) { - ts_info("Module [%s] already exists", + ts_debug("Module [%s] already exists", module->name); mutex_unlock(&goodix_modules.mutex); return; @@ -131,7 +131,7 @@ static void __do_register_ext_module(struct work_struct *work) goodix_modules.count++; mutex_unlock(&goodix_modules.mutex); - ts_info("Module [%s] registered,priority:%u", module->name, + ts_debug("Module [%s] registered,priority:%u", module->name, module->priority); } @@ -154,12 +154,12 @@ int goodix_register_ext_module(struct goodix_ext_module *module) init_completion(&goodix_modules.core_comp); } - ts_info("goodix_register_ext_module IN"); + ts_debug("goodix_register_ext_module IN"); INIT_WORK(&module->work, __do_register_ext_module); schedule_work(&module->work); - ts_info("goodix_register_ext_module OUT"); + ts_debug("goodix_register_ext_module OUT"); return 0; } @@ -213,7 +213,7 @@ int goodix_unregister_ext_module(struct goodix_ext_module *module) if (module->funcs && module->funcs->exit) module->funcs->exit(goodix_modules.core_data, module); - ts_info("Module [%s] unregistered", module->name ? module->name : " "); + ts_debug("Module [%s] unregistered", module->name ? module->name : " "); return 0; } EXPORT_SYMBOL_GPL(goodix_unregister_ext_module); @@ -242,7 +242,7 @@ static void goodix_remove_all_ext_modules(void) static void goodix_ext_sysfs_release(struct kobject *kobj) { - ts_info("Kobject released!"); + ts_debug("Kobject released!"); } #define to_ext_module(kobj) container_of(kobj, struct goodix_ext_module, kobj) @@ -548,7 +548,7 @@ static ssize_t goodix_ts_send_cfg_store(struct device *dev, GOODIX_DEFAULT_CFG_NAME, r); goto exit; } else - ts_info("cfg file [%s] is ready", GOODIX_DEFAULT_CFG_NAME); + ts_debug("cfg file [%s] is ready", GOODIX_DEFAULT_CFG_NAME); config = kzalloc(sizeof(*config), GFP_KERNEL); if (config == NULL) @@ -711,7 +711,7 @@ static ssize_t goodix_ts_reg_rw_store(struct device *dev, goto err_out; } rw_addr = (u16)result; - ts_info("rw addr is 0x%x\n", rw_addr); + ts_debug("rw addr is 0x%x\n", rw_addr); } /* get length */ @@ -725,7 +725,7 @@ static ssize_t goodix_ts_reg_rw_store(struct device *dev, goto err_out; } rw_len = (u32)result; - ts_info("rw length info is %d\n", rw_len); + ts_debug("rw length info is %d\n", rw_len); if (rw_len > sizeof(store_buf)) { ts_err("data len > %lu\n", sizeof(store_buf)); goto err_out; @@ -746,7 +746,7 @@ static ssize_t goodix_ts_reg_rw_store(struct device *dev, goto err_out; } store_buf[i] = (u8)result; - ts_info("get data[%d]=0x%x\n", i, store_buf[i]); + ts_debug("get data[%d]=0x%x\n", i, store_buf[i]); } } ret = ts_dev->hw_ops->write(ts_dev, rw_addr, store_buf, rw_len); @@ -756,7 +756,7 @@ static ssize_t goodix_ts_reg_rw_store(struct device *dev, goto err_out; } - ts_info("%s write to addr (%x) with data %*ph\n", "success", rw_addr, + ts_debug("%s write to addr (%x) with data %*ph\n", "success", rw_addr, rw_len, store_buf); return count; @@ -806,7 +806,7 @@ static ssize_t goodix_sysfs_config_write(struct file *file, int ret; if (pos != 0 || count > GOODIX_CFG_MAX_SIZE) { - ts_info("pos(%d) != 0, cfg size %zu", (int)pos, count); + ts_debug("pos(%d) != 0, cfg size %zu", (int)pos, count); return -EINVAL; } @@ -825,7 +825,7 @@ static ssize_t goodix_sysfs_config_write(struct file *file, count = -EINVAL; ts_err("send config failed %d", ret); } else { - ts_info("send config success"); + ts_debug("send config success"); } kfree(config); @@ -1077,7 +1077,7 @@ int goodix_ts_irq_setup(struct goodix_ts_core *core_data) else core_data->irq = ts_bdata->irq; - ts_info("IRQ:%u,flags:%d", core_data->irq, (int)ts_bdata->irq_flags); + ts_debug("IRQ:%u,flags:%d", core_data->irq, (int)ts_bdata->irq_flags); r = devm_request_threaded_irq(&core_data->pdev->dev, core_data->irq, NULL, goodix_ts_threadirq_func, ts_bdata->irq_flags | IRQF_ONESHOT, @@ -1125,7 +1125,7 @@ static int goodix_ts_power_init(struct goodix_ts_core *core_data) struct device *dev = NULL; int r = 0; - ts_info("Power init"); + ts_debug("Power init"); /* dev:i2c client device or spi slave device*/ dev = core_data->ts_dev->dev; ts_bdata = board_data(core_data); @@ -1140,7 +1140,7 @@ static int goodix_ts_power_init(struct goodix_ts_core *core_data) } core_data->avdd_load = ts_bdata->avdd_load; } else { - ts_info("Avdd name is NULL[skip]"); + ts_debug("Avdd name is NULL[skip]"); } return r; @@ -1156,7 +1156,7 @@ int goodix_ts_power_on(struct goodix_ts_core *core_data) struct goodix_ts_board_data *ts_bdata = board_data(core_data); int r; - ts_info("Device power on"); + ts_debug("Device power on"); if (core_data->power_on) return 0; @@ -1173,12 +1173,12 @@ int goodix_ts_power_on(struct goodix_ts_core *core_data) if (r < 0) ts_err("enable 3v3 fail!"); - ts_info("set regulator load SUCCESS"); + ts_debug("set regulator load SUCCESS"); } r = regulator_enable(core_data->avdd); if (!r) { - ts_info("regulator enable SUCCESS"); + ts_debug("regulator enable SUCCESS"); if (ts_bdata->power_on_delay_us) usleep_range(ts_bdata->power_on_delay_us, ts_bdata->power_on_delay_us); @@ -1201,14 +1201,14 @@ int goodix_ts_power_off(struct goodix_ts_core *core_data) struct goodix_ts_board_data *ts_bdata = board_data(core_data); int r; - ts_info("Device power off"); + ts_debug("Device power off"); if (!core_data->power_on) return 0; if (core_data->avdd) { r = regulator_disable(core_data->avdd); if (!r) { - ts_info("regulator disable SUCCESS"); + ts_debug("regulator disable SUCCESS"); if (ts_bdata->power_off_delay_us) usleep_range(ts_bdata->power_off_delay_us, ts_bdata->power_off_delay_us); @@ -1235,7 +1235,7 @@ static int goodix_ts_pinctrl_init(struct goodix_ts_core *core_data) /* get pinctrl handler from of node */ core_data->pinctrl = devm_pinctrl_get(core_data->ts_dev->dev); if (IS_ERR_OR_NULL(core_data->pinctrl)) { - ts_info("Failed to get pinctrl handler[need confirm]"); + ts_debug("Failed to get pinctrl handler[need confirm]"); core_data->pinctrl = NULL; return -EINVAL; } @@ -1286,7 +1286,7 @@ static int goodix_ts_gpio_setup(struct goodix_ts_core *core_data) struct goodix_ts_board_data *ts_bdata = board_data(core_data); int r = 0; - ts_info("GPIO setup,reset-gpio:%d, irq-gpio:%d", ts_bdata->reset_gpio, + ts_debug("GPIO setup,reset-gpio:%d, irq-gpio:%d", ts_bdata->reset_gpio, ts_bdata->irq_gpio); /* * after kenerl3.13, gpio_ api is deprecated, new @@ -1507,9 +1507,9 @@ static void goodix_ts_esd_on(struct goodix_ts_core *core) atomic_set(&ts_esd->esd_on, 1); if (!schedule_delayed_work(&ts_esd->esd_work, 2 * HZ)) { - ts_info("esd work already in workqueue"); + ts_debug("esd work already in workqueue"); } - ts_info("esd on"); + ts_debug("esd on"); } /** @@ -1522,7 +1522,7 @@ static void goodix_ts_esd_off(struct goodix_ts_core *core) atomic_set(&ts_esd->esd_on, 0); ret = cancel_delayed_work_sync(&ts_esd->esd_work); - ts_info("Esd off, esd work state %d", ret); + ts_debug("Esd off, esd work state %d", ret); } /** @@ -1570,7 +1570,7 @@ int goodix_ts_esd_init(struct goodix_ts_core *core) int r; if (!dev->hw_ops->check_hw || !dev->reg.esd) { - ts_info("missing key info for esd check"); + ts_debug("missing key info for esd check"); return 0; } @@ -1619,7 +1619,7 @@ static int goodix_ts_suspend(struct goodix_ts_core *core_data) struct goodix_ts_device *ts_dev = core_data->ts_dev; int r; - ts_info("Suspend start"); + ts_debug("Suspend start"); /* * notify suspend event, inform the esd protector @@ -1639,7 +1639,7 @@ static int goodix_ts_suspend(struct goodix_ts_core *core_data) ext_module); if (r == EVT_CANCEL_SUSPEND) { mutex_unlock(&goodix_modules.mutex); - ts_info("Canceled by module:%s", + ts_debug("Canceled by module:%s", ext_module->name); goto out; } @@ -1676,7 +1676,7 @@ static int goodix_ts_suspend(struct goodix_ts_core *core_data) ext_module); if (r == EVT_CANCEL_SUSPEND) { mutex_unlock(&goodix_modules.mutex); - ts_info("Canceled by module:%s", + ts_debug("Canceled by module:%s", ext_module->name); goto out; } @@ -1685,7 +1685,7 @@ static int goodix_ts_suspend(struct goodix_ts_core *core_data) mutex_unlock(&goodix_modules.mutex); out: - ts_info("Suspend end"); + ts_debug("Suspend end"); return 0; } @@ -1699,7 +1699,7 @@ static int goodix_ts_resume(struct goodix_ts_core *core_data) struct goodix_ts_device *ts_dev = core_data->ts_dev; int r; - ts_info("Resume start"); + ts_debug("Resume start"); goodix_ts_release_connects(core_data); mutex_lock(&goodix_modules.mutex); @@ -1713,7 +1713,7 @@ static int goodix_ts_resume(struct goodix_ts_core *core_data) ext_module); if (r == EVT_CANCEL_RESUME) { mutex_unlock(&goodix_modules.mutex); - ts_info("Canceled by module:%s", + ts_debug("Canceled by module:%s", ext_module->name); goto out; } @@ -1746,7 +1746,7 @@ static int goodix_ts_resume(struct goodix_ts_core *core_data) ext_module); if (r == EVT_CANCEL_RESUME) { mutex_unlock(&goodix_modules.mutex); - ts_info("Canceled by module:%s", + ts_debug("Canceled by module:%s", ext_module->name); goto out; } @@ -1760,7 +1760,7 @@ static int goodix_ts_resume(struct goodix_ts_core *core_data) * notify resume event, inform the esd protector * and charger detector to turn on the work */ - ts_info("try notify resume"); + ts_debug("try notify resume"); goodix_ts_blocking_notify(NOTIFY_RESUME, NULL); out: ts_debug("Resume end"); @@ -1856,13 +1856,13 @@ static int goodix_generic_noti_callback(struct notifier_block *self, const struct goodix_ts_hw_ops *hw_ops = ts_hw_ops(ts_core); int r; - ts_info("notify event type 0x%x", (unsigned int)action); + ts_debug("notify event type 0x%x", (unsigned int)action); switch (action) { case NOTIFY_FWUPDATE_SUCCESS: case NOTIFY_FWUPDATE_FAILED: r = hw_ops->read_version(ts_dev, &ts_dev->chip_version); if (r < 0) - ts_info("failed read fw version info[ignore]"); + ts_debug("failed read fw version info[ignore]"); break; default: break; @@ -1879,12 +1879,12 @@ int goodix_ts_stage2_init(struct goodix_ts_core *core_data) /* send normal-cfg to firmware */ r = ts_dev->hw_ops->send_config(ts_dev, &(ts_dev->normal_cfg)); if (r < 0) { - ts_info("failed send normal config[ignore]"); + ts_debug("failed send normal config[ignore]"); } r = ts_dev->hw_ops->read_version(ts_dev, &ts_dev->chip_version); if (r < 0) - ts_info("failed read fw version info[ignore]"); + ts_debug("failed read fw version info[ignore]"); /* alloc/config/register input device */ r = goodix_ts_input_dev_config(core_data); @@ -1903,10 +1903,10 @@ int goodix_ts_stage2_init(struct goodix_ts_core *core_data) /* request irq line */ r = goodix_ts_irq_setup(core_data); if (r < 0) { - ts_info("failed set irq"); + ts_debug("failed set irq"); goto exit; } - ts_info("success register irq"); + ts_debug("success register irq"); #ifdef CONFIG_FB core_data->fb_notifier.notifier_call = goodix_ts_fb_notifier_callback; @@ -1943,7 +1943,7 @@ static int goodix_ts_probe(struct platform_device *pdev) struct goodix_ts_device *ts_device; int r; - ts_info("goodix_ts_probe IN"); + ts_debug("goodix_ts_probe IN"); ts_device = pdev->dev.platform_data; if (!ts_device || !ts_device->hw_ops) { @@ -1998,7 +1998,7 @@ static int goodix_ts_probe(struct platform_device *pdev) /* Try start a thread to get config-bin info */ r = goodix_start_later_init(core_data); if (r) { - ts_info("Failed start cfg_bin_proc"); + ts_debug("Failed start cfg_bin_proc"); goto out; } @@ -2068,10 +2068,10 @@ static struct platform_driver goodix_ts_driver = { int goodix_ts_core_init(void) { - ts_info("Core layer init"); + ts_debug("Core layer init"); if (!goodix_modules.initialized) { /* this may init by outer modules register event */ - ts_info("init modules struct"); + ts_debug("init modules struct"); goodix_modules.initialized = true; INIT_LIST_HEAD(&goodix_modules.head); mutex_init(&goodix_modules.mutex); @@ -2085,7 +2085,7 @@ int goodix_ts_core_init(void) /* uninit module manually */ int goodix_ts_core_release(struct goodix_ts_core *core_data) { - ts_info("goodix core module removed"); + ts_debug("goodix core module removed"); platform_driver_unregister(&goodix_ts_driver); goodix_ts_dev_release(); diff --git a/drivers/input/touchscreen/gtx8/goodix_ts_gesture.c b/drivers/input/touchscreen/gtx8/goodix_ts_gesture.c index 4c8e291df12f9c..9030891338f6ea 100644 --- a/drivers/input/touchscreen/gtx8/goodix_ts_gesture.c +++ b/drivers/input/touchscreen/gtx8/goodix_ts_gesture.c @@ -71,7 +71,7 @@ static ssize_t gsx_gesture_type_show(struct goodix_ext_module *module, unsigned char *type; if (atomic_read(&gsx_gesture->registered) != 1) { - ts_info("Gesture module not register!"); + ts_debug("Gesture module not register!"); return -EPERM; } type = kzalloc(256, GFP_KERNEL); @@ -134,7 +134,7 @@ static ssize_t gsx_gesture_enable_store(struct goodix_ext_module *module, int ret; if (sscanf(buf, "%u", &tmp) != 1) { - ts_info("Parameter illegal"); + ts_debug("Parameter illegal"); return -EINVAL; } ts_debug("Tmp value =%d", tmp); @@ -146,7 +146,7 @@ static ssize_t gsx_gesture_enable_store(struct goodix_ext_module *module, } ret = goodix_register_ext_module(&gsx_gesture->module); if (!ret) { - ts_info("Gesture module registered!"); + ts_debug("Gesture module registered!"); atomic_set(&gsx_gesture->registered, 1); } else { atomic_set(&gsx_gesture->registered, 0); @@ -161,10 +161,10 @@ static ssize_t gsx_gesture_enable_store(struct goodix_ext_module *module, ret = goodix_unregister_ext_module(&gsx_gesture->module); if (!ret) { atomic_set(&gsx_gesture->registered, 0); - ts_info("Gesture module unregistered success"); + ts_debug("Gesture module unregistered success"); } else { atomic_set(&gsx_gesture->registered, 1); - ts_info("Gesture module unregistered failed"); + ts_debug("Gesture module unregistered failed"); } } else { ts_err("Parameter error!"); @@ -179,11 +179,11 @@ static ssize_t gsx_gesture_data_show(struct goodix_ext_module *module, ssize_t count; if (atomic_read(&gsx_gesture->registered) != 1) { - ts_info("Gesture module not register!"); + ts_debug("Gesture module not register!"); return -EPERM; } if (!buf) { - ts_info("Parameter error!"); + ts_debug("Parameter error!"); return -EPERM; } read_lock(&gsx_gesture->rwlock); @@ -336,7 +336,7 @@ static int gsx_gesture_ist(struct goodix_ts_core *core_data, checksum = checksum_u8(temp_data, key_data_len); if (checksum) { ts_err("Gesture data checksum error:0x%x", checksum); - ts_info("Gesture data %*ph", (int)sizeof(temp_data), temp_data); + ts_debug("Gesture data %*ph", (int)sizeof(temp_data), temp_data); goto re_send_ges_cmd; } @@ -355,19 +355,19 @@ static int gsx_gesture_ist(struct goodix_ts_core *core_data, if (QUERYBIT(gsx_gesture->gesture_type, gsx_type)) { /* do resume routine */ - ts_info("Gesture match success, resume IC"); + ts_debug("Gesture match success, resume IC"); input_report_key(core_data->input_dev, KEY_POWER, 1); input_sync(core_data->input_dev); input_report_key(core_data->input_dev, KEY_POWER, 0); input_sync(core_data->input_dev); goto gesture_ist_exit; } else { - ts_info("Unsupported gesture:%x", temp_data[2]); + ts_debug("Unsupported gesture:%x", temp_data[2]); } re_send_ges_cmd: if (gsx_enter_gesture_mode(core_data->ts_dev)) - ts_info("warning: failed re_send gesture cmd\n"); + ts_debug("warning: failed re_send gesture cmd\n"); gesture_ist_exit: ts_dev->hw_ops->write_trans(ts_dev, ts_dev->reg.gesture, &clear_reg, 1); return EVT_CANCEL_IRQEVT; @@ -398,7 +398,7 @@ static int gsx_gesture_before_suspend(struct goodix_ts_core *core_data, if (ret != 0) ts_err("failed enter gesture mode"); else - ts_info("Set IC in gesture mode"); + ts_debug("Set IC in gesture mode"); return EVT_CANCEL_SUSPEND; } @@ -414,7 +414,7 @@ static int __init goodix_gsx_gesture_init(void) { /* initialize core_data->ts_dev->gesture_cmd */ int result; - ts_info("gesture module init"); + ts_debug("gesture module init"); gsx_gesture = kzalloc(sizeof(struct gesture_module), GFP_KERNEL); if (!gsx_gesture) result = -ENOMEM; @@ -435,7 +435,7 @@ static int __init goodix_gsx_gesture_init(void) static void __exit goodix_gsx_gesture_exit(void) { int i, ret; - ts_info("gesture module exit"); + ts_debug("gesture module exit"); if (atomic_read(&gsx_gesture->registered)) { ret = goodix_unregister_ext_module(&gsx_gesture->module); atomic_set(&gsx_gesture->registered, 0); diff --git a/drivers/input/touchscreen/gtx8/goodix_ts_i2c.c b/drivers/input/touchscreen/gtx8/goodix_ts_i2c.c index 84529f5b76b86f..88c2ff07012660 100644 --- a/drivers/input/touchscreen/gtx8/goodix_ts_i2c.c +++ b/drivers/input/touchscreen/gtx8/goodix_ts_i2c.c @@ -148,7 +148,7 @@ static int goodix_parse_dt(struct device_node *node, ts_err("invalid reset-gpio in dt: %d", r); return -EINVAL; } - ts_info("get reset-gpio[%d] from dt", r); + ts_debug("get reset-gpio[%d] from dt", r); board_data->reset_gpio = r; r = of_get_named_gpio(node, "goodix,irq-gpio", 0); @@ -156,7 +156,7 @@ static int goodix_parse_dt(struct device_node *node, ts_err("invalid irq-gpio in dt: %d", r); return -EINVAL; } - ts_info("get irq-gpio[%d] from dt", r); + ts_debug("get irq-gpio[%d] from dt", r); board_data->irq_gpio = r; r = of_property_read_u32(node, "goodix,irq-flags", @@ -169,12 +169,12 @@ static int goodix_parse_dt(struct device_node *node, memset(board_data->avdd_name, 0, sizeof(board_data->avdd_name)); r = of_property_read_string(node, "goodix,avdd-name", &name_tmp); if (!r) { - ts_info("avdd name form dt: %s", name_tmp); + ts_debug("avdd name from dt: %s", name_tmp); if (strlen(name_tmp) < sizeof(board_data->avdd_name)) strncpy(board_data->avdd_name, name_tmp, sizeof(board_data->avdd_name)); else - ts_info("invalid avdd name length: %ld > %ld", + ts_debug("invalid avdd name length: %ld > %ld", strlen(name_tmp), sizeof(board_data->avdd_name)); } @@ -235,9 +235,9 @@ static int goodix_parse_dt(struct device_node *node, board_data->pen_enable = of_property_read_bool(node, "goodix,pen-enable"); if (board_data->pen_enable) - ts_info("goodix pen enabled"); + ts_debug("goodix pen enabled"); - ts_info("***key:%d, %d, %d, %d", board_data->panel_key_map[0], + ts_debug("***key:%d, %d, %d, %d", board_data->panel_key_map[0], board_data->panel_key_map[1], board_data->panel_key_map[2], board_data->panel_key_map[3]); @@ -356,7 +356,7 @@ int goodix_i2c_read_trans(struct goodix_ts_device *dev, unsigned int reg, address += transfer_length; break; } - ts_info("I2c read retry[%d]:0x%x", retry + 1, reg); + ts_debug("I2c read retry[%d]:0x%x", retry + 1, reg); msleep(20); } if (unlikely(retry == GOODIX_BUS_RETRY_TIMES)) { @@ -485,7 +485,7 @@ static int goodix_set_i2c_doze_mode(struct goodix_ts_device *dev, int enable) if (i >= TS_DOZE_ENABLE_RETRY_TIMES) ts_err("i2c doze mode enable failed"); } else { - /*ts_info("doze count not euqal 0, + /*ts_debug("doze count not euqal 0, * so skip doze mode enable"); */ result = 0; @@ -802,7 +802,7 @@ static int goodix_read_version(struct goodix_ts_device *dev, } if (sensor_id_mask != 0) { version->sensor_id = buffer[0] & sensor_id_mask; - ts_info("sensor_id_mask:0x%02x, sensor_id:0x%02x", + ts_debug("sensor_id_mask:0x%02x, sensor_id:0x%02x", sensor_id_mask, version->sensor_id); } else { version->sensor_id = buffer[0]; @@ -810,7 +810,7 @@ static int goodix_read_version(struct goodix_ts_device *dev, version->valid = true; - ts_info("PID:%s,SensorID:%d, VID:%*ph", version->pid, + ts_debug("PID:%s,SensorID:%d, VID:%*ph", version->pid, version->sensor_id, (int)sizeof(version->vid), version->vid); exit: /*enable doze mode, just valid for normandy @@ -922,7 +922,7 @@ static int _do_goodix_send_config(struct goodix_ts_device *dev, break; usleep_range(10000, 11000); } - ts_info("send config result: %*ph", 3, buf); + ts_debug("send config result: %*ph", 3, buf); /* set 0x7D to end send config process */ goodix_cmd_init(dev, &ts_cmd, COMMAND_END_SEND_CFG_YS, 0, dev->reg.command); @@ -941,7 +941,7 @@ static int _do_goodix_send_config(struct goodix_ts_device *dev, if (buf[2] != TS_CFG_REPLY_DATA_EQU) ts_err("failed send cfg"); else - ts_info("config data equal with flash"); + ts_debug("config data equal with flash"); r = -EINVAL; goto exit; } @@ -962,7 +962,7 @@ static int _do_goodix_send_config(struct goodix_ts_device *dev, } } - ts_info("Send cfg SUCCESS"); + ts_debug("Send cfg SUCCESS"); r = 0; exit: @@ -996,7 +996,7 @@ static int _do_goodix_send_config(struct goodix_ts_device *dev, bag_num = cfg[TS_CFG_BAG_NUM_INDEX]; bag_start = TS_CFG_BAG_START_INDEX; - ts_info("cfg bag_num:%d, cfg length:%d", bag_num, length); + ts_debug("cfg bag_num:%d, cfg length:%d", bag_num, length); for (j = 0; j < bag_num; j++) { if (bag_start >= length - 1) { ts_err("ERROR, overflow!!bag_start:%d, cfg_len:%d", @@ -1027,7 +1027,7 @@ static int _do_goodix_send_config(struct goodix_ts_device *dev, } ret = 0; - ts_info("configuration check SUCCESS"); + ts_debug("configuration check SUCCESS"); exit: return ret; @@ -1051,7 +1051,7 @@ static int goodix_send_config(struct goodix_ts_device *dev, // return -EINVAL; // } - ts_info("ver:%02xh,size:%d", config->data[0], config->length); + ts_debug("ver:%02xh,size:%d", config->data[0], config->length); mutex_lock(&config->lock); /*disable doze mode*/ @@ -1093,7 +1093,7 @@ static int goodix_read_config_ys(struct goodix_ts_device *dev, u8 *buf) goto err_out; } - ts_info("config_version:%u, vub_bags:%u", buf[0], sub_bags); + ts_debug("config_version:%u, vub_bags:%u", buf[0], sub_bags); for (i = 0; i < sub_bags; i++) { /* read sub head [0]: sub bag num, [1]: sub bag length */ ret = goodix_i2c_read(dev, cfg_addr + offset, buf + offset, 2); @@ -1157,7 +1157,7 @@ static int goodix_read_config_nor(struct goodix_ts_device *dev, u8 *buf) goto err_out; } - ts_info("config_version:%u, vub_bags:%u", buf[0], sub_bags); + ts_debug("config_version:%u, vub_bags:%u", buf[0], sub_bags); for (i = 0; i < sub_bags; i++) { /* read sub head [0]: sub bag num, [1]: sub bag length */ ret = goodix_i2c_read(dev, cfg_addr + offset, buf + offset, 2); @@ -1275,7 +1275,7 @@ int goodix_hw_reset(struct goodix_ts_device *dev) u8 data[2] = { 0x00 }; int r = 0; - ts_info("HW reset"); + ts_debug("HW reset"); gpio_direction_output(dev->board_data.reset_gpio, 0); udelay(2000); @@ -1288,7 +1288,7 @@ int goodix_hw_reset(struct goodix_ts_device *dev) if (r < 0) ts_err("IC reset, init dynamic esd FAILED"); } else { - ts_info("reg.esd is NULL, skip dynamic esd init"); + ts_debug("reg.esd is NULL, skip dynamic esd init"); } return 0; @@ -1312,30 +1312,30 @@ static int goodix_request_handler(struct goodix_ts_device *dev) switch (buffer[0]) { case REQUEST_CONFIG: - ts_info("HW request config"); + ts_debug("HW request config"); r = goodix_send_config(dev, &(dev->normal_cfg)); if (r != 0) - ts_info("request config, send config failed"); + ts_debug("request config, send config failed"); break; case REQUEST_BAKREF: - ts_info("HW request bakref"); + ts_debug("HW request bakref"); break; case REQUEST_RESET: - ts_info("HW requset reset"); + ts_debug("HW requset reset"); r = goodix_hw_reset(dev); if (r != 0) - ts_info("request reset, reset failed"); + ts_debug("request reset, reset failed"); break; case REQUEST_RELOADFW: - ts_info("HW request reload fw"); + ts_debug("HW request reload fw"); goodix_do_fw_update(UPDATE_MODE_FORCE | UPDATE_MODE_SRC_REQUEST); break; case REQUEST_IDLE: - ts_info("HW request idle"); + ts_debug("HW request idle"); break; default: - ts_info("Unknown hw request:%d", buffer[0]); + ts_debug("Unknown hw request:%d", buffer[0]); break; } @@ -1378,7 +1378,7 @@ static void goodix_parse_finger_nor(struct goodix_ts_device *dev, for (i = 0; i < touch_num; i++) { id = coor_data[0]; if (id >= GOODIX_MAX_TOUCH) { - ts_info("invalid finger id =%d", id); + ts_debug("invalid finger id =%d", id); break; } x = le16_to_cpup((__be16 *)(coor_data + 1)); @@ -1438,7 +1438,7 @@ static void goodix_parse_finger_ys(struct goodix_ts_device *dev, for (i = 0; i < touch_num; i++) { id = (coor_data[0] >> 4) & 0x0F; if (id >= GOODIX_MAX_TOUCH) { - ts_info("invalid finger id =%d", id); + ts_debug("invalid finger id =%d", id); break; } x = be16_to_cpup((__be16 *)(coor_data + 2)); @@ -1525,7 +1525,7 @@ static void goodix_parse_pen_ys(struct goodix_ts_device *dev, struct goodix_pen_data *pen_data, unsigned char *buf, int touch_num) { - ts_info("unsupported"); + ts_debug("unsupported"); } static int goodix_touch_handler_ys(struct goodix_ts_device *dev, @@ -1741,7 +1741,7 @@ static int goodix_hw_suspend(struct goodix_ts_device *dev) if (sleep_cmd.initialized) { r = goodix_send_command(dev, &sleep_cmd); if (!r) - ts_info("Chip in sleep mode"); + ts_debug("Chip in sleep mode"); } else { ts_err("Uninitialized sleep command"); } @@ -1774,7 +1774,7 @@ static int goodix_esd_check(struct goodix_ts_device *dev) r = dev->hw_ops->read_trans(dev, TS_REG_ESD_TICK_R, &data, 1); if (r < 0 || (data == GOODIX_ESD_TICK_WRITE_DATA)) { - ts_info("dynamic esd occur, r:%d, data:0x%02x", r, data); + ts_debug("dynamic esd occur, r:%d, data:0x%02x", r, data); r = -EINVAL; goto exit; } @@ -1805,7 +1805,7 @@ static struct platform_device *goodix_pdev; static void goodix_pdev_release(struct device *dev) { - ts_info("goodix pdev released"); + ts_debug("goodix pdev released"); } static int goodix_i2c_probe(struct i2c_client *client) @@ -1813,7 +1813,7 @@ static int goodix_i2c_probe(struct i2c_client *client) struct goodix_ts_device *ts_device = NULL; int r = 0; - ts_info("goodix_i2c_probe IN"); + ts_debug("goodix_i2c_probe IN"); r = i2c_check_functionality(client->adapter, I2C_FUNC_I2C); if (!r) @@ -1830,7 +1830,7 @@ static int goodix_i2c_probe(struct i2c_client *client) r = goodix_parse_dt(client->dev.of_node, &ts_device->board_data); if (r < 0) { - ts_err("failed parse device info form dts, %d", r); + ts_err("failed parse device info from dts, %d", r); return -EINVAL; } } else { @@ -1871,7 +1871,7 @@ static int goodix_i2c_probe(struct i2c_client *client) ts_err("failed register platform driver, %d", r); goto err_pdriver; } - ts_info("i2c probe out"); + ts_debug("i2c probe out"); return r; err_pdriver: @@ -1879,7 +1879,7 @@ static int goodix_i2c_probe(struct i2c_client *client) err_pdev: kfree(goodix_pdev); goodix_pdev = NULL; - ts_info("i2c probe out, %d", r); + ts_debug("i2c probe out, %d", r); return r; } @@ -1941,14 +1941,14 @@ void goodix_ts_dev_release(void) static int __init goodix_i2c_init(void) { - ts_info("Goodix driver init"); + ts_debug("Goodix driver init"); return i2c_add_driver(&goodix_i2c_driver); } static void __exit goodix_i2c_exit(void) { i2c_del_driver(&goodix_i2c_driver); - ts_info("Goodix driver exit"); + ts_debug("Goodix driver exit"); } module_init(goodix_i2c_init); diff --git a/drivers/input/touchscreen/gtx8/goodix_ts_tools.c b/drivers/input/touchscreen/gtx8/goodix_ts_tools.c index 960944778283f7..f67a76c1ffb999 100644 --- a/drivers/input/touchscreen/gtx8/goodix_ts_tools.c +++ b/drivers/input/touchscreen/gtx8/goodix_ts_tools.c @@ -148,7 +148,7 @@ static int read_config_data(struct goodix_ts_device *ts_dev, void __user *arg) (i2c_msg_head[2] << 16) + (i2c_msg_head[3] << 24); length = i2c_msg_head[4] + (i2c_msg_head[5] << 8) + (i2c_msg_head[6] << 16) + (i2c_msg_head[7] << 24); - ts_info("read config,reg_addr=0x%x, length=%d", reg_addr, length); + ts_debug("read config,reg_addr=0x%x, length=%d", reg_addr, length); tmp_buf = kzalloc(length, GFP_KERNEL); if (!tmp_buf) { ts_err("failed alloc memory"); @@ -355,15 +355,15 @@ static long goodix_tools_ioctl(struct file *file, unsigned int cmd, mutex_lock(&dev->mutex); dev->ops_mode |= IRQ_FALG; mutex_unlock(&dev->mutex); - ts_info("IRQ enabled"); + ts_debug("IRQ enabled"); } else if (arg == 0) { goodix_ts_irq_enable(dev->ts_core, false); mutex_lock(&dev->mutex); dev->ops_mode &= ~IRQ_FALG; mutex_unlock(&dev->mutex); - ts_info("IRQ disabled"); + ts_debug("IRQ disabled"); } else { - ts_info("Irq already set with, arg = %ld", arg); + ts_debug("Irq already set with, arg = %ld", arg); } ret = 0; break; @@ -406,7 +406,7 @@ static long goodix_tools_ioctl(struct file *file, unsigned int cmd, ts_err("Failed send config"); ret = -EAGAIN; } else { - ts_info("Send config success"); + ts_debug("Send config success"); ret = 0; } } @@ -414,7 +414,7 @@ static long goodix_tools_ioctl(struct file *file, unsigned int cmd, case GTP_READ_CONFIG: ret = read_config_data(ts_dev, (void __user *)arg); if (ret > 0) - ts_info("success read config:len=%d", ret); + ts_debug("success read config:len=%d", ret); else ts_err("failed read config:ret=0x%x", ret); break; @@ -445,7 +445,7 @@ static long goodix_tools_ioctl(struct file *file, unsigned int cmd, ts_err("failed copy driver version info to user"); break; default: - ts_info("Invalid cmd"); + ts_debug("Invalid cmd"); ret = -ENOTTY; break; } @@ -475,11 +475,11 @@ static int goodix_tools_open(struct inode *inode, struct file *file) int ret = 0; file->private_data = goodix_tools_dev; - ts_info("tools open"); + ts_debug("tools open"); /* Only the first time open device need to register module */ ret = goodix_register_ext_module(&goodix_tools_dev->module); if (ret) { - ts_info("failed register to core module"); + ts_debug("failed register to core module"); } return ret; @@ -607,7 +607,7 @@ static void __exit goodix_tools_exit(void) { misc_deregister(&goodix_tools_miscdev); kfree(goodix_tools_dev); - ts_info("Goodix tools miscdev exit"); + ts_debug("Goodix tools miscdev exit"); } module_init(goodix_tools_init); From 483fd5fb17dc5bd41410f51497ba00e3d01e0e9b Mon Sep 17 00:00:00 2001 From: Jens Reidel Date: Sun, 20 Aug 2023 23:02:30 +0200 Subject: [PATCH 2/2] input: gtx8: Remove the firmware updater In the current state of the driver, and therefore also in the one published by goodix, the firmware is actually unused and the driver is functioning properly without it. We can therefore remove the firmware update code, since it won't be needed. Signed-off-by: Jens Reidel --- drivers/input/touchscreen/gtx8/Kconfig | 10 - drivers/input/touchscreen/gtx8/Makefile | 1 - .../touchscreen/gtx8/goodix_default_fw.h | 6 - .../touchscreen/gtx8/goodix_gtx8_update.c | 1596 ----------------- 4 files changed, 1613 deletions(-) delete mode 100644 drivers/input/touchscreen/gtx8/goodix_default_fw.h delete mode 100644 drivers/input/touchscreen/gtx8/goodix_gtx8_update.c diff --git a/drivers/input/touchscreen/gtx8/Kconfig b/drivers/input/touchscreen/gtx8/Kconfig index dbbb15756a06b4..732830ebbb92a8 100644 --- a/drivers/input/touchscreen/gtx8/Kconfig +++ b/drivers/input/touchscreen/gtx8/Kconfig @@ -13,16 +13,6 @@ menuconfig TOUCHSCREEN_GOODIX_GTX8 if TOUCHSCREEN_GOODIX_GTX8 -config TOUCHSCREEN_GOODIX_GTX8_UPDATE - tristate "Goodix GTx8 firmware update module" - default y - help - Say Y here to enable support for doing firmware update. - - If unsure, say N. - - To compile this driver as a module, choose M here. - config TOUCHSCREEN_GOODIX_GTX8_GESTURE tristate "Goodix GTx8 gesture wakeup feature" default n diff --git a/drivers/input/touchscreen/gtx8/Makefile b/drivers/input/touchscreen/gtx8/Makefile index fba44bdf85d3a6..ecee8457c0d51d 100644 --- a/drivers/input/touchscreen/gtx8/Makefile +++ b/drivers/input/touchscreen/gtx8/Makefile @@ -1,5 +1,4 @@ obj-$(CONFIG_TOUCHSCREEN_GOODIX_GTX8) += goodix_core.o goodix_core-y := goodix_ts_i2c.o goodix_ts_core.o goodix_cfg_bin.o -obj-$(CONFIG_TOUCHSCREEN_GOODIX_GTX8_UPDATE) += goodix_gtx8_update.o obj-$(CONFIG_TOUCHSCREEN_GOODIX_GTX8_GESTURE) += goodix_ts_gesture.o obj-$(CONFIG_TOUCHSCREEN_GOODIX_GTX8_TOOLS) += goodix_ts_tools.o diff --git a/drivers/input/touchscreen/gtx8/goodix_default_fw.h b/drivers/input/touchscreen/gtx8/goodix_default_fw.h deleted file mode 100644 index 00fd39d4b8404c..00000000000000 --- a/drivers/input/touchscreen/gtx8/goodix_default_fw.h +++ /dev/null @@ -1,6 +0,0 @@ -#ifndef _GOODIX_FIRMWARE_FW_H_ -#define _GOODIX_FIRMWARE_FW_H_ - -u8 goodix_default_fw[] = { 0x00 }; - -#endif diff --git a/drivers/input/touchscreen/gtx8/goodix_gtx8_update.c b/drivers/input/touchscreen/gtx8/goodix_gtx8_update.c deleted file mode 100644 index 83b33b2e2e8c33..00000000000000 --- a/drivers/input/touchscreen/gtx8/goodix_gtx8_update.c +++ /dev/null @@ -1,1596 +0,0 @@ -/* - * Goodix Firmware Update Driver. - * - * Copyright (C) 2019 - 2020 Goodix, Inc. - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be a reference - * to you, when you are integrating the GOODiX's CTP IC into your system, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * General Public License for more details. - */ -#include "goodix_ts_core.h" -#include "goodix_cfg_bin.h" -#include "goodix_default_fw.h" -/* COMMON PART - START */ -#define TS_DEFAULT_FIRMWARE "goodix_firmware.bin" - -#define FW_HEADER_SIZE 256 -#define FW_SUBSYS_INFO_SIZE 8 -#define FW_SUBSYS_INFO_OFFSET 32 -#define FW_SUBSYS_MAX_NUM 28 - -#define ISP_MAX_BUFFERSIZE (1024 * 4) - -#define HW_REG_CPU_CTRL 0x2180 -#define HW_REG_DSP_MCU_POWER 0x2010 -#define HW_REG_RESET 0x2184 -#define HW_REG_SCRAMBLE 0x2218 -#define HW_REG_BANK_SELECT 0x2048 -#define HW_REG_ACCESS_PATCH0 0x204D -#define HW_REG_EC_SRM_START 0x204F -#define HW_REG_GIO_YS 0x2014 -#define HW_REG_ESD_KEY_EN 0x2318 -#define HW_REG_ESD_KEY_DIS 0x2324 -#define HW_REG_CPU_RUN_FROM 0x4506 /* for nor_L is 0x4006 */ -#define HW_REG_CPU_RUN_FROM_YS 0x4000 -#define HW_REG_ISP_RUN_FLAG 0x6006 -#define HW_REG_ISP_ADDR 0xC000 -#define HW_REG_ISP_BUFFER 0x6100 -#define HW_REG_SUBSYS_TYPE 0x6020 -#define HW_REG_FLASH_FLAG 0x6022 -#define HW_REG_CACHE 0x204B -#define HW_REG_ESD_KEY 0x2318 -#define HW_REG_WTD_TIMER 0x20B0 - -#define FLASH_ADDR_CONFIG_DATA 0x1E000 -#define FLASH_SUBSYS_TYPE_CONFIG 0x03 - -#define CPU_CTRL_PENDING 0x00 -#define CPU_CTRL_RUNNING 0x01 - -#define ISP_STAT_IDLE 0xFF -#define ISP_STAT_READY 0xAA -#define ISP_STAT_WRITING 0xAA -#define ISP_FLASH_SUCCESS 0xBB -#define ISP_FLASH_ERROR 0xCC -#define ISP_FLASH_CHECK_ERROR 0xDD -#define ISP_CMD_PREPARE 0x55 -#define ISP_CMD_FLASH 0xAA - -#define TS_CHECK_ISP_STATE_RETRY_TIMES 200 -#define TS_READ_FLASH_STATE_RETRY_TIMES 200 - -/** - * fw_subsys_info - subsystem firmware information - * @type: subsystem type - * @size: firmware size - * @flash_addr: flash address - * @data: firmware data - */ -struct fw_subsys_info { - u8 type; - u32 size; - u16 flash_addr; - const u8 *data; -}; - -#pragma pack(1) -/** - * firmware_info - * @size: fw total length - * @checksum: checksum of fw - * @hw_pid: mask pid string - * @hw_pid: mask vid code - * @fw_pid: fw pid string - * @fw_vid: fw vid code - * @subsys_num: number of fw subsystem - * @chip_type: chip type - * @protocol_ver: firmware packing - * protocol version - * @subsys: subsystem info - */ -struct firmware_info { - u32 size; - u16 checksum; - u8 hw_pid[6]; - u8 hw_vid[3]; - u8 fw_pid[8]; - u8 fw_vid[4]; - u8 subsys_num; - u8 chip_type; - u8 protocol_ver; - u8 reserved[2]; - struct fw_subsys_info subsys[FW_SUBSYS_MAX_NUM]; -}; - -#pragma pack() - -/** - * firmware_data - firmware data structure - * @fw_info: firmware information - * @firmware: firmware data structure - */ -struct firmware_data { - struct firmware_info fw_info; - const struct firmware *firmware; -}; - -enum update_status { - UPSTA_NOTWORK = 0, - UPSTA_PREPARING, - UPSTA_UPDATING, - UPSTA_ABORT, - UPSTA_SUCCESS, - UPSTA_FAILED -}; - -/** - * fw_update_ctrl - structure used to control the - * firmware update process - * @initialized: struct init state - * @mode: indicate weather reflash config or not, fw data source, - * and run on block mode or not. - * @status: update status - * @progress: indicate the progress of update - * @allow_reset: control the reset callback - * @allow_irq: control the irq callback - * @allow_suspend: control the suspend callback - * @allow_resume: allow resume callback - * @fw_data: firmware data - * @ts_dev: touch device - * @fw_name: firmware name - * @attr_fwimage: sysfs bin attrs, for storing fw image - * @fw_data_src: firmware data source form sysfs, request or head file - */ -struct fw_update_ctrl { - struct mutex mutex; - int initialized; - int mode; - enum update_status status; - unsigned int progress; - - bool allow_reset; - bool allow_irq; - bool allow_suspend; - bool allow_resume; - - struct firmware_data fw_data; - struct goodix_ts_device *ts_dev; - struct goodix_ts_core *core_data; - - char fw_name[32]; - struct bin_attribute attr_fwimage; -}; -static struct fw_update_ctrl goodix_fw_update_ctrl; -/** - * goodix_parse_firmware - parse firmware header information - * and subsystem information from firmware data buffer - * - * @fw_data: firmware struct, contains firmware header info - * and firmware data. - * return: 0 - OK, < 0 - error - */ -static int goodix_parse_firmware(struct firmware_data *fw_data) -{ - const struct firmware *firmware; - struct firmware_info *fw_info; - unsigned int i, fw_offset, info_offset; - u16 checksum; - int r = 0; - - if (!fw_data || !fw_data->firmware) { - ts_err("Invalid firmware data"); - return -EINVAL; - } - fw_info = &fw_data->fw_info; - - /* copy firmware head info */ - firmware = fw_data->firmware; - if (firmware->size < FW_SUBSYS_INFO_OFFSET) { - ts_err("Invalid firmware size:%zu", firmware->size); - r = -EINVAL; - goto err_size; - } - memcpy(fw_info, firmware->data, FW_SUBSYS_INFO_OFFSET); - - /* check firmware size */ - fw_info->size = be32_to_cpu(fw_info->size); - if (firmware->size != fw_info->size + 6) { - ts_err("Bad firmware, size not match"); - r = -EINVAL; - goto err_size; - } - - /* calculate checksum, note: sum of bytes, but check - * by u16 checksum - */ - for (i = 6, checksum = 0; i < firmware->size; i++) - checksum += firmware->data[i]; - - /* byte order change, and check */ - fw_info->checksum = be16_to_cpu(fw_info->checksum); - if (checksum != fw_info->checksum) { - ts_err("Bad firmware, checksum error %x(file) != %x(cal)", - fw_info->checksum, checksum); - r = -EINVAL; - goto err_size; - } - - if (fw_info->subsys_num > FW_SUBSYS_MAX_NUM) { - ts_err("Bad firmware, invalid subsys num: %d", - fw_info->subsys_num); - r = -EINVAL; - goto err_size; - } - - /* parse subsystem info */ - fw_offset = FW_HEADER_SIZE; - for (i = 0; i < fw_info->subsys_num; i++) { - info_offset = FW_SUBSYS_INFO_OFFSET + i * FW_SUBSYS_INFO_SIZE; - - fw_info->subsys[i].type = firmware->data[info_offset]; - fw_info->subsys[i].size = be32_to_cpup( - (__be32 *)&firmware->data[info_offset + 1]); - fw_info->subsys[i].flash_addr = be16_to_cpup( - (__be16 *)&firmware->data[info_offset + 5]); - - if (fw_offset > firmware->size) { - ts_err("Sybsys offset exceed Firmware size"); - goto err_size; - } - - fw_info->subsys[i].data = firmware->data + fw_offset; - fw_offset += fw_info->subsys[i].size; - } - - ts_debug("Firmware package protocol: V%u", fw_info->protocol_ver); - ts_debug("Firmware PID:GT%s", fw_info->fw_pid); - ts_debug("Firmware VID:%02X%02X%02X%02x", fw_info->fw_vid[0], - fw_info->fw_vid[1], fw_info->fw_vid[2], fw_info->fw_vid[3]); - ts_debug("Firmware chip type:%02X", fw_info->chip_type); - ts_debug("Firmware size:%u", fw_info->size); - ts_debug("Firmware subsystem num:%u", fw_info->subsys_num); -#ifdef CONFIG_GOODIX_DEBUG - for (i = 0; i < fw_info->subsys_num; i++) { - ts_debug("------------------------------------------"); - ts_debug("Index:%d", i); - ts_debug("Subsystem type:%02X", fw_info->subsys[i].type); - ts_debug("Subsystem size:%u", fw_info->subsys[i].size); - ts_debug("Subsystem flash_addr:%08X", - fw_info->subsys[i].flash_addr); - ts_debug("Subsystem Ptr:%p", fw_info->subsys[i].data); - } - ts_debug("------------------------------------------"); -#endif - -err_size: - return r; -} - -/** - * goodix_check_update - compare the version of firmware running in - * touch device with the version getting from the firmware file. - * @fw_info: firmware information to be compared - * return: 0 no need do update, - * otherwise need do update - */ -static int goodix_check_update(struct goodix_ts_device *dev, - const struct firmware_info *fw_info) -{ - struct goodix_ts_version fw_ver; - int ret = -EINVAL; - - /* read version from chip, if we got invalid - * firmware version, maybe firmware in flash is - * incorrect, so we need to update firmware - */ - ret = dev->hw_ops->read_version(dev, &fw_ver); - if (ret) { - ts_debug("failed get active pid"); - return -EINVAL; - } - - if (fw_ver.valid) { - // should we compare PID before fw update? - // if fw patch demage the PID may unmatch but - // we should de update to recover it. - // TODO skip PID check - /*if (memcmp(fw_ver.pid, fw_info->fw_pid, dev->reg.pid_len)) { - ts_err("Product ID is not match %s != %s", - fw_ver.pid, fw_info->fw_pid); - return -EPERM; - }*/ - - ret = memcmp(fw_ver.vid, fw_info->fw_vid, dev->reg.vid_len); - if (ret == 0) { - ts_debug("FW version is equal to the IC's"); - return 0; - } else if (ret > 0) { - ts_debug("Warning: fw version is lower the IC's"); - } - } /* else invalid firmware, update firmware */ - - ts_debug("Firmware needs to be updated"); - return ret; -} - -/** - * goodix_reg_write_confirm - write register and confirm the value - * in the register. - * @dev: pointer to touch device - * @addr: register address - * @data: pointer to data buffer - * @len: data length - * return: 0 write success and confirm ok - * < 0 failed - */ -static int goodix_reg_write_confirm(struct goodix_ts_device *dev, - unsigned int addr, unsigned char *data, - unsigned int len) -{ - u8 *cfm, cfm_buf[32]; - int r, i; - - if (len > sizeof(cfm_buf)) { - cfm = kzalloc(len, GFP_KERNEL); - if (!cfm) { - ts_err("Mem alloc failed"); - return -ENOMEM; - } - } else { - cfm = &cfm_buf[0]; - } - - for (i = 0; i < GOODIX_BUS_RETRY_TIMES; i++) { - r = dev->hw_ops->write_trans(dev, addr, data, len); - if (r < 0) - goto exit; - - r = dev->hw_ops->read_trans(dev, addr, cfm, len); - if (r < 0) - goto exit; - - if (memcmp(data, cfm, len)) { - ts_debug("data[0]:0x%02x, data[1]:0x%02x," - "read cfm[0]:0x%02x, cfm[1]:0x%02x", - data[0], data[1], cfm[0], cfm[1]); - dev->hw_ops->read_trans(dev, 0x6022, cfm, 2); - ts_debug("read 0x6022 data[0]:0x%02x, data[1]:0x%02x", - cfm[0], cfm[1]); - r = -EMEMCMP; - continue; - } else { - r = 0; - break; - } - } - -exit: - if (cfm != &cfm_buf[0]) - kfree(cfm); - return r; -} - -static inline int goodix_reg_write(struct goodix_ts_device *dev, - unsigned int addr, unsigned char *data, - unsigned int len) -{ - return dev->hw_ops->write_trans(dev, addr, data, len); -} - -static inline int goodix_reg_read(struct goodix_ts_device *dev, - unsigned int addr, unsigned char *data, - unsigned int len) -{ - return dev->hw_ops->read_trans(dev, addr, data, len); -} - -/** - * goodix_load_isp - load ISP program to device ram - * @dev: pointer to touch device - * @fw_data: firmware data - * return 0 ok, <0 error - */ -static int goodix_load_isp(struct goodix_ts_device *ts_dev, - struct firmware_data *fw_data) -{ - struct fw_subsys_info *fw_isp; - u8 reg_val[8] = { 0x00 }; - int r; - int i; - - fw_isp = &fw_data->fw_info.subsys[0]; - - ts_debug("Loading ISP start"); - reg_val[0] = 0x00; - r = goodix_reg_write(ts_dev, HW_REG_BANK_SELECT, reg_val, 1); - if (r < 0) { - ts_err("Failed to select bank0"); - return r; - } - ts_debug("Success select bank0, Set 0x%x -->0x00", HW_REG_BANK_SELECT); - - reg_val[0] = 0x01; - r = goodix_reg_write(ts_dev, HW_REG_ACCESS_PATCH0, reg_val, 1); - if (r < 0) { - ts_err("Failed to enable patch0 access"); - return r; - } - ts_debug("Success select bank0, Set 0x%x -->0x01", - HW_REG_ACCESS_PATCH0); - - r = goodix_reg_write_confirm(ts_dev, HW_REG_ISP_ADDR, - (u8 *)fw_isp->data, fw_isp->size); - if (r < 0) { - ts_err("Loading ISP error"); - return r; - } - - ts_debug("Success send ISP data to IC"); - - reg_val[0] = 0x00; - r = goodix_reg_write_confirm(ts_dev, HW_REG_ACCESS_PATCH0, reg_val, 1); - if (r < 0) { - ts_err("Failed to disable patch0 access"); - return r; - } - ts_debug("Success forbid bank0 accedd, set 0x%x -->0x00", - HW_REG_ACCESS_PATCH0); - - reg_val[0] = 0x00; - reg_val[1] = 0x00; - r = goodix_reg_write(ts_dev, HW_REG_ISP_RUN_FLAG, reg_val, 2); - if (r < 0) { - ts_err("Failed to clear 0x%x", HW_REG_ISP_RUN_FLAG); - return r; - } - ts_debug("Success clear 0x%x", HW_REG_ISP_RUN_FLAG); - - memset(reg_val, 0x55, 8); - if (ts_dev->ic_type == IC_TYPE_YELLOWSTONE) - r = goodix_reg_write(ts_dev, HW_REG_CPU_RUN_FROM_YS, reg_val, - 8); - else - r = goodix_reg_write(ts_dev, HW_REG_CPU_RUN_FROM, reg_val, 8); - if (r < 0) { - ts_err("Failed set HW_REG_CPU_RUN_FROM flag"); - return r; - } - ts_debug("Success write [8]0x55 to HW_REG_CPU_RUN_FROM"); - - reg_val[0] = 0x00; - r = goodix_reg_write(ts_dev, HW_REG_CPU_CTRL, reg_val, 1); - if (r < 0) { - ts_err("Failed to run isp"); - return r; - } - ts_debug("Success run isp, set 0x%x-->0x00", HW_REG_CPU_CTRL); - - /* check isp work state */ - for (i = 0; i < TS_CHECK_ISP_STATE_RETRY_TIMES; i++) { - msleep(10); - r = goodix_reg_read(ts_dev, HW_REG_ISP_RUN_FLAG, reg_val, 2); - if (r < 0 || (reg_val[0] == 0xAA && reg_val[1] == 0xBB)) - break; - } - if (reg_val[0] == 0xAA && reg_val[1] == 0xBB) { - ts_debug("ISP working OK"); - return 0; - } - ts_err("ISP not work,0x%x=0x%x, 0x%x=0x%x", HW_REG_ISP_RUN_FLAG, - reg_val[0], HW_REG_ISP_RUN_FLAG + 1, reg_val[1]); - return -EFAULT; -} - -/** - * goodix_update_prepare - update prepare, loading ISP program - * and make sure the ISP is running. - * @fwu_ctrl: pointer to firmware control structure - * return: 0 ok, <0 error - */ -static int goodix_update_prepare(struct fw_update_ctrl *fwu_ctrl) -{ - struct goodix_ts_device *ts_dev = fwu_ctrl->ts_dev; - u8 reg_val[4] = { 0x00 }; - u8 temp_buf[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; - int retry = 20; - int r; - - if (ts_dev->ic_type == IC_TYPE_YELLOWSTONE) - ts_dev->hw_ops->write(ts_dev, HW_REG_CPU_RUN_FROM_YS, temp_buf, - 8); - else - ts_dev->hw_ops->write(ts_dev, HW_REG_CPU_RUN_FROM, temp_buf, 8); - - /*reset IC*/ - fwu_ctrl->allow_reset = true; - ts_debug("firmware update, reset"); - gpio_direction_output(ts_dev->board_data.reset_gpio, 0); - udelay(2000); - gpio_direction_output(ts_dev->board_data.reset_gpio, 1); - usleep_range(10000, 11000); - fwu_ctrl->allow_reset = false; - - retry = 100; - do { - if (ts_dev->ic_type != IC_TYPE_YELLOWSTONE) - break; - reg_val[0] = 0x00; - r = goodix_reg_write_confirm(ts_dev, HW_REG_GIO_YS, reg_val, 1); - if (r < 0) - ts_debug("Failed to remove GIO hold flag, retry %d", - retry); - else - break; - } while (--retry); - if (!retry) { - ts_err("Failed to remove GIO flag"); - return -EINVAL; - } - - retry = 20; - for (retry = 0; retry < 20; retry++) { - if (ts_dev->ic_type == IC_TYPE_YELLOWSTONE) { - reg_val[0] = 0x00; - r = goodix_reg_write(ts_dev, HW_REG_ESD_KEY_DIS, - reg_val, 1); - if (r < 0) { - ts_debug("failed dis esd key"); - continue; - } - reg_val[0] = 0x95; - r = goodix_reg_write(ts_dev, HW_REG_ESD_KEY_EN, reg_val, - 1); - if (r < 0) { - ts_debug("failed open esd key"); - continue; - } - } - reg_val[0] = 0x24; - r = goodix_reg_write_confirm(ts_dev, HW_REG_CPU_CTRL, reg_val, - 1); - if (r < 0) { - ts_debug("Failed to hold ss51, retry"); - msleep(20); - } else { - break; - } - } - if (retry >= 20) { - ts_err("Failed hold ss51,return =%d", r); - return -EINVAL; - } - ts_debug("Success hold ss51"); - - /* enable DSP & MCU power */ - reg_val[0] = 0x00; - r = goodix_reg_write_confirm(ts_dev, HW_REG_DSP_MCU_POWER, reg_val, 1); - if (r < 0) { - ts_err("Failed enable DSP&MCU power"); - return r; - } - ts_debug("Success enabled DSP&MCU power,set 0x%x-->0x00", - HW_REG_DSP_MCU_POWER); - - /* disable watchdog timer */ - reg_val[0] = 0x00; - r = goodix_reg_write(ts_dev, HW_REG_CACHE, reg_val, 1); - if (r < 0) { - ts_err("Failed to clear cache"); - return r; - } - ts_debug("Success clear cache"); - - if (ts_dev->ic_type == IC_TYPE_YELLOWSTONE) { - reg_val[0] = 0x00; - r = goodix_reg_write(ts_dev, HW_REG_WTD_TIMER, reg_val, 1); - } else { - reg_val[0] = 0x95; - r = goodix_reg_write(ts_dev, HW_REG_ESD_KEY, reg_val, 1); - reg_val[0] = 0x00; - r |= goodix_reg_write(ts_dev, HW_REG_WTD_TIMER, reg_val, 1); - - reg_val[0] = 0x27; - r |= goodix_reg_write(ts_dev, HW_REG_ESD_KEY, reg_val, 1); - } - if (r < 0) { - ts_err("Failed to disable watchdog"); - return r; - } - ts_debug("Success disable watchdog"); - - /* set scramble */ - reg_val[0] = 0x00; - r = goodix_reg_write(ts_dev, HW_REG_SCRAMBLE, reg_val, 1); - if (r < 0) { - ts_err("Failed to set scramble"); - return r; - } - ts_debug("Success set scramble"); - - /* load ISP code and run form isp */ - r = goodix_load_isp(ts_dev, &fwu_ctrl->fw_data); - if (r < 0) - ts_err("Failed lode and run isp"); - - return r; -} - -/** - * goodix_format_fw_packet - format one flash packet - * @pkt: target firmware packet - * @flash_addr: flash address - * @size: packet size - * @data: packet data - */ -static int goodix_format_fw_packet(u8 *pkt, u32 flash_addr, u16 len, - const u8 *data) -{ - u16 checksum; - - if (!pkt || !data) - return -EINVAL; - - /* - * checksum rule:sum of data in one format is equal to zero - * data format: byte/le16/be16/le32/be32/le64/be64 - */ - pkt[0] = (len >> 8) & 0xff; - pkt[1] = len & 0xff; - /* u16 >> 16bit seems nosense but really important */ - pkt[2] = (flash_addr >> 16) & 0xff; - pkt[3] = (flash_addr >> 8) & 0xff; - memcpy(&pkt[4], data, len); - checksum = checksum_be16(pkt, len + 4); - checksum = 0 - checksum; - pkt[len + 4] = (checksum >> 8) & 0xff; - pkt[len + 5] = checksum & 0xff; - return 0; -} - -/** - * goodix_send_fw_packet - send one firmware packet to ISP - * @dev: target touch device - * @pkt: firmware packet - * return：0 ok, <0 error - */ -static int goodix_send_fw_packet(struct goodix_ts_device *dev, u8 type, u8 *pkt, - u32 len) -{ - u8 reg_val[4]; - int r, i; - - if (!pkt) - return -EINVAL; - - ts_debug("target fw subsys type:0x%x, len %d", type, len); - r = goodix_reg_write_confirm(dev, HW_REG_ISP_BUFFER, pkt, len); - if (r < 0) { - ts_err("Failed to write firmware packet"); - return r; - } - - reg_val[0] = 0; - reg_val[1] = 0; - /* clear flash flag 0X6022 */ - r = goodix_reg_write_confirm(dev, HW_REG_FLASH_FLAG, reg_val, 2); - if (r < 0) { - ts_err("Failed to clear flash flag"); - return r; - } - - /* write subsystem type 0X8020*/ - reg_val[0] = type; - reg_val[1] = type; - r = goodix_reg_write_confirm(dev, HW_REG_SUBSYS_TYPE, reg_val, 2); - if (r < 0) { - ts_err("Failed write subsystem type to IC"); - return r; - } - - for (i = 0; i < TS_READ_FLASH_STATE_RETRY_TIMES; i++) { - r = goodix_reg_read(dev, HW_REG_FLASH_FLAG, reg_val, 2); - if (r < 0) { - ts_err("Failed read flash state"); - return r; - } - - /* flash haven't end */ - if (reg_val[0] == ISP_STAT_WRITING && - reg_val[1] == ISP_STAT_WRITING) { - ts_debug("Flash not ending..."); - usleep_range(55000, 56000); - continue; - } - if (reg_val[0] == ISP_FLASH_SUCCESS && - reg_val[1] == ISP_FLASH_SUCCESS) { - r = goodix_reg_read(dev, HW_REG_FLASH_FLAG, reg_val, 2); - if (!r && reg_val[0] == ISP_FLASH_SUCCESS && - reg_val[1] == ISP_FLASH_SUCCESS) { - ts_debug("Flash subsystem ok"); - return 0; - } - } - if (reg_val[0] == ISP_FLASH_ERROR && - reg_val[1] == ISP_FLASH_ERROR) { - ts_err(" Flash subsystem failed"); - return -EAGAIN; - } - if (reg_val[0] == ISP_FLASH_CHECK_ERROR) { - ts_err("Subsystem checksum err"); - return -EAGAIN; - } - - usleep_range(250, 260); - } - - ts_err("Wait for flash end timeout, 0x6022= %x %x", reg_val[0], - reg_val[1]); - return -EAGAIN; -} - -/** - * goodix_flash_subsystem - flash subsystem firmware, - * Main flow of flashing firmware. - * Each firmware subsystem is divided into several - * packets, the max size of packet is limited to - * @{ISP_MAX_BUFFERSIZE} - * @dev: pointer to touch device - * @subsys: subsystem information - * return: 0 ok, < 0 error - */ -static int goodix_flash_subsystem(struct goodix_ts_device *dev, - struct fw_subsys_info *subsys) -{ - u16 data_size, offset; - u32 total_size; - u32 subsys_base_addr = subsys->flash_addr << 8; - u8 *fw_packet; - int r = 0, i; - - /* - * if bus(i2c/spi) error occued, then exit, we will do - * hardware reset and re-prepare ISP and then retry - * flashing - */ - total_size = subsys->size; - fw_packet = kzalloc(ISP_MAX_BUFFERSIZE + 6, GFP_KERNEL); - if (!fw_packet) { - ts_err("Failed alloc memory"); - return -EINVAL; - } - - offset = 0; - while (total_size > 0) { - data_size = total_size > ISP_MAX_BUFFERSIZE ? - ISP_MAX_BUFFERSIZE : - total_size; - ts_debug("Flash firmware to %08x,size:%u bytes", - subsys_base_addr + offset, data_size); - - /* format one firmware packet */ - r = goodix_format_fw_packet(fw_packet, - subsys_base_addr + offset, - data_size, &subsys->data[offset]); - if (r < 0) { - ts_err("Invalid packet params"); - goto exit; - } - - /* send one firmware packet, retry 3 time if send failed */ - for (i = 0; i < 3; i++) { - r = goodix_send_fw_packet(dev, subsys->type, fw_packet, - data_size + 6); - if (!r) - break; - } - if (r) { - ts_err("Failed flash subsystem"); - goto exit; - } - offset += data_size; - total_size -= data_size; - } /* end while */ - -exit: - kfree(fw_packet); - return r; -} - -/** - * goodix_flash_firmware - flash firmware - * @dev: pointer to touch device - * @fw_data: firmware data - * return: 0 ok, < 0 error - */ -static int goodix_flash_firmware(struct goodix_ts_device *dev, - struct firmware_data *fw_data) -{ - struct fw_update_ctrl *fw_ctrl; - struct firmware_info *fw_info; - struct fw_subsys_info *fw_x; - int retry = GOODIX_BUS_RETRY_TIMES; - int i, r = 0, fw_num, prog_step; - u8 *fw_packet = NULL; - u8 *flash_cfg = NULL; - - /* start from subsystem 1, - * subsystem 0 is the ISP program - */ - fw_ctrl = container_of(fw_data, struct fw_update_ctrl, fw_data); - fw_info = &fw_data->fw_info; - fw_num = fw_info->subsys_num; - - /* we have 80% work here */ - prog_step = 80 / (fw_num - 1); - - for (i = 1; i < fw_num && retry;) { - ts_debug("--- Start to flash subsystem[%d] ---", i); - fw_x = &fw_info->subsys[i]; - r = goodix_flash_subsystem(dev, fw_x); - if (r == 0) { - ts_debug("--- End flash subsystem[%d]: OK ---", i); - fw_ctrl->progress += prog_step; - i++; - } else if (r == -EAGAIN) { - retry--; - ts_err("--- End flash subsystem%d: Fail, errno:%d, retry:%d ---", - i, r, GOODIX_BUS_RETRY_TIMES - retry); - } else if (r < 0) { /* bus error */ - ts_err("--- End flash subsystem%d: Fatal error:%d exit ---", - i, r); - break; - } - } - - kfree(fw_packet); - fw_packet = NULL; - kfree(flash_cfg); - flash_cfg = NULL; - return r; -} - -/** - * goodix_update_finish - update finished, free resource - * and reset flags--- - * @fwu_ctrl: pointer to fw_update_ctrl structure - * return: 0 ok, < 0 error - */ -static int goodix_update_finish(struct goodix_ts_device *ts_dev, - struct fw_update_ctrl *fwu_ctrl) -{ - u8 reg_val[8] = { 0 }; - int r = 0, i = 0; - - /* hold ss51 */ - reg_val[0] = 0x24; - r = goodix_reg_write(ts_dev, HW_REG_CPU_CTRL, reg_val, 1); - if (r < 0) - ts_err("Failed to hold ss51"); - - /* clear recovery flag */ - memset(reg_val, 0, sizeof(reg_val)); - if (ts_dev->ic_type == IC_TYPE_YELLOWSTONE) - r = goodix_reg_write(ts_dev, HW_REG_CPU_RUN_FROM_YS, reg_val, - 8); - else - r = goodix_reg_write(ts_dev, HW_REG_CPU_RUN_FROM, reg_val, 8); - if (r) { - ts_err("Failed set CPU run from normal firmware"); - return r; - } - - /* release ss51 */ - reg_val[0] = 0x00; - r = goodix_reg_write(ts_dev, HW_REG_CPU_CTRL, reg_val, 1); - if (r < 0) - ts_err("Failed to run ss51"); - - /*reset*/ - gpio_direction_output(ts_dev->board_data.reset_gpio, 0); - udelay(2000); - gpio_direction_output(ts_dev->board_data.reset_gpio, 1); - msleep(80); - - for (i = 0; ts_dev->ic_type == IC_TYPE_YELLOWSTONE && i < 100; i++) { - reg_val[0] = 0x00; - r = goodix_reg_write_confirm(ts_dev, HW_REG_GIO_YS, reg_val, 1); - if (!r) - break; - ts_debug("failed set GIO flag, r %d", r); - } - if (i >= 100) - ts_err("failed set GIO flag, %d", r); - - return r; -} - -static int goodix_flash_config(struct goodix_ts_device *ts_dev) -{ - int ret; - u8 *fw_packet = NULL; - u8 *temp_data = NULL; - - if (!ts_dev || !ts_dev->cfg_bin_state || - !ts_dev->normal_cfg.initialized) { - ts_err("no valid config data for flash"); - return -EINVAL; - } - - temp_data = kzalloc(ISP_MAX_BUFFERSIZE, GFP_KERNEL); - fw_packet = kzalloc(ISP_MAX_BUFFERSIZE + 6, GFP_KERNEL); - if (!temp_data || !fw_packet) { - ts_err("Failed alloc memory"); - ret = -EINVAL; - goto exit; - } - - memset(temp_data, 0xFF, ISP_MAX_BUFFERSIZE); - ts_debug("normal config length %d", ts_dev->normal_cfg.length); - memcpy(temp_data, ts_dev->normal_cfg.data, ts_dev->normal_cfg.length); - - /* format one firmware packet */ - ret = goodix_format_fw_packet(fw_packet, FLASH_ADDR_CONFIG_DATA, - ISP_MAX_BUFFERSIZE, temp_data); - if (ret < 0) { - ts_err("Invalid packet params"); - goto exit; - } - ts_debug("fw_pack:%*ph", 10, fw_packet); - ts_debug("try flash config"); - ret = goodix_send_fw_packet(ts_dev, FLASH_SUBSYS_TYPE_CONFIG, fw_packet, - ISP_MAX_BUFFERSIZE + 6); - if (ret) - ts_err("failed flash config, ret %d", ret); - else - ts_debug("success flash config with isp"); - -exit: - kfree(temp_data); - kfree(fw_packet); - return ret; -} - -/** - * goodix_fw_update_proc - firmware update process, the entry of - * firmware update flow - * @fwu_ctrl: firmware control - * return: 0 ok, < 0 error - */ -static int goodix_fw_update_proc(struct fw_update_ctrl *fwu_ctrl) -{ -#define FW_UPDATE_RETRY 2 - int retry0 = FW_UPDATE_RETRY; - int retry1 = FW_UPDATE_RETRY; - int r = 0; - - if (fwu_ctrl->status == UPSTA_PREPARING || - fwu_ctrl->status == UPSTA_UPDATING) { - ts_err("Firmware update already in progress"); - return -EINVAL; - } - - fwu_ctrl->progress = 0; - fwu_ctrl->status = UPSTA_PREPARING; - - r = goodix_parse_firmware(&fwu_ctrl->fw_data); - if (r < 0) { - fwu_ctrl->status = UPSTA_ABORT; - goto err_parse_fw; - } - - fwu_ctrl->progress = 10; - if (!(fwu_ctrl->mode & UPDATE_MODE_FORCE)) { - r = goodix_check_update(fwu_ctrl->ts_dev, - &fwu_ctrl->fw_data.fw_info); - if (!r) { - fwu_ctrl->status = UPSTA_ABORT; - ts_debug("fw update skipped"); - goto err_check_update; - } - } else { - ts_debug("force update mode"); - } - -start_update: - fwu_ctrl->progress = 20; - fwu_ctrl->status = UPSTA_UPDATING; /* show upgrading status */ - r = goodix_update_prepare(fwu_ctrl); - if ((r == -EBUS || r == -EAGAIN) && --retry0 > 0) { - ts_err("Bus error, retry prepare ISP:%d", - FW_UPDATE_RETRY - retry0); - goto start_update; - } else if (r < 0) { - ts_err("Failed to prepare ISP, exit update:%d", r); - fwu_ctrl->status = UPSTA_FAILED; - goto err_fw_prepare; - } - - if (GOODIX_FLASH_CONFIG_WITH_ISP && - fwu_ctrl->mode & UPDATE_MODE_FLASH_CFG) { - ts_debug("need flash config with isp"); - goodix_flash_config(fwu_ctrl->ts_dev); - } - - /* progress: 20%~100% */ - r = goodix_flash_firmware(fwu_ctrl->ts_dev, &fwu_ctrl->fw_data); - if ((r == -EBUS || r == -ETIMEOUT) && --retry1 > 0) { - /* we will retry[twice] if returns bus error[i2c/spi] - * we will do hardware reset and re-prepare ISP and then retry - * flashing - */ - ts_err("Bus error, retry firmware update:%d", - FW_UPDATE_RETRY - retry1); - goto start_update; - } else if (r < 0) { - ts_err("Fatal error, exit update:%d", r); - fwu_ctrl->status = UPSTA_FAILED; - goto err_fw_flash; - } - - fwu_ctrl->status = UPSTA_SUCCESS; - -err_fw_flash: -err_fw_prepare: - goodix_update_finish(fwu_ctrl->ts_dev, fwu_ctrl); -err_check_update: -err_parse_fw: - if (fwu_ctrl->status == UPSTA_SUCCESS) - ts_debug("Firmware update successfully"); - else if (fwu_ctrl->status == UPSTA_FAILED) - ts_err("Firmware update failed"); - - fwu_ctrl->progress = 100; /* 100% */ - ts_debug("fw update ret %d", r); - return r; -} - -static struct goodix_ext_module goodix_fwu_module; - -/** - * goodix_request_firmware - request firmware data from user space - * - * @fw_data: firmware struct, contains firmware header info - * and firmware data pointer. - * return: 0 - OK, < 0 - error - */ -static int goodix_request_firmware(struct firmware_data *fw_data, - const char *name) -{ - struct fw_update_ctrl *fw_ctrl = - container_of(fw_data, struct fw_update_ctrl, fw_data); - struct device *dev = fw_ctrl->ts_dev->dev; - int r; - - ts_debug("Request firmware image [%s]", name); - r = request_firmware(&fw_data->firmware, name, dev); - if (r < 0) - ts_err("Firmware image [%s] not available,errno:%d", name, r); - else - ts_debug("Firmware image [%s] is ready", name); - return r; -} - -/** - * release firmware resources - * - */ -static inline void goodix_release_firmware(struct firmware_data *fw_data) -{ - if (fw_data->firmware) { - release_firmware(fw_data->firmware); - fw_data->firmware = NULL; - } -} - -static int goodix_fw_update_thread(void *data) -{ - struct fw_update_ctrl *fwu_ctrl = data; - struct firmware *temp_firmware = NULL; - int r = -EINVAL; - - mutex_lock(&fwu_ctrl->mutex); - - if (fwu_ctrl->mode & UPDATE_MODE_SRC_HEAD) { - ts_debug("Firmware header update starts"); - temp_firmware = kzalloc(sizeof(struct firmware), GFP_KERNEL); - if (!temp_firmware) { - ts_err("Failed to allocate memory for firmware"); - goto out; - } - temp_firmware->size = sizeof(goodix_default_fw); - temp_firmware->data = goodix_default_fw; - fwu_ctrl->fw_data.firmware = temp_firmware; - } else if (fwu_ctrl->mode & UPDATE_MODE_SRC_REQUEST) { - ts_debug("Firmware request update starts"); - r = goodix_request_firmware(&fwu_ctrl->fw_data, - fwu_ctrl->fw_name); - if (r < 0) { - fwu_ctrl->status = UPSTA_ABORT; - fwu_ctrl->progress = 100; - goto out; - } - } else if (fwu_ctrl->mode & UPDATE_MODE_SRC_SYSFS) { - if (!fwu_ctrl->fw_data.firmware) { - ts_err("Invalid firmware from sysfs"); - fwu_ctrl->status = UPSTA_ABORT; - fwu_ctrl->progress = 100; - r = -EINVAL; - goto out; - } - } else { - ts_err("unknown update mode 0x%x", fwu_ctrl->mode); - r = -EINVAL; - goto out; - } - - goodix_register_ext_module(&goodix_fwu_module); - /* DONT allow reset/irq/suspend/resume during update */ - fwu_ctrl->allow_irq = false; - fwu_ctrl->allow_suspend = false; - fwu_ctrl->allow_resume = false; - fwu_ctrl->allow_reset = false; - ts_debug("notify update start"); - goodix_ts_blocking_notify(NOTIFY_FWUPDATE_START, NULL); - - /* ready to update */ - ts_debug("start update proc"); - r = goodix_fw_update_proc(fwu_ctrl); - - fwu_ctrl->allow_reset = true; - fwu_ctrl->allow_irq = true; - fwu_ctrl->allow_suspend = true; - fwu_ctrl->allow_resume = true; - - /* clean */ - if (fwu_ctrl->mode & UPDATE_MODE_SRC_HEAD) { - kfree(fwu_ctrl->fw_data.firmware); - fwu_ctrl->fw_data.firmware = NULL; - temp_firmware = NULL; - } else if (fwu_ctrl->mode & UPDATE_MODE_SRC_REQUEST) { - goodix_release_firmware(&fwu_ctrl->fw_data); - } else if (fwu_ctrl->mode & UPDATE_MODE_SRC_SYSFS) { - vfree(fwu_ctrl->fw_data.firmware); - fwu_ctrl->fw_data.firmware = NULL; - } - goodix_unregister_ext_module(&goodix_fwu_module); -out: - fwu_ctrl->mode = UPDATE_MODE_DEFAULT; - mutex_unlock(&fwu_ctrl->mutex); - - if (r) { - ts_err("fw update failed, %d", r); - goodix_ts_blocking_notify(NOTIFY_FWUPDATE_FAILED, NULL); - } else { - ts_debug("fw update success"); - goodix_ts_blocking_notify(NOTIFY_FWUPDATE_SUCCESS, NULL); - } - return r; -} - -/* - * goodix_sysfs_update_en_store: start fw update manually - * @buf: '1'[001] update in blocking mode with fwdata from sysfs - * '2'[010] update in blocking mode with fwdata from request - * '5'[101] update in unblocking mode with fwdata from sysfs - * '6'[110] update in unblocking mode with fwdata from request - */ -static ssize_t goodix_sysfs_update_en_store(struct goodix_ext_module *module, - const char *buf, size_t count) -{ - int ret = 0; - int mode = 0; - struct fw_update_ctrl *fw_ctrl = module->priv_data; - - if (!buf || count <= 0) { - ts_err("invalid params"); - return -EINVAL; - } - if (!fw_ctrl || !fw_ctrl->initialized) { - ts_err("fw module uninit"); - return -EINVAL; - } - - ts_debug("set update mode:0x%x", buf[0]); - if (buf[0] == '1') { - mode = UPDATE_MODE_FORCE | UPDATE_MODE_BLOCK | - UPDATE_MODE_SRC_SYSFS; - } else if (buf[0] == '2') { - mode = UPDATE_MODE_FORCE | UPDATE_MODE_BLOCK | - UPDATE_MODE_SRC_REQUEST; - } else if (buf[0] == '5') { - mode = UPDATE_MODE_FORCE | UPDATE_MODE_SRC_SYSFS; - } else if (buf[0] == '6') { - mode = UPDATE_MODE_FORCE | UPDATE_MODE_SRC_REQUEST; - } else { - ts_err("invalid update mode:0x%x", buf[0]); - return -EINVAL; - } - - ret = goodix_do_fw_update(mode); - if (!ret) { - ts_debug("success start update work"); - return count; - } - ts_err("failed start fw update work"); - return -EINVAL; -} - -static ssize_t -goodix_sysfs_update_progress_show(struct goodix_ext_module *module, char *buf) -{ - struct fw_update_ctrl *fw_ctrl = module->priv_data; - return scnprintf(buf, PAGE_SIZE, "%d\n", fw_ctrl->progress); -} - -static ssize_t goodix_sysfs_update_result_show(struct goodix_ext_module *module, - char *buf) -{ - char *result = NULL; - struct fw_update_ctrl *fw_ctrl = module->priv_data; - - ts_debug("result show"); - switch (fw_ctrl->status) { - case UPSTA_NOTWORK: - result = "notwork"; - break; - case UPSTA_PREPARING: - result = "preparing"; - break; - case UPSTA_UPDATING: - result = "upgrading"; - break; - case UPSTA_ABORT: - result = "abort"; - break; - case UPSTA_SUCCESS: - result = "success"; - break; - case UPSTA_FAILED: - result = "failed"; - break; - default: - break; - } - - return scnprintf(buf, PAGE_SIZE, "%s\n", result); -} - -static ssize_t -goodix_sysfs_update_fwversion_show(struct goodix_ext_module *module, char *buf) -{ - struct goodix_ts_version fw_ver; - struct fw_update_ctrl *fw_ctrl = module->priv_data; - int r = 0; - char str[5]; - - /* read version from chip */ - r = fw_ctrl->ts_dev->hw_ops->read_version(fw_ctrl->ts_dev, &fw_ver); - if (!r) { - memcpy(str, fw_ver.pid, 4); - str[4] = '\0'; - return scnprintf( - buf, PAGE_SIZE, - "PID:%s VID:%02x %02x %02x %02x SENSOR_ID:%d\n", str, - fw_ver.vid[0], fw_ver.vid[1], fw_ver.vid[2], - fw_ver.vid[3], fw_ver.sensor_id); - } - return 0; -} - -static ssize_t goodix_sysfs_fwsize_show(struct goodix_ext_module *module, - char *buf) -{ - struct fw_update_ctrl *fw_ctrl = module->priv_data; - int r = -EINVAL; - - if (fw_ctrl && fw_ctrl->fw_data.firmware) - r = snprintf(buf, PAGE_SIZE, "%zu\n", - fw_ctrl->fw_data.firmware->size); - return r; -} - -static ssize_t goodix_sysfs_fwsize_store(struct goodix_ext_module *module, - const char *buf, size_t count) -{ - struct fw_update_ctrl *fw_ctrl = module->priv_data; - struct firmware *fw; - u8 **data; - size_t size = 0; - - if (!fw_ctrl) - return -EINVAL; - - if (sscanf(buf, "%zu", &size) < 0 || !size) { - ts_err("Failed to get fwsize"); - return -EFAULT; - } - - /* use vmalloc to alloc huge memory */ - fw = vmalloc(sizeof(*fw) + size); - if (fw == NULL) { - ts_err("Failed to alloc memory,size:%zu", size + sizeof(*fw)); - return -ENOMEM; - } - mutex_lock(&fw_ctrl->mutex); - memset(fw, 0x00, sizeof(*fw) + size); - data = (u8 **)&fw->data; - *data = (u8 *)fw + sizeof(struct firmware); - fw->size = size; - fw_ctrl->fw_data.firmware = fw; - fw_ctrl->mode = UPDATE_MODE_SRC_SYSFS; - mutex_unlock(&fw_ctrl->mutex); - return count; -} - -static ssize_t goodix_sysfs_fwimage_store(struct file *file, - struct kobject *kobj, - struct bin_attribute *attr, char *buf, - loff_t pos, size_t count) -{ - struct fw_update_ctrl *fw_ctrl; - struct firmware_data *fw_data; - - fw_ctrl = container_of(attr, struct fw_update_ctrl, attr_fwimage); - fw_data = &fw_ctrl->fw_data; - - if (!fw_data->firmware) { - ts_err("Need set fw image size first"); - return -ENOMEM; - } - - if (fw_data->firmware->size == 0) { - ts_err("Invalid firmware size"); - return -EINVAL; - } - - if (pos + count > fw_data->firmware->size) - return -EFAULT; - mutex_lock(&fw_ctrl->mutex); - memcpy((u8 *)&fw_data->firmware->data[pos], buf, count); - mutex_unlock(&fw_ctrl->mutex); - return count; -} - -/* this interface has ben deprecated */ -static ssize_t goodix_sysfs_force_update_store(struct goodix_ext_module *module, - const char *buf, size_t count) -{ - return count; -} - -static struct goodix_ext_attribute goodix_fwu_attrs[] = { - __EXTMOD_ATTR(update_en, S_IWUGO, NULL, goodix_sysfs_update_en_store), - __EXTMOD_ATTR(progress, S_IRUGO, goodix_sysfs_update_progress_show, - NULL), - __EXTMOD_ATTR(result, S_IRUGO, goodix_sysfs_update_result_show, NULL), - __EXTMOD_ATTR(fwversion, S_IRUGO, goodix_sysfs_update_fwversion_show, - NULL), - __EXTMOD_ATTR(fwsize, S_IRUGO | S_IWUGO, goodix_sysfs_fwsize_show, - goodix_sysfs_fwsize_store), - __EXTMOD_ATTR(force_update, S_IWUGO, NULL, - goodix_sysfs_force_update_store), -}; - -static int goodix_fw_sysfs_init(struct goodix_ts_core *core_data, - struct goodix_ext_module *module) -{ - struct fw_update_ctrl *fw_ctrl = module->priv_data; - struct kobj_type *ktype; - int ret = 0, i; - - ktype = goodix_get_default_ktype(); - ret = kobject_init_and_add(&module->kobj, ktype, - &core_data->pdev->dev.kobj, "fwupdate"); - if (ret) { - ts_err("Create fwupdate sysfs node error!"); - goto exit_sysfs_init; - } - - ret = 0; - for (i = 0; i < ARRAY_SIZE(goodix_fwu_attrs) && !ret; i++) - ret = sysfs_create_file(&module->kobj, - &goodix_fwu_attrs[i].attr); - if (ret) { - ts_err("failed create fwu sysfs files"); - while (--i >= 0) - sysfs_remove_file(&module->kobj, - &goodix_fwu_attrs[i].attr); - - kobject_put(&module->kobj); - ret = -EINVAL; - goto exit_sysfs_init; - } - - fw_ctrl->attr_fwimage.attr.name = "fwimage"; - fw_ctrl->attr_fwimage.attr.mode = S_IRUGO | S_IWUGO; - fw_ctrl->attr_fwimage.size = 0; - fw_ctrl->attr_fwimage.write = goodix_sysfs_fwimage_store; - ret = sysfs_create_bin_file(&module->kobj, &fw_ctrl->attr_fwimage); - -exit_sysfs_init: - return ret; -} - -static void goodix_fw_sysfs_remove(struct goodix_ext_module *module) -{ - struct fw_update_ctrl *fw_ctrl = module->priv_data; - int i; - - sysfs_remove_bin_file(&module->kobj, &fw_ctrl->attr_fwimage); - - for (i = 0; i < ARRAY_SIZE(goodix_fwu_attrs); i++) - sysfs_remove_file(&module->kobj, &goodix_fwu_attrs[i].attr); - - kobject_put(&module->kobj); -} - -int goodix_do_fw_update(int mode) -{ - struct task_struct *fwu_thrd; - struct fw_update_ctrl *fwu_ctrl = &goodix_fw_update_ctrl; - int ret; - - if (!fwu_ctrl->initialized) { - ts_err("fw mode uninit"); - return -EINVAL; - } - - fwu_ctrl->mode = mode; - ts_debug("fw update mode 0x%x", mode); - if (fwu_ctrl->mode & UPDATE_MODE_BLOCK) { - ret = goodix_fw_update_thread(fwu_ctrl); - ts_debug("fw update return %d", ret); - return ret; - } else { - /* create and run update thread */ - fwu_thrd = kthread_run(goodix_fw_update_thread, fwu_ctrl, - "goodix-fwu"); - if (IS_ERR_OR_NULL(fwu_thrd)) { - ts_err("Failed to create update thread:%ld", - PTR_ERR(fwu_thrd)); - return -EFAULT; - } - ts_debug("success create fw update thread"); - return 0; - } -} - -static int goodix_fw_update_init(struct goodix_ts_core *core_data, - struct goodix_ext_module *module) -{ - int ret = 0; - struct goodix_ts_board_data *ts_bdata = board_data(core_data); - - if (goodix_fw_update_ctrl.initialized) { - ts_debug("no need reinit"); - return ret; - } - - if (!core_data || !ts_bdata || !core_data->ts_dev) { - ts_err("core_data && ts_dev can't be null"); - return -ENODEV; - } - - mutex_lock(&goodix_fw_update_ctrl.mutex); - module->priv_data = &goodix_fw_update_ctrl; - - goodix_fw_update_ctrl.ts_dev = core_data->ts_dev; - goodix_fw_update_ctrl.allow_reset = true; - goodix_fw_update_ctrl.allow_irq = true; - goodix_fw_update_ctrl.allow_suspend = true; - goodix_fw_update_ctrl.allow_resume = true; - goodix_fw_update_ctrl.core_data = core_data; - goodix_fw_update_ctrl.mode = 0; - /* find a valid firmware image name */ - if (ts_bdata && ts_bdata->fw_name) - strlcpy(goodix_fw_update_ctrl.fw_name, ts_bdata->fw_name, - sizeof(goodix_fw_update_ctrl.fw_name)); - else - strlcpy(goodix_fw_update_ctrl.fw_name, TS_DEFAULT_FIRMWARE, - sizeof(goodix_fw_update_ctrl.fw_name)); - - ret = goodix_fw_sysfs_init(core_data, module); - if (ret) { - ts_err("failed create fwupate sysfs node"); - goto err_out; - } - - goodix_fw_update_ctrl.initialized = 1; -err_out: - mutex_unlock(&goodix_fw_update_ctrl.mutex); - return ret; -} - -static int goodix_fw_update_exit(struct goodix_ts_core *core_data, - struct goodix_ext_module *module) -{ - return 0; -} - -static int goodix_fw_before_suspend(struct goodix_ts_core *core_data, - struct goodix_ext_module *module) -{ - struct fw_update_ctrl *fwu_ctrl = module->priv_data; - - return fwu_ctrl->allow_suspend ? EVT_HANDLED : EVT_CANCEL_SUSPEND; -} - -static int goodix_fw_before_resume(struct goodix_ts_core *core_data, - struct goodix_ext_module *module) -{ - struct fw_update_ctrl *fwu_ctrl = module->priv_data; - - return fwu_ctrl->allow_resume ? EVT_HANDLED : EVT_CANCEL_RESUME; -} - -static int goodix_fw_after_resume(struct goodix_ts_core *core_data, - struct goodix_ext_module *module) -{ - return 0; -} - -static int goodix_fw_irq_event(struct goodix_ts_core *core_data, - struct goodix_ext_module *module) -{ - struct fw_update_ctrl *fwu_ctrl = module->priv_data; - - return fwu_ctrl->allow_irq ? EVT_HANDLED : EVT_CANCEL_IRQEVT; -} - -static int goodix_fw_before_reset(struct goodix_ts_core *core_data, - struct goodix_ext_module *module) -{ - struct fw_update_ctrl *fwu_ctrl = module->priv_data; - - return fwu_ctrl->allow_reset ? EVT_HANDLED : EVT_CANCEL_RESET; -} - -static const struct goodix_ext_module_funcs goodix_ext_funcs = { - .init = goodix_fw_update_init, - .exit = goodix_fw_update_exit, - .before_reset = goodix_fw_before_reset, - .after_reset = NULL, - .before_suspend = goodix_fw_before_suspend, - .after_suspend = NULL, - .before_resume = goodix_fw_before_resume, - .after_resume = goodix_fw_after_resume, - .irq_event = goodix_fw_irq_event, -}; - -static struct goodix_ext_module goodix_fwu_module = { - .name = "goodix-fwu", - .funcs = &goodix_ext_funcs, - .priority = EXTMOD_PRIO_FWUPDATE, -}; - -static int __init goodix_fwu_module_init(void) -{ - ts_debug("goodix_fwupdate_module_ini IN"); - mutex_init(&goodix_fw_update_ctrl.mutex); - return goodix_register_ext_module(&goodix_fwu_module); -} - -static void __exit goodix_fwu_module_exit(void) -{ - mutex_lock(&goodix_fw_update_ctrl.mutex); - goodix_unregister_ext_module(&goodix_fwu_module); - if (goodix_fw_update_ctrl.initialized) { - goodix_fw_sysfs_remove(&goodix_fwu_module); - goodix_fw_update_ctrl.initialized = 0; - } - mutex_lock(&goodix_fw_update_ctrl.mutex); -} - -module_init(goodix_fwu_module_init); -module_exit(goodix_fwu_module_exit); - -MODULE_DESCRIPTION("Goodix FWU Module"); -MODULE_AUTHOR("Goodix, Inc."); -MODULE_LICENSE("GPL v2");