[deliverable/linux.git] / drivers / crypto / ccp / ccp-crypto.h

/*
 * AMD Cryptographic Coprocessor (CCP) crypto API support
 *
 * Copyright (C) 2013 Advanced Micro Devices, Inc.
 *
 * Author: Tom Lendacky <thomas.lendacky@amd.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#ifndef __CCP_CRYPTO_H__
#define __CCP_CRYPTO_H__

#include <linux/list.h>
#include <linux/wait.h>
#include <linux/pci.h>
#include <linux/ccp.h>
#include <crypto/algapi.h>
#include <crypto/aes.h>
#include <crypto/ctr.h>
#include <crypto/hash.h>
#include <crypto/sha.h>

#define CCP_CRA_PRIORITY	300

struct ccp_crypto_ablkcipher_alg {
	struct list_head entry;

	u32 mode;

	struct crypto_alg alg;
};

struct ccp_crypto_ahash_alg {
	struct list_head entry;

	const __be32 *init;
	u32 type;
	u32 mode;

	/* Child algorithm used for HMAC, CMAC, etc */
	char child_alg[CRYPTO_MAX_ALG_NAME];

	struct ahash_alg alg;
};

static inline struct ccp_crypto_ablkcipher_alg *
	ccp_crypto_ablkcipher_alg(struct crypto_tfm *tfm)
{
	struct crypto_alg *alg = tfm->__crt_alg;

	return container_of(alg, struct ccp_crypto_ablkcipher_alg, alg);
}

static inline struct ccp_crypto_ahash_alg *
	ccp_crypto_ahash_alg(struct crypto_tfm *tfm)
{
	struct crypto_alg *alg = tfm->__crt_alg;
	struct ahash_alg *ahash_alg;

	ahash_alg = container_of(alg, struct ahash_alg, halg.base);

	return container_of(ahash_alg, struct ccp_crypto_ahash_alg, alg);
}

/***** AES related defines *****/
struct ccp_aes_ctx {
	/* Fallback cipher for XTS with unsupported unit sizes */
	struct crypto_skcipher *tfm_skcipher;

	/* Cipher used to generate CMAC K1/K2 keys */
	struct crypto_cipher *tfm_cipher;

	enum ccp_engine engine;
	enum ccp_aes_type type;
	enum ccp_aes_mode mode;

	struct scatterlist key_sg;
	unsigned int key_len;
	u8 key[AES_MAX_KEY_SIZE];

	u8 nonce[CTR_RFC3686_NONCE_SIZE];

	/* CMAC key structures */
	struct scatterlist k1_sg;
	struct scatterlist k2_sg;
	unsigned int kn_len;
	u8 k1[AES_BLOCK_SIZE];
	u8 k2[AES_BLOCK_SIZE];
};

struct ccp_aes_req_ctx {
	struct scatterlist iv_sg;
	u8 iv[AES_BLOCK_SIZE];

	/* Fields used for RFC3686 requests */
	u8 *rfc3686_info;
	u8 rfc3686_iv[AES_BLOCK_SIZE];

	struct ccp_cmd cmd;
};

struct ccp_aes_cmac_req_ctx {
	unsigned int null_msg;
	unsigned int final;

	struct scatterlist *src;
	unsigned int nbytes;

	u64 hash_cnt;
	unsigned int hash_rem;

	struct sg_table data_sg;

	struct scatterlist iv_sg;
	u8 iv[AES_BLOCK_SIZE];

	struct scatterlist buf_sg;
	unsigned int buf_count;
	u8 buf[AES_BLOCK_SIZE];

	struct scatterlist pad_sg;
	unsigned int pad_count;
	u8 pad[AES_BLOCK_SIZE];

	struct ccp_cmd cmd;
};

struct ccp_aes_cmac_exp_ctx {
	unsigned int null_msg;

	u8 iv[AES_BLOCK_SIZE];

	unsigned int buf_count;
	u8 buf[AES_BLOCK_SIZE];
};

/***** SHA related defines *****/
#define MAX_SHA_CONTEXT_SIZE	SHA256_DIGEST_SIZE
#define MAX_SHA_BLOCK_SIZE	SHA256_BLOCK_SIZE

struct ccp_sha_ctx {
	struct scatterlist opad_sg;
	unsigned int opad_count;

	unsigned int key_len;
	u8 key[MAX_SHA_BLOCK_SIZE];
	u8 ipad[MAX_SHA_BLOCK_SIZE];
	u8 opad[MAX_SHA_BLOCK_SIZE];
	struct crypto_shash *hmac_tfm;
};

struct ccp_sha_req_ctx {
	enum ccp_sha_type type;

	u64 msg_bits;

	unsigned int first;
	unsigned int final;

	struct scatterlist *src;
	unsigned int nbytes;

	u64 hash_cnt;
	unsigned int hash_rem;

	struct sg_table data_sg;

	struct scatterlist ctx_sg;
	u8 ctx[MAX_SHA_CONTEXT_SIZE];

	struct scatterlist buf_sg;
	unsigned int buf_count;
	u8 buf[MAX_SHA_BLOCK_SIZE];

	/* CCP driver command */
	struct ccp_cmd cmd;
};

struct ccp_sha_exp_ctx {
	enum ccp_sha_type type;

	u64 msg_bits;

	unsigned int first;

	u8 ctx[MAX_SHA_CONTEXT_SIZE];

	unsigned int buf_count;
	u8 buf[MAX_SHA_BLOCK_SIZE];
};

/***** Common Context Structure *****/
struct ccp_ctx {
	int (*complete)(struct crypto_async_request *req, int ret);

	union {
		struct ccp_aes_ctx aes;
		struct ccp_sha_ctx sha;
	} u;
};

int ccp_crypto_enqueue_request(struct crypto_async_request *req,
			       struct ccp_cmd *cmd);
struct scatterlist *ccp_crypto_sg_table_add(struct sg_table *table,
					    struct scatterlist *sg_add);

int ccp_register_aes_algs(struct list_head *head);
int ccp_register_aes_cmac_algs(struct list_head *head);
int ccp_register_aes_xts_algs(struct list_head *head);
int ccp_register_sha_algs(struct list_head *head);

#endif
Commit	Line	Data
d3123599 TL	1	/*
	2	* AMD Cryptographic Coprocessor (CCP) crypto API support
	3	*
	4	* Copyright (C) 2013 Advanced Micro Devices, Inc.
	5	*
	6	* Author: Tom Lendacky <thomas.lendacky@amd.com>
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License version 2 as
	10	* published by the Free Software Foundation.
	11	*/
	12
	13	#ifndef __CCP_CRYPTO_H__
	14	#define __CCP_CRYPTO_H__
	15
d3123599 TL	16	#include <linux/list.h>
	17	#include <linux/wait.h>
	18	#include <linux/pci.h>
	19	#include <linux/ccp.h>
d3123599 TL	20	#include <crypto/algapi.h>
	21	#include <crypto/aes.h>
	22	#include <crypto/ctr.h>
	23	#include <crypto/hash.h>
	24	#include <crypto/sha.h>
	25
d3123599 TL	26	#define CCP_CRA_PRIORITY 300
	27
	28	struct ccp_crypto_ablkcipher_alg {
	29	struct list_head entry;
	30
	31	u32 mode;
	32
	33	struct crypto_alg alg;
	34	};
	35
	36	struct ccp_crypto_ahash_alg {
	37	struct list_head entry;
	38
6f0be9b2	39	const __be32 *init;
d3123599 TL	40	u32 type;
	41	u32 mode;
	42
	43	/* Child algorithm used for HMAC, CMAC, etc */
	44	char child_alg[CRYPTO_MAX_ALG_NAME];
	45
	46	struct ahash_alg alg;
	47	};
	48
	49	static inline struct ccp_crypto_ablkcipher_alg *
	50	ccp_crypto_ablkcipher_alg(struct crypto_tfm *tfm)
	51	{
	52	struct crypto_alg *alg = tfm->__crt_alg;
	53
	54	return container_of(alg, struct ccp_crypto_ablkcipher_alg, alg);
	55	}
	56
	57	static inline struct ccp_crypto_ahash_alg *
	58	ccp_crypto_ahash_alg(struct crypto_tfm *tfm)
	59	{
	60	struct crypto_alg *alg = tfm->__crt_alg;
	61	struct ahash_alg *ahash_alg;
	62
	63	ahash_alg = container_of(alg, struct ahash_alg, halg.base);
	64
	65	return container_of(ahash_alg, struct ccp_crypto_ahash_alg, alg);
	66	}
	67
d3123599 TL	68	/*** AES related defines ***/
	69	struct ccp_aes_ctx {
	70	/* Fallback cipher for XTS with unsupported unit sizes */
241118de	71	struct crypto_skcipher *tfm_skcipher;
d3123599 TL	72
	73	/* Cipher used to generate CMAC K1/K2 keys */
	74	struct crypto_cipher *tfm_cipher;
	75
	76	enum ccp_engine engine;
	77	enum ccp_aes_type type;
	78	enum ccp_aes_mode mode;
	79
	80	struct scatterlist key_sg;
	81	unsigned int key_len;
	82	u8 key[AES_MAX_KEY_SIZE];
	83
	84	u8 nonce[CTR_RFC3686_NONCE_SIZE];
	85
	86	/* CMAC key structures */
	87	struct scatterlist k1_sg;
	88	struct scatterlist k2_sg;
	89	unsigned int kn_len;
	90	u8 k1[AES_BLOCK_SIZE];
	91	u8 k2[AES_BLOCK_SIZE];
	92	};
	93
	94	struct ccp_aes_req_ctx {
	95	struct scatterlist iv_sg;
	96	u8 iv[AES_BLOCK_SIZE];
	97
	98	/* Fields used for RFC3686 requests */
	99	u8 *rfc3686_info;
	100	u8 rfc3686_iv[AES_BLOCK_SIZE];
	101
	102	struct ccp_cmd cmd;
	103	};
	104
	105	struct ccp_aes_cmac_req_ctx {
	106	unsigned int null_msg;
	107	unsigned int final;
	108
81a59f00 TL	109	struct scatterlist *src;
	110	unsigned int nbytes;
	111
	112	u64 hash_cnt;
d3123599 TL	113	unsigned int hash_rem;
	114
	115	struct sg_table data_sg;
	116
	117	struct scatterlist iv_sg;
	118	u8 iv[AES_BLOCK_SIZE];
	119
	120	struct scatterlist buf_sg;
	121	unsigned int buf_count;
	122	u8 buf[AES_BLOCK_SIZE];
	123
	124	struct scatterlist pad_sg;
	125	unsigned int pad_count;
	126	u8 pad[AES_BLOCK_SIZE];
	127
	128	struct ccp_cmd cmd;
	129	};
	130
d1662165 TL	131	struct ccp_aes_cmac_exp_ctx {
	132	unsigned int null_msg;
	133
	134	u8 iv[AES_BLOCK_SIZE];
	135
	136	unsigned int buf_count;
	137	u8 buf[AES_BLOCK_SIZE];
	138	};
	139
d3123599 TL	140	/*** SHA related defines ***/
	141	#define MAX_SHA_CONTEXT_SIZE SHA256_DIGEST_SIZE
	142	#define MAX_SHA_BLOCK_SIZE SHA256_BLOCK_SIZE
	143
	144	struct ccp_sha_ctx {
c11baa02 TL	145	struct scatterlist opad_sg;
	146	unsigned int opad_count;
	147
d3123599 TL	148	unsigned int key_len;
	149	u8 key[MAX_SHA_BLOCK_SIZE];
	150	u8 ipad[MAX_SHA_BLOCK_SIZE];
	151	u8 opad[MAX_SHA_BLOCK_SIZE];
c11baa02	152	struct crypto_shash *hmac_tfm;
d3123599 TL	153	};
	154
	155	struct ccp_sha_req_ctx {
	156	enum ccp_sha_type type;
	157
	158	u64 msg_bits;
	159
	160	unsigned int first;
	161	unsigned int final;
	162
81a59f00 TL	163	struct scatterlist *src;
	164	unsigned int nbytes;
	165
	166	u64 hash_cnt;
d3123599 TL	167	unsigned int hash_rem;
	168
	169	struct sg_table data_sg;
	170
	171	struct scatterlist ctx_sg;
	172	u8 ctx[MAX_SHA_CONTEXT_SIZE];
	173
	174	struct scatterlist buf_sg;
	175	unsigned int buf_count;
	176	u8 buf[MAX_SHA_BLOCK_SIZE];
	177
d3123599 TL	178	/* CCP driver command */
	179	struct ccp_cmd cmd;
	180	};
	181
d1662165 TL	182	struct ccp_sha_exp_ctx {
	183	enum ccp_sha_type type;
	184
	185	u64 msg_bits;
	186
	187	unsigned int first;
	188
	189	u8 ctx[MAX_SHA_CONTEXT_SIZE];
	190
	191	unsigned int buf_count;
	192	u8 buf[MAX_SHA_BLOCK_SIZE];
	193	};
	194
d3123599 TL	195	/*** Common Context Structure ***/
	196	struct ccp_ctx {
	197	int (complete)(struct crypto_async_request req, int ret);
	198
	199	union {
	200	struct ccp_aes_ctx aes;
	201	struct ccp_sha_ctx sha;
	202	} u;
	203	};
	204
	205	int ccp_crypto_enqueue_request(struct crypto_async_request *req,
	206	struct ccp_cmd *cmd);
	207	struct scatterlist ccp_crypto_sg_table_add(struct sg_table table,
	208	struct scatterlist *sg_add);
	209
	210	int ccp_register_aes_algs(struct list_head *head);
	211	int ccp_register_aes_cmac_algs(struct list_head *head);
	212	int ccp_register_aes_xts_algs(struct list_head *head);
	213	int ccp_register_sha_algs(struct list_head *head);
	214
	215	#endif