drivers/input/rmi4/rmi_f34.c

   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 <linux/bitops.h>
  15
  16 #include "rmi_driver.h"
  17 #include "rmi_f34.h"
  18
  19 static int rmi_f34_write_bootloader_id(struct f34_data *f34)
  20 {
  21         struct rmi_function *fn = f34->fn;
  22         struct rmi_device *rmi_dev = fn->rmi_dev;
  23         u8 bootloader_id[F34_BOOTLOADER_ID_LEN];
  24         int ret;
  25
  26         ret = rmi_read_block(rmi_dev, fn->fd.query_base_addr,
  27                              bootloader_id, sizeof(bootloader_id));
  28         if (ret) {
  29                 dev_err(&fn->dev, "%s: Reading bootloader ID failed: %d\n",
  30                                 __func__, ret);
  31                 return ret;
  32         }
  33
  34         rmi_dbg(RMI_DEBUG_FN, &fn->dev, "%s: writing bootloader id '%c%c'\n",
  35                         __func__, bootloader_id[0], bootloader_id[1]);
  36
  37         ret = rmi_write_block(rmi_dev,
  38                               fn->fd.data_base_addr + F34_BLOCK_DATA_OFFSET,
  39                               bootloader_id, sizeof(bootloader_id));
  40         if (ret) {
  41                 dev_err(&fn->dev, "Failed to write bootloader ID: %d\n", ret);
  42                 return ret;
  43         }
  44
  45         return 0;
  46 }
  47
  48 static int rmi_f34_command(struct f34_data *f34, u8 command,
  49                            unsigned int timeout, bool write_bl_id)
  50 {
  51         struct rmi_function *fn = f34->fn;
  52         struct rmi_device *rmi_dev = fn->rmi_dev;
  53         int ret;
  54
  55         if (write_bl_id) {
  56                 ret = rmi_f34_write_bootloader_id(f34);
  57                 if (ret)
  58                         return ret;
  59         }
  60
  61         init_completion(&f34->v5.cmd_done);
  62
  63         ret = rmi_read(rmi_dev, f34->v5.ctrl_address, &f34->v5.status);
  64         if (ret) {
  65                 dev_err(&f34->fn->dev,
  66                         "%s: Failed to read cmd register: %d (command %#02x)\n",
  67                         __func__, ret, command);
  68                 return ret;
  69         }
  70
  71         f34->v5.status |= command & 0x0f;
  72
  73         ret = rmi_write(rmi_dev, f34->v5.ctrl_address, f34->v5.status);
  74         if (ret < 0) {
  75                 dev_err(&f34->fn->dev,
  76                         "Failed to write F34 command %#02x: %d\n",
  77                         command, ret);
  78                 return ret;
  79         }
  80
  81         if (!wait_for_completion_timeout(&f34->v5.cmd_done,
  82                                 msecs_to_jiffies(timeout))) {
  83
  84                 ret = rmi_read(rmi_dev, f34->v5.ctrl_address, &f34->v5.status);
  85                 if (ret) {
  86                         dev_err(&f34->fn->dev,
  87                                 "%s: cmd %#02x timed out: %d\n",
  88                                 __func__, command, ret);
  89                         return ret;
  90                 }
  91
  92                 if (f34->v5.status & 0x7f) {
  93                         dev_err(&f34->fn->dev,
  94                                 "%s: cmd %#02x timed out, status: %#02x\n",
  95                                 __func__, command, f34->v5.status);
  96                         return -ETIMEDOUT;
  97                 }
  98         }
  99
 100         return 0;
 101 }
 102
 103 static irqreturn_t rmi_f34_attention(int irq, void *ctx)
 104 {
 105         struct rmi_function *fn = ctx;
 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 IRQ_HANDLED;
 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 const 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 };