1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (c) 2007-2016, Synaptics Incorporated 4 * Copyright (C) 2016 Zodiac Inflight Innovations 5 */ 6 7 #include "linux/device.h" 8 #include <linux/kernel.h> 9 #include <linux/rmi.h> 10 #include <linux/firmware.h> 11 #include <linux/unaligned.h> 12 #include <linux/bitops.h> 13 14 #include "rmi_driver.h" 15 #include "rmi_f34.h" 16 17 static int rmi_f34_write_bootloader_id(struct f34_data *f34) 18 { 19 struct rmi_function *fn = f34->fn; 20 struct rmi_device *rmi_dev = fn->rmi_dev; 21 u8 bootloader_id[F34_BOOTLOADER_ID_LEN]; 22 int ret; 23 24 ret = rmi_read_block(rmi_dev, fn->fd.query_base_addr, 25 bootloader_id, sizeof(bootloader_id)); 26 if (ret) { 27 dev_err(&fn->dev, "%s: Reading bootloader ID failed: %d\n", 28 __func__, ret); 29 return ret; 30 } 31 32 rmi_dbg(RMI_DEBUG_FN, &fn->dev, "%s: writing bootloader id '%c%c'\n", 33 __func__, bootloader_id[0], bootloader_id[1]); 34 35 ret = rmi_write_block(rmi_dev, 36 fn->fd.data_base_addr + F34_BLOCK_DATA_OFFSET, 37 bootloader_id, sizeof(bootloader_id)); 38 if (ret) { 39 dev_err(&fn->dev, "Failed to write bootloader ID: %d\n", ret); 40 return ret; 41 } 42 43 return 0; 44 } 45 46 static int rmi_f34_command(struct f34_data *f34, u8 command, 47 unsigned int timeout, bool write_bl_id) 48 { 49 struct rmi_function *fn = f34->fn; 50 struct rmi_device *rmi_dev = fn->rmi_dev; 51 int ret; 52 53 if (write_bl_id) { 54 ret = rmi_f34_write_bootloader_id(f34); 55 if (ret) 56 return ret; 57 } 58 59 init_completion(&f34->v5.cmd_done); 60 61 ret = rmi_read(rmi_dev, f34->v5.ctrl_address, &f34->v5.status); 62 if (ret) { 63 dev_err(&f34->fn->dev, 64 "%s: Failed to read cmd register: %d (command %#02x)\n", 65 __func__, ret, command); 66 return ret; 67 } 68 69 f34->v5.status |= command & 0x0f; 70 71 ret = rmi_write(rmi_dev, f34->v5.ctrl_address, f34->v5.status); 72 if (ret < 0) { 73 dev_err(&f34->fn->dev, 74 "Failed to write F34 command %#02x: %d\n", 75 command, ret); 76 return ret; 77 } 78 79 if (!wait_for_completion_timeout(&f34->v5.cmd_done, 80 msecs_to_jiffies(timeout))) { 81 82 ret = rmi_read(rmi_dev, f34->v5.ctrl_address, &f34->v5.status); 83 if (ret) { 84 dev_err(&f34->fn->dev, 85 "%s: cmd %#02x timed out: %d\n", 86 __func__, command, ret); 87 return ret; 88 } 89 90 if (f34->v5.status & 0x7f) { 91 dev_err(&f34->fn->dev, 92 "%s: cmd %#02x timed out, status: %#02x\n", 93 __func__, command, f34->v5.status); 94 return -ETIMEDOUT; 95 } 96 } 97 98 return 0; 99 } 100 101 static irqreturn_t rmi_f34_attention(int irq, void *ctx) 102 { 103 struct rmi_function *fn = ctx; 104 struct f34_data *f34 = dev_get_drvdata(&fn->dev); 105 int ret; 106 u8 status; 107 108 if (f34->bl_version == 5) { 109 ret = rmi_read(f34->fn->rmi_dev, f34->v5.ctrl_address, 110 &status); 111 rmi_dbg(RMI_DEBUG_FN, &fn->dev, "%s: status: %#02x, ret: %d\n", 112 __func__, status, ret); 113 114 if (!ret && !(status & 0x7f)) 115 complete(&f34->v5.cmd_done); 116 } else { 117 ret = rmi_read_block(f34->fn->rmi_dev, 118 f34->fn->fd.data_base_addr + 119 V7_COMMAND_OFFSET, 120 &status, sizeof(status)); 121 rmi_dbg(RMI_DEBUG_FN, &f34->fn->dev, "%s: cmd: %#02x, ret: %d\n", 122 __func__, status, ret); 123 124 if (!ret && status == CMD_V7_IDLE) 125 complete(&f34->v7.cmd_done); 126 } 127 128 return IRQ_HANDLED; 129 } 130 131 static int rmi_f34_write_blocks(struct f34_data *f34, const void *data, 132 int block_count, u8 command) 133 { 134 struct rmi_function *fn = f34->fn; 135 struct rmi_device *rmi_dev = fn->rmi_dev; 136 u16 address = fn->fd.data_base_addr + F34_BLOCK_DATA_OFFSET; 137 u8 start_address[] = { 0, 0 }; 138 int i; 139 int ret; 140 141 ret = rmi_write_block(rmi_dev, fn->fd.data_base_addr, 142 start_address, sizeof(start_address)); 143 if (ret) { 144 dev_err(&fn->dev, "Failed to write initial zeros: %d\n", ret); 145 return ret; 146 } 147 148 for (i = 0; i < block_count; i++) { 149 ret = rmi_write_block(rmi_dev, address, 150 data, f34->v5.block_size); 151 if (ret) { 152 dev_err(&fn->dev, 153 "failed to write block #%d: %d\n", i, ret); 154 return ret; 155 } 156 157 ret = rmi_f34_command(f34, command, F34_IDLE_WAIT_MS, false); 158 if (ret) { 159 dev_err(&fn->dev, 160 "Failed to write command for block #%d: %d\n", 161 i, ret); 162 return ret; 163 } 164 165 rmi_dbg(RMI_DEBUG_FN, &fn->dev, "wrote block %d of %d\n", 166 i + 1, block_count); 167 168 data += f34->v5.block_size; 169 f34->update_progress += f34->v5.block_size; 170 f34->update_status = (f34->update_progress * 100) / 171 f34->update_size; 172 } 173 174 return 0; 175 } 176 177 static int rmi_f34_write_firmware(struct f34_data *f34, const void *data) 178 { 179 return rmi_f34_write_blocks(f34, data, f34->v5.fw_blocks, 180 F34_WRITE_FW_BLOCK); 181 } 182 183 static int rmi_f34_write_config(struct f34_data *f34, const void *data) 184 { 185 return rmi_f34_write_blocks(f34, data, f34->v5.config_blocks, 186 F34_WRITE_CONFIG_BLOCK); 187 } 188 189 static int rmi_f34_enable_flash(struct f34_data *f34) 190 { 191 return rmi_f34_command(f34, F34_ENABLE_FLASH_PROG, 192 F34_ENABLE_WAIT_MS, true); 193 } 194 195 static int rmi_f34_flash_firmware(struct f34_data *f34, 196 const struct rmi_f34_firmware *syn_fw) 197 { 198 struct rmi_function *fn = f34->fn; 199 u32 image_size = le32_to_cpu(syn_fw->image_size); 200 u32 config_size = le32_to_cpu(syn_fw->config_size); 201 int ret; 202 203 f34->update_progress = 0; 204 f34->update_size = image_size + config_size; 205 206 if (image_size) { 207 dev_info(&fn->dev, "Erasing firmware...\n"); 208 ret = rmi_f34_command(f34, F34_ERASE_ALL, 209 F34_ERASE_WAIT_MS, true); 210 if (ret) 211 return ret; 212 213 dev_info(&fn->dev, "Writing firmware (%d bytes)...\n", 214 image_size); 215 ret = rmi_f34_write_firmware(f34, syn_fw->data); 216 if (ret) 217 return ret; 218 } 219 220 if (config_size) { 221 /* 222 * We only need to erase config if we haven't updated 223 * firmware. 224 */ 225 if (!image_size) { 226 dev_info(&fn->dev, "Erasing config...\n"); 227 ret = rmi_f34_command(f34, F34_ERASE_CONFIG, 228 F34_ERASE_WAIT_MS, true); 229 if (ret) 230 return ret; 231 } 232 233 dev_info(&fn->dev, "Writing config (%d bytes)...\n", 234 config_size); 235 ret = rmi_f34_write_config(f34, &syn_fw->data[image_size]); 236 if (ret) 237 return ret; 238 } 239 240 return 0; 241 } 242 243 static int rmi_f34_update_firmware(struct f34_data *f34, 244 const struct firmware *fw) 245 { 246 const struct rmi_f34_firmware *syn_fw = 247 (const struct rmi_f34_firmware *)fw->data; 248 u32 image_size = le32_to_cpu(syn_fw->image_size); 249 u32 config_size = le32_to_cpu(syn_fw->config_size); 250 251 BUILD_BUG_ON(offsetof(struct rmi_f34_firmware, data) != 252 F34_FW_IMAGE_OFFSET); 253 254 rmi_dbg(RMI_DEBUG_FN, &f34->fn->dev, 255 "FW size:%zd, checksum:%08x, image_size:%d, config_size:%d\n", 256 fw->size, 257 le32_to_cpu(syn_fw->checksum), 258 image_size, config_size); 259 260 rmi_dbg(RMI_DEBUG_FN, &f34->fn->dev, 261 "FW bootloader_id:%02x, product_id:%.*s, info: %02x%02x\n", 262 syn_fw->bootloader_version, 263 (int)sizeof(syn_fw->product_id), syn_fw->product_id, 264 syn_fw->product_info[0], syn_fw->product_info[1]); 265 266 if (image_size && image_size != f34->v5.fw_blocks * f34->v5.block_size) { 267 dev_err(&f34->fn->dev, 268 "Bad firmware image: fw size %d, expected %d\n", 269 image_size, f34->v5.fw_blocks * f34->v5.block_size); 270 return -EILSEQ; 271 } 272 273 if (config_size && 274 config_size != f34->v5.config_blocks * f34->v5.block_size) { 275 dev_err(&f34->fn->dev, 276 "Bad firmware image: config size %d, expected %d\n", 277 config_size, 278 f34->v5.config_blocks * f34->v5.block_size); 279 return -EILSEQ; 280 } 281 282 if (image_size && !config_size) { 283 dev_err(&f34->fn->dev, "Bad firmware image: no config data\n"); 284 return -EILSEQ; 285 } 286 287 dev_info(&f34->fn->dev, "Firmware image OK\n"); 288 289 guard(mutex)(&f34->v5.flash_mutex); 290 return rmi_f34_flash_firmware(f34, syn_fw); 291 } 292 293 static ssize_t rmi_driver_bootloader_id_show(struct device *dev, 294 struct device_attribute *dattr, 295 char *buf) 296 { 297 struct rmi_driver_data *data = dev_get_drvdata(dev); 298 struct rmi_function *fn; 299 struct f34_data *f34; 300 301 fn = data->f34_container; 302 if (!fn) 303 return -ENODEV; 304 305 f34 = dev_get_drvdata(&fn->dev); 306 if (!f34) 307 return -ENODEV; 308 309 if (f34->bl_version == 5) 310 return sysfs_emit(buf, "%c%c\n", 311 f34->bootloader_id[0], 312 f34->bootloader_id[1]); 313 else 314 return sysfs_emit(buf, "V%d.%d\n", 315 f34->bootloader_id[1], 316 f34->bootloader_id[0]); 317 } 318 319 static DEVICE_ATTR(bootloader_id, 0444, rmi_driver_bootloader_id_show, NULL); 320 321 static ssize_t rmi_driver_configuration_id_show(struct device *dev, 322 struct device_attribute *dattr, 323 char *buf) 324 { 325 struct rmi_driver_data *data = dev_get_drvdata(dev); 326 struct rmi_function *fn = data->f34_container; 327 struct f34_data *f34; 328 329 fn = data->f34_container; 330 if (!fn) 331 return -ENODEV; 332 333 f34 = dev_get_drvdata(&fn->dev); 334 if (!f34) 335 return -ENODEV; 336 337 338 return sysfs_emit(buf, "%s\n", f34->configuration_id); 339 } 340 341 static DEVICE_ATTR(configuration_id, 0444, 342 rmi_driver_configuration_id_show, NULL); 343 344 static int rmi_firmware_update(struct rmi_driver_data *data, 345 const struct firmware *fw) 346 { 347 struct rmi_device *rmi_dev = data->rmi_dev; 348 struct device *dev = &rmi_dev->dev; 349 struct f34_data *f34; 350 int ret; 351 352 if (!data->f34_container) { 353 dev_warn(dev, "%s: No F34 present!\n", __func__); 354 return -ENODEV; 355 } 356 357 f34 = dev_get_drvdata(&data->f34_container->dev); 358 if (!f34) { 359 dev_warn(dev, "%s: No valid F34 present!\n", __func__); 360 return -ENODEV; 361 } 362 363 if (f34->bl_version >= 7) { 364 if (data->pdt_props & HAS_BSR) { 365 dev_err(dev, "%s: LTS not supported\n", __func__); 366 return -ENODEV; 367 } 368 } else if (f34->bl_version != 5) { 369 dev_warn(dev, "F34 V%d not supported!\n", 370 data->f34_container->fd.function_version); 371 return -ENODEV; 372 } 373 374 /* Enter flash mode */ 375 if (f34->bl_version >= 7) 376 ret = rmi_f34v7_start_reflash(f34, fw); 377 else 378 ret = rmi_f34_enable_flash(f34); 379 if (ret) 380 return ret; 381 382 rmi_disable_irq(rmi_dev, false); 383 384 /* Tear down functions and re-probe */ 385 rmi_free_function_list(rmi_dev); 386 387 ret = rmi_probe_interrupts(data); 388 if (ret) 389 return ret; 390 391 ret = rmi_init_functions(data); 392 if (ret) 393 return ret; 394 395 if (!data->bootloader_mode || !data->f34_container) { 396 dev_warn(dev, "%s: No F34 present or not in bootloader!\n", 397 __func__); 398 return -EINVAL; 399 } 400 401 rmi_enable_irq(rmi_dev, false); 402 403 f34 = dev_get_drvdata(&data->f34_container->dev); 404 405 /* Perform firmware update */ 406 if (f34->bl_version >= 7) 407 ret = rmi_f34v7_do_reflash(f34, fw); 408 else 409 ret = rmi_f34_update_firmware(f34, fw); 410 411 if (ret) { 412 f34->update_status = ret; 413 dev_err(&f34->fn->dev, 414 "Firmware update failed, status: %d\n", ret); 415 } else { 416 dev_info(&f34->fn->dev, "Firmware update complete\n"); 417 } 418 419 rmi_disable_irq(rmi_dev, false); 420 421 /* Re-probe */ 422 rmi_dbg(RMI_DEBUG_FN, dev, "Re-probing device\n"); 423 rmi_free_function_list(rmi_dev); 424 425 ret = rmi_scan_pdt(rmi_dev, NULL, rmi_initial_reset); 426 if (ret < 0) 427 dev_warn(dev, "RMI reset failed!\n"); 428 429 ret = rmi_probe_interrupts(data); 430 if (ret) 431 return ret; 432 433 ret = rmi_init_functions(data); 434 if (ret) 435 return ret; 436 437 rmi_enable_irq(rmi_dev, false); 438 439 if (data->f01_container->dev.driver) 440 /* Driver already bound, so enable ATTN now. */ 441 return rmi_enable_sensor(rmi_dev); 442 443 rmi_dbg(RMI_DEBUG_FN, dev, "%s complete\n", __func__); 444 445 return ret; 446 } 447 448 static ssize_t rmi_driver_update_fw_store(struct device *dev, 449 struct device_attribute *dattr, 450 const char *buf, size_t count) 451 { 452 struct rmi_driver_data *data = dev_get_drvdata(dev); 453 char fw_name[NAME_MAX]; 454 size_t copy_count = count; 455 int error; 456 457 if (count == 0 || count >= NAME_MAX) 458 return -EINVAL; 459 460 if (buf[count - 1] == '\0' || buf[count - 1] == '\n') 461 copy_count -= 1; 462 463 memcpy(fw_name, buf, copy_count); 464 fw_name[copy_count] = '\0'; 465 466 const struct firmware *fw __free(firmware) = NULL; 467 error = request_firmware(&fw, fw_name, dev); 468 if (error) 469 return error; 470 471 dev_info(dev, "Flashing %s\n", fw_name); 472 473 error = rmi_firmware_update(data, fw); 474 if (error) 475 return error; 476 477 return count; 478 } 479 480 static DEVICE_ATTR(update_fw, 0200, NULL, rmi_driver_update_fw_store); 481 482 static ssize_t rmi_driver_update_fw_status_show(struct device *dev, 483 struct device_attribute *dattr, 484 char *buf) 485 { 486 struct rmi_driver_data *data = dev_get_drvdata(dev); 487 struct f34_data *f34; 488 int update_status = -ENODEV; 489 490 /* 491 * The status is the percentage complete, or once complete, 492 * zero for success or a negative return code. 493 */ 494 if (data->f34_container) { 495 f34 = dev_get_drvdata(&data->f34_container->dev); 496 if (f34) 497 update_status = f34->update_status; 498 } 499 500 return sysfs_emit(buf, "%d\n", update_status); 501 } 502 503 static DEVICE_ATTR(update_fw_status, 0444, 504 rmi_driver_update_fw_status_show, NULL); 505 506 static struct attribute *rmi_firmware_attrs[] = { 507 &dev_attr_bootloader_id.attr, 508 &dev_attr_configuration_id.attr, 509 &dev_attr_update_fw.attr, 510 &dev_attr_update_fw_status.attr, 511 NULL 512 }; 513 514 static const struct attribute_group rmi_firmware_attr_group = { 515 .attrs = rmi_firmware_attrs, 516 }; 517 518 static int rmi_f34v5_probe(struct f34_data *f34) 519 { 520 struct rmi_function *fn = f34->fn; 521 u8 f34_queries[9]; 522 bool has_config_id; 523 int error; 524 525 f34->bl_version = 5; 526 527 error = rmi_read_block(fn->rmi_dev, fn->fd.query_base_addr, 528 f34_queries, sizeof(f34_queries)); 529 if (error) { 530 dev_err(&fn->dev, "%s: Failed to query properties\n", 531 __func__); 532 return error; 533 } 534 535 snprintf(f34->bootloader_id, sizeof(f34->bootloader_id), 536 "%c%c", f34_queries[0], f34_queries[1]); 537 538 mutex_init(&f34->v5.flash_mutex); 539 init_completion(&f34->v5.cmd_done); 540 541 f34->v5.block_size = get_unaligned_le16(&f34_queries[3]); 542 f34->v5.fw_blocks = get_unaligned_le16(&f34_queries[5]); 543 f34->v5.config_blocks = get_unaligned_le16(&f34_queries[7]); 544 f34->v5.ctrl_address = fn->fd.data_base_addr + F34_BLOCK_DATA_OFFSET + 545 f34->v5.block_size; 546 has_config_id = f34_queries[2] & (1 << 2); 547 548 rmi_dbg(RMI_DEBUG_FN, &fn->dev, "Bootloader ID: %s\n", 549 f34->bootloader_id); 550 rmi_dbg(RMI_DEBUG_FN, &fn->dev, "Block size: %d\n", 551 f34->v5.block_size); 552 rmi_dbg(RMI_DEBUG_FN, &fn->dev, "FW blocks: %d\n", 553 f34->v5.fw_blocks); 554 rmi_dbg(RMI_DEBUG_FN, &fn->dev, "CFG blocks: %d\n", 555 f34->v5.config_blocks); 556 557 if (has_config_id) { 558 error = rmi_read_block(fn->rmi_dev, fn->fd.control_base_addr, 559 f34_queries, sizeof(f34_queries)); 560 if (error) { 561 dev_err(&fn->dev, "Failed to read F34 config ID\n"); 562 return error; 563 } 564 565 snprintf(f34->configuration_id, sizeof(f34->configuration_id), 566 "%02x%02x%02x%02x", 567 f34_queries[0], f34_queries[1], 568 f34_queries[2], f34_queries[3]); 569 570 rmi_dbg(RMI_DEBUG_FN, &fn->dev, "Configuration ID: %s\n", 571 f34->configuration_id); 572 } 573 574 return 0; 575 } 576 577 static int rmi_f34_probe(struct rmi_function *fn) 578 { 579 struct f34_data *f34; 580 u8 version = fn->fd.function_version; 581 int error; 582 583 f34 = devm_kzalloc(&fn->dev, sizeof(struct f34_data), GFP_KERNEL); 584 if (!f34) 585 return -ENOMEM; 586 587 f34->fn = fn; 588 589 /* v5 code only supported version 0 */ 590 error = version == 0 ? rmi_f34v5_probe(f34) : rmi_f34v7_probe(f34); 591 if (error) 592 return error; 593 594 dev_set_drvdata(&fn->dev, f34); 595 596 return 0; 597 } 598 599 int rmi_f34_create_sysfs(struct rmi_device *rmi_dev) 600 { 601 return sysfs_create_group(&rmi_dev->dev.kobj, &rmi_firmware_attr_group); 602 } 603 604 void rmi_f34_remove_sysfs(struct rmi_device *rmi_dev) 605 { 606 sysfs_remove_group(&rmi_dev->dev.kobj, &rmi_firmware_attr_group); 607 } 608 609 struct rmi_function_handler rmi_f34_handler = { 610 .driver = { 611 .name = "rmi4_f34", 612 }, 613 .func = 0x34, 614 .probe = rmi_f34_probe, 615 .attention = rmi_f34_attention, 616 }; 617