projects/linux·blob master · refs

428 lines · 10.3 KiB

1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Goodix Touchscreen firmware upload support
4 *
5 * Copyright (c) 2021 Hans de Goede <[email protected]>
6 *
7 * This is a rewrite of gt9xx_update.c from the Allwinner H3 BSP which is:
8 * Copyright (c) 2010 - 2012 Goodix Technology.
9 * Author: [email protected]
10 */
11
12#include <linux/device.h>
13#include <linux/firmware.h>
14#include <linux/i2c.h>
15#include "goodix.h"
16
17#define GOODIX_FW_HEADER_LENGTH sizeof(struct goodix_fw_header)
18#define GOODIX_FW_SECTION_LENGTH 0x2000
19#define GOODIX_FW_DSP_LENGTH 0x1000
20#define GOODIX_FW_UPLOAD_ADDRESS 0xc000
21
22#define GOODIX_CFG_LOC_HAVE_KEY 7
23#define GOODIX_CFG_LOC_DRVA_NUM 27
24#define GOODIX_CFG_LOC_DRVB_NUM 28
25#define GOODIX_CFG_LOC_SENS_NUM 29
26
27struct goodix_fw_header {
28 u8 hw_info[4];
29 u8 pid[8];
30 u8 vid[2];
31} __packed;
32
33static u16 goodix_firmware_checksum(const u8 *data, int size)
34{
35 u16 checksum = 0;
36 int i;
37
38 for (i = 0; i < size; i += 2)
39 checksum += (data[i] << 8) + data[i + 1];
40
41 return checksum;
42}
43
44static int goodix_firmware_verify(struct device *dev, const struct firmware *fw)
45{
46 const struct goodix_fw_header *fw_header;
47 size_t expected_size;
48 const u8 *data;
49 u16 checksum;
50 char buf[9];
51
52 expected_size = GOODIX_FW_HEADER_LENGTH + 4 * GOODIX_FW_SECTION_LENGTH +
53 GOODIX_FW_DSP_LENGTH;
54 if (fw->size != expected_size) {
55 dev_err(dev, "Firmware has wrong size, expected %zu got %zu\n",
56 expected_size, fw->size);
57 return -EINVAL;
58 }
59
60 data = fw->data + GOODIX_FW_HEADER_LENGTH;
61 checksum = goodix_firmware_checksum(data, 4 * GOODIX_FW_SECTION_LENGTH);
62 if (checksum) {
63 dev_err(dev, "Main firmware checksum error\n");
64 return -EINVAL;
65 }
66
67 data += 4 * GOODIX_FW_SECTION_LENGTH;
68 checksum = goodix_firmware_checksum(data, GOODIX_FW_DSP_LENGTH);
69 if (checksum) {
70 dev_err(dev, "DSP firmware checksum error\n");
71 return -EINVAL;
72 }
73
74 fw_header = (const struct goodix_fw_header *)fw->data;
75 dev_info(dev, "Firmware hardware info %02x%02x%02x%02x\n",
76 fw_header->hw_info[0], fw_header->hw_info[1],
77 fw_header->hw_info[2], fw_header->hw_info[3]);
78 /* pid is a 8 byte buffer containing a string, weird I know */
79 memcpy(buf, fw_header->pid, 8);
80 buf[8] = 0;
81 dev_info(dev, "Firmware PID: %s VID: %02x%02x\n", buf,
82 fw_header->vid[0], fw_header->vid[1]);
83 return 0;
84}
85
86static int goodix_enter_upload_mode(struct i2c_client *client)
87{
88 int tries, error;
89 u8 val;
90
91 tries = 200;
92 do {
93 error = goodix_i2c_write_u8(client,
94 GOODIX_REG_MISCTL_SWRST, 0x0c);
95 if (error)
96 return error;
97
98 error = goodix_i2c_read(client,
99 GOODIX_REG_MISCTL_SWRST, &val, 1);
100 if (error)
101 return error;
102
103 if (val == 0x0c)
104 break;
105 } while (--tries);
106
107 if (!tries) {
108 dev_err(&client->dev, "Error could not hold ss51 & dsp\n");
109 return -EIO;
110 }
111
112 /* DSP_CK and DSP_ALU_CK PowerOn */
113 error = goodix_i2c_write_u8(client, GOODIX_REG_MISCTL_DSP_CTL, 0x00);
114 if (error)
115 return error;
116
117 /* Disable watchdog */
118 error = goodix_i2c_write_u8(client, GOODIX_REG_MISCTL_TMR0_EN, 0x00);
119 if (error)
120 return error;
121
122 /* Clear cache enable */
123 error = goodix_i2c_write_u8(client, GOODIX_REG_MISCTL_CACHE_EN, 0x00);
124 if (error)
125 return error;
126
127 /* Set boot from SRAM */
128 error = goodix_i2c_write_u8(client, GOODIX_REG_MISCTL_BOOTCTL, 0x02);
129 if (error)
130 return error;
131
132 /* Software reboot */
133 error = goodix_i2c_write_u8(client,
134 GOODIX_REG_MISCTL_CPU_SWRST_PULSE, 0x01);
135 if (error)
136 return error;
137
138 /* Clear control flag */
139 error = goodix_i2c_write_u8(client, GOODIX_REG_MISCTL_BOOTCTL, 0x00);
140 if (error)
141 return error;
142
143 /* Set scramble */
144 error = goodix_i2c_write_u8(client, GOODIX_REG_MISCTL_BOOT_OPT, 0x00);
145 if (error)
146 return error;
147
148 /* Enable accessing code */
149 error = goodix_i2c_write_u8(client, GOODIX_REG_MISCTL_MEM_CD_EN, 0x01);
150 if (error)
151 return error;
152
153 return 0;
154}
155
156static int goodix_start_firmware(struct i2c_client *client)
157{
158 int error;
159 u8 val;
160
161 /* Init software watchdog */
162 error = goodix_i2c_write_u8(client, GOODIX_REG_SW_WDT, 0xaa);
163 if (error)
164 return error;
165
166 /* Release SS51 & DSP */
167 error = goodix_i2c_write_u8(client, GOODIX_REG_MISCTL_SWRST, 0x00);
168 if (error)
169 return error;
170
171 error = goodix_i2c_read(client, GOODIX_REG_SW_WDT, &val, 1);
172 if (error)
173 return error;
174
175 /* The value we've written to SW_WDT should have been cleared now */
176 if (val == 0xaa) {
177 dev_err(&client->dev, "Error SW_WDT reg not cleared on fw startup\n");
178 return -EIO;
179 }
180
181 /* Re-init software watchdog */
182 error = goodix_i2c_write_u8(client, GOODIX_REG_SW_WDT, 0xaa);
183 if (error)
184 return error;
185
186 return 0;
187}
188
189static int goodix_firmware_upload(struct goodix_ts_data *ts)
190{
191 char fw_name[64];
192 const u8 *data;
193 int error;
194
195 snprintf(fw_name, sizeof(fw_name), "goodix/%s", ts->firmware_name);
196
197 const struct firmware *fw __free(firmware) = NULL;
198 error = request_firmware(&fw, fw_name, &ts->client->dev);
199 if (error) {
200 dev_err(&ts->client->dev, "Firmware request error %d\n", error);
201 return error;
202 }
203
204 error = goodix_firmware_verify(&ts->client->dev, fw);
205 if (error)
206 return error;
207
208 error = goodix_reset_no_int_sync(ts);
209 if (error)
210 return error;
211
212 error = goodix_enter_upload_mode(ts->client);
213 if (error)
214 return error;
215
216 /* Select SRAM bank 0 and upload section 1 & 2 */
217 error = goodix_i2c_write_u8(ts->client,
218 GOODIX_REG_MISCTL_SRAM_BANK, 0x00);
219 if (error)
220 return error;
221
222 data = fw->data + GOODIX_FW_HEADER_LENGTH;
223 error = goodix_i2c_write(ts->client, GOODIX_FW_UPLOAD_ADDRESS,
224 data, 2 * GOODIX_FW_SECTION_LENGTH);
225 if (error)
226 return error;
227
228 /* Select SRAM bank 1 and upload section 3 & 4 */
229 error = goodix_i2c_write_u8(ts->client,
230 GOODIX_REG_MISCTL_SRAM_BANK, 0x01);
231 if (error)
232 return error;
233
234 data += 2 * GOODIX_FW_SECTION_LENGTH;
235 error = goodix_i2c_write(ts->client, GOODIX_FW_UPLOAD_ADDRESS,
236 data, 2 * GOODIX_FW_SECTION_LENGTH);
237 if (error)
238 return error;
239
240 /* Select SRAM bank 2 and upload the DSP firmware */
241 error = goodix_i2c_write_u8(ts->client,
242 GOODIX_REG_MISCTL_SRAM_BANK, 0x02);
243 if (error)
244 return error;
245
246 data += 2 * GOODIX_FW_SECTION_LENGTH;
247 error = goodix_i2c_write(ts->client, GOODIX_FW_UPLOAD_ADDRESS,
248 data, GOODIX_FW_DSP_LENGTH);
249 if (error)
250 return error;
251
252 error = goodix_start_firmware(ts->client);
253 if (error)
254 return error;
255
256 error = goodix_int_sync(ts);
257 if (error)
258 return error;
259
260 return 0;
261}
262
263static int goodix_prepare_bak_ref(struct goodix_ts_data *ts)
264{
265 u8 have_key, driver_num, sensor_num;
266
267 if (ts->bak_ref)
268 return 0; /* Already done */
269
270 have_key = (ts->config[GOODIX_CFG_LOC_HAVE_KEY] & 0x01);
271
272 driver_num = (ts->config[GOODIX_CFG_LOC_DRVA_NUM] & 0x1f) +
273 (ts->config[GOODIX_CFG_LOC_DRVB_NUM] & 0x1f);
274 if (have_key)
275 driver_num--;
276
277 sensor_num = (ts->config[GOODIX_CFG_LOC_SENS_NUM] & 0x0f) +
278 ((ts->config[GOODIX_CFG_LOC_SENS_NUM] >> 4) & 0x0f);
279
280 dev_dbg(&ts->client->dev, "Drv %d Sen %d Key %d\n",
281 driver_num, sensor_num, have_key);
282
283 ts->bak_ref_len = (driver_num * (sensor_num - 2) + 2) * 2;
284
285 ts->bak_ref = devm_kzalloc(&ts->client->dev,
286 ts->bak_ref_len, GFP_KERNEL);
287 if (!ts->bak_ref)
288 return -ENOMEM;
289
290 /*
291 * The bak_ref array contains the backup of an array of (self/auto)
292 * calibration related values which the Android version of the driver
293 * stores on the filesystem so that it can be restored after reboot.
294 * The mainline kernel never writes directly to the filesystem like
295 * this, we always start will all the values which give a correction
296 * factor in approx. the -20 - +20 range (in 2s complement) set to 0.
297 *
298 * Note the touchscreen works fine without restoring the reference
299 * values after a reboot / power-cycle.
300 *
301 * The last 2 bytes are a 16 bits unsigned checksum which is expected
302 * to make the addition al all 16 bit unsigned values in the array add
303 * up to 1 (rather then the usual 0), so we must set the last byte to 1.
304 */
305 ts->bak_ref[ts->bak_ref_len - 1] = 1;
306
307 return 0;
308}
309
310static int goodix_send_main_clock(struct goodix_ts_data *ts)
311{
312 u32 main_clk = 54; /* Default main clock */
313 u8 checksum = 0;
314 int i;
315
316 device_property_read_u32(&ts->client->dev,
317 "goodix,main-clk", &main_clk);
318
319 for (i = 0; i < (GOODIX_MAIN_CLK_LEN - 1); i++) {
320 ts->main_clk[i] = main_clk;
321 checksum += main_clk;
322 }
323
324 /* The value of all bytes combines must be 0 */
325 ts->main_clk[GOODIX_MAIN_CLK_LEN - 1] = 256 - checksum;
326
327 return goodix_i2c_write(ts->client, GOODIX_REG_MAIN_CLK,
328 ts->main_clk, GOODIX_MAIN_CLK_LEN);
329}
330
331int goodix_firmware_check(struct goodix_ts_data *ts)
332{
333 device_property_read_string(&ts->client->dev,
334 "firmware-name", &ts->firmware_name);
335 if (!ts->firmware_name)
336 return 0;
337
338 if (ts->irq_pin_access_method == IRQ_PIN_ACCESS_NONE) {
339 dev_err(&ts->client->dev, "Error no IRQ-pin access method, cannot upload fw.\n");
340 return -EINVAL;
341 }
342
343 dev_info(&ts->client->dev, "Touchscreen controller needs fw-upload\n");
344 ts->load_cfg_from_disk = true;
345
346 return goodix_firmware_upload(ts);
347}
348
349bool goodix_handle_fw_request(struct goodix_ts_data *ts)
350{
351 int error;
352 u8 val;
353
354 error = goodix_i2c_read(ts->client, GOODIX_REG_REQUEST, &val, 1);
355 if (error)
356 return false;
357
358 switch (val) {
359 case GOODIX_RQST_RESPONDED:
360 /*
361 * If we read back our own last ack the IRQ was not for
362 * a request.
363 */
364 return false;
365 case GOODIX_RQST_CONFIG:
366 error = goodix_send_cfg(ts, ts->config, ts->chip->config_len);
367 if (error)
368 return false;
369
370 break;
371 case GOODIX_RQST_BAK_REF:
372 error = goodix_prepare_bak_ref(ts);
373 if (error)
374 return false;
375
376 error = goodix_i2c_write(ts->client, GOODIX_REG_BAK_REF,
377 ts->bak_ref, ts->bak_ref_len);
378 if (error)
379 return false;
380
381 break;
382 case GOODIX_RQST_RESET:
383 error = goodix_firmware_upload(ts);
384 if (error)
385 return false;
386
387 break;
388 case GOODIX_RQST_MAIN_CLOCK:
389 error = goodix_send_main_clock(ts);
390 if (error)
391 return false;
392
393 break;
394 case GOODIX_RQST_UNKNOWN:
395 case GOODIX_RQST_IDLE:
396 break;
397 default:
398 dev_err_ratelimited(&ts->client->dev, "Unknown Request: 0x%02x\n", val);
399 }
400
401 /* Ack the request */
402 goodix_i2c_write_u8(ts->client,
403 GOODIX_REG_REQUEST, GOODIX_RQST_RESPONDED);
404 return true;
405}
406
407void goodix_save_bak_ref(struct goodix_ts_data *ts)
408{
409 int error;
410 u8 val;
411
412 if (!ts->firmware_name)
413 return;
414
415 error = goodix_i2c_read(ts->client, GOODIX_REG_STATUS, &val, 1);
416 if (error)
417 return;
418
419 if (!(val & 0x80))
420 return;
421
422 error = goodix_i2c_read(ts->client, GOODIX_REG_BAK_REF,
423 ts->bak_ref, ts->bak_ref_len);
424 if (error) {
425 memset(ts->bak_ref, 0, ts->bak_ref_len);
426 ts->bak_ref[ts->bak_ref_len - 1] = 1;
427 }
428}