rmi_f34.c

  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 <linux/unaligned.h>
 12#include <linux/bitops.h>
 13
 14#include "rmi_driver.h"
 15#include "rmi_f34.h"
 16
 17static 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
 46static 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
101static 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
131static 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
177static 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
183static 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
189static 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
195static 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
243static 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
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		return -EILSEQ;
271	}
272
273	if (config_size &&
274	    config_size != f34->v5.config_blocks * f34->v5.block_size) {
275		dev_err(&f34->fn->dev,
276			"Bad firmware image: config size %d, expected %d\n",
277			config_size,
278			f34->v5.config_blocks * f34->v5.block_size);
279		return -EILSEQ;
280	}
281
282	if (image_size && !config_size) {
283		dev_err(&f34->fn->dev, "Bad firmware image: no config data\n");
284		return -EILSEQ;
285	}
286
287	dev_info(&f34->fn->dev, "Firmware image OK\n");
288
289	guard(mutex)(&f34->v5.flash_mutex);
290	return rmi_f34_flash_firmware(f34, syn_fw);
291}
292
293static ssize_t rmi_driver_bootloader_id_show(struct device *dev,
294					     struct device_attribute *dattr,
295					     char *buf)
296{
297	struct rmi_driver_data *data = dev_get_drvdata(dev);
298	struct rmi_function *fn;
299	struct f34_data *f34;
300
301	fn = data->f34_container;
302	if (!fn)
303		return -ENODEV;
304
305	f34 = dev_get_drvdata(&fn->dev);
306	if (!f34)
307		return -ENODEV;
308
309	if (f34->bl_version == 5)
310		return sysfs_emit(buf, "%c%c\n",
311				  f34->bootloader_id[0],
312				  f34->bootloader_id[1]);
313	else
314		return sysfs_emit(buf, "V%d.%d\n",
315				  f34->bootloader_id[1],
316				  f34->bootloader_id[0]);
317}
318
319static DEVICE_ATTR(bootloader_id, 0444, rmi_driver_bootloader_id_show, NULL);
320
321static ssize_t rmi_driver_configuration_id_show(struct device *dev,
322						struct device_attribute *dattr,
323						char *buf)
324{
325	struct rmi_driver_data *data = dev_get_drvdata(dev);
326	struct rmi_function *fn = data->f34_container;
327	struct f34_data *f34;
328
329	fn = data->f34_container;
330	if (!fn)
331		return -ENODEV;
332
333	f34 = dev_get_drvdata(&fn->dev);
334	if (!f34)
335		return -ENODEV;
336
337
338	return sysfs_emit(buf, "%s\n", f34->configuration_id);
339}
340
341static DEVICE_ATTR(configuration_id, 0444,
342		   rmi_driver_configuration_id_show, NULL);
343
344static int rmi_firmware_update(struct rmi_driver_data *data,
345			       const struct firmware *fw)
346{
347	struct rmi_device *rmi_dev = data->rmi_dev;
348	struct device *dev = &rmi_dev->dev;
349	struct f34_data *f34;
350	int ret;
351
352	if (!data->f34_container) {
353		dev_warn(dev, "%s: No F34 present!\n", __func__);
354		return -ENODEV;
355	}
356
357	f34 = dev_get_drvdata(&data->f34_container->dev);
358	if (!f34) {
359		dev_warn(dev, "%s: No valid F34 present!\n", __func__);
360		return -ENODEV;
361	}
362
363	if (f34->bl_version >= 7) {
364		if (data->pdt_props & HAS_BSR) {
365			dev_err(dev, "%s: LTS not supported\n", __func__);
366			return -ENODEV;
367		}
368	} else if (f34->bl_version != 5) {
369		dev_warn(dev, "F34 V%d not supported!\n",
370			 data->f34_container->fd.function_version);
371		return -ENODEV;
372	}
373
374	/* Enter flash mode */
375	if (f34->bl_version >= 7)
376		ret = rmi_f34v7_start_reflash(f34, fw);
377	else
378		ret = rmi_f34_enable_flash(f34);
379	if (ret)
380		return ret;
381
382	rmi_disable_irq(rmi_dev, false);
383
384	/* Tear down functions and re-probe */
385	rmi_free_function_list(rmi_dev);
386
387	ret = rmi_probe_interrupts(data);
388	if (ret)
389		return ret;
390
391	ret = rmi_init_functions(data);
392	if (ret)
393		return ret;
394
395	if (!data->bootloader_mode || !data->f34_container) {
396		dev_warn(dev, "%s: No F34 present or not in bootloader!\n",
397				__func__);
398		return -EINVAL;
399	}
400
401	rmi_enable_irq(rmi_dev, false);
402
403	f34 = dev_get_drvdata(&data->f34_container->dev);
404
405	/* Perform firmware update */
406	if (f34->bl_version >= 7)
407		ret = rmi_f34v7_do_reflash(f34, fw);
408	else
409		ret = rmi_f34_update_firmware(f34, fw);
410
411	if (ret) {
412		f34->update_status = ret;
413		dev_err(&f34->fn->dev,
414			"Firmware update failed, status: %d\n", ret);
415	} else {
416		dev_info(&f34->fn->dev, "Firmware update complete\n");
417	}
418
419	rmi_disable_irq(rmi_dev, false);
420
421	/* Re-probe */
422	rmi_dbg(RMI_DEBUG_FN, dev, "Re-probing device\n");
423	rmi_free_function_list(rmi_dev);
424
425	ret = rmi_scan_pdt(rmi_dev, NULL, rmi_initial_reset);
426	if (ret < 0)
427		dev_warn(dev, "RMI reset failed!\n");
428
429	ret = rmi_probe_interrupts(data);
430	if (ret)
431		return ret;
432
433	ret = rmi_init_functions(data);
434	if (ret)
435		return ret;
436
437	rmi_enable_irq(rmi_dev, false);
438
439	if (data->f01_container->dev.driver)
440		/* Driver already bound, so enable ATTN now. */
441		return rmi_enable_sensor(rmi_dev);
442
443	rmi_dbg(RMI_DEBUG_FN, dev, "%s complete\n", __func__);
444
445	return ret;
446}
447
448static ssize_t rmi_driver_update_fw_store(struct device *dev,
449					  struct device_attribute *dattr,
450					  const char *buf, size_t count)
451{
452	struct rmi_driver_data *data = dev_get_drvdata(dev);
453	char fw_name[NAME_MAX];
454	size_t copy_count = count;
455	int error;
456
457	if (count == 0 || count >= NAME_MAX)
458		return -EINVAL;
459
460	if (buf[count - 1] == '\0' || buf[count - 1] == '\n')
461		copy_count -= 1;
462
463	memcpy(fw_name, buf, copy_count);
464	fw_name[copy_count] = '\0';
465
466	const struct firmware *fw __free(firmware) = NULL;
467	error = request_firmware(&fw, fw_name, dev);
468	if (error)
469		return error;
470
471	dev_info(dev, "Flashing %s\n", fw_name);
472
473	error = rmi_firmware_update(data, fw);
474	if (error)
475		return error;
476
477	return count;
478}
479
480static DEVICE_ATTR(update_fw, 0200, NULL, rmi_driver_update_fw_store);
481
482static ssize_t rmi_driver_update_fw_status_show(struct device *dev,
483						struct device_attribute *dattr,
484						char *buf)
485{
486	struct rmi_driver_data *data = dev_get_drvdata(dev);
487	struct f34_data *f34;
488	int update_status = -ENODEV;
489
490	/*
491	 * The status is the percentage complete, or once complete,
492	 * zero for success or a negative return code.
493	 */
494	if (data->f34_container) {
495		f34 = dev_get_drvdata(&data->f34_container->dev);
496		if (f34)
497			update_status = f34->update_status;
498	}
499
500	return sysfs_emit(buf, "%d\n", update_status);
501}
502
503static DEVICE_ATTR(update_fw_status, 0444,
504		   rmi_driver_update_fw_status_show, NULL);
505
506static struct attribute *rmi_firmware_attrs[] = {
507	&dev_attr_bootloader_id.attr,
508	&dev_attr_configuration_id.attr,
509	&dev_attr_update_fw.attr,
510	&dev_attr_update_fw_status.attr,
511	NULL
512};
513
514static const struct attribute_group rmi_firmware_attr_group = {
515	.attrs = rmi_firmware_attrs,
516};
517
518static int rmi_f34v5_probe(struct f34_data *f34)
519{
520	struct rmi_function *fn = f34->fn;
521	u8 f34_queries[9];
522	bool has_config_id;
523	int error;
524
525	f34->bl_version = 5;
526
527	error = rmi_read_block(fn->rmi_dev, fn->fd.query_base_addr,
528			       f34_queries, sizeof(f34_queries));
529	if (error) {
530		dev_err(&fn->dev, "%s: Failed to query properties\n",
531			__func__);
532		return error;
533	}
534
535	snprintf(f34->bootloader_id, sizeof(f34->bootloader_id),
536		 "%c%c", f34_queries[0], f34_queries[1]);
537
538	mutex_init(&f34->v5.flash_mutex);
539	init_completion(&f34->v5.cmd_done);
540
541	f34->v5.block_size = get_unaligned_le16(&f34_queries[3]);
542	f34->v5.fw_blocks = get_unaligned_le16(&f34_queries[5]);
543	f34->v5.config_blocks = get_unaligned_le16(&f34_queries[7]);
544	f34->v5.ctrl_address = fn->fd.data_base_addr + F34_BLOCK_DATA_OFFSET +
545		f34->v5.block_size;
546	has_config_id = f34_queries[2] & (1 << 2);
547
548	rmi_dbg(RMI_DEBUG_FN, &fn->dev, "Bootloader ID: %s\n",
549		f34->bootloader_id);
550	rmi_dbg(RMI_DEBUG_FN, &fn->dev, "Block size: %d\n",
551		f34->v5.block_size);
552	rmi_dbg(RMI_DEBUG_FN, &fn->dev, "FW blocks: %d\n",
553		f34->v5.fw_blocks);
554	rmi_dbg(RMI_DEBUG_FN, &fn->dev, "CFG blocks: %d\n",
555		f34->v5.config_blocks);
556
557	if (has_config_id) {
558		error = rmi_read_block(fn->rmi_dev, fn->fd.control_base_addr,
559				       f34_queries, sizeof(f34_queries));
560		if (error) {
561			dev_err(&fn->dev, "Failed to read F34 config ID\n");
562			return error;
563		}
564
565		snprintf(f34->configuration_id, sizeof(f34->configuration_id),
566			 "%02x%02x%02x%02x",
567			 f34_queries[0], f34_queries[1],
568			 f34_queries[2], f34_queries[3]);
569
570		rmi_dbg(RMI_DEBUG_FN, &fn->dev, "Configuration ID: %s\n",
571			f34->configuration_id);
572	}
573
574	return 0;
575}
576
577static int rmi_f34_probe(struct rmi_function *fn)
578{
579	struct f34_data *f34;
580	u8 version = fn->fd.function_version;
581	int error;
582
583	f34 = devm_kzalloc(&fn->dev, sizeof(struct f34_data), GFP_KERNEL);
584	if (!f34)
585		return -ENOMEM;
586
587	f34->fn = fn;
588
589	/* v5 code only supported version 0 */
590	error = version == 0 ? rmi_f34v5_probe(f34) : rmi_f34v7_probe(f34);
591	if (error)
592		return error;
593
594	dev_set_drvdata(&fn->dev, f34);
595
596	return 0;
597}
598
599int rmi_f34_create_sysfs(struct rmi_device *rmi_dev)
600{
601	return sysfs_create_group(&rmi_dev->dev.kobj, &rmi_firmware_attr_group);
602}
603
604void rmi_f34_remove_sysfs(struct rmi_device *rmi_dev)
605{
606	sysfs_remove_group(&rmi_dev->dev.kobj, &rmi_firmware_attr_group);
607}
608
609struct rmi_function_handler rmi_f34_handler = {
610	.driver = {
611		.name = "rmi4_f34",
612	},
613	.func = 0x34,
614	.probe = rmi_f34_probe,
615	.attention = rmi_f34_attention,
616};