xref: /openbmc/linux/drivers/input/rmi4/rmi_f34.c (revision 44ad3baf1cca483e418b6aadf2d3994f69e0f16a)
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