From bcc68f6a8a775f90bfb546a21d307d53344aa14b Mon Sep 17 00:00:00 2001 From: Konstantin Makariev Date: Mon, 12 Jul 2021 20:22:00 -0500 Subject: [PATCH] pct1812_mmi: firmware upgrade Added code to support FW upgrade. This code has not been tested yet Change-Id: I677f0cc6f722515681608581afc9bff650e8a46d Signed-off-by: Konstantin Makariev Reviewed-on: https://gerrit.mot.com/2010238 SME-Granted: SME Approvals Granted SLTApproved: Slta Waiver Tested-by: Jira Key Reviewed-by: Igor Kovalenko Submit-Approved: Jira Key --- .../touchscreen/pixart_mmi/pct1812_captouch.c | 534 +++++++++++++++++- 1 file changed, 515 insertions(+), 19 deletions(-) diff --git a/drivers/input/touchscreen/pixart_mmi/pct1812_captouch.c b/drivers/input/touchscreen/pixart_mmi/pct1812_captouch.c index 5445f077e669..a0622966929f 100644 --- a/drivers/input/touchscreen/pixart_mmi/pct1812_captouch.c +++ b/drivers/input/touchscreen/pixart_mmi/pct1812_captouch.c @@ -37,14 +37,35 @@ #include #include #include +#include #include #include #include #include +#define AREAD (1) +#define AWRITE (0) + +#define INVALID_BYTE2 0xebeb +#define INVALID_BYTE 0xeb + +#define ADDRESS_FW 0x00 +#define ADDRESS_PARAMS 0xe0 + +#define SUPPORTED_FW_FILE_SIZE 0x0000F000 +#define FW_SECTION_SIZE 0x0000E000 + +#define PCT1812_SECTOR_SIZE (0x1000) // 4K +#define CHUNK_SZ 256 + +#define FW_ADDR_BASE 0x00 +#define PARAM_ADDR_BASE 0xe0 + +#define POWERUP_CODE 0x02 #define RESET_CODE 0xaa #define RESUME_CODE 0xbb +#define ENGINEERING_CODE 0xcc #define SUSPEND_CODE 0x99 #define FRAME_NUM_REG 0x00 @@ -55,10 +76,30 @@ #define STATUS_REG 0x71 #define USER_BANK_REG 0x73 #define USER_ADDR_REG 0x74 -#define USER_DAA_REG 0x75 +#define USER_DATA_REG 0x75 #define SW_RESET_REG 0x7a #define DEEP_SLEEP_REG 0x7c +#define BANK(a) (a) +#define KEYS_NUM 8 + +// USER BANK 0 +#define VER_LOW_REG 0x7e +#define VER_HIGH_REG 0x7f +// USER BANK 1 +#define FLASH_PUP_REG 0x0d +#define KEY1_REG 0x2c +#define KEY2_REG 0x2d +// USER BANK 3 +#define FUNCT_CTRL_REG 0x02 +#define KEYS_NUM_REG 0x1a +#define KEY_THRES_BASE 0x00 +// USER BANK 4 +#define FLASH_STATUS_REG 0x1c +#define FLASH_ADDR0_REG 0x24 +#define FLASH_ADDR1_REG 0x25 +#define FLASH_ADDR2_REG 0x26 + #define STAT_BIT_ERR (1 << 0) #define STAT_BIT_EVENT (1 << 3) #define STAT_BIT_WDOG (1 << 7) @@ -96,6 +137,17 @@ enum cmds { CMD_WDOG }; +enum gestures { + GEST_TAP = 2, + GEST_DBL_TAP, + GEST_VERT_SCROLL = 7, + GEST_HORIZ_SCROLL, + GEST_UP_SWIPE = 17, + GEST_DWN_SWIPE, + GEST_LFT_SWIPE, + GEST_RGHT_SWIPE +}; + struct pct1812_platform { int max_x; int max_y; @@ -133,6 +185,10 @@ struct pct1812_data { struct pinctrl *ts_pinctrl; struct pinctrl_state *pinctrl_state_active; struct pinctrl_state *pinctrl_state_suspend; + + unsigned short version; + unsigned char func_ctrl; + unsigned char keys; }; #if 0 static int inline get_cmd(void) @@ -298,11 +354,11 @@ static int pct1812_parse_dt(struct i2c_client *client) } if (of_property_read_string(np, "pct1812,regulator_vio", &pdata->vio)) { - dev_err(dev, "%s: Failed to get VIO name property\n", __func__); - return -EINVAL; + dev_warn(dev, "%s: Failed to get VIO name property\n", __func__); + //return -EINVAL; } - pdata->irq_gpio = of_get_named_gpio(np, "pct1812,irq_gpio", 0); + pdata->irq_gpio = of_get_named_gpio(np, "pct1812,irq-gpio", 0); if (gpio_is_valid(pdata->irq_gpio)) { ret = gpio_request_one(pdata->irq_gpio, GPIOF_DIR_IN, "pct1812,irq"); if (ret) { @@ -315,7 +371,7 @@ static int pct1812_parse_dt(struct i2c_client *client) return -EINVAL; } #if 0 - pdata->rst_gpio = of_get_named_gpio(np, "pct1812,rst_gpio", 0); + pdata->rst_gpio = of_get_named_gpio(np, "pct1812,reset-gpio", 0); if (gpio_is_valid(pdata->rst_gpio)) { ret = gpio_request_one(pdata->rst_gpio, GPIOF_DIR_OUT, "pct1812,reset"); if (ret) { @@ -337,6 +393,29 @@ static int pct1812_parse_dt(struct i2c_client *client) } static int pct1812_read_touch_event(struct pct1812_data *ts) { + unsigned char gest, gdata[2]; + int ret; + + ret = pct1812_i2c_read(ts, GEST_TYPE_REG, &gest, sizeof(gest)); + if (ret) + return -EIO; + pr_debug("gesture 0x%02x\n", gest); + switch(gest & 0x1f) { + case GEST_HORIZ_SCROLL: + case GEST_VERT_SCROLL: + ret = pct1812_i2c_read(ts, GEST_X0_REG, gdata, sizeof(gdata)); + pr_debug("X0: 0x%04x\n", (gdata[1] << 8) | gdata[0]); + break; + case GEST_TAP: + case GEST_DBL_TAP: + case GEST_UP_SWIPE: + case GEST_DWN_SWIPE: + case GEST_LFT_SWIPE: + case GEST_RGHT_SWIPE: + break; + default: return -EINVAL; + } + return 0; } @@ -364,6 +443,407 @@ static irqreturn_t pct1812_irq_handler(int irq, void *ptr) return IRQ_HANDLED; } +static int pct1812_user_access(struct pct1812_data *ts, + unsigned char bank, unsigned char addr, + unsigned char *value, unsigned int size, bool R) +{ + unsigned char val; + int ret; + + pr_debug("Access %c: b%d:0x%02x val 0x%02x\n", + R ? 'R' : 'W', bank, addr, R ? 0 : *value); + + ret = pct1812_i2c_write(ts, USER_BANK_REG, &bank, sizeof(bank)); + if (ret) + return -EIO; + + ret = pct1812_i2c_write(ts, USER_ADDR_REG, &addr, sizeof(addr)); + if (ret) + return -EIO; + + if (R) { // read access + if (value) + *value = 0; + ret = pct1812_i2c_read(ts, USER_DATA_REG, &val, sizeof(val)); + if (!ret && value) + *value = val; + } else { + ret = pct1812_i2c_write(ts, USER_DATA_REG, value, size); + } + + return ret; +} + +static int pct1812_get_extinfo(struct pct1812_data *ts) +{ + unsigned char val; + unsigned char t_addr; + unsigned short tk1, tk2, version = 0; + int i, ret; + + ts->version = INVALID_BYTE2; + ret = pct1812_user_access(ts, BANK(0), VER_LOW_REG, &val, sizeof(val), AREAD); + if (!ret) + version |= val; + + ret = pct1812_user_access(ts, BANK(0), VER_HIGH_REG, &val, sizeof(val), AREAD); + if (!ret) + version |= (val << 8); + ts->version = version; + + dev_info(ts->dev, "%s: FW version 0x%04x\n", __func__, ts->version); + + ts->func_ctrl = INVALID_BYTE; + ret = pct1812_user_access(ts, BANK(3), FUNCT_CTRL_REG, &val, sizeof(val), AREAD); + if (!ret) + ts->func_ctrl = val; + + if (ts->func_ctrl != INVALID_BYTE) + dev_info(ts->dev, "%s: Func CTRL 0x%02x\n", __func__, ts->func_ctrl); + + ts->keys = INVALID_BYTE; + ret = pct1812_user_access(ts, BANK(3), KEYS_NUM_REG, &val, sizeof(val), AREAD); + if (!ret) + ts->keys = val; + + if (ts->keys != INVALID_BYTE) + dev_info(ts->dev, "%s: Keys supported %d\n", __func__, ts->keys); + + t_addr = KEY_THRES_BASE; + for (i = 0; i < KEYS_NUM; i++) { + tk1 = 0; + ret = pct1812_user_access(ts, BANK(3), t_addr++, &val, sizeof(val), AREAD); + if (!ret) + tk1 |= val; + ret = pct1812_user_access(ts, BANK(3), t_addr++, &val, sizeof(val), AREAD); + if (!ret) + tk1 |= (val << 8); + + tk2 = 0; + ret = pct1812_user_access(ts, BANK(3), t_addr++, &val, sizeof(val), AREAD); + if (!ret) + tk2 |= val; + ret = pct1812_user_access(ts, BANK(3), t_addr++, &val, sizeof(val), AREAD); + if (!ret) + tk2 |= (val << 8); + + if (!ret) + pr_debug("Key[%i] THRESHOLD: TK1 = 0x%04x, TK2 = 0x%04x\n", i, tk1, tk2); + } + + return ret; +} + +static int inline pct1812_engmode(struct pct1812_data *ts, bool on) +{ + unsigned char value; + int ret; + + value = RESET_CODE; + ret = pct1812_user_access(ts, BANK(1), KEY1_REG, &value, sizeof(value), AWRITE); + if (ret) + return -EIO; + + value = on ? ENGINEERING_CODE : RESUME_CODE; + ret = pct1812_user_access(ts, BANK(1), KEY2_REG, &value, sizeof(value), AWRITE); + if (ret) + return -EIO; + + pct1812_delay_ms(2); + + return 0; +} + +static int pct1812_flash_exec(struct pct1812_data *ts, + unsigned char cmd, unsigned char flash_cmd, int cnt) +{ + unsigned char lval; + int repetition = 0; + int ret, step = 0; + + lval = 0; + ret = pct1812_user_access(ts, BANK(4), 0x2c, &lval, sizeof(lval), AWRITE); + if (ret) + goto error; + step++; + lval = flash_cmd; + ret = pct1812_user_access(ts, BANK(4), 0x20, &lval, sizeof(lval), AWRITE); + if (ret) + goto error; + step++; + lval = cnt & 0xff; + ret = pct1812_user_access(ts, BANK(4), 0x22, &lval, sizeof(lval), AWRITE); + if (ret) + goto error; + step++; + lval = (cnt >> 8) & 0xff; + ret = pct1812_user_access(ts, BANK(4), 0x23, &lval, sizeof(lval), AWRITE); + if (ret) + goto error; + step++; +do_again: + lval = 0; + ret = pct1812_user_access(ts, BANK(4), 0x2c, &lval, sizeof(lval), AREAD); + if (ret) + goto error; + + if ((lval & cmd) != 0) { + repetition++; + if (repetition%11) + pr_debug("Still waiting ... %d\n", repetition); + goto do_again; + } + + return 0; + +error: + dev_err(ts->dev, + "Error exec cmd 0x%02x, flash_cmd 0x%02x, cnt %d (stage %d, reps %d)\n", + __func__, cmd, flash_cmd, cnt, step, repetition); + return -EIO; +} + +static int pct1812_flash_status(struct pct1812_data *ts, int idx, int vok) +{ + unsigned char status[2]; + int ret; + +do_again: + ret = pct1812_flash_exec(ts, 0x08, 0x05, 1); + if (ret) { + dev_err(ts->dev, "Error flash cmd\n", __func__); + return -EIO; + } + + ret = pct1812_user_access(ts, BANK(4), FLASH_STATUS_REG, status, sizeof(status), AREAD); + if (ret) { + dev_err(ts->dev, "Error reading flash status\n", __func__); + return -EIO; + } + + if (status[idx] != vok) { + pct1812_delay_ms(1); // adjust delay if necessary + goto do_again; + } + + pr_debug("Flash status ([%d]=%d) OK\n", idx, vok); + + return 0; +} + +static int pct1812_flash_chunk(struct pct1812_data *ts, unsigned int address) +{ + int ret, step = 0; + unsigned char value; + + // Flash WriteEnable + ret = pct1812_flash_exec(ts, 0x02, 0x09, 0); + if (ret) + goto error; + step++; + // check status + ret = pct1812_flash_status(ts, 1, 1); + if (ret) + goto error; + step++; + value = (unsigned char)(address & 0xff); + ret = pct1812_user_access(ts, BANK(4), FLASH_ADDR0_REG, &value, sizeof(value), AWRITE); + if (ret) + goto error; + step++; + value = (unsigned char)((address >> 8) & 0xff); + ret = pct1812_user_access(ts, BANK(4), FLASH_ADDR1_REG, &value, sizeof(value), AWRITE); + if (ret) + goto error; + step++; + value = (unsigned char)((address >> 16) & 0xff); + ret = pct1812_user_access(ts, BANK(4), FLASH_ADDR2_REG, &value, sizeof(value), AWRITE); + if (ret) + goto error; + step++; + ret = pct1812_flash_exec(ts, 0x81, 0x02, CHUNK_SZ); + if (ret) + goto error; + step++; + // wait for completion + ret = pct1812_flash_status(ts, 0, 0); + if (ret) + goto error; + + return 0; + +error: + dev_err(ts->dev, "Error erasing address 0x%06x (stage %d)\n", + __func__, address, step); + return -EIO; +} + +static int pct1812_erase_sector(struct pct1812_data *ts, unsigned int address) +{ + int ret, step = 0; + unsigned char value; + + pr_debug("Erasing sector at address 0x%06x\n", address); + + // Flash WriteEnable + ret = pct1812_flash_exec(ts, 0x02, 0x09, 0); + if (ret) + goto error; + step++; + // check status + ret = pct1812_flash_status(ts, 1, 1); + if (ret) + goto error; + step++; + value = (unsigned char)(address & 0xff); + ret = pct1812_user_access(ts, BANK(4), FLASH_ADDR0_REG, &value, sizeof(value), AWRITE); + if (ret) + goto error; + step++; + value = (unsigned char)((address >> 8) & 0xff); + ret = pct1812_user_access(ts, BANK(4), FLASH_ADDR1_REG, &value, sizeof(value), AWRITE); + if (ret) + goto error; + step++; + value = (unsigned char)((address >> 16) & 0xff); + ret = pct1812_user_access(ts, BANK(4), FLASH_ADDR2_REG, &value, sizeof(value), AWRITE); + if (ret) + goto error; + step++; + ret = pct1812_flash_exec(ts, 0x02, 0x20, 3); + if (ret) + goto error; + step++; + // wait for completion + ret = pct1812_flash_status(ts, 0, 0); + if (ret) + goto error; + + return 0; + +error: + dev_err(ts->dev, "Error erasing address 0x%06x (stage %d)\n", + __func__, address, step); + return -EIO; +} + +static int pct1812_flash_section(struct pct1812_data *ts, unsigned char *data, + unsigned int size, unsigned int address) +{ + int m, ret; + unsigned int num_of_sectors = size / PCT1812_SECTOR_SIZE; + unsigned int target_num = size / CHUNK_SZ; + unsigned char value; + unsigned char *ptr = data; + + for (m = 0; m < num_of_sectors; m++) { + ret = pct1812_erase_sector(ts, address + PCT1812_SECTOR_SIZE * m); + if (ret) + goto error; + pr_debug("Erased sector %d of %d\n", m + 1, num_of_sectors); + } + + for (m = 0; m < target_num; m++) { + // Set SRAM select + value = 0x08; + ret = pct1812_user_access(ts, BANK(2), 0x09, &value, sizeof(value), AWRITE); + if (ret) + goto error; + // Set SRAM NSC to 0 + value = 0x00; + ret = pct1812_user_access(ts, BANK(2), 0x0a, &value, sizeof(value), AWRITE); + if (ret) + goto error; + // Write data to SRAM port + ret = pct1812_user_access(ts, BANK(2), 0x0b, ptr, CHUNK_SZ, AWRITE); + if (ret) + goto error; + // Set SRAM NSC to 1 + value = 0x01; + ret = pct1812_user_access(ts, BANK(2), 0x0a, &value, sizeof(value), AWRITE); + if (ret) + goto error; + // advance data pointer + ptr += CHUNK_SZ; + pr_debug("Flashing chunk @0x%04x\n", address); + // Program Flash from SRAM + ret = pct1812_flash_chunk(ts, address); + if (ret) + goto error; + address += CHUNK_SZ; + } + + return 0; +error: + dev_err(ts->dev, "Error flashing chunk %d\n", __func__, m); + return -EIO; +} + +/*static*/ +int pct1812_fw_update(struct pct1812_data *ts, const char *fname) +{ + int ret; + unsigned char value; + unsigned char *fwdata_ptr, *fwparam_ptr; + unsigned int fwdata_size, fwparam_size; + const struct firmware *fw_entry = NULL; + + //__pm_stay_awake(&ts->wake_src); + mutex_lock(&ts->cmdlock); + pr_debug("Start of FW reflash process\n"); + //fwu_irq_enable(fwu, true); + pr_debug("Requesting firmware %s\n", fname); + ret = request_firmware(&fw_entry, fname, ts->dev); + if (ret) { + dev_err(ts->dev, "%s: Error loading firmware %s\n", __func__, fname); + ret = -EINVAL; + goto exit; + } + // FW file size check + if (fw_entry->size != SUPPORTED_FW_FILE_SIZE) { + dev_err(ts->dev, "%s: Firmware %s file size is WRONG!!!\n", __func__, fname); + ret = -EINVAL; + goto exit; + } + + fwdata_size = FW_SECTION_SIZE; + fwdata_ptr = (unsigned char *)fw_entry->data; + fwparam_size = SUPPORTED_FW_FILE_SIZE - FW_SECTION_SIZE; + fwparam_ptr = fwdata_ptr + FW_SECTION_SIZE; + + ret = pct1812_engmode(ts, true); + if (ret) { + dev_err(ts->dev, "%s: Error entering flash mode\n", __func__); + goto exit; + } + + value = POWERUP_CODE; + ret = pct1812_user_access(ts, BANK(1), FLASH_PUP_REG, &value, sizeof(value), AWRITE); + if (ret) { + dev_err(ts->dev, "%s: Error powering flash controller\n", __func__); + goto exit; + } + + ret = pct1812_flash_section(ts, fwdata_ptr, fwdata_size, ADDRESS_FW); + if (ret) { + dev_err(ts->dev, "%s: Flash error!!!\n", __func__); + } else { + ret = pct1812_flash_section(ts, fwparam_ptr, fwparam_size, ADDRESS_PARAMS); + if (ret) + dev_err(ts->dev, "%s: Flash error!!!\n", __func__); + } + +exit: + ret = pct1812_engmode(ts, false); + if (ret) { + dev_err(ts->dev, "%s: Error leaving flash mode\n", __func__); + } + mutex_unlock(&ts->cmdlock); + //__pm_relax(&ts->wake_src); + + return ret; +} + static int pct1812_wait4ready(struct pct1812_data *ts, unsigned char reg, unsigned char vok) { unsigned char status = 0; @@ -375,8 +855,12 @@ static int pct1812_wait4ready(struct pct1812_data *ts, unsigned char reg, unsign break; pct1812_delay_ms(CMD_WAIT_DELAY); } - if (ret == CNT_WAIT_RETRY) + if (retry == CNT_WAIT_RETRY) ret = -ETIME; + else if (!ret) { + pr_debug("success waiting for %d\n", vok); + } + return (status == vok) ? 0 : ret; } @@ -409,6 +893,8 @@ static int pct1812_regulator(struct pct1812_data *ts, bool get) ts->reg_vdd = rvdd; ts->reg_vio = rvio; + pr_debug("vdd=%p, vio=%p\n", rvdd, rvio); + return 0; } @@ -433,6 +919,9 @@ static int pct1812_pinctrl_state(struct pct1812_data *info, bool on) if (error < 0) dev_err(info->dev, "%s: Failed to select %s\n", __func__, state_name); + else + pr_debug("set pinctrl state %s\n", state_name); + return error; } @@ -491,7 +980,7 @@ static int pct1812_power(struct pct1812_data *ts, bool on) regulator_disable(ts->reg_vio); } - dev_info(ts->dev,"%s: %s: %s:%s\n", __func__, on ? "on" : "off", + dev_info(ts->dev,"%s: power %s: %s:%s\n", __func__, on ? "ON" : "OFF", pdata->vdd, regulator_is_enabled(ts->reg_vdd) ? "on" : "off"); if (pdata->vio) dev_info(ts->dev,"%s: %s: %s:%s\n", __func__, on ? "on" : "off", @@ -509,21 +998,27 @@ static int pct1812_power_mode(struct pct1812_data *ts, enum pwr_modes mode) static int pct1812_run_cmd(struct pct1812_data *ts, enum cmds command) { unsigned char code; + const char *action; int ret, counter = 0; switch (command) { case CMD_RESET: + action = "RESET"; code = RESET_CODE; break; case CMD_RESUME: + action = "RESUME"; code = RESUME_CODE; break; case CMD_SUSPEND: + action = "SUSPEND"; code = SUSPEND_CODE; break; default: return -EINVAL; } + run_once_again: + pr_debug("command: %s\n", action); ret = pct1812_i2c_write(ts, SW_RESET_REG, &code, sizeof(code)); if (ret) { dev_err(ts->dev, "%s: Error sending cmd: %d (%d)\n", __func__, command, ret); @@ -532,6 +1027,7 @@ run_once_again: if (!counter++) pct1812_delay_ms(10); if (code == RESET_CODE) { + action = "RESUME"; code = RESUME_CODE; goto run_once_again; } @@ -543,6 +1039,8 @@ static int pct1812_queued_resume(struct pct1812_data *ts) { int ret; + pr_debug("enter\n"); + if (atomic_cmpxchg(&ts->touch_stopped, 1, 0) == 0) return 0; @@ -559,18 +1057,21 @@ static void pct1812_work(struct work_struct *work) struct pct1812_data *ts = container_of(work, struct pct1812_data, worker.work); unsigned char status = 0; static unsigned char prev; + const char *action; int cmd, ret; while (kfifo_get(&ts->cmd_pipe, &cmd)) { //cmd = get_cmd(); switch (cmd) { case CMD_WDOG: + action = "WDOG"; ret = pct1812_i2c_read(ts, FRAME_NUM_REG, &status, sizeof(status)); if (ret || (prev == status)) { dev_warn(ts->dev, "%s: Possible lockup\n", __func__); } break; case CMD_RECOVER: + action = "RECOVER"; ret = pct1812_run_cmd(ts, CMD_RESET); if (ret) { dev_err(ts->dev, "%s: Failed to reset\n", __func__); @@ -581,6 +1082,7 @@ static void pct1812_work(struct work_struct *work) } break; case CMD_RESUME: + action = "RESUME"; ret = pct1812_queued_resume(ts); if (ret) dev_err(ts->dev, "%s: Failed to resume\n", __func__); @@ -588,6 +1090,8 @@ static void pct1812_work(struct work_struct *work) } } + pr_debug("action: %s\n", action); + pct1812_fifo_cmd_add(ts, CMD_WDOG, WDOG_INTERVAL); } #if 0 @@ -596,6 +1100,8 @@ static int pct1812_suspend(struct device *dev) struct pct1812_data *ts = dev_get_drvdata(dev); int ret; + pr_debug("enter\n"); + if (atomic_cmpxchg(&ts->touch_stopped, 0, 1) == 1) return 0; @@ -658,17 +1164,6 @@ static int pct1812_probe(struct i2c_client *client, const struct i2c_device_id * i2c_set_clientdata(client, ts); dev_set_drvdata(&client->dev, ts); - pdata->pinctrl = devm_pinctrl_get(&client->dev); - if (IS_ERR(pdata->pinctrl)) { - dev_warn(&client->dev, "%s: no pinctrl found\n", __func__); - } else { - struct pinctrl_state *state; - - state = pinctrl_lookup_state(pdata->pinctrl, "on_state"); - if (IS_ERR(state)) - dev_err(&client->dev, "%s: could not get active pinstate\n", __func__); - } - mutex_init(&ts->i2c_mutex); mutex_init(&ts->cmdlock); mutex_init(&ts->eventlock); @@ -688,6 +1183,8 @@ static int pct1812_probe(struct i2c_client *client, const struct i2c_device_id * goto error_init; } + pct1812_get_extinfo(ts); + ret = kfifo_alloc(&ts->cmd_pipe, sizeof(unsigned int)* 10, GFP_KERNEL); if (ret) goto error_init; @@ -701,7 +1198,6 @@ static int pct1812_probe(struct i2c_client *client, const struct i2c_device_id * /* prevent unbalanced irq enable */ ts->irq_enabled = true; - dev_info(&client->dev, "%s: done\n", __func__); pct1812_fifo_cmd_add(ts, CMD_WDOG, WDOG_INTERVAL);