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