1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Goodix Touchscreen firmware upload support 4 * 5 * Copyright (c) 2021 Hans de Goede <hdegoede@redhat.com> 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: andrew@goodix.com 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 27 struct goodix_fw_header { 28 u8 hw_info[4]; 29 u8 pid[8]; 30 u8 vid[2]; 31 } __packed; 32 33 static 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 44 static 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 86 static 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 156 static 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 189 static int goodix_firmware_upload(struct goodix_ts_data *ts) 190 { 191 const struct firmware *fw; 192 char fw_name[64]; 193 const u8 *data; 194 int error; 195 196 snprintf(fw_name, sizeof(fw_name), "goodix/%s", ts->firmware_name); 197 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 goto release; 207 208 error = goodix_reset_no_int_sync(ts); 209 if (error) 210 goto release; 211 212 error = goodix_enter_upload_mode(ts->client); 213 if (error) 214 goto release; 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 goto release; 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 goto release; 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 goto release; 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 goto release; 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 goto release; 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 goto release; 251 252 error = goodix_start_firmware(ts->client); 253 if (error) 254 goto release; 255 256 error = goodix_int_sync(ts); 257 release: 258 release_firmware(fw); 259 return error; 260 } 261 262 static int goodix_prepare_bak_ref(struct goodix_ts_data *ts) 263 { 264 u8 have_key, driver_num, sensor_num; 265 266 if (ts->bak_ref) 267 return 0; /* Already done */ 268 269 have_key = (ts->config[GOODIX_CFG_LOC_HAVE_KEY] & 0x01); 270 271 driver_num = (ts->config[GOODIX_CFG_LOC_DRVA_NUM] & 0x1f) + 272 (ts->config[GOODIX_CFG_LOC_DRVB_NUM] & 0x1f); 273 if (have_key) 274 driver_num--; 275 276 sensor_num = (ts->config[GOODIX_CFG_LOC_SENS_NUM] & 0x0f) + 277 ((ts->config[GOODIX_CFG_LOC_SENS_NUM] >> 4) & 0x0f); 278 279 dev_dbg(&ts->client->dev, "Drv %d Sen %d Key %d\n", 280 driver_num, sensor_num, have_key); 281 282 ts->bak_ref_len = (driver_num * (sensor_num - 2) + 2) * 2; 283 284 ts->bak_ref = devm_kzalloc(&ts->client->dev, 285 ts->bak_ref_len, GFP_KERNEL); 286 if (!ts->bak_ref) 287 return -ENOMEM; 288 289 /* 290 * The bak_ref array contains the backup of an array of (self/auto) 291 * calibration related values which the Android version of the driver 292 * stores on the filesystem so that it can be restored after reboot. 293 * The mainline kernel never writes directly to the filesystem like 294 * this, we always start will all the values which give a correction 295 * factor in approx. the -20 - +20 range (in 2s complement) set to 0. 296 * 297 * Note the touchscreen works fine without restoring the reference 298 * values after a reboot / power-cycle. 299 * 300 * The last 2 bytes are a 16 bits unsigned checksum which is expected 301 * to make the addition al all 16 bit unsigned values in the array add 302 * up to 1 (rather then the usual 0), so we must set the last byte to 1. 303 */ 304 ts->bak_ref[ts->bak_ref_len - 1] = 1; 305 306 return 0; 307 } 308 309 static int goodix_send_main_clock(struct goodix_ts_data *ts) 310 { 311 u32 main_clk = 54; /* Default main clock */ 312 u8 checksum = 0; 313 int i; 314 315 device_property_read_u32(&ts->client->dev, 316 "goodix,main-clk", &main_clk); 317 318 for (i = 0; i < (GOODIX_MAIN_CLK_LEN - 1); i++) { 319 ts->main_clk[i] = main_clk; 320 checksum += main_clk; 321 } 322 323 /* The value of all bytes combines must be 0 */ 324 ts->main_clk[GOODIX_MAIN_CLK_LEN - 1] = 256 - checksum; 325 326 return goodix_i2c_write(ts->client, GOODIX_REG_MAIN_CLK, 327 ts->main_clk, GOODIX_MAIN_CLK_LEN); 328 } 329 330 int goodix_firmware_check(struct goodix_ts_data *ts) 331 { 332 device_property_read_string(&ts->client->dev, 333 "firmware-name", &ts->firmware_name); 334 if (!ts->firmware_name) 335 return 0; 336 337 if (ts->irq_pin_access_method == IRQ_PIN_ACCESS_NONE) { 338 dev_err(&ts->client->dev, "Error no IRQ-pin access method, cannot upload fw.\n"); 339 return -EINVAL; 340 } 341 342 dev_info(&ts->client->dev, "Touchscreen controller needs fw-upload\n"); 343 ts->load_cfg_from_disk = true; 344 345 return goodix_firmware_upload(ts); 346 } 347 348 bool goodix_handle_fw_request(struct goodix_ts_data *ts) 349 { 350 int error; 351 u8 val; 352 353 error = goodix_i2c_read(ts->client, GOODIX_REG_REQUEST, &val, 1); 354 if (error) 355 return false; 356 357 switch (val) { 358 case GOODIX_RQST_RESPONDED: 359 /* 360 * If we read back our own last ack the IRQ was not for 361 * a request. 362 */ 363 return false; 364 case GOODIX_RQST_CONFIG: 365 error = goodix_send_cfg(ts, ts->config, ts->chip->config_len); 366 if (error) 367 return false; 368 369 break; 370 case GOODIX_RQST_BAK_REF: 371 error = goodix_prepare_bak_ref(ts); 372 if (error) 373 return false; 374 375 error = goodix_i2c_write(ts->client, GOODIX_REG_BAK_REF, 376 ts->bak_ref, ts->bak_ref_len); 377 if (error) 378 return false; 379 380 break; 381 case GOODIX_RQST_RESET: 382 error = goodix_firmware_upload(ts); 383 if (error) 384 return false; 385 386 break; 387 case GOODIX_RQST_MAIN_CLOCK: 388 error = goodix_send_main_clock(ts); 389 if (error) 390 return false; 391 392 break; 393 case GOODIX_RQST_UNKNOWN: 394 case GOODIX_RQST_IDLE: 395 break; 396 default: 397 dev_err_ratelimited(&ts->client->dev, "Unknown Request: 0x%02x\n", val); 398 } 399 400 /* Ack the request */ 401 goodix_i2c_write_u8(ts->client, 402 GOODIX_REG_REQUEST, GOODIX_RQST_RESPONDED); 403 return true; 404 } 405 406 void goodix_save_bak_ref(struct goodix_ts_data *ts) 407 { 408 int error; 409 u8 val; 410 411 if (!ts->firmware_name) 412 return; 413 414 error = goodix_i2c_read(ts->client, GOODIX_REG_STATUS, &val, 1); 415 if (error) 416 return; 417 418 if (!(val & 0x80)) 419 return; 420 421 error = goodix_i2c_read(ts->client, GOODIX_REG_BAK_REF, 422 ts->bak_ref, ts->bak_ref_len); 423 if (error) { 424 memset(ts->bak_ref, 0, ts->bak_ref_len); 425 ts->bak_ref[ts->bak_ref_len - 1] = 1; 426 } 427 } 428