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