crypto: arm64/sm4 - add ARMv8 Crypto Extensions implementation
[linux-block.git] / crypto / crypto_engine.c
CommitLineData
2874c5fd 1// SPDX-License-Identifier: GPL-2.0-or-later
735d37b5
BW
2/*
3 * Handle async block request by crypto hardware engine.
4 *
5 * Copyright (C) 2016 Linaro, Inc.
6 *
7 * Author: Baolin Wang <baolin.wang@linaro.org>
735d37b5
BW
8 */
9
10#include <linux/err.h>
11#include <linux/delay.h>
0c3dc787 12#include <linux/device.h>
2589ad84 13#include <crypto/engine.h>
ae7e81c0 14#include <uapi/linux/sched/types.h>
735d37b5
BW
15#include "internal.h"
16
17#define CRYPTO_ENGINE_MAX_QLEN 10
18
218d1cc1
CL
19/**
20 * crypto_finalize_request - finalize one request if the request is done
21 * @engine: the hardware engine
22 * @req: the request need to be finalized
23 * @err: error number
24 */
25static void crypto_finalize_request(struct crypto_engine *engine,
6a89f492 26 struct crypto_async_request *req, int err)
218d1cc1
CL
27{
28 unsigned long flags;
6a89f492 29 bool finalize_req = false;
218d1cc1
CL
30 int ret;
31 struct crypto_engine_ctx *enginectx;
32
6a89f492
IP
33 /*
34 * If hardware cannot enqueue more requests
35 * and retry mechanism is not supported
36 * make sure we are completing the current request
37 */
38 if (!engine->retry_support) {
39 spin_lock_irqsave(&engine->queue_lock, flags);
40 if (engine->cur_req == req) {
41 finalize_req = true;
42 engine->cur_req = NULL;
43 }
44 spin_unlock_irqrestore(&engine->queue_lock, flags);
45 }
218d1cc1 46
6a89f492 47 if (finalize_req || engine->retry_support) {
218d1cc1 48 enginectx = crypto_tfm_ctx(req->tfm);
6a89f492 49 if (enginectx->op.prepare_request &&
218d1cc1
CL
50 enginectx->op.unprepare_request) {
51 ret = enginectx->op.unprepare_request(engine, req);
52 if (ret)
53 dev_err(engine->dev, "failed to unprepare request\n");
54 }
218d1cc1 55 }
4058cf08 56 lockdep_assert_in_softirq();
218d1cc1
CL
57 req->complete(req, err);
58
59 kthread_queue_work(engine->kworker, &engine->pump_requests);
60}
61
735d37b5
BW
62/**
63 * crypto_pump_requests - dequeue one request from engine queue to process
64 * @engine: the hardware engine
65 * @in_kthread: true if we are in the context of the request pump thread
66 *
67 * This function checks if there is any request in the engine queue that
68 * needs processing and if so call out to the driver to initialize hardware
69 * and handle each request.
70 */
71static void crypto_pump_requests(struct crypto_engine *engine,
72 bool in_kthread)
73{
74 struct crypto_async_request *async_req, *backlog;
735d37b5
BW
75 unsigned long flags;
76 bool was_busy = false;
218d1cc1
CL
77 int ret;
78 struct crypto_engine_ctx *enginectx;
735d37b5
BW
79
80 spin_lock_irqsave(&engine->queue_lock, flags);
81
82 /* Make sure we are not already running a request */
6a89f492 83 if (!engine->retry_support && engine->cur_req)
735d37b5
BW
84 goto out;
85
86 /* If another context is idling then defer */
87 if (engine->idling) {
c4ca2b0b 88 kthread_queue_work(engine->kworker, &engine->pump_requests);
735d37b5
BW
89 goto out;
90 }
91
92 /* Check if the engine queue is idle */
93 if (!crypto_queue_len(&engine->queue) || !engine->running) {
94 if (!engine->busy)
95 goto out;
96
97 /* Only do teardown in the thread */
98 if (!in_kthread) {
c4ca2b0b 99 kthread_queue_work(engine->kworker,
735d37b5
BW
100 &engine->pump_requests);
101 goto out;
102 }
103
104 engine->busy = false;
105 engine->idling = true;
106 spin_unlock_irqrestore(&engine->queue_lock, flags);
107
108 if (engine->unprepare_crypt_hardware &&
109 engine->unprepare_crypt_hardware(engine))
88d58ef8 110 dev_err(engine->dev, "failed to unprepare crypt hardware\n");
735d37b5
BW
111
112 spin_lock_irqsave(&engine->queue_lock, flags);
113 engine->idling = false;
114 goto out;
115 }
116
6a89f492 117start_request:
735d37b5
BW
118 /* Get the fist request from the engine queue to handle */
119 backlog = crypto_get_backlog(&engine->queue);
120 async_req = crypto_dequeue_request(&engine->queue);
121 if (!async_req)
122 goto out;
123
6a89f492
IP
124 /*
125 * If hardware doesn't support the retry mechanism,
126 * keep track of the request we are processing now.
127 * We'll need it on completion (crypto_finalize_request).
128 */
129 if (!engine->retry_support)
130 engine->cur_req = async_req;
131
735d37b5
BW
132 if (backlog)
133 backlog->complete(backlog, -EINPROGRESS);
134
135 if (engine->busy)
136 was_busy = true;
137 else
138 engine->busy = true;
139
140 spin_unlock_irqrestore(&engine->queue_lock, flags);
141
142 /* Until here we get the request need to be encrypted successfully */
143 if (!was_busy && engine->prepare_crypt_hardware) {
144 ret = engine->prepare_crypt_hardware(engine);
145 if (ret) {
88d58ef8 146 dev_err(engine->dev, "failed to prepare crypt hardware\n");
6a89f492 147 goto req_err_2;
735d37b5
BW
148 }
149 }
150
218d1cc1
CL
151 enginectx = crypto_tfm_ctx(async_req->tfm);
152
153 if (enginectx->op.prepare_request) {
154 ret = enginectx->op.prepare_request(engine, async_req);
4cba7cf0 155 if (ret) {
218d1cc1
CL
156 dev_err(engine->dev, "failed to prepare request: %d\n",
157 ret);
6a89f492 158 goto req_err_2;
4cba7cf0 159 }
218d1cc1
CL
160 }
161 if (!enginectx->op.do_one_request) {
162 dev_err(engine->dev, "failed to do request\n");
163 ret = -EINVAL;
6a89f492 164 goto req_err_1;
735d37b5 165 }
6a89f492 166
218d1cc1 167 ret = enginectx->op.do_one_request(engine, async_req);
6a89f492
IP
168
169 /* Request unsuccessfully executed by hardware */
170 if (ret < 0) {
171 /*
172 * If hardware queue is full (-ENOSPC), requeue request
173 * regardless of backlog flag.
6a89f492
IP
174 * Otherwise, unprepare and complete the request.
175 */
176 if (!engine->retry_support ||
d1c72f6e 177 (ret != -ENOSPC)) {
6a89f492
IP
178 dev_err(engine->dev,
179 "Failed to do one request from queue: %d\n",
180 ret);
181 goto req_err_1;
182 }
183 /*
184 * If retry mechanism is supported,
185 * unprepare current request and
186 * enqueue it back into crypto-engine queue.
187 */
188 if (enginectx->op.unprepare_request) {
189 ret = enginectx->op.unprepare_request(engine,
190 async_req);
191 if (ret)
192 dev_err(engine->dev,
193 "failed to unprepare request\n");
194 }
195 spin_lock_irqsave(&engine->queue_lock, flags);
196 /*
197 * If hardware was unable to execute request, enqueue it
198 * back in front of crypto-engine queue, to keep the order
199 * of requests.
200 */
201 crypto_enqueue_request_head(&engine->queue, async_req);
202
203 kthread_queue_work(engine->kworker, &engine->pump_requests);
204 goto out;
218d1cc1 205 }
735d37b5 206
6a89f492
IP
207 goto retry;
208
209req_err_1:
210 if (enginectx->op.unprepare_request) {
211 ret = enginectx->op.unprepare_request(engine, async_req);
212 if (ret)
213 dev_err(engine->dev, "failed to unprepare request\n");
214 }
215
216req_err_2:
217 async_req->complete(async_req, ret);
218
219retry:
220 /* If retry mechanism is supported, send new requests to engine */
221 if (engine->retry_support) {
222 spin_lock_irqsave(&engine->queue_lock, flags);
223 goto start_request;
224 }
735d37b5
BW
225 return;
226
227out:
228 spin_unlock_irqrestore(&engine->queue_lock, flags);
8d908226
IP
229
230 /*
231 * Batch requests is possible only if
232 * hardware can enqueue multiple requests
233 */
234 if (engine->do_batch_requests) {
235 ret = engine->do_batch_requests(engine);
236 if (ret)
237 dev_err(engine->dev, "failed to do batch requests: %d\n",
238 ret);
239 }
240
6a89f492 241 return;
735d37b5
BW
242}
243
244static void crypto_pump_work(struct kthread_work *work)
245{
246 struct crypto_engine *engine =
247 container_of(work, struct crypto_engine, pump_requests);
248
249 crypto_pump_requests(engine, true);
250}
251
252/**
218d1cc1 253 * crypto_transfer_request - transfer the new request into the engine queue
735d37b5
BW
254 * @engine: the hardware engine
255 * @req: the request need to be listed into the engine queue
256 */
218d1cc1
CL
257static int crypto_transfer_request(struct crypto_engine *engine,
258 struct crypto_async_request *req,
4cba7cf0 259 bool need_pump)
735d37b5
BW
260{
261 unsigned long flags;
262 int ret;
263
264 spin_lock_irqsave(&engine->queue_lock, flags);
265
266 if (!engine->running) {
267 spin_unlock_irqrestore(&engine->queue_lock, flags);
268 return -ESHUTDOWN;
269 }
270
218d1cc1 271 ret = crypto_enqueue_request(&engine->queue, req);
735d37b5
BW
272
273 if (!engine->busy && need_pump)
c4ca2b0b 274 kthread_queue_work(engine->kworker, &engine->pump_requests);
735d37b5
BW
275
276 spin_unlock_irqrestore(&engine->queue_lock, flags);
277 return ret;
278}
4cba7cf0
CL
279
280/**
218d1cc1 281 * crypto_transfer_request_to_engine - transfer one request to list
4cba7cf0
CL
282 * into the engine queue
283 * @engine: the hardware engine
284 * @req: the request need to be listed into the engine queue
285 */
218d1cc1
CL
286static int crypto_transfer_request_to_engine(struct crypto_engine *engine,
287 struct crypto_async_request *req)
4cba7cf0 288{
218d1cc1 289 return crypto_transfer_request(engine, req, true);
4cba7cf0 290}
4cba7cf0 291
218d1cc1
CL
292/**
293 * crypto_transfer_aead_request_to_engine - transfer one aead_request
294 * to list into the engine queue
295 * @engine: the hardware engine
296 * @req: the request need to be listed into the engine queue
297 */
298int crypto_transfer_aead_request_to_engine(struct crypto_engine *engine,
299 struct aead_request *req)
300{
301 return crypto_transfer_request_to_engine(engine, &req->base);
302}
303EXPORT_SYMBOL_GPL(crypto_transfer_aead_request_to_engine);
4cba7cf0 304
218d1cc1
CL
305/**
306 * crypto_transfer_akcipher_request_to_engine - transfer one akcipher_request
307 * to list into the engine queue
308 * @engine: the hardware engine
309 * @req: the request need to be listed into the engine queue
310 */
311int crypto_transfer_akcipher_request_to_engine(struct crypto_engine *engine,
312 struct akcipher_request *req)
313{
314 return crypto_transfer_request_to_engine(engine, &req->base);
4cba7cf0 315}
218d1cc1 316EXPORT_SYMBOL_GPL(crypto_transfer_akcipher_request_to_engine);
735d37b5
BW
317
318/**
218d1cc1
CL
319 * crypto_transfer_hash_request_to_engine - transfer one ahash_request
320 * to list into the engine queue
735d37b5
BW
321 * @engine: the hardware engine
322 * @req: the request need to be listed into the engine queue
323 */
4cba7cf0
CL
324int crypto_transfer_hash_request_to_engine(struct crypto_engine *engine,
325 struct ahash_request *req)
735d37b5 326{
218d1cc1 327 return crypto_transfer_request_to_engine(engine, &req->base);
735d37b5 328}
4cba7cf0 329EXPORT_SYMBOL_GPL(crypto_transfer_hash_request_to_engine);
735d37b5 330
1730c5aa
PK
331/**
332 * crypto_transfer_kpp_request_to_engine - transfer one kpp_request to list
333 * into the engine queue
334 * @engine: the hardware engine
335 * @req: the request need to be listed into the engine queue
336 */
337int crypto_transfer_kpp_request_to_engine(struct crypto_engine *engine,
338 struct kpp_request *req)
339{
340 return crypto_transfer_request_to_engine(engine, &req->base);
341}
342EXPORT_SYMBOL_GPL(crypto_transfer_kpp_request_to_engine);
343
735d37b5 344/**
218d1cc1
CL
345 * crypto_transfer_skcipher_request_to_engine - transfer one skcipher_request
346 * to list into the engine queue
347 * @engine: the hardware engine
348 * @req: the request need to be listed into the engine queue
349 */
350int crypto_transfer_skcipher_request_to_engine(struct crypto_engine *engine,
351 struct skcipher_request *req)
352{
353 return crypto_transfer_request_to_engine(engine, &req->base);
354}
355EXPORT_SYMBOL_GPL(crypto_transfer_skcipher_request_to_engine);
356
218d1cc1
CL
357/**
358 * crypto_finalize_aead_request - finalize one aead_request if
359 * the request is done
360 * @engine: the hardware engine
361 * @req: the request need to be finalized
362 * @err: error number
363 */
364void crypto_finalize_aead_request(struct crypto_engine *engine,
365 struct aead_request *req, int err)
366{
367 return crypto_finalize_request(engine, &req->base, err);
368}
369EXPORT_SYMBOL_GPL(crypto_finalize_aead_request);
735d37b5 370
218d1cc1
CL
371/**
372 * crypto_finalize_akcipher_request - finalize one akcipher_request if
373 * the request is done
374 * @engine: the hardware engine
375 * @req: the request need to be finalized
376 * @err: error number
377 */
378void crypto_finalize_akcipher_request(struct crypto_engine *engine,
379 struct akcipher_request *req, int err)
380{
381 return crypto_finalize_request(engine, &req->base, err);
4cba7cf0 382}
218d1cc1 383EXPORT_SYMBOL_GPL(crypto_finalize_akcipher_request);
4cba7cf0
CL
384
385/**
218d1cc1
CL
386 * crypto_finalize_hash_request - finalize one ahash_request if
387 * the request is done
4cba7cf0
CL
388 * @engine: the hardware engine
389 * @req: the request need to be finalized
390 * @err: error number
391 */
392void crypto_finalize_hash_request(struct crypto_engine *engine,
393 struct ahash_request *req, int err)
394{
218d1cc1 395 return crypto_finalize_request(engine, &req->base, err);
735d37b5 396}
4cba7cf0 397EXPORT_SYMBOL_GPL(crypto_finalize_hash_request);
735d37b5 398
1730c5aa
PK
399/**
400 * crypto_finalize_kpp_request - finalize one kpp_request if the request is done
401 * @engine: the hardware engine
402 * @req: the request need to be finalized
403 * @err: error number
404 */
405void crypto_finalize_kpp_request(struct crypto_engine *engine,
406 struct kpp_request *req, int err)
407{
408 return crypto_finalize_request(engine, &req->base, err);
409}
410EXPORT_SYMBOL_GPL(crypto_finalize_kpp_request);
411
218d1cc1
CL
412/**
413 * crypto_finalize_skcipher_request - finalize one skcipher_request if
414 * the request is done
415 * @engine: the hardware engine
416 * @req: the request need to be finalized
417 * @err: error number
418 */
419void crypto_finalize_skcipher_request(struct crypto_engine *engine,
420 struct skcipher_request *req, int err)
421{
422 return crypto_finalize_request(engine, &req->base, err);
423}
424EXPORT_SYMBOL_GPL(crypto_finalize_skcipher_request);
425
735d37b5
BW
426/**
427 * crypto_engine_start - start the hardware engine
428 * @engine: the hardware engine need to be started
429 *
430 * Return 0 on success, else on fail.
431 */
432int crypto_engine_start(struct crypto_engine *engine)
433{
434 unsigned long flags;
435
436 spin_lock_irqsave(&engine->queue_lock, flags);
437
438 if (engine->running || engine->busy) {
439 spin_unlock_irqrestore(&engine->queue_lock, flags);
440 return -EBUSY;
441 }
442
443 engine->running = true;
444 spin_unlock_irqrestore(&engine->queue_lock, flags);
445
c4ca2b0b 446 kthread_queue_work(engine->kworker, &engine->pump_requests);
735d37b5
BW
447
448 return 0;
449}
450EXPORT_SYMBOL_GPL(crypto_engine_start);
451
452/**
453 * crypto_engine_stop - stop the hardware engine
454 * @engine: the hardware engine need to be stopped
455 *
456 * Return 0 on success, else on fail.
457 */
458int crypto_engine_stop(struct crypto_engine *engine)
459{
460 unsigned long flags;
4cba7cf0 461 unsigned int limit = 500;
735d37b5
BW
462 int ret = 0;
463
464 spin_lock_irqsave(&engine->queue_lock, flags);
465
466 /*
467 * If the engine queue is not empty or the engine is on busy state,
468 * we need to wait for a while to pump the requests of engine queue.
469 */
470 while ((crypto_queue_len(&engine->queue) || engine->busy) && limit--) {
471 spin_unlock_irqrestore(&engine->queue_lock, flags);
472 msleep(20);
473 spin_lock_irqsave(&engine->queue_lock, flags);
474 }
475
476 if (crypto_queue_len(&engine->queue) || engine->busy)
477 ret = -EBUSY;
478 else
479 engine->running = false;
480
481 spin_unlock_irqrestore(&engine->queue_lock, flags);
482
483 if (ret)
88d58ef8 484 dev_warn(engine->dev, "could not stop engine\n");
735d37b5
BW
485
486 return ret;
487}
488EXPORT_SYMBOL_GPL(crypto_engine_stop);
489
490/**
6a89f492
IP
491 * crypto_engine_alloc_init_and_set - allocate crypto hardware engine structure
492 * and initialize it by setting the maximum number of entries in the software
493 * crypto-engine queue.
735d37b5 494 * @dev: the device attached with one hardware engine
6a89f492 495 * @retry_support: whether hardware has support for retry mechanism
40a3af45 496 * @cbk_do_batch: pointer to a callback function to be invoked when executing
8d908226
IP
497 * a batch of requests.
498 * This has the form:
499 * callback(struct crypto_engine *engine)
500 * where:
501 * @engine: the crypto engine structure.
735d37b5 502 * @rt: whether this queue is set to run as a realtime task
6a89f492 503 * @qlen: maximum size of the crypto-engine queue
735d37b5
BW
504 *
505 * This must be called from context that can sleep.
506 * Return: the crypto engine structure on success, else NULL.
507 */
6a89f492
IP
508struct crypto_engine *crypto_engine_alloc_init_and_set(struct device *dev,
509 bool retry_support,
8d908226 510 int (*cbk_do_batch)(struct crypto_engine *engine),
6a89f492 511 bool rt, int qlen)
735d37b5 512{
735d37b5
BW
513 struct crypto_engine *engine;
514
515 if (!dev)
516 return NULL;
517
518 engine = devm_kzalloc(dev, sizeof(*engine), GFP_KERNEL);
519 if (!engine)
520 return NULL;
521
88d58ef8 522 engine->dev = dev;
735d37b5
BW
523 engine->rt = rt;
524 engine->running = false;
525 engine->busy = false;
526 engine->idling = false;
6a89f492 527 engine->retry_support = retry_support;
735d37b5 528 engine->priv_data = dev;
8d908226
IP
529 /*
530 * Batch requests is possible only if
531 * hardware has support for retry mechanism.
532 */
533 engine->do_batch_requests = retry_support ? cbk_do_batch : NULL;
534
735d37b5
BW
535 snprintf(engine->name, sizeof(engine->name),
536 "%s-engine", dev_name(dev));
537
6a89f492 538 crypto_init_queue(&engine->queue, qlen);
735d37b5
BW
539 spin_lock_init(&engine->queue_lock);
540
c4ca2b0b
PM
541 engine->kworker = kthread_create_worker(0, "%s", engine->name);
542 if (IS_ERR(engine->kworker)) {
735d37b5
BW
543 dev_err(dev, "failed to create crypto request pump task\n");
544 return NULL;
545 }
3989144f 546 kthread_init_work(&engine->pump_requests, crypto_pump_work);
735d37b5
BW
547
548 if (engine->rt) {
549 dev_info(dev, "will run requests pump with realtime priority\n");
dbc6d0d5 550 sched_set_fifo(engine->kworker->task);
735d37b5
BW
551 }
552
553 return engine;
554}
6a89f492
IP
555EXPORT_SYMBOL_GPL(crypto_engine_alloc_init_and_set);
556
557/**
558 * crypto_engine_alloc_init - allocate crypto hardware engine structure and
559 * initialize it.
560 * @dev: the device attached with one hardware engine
561 * @rt: whether this queue is set to run as a realtime task
562 *
563 * This must be called from context that can sleep.
564 * Return: the crypto engine structure on success, else NULL.
565 */
566struct crypto_engine *crypto_engine_alloc_init(struct device *dev, bool rt)
567{
8d908226 568 return crypto_engine_alloc_init_and_set(dev, false, NULL, rt,
6a89f492
IP
569 CRYPTO_ENGINE_MAX_QLEN);
570}
735d37b5
BW
571EXPORT_SYMBOL_GPL(crypto_engine_alloc_init);
572
573/**
574 * crypto_engine_exit - free the resources of hardware engine when exit
575 * @engine: the hardware engine need to be freed
576 *
577 * Return 0 for success.
578 */
579int crypto_engine_exit(struct crypto_engine *engine)
580{
581 int ret;
582
583 ret = crypto_engine_stop(engine);
584 if (ret)
585 return ret;
586
c4ca2b0b 587 kthread_destroy_worker(engine->kworker);
735d37b5
BW
588
589 return 0;
590}
591EXPORT_SYMBOL_GPL(crypto_engine_exit);
592
593MODULE_LICENSE("GPL");
594MODULE_DESCRIPTION("Crypto hardware engine framework");