1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Turris Mox rWTM firmware driver
4  *
5  * Copyright (C) 2019 Marek Behún <kabel@kernel.org>
6  */
7 
8 #include <linux/armada-37xx-rwtm-mailbox.h>
9 #include <linux/completion.h>
10 #include <linux/debugfs.h>
11 #include <linux/dma-mapping.h>
12 #include <linux/hw_random.h>
13 #include <linux/mailbox_client.h>
14 #include <linux/module.h>
15 #include <linux/mutex.h>
16 #include <linux/of.h>
17 #include <linux/platform_device.h>
18 #include <linux/slab.h>
19 
20 #define DRIVER_NAME		"turris-mox-rwtm"
21 
22 /*
23  * The macros and constants below come from Turris Mox's rWTM firmware code.
24  * This firmware is open source and it's sources can be found at
25  * https://gitlab.labs.nic.cz/turris/mox-boot-builder/tree/master/wtmi.
26  */
27 
28 #define MBOX_STS_SUCCESS	(0 << 30)
29 #define MBOX_STS_FAIL		(1 << 30)
30 #define MBOX_STS_BADCMD		(2 << 30)
31 #define MBOX_STS_ERROR(s)	((s) & (3 << 30))
32 #define MBOX_STS_VALUE(s)	(((s) >> 10) & 0xfffff)
33 #define MBOX_STS_CMD(s)		((s) & 0x3ff)
34 
35 enum mbox_cmd {
36 	MBOX_CMD_GET_RANDOM	= 1,
37 	MBOX_CMD_BOARD_INFO	= 2,
38 	MBOX_CMD_ECDSA_PUB_KEY	= 3,
39 	MBOX_CMD_HASH		= 4,
40 	MBOX_CMD_SIGN		= 5,
41 	MBOX_CMD_VERIFY		= 6,
42 
43 	MBOX_CMD_OTP_READ	= 7,
44 	MBOX_CMD_OTP_WRITE	= 8,
45 };
46 
47 struct mox_kobject;
48 
49 struct mox_rwtm {
50 	struct device *dev;
51 	struct mbox_client mbox_client;
52 	struct mbox_chan *mbox;
53 	struct mox_kobject *kobj;
54 	struct hwrng hwrng;
55 
56 	struct armada_37xx_rwtm_rx_msg reply;
57 
58 	void *buf;
59 	dma_addr_t buf_phys;
60 
61 	struct mutex busy;
62 	struct completion cmd_done;
63 
64 	/* board information */
65 	int has_board_info;
66 	u64 serial_number;
67 	int board_version, ram_size;
68 	u8 mac_address1[6], mac_address2[6];
69 
70 	/* public key burned in eFuse */
71 	int has_pubkey;
72 	u8 pubkey[135];
73 
74 #ifdef CONFIG_DEBUG_FS
75 	/*
76 	 * Signature process. This is currently done via debugfs, because it
77 	 * does not conform to the sysfs standard "one file per attribute".
78 	 * It should be rewritten via crypto API once akcipher API is available
79 	 * from userspace.
80 	 */
81 	struct dentry *debugfs_root;
82 	u32 last_sig[34];
83 	int last_sig_done;
84 #endif
85 };
86 
87 struct mox_kobject {
88 	struct kobject kobj;
89 	struct mox_rwtm *rwtm;
90 };
91 
92 static inline struct kobject *rwtm_to_kobj(struct mox_rwtm *rwtm)
93 {
94 	return &rwtm->kobj->kobj;
95 }
96 
97 static inline struct mox_rwtm *to_rwtm(struct kobject *kobj)
98 {
99 	return container_of(kobj, struct mox_kobject, kobj)->rwtm;
100 }
101 
102 static void mox_kobj_release(struct kobject *kobj)
103 {
104 	kfree(to_rwtm(kobj)->kobj);
105 }
106 
107 static const struct kobj_type mox_kobj_ktype = {
108 	.release	= mox_kobj_release,
109 	.sysfs_ops	= &kobj_sysfs_ops,
110 };
111 
112 static int mox_kobj_create(struct mox_rwtm *rwtm)
113 {
114 	rwtm->kobj = kzalloc(sizeof(*rwtm->kobj), GFP_KERNEL);
115 	if (!rwtm->kobj)
116 		return -ENOMEM;
117 
118 	kobject_init(rwtm_to_kobj(rwtm), &mox_kobj_ktype);
119 	if (kobject_add(rwtm_to_kobj(rwtm), firmware_kobj, "turris-mox-rwtm")) {
120 		kobject_put(rwtm_to_kobj(rwtm));
121 		return -ENXIO;
122 	}
123 
124 	rwtm->kobj->rwtm = rwtm;
125 
126 	return 0;
127 }
128 
129 #define MOX_ATTR_RO(name, format, cat)				\
130 static ssize_t							\
131 name##_show(struct kobject *kobj, struct kobj_attribute *a,	\
132 	    char *buf)						\
133 {								\
134 	struct mox_rwtm *rwtm = to_rwtm(kobj);	\
135 	if (!rwtm->has_##cat)					\
136 		return -ENODATA;				\
137 	return sprintf(buf, format, rwtm->name);		\
138 }								\
139 static struct kobj_attribute mox_attr_##name = __ATTR_RO(name)
140 
141 MOX_ATTR_RO(serial_number, "%016llX\n", board_info);
142 MOX_ATTR_RO(board_version, "%i\n", board_info);
143 MOX_ATTR_RO(ram_size, "%i\n", board_info);
144 MOX_ATTR_RO(mac_address1, "%pM\n", board_info);
145 MOX_ATTR_RO(mac_address2, "%pM\n", board_info);
146 MOX_ATTR_RO(pubkey, "%s\n", pubkey);
147 
148 static int mox_get_status(enum mbox_cmd cmd, u32 retval)
149 {
150 	if (MBOX_STS_CMD(retval) != cmd)
151 		return -EIO;
152 	else if (MBOX_STS_ERROR(retval) == MBOX_STS_FAIL)
153 		return -(int)MBOX_STS_VALUE(retval);
154 	else if (MBOX_STS_ERROR(retval) == MBOX_STS_BADCMD)
155 		return -ENOSYS;
156 	else if (MBOX_STS_ERROR(retval) != MBOX_STS_SUCCESS)
157 		return -EIO;
158 	else
159 		return MBOX_STS_VALUE(retval);
160 }
161 
162 static const struct attribute *mox_rwtm_attrs[] = {
163 	&mox_attr_serial_number.attr,
164 	&mox_attr_board_version.attr,
165 	&mox_attr_ram_size.attr,
166 	&mox_attr_mac_address1.attr,
167 	&mox_attr_mac_address2.attr,
168 	&mox_attr_pubkey.attr,
169 	NULL
170 };
171 
172 static void mox_rwtm_rx_callback(struct mbox_client *cl, void *data)
173 {
174 	struct mox_rwtm *rwtm = dev_get_drvdata(cl->dev);
175 	struct armada_37xx_rwtm_rx_msg *msg = data;
176 
177 	rwtm->reply = *msg;
178 	complete(&rwtm->cmd_done);
179 }
180 
181 static void reply_to_mac_addr(u8 *mac, u32 t1, u32 t2)
182 {
183 	mac[0] = t1 >> 8;
184 	mac[1] = t1;
185 	mac[2] = t2 >> 24;
186 	mac[3] = t2 >> 16;
187 	mac[4] = t2 >> 8;
188 	mac[5] = t2;
189 }
190 
191 static int mox_get_board_info(struct mox_rwtm *rwtm)
192 {
193 	struct armada_37xx_rwtm_tx_msg msg;
194 	struct armada_37xx_rwtm_rx_msg *reply = &rwtm->reply;
195 	int ret;
196 
197 	msg.command = MBOX_CMD_BOARD_INFO;
198 	ret = mbox_send_message(rwtm->mbox, &msg);
199 	if (ret < 0)
200 		return ret;
201 
202 	ret = wait_for_completion_timeout(&rwtm->cmd_done, HZ / 2);
203 	if (ret < 0)
204 		return ret;
205 
206 	ret = mox_get_status(MBOX_CMD_BOARD_INFO, reply->retval);
207 	if (ret == -ENODATA) {
208 		dev_warn(rwtm->dev,
209 			 "Board does not have manufacturing information burned!\n");
210 	} else if (ret == -ENOSYS) {
211 		dev_notice(rwtm->dev,
212 			   "Firmware does not support the BOARD_INFO command\n");
213 	} else if (ret < 0) {
214 		return ret;
215 	} else {
216 		rwtm->serial_number = reply->status[1];
217 		rwtm->serial_number <<= 32;
218 		rwtm->serial_number |= reply->status[0];
219 		rwtm->board_version = reply->status[2];
220 		rwtm->ram_size = reply->status[3];
221 		reply_to_mac_addr(rwtm->mac_address1, reply->status[4],
222 				  reply->status[5]);
223 		reply_to_mac_addr(rwtm->mac_address2, reply->status[6],
224 				  reply->status[7]);
225 		rwtm->has_board_info = 1;
226 
227 		pr_info("Turris Mox serial number %016llX\n",
228 			rwtm->serial_number);
229 		pr_info("           board version %i\n", rwtm->board_version);
230 		pr_info("           burned RAM size %i MiB\n", rwtm->ram_size);
231 	}
232 
233 	msg.command = MBOX_CMD_ECDSA_PUB_KEY;
234 	ret = mbox_send_message(rwtm->mbox, &msg);
235 	if (ret < 0)
236 		return ret;
237 
238 	ret = wait_for_completion_timeout(&rwtm->cmd_done, HZ / 2);
239 	if (ret < 0)
240 		return ret;
241 
242 	ret = mox_get_status(MBOX_CMD_ECDSA_PUB_KEY, reply->retval);
243 	if (ret == -ENODATA) {
244 		dev_warn(rwtm->dev, "Board has no public key burned!\n");
245 	} else if (ret == -ENOSYS) {
246 		dev_notice(rwtm->dev,
247 			   "Firmware does not support the ECDSA_PUB_KEY command\n");
248 	} else if (ret < 0) {
249 		return ret;
250 	} else {
251 		u32 *s = reply->status;
252 
253 		rwtm->has_pubkey = 1;
254 		sprintf(rwtm->pubkey,
255 			"%06x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x",
256 			ret, s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7],
257 			s[8], s[9], s[10], s[11], s[12], s[13], s[14], s[15]);
258 	}
259 
260 	return 0;
261 }
262 
263 static int check_get_random_support(struct mox_rwtm *rwtm)
264 {
265 	struct armada_37xx_rwtm_tx_msg msg;
266 	int ret;
267 
268 	msg.command = MBOX_CMD_GET_RANDOM;
269 	msg.args[0] = 1;
270 	msg.args[1] = rwtm->buf_phys;
271 	msg.args[2] = 4;
272 
273 	ret = mbox_send_message(rwtm->mbox, &msg);
274 	if (ret < 0)
275 		return ret;
276 
277 	ret = wait_for_completion_timeout(&rwtm->cmd_done, HZ / 2);
278 	if (ret < 0)
279 		return ret;
280 
281 	return mox_get_status(MBOX_CMD_GET_RANDOM, rwtm->reply.retval);
282 }
283 
284 static int mox_hwrng_read(struct hwrng *rng, void *data, size_t max, bool wait)
285 {
286 	struct mox_rwtm *rwtm = (struct mox_rwtm *) rng->priv;
287 	struct armada_37xx_rwtm_tx_msg msg;
288 	int ret;
289 
290 	if (max > 4096)
291 		max = 4096;
292 
293 	msg.command = MBOX_CMD_GET_RANDOM;
294 	msg.args[0] = 1;
295 	msg.args[1] = rwtm->buf_phys;
296 	msg.args[2] = (max + 3) & ~3;
297 
298 	if (!wait) {
299 		if (!mutex_trylock(&rwtm->busy))
300 			return -EBUSY;
301 	} else {
302 		mutex_lock(&rwtm->busy);
303 	}
304 
305 	ret = mbox_send_message(rwtm->mbox, &msg);
306 	if (ret < 0)
307 		goto unlock_mutex;
308 
309 	ret = wait_for_completion_interruptible(&rwtm->cmd_done);
310 	if (ret < 0)
311 		goto unlock_mutex;
312 
313 	ret = mox_get_status(MBOX_CMD_GET_RANDOM, rwtm->reply.retval);
314 	if (ret < 0)
315 		goto unlock_mutex;
316 
317 	memcpy(data, rwtm->buf, max);
318 	ret = max;
319 
320 unlock_mutex:
321 	mutex_unlock(&rwtm->busy);
322 	return ret;
323 }
324 
325 #ifdef CONFIG_DEBUG_FS
326 static int rwtm_debug_open(struct inode *inode, struct file *file)
327 {
328 	file->private_data = inode->i_private;
329 
330 	return nonseekable_open(inode, file);
331 }
332 
333 static ssize_t do_sign_read(struct file *file, char __user *buf, size_t len,
334 			    loff_t *ppos)
335 {
336 	struct mox_rwtm *rwtm = file->private_data;
337 	ssize_t ret;
338 
339 	/* only allow one read, of 136 bytes, from position 0 */
340 	if (*ppos != 0)
341 		return 0;
342 
343 	if (len < 136)
344 		return -EINVAL;
345 
346 	if (!rwtm->last_sig_done)
347 		return -ENODATA;
348 
349 	/* 2 arrays of 17 32-bit words are 136 bytes */
350 	ret = simple_read_from_buffer(buf, len, ppos, rwtm->last_sig, 136);
351 	rwtm->last_sig_done = 0;
352 
353 	return ret;
354 }
355 
356 static ssize_t do_sign_write(struct file *file, const char __user *buf,
357 			     size_t len, loff_t *ppos)
358 {
359 	struct mox_rwtm *rwtm = file->private_data;
360 	struct armada_37xx_rwtm_rx_msg *reply = &rwtm->reply;
361 	struct armada_37xx_rwtm_tx_msg msg;
362 	loff_t dummy = 0;
363 	ssize_t ret;
364 
365 	/* the input is a SHA-512 hash, so exactly 64 bytes have to be read */
366 	if (len != 64)
367 		return -EINVAL;
368 
369 	/* if last result is not zero user has not read that information yet */
370 	if (rwtm->last_sig_done)
371 		return -EBUSY;
372 
373 	if (!mutex_trylock(&rwtm->busy))
374 		return -EBUSY;
375 
376 	/*
377 	 * Here we have to send:
378 	 *   1. Address of the input to sign.
379 	 *      The input is an array of 17 32-bit words, the first (most
380 	 *      significat) is 0, the rest 16 words are copied from the SHA-512
381 	 *      hash given by the user and converted from BE to LE.
382 	 *   2. Address of the buffer where ECDSA signature value R shall be
383 	 *      stored by the rWTM firmware.
384 	 *   3. Address of the buffer where ECDSA signature value S shall be
385 	 *      stored by the rWTM firmware.
386 	 */
387 	memset(rwtm->buf, 0, 4);
388 	ret = simple_write_to_buffer(rwtm->buf + 4, 64, &dummy, buf, len);
389 	if (ret < 0)
390 		goto unlock_mutex;
391 	be32_to_cpu_array(rwtm->buf, rwtm->buf, 17);
392 
393 	msg.command = MBOX_CMD_SIGN;
394 	msg.args[0] = 1;
395 	msg.args[1] = rwtm->buf_phys;
396 	msg.args[2] = rwtm->buf_phys + 68;
397 	msg.args[3] = rwtm->buf_phys + 2 * 68;
398 	ret = mbox_send_message(rwtm->mbox, &msg);
399 	if (ret < 0)
400 		goto unlock_mutex;
401 
402 	ret = wait_for_completion_interruptible(&rwtm->cmd_done);
403 	if (ret < 0)
404 		goto unlock_mutex;
405 
406 	ret = MBOX_STS_VALUE(reply->retval);
407 	if (MBOX_STS_ERROR(reply->retval) != MBOX_STS_SUCCESS)
408 		goto unlock_mutex;
409 
410 	/*
411 	 * Here we read the R and S values of the ECDSA signature
412 	 * computed by the rWTM firmware and convert their words from
413 	 * LE to BE.
414 	 */
415 	memcpy(rwtm->last_sig, rwtm->buf + 68, 136);
416 	cpu_to_be32_array(rwtm->last_sig, rwtm->last_sig, 34);
417 	rwtm->last_sig_done = 1;
418 
419 	mutex_unlock(&rwtm->busy);
420 	return len;
421 unlock_mutex:
422 	mutex_unlock(&rwtm->busy);
423 	return ret;
424 }
425 
426 static const struct file_operations do_sign_fops = {
427 	.owner	= THIS_MODULE,
428 	.open	= rwtm_debug_open,
429 	.read	= do_sign_read,
430 	.write	= do_sign_write,
431 	.llseek	= no_llseek,
432 };
433 
434 static int rwtm_register_debugfs(struct mox_rwtm *rwtm)
435 {
436 	struct dentry *root, *entry;
437 
438 	root = debugfs_create_dir("turris-mox-rwtm", NULL);
439 
440 	if (IS_ERR(root))
441 		return PTR_ERR(root);
442 
443 	entry = debugfs_create_file_unsafe("do_sign", 0600, root, rwtm,
444 					   &do_sign_fops);
445 	if (IS_ERR(entry))
446 		goto err_remove;
447 
448 	rwtm->debugfs_root = root;
449 
450 	return 0;
451 err_remove:
452 	debugfs_remove_recursive(root);
453 	return PTR_ERR(entry);
454 }
455 
456 static void rwtm_unregister_debugfs(struct mox_rwtm *rwtm)
457 {
458 	debugfs_remove_recursive(rwtm->debugfs_root);
459 }
460 #else
461 static inline int rwtm_register_debugfs(struct mox_rwtm *rwtm)
462 {
463 	return 0;
464 }
465 
466 static inline void rwtm_unregister_debugfs(struct mox_rwtm *rwtm)
467 {
468 }
469 #endif
470 
471 static int turris_mox_rwtm_probe(struct platform_device *pdev)
472 {
473 	struct mox_rwtm *rwtm;
474 	struct device *dev = &pdev->dev;
475 	int ret;
476 
477 	rwtm = devm_kzalloc(dev, sizeof(*rwtm), GFP_KERNEL);
478 	if (!rwtm)
479 		return -ENOMEM;
480 
481 	rwtm->dev = dev;
482 	rwtm->buf = dmam_alloc_coherent(dev, PAGE_SIZE, &rwtm->buf_phys,
483 					GFP_KERNEL);
484 	if (!rwtm->buf)
485 		return -ENOMEM;
486 
487 	ret = mox_kobj_create(rwtm);
488 	if (ret < 0) {
489 		dev_err(dev, "Cannot create turris-mox-rwtm kobject!\n");
490 		return ret;
491 	}
492 
493 	ret = sysfs_create_files(rwtm_to_kobj(rwtm), mox_rwtm_attrs);
494 	if (ret < 0) {
495 		dev_err(dev, "Cannot create sysfs files!\n");
496 		goto put_kobj;
497 	}
498 
499 	platform_set_drvdata(pdev, rwtm);
500 
501 	mutex_init(&rwtm->busy);
502 
503 	rwtm->mbox_client.dev = dev;
504 	rwtm->mbox_client.rx_callback = mox_rwtm_rx_callback;
505 
506 	rwtm->mbox = mbox_request_channel(&rwtm->mbox_client, 0);
507 	if (IS_ERR(rwtm->mbox)) {
508 		ret = PTR_ERR(rwtm->mbox);
509 		if (ret != -EPROBE_DEFER)
510 			dev_err(dev, "Cannot request mailbox channel: %i\n",
511 				ret);
512 		goto remove_files;
513 	}
514 
515 	init_completion(&rwtm->cmd_done);
516 
517 	ret = mox_get_board_info(rwtm);
518 	if (ret < 0)
519 		dev_warn(dev, "Cannot read board information: %i\n", ret);
520 
521 	ret = check_get_random_support(rwtm);
522 	if (ret < 0) {
523 		dev_notice(dev,
524 			   "Firmware does not support the GET_RANDOM command\n");
525 		goto free_channel;
526 	}
527 
528 	rwtm->hwrng.name = DRIVER_NAME "_hwrng";
529 	rwtm->hwrng.read = mox_hwrng_read;
530 	rwtm->hwrng.priv = (unsigned long) rwtm;
531 
532 	ret = devm_hwrng_register(dev, &rwtm->hwrng);
533 	if (ret < 0) {
534 		dev_err(dev, "Cannot register HWRNG: %i\n", ret);
535 		goto free_channel;
536 	}
537 
538 	ret = rwtm_register_debugfs(rwtm);
539 	if (ret < 0) {
540 		dev_err(dev, "Failed creating debugfs entries: %i\n", ret);
541 		goto free_channel;
542 	}
543 
544 	dev_info(dev, "HWRNG successfully registered\n");
545 
546 	return 0;
547 
548 free_channel:
549 	mbox_free_channel(rwtm->mbox);
550 remove_files:
551 	sysfs_remove_files(rwtm_to_kobj(rwtm), mox_rwtm_attrs);
552 put_kobj:
553 	kobject_put(rwtm_to_kobj(rwtm));
554 	return ret;
555 }
556 
557 static int turris_mox_rwtm_remove(struct platform_device *pdev)
558 {
559 	struct mox_rwtm *rwtm = platform_get_drvdata(pdev);
560 
561 	rwtm_unregister_debugfs(rwtm);
562 	sysfs_remove_files(rwtm_to_kobj(rwtm), mox_rwtm_attrs);
563 	kobject_put(rwtm_to_kobj(rwtm));
564 	mbox_free_channel(rwtm->mbox);
565 
566 	return 0;
567 }
568 
569 static const struct of_device_id turris_mox_rwtm_match[] = {
570 	{ .compatible = "cznic,turris-mox-rwtm", },
571 	{ .compatible = "marvell,armada-3700-rwtm-firmware", },
572 	{ },
573 };
574 
575 MODULE_DEVICE_TABLE(of, turris_mox_rwtm_match);
576 
577 static struct platform_driver turris_mox_rwtm_driver = {
578 	.probe	= turris_mox_rwtm_probe,
579 	.remove	= turris_mox_rwtm_remove,
580 	.driver	= {
581 		.name		= DRIVER_NAME,
582 		.of_match_table	= turris_mox_rwtm_match,
583 	},
584 };
585 module_platform_driver(turris_mox_rwtm_driver);
586 
587 MODULE_LICENSE("GPL v2");
588 MODULE_DESCRIPTION("Turris Mox rWTM firmware driver");
589 MODULE_AUTHOR("Marek Behun <kabel@kernel.org>");
590