109182ed2SHans de Goede // SPDX-License-Identifier: GPL-2.0-only
209182ed2SHans de Goede /*
309182ed2SHans de Goede * Goodix Touchscreen firmware upload support
409182ed2SHans de Goede *
509182ed2SHans de Goede * Copyright (c) 2021 Hans de Goede <hdegoede@redhat.com>
609182ed2SHans de Goede *
709182ed2SHans de Goede * This is a rewrite of gt9xx_update.c from the Allwinner H3 BSP which is:
809182ed2SHans de Goede * Copyright (c) 2010 - 2012 Goodix Technology.
909182ed2SHans de Goede * Author: andrew@goodix.com
1009182ed2SHans de Goede */
1109182ed2SHans de Goede
1209182ed2SHans de Goede #include <linux/device.h>
1309182ed2SHans de Goede #include <linux/firmware.h>
1409182ed2SHans de Goede #include <linux/i2c.h>
1509182ed2SHans de Goede #include "goodix.h"
1609182ed2SHans de Goede
1709182ed2SHans de Goede #define GOODIX_FW_HEADER_LENGTH sizeof(struct goodix_fw_header)
1809182ed2SHans de Goede #define GOODIX_FW_SECTION_LENGTH 0x2000
1909182ed2SHans de Goede #define GOODIX_FW_DSP_LENGTH 0x1000
2009182ed2SHans de Goede #define GOODIX_FW_UPLOAD_ADDRESS 0xc000
2109182ed2SHans de Goede
2209182ed2SHans de Goede #define GOODIX_CFG_LOC_HAVE_KEY 7
2309182ed2SHans de Goede #define GOODIX_CFG_LOC_DRVA_NUM 27
2409182ed2SHans de Goede #define GOODIX_CFG_LOC_DRVB_NUM 28
2509182ed2SHans de Goede #define GOODIX_CFG_LOC_SENS_NUM 29
2609182ed2SHans de Goede
2709182ed2SHans de Goede struct goodix_fw_header {
2809182ed2SHans de Goede u8 hw_info[4];
2909182ed2SHans de Goede u8 pid[8];
3009182ed2SHans de Goede u8 vid[2];
3109182ed2SHans de Goede } __packed;
3209182ed2SHans de Goede
goodix_firmware_checksum(const u8 * data,int size)3309182ed2SHans de Goede static u16 goodix_firmware_checksum(const u8 *data, int size)
3409182ed2SHans de Goede {
3509182ed2SHans de Goede u16 checksum = 0;
3609182ed2SHans de Goede int i;
3709182ed2SHans de Goede
3809182ed2SHans de Goede for (i = 0; i < size; i += 2)
3909182ed2SHans de Goede checksum += (data[i] << 8) + data[i + 1];
4009182ed2SHans de Goede
4109182ed2SHans de Goede return checksum;
4209182ed2SHans de Goede }
4309182ed2SHans de Goede
goodix_firmware_verify(struct device * dev,const struct firmware * fw)4409182ed2SHans de Goede static int goodix_firmware_verify(struct device *dev, const struct firmware *fw)
4509182ed2SHans de Goede {
4609182ed2SHans de Goede const struct goodix_fw_header *fw_header;
4709182ed2SHans de Goede size_t expected_size;
4809182ed2SHans de Goede const u8 *data;
4909182ed2SHans de Goede u16 checksum;
5009182ed2SHans de Goede char buf[9];
5109182ed2SHans de Goede
5209182ed2SHans de Goede expected_size = GOODIX_FW_HEADER_LENGTH + 4 * GOODIX_FW_SECTION_LENGTH +
5309182ed2SHans de Goede GOODIX_FW_DSP_LENGTH;
5409182ed2SHans de Goede if (fw->size != expected_size) {
5509182ed2SHans de Goede dev_err(dev, "Firmware has wrong size, expected %zu got %zu\n",
5609182ed2SHans de Goede expected_size, fw->size);
5709182ed2SHans de Goede return -EINVAL;
5809182ed2SHans de Goede }
5909182ed2SHans de Goede
6009182ed2SHans de Goede data = fw->data + GOODIX_FW_HEADER_LENGTH;
6109182ed2SHans de Goede checksum = goodix_firmware_checksum(data, 4 * GOODIX_FW_SECTION_LENGTH);
6209182ed2SHans de Goede if (checksum) {
6309182ed2SHans de Goede dev_err(dev, "Main firmware checksum error\n");
6409182ed2SHans de Goede return -EINVAL;
6509182ed2SHans de Goede }
6609182ed2SHans de Goede
6709182ed2SHans de Goede data += 4 * GOODIX_FW_SECTION_LENGTH;
6809182ed2SHans de Goede checksum = goodix_firmware_checksum(data, GOODIX_FW_DSP_LENGTH);
6909182ed2SHans de Goede if (checksum) {
7009182ed2SHans de Goede dev_err(dev, "DSP firmware checksum error\n");
7109182ed2SHans de Goede return -EINVAL;
7209182ed2SHans de Goede }
7309182ed2SHans de Goede
7409182ed2SHans de Goede fw_header = (const struct goodix_fw_header *)fw->data;
7509182ed2SHans de Goede dev_info(dev, "Firmware hardware info %02x%02x%02x%02x\n",
7609182ed2SHans de Goede fw_header->hw_info[0], fw_header->hw_info[1],
7709182ed2SHans de Goede fw_header->hw_info[2], fw_header->hw_info[3]);
7809182ed2SHans de Goede /* pid is a 8 byte buffer containing a string, weird I know */
7909182ed2SHans de Goede memcpy(buf, fw_header->pid, 8);
8009182ed2SHans de Goede buf[8] = 0;
8109182ed2SHans de Goede dev_info(dev, "Firmware PID: %s VID: %02x%02x\n", buf,
8209182ed2SHans de Goede fw_header->vid[0], fw_header->vid[1]);
8309182ed2SHans de Goede return 0;
8409182ed2SHans de Goede }
8509182ed2SHans de Goede
goodix_enter_upload_mode(struct i2c_client * client)8609182ed2SHans de Goede static int goodix_enter_upload_mode(struct i2c_client *client)
8709182ed2SHans de Goede {
8809182ed2SHans de Goede int tries, error;
8909182ed2SHans de Goede u8 val;
9009182ed2SHans de Goede
9109182ed2SHans de Goede tries = 200;
9209182ed2SHans de Goede do {
9309182ed2SHans de Goede error = goodix_i2c_write_u8(client,
9409182ed2SHans de Goede GOODIX_REG_MISCTL_SWRST, 0x0c);
9509182ed2SHans de Goede if (error)
9609182ed2SHans de Goede return error;
9709182ed2SHans de Goede
9809182ed2SHans de Goede error = goodix_i2c_read(client,
9909182ed2SHans de Goede GOODIX_REG_MISCTL_SWRST, &val, 1);
10009182ed2SHans de Goede if (error)
10109182ed2SHans de Goede return error;
10209182ed2SHans de Goede
10309182ed2SHans de Goede if (val == 0x0c)
10409182ed2SHans de Goede break;
10509182ed2SHans de Goede } while (--tries);
10609182ed2SHans de Goede
10709182ed2SHans de Goede if (!tries) {
10809182ed2SHans de Goede dev_err(&client->dev, "Error could not hold ss51 & dsp\n");
10909182ed2SHans de Goede return -EIO;
11009182ed2SHans de Goede }
11109182ed2SHans de Goede
11209182ed2SHans de Goede /* DSP_CK and DSP_ALU_CK PowerOn */
11309182ed2SHans de Goede error = goodix_i2c_write_u8(client, GOODIX_REG_MISCTL_DSP_CTL, 0x00);
11409182ed2SHans de Goede if (error)
11509182ed2SHans de Goede return error;
11609182ed2SHans de Goede
11709182ed2SHans de Goede /* Disable watchdog */
11809182ed2SHans de Goede error = goodix_i2c_write_u8(client, GOODIX_REG_MISCTL_TMR0_EN, 0x00);
11909182ed2SHans de Goede if (error)
12009182ed2SHans de Goede return error;
12109182ed2SHans de Goede
12209182ed2SHans de Goede /* Clear cache enable */
12309182ed2SHans de Goede error = goodix_i2c_write_u8(client, GOODIX_REG_MISCTL_CACHE_EN, 0x00);
12409182ed2SHans de Goede if (error)
12509182ed2SHans de Goede return error;
12609182ed2SHans de Goede
12709182ed2SHans de Goede /* Set boot from SRAM */
12809182ed2SHans de Goede error = goodix_i2c_write_u8(client, GOODIX_REG_MISCTL_BOOTCTL, 0x02);
12909182ed2SHans de Goede if (error)
13009182ed2SHans de Goede return error;
13109182ed2SHans de Goede
13209182ed2SHans de Goede /* Software reboot */
13309182ed2SHans de Goede error = goodix_i2c_write_u8(client,
13409182ed2SHans de Goede GOODIX_REG_MISCTL_CPU_SWRST_PULSE, 0x01);
13509182ed2SHans de Goede if (error)
13609182ed2SHans de Goede return error;
13709182ed2SHans de Goede
13809182ed2SHans de Goede /* Clear control flag */
13909182ed2SHans de Goede error = goodix_i2c_write_u8(client, GOODIX_REG_MISCTL_BOOTCTL, 0x00);
14009182ed2SHans de Goede if (error)
14109182ed2SHans de Goede return error;
14209182ed2SHans de Goede
14309182ed2SHans de Goede /* Set scramble */
14409182ed2SHans de Goede error = goodix_i2c_write_u8(client, GOODIX_REG_MISCTL_BOOT_OPT, 0x00);
14509182ed2SHans de Goede if (error)
14609182ed2SHans de Goede return error;
14709182ed2SHans de Goede
14809182ed2SHans de Goede /* Enable accessing code */
14909182ed2SHans de Goede error = goodix_i2c_write_u8(client, GOODIX_REG_MISCTL_MEM_CD_EN, 0x01);
15009182ed2SHans de Goede if (error)
15109182ed2SHans de Goede return error;
15209182ed2SHans de Goede
15309182ed2SHans de Goede return 0;
15409182ed2SHans de Goede }
15509182ed2SHans de Goede
goodix_start_firmware(struct i2c_client * client)15609182ed2SHans de Goede static int goodix_start_firmware(struct i2c_client *client)
15709182ed2SHans de Goede {
15809182ed2SHans de Goede int error;
15909182ed2SHans de Goede u8 val;
16009182ed2SHans de Goede
16109182ed2SHans de Goede /* Init software watchdog */
16209182ed2SHans de Goede error = goodix_i2c_write_u8(client, GOODIX_REG_SW_WDT, 0xaa);
16309182ed2SHans de Goede if (error)
16409182ed2SHans de Goede return error;
16509182ed2SHans de Goede
16609182ed2SHans de Goede /* Release SS51 & DSP */
16709182ed2SHans de Goede error = goodix_i2c_write_u8(client, GOODIX_REG_MISCTL_SWRST, 0x00);
16809182ed2SHans de Goede if (error)
16909182ed2SHans de Goede return error;
17009182ed2SHans de Goede
17109182ed2SHans de Goede error = goodix_i2c_read(client, GOODIX_REG_SW_WDT, &val, 1);
17209182ed2SHans de Goede if (error)
17309182ed2SHans de Goede return error;
17409182ed2SHans de Goede
17509182ed2SHans de Goede /* The value we've written to SW_WDT should have been cleared now */
17609182ed2SHans de Goede if (val == 0xaa) {
17709182ed2SHans de Goede dev_err(&client->dev, "Error SW_WDT reg not cleared on fw startup\n");
17809182ed2SHans de Goede return -EIO;
17909182ed2SHans de Goede }
18009182ed2SHans de Goede
18109182ed2SHans de Goede /* Re-init software watchdog */
18209182ed2SHans de Goede error = goodix_i2c_write_u8(client, GOODIX_REG_SW_WDT, 0xaa);
18309182ed2SHans de Goede if (error)
18409182ed2SHans de Goede return error;
18509182ed2SHans de Goede
18609182ed2SHans de Goede return 0;
18709182ed2SHans de Goede }
18809182ed2SHans de Goede
goodix_firmware_upload(struct goodix_ts_data * ts)18909182ed2SHans de Goede static int goodix_firmware_upload(struct goodix_ts_data *ts)
19009182ed2SHans de Goede {
19109182ed2SHans de Goede const struct firmware *fw;
19209182ed2SHans de Goede char fw_name[64];
19309182ed2SHans de Goede const u8 *data;
19409182ed2SHans de Goede int error;
19509182ed2SHans de Goede
19609182ed2SHans de Goede snprintf(fw_name, sizeof(fw_name), "goodix/%s", ts->firmware_name);
19709182ed2SHans de Goede
19809182ed2SHans de Goede error = request_firmware(&fw, fw_name, &ts->client->dev);
19909182ed2SHans de Goede if (error) {
20009182ed2SHans de Goede dev_err(&ts->client->dev, "Firmware request error %d\n", error);
20109182ed2SHans de Goede return error;
20209182ed2SHans de Goede }
20309182ed2SHans de Goede
20409182ed2SHans de Goede error = goodix_firmware_verify(&ts->client->dev, fw);
20509182ed2SHans de Goede if (error)
20609182ed2SHans de Goede goto release;
20709182ed2SHans de Goede
20809182ed2SHans de Goede error = goodix_reset_no_int_sync(ts);
20909182ed2SHans de Goede if (error)
210*3fd6e12aSJosé Expósito goto release;
21109182ed2SHans de Goede
21209182ed2SHans de Goede error = goodix_enter_upload_mode(ts->client);
21309182ed2SHans de Goede if (error)
21409182ed2SHans de Goede goto release;
21509182ed2SHans de Goede
21609182ed2SHans de Goede /* Select SRAM bank 0 and upload section 1 & 2 */
21709182ed2SHans de Goede error = goodix_i2c_write_u8(ts->client,
21809182ed2SHans de Goede GOODIX_REG_MISCTL_SRAM_BANK, 0x00);
21909182ed2SHans de Goede if (error)
22009182ed2SHans de Goede goto release;
22109182ed2SHans de Goede
22209182ed2SHans de Goede data = fw->data + GOODIX_FW_HEADER_LENGTH;
22309182ed2SHans de Goede error = goodix_i2c_write(ts->client, GOODIX_FW_UPLOAD_ADDRESS,
22409182ed2SHans de Goede data, 2 * GOODIX_FW_SECTION_LENGTH);
22509182ed2SHans de Goede if (error)
22609182ed2SHans de Goede goto release;
22709182ed2SHans de Goede
22809182ed2SHans de Goede /* Select SRAM bank 1 and upload section 3 & 4 */
22909182ed2SHans de Goede error = goodix_i2c_write_u8(ts->client,
23009182ed2SHans de Goede GOODIX_REG_MISCTL_SRAM_BANK, 0x01);
23109182ed2SHans de Goede if (error)
23209182ed2SHans de Goede goto release;
23309182ed2SHans de Goede
23409182ed2SHans de Goede data += 2 * GOODIX_FW_SECTION_LENGTH;
23509182ed2SHans de Goede error = goodix_i2c_write(ts->client, GOODIX_FW_UPLOAD_ADDRESS,
23609182ed2SHans de Goede data, 2 * GOODIX_FW_SECTION_LENGTH);
23709182ed2SHans de Goede if (error)
23809182ed2SHans de Goede goto release;
23909182ed2SHans de Goede
24009182ed2SHans de Goede /* Select SRAM bank 2 and upload the DSP firmware */
24109182ed2SHans de Goede error = goodix_i2c_write_u8(ts->client,
24209182ed2SHans de Goede GOODIX_REG_MISCTL_SRAM_BANK, 0x02);
24309182ed2SHans de Goede if (error)
24409182ed2SHans de Goede goto release;
24509182ed2SHans de Goede
24609182ed2SHans de Goede data += 2 * GOODIX_FW_SECTION_LENGTH;
24709182ed2SHans de Goede error = goodix_i2c_write(ts->client, GOODIX_FW_UPLOAD_ADDRESS,
24809182ed2SHans de Goede data, GOODIX_FW_DSP_LENGTH);
24909182ed2SHans de Goede if (error)
25009182ed2SHans de Goede goto release;
25109182ed2SHans de Goede
25209182ed2SHans de Goede error = goodix_start_firmware(ts->client);
25309182ed2SHans de Goede if (error)
25409182ed2SHans de Goede goto release;
25509182ed2SHans de Goede
25609182ed2SHans de Goede error = goodix_int_sync(ts);
25709182ed2SHans de Goede release:
25809182ed2SHans de Goede release_firmware(fw);
25909182ed2SHans de Goede return error;
26009182ed2SHans de Goede }
26109182ed2SHans de Goede
goodix_prepare_bak_ref(struct goodix_ts_data * ts)26209182ed2SHans de Goede static int goodix_prepare_bak_ref(struct goodix_ts_data *ts)
26309182ed2SHans de Goede {
26409182ed2SHans de Goede u8 have_key, driver_num, sensor_num;
26509182ed2SHans de Goede
26609182ed2SHans de Goede if (ts->bak_ref)
26709182ed2SHans de Goede return 0; /* Already done */
26809182ed2SHans de Goede
26909182ed2SHans de Goede have_key = (ts->config[GOODIX_CFG_LOC_HAVE_KEY] & 0x01);
27009182ed2SHans de Goede
27109182ed2SHans de Goede driver_num = (ts->config[GOODIX_CFG_LOC_DRVA_NUM] & 0x1f) +
27209182ed2SHans de Goede (ts->config[GOODIX_CFG_LOC_DRVB_NUM] & 0x1f);
27309182ed2SHans de Goede if (have_key)
27409182ed2SHans de Goede driver_num--;
27509182ed2SHans de Goede
27609182ed2SHans de Goede sensor_num = (ts->config[GOODIX_CFG_LOC_SENS_NUM] & 0x0f) +
27709182ed2SHans de Goede ((ts->config[GOODIX_CFG_LOC_SENS_NUM] >> 4) & 0x0f);
27809182ed2SHans de Goede
27909182ed2SHans de Goede dev_dbg(&ts->client->dev, "Drv %d Sen %d Key %d\n",
28009182ed2SHans de Goede driver_num, sensor_num, have_key);
28109182ed2SHans de Goede
28209182ed2SHans de Goede ts->bak_ref_len = (driver_num * (sensor_num - 2) + 2) * 2;
28309182ed2SHans de Goede
28409182ed2SHans de Goede ts->bak_ref = devm_kzalloc(&ts->client->dev,
28509182ed2SHans de Goede ts->bak_ref_len, GFP_KERNEL);
28609182ed2SHans de Goede if (!ts->bak_ref)
28709182ed2SHans de Goede return -ENOMEM;
28809182ed2SHans de Goede
28909182ed2SHans de Goede /*
29009182ed2SHans de Goede * The bak_ref array contains the backup of an array of (self/auto)
29109182ed2SHans de Goede * calibration related values which the Android version of the driver
29209182ed2SHans de Goede * stores on the filesystem so that it can be restored after reboot.
29309182ed2SHans de Goede * The mainline kernel never writes directly to the filesystem like
29409182ed2SHans de Goede * this, we always start will all the values which give a correction
29509182ed2SHans de Goede * factor in approx. the -20 - +20 range (in 2s complement) set to 0.
29609182ed2SHans de Goede *
29709182ed2SHans de Goede * Note the touchscreen works fine without restoring the reference
29809182ed2SHans de Goede * values after a reboot / power-cycle.
29909182ed2SHans de Goede *
30009182ed2SHans de Goede * The last 2 bytes are a 16 bits unsigned checksum which is expected
30109182ed2SHans de Goede * to make the addition al all 16 bit unsigned values in the array add
30209182ed2SHans de Goede * up to 1 (rather then the usual 0), so we must set the last byte to 1.
30309182ed2SHans de Goede */
30409182ed2SHans de Goede ts->bak_ref[ts->bak_ref_len - 1] = 1;
30509182ed2SHans de Goede
30609182ed2SHans de Goede return 0;
30709182ed2SHans de Goede }
30809182ed2SHans de Goede
goodix_send_main_clock(struct goodix_ts_data * ts)30909182ed2SHans de Goede static int goodix_send_main_clock(struct goodix_ts_data *ts)
31009182ed2SHans de Goede {
31109182ed2SHans de Goede u32 main_clk = 54; /* Default main clock */
31209182ed2SHans de Goede u8 checksum = 0;
31309182ed2SHans de Goede int i;
31409182ed2SHans de Goede
31509182ed2SHans de Goede device_property_read_u32(&ts->client->dev,
31609182ed2SHans de Goede "goodix,main-clk", &main_clk);
31709182ed2SHans de Goede
31809182ed2SHans de Goede for (i = 0; i < (GOODIX_MAIN_CLK_LEN - 1); i++) {
31909182ed2SHans de Goede ts->main_clk[i] = main_clk;
32009182ed2SHans de Goede checksum += main_clk;
32109182ed2SHans de Goede }
32209182ed2SHans de Goede
32309182ed2SHans de Goede /* The value of all bytes combines must be 0 */
32409182ed2SHans de Goede ts->main_clk[GOODIX_MAIN_CLK_LEN - 1] = 256 - checksum;
32509182ed2SHans de Goede
32609182ed2SHans de Goede return goodix_i2c_write(ts->client, GOODIX_REG_MAIN_CLK,
32709182ed2SHans de Goede ts->main_clk, GOODIX_MAIN_CLK_LEN);
32809182ed2SHans de Goede }
32909182ed2SHans de Goede
goodix_firmware_check(struct goodix_ts_data * ts)33009182ed2SHans de Goede int goodix_firmware_check(struct goodix_ts_data *ts)
33109182ed2SHans de Goede {
33209182ed2SHans de Goede device_property_read_string(&ts->client->dev,
33309182ed2SHans de Goede "firmware-name", &ts->firmware_name);
33409182ed2SHans de Goede if (!ts->firmware_name)
33509182ed2SHans de Goede return 0;
33609182ed2SHans de Goede
33709182ed2SHans de Goede if (ts->irq_pin_access_method == IRQ_PIN_ACCESS_NONE) {
33809182ed2SHans de Goede dev_err(&ts->client->dev, "Error no IRQ-pin access method, cannot upload fw.\n");
33909182ed2SHans de Goede return -EINVAL;
34009182ed2SHans de Goede }
34109182ed2SHans de Goede
34209182ed2SHans de Goede dev_info(&ts->client->dev, "Touchscreen controller needs fw-upload\n");
34309182ed2SHans de Goede ts->load_cfg_from_disk = true;
34409182ed2SHans de Goede
34509182ed2SHans de Goede return goodix_firmware_upload(ts);
34609182ed2SHans de Goede }
34709182ed2SHans de Goede
goodix_handle_fw_request(struct goodix_ts_data * ts)34809182ed2SHans de Goede bool goodix_handle_fw_request(struct goodix_ts_data *ts)
34909182ed2SHans de Goede {
35009182ed2SHans de Goede int error;
35109182ed2SHans de Goede u8 val;
35209182ed2SHans de Goede
35309182ed2SHans de Goede error = goodix_i2c_read(ts->client, GOODIX_REG_REQUEST, &val, 1);
35409182ed2SHans de Goede if (error)
35509182ed2SHans de Goede return false;
35609182ed2SHans de Goede
35709182ed2SHans de Goede switch (val) {
35809182ed2SHans de Goede case GOODIX_RQST_RESPONDED:
35909182ed2SHans de Goede /*
36009182ed2SHans de Goede * If we read back our own last ack the IRQ was not for
36109182ed2SHans de Goede * a request.
36209182ed2SHans de Goede */
36309182ed2SHans de Goede return false;
36409182ed2SHans de Goede case GOODIX_RQST_CONFIG:
36509182ed2SHans de Goede error = goodix_send_cfg(ts, ts->config, ts->chip->config_len);
36609182ed2SHans de Goede if (error)
36709182ed2SHans de Goede return false;
36809182ed2SHans de Goede
36909182ed2SHans de Goede break;
37009182ed2SHans de Goede case GOODIX_RQST_BAK_REF:
37109182ed2SHans de Goede error = goodix_prepare_bak_ref(ts);
37209182ed2SHans de Goede if (error)
37309182ed2SHans de Goede return false;
37409182ed2SHans de Goede
37509182ed2SHans de Goede error = goodix_i2c_write(ts->client, GOODIX_REG_BAK_REF,
37609182ed2SHans de Goede ts->bak_ref, ts->bak_ref_len);
37709182ed2SHans de Goede if (error)
37809182ed2SHans de Goede return false;
37909182ed2SHans de Goede
38009182ed2SHans de Goede break;
38109182ed2SHans de Goede case GOODIX_RQST_RESET:
38209182ed2SHans de Goede error = goodix_firmware_upload(ts);
38309182ed2SHans de Goede if (error)
38409182ed2SHans de Goede return false;
38509182ed2SHans de Goede
38609182ed2SHans de Goede break;
38709182ed2SHans de Goede case GOODIX_RQST_MAIN_CLOCK:
38809182ed2SHans de Goede error = goodix_send_main_clock(ts);
38909182ed2SHans de Goede if (error)
39009182ed2SHans de Goede return false;
39109182ed2SHans de Goede
39209182ed2SHans de Goede break;
39309182ed2SHans de Goede case GOODIX_RQST_UNKNOWN:
39409182ed2SHans de Goede case GOODIX_RQST_IDLE:
39509182ed2SHans de Goede break;
39609182ed2SHans de Goede default:
39709182ed2SHans de Goede dev_err_ratelimited(&ts->client->dev, "Unknown Request: 0x%02x\n", val);
39809182ed2SHans de Goede }
39909182ed2SHans de Goede
40009182ed2SHans de Goede /* Ack the request */
40109182ed2SHans de Goede goodix_i2c_write_u8(ts->client,
40209182ed2SHans de Goede GOODIX_REG_REQUEST, GOODIX_RQST_RESPONDED);
40309182ed2SHans de Goede return true;
40409182ed2SHans de Goede }
40509182ed2SHans de Goede
goodix_save_bak_ref(struct goodix_ts_data * ts)40609182ed2SHans de Goede void goodix_save_bak_ref(struct goodix_ts_data *ts)
40709182ed2SHans de Goede {
40809182ed2SHans de Goede int error;
40909182ed2SHans de Goede u8 val;
41009182ed2SHans de Goede
41109182ed2SHans de Goede if (!ts->firmware_name)
41209182ed2SHans de Goede return;
41309182ed2SHans de Goede
41409182ed2SHans de Goede error = goodix_i2c_read(ts->client, GOODIX_REG_STATUS, &val, 1);
41509182ed2SHans de Goede if (error)
41609182ed2SHans de Goede return;
41709182ed2SHans de Goede
41809182ed2SHans de Goede if (!(val & 0x80))
41909182ed2SHans de Goede return;
42009182ed2SHans de Goede
42109182ed2SHans de Goede error = goodix_i2c_read(ts->client, GOODIX_REG_BAK_REF,
42209182ed2SHans de Goede ts->bak_ref, ts->bak_ref_len);
42309182ed2SHans de Goede if (error) {
42409182ed2SHans de Goede memset(ts->bak_ref, 0, ts->bak_ref_len);
42509182ed2SHans de Goede ts->bak_ref[ts->bak_ref_len - 1] = 1;
42609182ed2SHans de Goede }
42709182ed2SHans de Goede }
428