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 #include <linux/module.h>
14 #include <linux/moduleparam.h>
15 #include <linux/kernel.h>
16 #include <linux/list.h>
17 #include <linux/ccp.h>
18 #include <linux/scatterlist.h>
19 #include <crypto/internal/hash.h>
20 
21 #include "ccp-crypto.h"
22 
23 MODULE_AUTHOR("Tom Lendacky <thomas.lendacky@amd.com>");
24 MODULE_LICENSE("GPL");
25 MODULE_VERSION("1.0.0");
26 MODULE_DESCRIPTION("AMD Cryptographic Coprocessor crypto API support");
27 
28 static unsigned int aes_disable;
29 module_param(aes_disable, uint, 0444);
30 MODULE_PARM_DESC(aes_disable, "Disable use of AES - any non-zero value");
31 
32 static unsigned int sha_disable;
33 module_param(sha_disable, uint, 0444);
34 MODULE_PARM_DESC(sha_disable, "Disable use of SHA - any non-zero value");
35 
36 /* List heads for the supported algorithms */
37 static LIST_HEAD(hash_algs);
38 static LIST_HEAD(cipher_algs);
39 
40 /* For any tfm, requests for that tfm must be returned on the order
41  * received.  With multiple queues available, the CCP can process more
42  * than one cmd at a time.  Therefore we must maintain a cmd list to insure
43  * the proper ordering of requests on a given tfm.
44  */
45 struct ccp_crypto_queue {
46 	struct list_head cmds;
47 	struct list_head *backlog;
48 	unsigned int cmd_count;
49 };
50 
51 #define CCP_CRYPTO_MAX_QLEN	100
52 
53 static struct ccp_crypto_queue req_queue;
54 static spinlock_t req_queue_lock;
55 
56 struct ccp_crypto_cmd {
57 	struct list_head entry;
58 
59 	struct ccp_cmd *cmd;
60 
61 	/* Save the crypto_tfm and crypto_async_request addresses
62 	 * separately to avoid any reference to a possibly invalid
63 	 * crypto_async_request structure after invoking the request
64 	 * callback
65 	 */
66 	struct crypto_async_request *req;
67 	struct crypto_tfm *tfm;
68 
69 	/* Used for held command processing to determine state */
70 	int ret;
71 };
72 
73 struct ccp_crypto_cpu {
74 	struct work_struct work;
75 	struct completion completion;
76 	struct ccp_crypto_cmd *crypto_cmd;
77 	int err;
78 };
79 
80 static inline bool ccp_crypto_success(int err)
81 {
82 	if (err && (err != -EINPROGRESS) && (err != -EBUSY))
83 		return false;
84 
85 	return true;
86 }
87 
88 static struct ccp_crypto_cmd *ccp_crypto_cmd_complete(
89 	struct ccp_crypto_cmd *crypto_cmd, struct ccp_crypto_cmd **backlog)
90 {
91 	struct ccp_crypto_cmd *held = NULL, *tmp;
92 	unsigned long flags;
93 
94 	*backlog = NULL;
95 
96 	spin_lock_irqsave(&req_queue_lock, flags);
97 
98 	/* Held cmds will be after the current cmd in the queue so start
99 	 * searching for a cmd with a matching tfm for submission.
100 	 */
101 	tmp = crypto_cmd;
102 	list_for_each_entry_continue(tmp, &req_queue.cmds, entry) {
103 		if (crypto_cmd->tfm != tmp->tfm)
104 			continue;
105 		held = tmp;
106 		break;
107 	}
108 
109 	/* Process the backlog:
110 	 *   Because cmds can be executed from any point in the cmd list
111 	 *   special precautions have to be taken when handling the backlog.
112 	 */
113 	if (req_queue.backlog != &req_queue.cmds) {
114 		/* Skip over this cmd if it is the next backlog cmd */
115 		if (req_queue.backlog == &crypto_cmd->entry)
116 			req_queue.backlog = crypto_cmd->entry.next;
117 
118 		*backlog = container_of(req_queue.backlog,
119 					struct ccp_crypto_cmd, entry);
120 		req_queue.backlog = req_queue.backlog->next;
121 
122 		/* Skip over this cmd if it is now the next backlog cmd */
123 		if (req_queue.backlog == &crypto_cmd->entry)
124 			req_queue.backlog = crypto_cmd->entry.next;
125 	}
126 
127 	/* Remove the cmd entry from the list of cmds */
128 	req_queue.cmd_count--;
129 	list_del(&crypto_cmd->entry);
130 
131 	spin_unlock_irqrestore(&req_queue_lock, flags);
132 
133 	return held;
134 }
135 
136 static void ccp_crypto_complete(void *data, int err)
137 {
138 	struct ccp_crypto_cmd *crypto_cmd = data;
139 	struct ccp_crypto_cmd *held, *next, *backlog;
140 	struct crypto_async_request *req = crypto_cmd->req;
141 	struct ccp_ctx *ctx = crypto_tfm_ctx(req->tfm);
142 	int ret;
143 
144 	if (err == -EINPROGRESS) {
145 		/* Only propagate the -EINPROGRESS if necessary */
146 		if (crypto_cmd->ret == -EBUSY) {
147 			crypto_cmd->ret = -EINPROGRESS;
148 			req->complete(req, -EINPROGRESS);
149 		}
150 
151 		return;
152 	}
153 
154 	/* Operation has completed - update the queue before invoking
155 	 * the completion callbacks and retrieve the next cmd (cmd with
156 	 * a matching tfm) that can be submitted to the CCP.
157 	 */
158 	held = ccp_crypto_cmd_complete(crypto_cmd, &backlog);
159 	if (backlog) {
160 		backlog->ret = -EINPROGRESS;
161 		backlog->req->complete(backlog->req, -EINPROGRESS);
162 	}
163 
164 	/* Transition the state from -EBUSY to -EINPROGRESS first */
165 	if (crypto_cmd->ret == -EBUSY)
166 		req->complete(req, -EINPROGRESS);
167 
168 	/* Completion callbacks */
169 	ret = err;
170 	if (ctx->complete)
171 		ret = ctx->complete(req, ret);
172 	req->complete(req, ret);
173 
174 	/* Submit the next cmd */
175 	while (held) {
176 		/* Since we have already queued the cmd, we must indicate that
177 		 * we can backlog so as not to "lose" this request.
178 		 */
179 		held->cmd->flags |= CCP_CMD_MAY_BACKLOG;
180 		ret = ccp_enqueue_cmd(held->cmd);
181 		if (ccp_crypto_success(ret))
182 			break;
183 
184 		/* Error occurred, report it and get the next entry */
185 		ctx = crypto_tfm_ctx(held->req->tfm);
186 		if (ctx->complete)
187 			ret = ctx->complete(held->req, ret);
188 		held->req->complete(held->req, ret);
189 
190 		next = ccp_crypto_cmd_complete(held, &backlog);
191 		if (backlog) {
192 			backlog->ret = -EINPROGRESS;
193 			backlog->req->complete(backlog->req, -EINPROGRESS);
194 		}
195 
196 		kfree(held);
197 		held = next;
198 	}
199 
200 	kfree(crypto_cmd);
201 }
202 
203 static int ccp_crypto_enqueue_cmd(struct ccp_crypto_cmd *crypto_cmd)
204 {
205 	struct ccp_crypto_cmd *active = NULL, *tmp;
206 	unsigned long flags;
207 	bool free_cmd = true;
208 	int ret;
209 
210 	spin_lock_irqsave(&req_queue_lock, flags);
211 
212 	/* Check if the cmd can/should be queued */
213 	if (req_queue.cmd_count >= CCP_CRYPTO_MAX_QLEN) {
214 		ret = -EBUSY;
215 		if (!(crypto_cmd->cmd->flags & CCP_CMD_MAY_BACKLOG))
216 			goto e_lock;
217 	}
218 
219 	/* Look for an entry with the same tfm.  If there is a cmd
220 	 * with the same tfm in the list then the current cmd cannot
221 	 * be submitted to the CCP yet.
222 	 */
223 	list_for_each_entry(tmp, &req_queue.cmds, entry) {
224 		if (crypto_cmd->tfm != tmp->tfm)
225 			continue;
226 		active = tmp;
227 		break;
228 	}
229 
230 	ret = -EINPROGRESS;
231 	if (!active) {
232 		ret = ccp_enqueue_cmd(crypto_cmd->cmd);
233 		if (!ccp_crypto_success(ret))
234 			goto e_lock;	/* Error, don't queue it */
235 		if ((ret == -EBUSY) &&
236 		    !(crypto_cmd->cmd->flags & CCP_CMD_MAY_BACKLOG))
237 			goto e_lock;	/* Not backlogging, don't queue it */
238 	}
239 
240 	if (req_queue.cmd_count >= CCP_CRYPTO_MAX_QLEN) {
241 		ret = -EBUSY;
242 		if (req_queue.backlog == &req_queue.cmds)
243 			req_queue.backlog = &crypto_cmd->entry;
244 	}
245 	crypto_cmd->ret = ret;
246 
247 	req_queue.cmd_count++;
248 	list_add_tail(&crypto_cmd->entry, &req_queue.cmds);
249 
250 	free_cmd = false;
251 
252 e_lock:
253 	spin_unlock_irqrestore(&req_queue_lock, flags);
254 
255 	if (free_cmd)
256 		kfree(crypto_cmd);
257 
258 	return ret;
259 }
260 
261 /**
262  * ccp_crypto_enqueue_request - queue an crypto async request for processing
263  *				by the CCP
264  *
265  * @req: crypto_async_request struct to be processed
266  * @cmd: ccp_cmd struct to be sent to the CCP
267  */
268 int ccp_crypto_enqueue_request(struct crypto_async_request *req,
269 			       struct ccp_cmd *cmd)
270 {
271 	struct ccp_crypto_cmd *crypto_cmd;
272 	gfp_t gfp;
273 
274 	gfp = req->flags & CRYPTO_TFM_REQ_MAY_SLEEP ? GFP_KERNEL : GFP_ATOMIC;
275 
276 	crypto_cmd = kzalloc(sizeof(*crypto_cmd), gfp);
277 	if (!crypto_cmd)
278 		return -ENOMEM;
279 
280 	/* The tfm pointer must be saved and not referenced from the
281 	 * crypto_async_request (req) pointer because it is used after
282 	 * completion callback for the request and the req pointer
283 	 * might not be valid anymore.
284 	 */
285 	crypto_cmd->cmd = cmd;
286 	crypto_cmd->req = req;
287 	crypto_cmd->tfm = req->tfm;
288 
289 	cmd->callback = ccp_crypto_complete;
290 	cmd->data = crypto_cmd;
291 
292 	if (req->flags & CRYPTO_TFM_REQ_MAY_BACKLOG)
293 		cmd->flags |= CCP_CMD_MAY_BACKLOG;
294 	else
295 		cmd->flags &= ~CCP_CMD_MAY_BACKLOG;
296 
297 	return ccp_crypto_enqueue_cmd(crypto_cmd);
298 }
299 
300 struct scatterlist *ccp_crypto_sg_table_add(struct sg_table *table,
301 					    struct scatterlist *sg_add)
302 {
303 	struct scatterlist *sg, *sg_last = NULL;
304 
305 	for (sg = table->sgl; sg; sg = sg_next(sg))
306 		if (!sg_page(sg))
307 			break;
308 	BUG_ON(!sg);
309 
310 	for (; sg && sg_add; sg = sg_next(sg), sg_add = sg_next(sg_add)) {
311 		sg_set_page(sg, sg_page(sg_add), sg_add->length,
312 			    sg_add->offset);
313 		sg_last = sg;
314 	}
315 	BUG_ON(sg_add);
316 
317 	return sg_last;
318 }
319 
320 static int ccp_register_algs(void)
321 {
322 	int ret;
323 
324 	if (!aes_disable) {
325 		ret = ccp_register_aes_algs(&cipher_algs);
326 		if (ret)
327 			return ret;
328 
329 		ret = ccp_register_aes_cmac_algs(&hash_algs);
330 		if (ret)
331 			return ret;
332 
333 		ret = ccp_register_aes_xts_algs(&cipher_algs);
334 		if (ret)
335 			return ret;
336 	}
337 
338 	if (!sha_disable) {
339 		ret = ccp_register_sha_algs(&hash_algs);
340 		if (ret)
341 			return ret;
342 	}
343 
344 	return 0;
345 }
346 
347 static void ccp_unregister_algs(void)
348 {
349 	struct ccp_crypto_ahash_alg *ahash_alg, *ahash_tmp;
350 	struct ccp_crypto_ablkcipher_alg *ablk_alg, *ablk_tmp;
351 
352 	list_for_each_entry_safe(ahash_alg, ahash_tmp, &hash_algs, entry) {
353 		crypto_unregister_ahash(&ahash_alg->alg);
354 		list_del(&ahash_alg->entry);
355 		kfree(ahash_alg);
356 	}
357 
358 	list_for_each_entry_safe(ablk_alg, ablk_tmp, &cipher_algs, entry) {
359 		crypto_unregister_alg(&ablk_alg->alg);
360 		list_del(&ablk_alg->entry);
361 		kfree(ablk_alg);
362 	}
363 }
364 
365 static int ccp_crypto_init(void)
366 {
367 	int ret;
368 
369 	ret = ccp_present();
370 	if (ret)
371 		return ret;
372 
373 	spin_lock_init(&req_queue_lock);
374 	INIT_LIST_HEAD(&req_queue.cmds);
375 	req_queue.backlog = &req_queue.cmds;
376 	req_queue.cmd_count = 0;
377 
378 	ret = ccp_register_algs();
379 	if (ret)
380 		ccp_unregister_algs();
381 
382 	return ret;
383 }
384 
385 static void ccp_crypto_exit(void)
386 {
387 	ccp_unregister_algs();
388 }
389 
390 module_init(ccp_crypto_init);
391 module_exit(ccp_crypto_exit);
392