drivers/crypto/chelsio/chcr_algo.h - linux - Git at Google

 /*
  * This file is part of the Chelsio T6 Crypto driver for Linux.
  *
  * Copyright (c) 2003-2016 Chelsio Communications, Inc. All rights reserved.
  *
  * This software is available to you under a choice of one of two
  * licenses.  You may choose to be licensed under the terms of the GNU
  * General Public License (GPL) Version 2, available from the file
  * COPYING in the main directory of this source tree, or the
  * OpenIB.org BSD license below:
  *
  *     Redistribution and use in source and binary forms, with or
  *     without modification, are permitted provided that the following
  *     conditions are met:
  *
  *      - Redistributions of source code must retain the above
  *        copyright notice, this list of conditions and the following
  *        disclaimer.
  *
  *      - Redistributions in binary form must reproduce the above
  *        copyright notice, this list of conditions and the following
  *        disclaimer in the documentation and/or other materials
  *        provided with the distribution.
  *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  *
  */

 #ifndef __CHCR_ALGO_H__
 #define __CHCR_ALGO_H__

 /* Crypto key context */
 #define KEY_CONTEXT_CTX_LEN_S           24
 #define KEY_CONTEXT_CTX_LEN_M           0xff
 #define KEY_CONTEXT_CTX_LEN_V(x)        ((x) << KEY_CONTEXT_CTX_LEN_S)
 #define KEY_CONTEXT_CTX_LEN_G(x) \
 	(((x) >> KEY_CONTEXT_CTX_LEN_S) & KEY_CONTEXT_CTX_LEN_M)

 #define KEY_CONTEXT_DUAL_CK_S      12
 #define KEY_CONTEXT_DUAL_CK_M      0x1
 #define KEY_CONTEXT_DUAL_CK_V(x)   ((x) << KEY_CONTEXT_DUAL_CK_S)
 #define KEY_CONTEXT_DUAL_CK_G(x)   \
 (((x) >> KEY_CONTEXT_DUAL_CK_S) & KEY_CONTEXT_DUAL_CK_M)
 #define KEY_CONTEXT_DUAL_CK_F      KEY_CONTEXT_DUAL_CK_V(1U)

 #define KEY_CONTEXT_SALT_PRESENT_S      10
 #define KEY_CONTEXT_SALT_PRESENT_M      0x1
 #define KEY_CONTEXT_SALT_PRESENT_V(x)   ((x) << KEY_CONTEXT_SALT_PRESENT_S)
 #define KEY_CONTEXT_SALT_PRESENT_G(x)   \
 	(((x) >> KEY_CONTEXT_SALT_PRESENT_S) & \
 	 KEY_CONTEXT_SALT_PRESENT_M)
 #define KEY_CONTEXT_SALT_PRESENT_F      KEY_CONTEXT_SALT_PRESENT_V(1U)

 #define KEY_CONTEXT_VALID_S     0
 #define KEY_CONTEXT_VALID_M     0x1
 #define KEY_CONTEXT_VALID_V(x)  ((x) << KEY_CONTEXT_VALID_S)
 #define KEY_CONTEXT_VALID_G(x)  \
 	(((x) >> KEY_CONTEXT_VALID_S) & \
 	 KEY_CONTEXT_VALID_M)
 #define KEY_CONTEXT_VALID_F     KEY_CONTEXT_VALID_V(1U)

 #define KEY_CONTEXT_CK_SIZE_S           6
 #define KEY_CONTEXT_CK_SIZE_M           0xf
 #define KEY_CONTEXT_CK_SIZE_V(x)        ((x) << KEY_CONTEXT_CK_SIZE_S)
 #define KEY_CONTEXT_CK_SIZE_G(x)        \
 	(((x) >> KEY_CONTEXT_CK_SIZE_S) & KEY_CONTEXT_CK_SIZE_M)

 #define KEY_CONTEXT_MK_SIZE_S           2
 #define KEY_CONTEXT_MK_SIZE_M           0xf
 #define KEY_CONTEXT_MK_SIZE_V(x)        ((x) << KEY_CONTEXT_MK_SIZE_S)
 #define KEY_CONTEXT_MK_SIZE_G(x)        \
 	(((x) >> KEY_CONTEXT_MK_SIZE_S) & KEY_CONTEXT_MK_SIZE_M)

 #define KEY_CONTEXT_OPAD_PRESENT_S      11
 #define KEY_CONTEXT_OPAD_PRESENT_M      0x1
 #define KEY_CONTEXT_OPAD_PRESENT_V(x)   ((x) << KEY_CONTEXT_OPAD_PRESENT_S)
 #define KEY_CONTEXT_OPAD_PRESENT_G(x)   \
 	(((x) >> KEY_CONTEXT_OPAD_PRESENT_S) & \
 	 KEY_CONTEXT_OPAD_PRESENT_M)
 #define KEY_CONTEXT_OPAD_PRESENT_F      KEY_CONTEXT_OPAD_PRESENT_V(1U)

 #define CHCR_HASH_MAX_DIGEST_SIZE 64
 #define CHCR_MAX_SHA_DIGEST_SIZE 64

 #define IPSEC_TRUNCATED_ICV_SIZE 12
 #define TLS_TRUNCATED_HMAC_SIZE 10
 #define CBCMAC_DIGEST_SIZE 16
 #define MAX_HASH_NAME 20

 #define SHA1_INIT_STATE_5X4B    5
 #define SHA256_INIT_STATE_8X4B  8
 #define SHA512_INIT_STATE_8X8B  8
 #define SHA1_INIT_STATE         SHA1_INIT_STATE_5X4B
 #define SHA224_INIT_STATE       SHA256_INIT_STATE_8X4B
 #define SHA256_INIT_STATE       SHA256_INIT_STATE_8X4B
 #define SHA384_INIT_STATE       SHA512_INIT_STATE_8X8B
 #define SHA512_INIT_STATE       SHA512_INIT_STATE_8X8B

 #define DUMMY_BYTES 16

 #define IPAD_DATA 0x36363636
 #define OPAD_DATA 0x5c5c5c5c

 #define TRANSHDR_SIZE(kctx_len)\
 	(sizeof(struct chcr_wr) +\
 	 kctx_len)
 #define CIPHER_TRANSHDR_SIZE(kctx_len, sge_pairs) \
 	(TRANSHDR_SIZE((kctx_len)) + (sge_pairs) +\
 	 sizeof(struct cpl_rx_phys_dsgl))
 #define HASH_TRANSHDR_SIZE(kctx_len)\
 	(TRANSHDR_SIZE(kctx_len) + DUMMY_BYTES)


 #define FILL_SEC_CPL_OP_IVINSR(id, len, ofst)      \
 	htonl( \
 	       CPL_TX_SEC_PDU_OPCODE_V(CPL_TX_SEC_PDU) | \
 	       CPL_TX_SEC_PDU_RXCHID_V((id)) | \
 	       CPL_TX_SEC_PDU_ACKFOLLOWS_V(0) | \
 	       CPL_TX_SEC_PDU_ULPTXLPBK_V(1) | \
 	       CPL_TX_SEC_PDU_CPLLEN_V((len)) | \
 	       CPL_TX_SEC_PDU_PLACEHOLDER_V(0) | \
 	       CPL_TX_SEC_PDU_IVINSRTOFST_V((ofst)))

 #define  FILL_SEC_CPL_CIPHERSTOP_HI(a_start, a_stop, c_start, c_stop_hi) \
 	htonl( \
 	       CPL_TX_SEC_PDU_AADSTART_V((a_start)) | \
 	       CPL_TX_SEC_PDU_AADSTOP_V((a_stop)) | \
 	       CPL_TX_SEC_PDU_CIPHERSTART_V((c_start)) | \
 	       CPL_TX_SEC_PDU_CIPHERSTOP_HI_V((c_stop_hi)))

 #define  FILL_SEC_CPL_AUTHINSERT(c_stop_lo, a_start, a_stop, a_inst) \
 	htonl( \
 	       CPL_TX_SEC_PDU_CIPHERSTOP_LO_V((c_stop_lo)) | \
 		CPL_TX_SEC_PDU_AUTHSTART_V((a_start)) | \
 		CPL_TX_SEC_PDU_AUTHSTOP_V((a_stop)) | \
 		CPL_TX_SEC_PDU_AUTHINSERT_V((a_inst)))

 #define  FILL_SEC_CPL_SCMD0_SEQNO(ctrl, seq, cmode, amode, opad, size)  \
 		htonl( \
 		SCMD_SEQ_NO_CTRL_V(0) | \
 		SCMD_STATUS_PRESENT_V(0) | \
 		SCMD_PROTO_VERSION_V(CHCR_SCMD_PROTO_VERSION_GENERIC) | \
 		SCMD_ENC_DEC_CTRL_V((ctrl)) | \
 		SCMD_CIPH_AUTH_SEQ_CTRL_V((seq)) | \
 		SCMD_CIPH_MODE_V((cmode)) | \
 		SCMD_AUTH_MODE_V((amode)) | \
 		SCMD_HMAC_CTRL_V((opad)) | \
 		SCMD_IV_SIZE_V((size)) | \
 		SCMD_NUM_IVS_V(0))

 #define FILL_SEC_CPL_IVGEN_HDRLEN(last, more, ctx_in, mac, ivdrop, len) htonl( \
 		SCMD_ENB_DBGID_V(0) | \
 		SCMD_IV_GEN_CTRL_V(0) | \
 		SCMD_LAST_FRAG_V((last)) | \
 		SCMD_MORE_FRAGS_V((more)) | \
 		SCMD_TLS_COMPPDU_V(0) | \
 		SCMD_KEY_CTX_INLINE_V((ctx_in)) | \
 		SCMD_TLS_FRAG_ENABLE_V(0) | \
 		SCMD_MAC_ONLY_V((mac)) |  \
 		SCMD_AADIVDROP_V((ivdrop)) | \
 		SCMD_HDR_LEN_V((len)))

 #define  FILL_KEY_CTX_HDR(ck_size, mk_size, d_ck, opad, ctx_len) \
 		htonl(KEY_CONTEXT_VALID_V(1) | \
 		      KEY_CONTEXT_CK_SIZE_V((ck_size)) | \
 		      KEY_CONTEXT_MK_SIZE_V(mk_size) | \
 		      KEY_CONTEXT_DUAL_CK_V((d_ck)) | \
 		      KEY_CONTEXT_OPAD_PRESENT_V((opad)) | \
 		      KEY_CONTEXT_SALT_PRESENT_V(1) | \
 		      KEY_CONTEXT_CTX_LEN_V((ctx_len)))

 #define FILL_WR_OP_CCTX_SIZE \
 		htonl( \
 			FW_CRYPTO_LOOKASIDE_WR_OPCODE_V( \
 			FW_CRYPTO_LOOKASIDE_WR) | \
 			FW_CRYPTO_LOOKASIDE_WR_COMPL_V(0) | \
 			FW_CRYPTO_LOOKASIDE_WR_IMM_LEN_V((0)) | \
 			FW_CRYPTO_LOOKASIDE_WR_CCTX_LOC_V(0) | \
 			FW_CRYPTO_LOOKASIDE_WR_CCTX_SIZE_V(0))

 #define FILL_WR_RX_Q_ID(cid, qid, lcb, fid) \
 		htonl( \
 			FW_CRYPTO_LOOKASIDE_WR_RX_CHID_V((cid)) | \
 			FW_CRYPTO_LOOKASIDE_WR_RX_Q_ID_V((qid)) | \
 			FW_CRYPTO_LOOKASIDE_WR_LCB_V((lcb)) | \
 			FW_CRYPTO_LOOKASIDE_WR_IV_V((IV_NOP)) | \
 			FW_CRYPTO_LOOKASIDE_WR_FQIDX_V(fid))

 #define FILL_ULPTX_CMD_DEST(cid, qid) \
 	htonl(ULPTX_CMD_V(ULP_TX_PKT) | \
 	      ULP_TXPKT_DEST_V(0) | \
 	      ULP_TXPKT_DATAMODIFY_V(0) | \
 	      ULP_TXPKT_CHANNELID_V((cid)) | \
 	      ULP_TXPKT_RO_V(1) | \
 	      ULP_TXPKT_FID_V(qid))

 #define KEYCTX_ALIGN_PAD(bs) ({unsigned int _bs = (bs);\
 			      _bs == SHA1_DIGEST_SIZE ? 12 : 0; })

 #define FILL_PLD_SIZE_HASH_SIZE(payload_sgl_len, sgl_lengths, total_frags) \
 	htonl(FW_CRYPTO_LOOKASIDE_WR_PLD_SIZE_V(payload_sgl_len ? \
 						sgl_lengths[total_frags] : 0) |\
 	      FW_CRYPTO_LOOKASIDE_WR_HASH_SIZE_V(0))

 #define FILL_LEN_PKD(calc_tx_flits_ofld, skb) \
 	htonl(FW_CRYPTO_LOOKASIDE_WR_LEN16_V(DIV_ROUND_UP((\
 					   calc_tx_flits_ofld(skb) * 8), 16)))

 #define FILL_CMD_MORE(immdatalen) htonl(ULPTX_CMD_V(ULP_TX_SC_IMM) |\
 					ULP_TX_SC_MORE_V((immdatalen)))
 #define MAX_NK 8
 #define ROUND_16(bytes)		((bytes) & 0xFFFFFFF0)
 #define MAX_DSGL_ENT			32
 #define MIN_CIPHER_SG			1 /* IV */
 #define MIN_AUTH_SG			1 /* IV */
 #define MIN_GCM_SG			1 /* IV */
 #define MIN_DIGEST_SG			1 /*Partial Buffer*/
 #define MIN_CCM_SG			2 /*IV+B0*/
 #define SPACE_LEFT(len) \
 	((SGE_MAX_WR_LEN - WR_MIN_LEN - (len)))

 unsigned int sgl_ent_len[] = {0, 0, 16, 24, 40, 48, 64, 72, 88,
 				96, 112, 120, 136, 144, 160, 168, 184,
 				192, 208, 216, 232, 240, 256, 264, 280,
 				288, 304, 312, 328, 336, 352, 360, 376};
 unsigned int dsgl_ent_len[] = {0, 32, 32, 48, 48, 64, 64, 80, 80,
 				112, 112, 128, 128, 144, 144, 160, 160,
 				192, 192, 208, 208, 224, 224, 240, 240,
 				272, 272, 288, 288, 304, 304, 320, 320};

 struct algo_param {
 	unsigned int auth_mode;
 	unsigned int mk_size;
 	unsigned int result_size;
 };

 struct hash_wr_param {
 	unsigned int opad_needed;
 	unsigned int more;
 	unsigned int last;
 	struct algo_param alg_prm;
 	unsigned int sg_len;
 	unsigned int bfr_len;
 	u64 scmd1;
 };

 struct cipher_wr_param {
 	struct ablkcipher_request *req;
 	char *iv;
 	int bytes;
 	unsigned short qid;
 };
 enum {
 	AES_KEYLENGTH_128BIT = 128,
 	AES_KEYLENGTH_192BIT = 192,
 	AES_KEYLENGTH_256BIT = 256
 };

 enum {
 	KEYLENGTH_3BYTES = 3,
 	KEYLENGTH_4BYTES = 4,
 	KEYLENGTH_6BYTES = 6,
 	KEYLENGTH_8BYTES = 8
 };

 enum {
 	NUMBER_OF_ROUNDS_10 = 10,
 	NUMBER_OF_ROUNDS_12 = 12,
 	NUMBER_OF_ROUNDS_14 = 14,
 };

 /*
  * CCM defines values of 4, 6, 8, 10, 12, 14, and 16 octets,
  * where they indicate the size of the integrity check value (ICV)
  */
 enum {
 	ICV_4  = 4,
 	ICV_6  = 6,
 	ICV_8  = 8,
 	ICV_10 = 10,
 	ICV_12 = 12,
 	ICV_13 = 13,
 	ICV_14 = 14,
 	ICV_15 = 15,
 	ICV_16 = 16
 };

 struct phys_sge_pairs {
 	__be16 len[8];
 	__be64 addr[8];
 };


 static const u32 sha1_init[SHA1_DIGEST_SIZE / 4] = {
 		SHA1_H0, SHA1_H1, SHA1_H2, SHA1_H3, SHA1_H4,
 };

 static const u32 sha224_init[SHA256_DIGEST_SIZE / 4] = {
 		SHA224_H0, SHA224_H1, SHA224_H2, SHA224_H3,
 		SHA224_H4, SHA224_H5, SHA224_H6, SHA224_H7,
 };

 static const u32 sha256_init[SHA256_DIGEST_SIZE / 4] = {
 		SHA256_H0, SHA256_H1, SHA256_H2, SHA256_H3,
 		SHA256_H4, SHA256_H5, SHA256_H6, SHA256_H7,
 };

 static const u64 sha384_init[SHA512_DIGEST_SIZE / 8] = {
 		SHA384_H0, SHA384_H1, SHA384_H2, SHA384_H3,
 		SHA384_H4, SHA384_H5, SHA384_H6, SHA384_H7,
 };

 static const u64 sha512_init[SHA512_DIGEST_SIZE / 8] = {
 		SHA512_H0, SHA512_H1, SHA512_H2, SHA512_H3,
 		SHA512_H4, SHA512_H5, SHA512_H6, SHA512_H7,
 };

 static inline void copy_hash_init_values(char *key, int digestsize)
 {
 	u8 i;
 	__be32 *dkey = (__be32 *)key;
 	u64 *ldkey = (u64 *)key;
 	__be64 *sha384 = (__be64 *)sha384_init;
 	__be64 *sha512 = (__be64 *)sha512_init;

 	switch (digestsize) {
 	case SHA1_DIGEST_SIZE:
 		for (i = 0; i < SHA1_INIT_STATE; i++)
 			dkey[i] = cpu_to_be32(sha1_init[i]);
 		break;
 	case SHA224_DIGEST_SIZE:
 		for (i = 0; i < SHA224_INIT_STATE; i++)
 			dkey[i] = cpu_to_be32(sha224_init[i]);
 		break;
 	case SHA256_DIGEST_SIZE:
 		for (i = 0; i < SHA256_INIT_STATE; i++)
 			dkey[i] = cpu_to_be32(sha256_init[i]);
 		break;
 	case SHA384_DIGEST_SIZE:
 		for (i = 0; i < SHA384_INIT_STATE; i++)
 			ldkey[i] = be64_to_cpu(sha384[i]);
 		break;
 	case SHA512_DIGEST_SIZE:
 		for (i = 0; i < SHA512_INIT_STATE; i++)
 			ldkey[i] = be64_to_cpu(sha512[i]);
 		break;
 	}
 }

 static const u8 sgl_lengths[20] = {
 	0, 1, 2, 3, 4, 4, 5, 6, 7, 7, 8, 9, 10, 10, 11, 12, 13, 13, 14, 15
 };

 /* Number of len fields(8) * size of one addr field */
 #define PHYSDSGL_MAX_LEN_SIZE 16

 static inline u16 get_space_for_phys_dsgl(unsigned int sgl_entr)
 {
 	/* len field size + addr field size */
 	return ((sgl_entr >> 3) + ((sgl_entr % 8) ?
 				   1 : 0)) * PHYSDSGL_MAX_LEN_SIZE +
 		(sgl_entr << 3) + ((sgl_entr % 2 ? 1 : 0) << 3);
 }

 /* The AES s-transform matrix (s-box). */
 static const u8 aes_sbox[256] = {
 	99,  124, 119, 123, 242, 107, 111, 197, 48,  1,   103, 43,  254, 215,
 	171, 118, 202, 130, 201, 125, 250, 89,  71,  240, 173, 212, 162, 175,
 	156, 164, 114, 192, 183, 253, 147, 38,  54,  63,  247, 204, 52,  165,
 	229, 241, 113, 216, 49,  21, 4,   199, 35,  195, 24,  150, 5, 154, 7,
 	18,  128, 226, 235, 39,  178, 117, 9,   131, 44,  26,  27,  110, 90,
 	160, 82,  59,  214, 179, 41,  227, 47,  132, 83,  209, 0,   237, 32,
 	252, 177, 91,  106, 203, 190, 57,  74,  76,  88,  207, 208, 239, 170,
 	251, 67,  77,  51,  133, 69,  249, 2,   127, 80,  60,  159, 168, 81,
 	163, 64,  143, 146, 157, 56,  245, 188, 182, 218, 33,  16,  255, 243,
 	210, 205, 12,  19,  236, 95,  151, 68,  23,  196, 167, 126, 61,  100,
 	93,  25,  115, 96,  129, 79,  220, 34,  42,  144, 136, 70,  238, 184,
 	20,  222, 94,  11,  219, 224, 50,  58,  10,  73,  6,   36,  92,  194,
 	211, 172, 98,  145, 149, 228, 121, 231, 200, 55,  109, 141, 213, 78,
 	169, 108, 86,  244, 234, 101, 122, 174, 8, 186, 120, 37,  46,  28, 166,
 	180, 198, 232, 221, 116, 31,  75,  189, 139, 138, 112, 62,  181, 102,
 	72,  3,   246, 14,  97,  53,  87,  185, 134, 193, 29,  158, 225, 248,
 	152, 17,  105, 217, 142, 148, 155, 30,  135, 233, 206, 85,  40,  223,
 	140, 161, 137, 13,  191, 230, 66,  104, 65,  153, 45,  15,  176, 84,
 	187, 22
 };

 static inline u32 aes_ks_subword(const u32 w)
 {
 	u8 bytes[4];

 	*(u32 *)(&bytes[0]) = w;
 	bytes[0] = aes_sbox[bytes[0]];
 	bytes[1] = aes_sbox[bytes[1]];
 	bytes[2] = aes_sbox[bytes[2]];
 	bytes[3] = aes_sbox[bytes[3]];
 	return *(u32 *)(&bytes[0]);
 }

 static u32 round_constant[11] = {
 	0x01000000, 0x02000000, 0x04000000, 0x08000000,
 	0x10000000, 0x20000000, 0x40000000, 0x80000000,
 	0x1B000000, 0x36000000, 0x6C000000
 };

 #endif /* __CHCR_ALGO_H__ */
	/*
	* This file is part of the Chelsio T6 Crypto driver for Linux.
	*
	* Copyright (c) 2003-2016 Chelsio Communications, Inc. All rights reserved.
	*
	* This software is available to you under a choice of one of two
	* licenses. You may choose to be licensed under the terms of the GNU
	* General Public License (GPL) Version 2, available from the file
	* COPYING in the main directory of this source tree, or the
	* OpenIB.org BSD license below:
	*
	* Redistribution and use in source and binary forms, with or
	* without modification, are permitted provided that the following
	* conditions are met:
	*
	* - Redistributions of source code must retain the above
	* copyright notice, this list of conditions and the following
	* disclaimer.
	*
	* - Redistributions in binary form must reproduce the above
	* copyright notice, this list of conditions and the following
	* disclaimer in the documentation and/or other materials
	* provided with the distribution.
	*
	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
	* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
	* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
	* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
	* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
	* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
	* SOFTWARE.
	*
	*/

	#ifndef __CHCR_ALGO_H__
	#define __CHCR_ALGO_H__

	/* Crypto key context */
	#define KEY_CONTEXT_CTX_LEN_S 24
	#define KEY_CONTEXT_CTX_LEN_M 0xff
	#define KEY_CONTEXT_CTX_LEN_V(x) ((x) << KEY_CONTEXT_CTX_LEN_S)
	#define KEY_CONTEXT_CTX_LEN_G(x) \
	(((x) >> KEY_CONTEXT_CTX_LEN_S) & KEY_CONTEXT_CTX_LEN_M)

	#define KEY_CONTEXT_DUAL_CK_S 12
	#define KEY_CONTEXT_DUAL_CK_M 0x1
	#define KEY_CONTEXT_DUAL_CK_V(x) ((x) << KEY_CONTEXT_DUAL_CK_S)
	#define KEY_CONTEXT_DUAL_CK_G(x) \
	(((x) >> KEY_CONTEXT_DUAL_CK_S) & KEY_CONTEXT_DUAL_CK_M)
	#define KEY_CONTEXT_DUAL_CK_F KEY_CONTEXT_DUAL_CK_V(1U)

	#define KEY_CONTEXT_SALT_PRESENT_S 10
	#define KEY_CONTEXT_SALT_PRESENT_M 0x1
	#define KEY_CONTEXT_SALT_PRESENT_V(x) ((x) << KEY_CONTEXT_SALT_PRESENT_S)
	#define KEY_CONTEXT_SALT_PRESENT_G(x) \
	(((x) >> KEY_CONTEXT_SALT_PRESENT_S) & \
	KEY_CONTEXT_SALT_PRESENT_M)
	#define KEY_CONTEXT_SALT_PRESENT_F KEY_CONTEXT_SALT_PRESENT_V(1U)

	#define KEY_CONTEXT_VALID_S 0
	#define KEY_CONTEXT_VALID_M 0x1
	#define KEY_CONTEXT_VALID_V(x) ((x) << KEY_CONTEXT_VALID_S)
	#define KEY_CONTEXT_VALID_G(x) \
	(((x) >> KEY_CONTEXT_VALID_S) & \
	KEY_CONTEXT_VALID_M)
	#define KEY_CONTEXT_VALID_F KEY_CONTEXT_VALID_V(1U)

	#define KEY_CONTEXT_CK_SIZE_S 6
	#define KEY_CONTEXT_CK_SIZE_M 0xf
	#define KEY_CONTEXT_CK_SIZE_V(x) ((x) << KEY_CONTEXT_CK_SIZE_S)
	#define KEY_CONTEXT_CK_SIZE_G(x) \
	(((x) >> KEY_CONTEXT_CK_SIZE_S) & KEY_CONTEXT_CK_SIZE_M)

	#define KEY_CONTEXT_MK_SIZE_S 2
	#define KEY_CONTEXT_MK_SIZE_M 0xf
	#define KEY_CONTEXT_MK_SIZE_V(x) ((x) << KEY_CONTEXT_MK_SIZE_S)
	#define KEY_CONTEXT_MK_SIZE_G(x) \
	(((x) >> KEY_CONTEXT_MK_SIZE_S) & KEY_CONTEXT_MK_SIZE_M)

	#define KEY_CONTEXT_OPAD_PRESENT_S 11
	#define KEY_CONTEXT_OPAD_PRESENT_M 0x1
	#define KEY_CONTEXT_OPAD_PRESENT_V(x) ((x) << KEY_CONTEXT_OPAD_PRESENT_S)
	#define KEY_CONTEXT_OPAD_PRESENT_G(x) \
	(((x) >> KEY_CONTEXT_OPAD_PRESENT_S) & \
	KEY_CONTEXT_OPAD_PRESENT_M)
	#define KEY_CONTEXT_OPAD_PRESENT_F KEY_CONTEXT_OPAD_PRESENT_V(1U)

	#define CHCR_HASH_MAX_DIGEST_SIZE 64
	#define CHCR_MAX_SHA_DIGEST_SIZE 64

	#define IPSEC_TRUNCATED_ICV_SIZE 12
	#define TLS_TRUNCATED_HMAC_SIZE 10
	#define CBCMAC_DIGEST_SIZE 16
	#define MAX_HASH_NAME 20

	#define SHA1_INIT_STATE_5X4B 5
	#define SHA256_INIT_STATE_8X4B 8
	#define SHA512_INIT_STATE_8X8B 8
	#define SHA1_INIT_STATE SHA1_INIT_STATE_5X4B
	#define SHA224_INIT_STATE SHA256_INIT_STATE_8X4B
	#define SHA256_INIT_STATE SHA256_INIT_STATE_8X4B
	#define SHA384_INIT_STATE SHA512_INIT_STATE_8X8B
	#define SHA512_INIT_STATE SHA512_INIT_STATE_8X8B

	#define DUMMY_BYTES 16

	#define IPAD_DATA 0x36363636
	#define OPAD_DATA 0x5c5c5c5c

	#define TRANSHDR_SIZE(kctx_len)\
	(sizeof(struct chcr_wr) +\
	kctx_len)
	#define CIPHER_TRANSHDR_SIZE(kctx_len, sge_pairs) \
	(TRANSHDR_SIZE((kctx_len)) + (sge_pairs) +\
	sizeof(struct cpl_rx_phys_dsgl))
	#define HASH_TRANSHDR_SIZE(kctx_len)\
	(TRANSHDR_SIZE(kctx_len) + DUMMY_BYTES)


	#define FILL_SEC_CPL_OP_IVINSR(id, len, ofst) \
	htonl( \
	CPL_TX_SEC_PDU_OPCODE_V(CPL_TX_SEC_PDU) \| \
	CPL_TX_SEC_PDU_RXCHID_V((id)) \| \
	CPL_TX_SEC_PDU_ACKFOLLOWS_V(0) \| \
	CPL_TX_SEC_PDU_ULPTXLPBK_V(1) \| \
	CPL_TX_SEC_PDU_CPLLEN_V((len)) \| \
	CPL_TX_SEC_PDU_PLACEHOLDER_V(0) \| \
	CPL_TX_SEC_PDU_IVINSRTOFST_V((ofst)))

	#define FILL_SEC_CPL_CIPHERSTOP_HI(a_start, a_stop, c_start, c_stop_hi) \
	htonl( \
	CPL_TX_SEC_PDU_AADSTART_V((a_start)) \| \
	CPL_TX_SEC_PDU_AADSTOP_V((a_stop)) \| \
	CPL_TX_SEC_PDU_CIPHERSTART_V((c_start)) \| \
	CPL_TX_SEC_PDU_CIPHERSTOP_HI_V((c_stop_hi)))

	#define FILL_SEC_CPL_AUTHINSERT(c_stop_lo, a_start, a_stop, a_inst) \
	htonl( \
	CPL_TX_SEC_PDU_CIPHERSTOP_LO_V((c_stop_lo)) \| \
	CPL_TX_SEC_PDU_AUTHSTART_V((a_start)) \| \
	CPL_TX_SEC_PDU_AUTHSTOP_V((a_stop)) \| \
	CPL_TX_SEC_PDU_AUTHINSERT_V((a_inst)))

	#define FILL_SEC_CPL_SCMD0_SEQNO(ctrl, seq, cmode, amode, opad, size) \
	htonl( \
	SCMD_SEQ_NO_CTRL_V(0) \| \
	SCMD_STATUS_PRESENT_V(0) \| \
	SCMD_PROTO_VERSION_V(CHCR_SCMD_PROTO_VERSION_GENERIC) \| \
	SCMD_ENC_DEC_CTRL_V((ctrl)) \| \
	SCMD_CIPH_AUTH_SEQ_CTRL_V((seq)) \| \
	SCMD_CIPH_MODE_V((cmode)) \| \
	SCMD_AUTH_MODE_V((amode)) \| \
	SCMD_HMAC_CTRL_V((opad)) \| \
	SCMD_IV_SIZE_V((size)) \| \
	SCMD_NUM_IVS_V(0))

	#define FILL_SEC_CPL_IVGEN_HDRLEN(last, more, ctx_in, mac, ivdrop, len) htonl( \
	SCMD_ENB_DBGID_V(0) \| \
	SCMD_IV_GEN_CTRL_V(0) \| \
	SCMD_LAST_FRAG_V((last)) \| \
	SCMD_MORE_FRAGS_V((more)) \| \
	SCMD_TLS_COMPPDU_V(0) \| \
	SCMD_KEY_CTX_INLINE_V((ctx_in)) \| \
	SCMD_TLS_FRAG_ENABLE_V(0) \| \
	SCMD_MAC_ONLY_V((mac)) \| \
	SCMD_AADIVDROP_V((ivdrop)) \| \
	SCMD_HDR_LEN_V((len)))

	#define FILL_KEY_CTX_HDR(ck_size, mk_size, d_ck, opad, ctx_len) \
	htonl(KEY_CONTEXT_VALID_V(1) \| \
	KEY_CONTEXT_CK_SIZE_V((ck_size)) \| \
	KEY_CONTEXT_MK_SIZE_V(mk_size) \| \
	KEY_CONTEXT_DUAL_CK_V((d_ck)) \| \
	KEY_CONTEXT_OPAD_PRESENT_V((opad)) \| \
	KEY_CONTEXT_SALT_PRESENT_V(1) \| \
	KEY_CONTEXT_CTX_LEN_V((ctx_len)))

	#define FILL_WR_OP_CCTX_SIZE \
	htonl( \
	FW_CRYPTO_LOOKASIDE_WR_OPCODE_V( \
	FW_CRYPTO_LOOKASIDE_WR) \| \
	FW_CRYPTO_LOOKASIDE_WR_COMPL_V(0) \| \
	FW_CRYPTO_LOOKASIDE_WR_IMM_LEN_V((0)) \| \
	FW_CRYPTO_LOOKASIDE_WR_CCTX_LOC_V(0) \| \
	FW_CRYPTO_LOOKASIDE_WR_CCTX_SIZE_V(0))

	#define FILL_WR_RX_Q_ID(cid, qid, lcb, fid) \
	htonl( \
	FW_CRYPTO_LOOKASIDE_WR_RX_CHID_V((cid)) \| \
	FW_CRYPTO_LOOKASIDE_WR_RX_Q_ID_V((qid)) \| \
	FW_CRYPTO_LOOKASIDE_WR_LCB_V((lcb)) \| \
	FW_CRYPTO_LOOKASIDE_WR_IV_V((IV_NOP)) \| \
	FW_CRYPTO_LOOKASIDE_WR_FQIDX_V(fid))

	#define FILL_ULPTX_CMD_DEST(cid, qid) \
	htonl(ULPTX_CMD_V(ULP_TX_PKT) \| \
	ULP_TXPKT_DEST_V(0) \| \
	ULP_TXPKT_DATAMODIFY_V(0) \| \
	ULP_TXPKT_CHANNELID_V((cid)) \| \
	ULP_TXPKT_RO_V(1) \| \
	ULP_TXPKT_FID_V(qid))

	#define KEYCTX_ALIGN_PAD(bs) ({unsigned int _bs = (bs);\
	_bs == SHA1_DIGEST_SIZE ? 12 : 0; })

	#define FILL_PLD_SIZE_HASH_SIZE(payload_sgl_len, sgl_lengths, total_frags) \
	htonl(FW_CRYPTO_LOOKASIDE_WR_PLD_SIZE_V(payload_sgl_len ? \
	sgl_lengths[total_frags] : 0) \|\
	FW_CRYPTO_LOOKASIDE_WR_HASH_SIZE_V(0))

	#define FILL_LEN_PKD(calc_tx_flits_ofld, skb) \
	htonl(FW_CRYPTO_LOOKASIDE_WR_LEN16_V(DIV_ROUND_UP((\
	calc_tx_flits_ofld(skb) * 8), 16)))

	#define FILL_CMD_MORE(immdatalen) htonl(ULPTX_CMD_V(ULP_TX_SC_IMM) \|\
	ULP_TX_SC_MORE_V((immdatalen)))
	#define MAX_NK 8
	#define ROUND_16(bytes) ((bytes) & 0xFFFFFFF0)
	#define MAX_DSGL_ENT 32
	#define MIN_CIPHER_SG 1 /* IV */
	#define MIN_AUTH_SG 1 /* IV */
	#define MIN_GCM_SG 1 /* IV */
	#define MIN_DIGEST_SG 1 /Partial Buffer/
	#define MIN_CCM_SG 2 /IV+B0/
	#define SPACE_LEFT(len) \
	((SGE_MAX_WR_LEN - WR_MIN_LEN - (len)))

	unsigned int sgl_ent_len[] = {0, 0, 16, 24, 40, 48, 64, 72, 88,
	96, 112, 120, 136, 144, 160, 168, 184,
	192, 208, 216, 232, 240, 256, 264, 280,
	288, 304, 312, 328, 336, 352, 360, 376};
	unsigned int dsgl_ent_len[] = {0, 32, 32, 48, 48, 64, 64, 80, 80,
	112, 112, 128, 128, 144, 144, 160, 160,
	192, 192, 208, 208, 224, 224, 240, 240,
	272, 272, 288, 288, 304, 304, 320, 320};

	struct algo_param {
	unsigned int auth_mode;
	unsigned int mk_size;
	unsigned int result_size;
	};

	struct hash_wr_param {
	unsigned int opad_needed;
	unsigned int more;
	unsigned int last;
	struct algo_param alg_prm;
	unsigned int sg_len;
	unsigned int bfr_len;
	u64 scmd1;
	};

	struct cipher_wr_param {
	struct ablkcipher_request *req;
	char *iv;
	int bytes;
	unsigned short qid;
	};
	enum {
	AES_KEYLENGTH_128BIT = 128,
	AES_KEYLENGTH_192BIT = 192,
	AES_KEYLENGTH_256BIT = 256
	};

	enum {
	KEYLENGTH_3BYTES = 3,
	KEYLENGTH_4BYTES = 4,
	KEYLENGTH_6BYTES = 6,
	KEYLENGTH_8BYTES = 8
	};

	enum {
	NUMBER_OF_ROUNDS_10 = 10,
	NUMBER_OF_ROUNDS_12 = 12,
	NUMBER_OF_ROUNDS_14 = 14,
	};

	/*
	* CCM defines values of 4, 6, 8, 10, 12, 14, and 16 octets,
	* where they indicate the size of the integrity check value (ICV)
	*/
	enum {
	ICV_4 = 4,
	ICV_6 = 6,
	ICV_8 = 8,
	ICV_10 = 10,
	ICV_12 = 12,
	ICV_13 = 13,
	ICV_14 = 14,
	ICV_15 = 15,
	ICV_16 = 16
	};

	struct phys_sge_pairs {
	__be16 len[8];
	__be64 addr[8];
	};


	static const u32 sha1_init[SHA1_DIGEST_SIZE / 4] = {
	SHA1_H0, SHA1_H1, SHA1_H2, SHA1_H3, SHA1_H4,
	};

	static const u32 sha224_init[SHA256_DIGEST_SIZE / 4] = {
	SHA224_H0, SHA224_H1, SHA224_H2, SHA224_H3,
	SHA224_H4, SHA224_H5, SHA224_H6, SHA224_H7,
	};

	static const u32 sha256_init[SHA256_DIGEST_SIZE / 4] = {
	SHA256_H0, SHA256_H1, SHA256_H2, SHA256_H3,
	SHA256_H4, SHA256_H5, SHA256_H6, SHA256_H7,
	};

	static const u64 sha384_init[SHA512_DIGEST_SIZE / 8] = {
	SHA384_H0, SHA384_H1, SHA384_H2, SHA384_H3,
	SHA384_H4, SHA384_H5, SHA384_H6, SHA384_H7,
	};

	static const u64 sha512_init[SHA512_DIGEST_SIZE / 8] = {
	SHA512_H0, SHA512_H1, SHA512_H2, SHA512_H3,
	SHA512_H4, SHA512_H5, SHA512_H6, SHA512_H7,
	};

	static inline void copy_hash_init_values(char *key, int digestsize)
	{
	u8 i;
	__be32 dkey = (__be32 )key;
	u64 ldkey = (u64 )key;
	__be64 sha384 = (__be64 )sha384_init;
	__be64 sha512 = (__be64 )sha512_init;

	switch (digestsize) {
	case SHA1_DIGEST_SIZE:
	for (i = 0; i < SHA1_INIT_STATE; i++)
	dkey[i] = cpu_to_be32(sha1_init[i]);
	break;
	case SHA224_DIGEST_SIZE:
	for (i = 0; i < SHA224_INIT_STATE; i++)
	dkey[i] = cpu_to_be32(sha224_init[i]);
	break;
	case SHA256_DIGEST_SIZE:
	for (i = 0; i < SHA256_INIT_STATE; i++)
	dkey[i] = cpu_to_be32(sha256_init[i]);
	break;
	case SHA384_DIGEST_SIZE:
	for (i = 0; i < SHA384_INIT_STATE; i++)
	ldkey[i] = be64_to_cpu(sha384[i]);
	break;
	case SHA512_DIGEST_SIZE:
	for (i = 0; i < SHA512_INIT_STATE; i++)
	ldkey[i] = be64_to_cpu(sha512[i]);
	break;
	}
	}

	static const u8 sgl_lengths[20] = {
	0, 1, 2, 3, 4, 4, 5, 6, 7, 7, 8, 9, 10, 10, 11, 12, 13, 13, 14, 15
	};

	/* Number of len fields(8) * size of one addr field */
	#define PHYSDSGL_MAX_LEN_SIZE 16

	static inline u16 get_space_for_phys_dsgl(unsigned int sgl_entr)
	{
	/* len field size + addr field size */
	return ((sgl_entr >> 3) + ((sgl_entr % 8) ?
	1 : 0)) * PHYSDSGL_MAX_LEN_SIZE +
	(sgl_entr << 3) + ((sgl_entr % 2 ? 1 : 0) << 3);
	}

	/* The AES s-transform matrix (s-box). */
	static const u8 aes_sbox[256] = {
	99, 124, 119, 123, 242, 107, 111, 197, 48, 1, 103, 43, 254, 215,
	171, 118, 202, 130, 201, 125, 250, 89, 71, 240, 173, 212, 162, 175,
	156, 164, 114, 192, 183, 253, 147, 38, 54, 63, 247, 204, 52, 165,
	229, 241, 113, 216, 49, 21, 4, 199, 35, 195, 24, 150, 5, 154, 7,
	18, 128, 226, 235, 39, 178, 117, 9, 131, 44, 26, 27, 110, 90,
	160, 82, 59, 214, 179, 41, 227, 47, 132, 83, 209, 0, 237, 32,
	252, 177, 91, 106, 203, 190, 57, 74, 76, 88, 207, 208, 239, 170,
	251, 67, 77, 51, 133, 69, 249, 2, 127, 80, 60, 159, 168, 81,
	163, 64, 143, 146, 157, 56, 245, 188, 182, 218, 33, 16, 255, 243,
	210, 205, 12, 19, 236, 95, 151, 68, 23, 196, 167, 126, 61, 100,
	93, 25, 115, 96, 129, 79, 220, 34, 42, 144, 136, 70, 238, 184,
	20, 222, 94, 11, 219, 224, 50, 58, 10, 73, 6, 36, 92, 194,
	211, 172, 98, 145, 149, 228, 121, 231, 200, 55, 109, 141, 213, 78,
	169, 108, 86, 244, 234, 101, 122, 174, 8, 186, 120, 37, 46, 28, 166,
	180, 198, 232, 221, 116, 31, 75, 189, 139, 138, 112, 62, 181, 102,
	72, 3, 246, 14, 97, 53, 87, 185, 134, 193, 29, 158, 225, 248,
	152, 17, 105, 217, 142, 148, 155, 30, 135, 233, 206, 85, 40, 223,
	140, 161, 137, 13, 191, 230, 66, 104, 65, 153, 45, 15, 176, 84,
	187, 22
	};

	static inline u32 aes_ks_subword(const u32 w)
	{
	u8 bytes[4];

	(u32 )(&bytes[0]) = w;
	bytes[0] = aes_sbox[bytes[0]];
	bytes[1] = aes_sbox[bytes[1]];
	bytes[2] = aes_sbox[bytes[2]];
	bytes[3] = aes_sbox[bytes[3]];
	return (u32 )(&bytes[0]);
	}

	static u32 round_constant[11] = {
	0x01000000, 0x02000000, 0x04000000, 0x08000000,
	0x10000000, 0x20000000, 0x40000000, 0x80000000,
	0x1B000000, 0x36000000, 0x6C000000
	};

	#endif /* __CHCR_ALGO_H__ */