1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Copyright 2016 Broadcom
4  */
5 
6 #include <linux/kernel.h>
7 #include <linux/string.h>
8 
9 #include "util.h"
10 #include "spu.h"
11 #include "spum.h"
12 #include "cipher.h"
13 
14 char *hash_alg_name[] = { "None", "md5", "sha1", "sha224", "sha256", "aes",
15 	"sha384", "sha512", "sha3_224", "sha3_256", "sha3_384", "sha3_512" };
16 
17 char *aead_alg_name[] = { "ccm(aes)", "gcm(aes)", "authenc" };
18 
19 /* Assumes SPU-M messages are in big endian */
spum_dump_msg_hdr(u8 * buf,unsigned int buf_len)20 void spum_dump_msg_hdr(u8 *buf, unsigned int buf_len)
21 {
22 	u8 *ptr = buf;
23 	struct SPUHEADER *spuh = (struct SPUHEADER *)buf;
24 	unsigned int hash_key_len = 0;
25 	unsigned int hash_state_len = 0;
26 	unsigned int cipher_key_len = 0;
27 	unsigned int iv_len;
28 	u32 pflags;
29 	u32 cflags;
30 	u32 ecf;
31 	u32 cipher_alg;
32 	u32 cipher_mode;
33 	u32 cipher_type;
34 	u32 hash_alg;
35 	u32 hash_mode;
36 	u32 hash_type;
37 	u32 sctx_size;   /* SCTX length in words */
38 	u32 sctx_pl_len; /* SCTX payload length in bytes */
39 
40 	packet_log("\n");
41 	packet_log("SPU Message header %p len: %u\n", buf, buf_len);
42 
43 	/* ========== Decode MH ========== */
44 	packet_log("  MH 0x%08x\n", be32_to_cpup((__be32 *)ptr));
45 	if (spuh->mh.flags & MH_SCTX_PRES)
46 		packet_log("    SCTX  present\n");
47 	if (spuh->mh.flags & MH_BDESC_PRES)
48 		packet_log("    BDESC present\n");
49 	if (spuh->mh.flags & MH_MFM_PRES)
50 		packet_log("    MFM   present\n");
51 	if (spuh->mh.flags & MH_BD_PRES)
52 		packet_log("    BD    present\n");
53 	if (spuh->mh.flags & MH_HASH_PRES)
54 		packet_log("    HASH  present\n");
55 	if (spuh->mh.flags & MH_SUPDT_PRES)
56 		packet_log("    SUPDT present\n");
57 	packet_log("    Opcode 0x%02x\n", spuh->mh.op_code);
58 
59 	ptr += sizeof(spuh->mh) + sizeof(spuh->emh);  /* skip emh. unused */
60 
61 	/* ========== Decode SCTX ========== */
62 	if (spuh->mh.flags & MH_SCTX_PRES) {
63 		pflags = be32_to_cpu(spuh->sa.proto_flags);
64 		packet_log("  SCTX[0] 0x%08x\n", pflags);
65 		sctx_size = pflags & SCTX_SIZE;
66 		packet_log("    Size %u words\n", sctx_size);
67 
68 		cflags = be32_to_cpu(spuh->sa.cipher_flags);
69 		packet_log("  SCTX[1] 0x%08x\n", cflags);
70 		packet_log("    Inbound:%lu (1:decrypt/vrfy 0:encrypt/auth)\n",
71 			   (cflags & CIPHER_INBOUND) >> CIPHER_INBOUND_SHIFT);
72 		packet_log("    Order:%lu (1:AuthFirst 0:EncFirst)\n",
73 			   (cflags & CIPHER_ORDER) >> CIPHER_ORDER_SHIFT);
74 		packet_log("    ICV_IS_512:%lx\n",
75 			   (cflags & ICV_IS_512) >> ICV_IS_512_SHIFT);
76 		cipher_alg = (cflags & CIPHER_ALG) >> CIPHER_ALG_SHIFT;
77 		cipher_mode = (cflags & CIPHER_MODE) >> CIPHER_MODE_SHIFT;
78 		cipher_type = (cflags & CIPHER_TYPE) >> CIPHER_TYPE_SHIFT;
79 		packet_log("    Crypto Alg:%u Mode:%u Type:%u\n",
80 			   cipher_alg, cipher_mode, cipher_type);
81 		hash_alg = (cflags & HASH_ALG) >> HASH_ALG_SHIFT;
82 		hash_mode = (cflags & HASH_MODE) >> HASH_MODE_SHIFT;
83 		hash_type = (cflags & HASH_TYPE) >> HASH_TYPE_SHIFT;
84 		packet_log("    Hash   Alg:%x Mode:%x Type:%x\n",
85 			   hash_alg, hash_mode, hash_type);
86 		packet_log("    UPDT_Offset:%u\n", cflags & UPDT_OFST);
87 
88 		ecf = be32_to_cpu(spuh->sa.ecf);
89 		packet_log("  SCTX[2] 0x%08x\n", ecf);
90 		packet_log("    WriteICV:%lu CheckICV:%lu ICV_SIZE:%u ",
91 			   (ecf & INSERT_ICV) >> INSERT_ICV_SHIFT,
92 			   (ecf & CHECK_ICV) >> CHECK_ICV_SHIFT,
93 			   (ecf & ICV_SIZE) >> ICV_SIZE_SHIFT);
94 		packet_log("BD_SUPPRESS:%lu\n",
95 			   (ecf & BD_SUPPRESS) >> BD_SUPPRESS_SHIFT);
96 		packet_log("    SCTX_IV:%lu ExplicitIV:%lu GenIV:%lu ",
97 			   (ecf & SCTX_IV) >> SCTX_IV_SHIFT,
98 			   (ecf & EXPLICIT_IV) >> EXPLICIT_IV_SHIFT,
99 			   (ecf & GEN_IV) >> GEN_IV_SHIFT);
100 		packet_log("IV_OV_OFST:%lu EXP_IV_SIZE:%u\n",
101 			   (ecf & IV_OFFSET) >> IV_OFFSET_SHIFT,
102 			   ecf & EXP_IV_SIZE);
103 
104 		ptr += sizeof(struct SCTX);
105 
106 		if (hash_alg && hash_mode) {
107 			char *name = "NONE";
108 
109 			switch (hash_alg) {
110 			case HASH_ALG_MD5:
111 				hash_key_len = 16;
112 				name = "MD5";
113 				break;
114 			case HASH_ALG_SHA1:
115 				hash_key_len = 20;
116 				name = "SHA1";
117 				break;
118 			case HASH_ALG_SHA224:
119 				hash_key_len = 28;
120 				name = "SHA224";
121 				break;
122 			case HASH_ALG_SHA256:
123 				hash_key_len = 32;
124 				name = "SHA256";
125 				break;
126 			case HASH_ALG_SHA384:
127 				hash_key_len = 48;
128 				name = "SHA384";
129 				break;
130 			case HASH_ALG_SHA512:
131 				hash_key_len = 64;
132 				name = "SHA512";
133 				break;
134 			case HASH_ALG_AES:
135 				hash_key_len = 0;
136 				name = "AES";
137 				break;
138 			case HASH_ALG_NONE:
139 				break;
140 			}
141 
142 			packet_log("    Auth Key Type:%s Length:%u Bytes\n",
143 				   name, hash_key_len);
144 			packet_dump("    KEY: ", ptr, hash_key_len);
145 			ptr += hash_key_len;
146 		} else if ((hash_alg == HASH_ALG_AES) &&
147 			   (hash_mode == HASH_MODE_XCBC)) {
148 			char *name = "NONE";
149 
150 			switch (cipher_type) {
151 			case CIPHER_TYPE_AES128:
152 				hash_key_len = 16;
153 				name = "AES128-XCBC";
154 				break;
155 			case CIPHER_TYPE_AES192:
156 				hash_key_len = 24;
157 				name = "AES192-XCBC";
158 				break;
159 			case CIPHER_TYPE_AES256:
160 				hash_key_len = 32;
161 				name = "AES256-XCBC";
162 				break;
163 			}
164 			packet_log("    Auth Key Type:%s Length:%u Bytes\n",
165 				   name, hash_key_len);
166 			packet_dump("    KEY: ", ptr, hash_key_len);
167 			ptr += hash_key_len;
168 		}
169 
170 		if (hash_alg && (hash_mode == HASH_MODE_NONE) &&
171 		    (hash_type == HASH_TYPE_UPDT)) {
172 			char *name = "NONE";
173 
174 			switch (hash_alg) {
175 			case HASH_ALG_MD5:
176 				hash_state_len = 16;
177 				name = "MD5";
178 				break;
179 			case HASH_ALG_SHA1:
180 				hash_state_len = 20;
181 				name = "SHA1";
182 				break;
183 			case HASH_ALG_SHA224:
184 				hash_state_len = 32;
185 				name = "SHA224";
186 				break;
187 			case HASH_ALG_SHA256:
188 				hash_state_len = 32;
189 				name = "SHA256";
190 				break;
191 			case HASH_ALG_SHA384:
192 				hash_state_len = 48;
193 				name = "SHA384";
194 				break;
195 			case HASH_ALG_SHA512:
196 				hash_state_len = 64;
197 				name = "SHA512";
198 				break;
199 			case HASH_ALG_AES:
200 				hash_state_len = 0;
201 				name = "AES";
202 				break;
203 			case HASH_ALG_NONE:
204 				break;
205 			}
206 
207 			packet_log("    Auth State Type:%s Length:%u Bytes\n",
208 				   name, hash_state_len);
209 			packet_dump("    State: ", ptr, hash_state_len);
210 			ptr += hash_state_len;
211 		}
212 
213 		if (cipher_alg) {
214 			char *name = "NONE";
215 
216 			switch (cipher_alg) {
217 			case CIPHER_ALG_DES:
218 				cipher_key_len = 8;
219 				name = "DES";
220 				break;
221 			case CIPHER_ALG_3DES:
222 				cipher_key_len = 24;
223 				name = "3DES";
224 				break;
225 			case CIPHER_ALG_AES:
226 				switch (cipher_type) {
227 				case CIPHER_TYPE_AES128:
228 					cipher_key_len = 16;
229 					name = "AES128";
230 					break;
231 				case CIPHER_TYPE_AES192:
232 					cipher_key_len = 24;
233 					name = "AES192";
234 					break;
235 				case CIPHER_TYPE_AES256:
236 					cipher_key_len = 32;
237 					name = "AES256";
238 					break;
239 				}
240 				break;
241 			case CIPHER_ALG_NONE:
242 				break;
243 			}
244 
245 			packet_log("    Cipher Key Type:%s Length:%u Bytes\n",
246 				   name, cipher_key_len);
247 
248 			/* XTS has two keys */
249 			if (cipher_mode == CIPHER_MODE_XTS) {
250 				packet_dump("    KEY2: ", ptr, cipher_key_len);
251 				ptr += cipher_key_len;
252 				packet_dump("    KEY1: ", ptr, cipher_key_len);
253 				ptr += cipher_key_len;
254 
255 				cipher_key_len *= 2;
256 			} else {
257 				packet_dump("    KEY: ", ptr, cipher_key_len);
258 				ptr += cipher_key_len;
259 			}
260 
261 			if (ecf & SCTX_IV) {
262 				sctx_pl_len = sctx_size * sizeof(u32) -
263 					sizeof(struct SCTX);
264 				iv_len = sctx_pl_len -
265 					(hash_key_len + hash_state_len +
266 					 cipher_key_len);
267 				packet_log("    IV Length:%u Bytes\n", iv_len);
268 				packet_dump("    IV: ", ptr, iv_len);
269 				ptr += iv_len;
270 			}
271 		}
272 	}
273 
274 	/* ========== Decode BDESC ========== */
275 	if (spuh->mh.flags & MH_BDESC_PRES) {
276 		struct BDESC_HEADER *bdesc = (struct BDESC_HEADER *)ptr;
277 
278 		packet_log("  BDESC[0] 0x%08x\n", be32_to_cpup((__be32 *)ptr));
279 		packet_log("    OffsetMAC:%u LengthMAC:%u\n",
280 			   be16_to_cpu(bdesc->offset_mac),
281 			   be16_to_cpu(bdesc->length_mac));
282 		ptr += sizeof(u32);
283 
284 		packet_log("  BDESC[1] 0x%08x\n", be32_to_cpup((__be32 *)ptr));
285 		packet_log("    OffsetCrypto:%u LengthCrypto:%u\n",
286 			   be16_to_cpu(bdesc->offset_crypto),
287 			   be16_to_cpu(bdesc->length_crypto));
288 		ptr += sizeof(u32);
289 
290 		packet_log("  BDESC[2] 0x%08x\n", be32_to_cpup((__be32 *)ptr));
291 		packet_log("    OffsetICV:%u OffsetIV:%u\n",
292 			   be16_to_cpu(bdesc->offset_icv),
293 			   be16_to_cpu(bdesc->offset_iv));
294 		ptr += sizeof(u32);
295 	}
296 
297 	/* ========== Decode BD ========== */
298 	if (spuh->mh.flags & MH_BD_PRES) {
299 		struct BD_HEADER *bd = (struct BD_HEADER *)ptr;
300 
301 		packet_log("  BD[0] 0x%08x\n", be32_to_cpup((__be32 *)ptr));
302 		packet_log("    Size:%ubytes PrevLength:%u\n",
303 			   be16_to_cpu(bd->size), be16_to_cpu(bd->prev_length));
304 		ptr += 4;
305 	}
306 
307 	/* Double check sanity */
308 	if (buf + buf_len != ptr) {
309 		packet_log(" Packet parsed incorrectly. ");
310 		packet_log("buf:%p buf_len:%u buf+buf_len:%p ptr:%p\n",
311 			   buf, buf_len, buf + buf_len, ptr);
312 	}
313 
314 	packet_log("\n");
315 }
316 
317 /**
318  * spum_ns2_ctx_max_payload() - Determine the max length of the payload for a
319  * SPU message for a given cipher and hash alg context.
320  * @cipher_alg:		The cipher algorithm
321  * @cipher_mode:	The cipher mode
322  * @blocksize:		The size of a block of data for this algo
323  *
324  * The max payload must be a multiple of the blocksize so that if a request is
325  * too large to fit in a single SPU message, the request can be broken into
326  * max_payload sized chunks. Each chunk must be a multiple of blocksize.
327  *
328  * Return: Max payload length in bytes
329  */
spum_ns2_ctx_max_payload(enum spu_cipher_alg cipher_alg,enum spu_cipher_mode cipher_mode,unsigned int blocksize)330 u32 spum_ns2_ctx_max_payload(enum spu_cipher_alg cipher_alg,
331 			     enum spu_cipher_mode cipher_mode,
332 			     unsigned int blocksize)
333 {
334 	u32 max_payload = SPUM_NS2_MAX_PAYLOAD;
335 	u32 excess;
336 
337 	/* In XTS on SPU-M, we'll need to insert tweak before input data */
338 	if (cipher_mode == CIPHER_MODE_XTS)
339 		max_payload -= SPU_XTS_TWEAK_SIZE;
340 
341 	excess = max_payload % blocksize;
342 
343 	return max_payload - excess;
344 }
345 
346 /**
347  * spum_nsp_ctx_max_payload() - Determine the max length of the payload for a
348  * SPU message for a given cipher and hash alg context.
349  * @cipher_alg:		The cipher algorithm
350  * @cipher_mode:	The cipher mode
351  * @blocksize:		The size of a block of data for this algo
352  *
353  * The max payload must be a multiple of the blocksize so that if a request is
354  * too large to fit in a single SPU message, the request can be broken into
355  * max_payload sized chunks. Each chunk must be a multiple of blocksize.
356  *
357  * Return: Max payload length in bytes
358  */
spum_nsp_ctx_max_payload(enum spu_cipher_alg cipher_alg,enum spu_cipher_mode cipher_mode,unsigned int blocksize)359 u32 spum_nsp_ctx_max_payload(enum spu_cipher_alg cipher_alg,
360 			     enum spu_cipher_mode cipher_mode,
361 			     unsigned int blocksize)
362 {
363 	u32 max_payload = SPUM_NSP_MAX_PAYLOAD;
364 	u32 excess;
365 
366 	/* In XTS on SPU-M, we'll need to insert tweak before input data */
367 	if (cipher_mode == CIPHER_MODE_XTS)
368 		max_payload -= SPU_XTS_TWEAK_SIZE;
369 
370 	excess = max_payload % blocksize;
371 
372 	return max_payload - excess;
373 }
374 
375 /** spum_payload_length() - Given a SPU-M message header, extract the payload
376  * length.
377  * @spu_hdr:	Start of SPU header
378  *
379  * Assumes just MH, EMH, BD (no SCTX, BDESC. Works for response frames.
380  *
381  * Return: payload length in bytes
382  */
spum_payload_length(u8 * spu_hdr)383 u32 spum_payload_length(u8 *spu_hdr)
384 {
385 	struct BD_HEADER *bd;
386 	u32 pl_len;
387 
388 	/* Find BD header.  skip MH, EMH */
389 	bd = (struct BD_HEADER *)(spu_hdr + 8);
390 	pl_len = be16_to_cpu(bd->size);
391 
392 	return pl_len;
393 }
394 
395 /**
396  * spum_response_hdr_len() - Given the length of the hash key and encryption
397  * key, determine the expected length of a SPU response header.
398  * @auth_key_len:	authentication key length (bytes)
399  * @enc_key_len:	encryption key length (bytes)
400  * @is_hash:		true if response message is for a hash operation
401  *
402  * Return: length of SPU response header (bytes)
403  */
spum_response_hdr_len(u16 auth_key_len,u16 enc_key_len,bool is_hash)404 u16 spum_response_hdr_len(u16 auth_key_len, u16 enc_key_len, bool is_hash)
405 {
406 	if (is_hash)
407 		return SPU_HASH_RESP_HDR_LEN;
408 	else
409 		return SPU_RESP_HDR_LEN;
410 }
411 
412 /**
413  * spum_hash_pad_len() - Calculate the length of hash padding required to extend
414  * data to a full block size.
415  * @hash_alg:   hash algorithm
416  * @hash_mode:       hash mode
417  * @chunksize:  length of data, in bytes
418  * @hash_block_size:  size of a block of data for hash algorithm
419  *
420  * Reserve space for 1 byte (0x80) start of pad and the total length as u64
421  *
422  * Return:  length of hash pad in bytes
423  */
spum_hash_pad_len(enum hash_alg hash_alg,enum hash_mode hash_mode,u32 chunksize,u16 hash_block_size)424 u16 spum_hash_pad_len(enum hash_alg hash_alg, enum hash_mode hash_mode,
425 		      u32 chunksize, u16 hash_block_size)
426 {
427 	unsigned int length_len;
428 	unsigned int used_space_last_block;
429 	int hash_pad_len;
430 
431 	/* AES-XCBC hash requires just padding to next block boundary */
432 	if ((hash_alg == HASH_ALG_AES) && (hash_mode == HASH_MODE_XCBC)) {
433 		used_space_last_block = chunksize % hash_block_size;
434 		hash_pad_len = hash_block_size - used_space_last_block;
435 		if (hash_pad_len >= hash_block_size)
436 			hash_pad_len -= hash_block_size;
437 		return hash_pad_len;
438 	}
439 
440 	used_space_last_block = chunksize % hash_block_size + 1;
441 	if ((hash_alg == HASH_ALG_SHA384) || (hash_alg == HASH_ALG_SHA512))
442 		length_len = 2 * sizeof(u64);
443 	else
444 		length_len = sizeof(u64);
445 
446 	used_space_last_block += length_len;
447 	hash_pad_len = hash_block_size - used_space_last_block;
448 	if (hash_pad_len < 0)
449 		hash_pad_len += hash_block_size;
450 
451 	hash_pad_len += 1 + length_len;
452 	return hash_pad_len;
453 }
454 
455 /**
456  * spum_gcm_ccm_pad_len() - Determine the required length of GCM or CCM padding.
457  * @cipher_mode:	Algo type
458  * @data_size:		Length of plaintext (bytes)
459  *
460  * Return: Length of padding, in bytes
461  */
spum_gcm_ccm_pad_len(enum spu_cipher_mode cipher_mode,unsigned int data_size)462 u32 spum_gcm_ccm_pad_len(enum spu_cipher_mode cipher_mode,
463 			 unsigned int data_size)
464 {
465 	u32 pad_len = 0;
466 	u32 m1 = SPU_GCM_CCM_ALIGN - 1;
467 
468 	if ((cipher_mode == CIPHER_MODE_GCM) ||
469 	    (cipher_mode == CIPHER_MODE_CCM))
470 		pad_len = ((data_size + m1) & ~m1) - data_size;
471 
472 	return pad_len;
473 }
474 
475 /**
476  * spum_assoc_resp_len() - Determine the size of the receive buffer required to
477  * catch associated data.
478  * @cipher_mode:	cipher mode
479  * @assoc_len:		length of associated data (bytes)
480  * @iv_len:		length of IV (bytes)
481  * @is_encrypt:		true if encrypting. false if decrypting.
482  *
483  * Return: length of associated data in response message (bytes)
484  */
spum_assoc_resp_len(enum spu_cipher_mode cipher_mode,unsigned int assoc_len,unsigned int iv_len,bool is_encrypt)485 u32 spum_assoc_resp_len(enum spu_cipher_mode cipher_mode,
486 			unsigned int assoc_len, unsigned int iv_len,
487 			bool is_encrypt)
488 {
489 	u32 buflen = 0;
490 	u32 pad;
491 
492 	if (assoc_len)
493 		buflen = assoc_len;
494 
495 	if (cipher_mode == CIPHER_MODE_GCM) {
496 		/* AAD needs to be padded in responses too */
497 		pad = spum_gcm_ccm_pad_len(cipher_mode, buflen);
498 		buflen += pad;
499 	}
500 	if (cipher_mode == CIPHER_MODE_CCM) {
501 		/*
502 		 * AAD needs to be padded in responses too
503 		 * for CCM, len + 2 needs to be 128-bit aligned.
504 		 */
505 		pad = spum_gcm_ccm_pad_len(cipher_mode, buflen + 2);
506 		buflen += pad;
507 	}
508 
509 	return buflen;
510 }
511 
512 /**
513  * spum_aead_ivlen() - Calculate the length of the AEAD IV to be included
514  * in a SPU request after the AAD and before the payload.
515  * @cipher_mode:  cipher mode
516  * @iv_len:   initialization vector length in bytes
517  *
518  * In Linux ~4.2 and later, the assoc_data sg includes the IV. So no need
519  * to include the IV as a separate field in the SPU request msg.
520  *
521  * Return: Length of AEAD IV in bytes
522  */
spum_aead_ivlen(enum spu_cipher_mode cipher_mode,u16 iv_len)523 u8 spum_aead_ivlen(enum spu_cipher_mode cipher_mode, u16 iv_len)
524 {
525 	return 0;
526 }
527 
528 /**
529  * spum_hash_type() - Determine the type of hash operation.
530  * @src_sent:  The number of bytes in the current request that have already
531  *             been sent to the SPU to be hashed.
532  *
533  * We do not use HASH_TYPE_FULL for requests that fit in a single SPU message.
534  * Using FULL causes failures (such as when the string to be hashed is empty).
535  * For similar reasons, we never use HASH_TYPE_FIN. Instead, submit messages
536  * as INIT or UPDT and do the hash padding in sw.
537  */
spum_hash_type(u32 src_sent)538 enum hash_type spum_hash_type(u32 src_sent)
539 {
540 	return src_sent ? HASH_TYPE_UPDT : HASH_TYPE_INIT;
541 }
542 
543 /**
544  * spum_digest_size() - Determine the size of a hash digest to expect the SPU to
545  * return.
546  * @alg_digest_size: Number of bytes in the final digest for the given algo
547  * @alg:             The hash algorithm
548  * @htype:           Type of hash operation (init, update, full, etc)
549  *
550  * When doing incremental hashing for an algorithm with a truncated hash
551  * (e.g., SHA224), the SPU returns the full digest so that it can be fed back as
552  * a partial result for the next chunk.
553  */
spum_digest_size(u32 alg_digest_size,enum hash_alg alg,enum hash_type htype)554 u32 spum_digest_size(u32 alg_digest_size, enum hash_alg alg,
555 		     enum hash_type htype)
556 {
557 	u32 digestsize = alg_digest_size;
558 
559 	/* SPU returns complete digest when doing incremental hash and truncated
560 	 * hash algo.
561 	 */
562 	if ((htype == HASH_TYPE_INIT) || (htype == HASH_TYPE_UPDT)) {
563 		if (alg == HASH_ALG_SHA224)
564 			digestsize = SHA256_DIGEST_SIZE;
565 		else if (alg == HASH_ALG_SHA384)
566 			digestsize = SHA512_DIGEST_SIZE;
567 	}
568 	return digestsize;
569 }
570 
571 /**
572  * spum_create_request() - Build a SPU request message header, up to and
573  * including the BD header. Construct the message starting at spu_hdr. Caller
574  * should allocate this buffer in DMA-able memory at least SPU_HEADER_ALLOC_LEN
575  * bytes long.
576  * @spu_hdr: Start of buffer where SPU request header is to be written
577  * @req_opts: SPU request message options
578  * @cipher_parms: Parameters related to cipher algorithm
579  * @hash_parms:   Parameters related to hash algorithm
580  * @aead_parms:   Parameters related to AEAD operation
581  * @data_size:    Length of data to be encrypted or authenticated. If AEAD, does
582  *		  not include length of AAD.
583  *
584  * Return: the length of the SPU header in bytes. 0 if an error occurs.
585  */
spum_create_request(u8 * spu_hdr,struct spu_request_opts * req_opts,struct spu_cipher_parms * cipher_parms,struct spu_hash_parms * hash_parms,struct spu_aead_parms * aead_parms,unsigned int data_size)586 u32 spum_create_request(u8 *spu_hdr,
587 			struct spu_request_opts *req_opts,
588 			struct spu_cipher_parms *cipher_parms,
589 			struct spu_hash_parms *hash_parms,
590 			struct spu_aead_parms *aead_parms,
591 			unsigned int data_size)
592 {
593 	struct SPUHEADER *spuh;
594 	struct BDESC_HEADER *bdesc;
595 	struct BD_HEADER *bd;
596 
597 	u8 *ptr;
598 	u32 protocol_bits = 0;
599 	u32 cipher_bits = 0;
600 	u32 ecf_bits = 0;
601 	u8 sctx_words = 0;
602 	unsigned int buf_len = 0;
603 
604 	/* size of the cipher payload */
605 	unsigned int cipher_len = hash_parms->prebuf_len + data_size +
606 				hash_parms->pad_len;
607 
608 	/* offset of prebuf or data from end of BD header */
609 	unsigned int cipher_offset = aead_parms->assoc_size +
610 		aead_parms->iv_len + aead_parms->aad_pad_len;
611 
612 	/* total size of the DB data (without STAT word padding) */
613 	unsigned int real_db_size = spu_real_db_size(aead_parms->assoc_size,
614 						 aead_parms->iv_len,
615 						 hash_parms->prebuf_len,
616 						 data_size,
617 						 aead_parms->aad_pad_len,
618 						 aead_parms->data_pad_len,
619 						 hash_parms->pad_len);
620 
621 	unsigned int auth_offset = 0;
622 	unsigned int offset_iv = 0;
623 
624 	/* size/offset of the auth payload */
625 	unsigned int auth_len;
626 
627 	auth_len = real_db_size;
628 
629 	if (req_opts->is_aead && req_opts->is_inbound)
630 		cipher_len -= hash_parms->digestsize;
631 
632 	if (req_opts->is_aead && req_opts->is_inbound)
633 		auth_len -= hash_parms->digestsize;
634 
635 	if ((hash_parms->alg == HASH_ALG_AES) &&
636 	    (hash_parms->mode == HASH_MODE_XCBC)) {
637 		auth_len -= hash_parms->pad_len;
638 		cipher_len -= hash_parms->pad_len;
639 	}
640 
641 	flow_log("%s()\n", __func__);
642 	flow_log("  in:%u authFirst:%u\n",
643 		 req_opts->is_inbound, req_opts->auth_first);
644 	flow_log("  %s. cipher alg:%u mode:%u type %u\n",
645 		 spu_alg_name(cipher_parms->alg, cipher_parms->mode),
646 		 cipher_parms->alg, cipher_parms->mode, cipher_parms->type);
647 	flow_log("    key: %d\n", cipher_parms->key_len);
648 	flow_dump("    key: ", cipher_parms->key_buf, cipher_parms->key_len);
649 	flow_log("    iv: %d\n", cipher_parms->iv_len);
650 	flow_dump("    iv: ", cipher_parms->iv_buf, cipher_parms->iv_len);
651 	flow_log("  auth alg:%u mode:%u type %u\n",
652 		 hash_parms->alg, hash_parms->mode, hash_parms->type);
653 	flow_log("  digestsize: %u\n", hash_parms->digestsize);
654 	flow_log("  authkey: %d\n", hash_parms->key_len);
655 	flow_dump("  authkey: ", hash_parms->key_buf, hash_parms->key_len);
656 	flow_log("  assoc_size:%u\n", aead_parms->assoc_size);
657 	flow_log("  prebuf_len:%u\n", hash_parms->prebuf_len);
658 	flow_log("  data_size:%u\n", data_size);
659 	flow_log("  hash_pad_len:%u\n", hash_parms->pad_len);
660 	flow_log("  real_db_size:%u\n", real_db_size);
661 	flow_log(" auth_offset:%u auth_len:%u cipher_offset:%u cipher_len:%u\n",
662 		 auth_offset, auth_len, cipher_offset, cipher_len);
663 	flow_log("  aead_iv: %u\n", aead_parms->iv_len);
664 
665 	/* starting out: zero the header (plus some) */
666 	ptr = spu_hdr;
667 	memset(ptr, 0, sizeof(struct SPUHEADER));
668 
669 	/* format master header word */
670 	/* Do not set the next bit even though the datasheet says to */
671 	spuh = (struct SPUHEADER *)ptr;
672 	ptr += sizeof(struct SPUHEADER);
673 	buf_len += sizeof(struct SPUHEADER);
674 
675 	spuh->mh.op_code = SPU_CRYPTO_OPERATION_GENERIC;
676 	spuh->mh.flags |= (MH_SCTX_PRES | MH_BDESC_PRES | MH_BD_PRES);
677 
678 	/* Format sctx word 0 (protocol_bits) */
679 	sctx_words = 3;		/* size in words */
680 
681 	/* Format sctx word 1 (cipher_bits) */
682 	if (req_opts->is_inbound)
683 		cipher_bits |= CIPHER_INBOUND;
684 	if (req_opts->auth_first)
685 		cipher_bits |= CIPHER_ORDER;
686 
687 	/* Set the crypto parameters in the cipher.flags */
688 	cipher_bits |= cipher_parms->alg << CIPHER_ALG_SHIFT;
689 	cipher_bits |= cipher_parms->mode << CIPHER_MODE_SHIFT;
690 	cipher_bits |= cipher_parms->type << CIPHER_TYPE_SHIFT;
691 
692 	/* Set the auth parameters in the cipher.flags */
693 	cipher_bits |= hash_parms->alg << HASH_ALG_SHIFT;
694 	cipher_bits |= hash_parms->mode << HASH_MODE_SHIFT;
695 	cipher_bits |= hash_parms->type << HASH_TYPE_SHIFT;
696 
697 	/*
698 	 * Format sctx extensions if required, and update main fields if
699 	 * required)
700 	 */
701 	if (hash_parms->alg) {
702 		/* Write the authentication key material if present */
703 		if (hash_parms->key_len) {
704 			memcpy(ptr, hash_parms->key_buf, hash_parms->key_len);
705 			ptr += hash_parms->key_len;
706 			buf_len += hash_parms->key_len;
707 			sctx_words += hash_parms->key_len / 4;
708 		}
709 
710 		if ((cipher_parms->mode == CIPHER_MODE_GCM) ||
711 		    (cipher_parms->mode == CIPHER_MODE_CCM))
712 			/* unpadded length */
713 			offset_iv = aead_parms->assoc_size;
714 
715 		/* if GCM/CCM we need to write ICV into the payload */
716 		if (!req_opts->is_inbound) {
717 			if ((cipher_parms->mode == CIPHER_MODE_GCM) ||
718 			    (cipher_parms->mode == CIPHER_MODE_CCM))
719 				ecf_bits |= 1 << INSERT_ICV_SHIFT;
720 		} else {
721 			ecf_bits |= CHECK_ICV;
722 		}
723 
724 		/* Inform the SPU of the ICV size (in words) */
725 		if (hash_parms->digestsize == 64)
726 			cipher_bits |= ICV_IS_512;
727 		else
728 			ecf_bits |=
729 			(hash_parms->digestsize / 4) << ICV_SIZE_SHIFT;
730 	}
731 
732 	if (req_opts->bd_suppress)
733 		ecf_bits |= BD_SUPPRESS;
734 
735 	/* copy the encryption keys in the SAD entry */
736 	if (cipher_parms->alg) {
737 		if (cipher_parms->key_len) {
738 			memcpy(ptr, cipher_parms->key_buf,
739 			       cipher_parms->key_len);
740 			ptr += cipher_parms->key_len;
741 			buf_len += cipher_parms->key_len;
742 			sctx_words += cipher_parms->key_len / 4;
743 		}
744 
745 		/*
746 		 * if encrypting then set IV size, use SCTX IV unless no IV
747 		 * given here
748 		 */
749 		if (cipher_parms->iv_buf && cipher_parms->iv_len) {
750 			/* Use SCTX IV */
751 			ecf_bits |= SCTX_IV;
752 
753 			/* cipher iv provided so put it in here */
754 			memcpy(ptr, cipher_parms->iv_buf, cipher_parms->iv_len);
755 
756 			ptr += cipher_parms->iv_len;
757 			buf_len += cipher_parms->iv_len;
758 			sctx_words += cipher_parms->iv_len / 4;
759 		}
760 	}
761 
762 	/*
763 	 * RFC4543 (GMAC/ESP) requires data to be sent as part of AAD
764 	 * so we need to override the BDESC parameters.
765 	 */
766 	if (req_opts->is_rfc4543) {
767 		if (req_opts->is_inbound)
768 			data_size -= hash_parms->digestsize;
769 		offset_iv = aead_parms->assoc_size + data_size;
770 		cipher_len = 0;
771 		cipher_offset = offset_iv;
772 		auth_len = cipher_offset + aead_parms->data_pad_len;
773 	}
774 
775 	/* write in the total sctx length now that we know it */
776 	protocol_bits |= sctx_words;
777 
778 	/* Endian adjust the SCTX */
779 	spuh->sa.proto_flags = cpu_to_be32(protocol_bits);
780 	spuh->sa.cipher_flags = cpu_to_be32(cipher_bits);
781 	spuh->sa.ecf = cpu_to_be32(ecf_bits);
782 
783 	/* === create the BDESC section === */
784 	bdesc = (struct BDESC_HEADER *)ptr;
785 
786 	bdesc->offset_mac = cpu_to_be16(auth_offset);
787 	bdesc->length_mac = cpu_to_be16(auth_len);
788 	bdesc->offset_crypto = cpu_to_be16(cipher_offset);
789 	bdesc->length_crypto = cpu_to_be16(cipher_len);
790 
791 	/*
792 	 * CCM in SPU-M requires that ICV not be in same 32-bit word as data or
793 	 * padding.  So account for padding as necessary.
794 	 */
795 	if (cipher_parms->mode == CIPHER_MODE_CCM)
796 		auth_len += spum_wordalign_padlen(auth_len);
797 
798 	bdesc->offset_icv = cpu_to_be16(auth_len);
799 	bdesc->offset_iv = cpu_to_be16(offset_iv);
800 
801 	ptr += sizeof(struct BDESC_HEADER);
802 	buf_len += sizeof(struct BDESC_HEADER);
803 
804 	/* === no MFM section === */
805 
806 	/* === create the BD section === */
807 
808 	/* add the BD header */
809 	bd = (struct BD_HEADER *)ptr;
810 	bd->size = cpu_to_be16(real_db_size);
811 	bd->prev_length = 0;
812 
813 	ptr += sizeof(struct BD_HEADER);
814 	buf_len += sizeof(struct BD_HEADER);
815 
816 	packet_dump("  SPU request header: ", spu_hdr, buf_len);
817 
818 	return buf_len;
819 }
820 
821 /**
822  * spum_cipher_req_init() - Build a SPU request message header, up to and
823  * including the BD header.
824  * @spu_hdr:      Start of SPU request header (MH)
825  * @cipher_parms: Parameters that describe the cipher request
826  *
827  * Construct the message starting at spu_hdr. Caller should allocate this buffer
828  * in DMA-able memory at least SPU_HEADER_ALLOC_LEN bytes long.
829  *
830  * Return: the length of the SPU header in bytes. 0 if an error occurs.
831  */
spum_cipher_req_init(u8 * spu_hdr,struct spu_cipher_parms * cipher_parms)832 u16 spum_cipher_req_init(u8 *spu_hdr, struct spu_cipher_parms *cipher_parms)
833 {
834 	struct SPUHEADER *spuh;
835 	u32 protocol_bits = 0;
836 	u32 cipher_bits = 0;
837 	u32 ecf_bits = 0;
838 	u8 sctx_words = 0;
839 	u8 *ptr = spu_hdr;
840 
841 	flow_log("%s()\n", __func__);
842 	flow_log("  cipher alg:%u mode:%u type %u\n", cipher_parms->alg,
843 		 cipher_parms->mode, cipher_parms->type);
844 	flow_log("  cipher_iv_len: %u\n", cipher_parms->iv_len);
845 	flow_log("    key: %d\n", cipher_parms->key_len);
846 	flow_dump("    key: ", cipher_parms->key_buf, cipher_parms->key_len);
847 
848 	/* starting out: zero the header (plus some) */
849 	memset(spu_hdr, 0, sizeof(struct SPUHEADER));
850 	ptr += sizeof(struct SPUHEADER);
851 
852 	/* format master header word */
853 	/* Do not set the next bit even though the datasheet says to */
854 	spuh = (struct SPUHEADER *)spu_hdr;
855 
856 	spuh->mh.op_code = SPU_CRYPTO_OPERATION_GENERIC;
857 	spuh->mh.flags |= (MH_SCTX_PRES | MH_BDESC_PRES | MH_BD_PRES);
858 
859 	/* Format sctx word 0 (protocol_bits) */
860 	sctx_words = 3;		/* size in words */
861 
862 	/* copy the encryption keys in the SAD entry */
863 	if (cipher_parms->alg) {
864 		if (cipher_parms->key_len) {
865 			ptr += cipher_parms->key_len;
866 			sctx_words += cipher_parms->key_len / 4;
867 		}
868 
869 		/*
870 		 * if encrypting then set IV size, use SCTX IV unless no IV
871 		 * given here
872 		 */
873 		if (cipher_parms->iv_len) {
874 			/* Use SCTX IV */
875 			ecf_bits |= SCTX_IV;
876 			ptr += cipher_parms->iv_len;
877 			sctx_words += cipher_parms->iv_len / 4;
878 		}
879 	}
880 
881 	/* Set the crypto parameters in the cipher.flags */
882 	cipher_bits |= cipher_parms->alg << CIPHER_ALG_SHIFT;
883 	cipher_bits |= cipher_parms->mode << CIPHER_MODE_SHIFT;
884 	cipher_bits |= cipher_parms->type << CIPHER_TYPE_SHIFT;
885 
886 	/* copy the encryption keys in the SAD entry */
887 	if (cipher_parms->alg && cipher_parms->key_len)
888 		memcpy(spuh + 1, cipher_parms->key_buf, cipher_parms->key_len);
889 
890 	/* write in the total sctx length now that we know it */
891 	protocol_bits |= sctx_words;
892 
893 	/* Endian adjust the SCTX */
894 	spuh->sa.proto_flags = cpu_to_be32(protocol_bits);
895 
896 	/* Endian adjust the SCTX */
897 	spuh->sa.cipher_flags = cpu_to_be32(cipher_bits);
898 	spuh->sa.ecf = cpu_to_be32(ecf_bits);
899 
900 	packet_dump("  SPU request header: ", spu_hdr,
901 		    sizeof(struct SPUHEADER));
902 
903 	return sizeof(struct SPUHEADER) + cipher_parms->key_len +
904 		cipher_parms->iv_len + sizeof(struct BDESC_HEADER) +
905 		sizeof(struct BD_HEADER);
906 }
907 
908 /**
909  * spum_cipher_req_finish() - Finish building a SPU request message header for a
910  * block cipher request. Assumes much of the header was already filled in at
911  * setkey() time in spu_cipher_req_init().
912  * @spu_hdr:         Start of the request message header (MH field)
913  * @spu_req_hdr_len: Length in bytes of the SPU request header
914  * @is_inbound:      0 encrypt, 1 decrypt
915  * @cipher_parms:    Parameters describing cipher operation to be performed
916  * @data_size:       Length of the data in the BD field
917  *
918  * Assumes much of the header was already filled in at setkey() time in
919  * spum_cipher_req_init().
920  * spum_cipher_req_init() fills in the encryption key.
921  */
spum_cipher_req_finish(u8 * spu_hdr,u16 spu_req_hdr_len,unsigned int is_inbound,struct spu_cipher_parms * cipher_parms,unsigned int data_size)922 void spum_cipher_req_finish(u8 *spu_hdr,
923 			    u16 spu_req_hdr_len,
924 			    unsigned int is_inbound,
925 			    struct spu_cipher_parms *cipher_parms,
926 			    unsigned int data_size)
927 {
928 	struct SPUHEADER *spuh;
929 	struct BDESC_HEADER *bdesc;
930 	struct BD_HEADER *bd;
931 	u8 *bdesc_ptr = spu_hdr + spu_req_hdr_len -
932 	    (sizeof(struct BD_HEADER) + sizeof(struct BDESC_HEADER));
933 
934 	u32 cipher_bits;
935 
936 	flow_log("%s()\n", __func__);
937 	flow_log(" in: %u\n", is_inbound);
938 	flow_log(" cipher alg: %u, cipher_type: %u\n", cipher_parms->alg,
939 		 cipher_parms->type);
940 
941 	/*
942 	 * In XTS mode, API puts "i" parameter (block tweak) in IV.  For
943 	 * SPU-M, should be in start of the BD; tx_sg_create() copies it there.
944 	 * IV in SPU msg for SPU-M should be 0, since that's the "j" parameter
945 	 * (block ctr within larger data unit) - given we can send entire disk
946 	 * block (<= 4KB) in 1 SPU msg, don't need to use this parameter.
947 	 */
948 	if (cipher_parms->mode == CIPHER_MODE_XTS)
949 		memset(cipher_parms->iv_buf, 0, cipher_parms->iv_len);
950 
951 	flow_log(" iv len: %d\n", cipher_parms->iv_len);
952 	flow_dump("    iv: ", cipher_parms->iv_buf, cipher_parms->iv_len);
953 	flow_log(" data_size: %u\n", data_size);
954 
955 	/* format master header word */
956 	/* Do not set the next bit even though the datasheet says to */
957 	spuh = (struct SPUHEADER *)spu_hdr;
958 
959 	/* cipher_bits was initialized at setkey time */
960 	cipher_bits = be32_to_cpu(spuh->sa.cipher_flags);
961 
962 	/* Format sctx word 1 (cipher_bits) */
963 	if (is_inbound)
964 		cipher_bits |= CIPHER_INBOUND;
965 	else
966 		cipher_bits &= ~CIPHER_INBOUND;
967 
968 	if (cipher_parms->alg && cipher_parms->iv_buf && cipher_parms->iv_len)
969 		/* cipher iv provided so put it in here */
970 		memcpy(bdesc_ptr - cipher_parms->iv_len, cipher_parms->iv_buf,
971 		       cipher_parms->iv_len);
972 
973 	spuh->sa.cipher_flags = cpu_to_be32(cipher_bits);
974 
975 	/* === create the BDESC section === */
976 	bdesc = (struct BDESC_HEADER *)bdesc_ptr;
977 	bdesc->offset_mac = 0;
978 	bdesc->length_mac = 0;
979 	bdesc->offset_crypto = 0;
980 
981 	/* XTS mode, data_size needs to include tweak parameter */
982 	if (cipher_parms->mode == CIPHER_MODE_XTS)
983 		bdesc->length_crypto = cpu_to_be16(data_size +
984 						  SPU_XTS_TWEAK_SIZE);
985 	else
986 		bdesc->length_crypto = cpu_to_be16(data_size);
987 
988 	bdesc->offset_icv = 0;
989 	bdesc->offset_iv = 0;
990 
991 	/* === no MFM section === */
992 
993 	/* === create the BD section === */
994 	/* add the BD header */
995 	bd = (struct BD_HEADER *)(bdesc_ptr + sizeof(struct BDESC_HEADER));
996 	bd->size = cpu_to_be16(data_size);
997 
998 	/* XTS mode, data_size needs to include tweak parameter */
999 	if (cipher_parms->mode == CIPHER_MODE_XTS)
1000 		bd->size = cpu_to_be16(data_size + SPU_XTS_TWEAK_SIZE);
1001 	else
1002 		bd->size = cpu_to_be16(data_size);
1003 
1004 	bd->prev_length = 0;
1005 
1006 	packet_dump("  SPU request header: ", spu_hdr, spu_req_hdr_len);
1007 }
1008 
1009 /**
1010  * spum_request_pad() - Create pad bytes at the end of the data.
1011  * @pad_start:		Start of buffer where pad bytes are to be written
1012  * @gcm_ccm_padding:	length of GCM/CCM padding, in bytes
1013  * @hash_pad_len:	Number of bytes of padding extend data to full block
1014  * @auth_alg:		authentication algorithm
1015  * @auth_mode:		authentication mode
1016  * @total_sent:		length inserted at end of hash pad
1017  * @status_padding:	Number of bytes of padding to align STATUS word
1018  *
1019  * There may be three forms of pad:
1020  *  1. GCM/CCM pad - for GCM/CCM mode ciphers, pad to 16-byte alignment
1021  *  2. hash pad - pad to a block length, with 0x80 data terminator and
1022  *                size at the end
1023  *  3. STAT pad - to ensure the STAT field is 4-byte aligned
1024  */
spum_request_pad(u8 * pad_start,u32 gcm_ccm_padding,u32 hash_pad_len,enum hash_alg auth_alg,enum hash_mode auth_mode,unsigned int total_sent,u32 status_padding)1025 void spum_request_pad(u8 *pad_start,
1026 		      u32 gcm_ccm_padding,
1027 		      u32 hash_pad_len,
1028 		      enum hash_alg auth_alg,
1029 		      enum hash_mode auth_mode,
1030 		      unsigned int total_sent, u32 status_padding)
1031 {
1032 	u8 *ptr = pad_start;
1033 
1034 	/* fix data alignent for GCM/CCM */
1035 	if (gcm_ccm_padding > 0) {
1036 		flow_log("  GCM: padding to 16 byte alignment: %u bytes\n",
1037 			 gcm_ccm_padding);
1038 		memset(ptr, 0, gcm_ccm_padding);
1039 		ptr += gcm_ccm_padding;
1040 	}
1041 
1042 	if (hash_pad_len > 0) {
1043 		/* clear the padding section */
1044 		memset(ptr, 0, hash_pad_len);
1045 
1046 		if ((auth_alg == HASH_ALG_AES) &&
1047 		    (auth_mode == HASH_MODE_XCBC)) {
1048 			/* AES/XCBC just requires padding to be 0s */
1049 			ptr += hash_pad_len;
1050 		} else {
1051 			/* terminate the data */
1052 			*ptr = 0x80;
1053 			ptr += (hash_pad_len - sizeof(u64));
1054 
1055 			/* add the size at the end as required per alg */
1056 			if (auth_alg == HASH_ALG_MD5)
1057 				*(__le64 *)ptr = cpu_to_le64(total_sent * 8ull);
1058 			else		/* SHA1, SHA2-224, SHA2-256 */
1059 				*(__be64 *)ptr = cpu_to_be64(total_sent * 8ull);
1060 			ptr += sizeof(u64);
1061 		}
1062 	}
1063 
1064 	/* pad to a 4byte alignment for STAT */
1065 	if (status_padding > 0) {
1066 		flow_log("  STAT: padding to 4 byte alignment: %u bytes\n",
1067 			 status_padding);
1068 
1069 		memset(ptr, 0, status_padding);
1070 		ptr += status_padding;
1071 	}
1072 }
1073 
1074 /**
1075  * spum_xts_tweak_in_payload() - Indicate that SPUM DOES place the XTS tweak
1076  * field in the packet payload (rather than using IV)
1077  *
1078  * Return: 1
1079  */
spum_xts_tweak_in_payload(void)1080 u8 spum_xts_tweak_in_payload(void)
1081 {
1082 	return 1;
1083 }
1084 
1085 /**
1086  * spum_tx_status_len() - Return the length of the STATUS field in a SPU
1087  * response message.
1088  *
1089  * Return: Length of STATUS field in bytes.
1090  */
spum_tx_status_len(void)1091 u8 spum_tx_status_len(void)
1092 {
1093 	return SPU_TX_STATUS_LEN;
1094 }
1095 
1096 /**
1097  * spum_rx_status_len() - Return the length of the STATUS field in a SPU
1098  * response message.
1099  *
1100  * Return: Length of STATUS field in bytes.
1101  */
spum_rx_status_len(void)1102 u8 spum_rx_status_len(void)
1103 {
1104 	return SPU_RX_STATUS_LEN;
1105 }
1106 
1107 /**
1108  * spum_status_process() - Process the status from a SPU response message.
1109  * @statp:  start of STATUS word
1110  * Return:
1111  *   0 - if status is good and response should be processed
1112  *   !0 - status indicates an error and response is invalid
1113  */
spum_status_process(u8 * statp)1114 int spum_status_process(u8 *statp)
1115 {
1116 	u32 status;
1117 
1118 	status = __be32_to_cpu(*(__be32 *)statp);
1119 	flow_log("SPU response STATUS %#08x\n", status);
1120 	if (status & SPU_STATUS_ERROR_FLAG) {
1121 		pr_err("%s() Warning: Error result from SPU: %#08x\n",
1122 		       __func__, status);
1123 		if (status & SPU_STATUS_INVALID_ICV)
1124 			return SPU_INVALID_ICV;
1125 		return -EBADMSG;
1126 	}
1127 	return 0;
1128 }
1129 
1130 /**
1131  * spum_ccm_update_iv() - Update the IV as per the requirements for CCM mode.
1132  *
1133  * @digestsize:		Digest size of this request
1134  * @cipher_parms:	(pointer to) cipher parmaeters, includes IV buf & IV len
1135  * @assoclen:		Length of AAD data
1136  * @chunksize:		length of input data to be sent in this req
1137  * @is_encrypt:		true if this is an output/encrypt operation
1138  * @is_esp:		true if this is an ESP / RFC4309 operation
1139  *
1140  */
spum_ccm_update_iv(unsigned int digestsize,struct spu_cipher_parms * cipher_parms,unsigned int assoclen,unsigned int chunksize,bool is_encrypt,bool is_esp)1141 void spum_ccm_update_iv(unsigned int digestsize,
1142 			struct spu_cipher_parms *cipher_parms,
1143 			unsigned int assoclen,
1144 			unsigned int chunksize,
1145 			bool is_encrypt,
1146 			bool is_esp)
1147 {
1148 	u8 L;		/* L from CCM algorithm, length of plaintext data */
1149 	u8 mprime;	/* M' from CCM algo, (M - 2) / 2, where M=authsize */
1150 	u8 adata;
1151 
1152 	if (cipher_parms->iv_len != CCM_AES_IV_SIZE) {
1153 		pr_err("%s(): Invalid IV len %d for CCM mode, should be %d\n",
1154 		       __func__, cipher_parms->iv_len, CCM_AES_IV_SIZE);
1155 		return;
1156 	}
1157 
1158 	/*
1159 	 * IV needs to be formatted as follows:
1160 	 *
1161 	 * |          Byte 0               | Bytes 1 - N | Bytes (N+1) - 15 |
1162 	 * | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 | Bits 7 - 0  |    Bits 7 - 0    |
1163 	 * | 0 |Ad?|(M - 2) / 2|   L - 1   |    Nonce    | Plaintext Length |
1164 	 *
1165 	 * Ad? = 1 if AAD present, 0 if not present
1166 	 * M = size of auth field, 8, 12, or 16 bytes (SPU-M) -or-
1167 	 *                         4, 6, 8, 10, 12, 14, 16 bytes (SPU2)
1168 	 * L = Size of Plaintext Length field; Nonce size = 15 - L
1169 	 *
1170 	 * It appears that the crypto API already expects the L-1 portion
1171 	 * to be set in the first byte of the IV, which implicitly determines
1172 	 * the nonce size, and also fills in the nonce.  But the other bits
1173 	 * in byte 0 as well as the plaintext length need to be filled in.
1174 	 *
1175 	 * In rfc4309/esp mode, L is not already in the supplied IV and
1176 	 * we need to fill it in, as well as move the IV data to be after
1177 	 * the salt
1178 	 */
1179 	if (is_esp) {
1180 		L = CCM_ESP_L_VALUE;	/* RFC4309 has fixed L */
1181 	} else {
1182 		/* L' = plaintext length - 1 so Plaintext length is L' + 1 */
1183 		L = ((cipher_parms->iv_buf[0] & CCM_B0_L_PRIME) >>
1184 		      CCM_B0_L_PRIME_SHIFT) + 1;
1185 	}
1186 
1187 	mprime = (digestsize - 2) >> 1;  /* M' = (M - 2) / 2 */
1188 	adata = (assoclen > 0);  /* adata = 1 if any associated data */
1189 
1190 	cipher_parms->iv_buf[0] = (adata << CCM_B0_ADATA_SHIFT) |
1191 				  (mprime << CCM_B0_M_PRIME_SHIFT) |
1192 				  ((L - 1) << CCM_B0_L_PRIME_SHIFT);
1193 
1194 	/* Nonce is already filled in by crypto API, and is 15 - L bytes */
1195 
1196 	/* Don't include digest in plaintext size when decrypting */
1197 	if (!is_encrypt)
1198 		chunksize -= digestsize;
1199 
1200 	/* Fill in length of plaintext, formatted to be L bytes long */
1201 	format_value_ccm(chunksize, &cipher_parms->iv_buf[15 - L + 1], L);
1202 }
1203 
1204 /**
1205  * spum_wordalign_padlen() - Given the length of a data field, determine the
1206  * padding required to align the data following this field on a 4-byte boundary.
1207  * @data_size: length of data field in bytes
1208  *
1209  * Return: length of status field padding, in bytes
1210  */
spum_wordalign_padlen(u32 data_size)1211 u32 spum_wordalign_padlen(u32 data_size)
1212 {
1213 	return ((data_size + 3) & ~3) - data_size;
1214 }
1215