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