Add the rt linux 4.1.3-rt3 as base
[kvmfornfv.git] / kernel / drivers / crypto / ccp / ccp-crypto.h
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
16 #include <linux/list.h>
17 #include <linux/wait.h>
18 #include <linux/pci.h>
19 #include <linux/ccp.h>
20 #include <linux/crypto.h>
21 #include <crypto/algapi.h>
22 #include <crypto/aes.h>
23 #include <crypto/ctr.h>
24 #include <crypto/hash.h>
25 #include <crypto/sha.h>
26
27 #define CCP_CRA_PRIORITY        300
28
29 struct ccp_crypto_ablkcipher_alg {
30         struct list_head entry;
31
32         u32 mode;
33
34         struct crypto_alg alg;
35 };
36
37 struct ccp_crypto_ahash_alg {
38         struct list_head entry;
39
40         const __be32 *init;
41         u32 type;
42         u32 mode;
43
44         /* Child algorithm used for HMAC, CMAC, etc */
45         char child_alg[CRYPTO_MAX_ALG_NAME];
46
47         struct ahash_alg alg;
48 };
49
50 static inline struct ccp_crypto_ablkcipher_alg *
51         ccp_crypto_ablkcipher_alg(struct crypto_tfm *tfm)
52 {
53         struct crypto_alg *alg = tfm->__crt_alg;
54
55         return container_of(alg, struct ccp_crypto_ablkcipher_alg, alg);
56 }
57
58 static inline struct ccp_crypto_ahash_alg *
59         ccp_crypto_ahash_alg(struct crypto_tfm *tfm)
60 {
61         struct crypto_alg *alg = tfm->__crt_alg;
62         struct ahash_alg *ahash_alg;
63
64         ahash_alg = container_of(alg, struct ahash_alg, halg.base);
65
66         return container_of(ahash_alg, struct ccp_crypto_ahash_alg, alg);
67 }
68
69 /***** AES related defines *****/
70 struct ccp_aes_ctx {
71         /* Fallback cipher for XTS with unsupported unit sizes */
72         struct crypto_ablkcipher *tfm_ablkcipher;
73
74         /* Cipher used to generate CMAC K1/K2 keys */
75         struct crypto_cipher *tfm_cipher;
76
77         enum ccp_engine engine;
78         enum ccp_aes_type type;
79         enum ccp_aes_mode mode;
80
81         struct scatterlist key_sg;
82         unsigned int key_len;
83         u8 key[AES_MAX_KEY_SIZE];
84
85         u8 nonce[CTR_RFC3686_NONCE_SIZE];
86
87         /* CMAC key structures */
88         struct scatterlist k1_sg;
89         struct scatterlist k2_sg;
90         unsigned int kn_len;
91         u8 k1[AES_BLOCK_SIZE];
92         u8 k2[AES_BLOCK_SIZE];
93 };
94
95 struct ccp_aes_req_ctx {
96         struct scatterlist iv_sg;
97         u8 iv[AES_BLOCK_SIZE];
98
99         /* Fields used for RFC3686 requests */
100         u8 *rfc3686_info;
101         u8 rfc3686_iv[AES_BLOCK_SIZE];
102
103         struct ccp_cmd cmd;
104 };
105
106 struct ccp_aes_cmac_req_ctx {
107         unsigned int null_msg;
108         unsigned int final;
109
110         struct scatterlist *src;
111         unsigned int nbytes;
112
113         u64 hash_cnt;
114         unsigned int hash_rem;
115
116         struct sg_table data_sg;
117
118         struct scatterlist iv_sg;
119         u8 iv[AES_BLOCK_SIZE];
120
121         struct scatterlist buf_sg;
122         unsigned int buf_count;
123         u8 buf[AES_BLOCK_SIZE];
124
125         struct scatterlist pad_sg;
126         unsigned int pad_count;
127         u8 pad[AES_BLOCK_SIZE];
128
129         struct ccp_cmd cmd;
130 };
131
132 /***** SHA related defines *****/
133 #define MAX_SHA_CONTEXT_SIZE    SHA256_DIGEST_SIZE
134 #define MAX_SHA_BLOCK_SIZE      SHA256_BLOCK_SIZE
135
136 struct ccp_sha_ctx {
137         struct scatterlist opad_sg;
138         unsigned int opad_count;
139
140         unsigned int key_len;
141         u8 key[MAX_SHA_BLOCK_SIZE];
142         u8 ipad[MAX_SHA_BLOCK_SIZE];
143         u8 opad[MAX_SHA_BLOCK_SIZE];
144         struct crypto_shash *hmac_tfm;
145 };
146
147 struct ccp_sha_req_ctx {
148         enum ccp_sha_type type;
149
150         u64 msg_bits;
151
152         unsigned int first;
153         unsigned int final;
154
155         struct scatterlist *src;
156         unsigned int nbytes;
157
158         u64 hash_cnt;
159         unsigned int hash_rem;
160
161         struct sg_table data_sg;
162
163         struct scatterlist ctx_sg;
164         u8 ctx[MAX_SHA_CONTEXT_SIZE];
165
166         struct scatterlist buf_sg;
167         unsigned int buf_count;
168         u8 buf[MAX_SHA_BLOCK_SIZE];
169
170         /* CCP driver command */
171         struct ccp_cmd cmd;
172 };
173
174 /***** Common Context Structure *****/
175 struct ccp_ctx {
176         int (*complete)(struct crypto_async_request *req, int ret);
177
178         union {
179                 struct ccp_aes_ctx aes;
180                 struct ccp_sha_ctx sha;
181         } u;
182 };
183
184 int ccp_crypto_enqueue_request(struct crypto_async_request *req,
185                                struct ccp_cmd *cmd);
186 struct scatterlist *ccp_crypto_sg_table_add(struct sg_table *table,
187                                             struct scatterlist *sg_add);
188
189 int ccp_register_aes_algs(struct list_head *head);
190 int ccp_register_aes_cmac_algs(struct list_head *head);
191 int ccp_register_aes_xts_algs(struct list_head *head);
192 int ccp_register_sha_algs(struct list_head *head);
193
194 #endif