[mirror_qemu.git] / include / standard-headers / linux / virtio_crypto.h

#ifndef _VIRTIO_CRYPTO_H
#define _VIRTIO_CRYPTO_H
/* This header is BSD licensed so anyone can use the definitions to implement
 * compatible drivers/servers.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. 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.
 * 3. Neither the name of IBM nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL IBM OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */
#include "standard-headers/linux/types.h"
#include "standard-headers/linux/virtio_types.h"
#include "standard-headers/linux/virtio_ids.h"
#include "standard-headers/linux/virtio_config.h"


#define VIRTIO_CRYPTO_SERVICE_CIPHER 0
#define VIRTIO_CRYPTO_SERVICE_HASH   1
#define VIRTIO_CRYPTO_SERVICE_MAC    2
#define VIRTIO_CRYPTO_SERVICE_AEAD   3

#define VIRTIO_CRYPTO_OPCODE(service, op)   (((service) << 8) | (op))

struct virtio_crypto_ctrl_header {
#define VIRTIO_CRYPTO_CIPHER_CREATE_SESSION \
	   VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_CIPHER, 0x02)
#define VIRTIO_CRYPTO_CIPHER_DESTROY_SESSION \
	   VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_CIPHER, 0x03)
#define VIRTIO_CRYPTO_HASH_CREATE_SESSION \
	   VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_HASH, 0x02)
#define VIRTIO_CRYPTO_HASH_DESTROY_SESSION \
	   VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_HASH, 0x03)
#define VIRTIO_CRYPTO_MAC_CREATE_SESSION \
	   VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_MAC, 0x02)
#define VIRTIO_CRYPTO_MAC_DESTROY_SESSION \
	   VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_MAC, 0x03)
#define VIRTIO_CRYPTO_AEAD_CREATE_SESSION \
	   VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_AEAD, 0x02)
#define VIRTIO_CRYPTO_AEAD_DESTROY_SESSION \
	   VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_AEAD, 0x03)
	uint32_t opcode;
	uint32_t algo;
	uint32_t flag;
	/* data virtqueue id */
	uint32_t queue_id;
};

struct virtio_crypto_cipher_session_para {
#define VIRTIO_CRYPTO_NO_CIPHER                 0
#define VIRTIO_CRYPTO_CIPHER_ARC4               1
#define VIRTIO_CRYPTO_CIPHER_AES_ECB            2
#define VIRTIO_CRYPTO_CIPHER_AES_CBC            3
#define VIRTIO_CRYPTO_CIPHER_AES_CTR            4
#define VIRTIO_CRYPTO_CIPHER_DES_ECB            5
#define VIRTIO_CRYPTO_CIPHER_DES_CBC            6
#define VIRTIO_CRYPTO_CIPHER_3DES_ECB           7
#define VIRTIO_CRYPTO_CIPHER_3DES_CBC           8
#define VIRTIO_CRYPTO_CIPHER_3DES_CTR           9
#define VIRTIO_CRYPTO_CIPHER_KASUMI_F8          10
#define VIRTIO_CRYPTO_CIPHER_SNOW3G_UEA2        11
#define VIRTIO_CRYPTO_CIPHER_AES_F8             12
#define VIRTIO_CRYPTO_CIPHER_AES_XTS            13
#define VIRTIO_CRYPTO_CIPHER_ZUC_EEA3           14
	uint32_t algo;
	/* length of key */
	uint32_t keylen;

#define VIRTIO_CRYPTO_OP_ENCRYPT  1
#define VIRTIO_CRYPTO_OP_DECRYPT  2
	/* encrypt or decrypt */
	uint32_t op;
	uint32_t padding;
};

struct virtio_crypto_session_input {
	/* Device-writable part */
	uint64_t session_id;
	uint32_t status;
	uint32_t padding;
};

struct virtio_crypto_cipher_session_req {
	struct virtio_crypto_cipher_session_para para;
	uint8_t padding[32];
};

struct virtio_crypto_hash_session_para {
#define VIRTIO_CRYPTO_NO_HASH            0
#define VIRTIO_CRYPTO_HASH_MD5           1
#define VIRTIO_CRYPTO_HASH_SHA1          2
#define VIRTIO_CRYPTO_HASH_SHA_224       3
#define VIRTIO_CRYPTO_HASH_SHA_256       4
#define VIRTIO_CRYPTO_HASH_SHA_384       5
#define VIRTIO_CRYPTO_HASH_SHA_512       6
#define VIRTIO_CRYPTO_HASH_SHA3_224      7
#define VIRTIO_CRYPTO_HASH_SHA3_256      8
#define VIRTIO_CRYPTO_HASH_SHA3_384      9
#define VIRTIO_CRYPTO_HASH_SHA3_512      10
#define VIRTIO_CRYPTO_HASH_SHA3_SHAKE128      11
#define VIRTIO_CRYPTO_HASH_SHA3_SHAKE256      12
	uint32_t algo;
	/* hash result length */
	uint32_t hash_result_len;
	uint8_t padding[8];
};

struct virtio_crypto_hash_create_session_req {
	struct virtio_crypto_hash_session_para para;
	uint8_t padding[40];
};

struct virtio_crypto_mac_session_para {
#define VIRTIO_CRYPTO_NO_MAC                       0
#define VIRTIO_CRYPTO_MAC_HMAC_MD5                 1
#define VIRTIO_CRYPTO_MAC_HMAC_SHA1                2
#define VIRTIO_CRYPTO_MAC_HMAC_SHA_224             3
#define VIRTIO_CRYPTO_MAC_HMAC_SHA_256             4
#define VIRTIO_CRYPTO_MAC_HMAC_SHA_384             5
#define VIRTIO_CRYPTO_MAC_HMAC_SHA_512             6
#define VIRTIO_CRYPTO_MAC_CMAC_3DES                25
#define VIRTIO_CRYPTO_MAC_CMAC_AES                 26
#define VIRTIO_CRYPTO_MAC_KASUMI_F9                27
#define VIRTIO_CRYPTO_MAC_SNOW3G_UIA2              28
#define VIRTIO_CRYPTO_MAC_GMAC_AES                 41
#define VIRTIO_CRYPTO_MAC_GMAC_TWOFISH             42
#define VIRTIO_CRYPTO_MAC_CBCMAC_AES               49
#define VIRTIO_CRYPTO_MAC_CBCMAC_KASUMI_F9         50
#define VIRTIO_CRYPTO_MAC_XCBC_AES                 53
	uint32_t algo;
	/* hash result length */
	uint32_t hash_result_len;
	/* length of authenticated key */
	uint32_t auth_key_len;
	uint32_t padding;
};

struct virtio_crypto_mac_create_session_req {
	struct virtio_crypto_mac_session_para para;
	uint8_t padding[40];
};

struct virtio_crypto_aead_session_para {
#define VIRTIO_CRYPTO_NO_AEAD     0
#define VIRTIO_CRYPTO_AEAD_GCM    1
#define VIRTIO_CRYPTO_AEAD_CCM    2
#define VIRTIO_CRYPTO_AEAD_CHACHA20_POLY1305  3
	uint32_t algo;
	/* length of key */
	uint32_t key_len;
	/* hash result length */
	uint32_t hash_result_len;
	/* length of the additional authenticated data (AAD) in bytes */
	uint32_t aad_len;
	/* encrypt or decrypt, See above VIRTIO_CRYPTO_OP_* */
	uint32_t op;
	uint32_t padding;
};

struct virtio_crypto_aead_create_session_req {
	struct virtio_crypto_aead_session_para para;
	uint8_t padding[32];
};

struct virtio_crypto_alg_chain_session_para {
#define VIRTIO_CRYPTO_SYM_ALG_CHAIN_ORDER_HASH_THEN_CIPHER  1
#define VIRTIO_CRYPTO_SYM_ALG_CHAIN_ORDER_CIPHER_THEN_HASH  2
	uint32_t alg_chain_order;
/* Plain hash */
#define VIRTIO_CRYPTO_SYM_HASH_MODE_PLAIN    1
/* Authenticated hash (mac) */
#define VIRTIO_CRYPTO_SYM_HASH_MODE_AUTH     2
/* Nested hash */
#define VIRTIO_CRYPTO_SYM_HASH_MODE_NESTED   3
	uint32_t hash_mode;
	struct virtio_crypto_cipher_session_para cipher_param;
	union {
		struct virtio_crypto_hash_session_para hash_param;
		struct virtio_crypto_mac_session_para mac_param;
		uint8_t padding[16];
	} u;
	/* length of the additional authenticated data (AAD) in bytes */
	uint32_t aad_len;
	uint32_t padding;
};

struct virtio_crypto_alg_chain_session_req {
	struct virtio_crypto_alg_chain_session_para para;
};

struct virtio_crypto_sym_create_session_req {
	union {
		struct virtio_crypto_cipher_session_req cipher;
		struct virtio_crypto_alg_chain_session_req chain;
		uint8_t padding[48];
	} u;

	/* Device-readable part */

/* No operation */
#define VIRTIO_CRYPTO_SYM_OP_NONE  0
/* Cipher only operation on the data */
#define VIRTIO_CRYPTO_SYM_OP_CIPHER  1
/*
 * Chain any cipher with any hash or mac operation. The order
 * depends on the value of alg_chain_order param
 */
#define VIRTIO_CRYPTO_SYM_OP_ALGORITHM_CHAINING  2
	uint32_t op_type;
	uint32_t padding;
};

struct virtio_crypto_destroy_session_req {
	/* Device-readable part */
	uint64_t  session_id;
	uint8_t padding[48];
};

/* The request of the control virtqueue's packet */
struct virtio_crypto_op_ctrl_req {
	struct virtio_crypto_ctrl_header header;

	union {
		struct virtio_crypto_sym_create_session_req
			sym_create_session;
		struct virtio_crypto_hash_create_session_req
			hash_create_session;
		struct virtio_crypto_mac_create_session_req
			mac_create_session;
		struct virtio_crypto_aead_create_session_req
			aead_create_session;
		struct virtio_crypto_destroy_session_req
			destroy_session;
		uint8_t padding[56];
	} u;
};

struct virtio_crypto_op_header {
#define VIRTIO_CRYPTO_CIPHER_ENCRYPT \
	VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_CIPHER, 0x00)
#define VIRTIO_CRYPTO_CIPHER_DECRYPT \
	VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_CIPHER, 0x01)
#define VIRTIO_CRYPTO_HASH \
	VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_HASH, 0x00)
#define VIRTIO_CRYPTO_MAC \
	VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_MAC, 0x00)
#define VIRTIO_CRYPTO_AEAD_ENCRYPT \
	VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_AEAD, 0x00)
#define VIRTIO_CRYPTO_AEAD_DECRYPT \
	VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_AEAD, 0x01)
	uint32_t opcode;
	/* algo should be service-specific algorithms */
	uint32_t algo;
	/* session_id should be service-specific algorithms */
	uint64_t session_id;
	/* control flag to control the request */
	uint32_t flag;
	uint32_t padding;
};

struct virtio_crypto_cipher_para {
	/*
	 * Byte Length of valid IV/Counter
	 *
	 * For block ciphers in CBC or F8 mode, or for Kasumi in F8 mode, or for
	 *   SNOW3G in UEA2 mode, this is the length of the IV (which
	 *   must be the same as the block length of the cipher).
	 * For block ciphers in CTR mode, this is the length of the counter
	 *   (which must be the same as the block length of the cipher).
	 * For AES-XTS, this is the 128bit tweak, i, from IEEE Std 1619-2007.
	 *
	 * The IV/Counter will be updated after every partial cryptographic
	 * operation.
	 */
	uint32_t iv_len;
	/* length of source data */
	uint32_t src_data_len;
	/* length of dst data */
	uint32_t dst_data_len;
	uint32_t padding;
};

struct virtio_crypto_hash_para {
	/* length of source data */
	uint32_t src_data_len;
	/* hash result length */
	uint32_t hash_result_len;
};

struct virtio_crypto_mac_para {
	struct virtio_crypto_hash_para hash;
};

struct virtio_crypto_aead_para {
	/*
	 * Byte Length of valid IV data pointed to by the below iv_addr
	 * parameter.
	 *
	 * For GCM mode, this is either 12 (for 96-bit IVs) or 16, in which
	 *   case iv_addr points to J0.
	 * For CCM mode, this is the length of the nonce, which can be in the
	 *   range 7 to 13 inclusive.
	 */
	uint32_t iv_len;
	/* length of additional auth data */
	uint32_t aad_len;
	/* length of source data */
	uint32_t src_data_len;
	/* length of dst data */
	uint32_t dst_data_len;
};

struct virtio_crypto_cipher_data_req {
	/* Device-readable part */
	struct virtio_crypto_cipher_para para;
	uint8_t padding[24];
};

struct virtio_crypto_hash_data_req {
	/* Device-readable part */
	struct virtio_crypto_hash_para para;
	uint8_t padding[40];
};

struct virtio_crypto_mac_data_req {
	/* Device-readable part */
	struct virtio_crypto_mac_para para;
	uint8_t padding[40];
};

struct virtio_crypto_alg_chain_data_para {
	uint32_t iv_len;
	/* Length of source data */
	uint32_t src_data_len;
	/* Length of destination data */
	uint32_t dst_data_len;
	/* Starting point for cipher processing in source data */
	uint32_t cipher_start_src_offset;
	/* Length of the source data that the cipher will be computed on */
	uint32_t len_to_cipher;
	/* Starting point for hash processing in source data */
	uint32_t hash_start_src_offset;
	/* Length of the source data that the hash will be computed on */
	uint32_t len_to_hash;
	/* Length of the additional auth data */
	uint32_t aad_len;
	/* Length of the hash result */
	uint32_t hash_result_len;
	uint32_t reserved;
};

struct virtio_crypto_alg_chain_data_req {
	/* Device-readable part */
	struct virtio_crypto_alg_chain_data_para para;
};

struct virtio_crypto_sym_data_req {
	union {
		struct virtio_crypto_cipher_data_req cipher;
		struct virtio_crypto_alg_chain_data_req chain;
		uint8_t padding[40];
	} u;

	/* See above VIRTIO_CRYPTO_SYM_OP_* */
	uint32_t op_type;
	uint32_t padding;
};

struct virtio_crypto_aead_data_req {
	/* Device-readable part */
	struct virtio_crypto_aead_para para;
	uint8_t padding[32];
};

/* The request of the data virtqueue's packet */
struct virtio_crypto_op_data_req {
	struct virtio_crypto_op_header header;

	union {
		struct virtio_crypto_sym_data_req  sym_req;
		struct virtio_crypto_hash_data_req hash_req;
		struct virtio_crypto_mac_data_req mac_req;
		struct virtio_crypto_aead_data_req aead_req;
		uint8_t padding[48];
	} u;
};

#define VIRTIO_CRYPTO_OK        0
#define VIRTIO_CRYPTO_ERR       1
#define VIRTIO_CRYPTO_BADMSG    2
#define VIRTIO_CRYPTO_NOTSUPP   3
#define VIRTIO_CRYPTO_INVSESS   4 /* Invalid session id */

/* The accelerator hardware is ready */
#define VIRTIO_CRYPTO_S_HW_READY  (1 << 0)

struct virtio_crypto_config {
	/* See VIRTIO_CRYPTO_OP_* above */
	uint32_t  status;

	/*
	 * Maximum number of data queue
	 */
	uint32_t  max_dataqueues;

	/*
	 * Specifies the services mask which the device support,
	 * see VIRTIO_CRYPTO_SERVICE_* above
	 */
	uint32_t crypto_services;

	/* Detailed algorithms mask */
	uint32_t cipher_algo_l;
	uint32_t cipher_algo_h;
	uint32_t hash_algo;
	uint32_t mac_algo_l;
	uint32_t mac_algo_h;
	uint32_t aead_algo;
	/* Maximum length of cipher key */
	uint32_t max_cipher_key_len;
	/* Maximum length of authenticated key */
	uint32_t max_auth_key_len;
	uint32_t reserve;
	/* Maximum size of each crypto request's content */
	uint64_t max_size;
};

struct virtio_crypto_inhdr {
	/* See VIRTIO_CRYPTO_* above */
	uint8_t status;
};
#endif
Commit	Line	Data
f43c0076 MT	1	#ifndef _VIRTIO_CRYPTO_H
f43c0076 MT	2	#define _VIRTIO_CRYPTO_H
5551e3a8 GA	3	/* This header is BSD licensed so anyone can use the definitions to implement
	4	* compatible drivers/servers.
	5	*
	6	* Redistribution and use in source and binary forms, with or without
	7	* modification, are permitted provided that the following conditions
	8	* are met:
	9	* 1. Redistributions of source code must retain the above copyright
	10	* notice, this list of conditions and the following disclaimer.
	11	* 2. Redistributions in binary form must reproduce the above copyright
	12	* notice, this list of conditions and the following disclaimer in the
	13	* documentation and/or other materials provided with the distribution.
	14	* 3. Neither the name of IBM nor the names of its contributors
	15	* may be used to endorse or promote products derived from this software
	16	* without specific prior written permission.
f43c0076 MT	17	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	18	* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	19	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
	20	* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL IBM OR
	21	* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	22	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
	23	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
	24	* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
	25	* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
	26	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
	27	* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	28	* SUCH DAMAGE.
	29	*/
5551e3a8	30	#include "standard-headers/linux/types.h"
5551e3a8	31	#include "standard-headers/linux/virtio_types.h"
f43c0076 MT	32	#include "standard-headers/linux/virtio_ids.h"
f43c0076 MT	33	#include "standard-headers/linux/virtio_config.h"
5551e3a8 GA	34
	35
	36	#define VIRTIO_CRYPTO_SERVICE_CIPHER 0
f43c0076 MT	37	#define VIRTIO_CRYPTO_SERVICE_HASH 1
	38	#define VIRTIO_CRYPTO_SERVICE_MAC 2
	39	#define VIRTIO_CRYPTO_SERVICE_AEAD 3
5551e3a8 GA	40
	41	#define VIRTIO_CRYPTO_OPCODE(service, op) (((service) << 8) \| (op))
	42
	43	struct virtio_crypto_ctrl_header {
	44	#define VIRTIO_CRYPTO_CIPHER_CREATE_SESSION \
f43c0076	45	VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_CIPHER, 0x02)
5551e3a8	46	#define VIRTIO_CRYPTO_CIPHER_DESTROY_SESSION \
f43c0076	47	VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_CIPHER, 0x03)
5551e3a8	48	#define VIRTIO_CRYPTO_HASH_CREATE_SESSION \
f43c0076	49	VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_HASH, 0x02)
5551e3a8	50	#define VIRTIO_CRYPTO_HASH_DESTROY_SESSION \
f43c0076	51	VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_HASH, 0x03)
5551e3a8	52	#define VIRTIO_CRYPTO_MAC_CREATE_SESSION \
f43c0076	53	VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_MAC, 0x02)
5551e3a8	54	#define VIRTIO_CRYPTO_MAC_DESTROY_SESSION \
f43c0076	55	VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_MAC, 0x03)
5551e3a8	56	#define VIRTIO_CRYPTO_AEAD_CREATE_SESSION \
f43c0076	57	VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_AEAD, 0x02)
5551e3a8	58	#define VIRTIO_CRYPTO_AEAD_DESTROY_SESSION \
f43c0076 MT	59	VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_AEAD, 0x03)
	60	uint32_t opcode;
	61	uint32_t algo;
	62	uint32_t flag;
	63	/* data virtqueue id */
	64	uint32_t queue_id;
5551e3a8 GA	65	};
	66
	67	struct virtio_crypto_cipher_session_para {
	68	#define VIRTIO_CRYPTO_NO_CIPHER 0
	69	#define VIRTIO_CRYPTO_CIPHER_ARC4 1
	70	#define VIRTIO_CRYPTO_CIPHER_AES_ECB 2
	71	#define VIRTIO_CRYPTO_CIPHER_AES_CBC 3
	72	#define VIRTIO_CRYPTO_CIPHER_AES_CTR 4
	73	#define VIRTIO_CRYPTO_CIPHER_DES_ECB 5
	74	#define VIRTIO_CRYPTO_CIPHER_DES_CBC 6
	75	#define VIRTIO_CRYPTO_CIPHER_3DES_ECB 7
	76	#define VIRTIO_CRYPTO_CIPHER_3DES_CBC 8
	77	#define VIRTIO_CRYPTO_CIPHER_3DES_CTR 9
	78	#define VIRTIO_CRYPTO_CIPHER_KASUMI_F8 10
	79	#define VIRTIO_CRYPTO_CIPHER_SNOW3G_UEA2 11
	80	#define VIRTIO_CRYPTO_CIPHER_AES_F8 12
	81	#define VIRTIO_CRYPTO_CIPHER_AES_XTS 13
	82	#define VIRTIO_CRYPTO_CIPHER_ZUC_EEA3 14
f43c0076 MT	83	uint32_t algo;
	84	/* length of key */
	85	uint32_t keylen;
5551e3a8 GA	86
	87	#define VIRTIO_CRYPTO_OP_ENCRYPT 1
	88	#define VIRTIO_CRYPTO_OP_DECRYPT 2
f43c0076 MT	89	/* encrypt or decrypt */
	90	uint32_t op;
	91	uint32_t padding;
5551e3a8 GA	92	};
	93
	94	struct virtio_crypto_session_input {
f43c0076 MT	95	/* Device-writable part */
	96	uint64_t session_id;
	97	uint32_t status;
	98	uint32_t padding;
5551e3a8 GA	99	};
	100
	101	struct virtio_crypto_cipher_session_req {
f43c0076 MT	102	struct virtio_crypto_cipher_session_para para;
f43c0076 MT	103	uint8_t padding[32];
5551e3a8 GA	104	};
	105
	106	struct virtio_crypto_hash_session_para {
	107	#define VIRTIO_CRYPTO_NO_HASH 0
	108	#define VIRTIO_CRYPTO_HASH_MD5 1
	109	#define VIRTIO_CRYPTO_HASH_SHA1 2
	110	#define VIRTIO_CRYPTO_HASH_SHA_224 3
	111	#define VIRTIO_CRYPTO_HASH_SHA_256 4
	112	#define VIRTIO_CRYPTO_HASH_SHA_384 5
	113	#define VIRTIO_CRYPTO_HASH_SHA_512 6
	114	#define VIRTIO_CRYPTO_HASH_SHA3_224 7
	115	#define VIRTIO_CRYPTO_HASH_SHA3_256 8
	116	#define VIRTIO_CRYPTO_HASH_SHA3_384 9
	117	#define VIRTIO_CRYPTO_HASH_SHA3_512 10
	118	#define VIRTIO_CRYPTO_HASH_SHA3_SHAKE128 11
	119	#define VIRTIO_CRYPTO_HASH_SHA3_SHAKE256 12
f43c0076 MT	120	uint32_t algo;
	121	/* hash result length */
	122	uint32_t hash_result_len;
	123	uint8_t padding[8];
5551e3a8 GA	124	};
	125
	126	struct virtio_crypto_hash_create_session_req {
f43c0076 MT	127	struct virtio_crypto_hash_session_para para;
f43c0076 MT	128	uint8_t padding[40];
5551e3a8 GA	129	};
	130
	131	struct virtio_crypto_mac_session_para {
	132	#define VIRTIO_CRYPTO_NO_MAC 0
	133	#define VIRTIO_CRYPTO_MAC_HMAC_MD5 1
	134	#define VIRTIO_CRYPTO_MAC_HMAC_SHA1 2
	135	#define VIRTIO_CRYPTO_MAC_HMAC_SHA_224 3
	136	#define VIRTIO_CRYPTO_MAC_HMAC_SHA_256 4
	137	#define VIRTIO_CRYPTO_MAC_HMAC_SHA_384 5
	138	#define VIRTIO_CRYPTO_MAC_HMAC_SHA_512 6
	139	#define VIRTIO_CRYPTO_MAC_CMAC_3DES 25
	140	#define VIRTIO_CRYPTO_MAC_CMAC_AES 26
	141	#define VIRTIO_CRYPTO_MAC_KASUMI_F9 27
	142	#define VIRTIO_CRYPTO_MAC_SNOW3G_UIA2 28
	143	#define VIRTIO_CRYPTO_MAC_GMAC_AES 41
	144	#define VIRTIO_CRYPTO_MAC_GMAC_TWOFISH 42
	145	#define VIRTIO_CRYPTO_MAC_CBCMAC_AES 49
	146	#define VIRTIO_CRYPTO_MAC_CBCMAC_KASUMI_F9 50
	147	#define VIRTIO_CRYPTO_MAC_XCBC_AES 53
f43c0076 MT	148	uint32_t algo;
	149	/* hash result length */
	150	uint32_t hash_result_len;
	151	/* length of authenticated key */
	152	uint32_t auth_key_len;
	153	uint32_t padding;
5551e3a8 GA	154	};
	155
	156	struct virtio_crypto_mac_create_session_req {
f43c0076 MT	157	struct virtio_crypto_mac_session_para para;
f43c0076 MT	158	uint8_t padding[40];
5551e3a8 GA	159	};
	160
	161	struct virtio_crypto_aead_session_para {
	162	#define VIRTIO_CRYPTO_NO_AEAD 0
	163	#define VIRTIO_CRYPTO_AEAD_GCM 1
	164	#define VIRTIO_CRYPTO_AEAD_CCM 2
	165	#define VIRTIO_CRYPTO_AEAD_CHACHA20_POLY1305 3
f43c0076 MT	166	uint32_t algo;
	167	/* length of key */
	168	uint32_t key_len;
	169	/* hash result length */
	170	uint32_t hash_result_len;
	171	/* length of the additional authenticated data (AAD) in bytes */
	172	uint32_t aad_len;
	173	/* encrypt or decrypt, See above VIRTIO_CRYPTO_OP_* */
	174	uint32_t op;
	175	uint32_t padding;
5551e3a8 GA	176	};
	177
	178	struct virtio_crypto_aead_create_session_req {
f43c0076 MT	179	struct virtio_crypto_aead_session_para para;
f43c0076 MT	180	uint8_t padding[32];
5551e3a8 GA	181	};
	182
	183	struct virtio_crypto_alg_chain_session_para {
	184	#define VIRTIO_CRYPTO_SYM_ALG_CHAIN_ORDER_HASH_THEN_CIPHER 1
	185	#define VIRTIO_CRYPTO_SYM_ALG_CHAIN_ORDER_CIPHER_THEN_HASH 2
f43c0076	186	uint32_t alg_chain_order;
5551e3a8 GA	187	/* Plain hash */
	188	#define VIRTIO_CRYPTO_SYM_HASH_MODE_PLAIN 1
	189	/* Authenticated hash (mac) */
	190	#define VIRTIO_CRYPTO_SYM_HASH_MODE_AUTH 2
	191	/* Nested hash */
	192	#define VIRTIO_CRYPTO_SYM_HASH_MODE_NESTED 3
f43c0076 MT	193	uint32_t hash_mode;
	194	struct virtio_crypto_cipher_session_para cipher_param;
	195	union {
	196	struct virtio_crypto_hash_session_para hash_param;
	197	struct virtio_crypto_mac_session_para mac_param;
	198	uint8_t padding[16];
	199	} u;
	200	/* length of the additional authenticated data (AAD) in bytes */
	201	uint32_t aad_len;
	202	uint32_t padding;
5551e3a8 GA	203	};
	204
	205	struct virtio_crypto_alg_chain_session_req {
f43c0076	206	struct virtio_crypto_alg_chain_session_para para;
5551e3a8 GA	207	};
	208
	209	struct virtio_crypto_sym_create_session_req {
f43c0076 MT	210	union {
	211	struct virtio_crypto_cipher_session_req cipher;
	212	struct virtio_crypto_alg_chain_session_req chain;
	213	uint8_t padding[48];
	214	} u;
5551e3a8	215
f43c0076	216	/* Device-readable part */
5551e3a8 GA	217
	218	/* No operation */
	219	#define VIRTIO_CRYPTO_SYM_OP_NONE 0
	220	/* Cipher only operation on the data */
	221	#define VIRTIO_CRYPTO_SYM_OP_CIPHER 1
f43c0076 MT	222	/*
	223	* Chain any cipher with any hash or mac operation. The order
	224	* depends on the value of alg_chain_order param
	225	*/
5551e3a8	226	#define VIRTIO_CRYPTO_SYM_OP_ALGORITHM_CHAINING 2
f43c0076 MT	227	uint32_t op_type;
f43c0076 MT	228	uint32_t padding;
5551e3a8 GA	229	};
	230
	231	struct virtio_crypto_destroy_session_req {
f43c0076 MT	232	/* Device-readable part */
	233	uint64_t session_id;
	234	uint8_t padding[48];
5551e3a8 GA	235	};
5551e3a8 GA	236
f43c0076	237	/* The request of the control virtqueue's packet */
5551e3a8	238	struct virtio_crypto_op_ctrl_req {
f43c0076 MT	239	struct virtio_crypto_ctrl_header header;
	240
	241	union {
	242	struct virtio_crypto_sym_create_session_req
	243	sym_create_session;
	244	struct virtio_crypto_hash_create_session_req
	245	hash_create_session;
	246	struct virtio_crypto_mac_create_session_req
	247	mac_create_session;
	248	struct virtio_crypto_aead_create_session_req
	249	aead_create_session;
	250	struct virtio_crypto_destroy_session_req
	251	destroy_session;
	252	uint8_t padding[56];
	253	} u;
5551e3a8 GA	254	};
	255
	256	struct virtio_crypto_op_header {
	257	#define VIRTIO_CRYPTO_CIPHER_ENCRYPT \
f43c0076	258	VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_CIPHER, 0x00)
5551e3a8	259	#define VIRTIO_CRYPTO_CIPHER_DECRYPT \
f43c0076	260	VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_CIPHER, 0x01)
5551e3a8	261	#define VIRTIO_CRYPTO_HASH \
f43c0076	262	VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_HASH, 0x00)
5551e3a8	263	#define VIRTIO_CRYPTO_MAC \
f43c0076	264	VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_MAC, 0x00)
5551e3a8	265	#define VIRTIO_CRYPTO_AEAD_ENCRYPT \
f43c0076	266	VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_AEAD, 0x00)
5551e3a8	267	#define VIRTIO_CRYPTO_AEAD_DECRYPT \
f43c0076 MT	268	VIRTIO_CRYPTO_OPCODE(VIRTIO_CRYPTO_SERVICE_AEAD, 0x01)
	269	uint32_t opcode;
	270	/* algo should be service-specific algorithms */
	271	uint32_t algo;
	272	/* session_id should be service-specific algorithms */
	273	uint64_t session_id;
	274	/* control flag to control the request */
	275	uint32_t flag;
	276	uint32_t padding;
5551e3a8 GA	277	};
	278
	279	struct virtio_crypto_cipher_para {
f43c0076 MT	280	/*
	281	* Byte Length of valid IV/Counter
	282	*
	283	* For block ciphers in CBC or F8 mode, or for Kasumi in F8 mode, or for
	284	* SNOW3G in UEA2 mode, this is the length of the IV (which
	285	* must be the same as the block length of the cipher).
	286	* For block ciphers in CTR mode, this is the length of the counter
	287	* (which must be the same as the block length of the cipher).
	288	* For AES-XTS, this is the 128bit tweak, i, from IEEE Std 1619-2007.
	289	*
	290	* The IV/Counter will be updated after every partial cryptographic
	291	* operation.
	292	*/
	293	uint32_t iv_len;
	294	/* length of source data */
	295	uint32_t src_data_len;
	296	/* length of dst data */
	297	uint32_t dst_data_len;
	298	uint32_t padding;
5551e3a8 GA	299	};
	300
	301	struct virtio_crypto_hash_para {
f43c0076 MT	302	/* length of source data */
	303	uint32_t src_data_len;
	304	/* hash result length */
	305	uint32_t hash_result_len;
5551e3a8 GA	306	};
	307
	308	struct virtio_crypto_mac_para {
f43c0076	309	struct virtio_crypto_hash_para hash;
5551e3a8 GA	310	};
	311
	312	struct virtio_crypto_aead_para {
f43c0076 MT	313	/*
	314	* Byte Length of valid IV data pointed to by the below iv_addr
	315	* parameter.
	316	*
	317	* For GCM mode, this is either 12 (for 96-bit IVs) or 16, in which
	318	* case iv_addr points to J0.
	319	* For CCM mode, this is the length of the nonce, which can be in the
	320	* range 7 to 13 inclusive.
	321	*/
	322	uint32_t iv_len;
	323	/* length of additional auth data */
	324	uint32_t aad_len;
	325	/* length of source data */
	326	uint32_t src_data_len;
	327	/* length of dst data */
	328	uint32_t dst_data_len;
5551e3a8 GA	329	};
	330
	331	struct virtio_crypto_cipher_data_req {
f43c0076 MT	332	/* Device-readable part */
	333	struct virtio_crypto_cipher_para para;
	334	uint8_t padding[24];
5551e3a8 GA	335	};
	336
	337	struct virtio_crypto_hash_data_req {
f43c0076 MT	338	/* Device-readable part */
	339	struct virtio_crypto_hash_para para;
	340	uint8_t padding[40];
5551e3a8 GA	341	};
	342
	343	struct virtio_crypto_mac_data_req {
f43c0076 MT	344	/* Device-readable part */
	345	struct virtio_crypto_mac_para para;
	346	uint8_t padding[40];
5551e3a8 GA	347	};
	348
	349	struct virtio_crypto_alg_chain_data_para {
f43c0076 MT	350	uint32_t iv_len;
	351	/* Length of source data */
	352	uint32_t src_data_len;
	353	/* Length of destination data */
	354	uint32_t dst_data_len;
	355	/* Starting point for cipher processing in source data */
	356	uint32_t cipher_start_src_offset;
	357	/* Length of the source data that the cipher will be computed on */
	358	uint32_t len_to_cipher;
	359	/* Starting point for hash processing in source data */
	360	uint32_t hash_start_src_offset;
	361	/* Length of the source data that the hash will be computed on */
	362	uint32_t len_to_hash;
	363	/* Length of the additional auth data */
	364	uint32_t aad_len;
	365	/* Length of the hash result */
	366	uint32_t hash_result_len;
	367	uint32_t reserved;
5551e3a8 GA	368	};
	369
	370	struct virtio_crypto_alg_chain_data_req {
f43c0076 MT	371	/* Device-readable part */
f43c0076 MT	372	struct virtio_crypto_alg_chain_data_para para;
5551e3a8 GA	373	};
	374
	375	struct virtio_crypto_sym_data_req {
f43c0076 MT	376	union {
	377	struct virtio_crypto_cipher_data_req cipher;
	378	struct virtio_crypto_alg_chain_data_req chain;
	379	uint8_t padding[40];
	380	} u;
	381
	382	/* See above VIRTIO_CRYPTO_SYM_OP_* */
	383	uint32_t op_type;
	384	uint32_t padding;
5551e3a8 GA	385	};
	386
	387	struct virtio_crypto_aead_data_req {
f43c0076 MT	388	/* Device-readable part */
	389	struct virtio_crypto_aead_para para;
	390	uint8_t padding[32];
5551e3a8 GA	391	};
5551e3a8 GA	392
f43c0076	393	/* The request of the data virtqueue's packet */
5551e3a8	394	struct virtio_crypto_op_data_req {
f43c0076 MT	395	struct virtio_crypto_op_header header;
	396
	397	union {
	398	struct virtio_crypto_sym_data_req sym_req;
	399	struct virtio_crypto_hash_data_req hash_req;
	400	struct virtio_crypto_mac_data_req mac_req;
	401	struct virtio_crypto_aead_data_req aead_req;
	402	uint8_t padding[48];
	403	} u;
5551e3a8 GA	404	};
	405
	406	#define VIRTIO_CRYPTO_OK 0
	407	#define VIRTIO_CRYPTO_ERR 1
	408	#define VIRTIO_CRYPTO_BADMSG 2
	409	#define VIRTIO_CRYPTO_NOTSUPP 3
f43c0076	410	#define VIRTIO_CRYPTO_INVSESS 4 /* Invalid session id */
5551e3a8 GA	411
	412	/* The accelerator hardware is ready */
	413	#define VIRTIO_CRYPTO_S_HW_READY (1 << 0)
5551e3a8 GA	414
5551e3a8 GA	415	struct virtio_crypto_config {
f43c0076 MT	416	/* See VIRTIO_CRYPTO_OP_* above */
	417	uint32_t status;
	418
	419	/*
	420	* Maximum number of data queue
	421	*/
	422	uint32_t max_dataqueues;
	423
	424	/*
	425	* Specifies the services mask which the device support,
	426	* see VIRTIO_CRYPTO_SERVICE_* above
	427	*/
	428	uint32_t crypto_services;
	429
	430	/* Detailed algorithms mask */
	431	uint32_t cipher_algo_l;
	432	uint32_t cipher_algo_h;
	433	uint32_t hash_algo;
	434	uint32_t mac_algo_l;
	435	uint32_t mac_algo_h;
	436	uint32_t aead_algo;
	437	/* Maximum length of cipher key */
	438	uint32_t max_cipher_key_len;
	439	/* Maximum length of authenticated key */
	440	uint32_t max_auth_key_len;
	441	uint32_t reserve;
	442	/* Maximum size of each crypto request's content */
	443	uint64_t max_size;
5551e3a8 GA	444	};
	445
	446	struct virtio_crypto_inhdr {
f43c0076 MT	447	/* See VIRTIO_CRYPTO_* above */
f43c0076 MT	448	uint8_t status;
5551e3a8	449	};
f43c0076	450	#endif