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