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