xref: /openbmc/linux/drivers/crypto/bcm/util.c (revision a36954f5)
1 /*
2  * Copyright 2016 Broadcom
3  *
4  * This program is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License, version 2, as
6  * published by the Free Software Foundation (the "GPL").
7  *
8  * This program is distributed in the hope that it will be useful, but
9  * WITHOUT ANY WARRANTY; without even the implied warranty of
10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
11  * General Public License version 2 (GPLv2) for more details.
12  *
13  * You should have received a copy of the GNU General Public License
14  * version 2 (GPLv2) along with this source code.
15  */
16 
17 #include <linux/debugfs.h>
18 
19 #include "cipher.h"
20 #include "util.h"
21 
22 /* offset of SPU_OFIFO_CTRL register */
23 #define SPU_OFIFO_CTRL      0x40
24 #define SPU_FIFO_WATERMARK  0x1FF
25 
26 /**
27  * spu_sg_at_offset() - Find the scatterlist entry at a given distance from the
28  * start of a scatterlist.
29  * @sg:         [in]  Start of a scatterlist
30  * @skip:       [in]  Distance from the start of the scatterlist, in bytes
31  * @sge:        [out] Scatterlist entry at skip bytes from start
32  * @sge_offset: [out] Number of bytes from start of sge buffer to get to
33  *                    requested distance.
34  *
35  * Return: 0 if entry found at requested distance
36  *         < 0 otherwise
37  */
38 int spu_sg_at_offset(struct scatterlist *sg, unsigned int skip,
39 		     struct scatterlist **sge, unsigned int *sge_offset)
40 {
41 	/* byte index from start of sg to the end of the previous entry */
42 	unsigned int index = 0;
43 	/* byte index from start of sg to the end of the current entry */
44 	unsigned int next_index;
45 
46 	next_index = sg->length;
47 	while (next_index <= skip) {
48 		sg = sg_next(sg);
49 		index = next_index;
50 		if (!sg)
51 			return -EINVAL;
52 		next_index += sg->length;
53 	}
54 
55 	*sge_offset = skip - index;
56 	*sge = sg;
57 	return 0;
58 }
59 
60 /* Copy len bytes of sg data, starting at offset skip, to a dest buffer */
61 void sg_copy_part_to_buf(struct scatterlist *src, u8 *dest,
62 			 unsigned int len, unsigned int skip)
63 {
64 	size_t copied;
65 	unsigned int nents = sg_nents(src);
66 
67 	copied = sg_pcopy_to_buffer(src, nents, dest, len, skip);
68 	if (copied != len) {
69 		flow_log("%s copied %u bytes of %u requested. ",
70 			 __func__, (u32)copied, len);
71 		flow_log("sg with %u entries and skip %u\n", nents, skip);
72 	}
73 }
74 
75 /*
76  * Copy data into a scatterlist starting at a specified offset in the
77  * scatterlist. Specifically, copy len bytes of data in the buffer src
78  * into the scatterlist dest, starting skip bytes into the scatterlist.
79  */
80 void sg_copy_part_from_buf(struct scatterlist *dest, u8 *src,
81 			   unsigned int len, unsigned int skip)
82 {
83 	size_t copied;
84 	unsigned int nents = sg_nents(dest);
85 
86 	copied = sg_pcopy_from_buffer(dest, nents, src, len, skip);
87 	if (copied != len) {
88 		flow_log("%s copied %u bytes of %u requested. ",
89 			 __func__, (u32)copied, len);
90 		flow_log("sg with %u entries and skip %u\n", nents, skip);
91 	}
92 }
93 
94 /**
95  * spu_sg_count() - Determine number of elements in scatterlist to provide a
96  * specified number of bytes.
97  * @sg_list:  scatterlist to examine
98  * @skip:     index of starting point
99  * @nbytes:   consider elements of scatterlist until reaching this number of
100  *	      bytes
101  *
102  * Return: the number of sg entries contributing to nbytes of data
103  */
104 int spu_sg_count(struct scatterlist *sg_list, unsigned int skip, int nbytes)
105 {
106 	struct scatterlist *sg;
107 	int sg_nents = 0;
108 	unsigned int offset;
109 
110 	if (!sg_list)
111 		return 0;
112 
113 	if (spu_sg_at_offset(sg_list, skip, &sg, &offset) < 0)
114 		return 0;
115 
116 	while (sg && (nbytes > 0)) {
117 		sg_nents++;
118 		nbytes -= (sg->length - offset);
119 		offset = 0;
120 		sg = sg_next(sg);
121 	}
122 	return sg_nents;
123 }
124 
125 /**
126  * spu_msg_sg_add() - Copy scatterlist entries from one sg to another, up to a
127  * given length.
128  * @to_sg:       scatterlist to copy to
129  * @from_sg:     scatterlist to copy from
130  * @from_skip:   number of bytes to skip in from_sg. Non-zero when previous
131  *		 request included part of the buffer in entry in from_sg.
132  *		 Assumes from_skip < from_sg->length.
133  * @from_nents   number of entries in from_sg
134  * @length       number of bytes to copy. may reach this limit before exhausting
135  *		 from_sg.
136  *
137  * Copies the entries themselves, not the data in the entries. Assumes to_sg has
138  * enough entries. Does not limit the size of an individual buffer in to_sg.
139  *
140  * to_sg, from_sg, skip are all updated to end of copy
141  *
142  * Return: Number of bytes copied
143  */
144 u32 spu_msg_sg_add(struct scatterlist **to_sg,
145 		   struct scatterlist **from_sg, u32 *from_skip,
146 		   u8 from_nents, u32 length)
147 {
148 	struct scatterlist *sg;	/* an entry in from_sg */
149 	struct scatterlist *to = *to_sg;
150 	struct scatterlist *from = *from_sg;
151 	u32 skip = *from_skip;
152 	u32 offset;
153 	int i;
154 	u32 entry_len = 0;
155 	u32 frag_len = 0;	/* length of entry added to to_sg */
156 	u32 copied = 0;		/* number of bytes copied so far */
157 
158 	if (length == 0)
159 		return 0;
160 
161 	for_each_sg(from, sg, from_nents, i) {
162 		/* number of bytes in this from entry not yet used */
163 		entry_len = sg->length - skip;
164 		frag_len = min(entry_len, length - copied);
165 		offset = sg->offset + skip;
166 		if (frag_len)
167 			sg_set_page(to++, sg_page(sg), frag_len, offset);
168 		copied += frag_len;
169 		if (copied == entry_len) {
170 			/* used up all of from entry */
171 			skip = 0;	/* start at beginning of next entry */
172 		}
173 		if (copied == length)
174 			break;
175 	}
176 	*to_sg = to;
177 	*from_sg = sg;
178 	if (frag_len < entry_len)
179 		*from_skip = skip + frag_len;
180 	else
181 		*from_skip = 0;
182 
183 	return copied;
184 }
185 
186 void add_to_ctr(u8 *ctr_pos, unsigned int increment)
187 {
188 	__be64 *high_be = (__be64 *)ctr_pos;
189 	__be64 *low_be = high_be + 1;
190 	u64 orig_low = __be64_to_cpu(*low_be);
191 	u64 new_low = orig_low + (u64)increment;
192 
193 	*low_be = __cpu_to_be64(new_low);
194 	if (new_low < orig_low)
195 		/* there was a carry from the low 8 bytes */
196 		*high_be = __cpu_to_be64(__be64_to_cpu(*high_be) + 1);
197 }
198 
199 struct sdesc {
200 	struct shash_desc shash;
201 	char ctx[];
202 };
203 
204 /* do a synchronous decrypt operation */
205 int do_decrypt(char *alg_name,
206 	       void *key_ptr, unsigned int key_len,
207 	       void *iv_ptr, void *src_ptr, void *dst_ptr,
208 	       unsigned int block_len)
209 {
210 	struct scatterlist sg_in[1], sg_out[1];
211 	struct crypto_blkcipher *tfm =
212 	    crypto_alloc_blkcipher(alg_name, 0, CRYPTO_ALG_ASYNC);
213 	struct blkcipher_desc desc = {.tfm = tfm, .flags = 0 };
214 	int ret = 0;
215 	void *iv;
216 	int ivsize;
217 
218 	flow_log("%s() name:%s block_len:%u\n", __func__, alg_name, block_len);
219 
220 	if (IS_ERR(tfm))
221 		return PTR_ERR(tfm);
222 
223 	crypto_blkcipher_setkey((void *)tfm, key_ptr, key_len);
224 
225 	sg_init_table(sg_in, 1);
226 	sg_set_buf(sg_in, src_ptr, block_len);
227 
228 	sg_init_table(sg_out, 1);
229 	sg_set_buf(sg_out, dst_ptr, block_len);
230 
231 	iv = crypto_blkcipher_crt(tfm)->iv;
232 	ivsize = crypto_blkcipher_ivsize(tfm);
233 	memcpy(iv, iv_ptr, ivsize);
234 
235 	ret = crypto_blkcipher_decrypt(&desc, sg_out, sg_in, block_len);
236 	crypto_free_blkcipher(tfm);
237 
238 	if (ret < 0)
239 		pr_err("aes_decrypt failed %d\n", ret);
240 
241 	return ret;
242 }
243 
244 /**
245  * do_shash() - Do a synchronous hash operation in software
246  * @name:       The name of the hash algorithm
247  * @result:     Buffer where digest is to be written
248  * @data1:      First part of data to hash. May be NULL.
249  * @data1_len:  Length of data1, in bytes
250  * @data2:      Second part of data to hash. May be NULL.
251  * @data2_len:  Length of data2, in bytes
252  * @key:	Key (if keyed hash)
253  * @key_len:	Length of key, in bytes (or 0 if non-keyed hash)
254  *
255  * Note that the crypto API will not select this driver's own transform because
256  * this driver only registers asynchronous algos.
257  *
258  * Return: 0 if hash successfully stored in result
259  *         < 0 otherwise
260  */
261 int do_shash(unsigned char *name, unsigned char *result,
262 	     const u8 *data1, unsigned int data1_len,
263 	     const u8 *data2, unsigned int data2_len,
264 	     const u8 *key, unsigned int key_len)
265 {
266 	int rc;
267 	unsigned int size;
268 	struct crypto_shash *hash;
269 	struct sdesc *sdesc;
270 
271 	hash = crypto_alloc_shash(name, 0, 0);
272 	if (IS_ERR(hash)) {
273 		rc = PTR_ERR(hash);
274 		pr_err("%s: Crypto %s allocation error %d", __func__, name, rc);
275 		return rc;
276 	}
277 
278 	size = sizeof(struct shash_desc) + crypto_shash_descsize(hash);
279 	sdesc = kmalloc(size, GFP_KERNEL);
280 	if (!sdesc) {
281 		rc = -ENOMEM;
282 		pr_err("%s: Memory allocation failure", __func__);
283 		goto do_shash_err;
284 	}
285 	sdesc->shash.tfm = hash;
286 	sdesc->shash.flags = 0x0;
287 
288 	if (key_len > 0) {
289 		rc = crypto_shash_setkey(hash, key, key_len);
290 		if (rc) {
291 			pr_err("%s: Could not setkey %s shash", __func__, name);
292 			goto do_shash_err;
293 		}
294 	}
295 
296 	rc = crypto_shash_init(&sdesc->shash);
297 	if (rc) {
298 		pr_err("%s: Could not init %s shash", __func__, name);
299 		goto do_shash_err;
300 	}
301 	rc = crypto_shash_update(&sdesc->shash, data1, data1_len);
302 	if (rc) {
303 		pr_err("%s: Could not update1", __func__);
304 		goto do_shash_err;
305 	}
306 	if (data2 && data2_len) {
307 		rc = crypto_shash_update(&sdesc->shash, data2, data2_len);
308 		if (rc) {
309 			pr_err("%s: Could not update2", __func__);
310 			goto do_shash_err;
311 		}
312 	}
313 	rc = crypto_shash_final(&sdesc->shash, result);
314 	if (rc)
315 		pr_err("%s: Could not generate %s hash", __func__, name);
316 
317 do_shash_err:
318 	crypto_free_shash(hash);
319 	kfree(sdesc);
320 
321 	return rc;
322 }
323 
324 /* Dump len bytes of a scatterlist starting at skip bytes into the sg */
325 void __dump_sg(struct scatterlist *sg, unsigned int skip, unsigned int len)
326 {
327 	u8 dbuf[16];
328 	unsigned int idx = skip;
329 	unsigned int num_out = 0;	/* number of bytes dumped so far */
330 	unsigned int count;
331 
332 	if (packet_debug_logging) {
333 		while (num_out < len) {
334 			count = (len - num_out > 16) ? 16 : len - num_out;
335 			sg_copy_part_to_buf(sg, dbuf, count, idx);
336 			num_out += count;
337 			print_hex_dump(KERN_ALERT, "  sg: ", DUMP_PREFIX_NONE,
338 				       4, 1, dbuf, count, false);
339 			idx += 16;
340 		}
341 	}
342 	if (debug_logging_sleep)
343 		msleep(debug_logging_sleep);
344 }
345 
346 /* Returns the name for a given cipher alg/mode */
347 char *spu_alg_name(enum spu_cipher_alg alg, enum spu_cipher_mode mode)
348 {
349 	switch (alg) {
350 	case CIPHER_ALG_RC4:
351 		return "rc4";
352 	case CIPHER_ALG_AES:
353 		switch (mode) {
354 		case CIPHER_MODE_CBC:
355 			return "cbc(aes)";
356 		case CIPHER_MODE_ECB:
357 			return "ecb(aes)";
358 		case CIPHER_MODE_OFB:
359 			return "ofb(aes)";
360 		case CIPHER_MODE_CFB:
361 			return "cfb(aes)";
362 		case CIPHER_MODE_CTR:
363 			return "ctr(aes)";
364 		case CIPHER_MODE_XTS:
365 			return "xts(aes)";
366 		case CIPHER_MODE_GCM:
367 			return "gcm(aes)";
368 		default:
369 			return "aes";
370 		}
371 		break;
372 	case CIPHER_ALG_DES:
373 		switch (mode) {
374 		case CIPHER_MODE_CBC:
375 			return "cbc(des)";
376 		case CIPHER_MODE_ECB:
377 			return "ecb(des)";
378 		case CIPHER_MODE_CTR:
379 			return "ctr(des)";
380 		default:
381 			return "des";
382 		}
383 		break;
384 	case CIPHER_ALG_3DES:
385 		switch (mode) {
386 		case CIPHER_MODE_CBC:
387 			return "cbc(des3_ede)";
388 		case CIPHER_MODE_ECB:
389 			return "ecb(des3_ede)";
390 		case CIPHER_MODE_CTR:
391 			return "ctr(des3_ede)";
392 		default:
393 			return "3des";
394 		}
395 		break;
396 	default:
397 		return "other";
398 	}
399 }
400 
401 static ssize_t spu_debugfs_read(struct file *filp, char __user *ubuf,
402 				size_t count, loff_t *offp)
403 {
404 	struct device_private *ipriv;
405 	char *buf;
406 	ssize_t ret, out_offset, out_count;
407 	int i;
408 	u32 fifo_len;
409 	u32 spu_ofifo_ctrl;
410 	u32 alg;
411 	u32 mode;
412 	u32 op_cnt;
413 
414 	out_count = 2048;
415 
416 	buf = kmalloc(out_count, GFP_KERNEL);
417 	if (!buf)
418 		return -ENOMEM;
419 
420 	ipriv = filp->private_data;
421 	out_offset = 0;
422 	out_offset += snprintf(buf + out_offset, out_count - out_offset,
423 			       "Number of SPUs.........%u\n",
424 			       ipriv->spu.num_spu);
425 	out_offset += snprintf(buf + out_offset, out_count - out_offset,
426 			       "Current sessions.......%u\n",
427 			       atomic_read(&ipriv->session_count));
428 	out_offset += snprintf(buf + out_offset, out_count - out_offset,
429 			       "Session count..........%u\n",
430 			       atomic_read(&ipriv->stream_count));
431 	out_offset += snprintf(buf + out_offset, out_count - out_offset,
432 			       "Cipher setkey..........%u\n",
433 			       atomic_read(&ipriv->setkey_cnt[SPU_OP_CIPHER]));
434 	out_offset += snprintf(buf + out_offset, out_count - out_offset,
435 			       "Cipher Ops.............%u\n",
436 			       atomic_read(&ipriv->op_counts[SPU_OP_CIPHER]));
437 	for (alg = 0; alg < CIPHER_ALG_LAST; alg++) {
438 		for (mode = 0; mode < CIPHER_MODE_LAST; mode++) {
439 			op_cnt = atomic_read(&ipriv->cipher_cnt[alg][mode]);
440 			if (op_cnt) {
441 				out_offset += snprintf(buf + out_offset,
442 						       out_count - out_offset,
443 			       "  %-13s%11u\n",
444 			       spu_alg_name(alg, mode), op_cnt);
445 			}
446 		}
447 	}
448 	out_offset += snprintf(buf + out_offset, out_count - out_offset,
449 			       "Hash Ops...............%u\n",
450 			       atomic_read(&ipriv->op_counts[SPU_OP_HASH]));
451 	for (alg = 0; alg < HASH_ALG_LAST; alg++) {
452 		op_cnt = atomic_read(&ipriv->hash_cnt[alg]);
453 		if (op_cnt) {
454 			out_offset += snprintf(buf + out_offset,
455 					       out_count - out_offset,
456 		       "  %-13s%11u\n",
457 		       hash_alg_name[alg], op_cnt);
458 		}
459 	}
460 	out_offset += snprintf(buf + out_offset, out_count - out_offset,
461 			       "HMAC setkey............%u\n",
462 			       atomic_read(&ipriv->setkey_cnt[SPU_OP_HMAC]));
463 	out_offset += snprintf(buf + out_offset, out_count - out_offset,
464 			       "HMAC Ops...............%u\n",
465 			       atomic_read(&ipriv->op_counts[SPU_OP_HMAC]));
466 	for (alg = 0; alg < HASH_ALG_LAST; alg++) {
467 		op_cnt = atomic_read(&ipriv->hmac_cnt[alg]);
468 		if (op_cnt) {
469 			out_offset += snprintf(buf + out_offset,
470 					       out_count - out_offset,
471 		       "  %-13s%11u\n",
472 		       hash_alg_name[alg], op_cnt);
473 		}
474 	}
475 	out_offset += snprintf(buf + out_offset, out_count - out_offset,
476 			       "AEAD setkey............%u\n",
477 			       atomic_read(&ipriv->setkey_cnt[SPU_OP_AEAD]));
478 
479 	out_offset += snprintf(buf + out_offset, out_count - out_offset,
480 			       "AEAD Ops...............%u\n",
481 			       atomic_read(&ipriv->op_counts[SPU_OP_AEAD]));
482 	for (alg = 0; alg < AEAD_TYPE_LAST; alg++) {
483 		op_cnt = atomic_read(&ipriv->aead_cnt[alg]);
484 		if (op_cnt) {
485 			out_offset += snprintf(buf + out_offset,
486 					       out_count - out_offset,
487 		       "  %-13s%11u\n",
488 		       aead_alg_name[alg], op_cnt);
489 		}
490 	}
491 	out_offset += snprintf(buf + out_offset, out_count - out_offset,
492 			       "Bytes of req data......%llu\n",
493 			       (u64)atomic64_read(&ipriv->bytes_out));
494 	out_offset += snprintf(buf + out_offset, out_count - out_offset,
495 			       "Bytes of resp data.....%llu\n",
496 			       (u64)atomic64_read(&ipriv->bytes_in));
497 	out_offset += snprintf(buf + out_offset, out_count - out_offset,
498 			       "Mailbox full...........%u\n",
499 			       atomic_read(&ipriv->mb_no_spc));
500 	out_offset += snprintf(buf + out_offset, out_count - out_offset,
501 			       "Mailbox send failures..%u\n",
502 			       atomic_read(&ipriv->mb_send_fail));
503 	out_offset += snprintf(buf + out_offset, out_count - out_offset,
504 			       "Check ICV errors.......%u\n",
505 			       atomic_read(&ipriv->bad_icv));
506 	if (ipriv->spu.spu_type == SPU_TYPE_SPUM)
507 		for (i = 0; i < ipriv->spu.num_spu; i++) {
508 			spu_ofifo_ctrl = ioread32(ipriv->spu.reg_vbase[i] +
509 						  SPU_OFIFO_CTRL);
510 			fifo_len = spu_ofifo_ctrl & SPU_FIFO_WATERMARK;
511 			out_offset += snprintf(buf + out_offset,
512 					       out_count - out_offset,
513 				       "SPU %d output FIFO high water.....%u\n",
514 				       i, fifo_len);
515 		}
516 
517 	if (out_offset > out_count)
518 		out_offset = out_count;
519 
520 	ret = simple_read_from_buffer(ubuf, count, offp, buf, out_offset);
521 	kfree(buf);
522 	return ret;
523 }
524 
525 static const struct file_operations spu_debugfs_stats = {
526 	.owner = THIS_MODULE,
527 	.open = simple_open,
528 	.read = spu_debugfs_read,
529 };
530 
531 /*
532  * Create the debug FS directories. If the top-level directory has not yet
533  * been created, create it now. Create a stats file in this directory for
534  * a SPU.
535  */
536 void spu_setup_debugfs(void)
537 {
538 	if (!debugfs_initialized())
539 		return;
540 
541 	if (!iproc_priv.debugfs_dir)
542 		iproc_priv.debugfs_dir = debugfs_create_dir(KBUILD_MODNAME,
543 							    NULL);
544 
545 	if (!iproc_priv.debugfs_stats)
546 		/* Create file with permissions S_IRUSR */
547 		debugfs_create_file("stats", 0400, iproc_priv.debugfs_dir,
548 				    &iproc_priv, &spu_debugfs_stats);
549 }
550 
551 void spu_free_debugfs(void)
552 {
553 	debugfs_remove_recursive(iproc_priv.debugfs_dir);
554 	iproc_priv.debugfs_dir = NULL;
555 }
556 
557 /**
558  * format_value_ccm() - Format a value into a buffer, using a specified number
559  *			of bytes (i.e. maybe writing value X into a 4 byte
560  *			buffer, or maybe into a 12 byte buffer), as per the
561  *			SPU CCM spec.
562  *
563  * @val:		value to write (up to max of unsigned int)
564  * @buf:		(pointer to) buffer to write the value
565  * @len:		number of bytes to use (0 to 255)
566  *
567  */
568 void format_value_ccm(unsigned int val, u8 *buf, u8 len)
569 {
570 	int i;
571 
572 	/* First clear full output buffer */
573 	memset(buf, 0, len);
574 
575 	/* Then, starting from right side, fill in with data */
576 	for (i = 0; i < len; i++) {
577 		buf[len - i - 1] = (val >> (8 * i)) & 0xff;
578 		if (i >= 3)
579 			break;  /* Only handle up to 32 bits of 'val' */
580 	}
581 }
582