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