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
19static 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
48static 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
103static 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
133static 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
179static 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
185static 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
191static 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
197static 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
245static 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
300out:
301 return ret;
302}
303
304static 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
315static 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
339static DEVICE_ATTR(bootloader_id, 0444, rmi_driver_bootloader_id_show, NULL);
340
341static 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
358static DEVICE_ATTR(configuration_id, 0444,
359 rmi_driver_configuration_id_show, NULL);
360
361static 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
461static 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
493static DEVICE_ATTR(update_fw, 0200, NULL, rmi_driver_update_fw_store);
494
495static 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
508static DEVICE_ATTR(update_fw_status, 0444,
509 rmi_driver_update_fw_status_show, NULL);
510
511static 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
519static const struct attribute_group rmi_firmware_attr_group = {
520 .attrs = rmi_firmware_attrs,
521};
522
523static 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
594int 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
599void rmi_f34_remove_sysfs(struct rmi_device *rmi_dev)
600{
601 sysfs_remove_group(&rmi_dev->dev.kobj, &rmi_firmware_attr_group);
602}
603
604struct 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