1 // SPDX-License-Identifier: GPL-2.0-or-later 1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* 2 /*
3 * Handle async block request by crypto hardwa 3 * Handle async block request by crypto hardware engine.
4 * 4 *
5 * Copyright (C) 2016 Linaro, Inc. 5 * Copyright (C) 2016 Linaro, Inc.
6 * 6 *
7 * Author: Baolin Wang <baolin.wang@linaro.org 7 * Author: Baolin Wang <baolin.wang@linaro.org>
8 */ 8 */
9 9
10 #include <crypto/internal/aead.h> 10 #include <crypto/internal/aead.h>
11 #include <crypto/internal/akcipher.h> 11 #include <crypto/internal/akcipher.h>
12 #include <crypto/internal/engine.h> 12 #include <crypto/internal/engine.h>
13 #include <crypto/internal/hash.h> 13 #include <crypto/internal/hash.h>
14 #include <crypto/internal/kpp.h> 14 #include <crypto/internal/kpp.h>
15 #include <crypto/internal/skcipher.h> 15 #include <crypto/internal/skcipher.h>
16 #include <linux/err.h> 16 #include <linux/err.h>
17 #include <linux/delay.h> 17 #include <linux/delay.h>
18 #include <linux/device.h> 18 #include <linux/device.h>
19 #include <linux/kernel.h> 19 #include <linux/kernel.h>
20 #include <linux/module.h> 20 #include <linux/module.h>
21 #include <uapi/linux/sched/types.h> 21 #include <uapi/linux/sched/types.h>
22 #include "internal.h" 22 #include "internal.h"
23 23
24 #define CRYPTO_ENGINE_MAX_QLEN 10 24 #define CRYPTO_ENGINE_MAX_QLEN 10
25 25
26 /* Temporary algorithm flag used to indicate a 26 /* Temporary algorithm flag used to indicate an updated driver. */
27 #define CRYPTO_ALG_ENGINE 0x200 27 #define CRYPTO_ALG_ENGINE 0x200
28 28
29 struct crypto_engine_alg { 29 struct crypto_engine_alg {
30 struct crypto_alg base; 30 struct crypto_alg base;
31 struct crypto_engine_op op; 31 struct crypto_engine_op op;
32 }; 32 };
33 33
34 /** 34 /**
35 * crypto_finalize_request - finalize one requ 35 * crypto_finalize_request - finalize one request if the request is done
36 * @engine: the hardware engine 36 * @engine: the hardware engine
37 * @req: the request need to be finalized 37 * @req: the request need to be finalized
38 * @err: error number 38 * @err: error number
39 */ 39 */
40 static void crypto_finalize_request(struct cry 40 static void crypto_finalize_request(struct crypto_engine *engine,
41 struct cry 41 struct crypto_async_request *req, int err)
42 { 42 {
43 unsigned long flags; 43 unsigned long flags;
44 44
45 /* 45 /*
46 * If hardware cannot enqueue more req 46 * If hardware cannot enqueue more requests
47 * and retry mechanism is not supporte 47 * and retry mechanism is not supported
48 * make sure we are completing the cur 48 * make sure we are completing the current request
49 */ 49 */
50 if (!engine->retry_support) { 50 if (!engine->retry_support) {
51 spin_lock_irqsave(&engine->que 51 spin_lock_irqsave(&engine->queue_lock, flags);
52 if (engine->cur_req == req) { 52 if (engine->cur_req == req) {
53 engine->cur_req = NULL 53 engine->cur_req = NULL;
54 } 54 }
55 spin_unlock_irqrestore(&engine 55 spin_unlock_irqrestore(&engine->queue_lock, flags);
56 } 56 }
57 57
58 lockdep_assert_in_softirq(); 58 lockdep_assert_in_softirq();
59 crypto_request_complete(req, err); 59 crypto_request_complete(req, err);
60 60
61 kthread_queue_work(engine->kworker, &e 61 kthread_queue_work(engine->kworker, &engine->pump_requests);
62 } 62 }
63 63
64 /** 64 /**
65 * crypto_pump_requests - dequeue one request 65 * crypto_pump_requests - dequeue one request from engine queue to process
66 * @engine: the hardware engine 66 * @engine: the hardware engine
67 * @in_kthread: true if we are in the context 67 * @in_kthread: true if we are in the context of the request pump thread
68 * 68 *
69 * This function checks if there is any reques 69 * This function checks if there is any request in the engine queue that
70 * needs processing and if so call out to the 70 * needs processing and if so call out to the driver to initialize hardware
71 * and handle each request. 71 * and handle each request.
72 */ 72 */
73 static void crypto_pump_requests(struct crypto 73 static void crypto_pump_requests(struct crypto_engine *engine,
74 bool in_kthre 74 bool in_kthread)
75 { 75 {
76 struct crypto_async_request *async_req 76 struct crypto_async_request *async_req, *backlog;
77 struct crypto_engine_alg *alg; 77 struct crypto_engine_alg *alg;
78 struct crypto_engine_op *op; 78 struct crypto_engine_op *op;
79 unsigned long flags; 79 unsigned long flags;
80 bool was_busy = false; 80 bool was_busy = false;
81 int ret; 81 int ret;
82 82
83 spin_lock_irqsave(&engine->queue_lock, 83 spin_lock_irqsave(&engine->queue_lock, flags);
84 84
85 /* Make sure we are not already runnin 85 /* Make sure we are not already running a request */
86 if (!engine->retry_support && engine-> 86 if (!engine->retry_support && engine->cur_req)
87 goto out; 87 goto out;
88 88
89 /* If another context is idling then d 89 /* If another context is idling then defer */
90 if (engine->idling) { 90 if (engine->idling) {
91 kthread_queue_work(engine->kwo 91 kthread_queue_work(engine->kworker, &engine->pump_requests);
92 goto out; 92 goto out;
93 } 93 }
94 94
95 /* Check if the engine queue is idle * 95 /* Check if the engine queue is idle */
96 if (!crypto_queue_len(&engine->queue) 96 if (!crypto_queue_len(&engine->queue) || !engine->running) {
97 if (!engine->busy) 97 if (!engine->busy)
98 goto out; 98 goto out;
99 99
100 /* Only do teardown in the thr 100 /* Only do teardown in the thread */
101 if (!in_kthread) { 101 if (!in_kthread) {
102 kthread_queue_work(eng 102 kthread_queue_work(engine->kworker,
103 &en 103 &engine->pump_requests);
104 goto out; 104 goto out;
105 } 105 }
106 106
107 engine->busy = false; 107 engine->busy = false;
108 engine->idling = true; 108 engine->idling = true;
109 spin_unlock_irqrestore(&engine 109 spin_unlock_irqrestore(&engine->queue_lock, flags);
110 110
111 if (engine->unprepare_crypt_ha 111 if (engine->unprepare_crypt_hardware &&
112 engine->unprepare_crypt_ha 112 engine->unprepare_crypt_hardware(engine))
113 dev_err(engine->dev, " 113 dev_err(engine->dev, "failed to unprepare crypt hardware\n");
114 114
115 spin_lock_irqsave(&engine->que 115 spin_lock_irqsave(&engine->queue_lock, flags);
116 engine->idling = false; 116 engine->idling = false;
117 goto out; 117 goto out;
118 } 118 }
119 119
120 start_request: 120 start_request:
121 /* Get the fist request from the engin 121 /* Get the fist request from the engine queue to handle */
122 backlog = crypto_get_backlog(&engine-> 122 backlog = crypto_get_backlog(&engine->queue);
123 async_req = crypto_dequeue_request(&en 123 async_req = crypto_dequeue_request(&engine->queue);
124 if (!async_req) 124 if (!async_req)
125 goto out; 125 goto out;
126 126
127 /* 127 /*
128 * If hardware doesn't support the ret 128 * If hardware doesn't support the retry mechanism,
129 * keep track of the request we are pr 129 * keep track of the request we are processing now.
130 * We'll need it on completion (crypto 130 * We'll need it on completion (crypto_finalize_request).
131 */ 131 */
132 if (!engine->retry_support) 132 if (!engine->retry_support)
133 engine->cur_req = async_req; 133 engine->cur_req = async_req;
134 134
135 if (engine->busy) 135 if (engine->busy)
136 was_busy = true; 136 was_busy = true;
137 else 137 else
138 engine->busy = true; 138 engine->busy = true;
139 139
140 spin_unlock_irqrestore(&engine->queue_ 140 spin_unlock_irqrestore(&engine->queue_lock, flags);
141 141
142 /* Until here we get the request need 142 /* Until here we get the request need to be encrypted successfully */
143 if (!was_busy && engine->prepare_crypt 143 if (!was_busy && engine->prepare_crypt_hardware) {
144 ret = engine->prepare_crypt_ha 144 ret = engine->prepare_crypt_hardware(engine);
145 if (ret) { 145 if (ret) {
146 dev_err(engine->dev, " 146 dev_err(engine->dev, "failed to prepare crypt hardware\n");
147 goto req_err_1; 147 goto req_err_1;
148 } 148 }
149 } 149 }
150 150
151 if (async_req->tfm->__crt_alg->cra_fla 151 if (async_req->tfm->__crt_alg->cra_flags & CRYPTO_ALG_ENGINE) {
152 alg = container_of(async_req-> 152 alg = container_of(async_req->tfm->__crt_alg,
153 struct cryp 153 struct crypto_engine_alg, base);
154 op = &alg->op; 154 op = &alg->op;
155 } else { 155 } else {
156 dev_err(engine->dev, "failed t 156 dev_err(engine->dev, "failed to do request\n");
157 ret = -EINVAL; 157 ret = -EINVAL;
158 goto req_err_1; 158 goto req_err_1;
159 } 159 }
160 160
161 ret = op->do_one_request(engine, async 161 ret = op->do_one_request(engine, async_req);
162 162
163 /* Request unsuccessfully executed by 163 /* Request unsuccessfully executed by hardware */
164 if (ret < 0) { 164 if (ret < 0) {
165 /* 165 /*
166 * If hardware queue is full ( 166 * If hardware queue is full (-ENOSPC), requeue request
167 * regardless of backlog flag. 167 * regardless of backlog flag.
168 * Otherwise, unprepare and co 168 * Otherwise, unprepare and complete the request.
169 */ 169 */
170 if (!engine->retry_support || 170 if (!engine->retry_support ||
171 (ret != -ENOSPC)) { 171 (ret != -ENOSPC)) {
172 dev_err(engine->dev, 172 dev_err(engine->dev,
173 "Failed to do 173 "Failed to do one request from queue: %d\n",
174 ret); 174 ret);
175 goto req_err_1; 175 goto req_err_1;
176 } 176 }
177 spin_lock_irqsave(&engine->que 177 spin_lock_irqsave(&engine->queue_lock, flags);
178 /* 178 /*
179 * If hardware was unable to e 179 * If hardware was unable to execute request, enqueue it
180 * back in front of crypto-eng 180 * back in front of crypto-engine queue, to keep the order
181 * of requests. 181 * of requests.
182 */ 182 */
183 crypto_enqueue_request_head(&e 183 crypto_enqueue_request_head(&engine->queue, async_req);
184 184
185 kthread_queue_work(engine->kwo 185 kthread_queue_work(engine->kworker, &engine->pump_requests);
186 goto out; 186 goto out;
187 } 187 }
188 188
189 goto retry; 189 goto retry;
190 190
191 req_err_1: 191 req_err_1:
192 crypto_request_complete(async_req, ret 192 crypto_request_complete(async_req, ret);
193 193
194 retry: 194 retry:
195 if (backlog) 195 if (backlog)
196 crypto_request_complete(backlo 196 crypto_request_complete(backlog, -EINPROGRESS);
197 197
198 /* If retry mechanism is supported, se 198 /* If retry mechanism is supported, send new requests to engine */
199 if (engine->retry_support) { 199 if (engine->retry_support) {
200 spin_lock_irqsave(&engine->que 200 spin_lock_irqsave(&engine->queue_lock, flags);
201 goto start_request; 201 goto start_request;
202 } 202 }
203 return; 203 return;
204 204
205 out: 205 out:
206 spin_unlock_irqrestore(&engine->queue_ 206 spin_unlock_irqrestore(&engine->queue_lock, flags);
207 207
208 /* 208 /*
209 * Batch requests is possible only if 209 * Batch requests is possible only if
210 * hardware can enqueue multiple reque 210 * hardware can enqueue multiple requests
211 */ 211 */
212 if (engine->do_batch_requests) { 212 if (engine->do_batch_requests) {
213 ret = engine->do_batch_request 213 ret = engine->do_batch_requests(engine);
214 if (ret) 214 if (ret)
215 dev_err(engine->dev, " 215 dev_err(engine->dev, "failed to do batch requests: %d\n",
216 ret); 216 ret);
217 } 217 }
218 218
219 return; 219 return;
220 } 220 }
221 221
222 static void crypto_pump_work(struct kthread_wo 222 static void crypto_pump_work(struct kthread_work *work)
223 { 223 {
224 struct crypto_engine *engine = 224 struct crypto_engine *engine =
225 container_of(work, struct cryp 225 container_of(work, struct crypto_engine, pump_requests);
226 226
227 crypto_pump_requests(engine, true); 227 crypto_pump_requests(engine, true);
228 } 228 }
229 229
230 /** 230 /**
231 * crypto_transfer_request - transfer the new 231 * crypto_transfer_request - transfer the new request into the engine queue
232 * @engine: the hardware engine 232 * @engine: the hardware engine
233 * @req: the request need to be listed into th 233 * @req: the request need to be listed into the engine queue
234 * @need_pump: indicates whether queue the pum 234 * @need_pump: indicates whether queue the pump of request to kthread_work
235 */ 235 */
236 static int crypto_transfer_request(struct cryp 236 static int crypto_transfer_request(struct crypto_engine *engine,
237 struct cryp 237 struct crypto_async_request *req,
238 bool need_p 238 bool need_pump)
239 { 239 {
240 unsigned long flags; 240 unsigned long flags;
241 int ret; 241 int ret;
242 242
243 spin_lock_irqsave(&engine->queue_lock, 243 spin_lock_irqsave(&engine->queue_lock, flags);
244 244
245 if (!engine->running) { 245 if (!engine->running) {
246 spin_unlock_irqrestore(&engine 246 spin_unlock_irqrestore(&engine->queue_lock, flags);
247 return -ESHUTDOWN; 247 return -ESHUTDOWN;
248 } 248 }
249 249
250 ret = crypto_enqueue_request(&engine-> 250 ret = crypto_enqueue_request(&engine->queue, req);
251 251
252 if (!engine->busy && need_pump) 252 if (!engine->busy && need_pump)
253 kthread_queue_work(engine->kwo 253 kthread_queue_work(engine->kworker, &engine->pump_requests);
254 254
255 spin_unlock_irqrestore(&engine->queue_ 255 spin_unlock_irqrestore(&engine->queue_lock, flags);
256 return ret; 256 return ret;
257 } 257 }
258 258
259 /** 259 /**
260 * crypto_transfer_request_to_engine - transfe 260 * crypto_transfer_request_to_engine - transfer one request to list
261 * into the engine queue 261 * into the engine queue
262 * @engine: the hardware engine 262 * @engine: the hardware engine
263 * @req: the request need to be listed into th 263 * @req: the request need to be listed into the engine queue
264 */ 264 */
265 static int crypto_transfer_request_to_engine(s 265 static int crypto_transfer_request_to_engine(struct crypto_engine *engine,
266 s 266 struct crypto_async_request *req)
267 { 267 {
268 return crypto_transfer_request(engine, 268 return crypto_transfer_request(engine, req, true);
269 } 269 }
270 270
271 /** 271 /**
272 * crypto_transfer_aead_request_to_engine - tr 272 * crypto_transfer_aead_request_to_engine - transfer one aead_request
273 * to list into the engine queue 273 * to list into the engine queue
274 * @engine: the hardware engine 274 * @engine: the hardware engine
275 * @req: the request need to be listed into th 275 * @req: the request need to be listed into the engine queue
276 */ 276 */
277 int crypto_transfer_aead_request_to_engine(str 277 int crypto_transfer_aead_request_to_engine(struct crypto_engine *engine,
278 str 278 struct aead_request *req)
279 { 279 {
280 return crypto_transfer_request_to_engi 280 return crypto_transfer_request_to_engine(engine, &req->base);
281 } 281 }
282 EXPORT_SYMBOL_GPL(crypto_transfer_aead_request 282 EXPORT_SYMBOL_GPL(crypto_transfer_aead_request_to_engine);
283 283
284 /** 284 /**
285 * crypto_transfer_akcipher_request_to_engine 285 * crypto_transfer_akcipher_request_to_engine - transfer one akcipher_request
286 * to list into the engine queue 286 * to list into the engine queue
287 * @engine: the hardware engine 287 * @engine: the hardware engine
288 * @req: the request need to be listed into th 288 * @req: the request need to be listed into the engine queue
289 */ 289 */
290 int crypto_transfer_akcipher_request_to_engine 290 int crypto_transfer_akcipher_request_to_engine(struct crypto_engine *engine,
291 291 struct akcipher_request *req)
292 { 292 {
293 return crypto_transfer_request_to_engi 293 return crypto_transfer_request_to_engine(engine, &req->base);
294 } 294 }
295 EXPORT_SYMBOL_GPL(crypto_transfer_akcipher_req 295 EXPORT_SYMBOL_GPL(crypto_transfer_akcipher_request_to_engine);
296 296
297 /** 297 /**
298 * crypto_transfer_hash_request_to_engine - tr 298 * crypto_transfer_hash_request_to_engine - transfer one ahash_request
299 * to list into the engine queue 299 * to list into the engine queue
300 * @engine: the hardware engine 300 * @engine: the hardware engine
301 * @req: the request need to be listed into th 301 * @req: the request need to be listed into the engine queue
302 */ 302 */
303 int crypto_transfer_hash_request_to_engine(str 303 int crypto_transfer_hash_request_to_engine(struct crypto_engine *engine,
304 str 304 struct ahash_request *req)
305 { 305 {
306 return crypto_transfer_request_to_engi 306 return crypto_transfer_request_to_engine(engine, &req->base);
307 } 307 }
308 EXPORT_SYMBOL_GPL(crypto_transfer_hash_request 308 EXPORT_SYMBOL_GPL(crypto_transfer_hash_request_to_engine);
309 309
310 /** 310 /**
311 * crypto_transfer_kpp_request_to_engine - tra 311 * crypto_transfer_kpp_request_to_engine - transfer one kpp_request to list
312 * into the engine queue 312 * into the engine queue
313 * @engine: the hardware engine 313 * @engine: the hardware engine
314 * @req: the request need to be listed into th 314 * @req: the request need to be listed into the engine queue
315 */ 315 */
316 int crypto_transfer_kpp_request_to_engine(stru 316 int crypto_transfer_kpp_request_to_engine(struct crypto_engine *engine,
317 stru 317 struct kpp_request *req)
318 { 318 {
319 return crypto_transfer_request_to_engi 319 return crypto_transfer_request_to_engine(engine, &req->base);
320 } 320 }
321 EXPORT_SYMBOL_GPL(crypto_transfer_kpp_request_ 321 EXPORT_SYMBOL_GPL(crypto_transfer_kpp_request_to_engine);
322 322
323 /** 323 /**
324 * crypto_transfer_skcipher_request_to_engine 324 * crypto_transfer_skcipher_request_to_engine - transfer one skcipher_request
325 * to list into the engine queue 325 * to list into the engine queue
326 * @engine: the hardware engine 326 * @engine: the hardware engine
327 * @req: the request need to be listed into th 327 * @req: the request need to be listed into the engine queue
328 */ 328 */
329 int crypto_transfer_skcipher_request_to_engine 329 int crypto_transfer_skcipher_request_to_engine(struct crypto_engine *engine,
330 330 struct skcipher_request *req)
331 { 331 {
332 return crypto_transfer_request_to_engi 332 return crypto_transfer_request_to_engine(engine, &req->base);
333 } 333 }
334 EXPORT_SYMBOL_GPL(crypto_transfer_skcipher_req 334 EXPORT_SYMBOL_GPL(crypto_transfer_skcipher_request_to_engine);
335 335
336 /** 336 /**
337 * crypto_finalize_aead_request - finalize one 337 * crypto_finalize_aead_request - finalize one aead_request if
338 * the request is done 338 * the request is done
339 * @engine: the hardware engine 339 * @engine: the hardware engine
340 * @req: the request need to be finalized 340 * @req: the request need to be finalized
341 * @err: error number 341 * @err: error number
342 */ 342 */
343 void crypto_finalize_aead_request(struct crypt 343 void crypto_finalize_aead_request(struct crypto_engine *engine,
344 struct aead_ 344 struct aead_request *req, int err)
345 { 345 {
346 return crypto_finalize_request(engine, 346 return crypto_finalize_request(engine, &req->base, err);
347 } 347 }
348 EXPORT_SYMBOL_GPL(crypto_finalize_aead_request 348 EXPORT_SYMBOL_GPL(crypto_finalize_aead_request);
349 349
350 /** 350 /**
351 * crypto_finalize_akcipher_request - finalize 351 * crypto_finalize_akcipher_request - finalize one akcipher_request if
352 * the request is done 352 * the request is done
353 * @engine: the hardware engine 353 * @engine: the hardware engine
354 * @req: the request need to be finalized 354 * @req: the request need to be finalized
355 * @err: error number 355 * @err: error number
356 */ 356 */
357 void crypto_finalize_akcipher_request(struct c 357 void crypto_finalize_akcipher_request(struct crypto_engine *engine,
358 struct a 358 struct akcipher_request *req, int err)
359 { 359 {
360 return crypto_finalize_request(engine, 360 return crypto_finalize_request(engine, &req->base, err);
361 } 361 }
362 EXPORT_SYMBOL_GPL(crypto_finalize_akcipher_req 362 EXPORT_SYMBOL_GPL(crypto_finalize_akcipher_request);
363 363
364 /** 364 /**
365 * crypto_finalize_hash_request - finalize one 365 * crypto_finalize_hash_request - finalize one ahash_request if
366 * the request is done 366 * the request is done
367 * @engine: the hardware engine 367 * @engine: the hardware engine
368 * @req: the request need to be finalized 368 * @req: the request need to be finalized
369 * @err: error number 369 * @err: error number
370 */ 370 */
371 void crypto_finalize_hash_request(struct crypt 371 void crypto_finalize_hash_request(struct crypto_engine *engine,
372 struct ahash 372 struct ahash_request *req, int err)
373 { 373 {
374 return crypto_finalize_request(engine, 374 return crypto_finalize_request(engine, &req->base, err);
375 } 375 }
376 EXPORT_SYMBOL_GPL(crypto_finalize_hash_request 376 EXPORT_SYMBOL_GPL(crypto_finalize_hash_request);
377 377
378 /** 378 /**
379 * crypto_finalize_kpp_request - finalize one 379 * crypto_finalize_kpp_request - finalize one kpp_request if the request is done
380 * @engine: the hardware engine 380 * @engine: the hardware engine
381 * @req: the request need to be finalized 381 * @req: the request need to be finalized
382 * @err: error number 382 * @err: error number
383 */ 383 */
384 void crypto_finalize_kpp_request(struct crypto 384 void crypto_finalize_kpp_request(struct crypto_engine *engine,
385 struct kpp_re 385 struct kpp_request *req, int err)
386 { 386 {
387 return crypto_finalize_request(engine, 387 return crypto_finalize_request(engine, &req->base, err);
388 } 388 }
389 EXPORT_SYMBOL_GPL(crypto_finalize_kpp_request) 389 EXPORT_SYMBOL_GPL(crypto_finalize_kpp_request);
390 390
391 /** 391 /**
392 * crypto_finalize_skcipher_request - finalize 392 * crypto_finalize_skcipher_request - finalize one skcipher_request if
393 * the request is done 393 * the request is done
394 * @engine: the hardware engine 394 * @engine: the hardware engine
395 * @req: the request need to be finalized 395 * @req: the request need to be finalized
396 * @err: error number 396 * @err: error number
397 */ 397 */
398 void crypto_finalize_skcipher_request(struct c 398 void crypto_finalize_skcipher_request(struct crypto_engine *engine,
399 struct s 399 struct skcipher_request *req, int err)
400 { 400 {
401 return crypto_finalize_request(engine, 401 return crypto_finalize_request(engine, &req->base, err);
402 } 402 }
403 EXPORT_SYMBOL_GPL(crypto_finalize_skcipher_req 403 EXPORT_SYMBOL_GPL(crypto_finalize_skcipher_request);
404 404
405 /** 405 /**
406 * crypto_engine_start - start the hardware en 406 * crypto_engine_start - start the hardware engine
407 * @engine: the hardware engine need to be sta 407 * @engine: the hardware engine need to be started
408 * 408 *
409 * Return 0 on success, else on fail. 409 * Return 0 on success, else on fail.
410 */ 410 */
411 int crypto_engine_start(struct crypto_engine * 411 int crypto_engine_start(struct crypto_engine *engine)
412 { 412 {
413 unsigned long flags; 413 unsigned long flags;
414 414
415 spin_lock_irqsave(&engine->queue_lock, 415 spin_lock_irqsave(&engine->queue_lock, flags);
416 416
417 if (engine->running || engine->busy) { 417 if (engine->running || engine->busy) {
418 spin_unlock_irqrestore(&engine 418 spin_unlock_irqrestore(&engine->queue_lock, flags);
419 return -EBUSY; 419 return -EBUSY;
420 } 420 }
421 421
422 engine->running = true; 422 engine->running = true;
423 spin_unlock_irqrestore(&engine->queue_ 423 spin_unlock_irqrestore(&engine->queue_lock, flags);
424 424
425 kthread_queue_work(engine->kworker, &e 425 kthread_queue_work(engine->kworker, &engine->pump_requests);
426 426
427 return 0; 427 return 0;
428 } 428 }
429 EXPORT_SYMBOL_GPL(crypto_engine_start); 429 EXPORT_SYMBOL_GPL(crypto_engine_start);
430 430
431 /** 431 /**
432 * crypto_engine_stop - stop the hardware engi 432 * crypto_engine_stop - stop the hardware engine
433 * @engine: the hardware engine need to be sto 433 * @engine: the hardware engine need to be stopped
434 * 434 *
435 * Return 0 on success, else on fail. 435 * Return 0 on success, else on fail.
436 */ 436 */
437 int crypto_engine_stop(struct crypto_engine *e 437 int crypto_engine_stop(struct crypto_engine *engine)
438 { 438 {
439 unsigned long flags; 439 unsigned long flags;
440 unsigned int limit = 500; 440 unsigned int limit = 500;
441 int ret = 0; 441 int ret = 0;
442 442
443 spin_lock_irqsave(&engine->queue_lock, 443 spin_lock_irqsave(&engine->queue_lock, flags);
444 444
445 /* 445 /*
446 * If the engine queue is not empty or 446 * If the engine queue is not empty or the engine is on busy state,
447 * we need to wait for a while to pump 447 * we need to wait for a while to pump the requests of engine queue.
448 */ 448 */
449 while ((crypto_queue_len(&engine->queu 449 while ((crypto_queue_len(&engine->queue) || engine->busy) && limit--) {
450 spin_unlock_irqrestore(&engine 450 spin_unlock_irqrestore(&engine->queue_lock, flags);
451 msleep(20); 451 msleep(20);
452 spin_lock_irqsave(&engine->que 452 spin_lock_irqsave(&engine->queue_lock, flags);
453 } 453 }
454 454
455 if (crypto_queue_len(&engine->queue) | 455 if (crypto_queue_len(&engine->queue) || engine->busy)
456 ret = -EBUSY; 456 ret = -EBUSY;
457 else 457 else
458 engine->running = false; 458 engine->running = false;
459 459
460 spin_unlock_irqrestore(&engine->queue_ 460 spin_unlock_irqrestore(&engine->queue_lock, flags);
461 461
462 if (ret) 462 if (ret)
463 dev_warn(engine->dev, "could n 463 dev_warn(engine->dev, "could not stop engine\n");
464 464
465 return ret; 465 return ret;
466 } 466 }
467 EXPORT_SYMBOL_GPL(crypto_engine_stop); 467 EXPORT_SYMBOL_GPL(crypto_engine_stop);
468 468
469 /** 469 /**
470 * crypto_engine_alloc_init_and_set - allocate 470 * crypto_engine_alloc_init_and_set - allocate crypto hardware engine structure
471 * and initialize it by setting the maximum nu 471 * and initialize it by setting the maximum number of entries in the software
472 * crypto-engine queue. 472 * crypto-engine queue.
473 * @dev: the device attached with one hardware 473 * @dev: the device attached with one hardware engine
474 * @retry_support: whether hardware has suppor 474 * @retry_support: whether hardware has support for retry mechanism
475 * @cbk_do_batch: pointer to a callback functi 475 * @cbk_do_batch: pointer to a callback function to be invoked when executing
476 * a batch of requests. 476 * a batch of requests.
477 * This has the form: 477 * This has the form:
478 * callback(struct crypto_engin 478 * callback(struct crypto_engine *engine)
479 * where: 479 * where:
480 * engine: the crypto engine st 480 * engine: the crypto engine structure.
481 * @rt: whether this queue is set to run as a 481 * @rt: whether this queue is set to run as a realtime task
482 * @qlen: maximum size of the crypto-engine qu 482 * @qlen: maximum size of the crypto-engine queue
483 * 483 *
484 * This must be called from context that can s 484 * This must be called from context that can sleep.
485 * Return: the crypto engine structure on succ 485 * Return: the crypto engine structure on success, else NULL.
486 */ 486 */
487 struct crypto_engine *crypto_engine_alloc_init 487 struct crypto_engine *crypto_engine_alloc_init_and_set(struct device *dev,
488 488 bool retry_support,
489 489 int (*cbk_do_batch)(struct crypto_engine *engine),
490 490 bool rt, int qlen)
491 { 491 {
492 struct crypto_engine *engine; 492 struct crypto_engine *engine;
493 493
494 if (!dev) 494 if (!dev)
495 return NULL; 495 return NULL;
496 496
497 engine = devm_kzalloc(dev, sizeof(*eng 497 engine = devm_kzalloc(dev, sizeof(*engine), GFP_KERNEL);
498 if (!engine) 498 if (!engine)
499 return NULL; 499 return NULL;
500 500
501 engine->dev = dev; 501 engine->dev = dev;
502 engine->rt = rt; 502 engine->rt = rt;
503 engine->running = false; 503 engine->running = false;
504 engine->busy = false; 504 engine->busy = false;
505 engine->idling = false; 505 engine->idling = false;
506 engine->retry_support = retry_support; 506 engine->retry_support = retry_support;
507 engine->priv_data = dev; 507 engine->priv_data = dev;
508 /* 508 /*
509 * Batch requests is possible only if 509 * Batch requests is possible only if
510 * hardware has support for retry mech 510 * hardware has support for retry mechanism.
511 */ 511 */
512 engine->do_batch_requests = retry_supp 512 engine->do_batch_requests = retry_support ? cbk_do_batch : NULL;
513 513
514 snprintf(engine->name, sizeof(engine-> 514 snprintf(engine->name, sizeof(engine->name),
515 "%s-engine", dev_name(dev)); 515 "%s-engine", dev_name(dev));
516 516
517 crypto_init_queue(&engine->queue, qlen 517 crypto_init_queue(&engine->queue, qlen);
518 spin_lock_init(&engine->queue_lock); 518 spin_lock_init(&engine->queue_lock);
519 519
520 engine->kworker = kthread_create_worke 520 engine->kworker = kthread_create_worker(0, "%s", engine->name);
521 if (IS_ERR(engine->kworker)) { 521 if (IS_ERR(engine->kworker)) {
522 dev_err(dev, "failed to create 522 dev_err(dev, "failed to create crypto request pump task\n");
523 return NULL; 523 return NULL;
524 } 524 }
525 kthread_init_work(&engine->pump_reques 525 kthread_init_work(&engine->pump_requests, crypto_pump_work);
526 526
527 if (engine->rt) { 527 if (engine->rt) {
528 dev_info(dev, "will run reques 528 dev_info(dev, "will run requests pump with realtime priority\n");
529 sched_set_fifo(engine->kworker 529 sched_set_fifo(engine->kworker->task);
530 } 530 }
531 531
532 return engine; 532 return engine;
533 } 533 }
534 EXPORT_SYMBOL_GPL(crypto_engine_alloc_init_and 534 EXPORT_SYMBOL_GPL(crypto_engine_alloc_init_and_set);
535 535
536 /** 536 /**
537 * crypto_engine_alloc_init - allocate crypto 537 * crypto_engine_alloc_init - allocate crypto hardware engine structure and
538 * initialize it. 538 * initialize it.
539 * @dev: the device attached with one hardware 539 * @dev: the device attached with one hardware engine
540 * @rt: whether this queue is set to run as a 540 * @rt: whether this queue is set to run as a realtime task
541 * 541 *
542 * This must be called from context that can s 542 * This must be called from context that can sleep.
543 * Return: the crypto engine structure on succ 543 * Return: the crypto engine structure on success, else NULL.
544 */ 544 */
545 struct crypto_engine *crypto_engine_alloc_init 545 struct crypto_engine *crypto_engine_alloc_init(struct device *dev, bool rt)
546 { 546 {
547 return crypto_engine_alloc_init_and_se 547 return crypto_engine_alloc_init_and_set(dev, false, NULL, rt,
548 548 CRYPTO_ENGINE_MAX_QLEN);
549 } 549 }
550 EXPORT_SYMBOL_GPL(crypto_engine_alloc_init); 550 EXPORT_SYMBOL_GPL(crypto_engine_alloc_init);
551 551
552 /** 552 /**
553 * crypto_engine_exit - free the resources of 553 * crypto_engine_exit - free the resources of hardware engine when exit
554 * @engine: the hardware engine need to be fre 554 * @engine: the hardware engine need to be freed
555 */ 555 */
556 void crypto_engine_exit(struct crypto_engine * 556 void crypto_engine_exit(struct crypto_engine *engine)
557 { 557 {
558 int ret; 558 int ret;
559 559
560 ret = crypto_engine_stop(engine); 560 ret = crypto_engine_stop(engine);
561 if (ret) 561 if (ret)
562 return; 562 return;
563 563
564 kthread_destroy_worker(engine->kworker 564 kthread_destroy_worker(engine->kworker);
565 } 565 }
566 EXPORT_SYMBOL_GPL(crypto_engine_exit); 566 EXPORT_SYMBOL_GPL(crypto_engine_exit);
567 567
568 int crypto_engine_register_aead(struct aead_en 568 int crypto_engine_register_aead(struct aead_engine_alg *alg)
569 { 569 {
570 if (!alg->op.do_one_request) 570 if (!alg->op.do_one_request)
571 return -EINVAL; 571 return -EINVAL;
572 572
573 alg->base.base.cra_flags |= CRYPTO_ALG 573 alg->base.base.cra_flags |= CRYPTO_ALG_ENGINE;
574 574
575 return crypto_register_aead(&alg->base 575 return crypto_register_aead(&alg->base);
576 } 576 }
577 EXPORT_SYMBOL_GPL(crypto_engine_register_aead) 577 EXPORT_SYMBOL_GPL(crypto_engine_register_aead);
578 578
579 void crypto_engine_unregister_aead(struct aead 579 void crypto_engine_unregister_aead(struct aead_engine_alg *alg)
580 { 580 {
581 crypto_unregister_aead(&alg->base); 581 crypto_unregister_aead(&alg->base);
582 } 582 }
583 EXPORT_SYMBOL_GPL(crypto_engine_unregister_aea 583 EXPORT_SYMBOL_GPL(crypto_engine_unregister_aead);
584 584
585 int crypto_engine_register_aeads(struct aead_e 585 int crypto_engine_register_aeads(struct aead_engine_alg *algs, int count)
586 { 586 {
587 int i, ret; 587 int i, ret;
588 588
589 for (i = 0; i < count; i++) { 589 for (i = 0; i < count; i++) {
590 ret = crypto_engine_register_a 590 ret = crypto_engine_register_aead(&algs[i]);
591 if (ret) 591 if (ret)
592 goto err; 592 goto err;
593 } 593 }
594 594
595 return 0; 595 return 0;
596 596
597 err: 597 err:
598 crypto_engine_unregister_aeads(algs, i 598 crypto_engine_unregister_aeads(algs, i);
599 599
600 return ret; 600 return ret;
601 } 601 }
602 EXPORT_SYMBOL_GPL(crypto_engine_register_aeads 602 EXPORT_SYMBOL_GPL(crypto_engine_register_aeads);
603 603
604 void crypto_engine_unregister_aeads(struct aea 604 void crypto_engine_unregister_aeads(struct aead_engine_alg *algs, int count)
605 { 605 {
606 int i; 606 int i;
607 607
608 for (i = count - 1; i >= 0; --i) 608 for (i = count - 1; i >= 0; --i)
609 crypto_engine_unregister_aead( 609 crypto_engine_unregister_aead(&algs[i]);
610 } 610 }
611 EXPORT_SYMBOL_GPL(crypto_engine_unregister_aea 611 EXPORT_SYMBOL_GPL(crypto_engine_unregister_aeads);
612 612
613 int crypto_engine_register_ahash(struct ahash_ 613 int crypto_engine_register_ahash(struct ahash_engine_alg *alg)
614 { 614 {
615 if (!alg->op.do_one_request) 615 if (!alg->op.do_one_request)
616 return -EINVAL; 616 return -EINVAL;
617 617
618 alg->base.halg.base.cra_flags |= CRYPT 618 alg->base.halg.base.cra_flags |= CRYPTO_ALG_ENGINE;
619 619
620 return crypto_register_ahash(&alg->bas 620 return crypto_register_ahash(&alg->base);
621 } 621 }
622 EXPORT_SYMBOL_GPL(crypto_engine_register_ahash 622 EXPORT_SYMBOL_GPL(crypto_engine_register_ahash);
623 623
624 void crypto_engine_unregister_ahash(struct aha 624 void crypto_engine_unregister_ahash(struct ahash_engine_alg *alg)
625 { 625 {
626 crypto_unregister_ahash(&alg->base); 626 crypto_unregister_ahash(&alg->base);
627 } 627 }
628 EXPORT_SYMBOL_GPL(crypto_engine_unregister_aha 628 EXPORT_SYMBOL_GPL(crypto_engine_unregister_ahash);
629 629
630 int crypto_engine_register_ahashes(struct ahas 630 int crypto_engine_register_ahashes(struct ahash_engine_alg *algs, int count)
631 { 631 {
632 int i, ret; 632 int i, ret;
633 633
634 for (i = 0; i < count; i++) { 634 for (i = 0; i < count; i++) {
635 ret = crypto_engine_register_a 635 ret = crypto_engine_register_ahash(&algs[i]);
636 if (ret) 636 if (ret)
637 goto err; 637 goto err;
638 } 638 }
639 639
640 return 0; 640 return 0;
641 641
642 err: 642 err:
643 crypto_engine_unregister_ahashes(algs, 643 crypto_engine_unregister_ahashes(algs, i);
644 644
645 return ret; 645 return ret;
646 } 646 }
647 EXPORT_SYMBOL_GPL(crypto_engine_register_ahash 647 EXPORT_SYMBOL_GPL(crypto_engine_register_ahashes);
648 648
649 void crypto_engine_unregister_ahashes(struct a 649 void crypto_engine_unregister_ahashes(struct ahash_engine_alg *algs,
650 int coun 650 int count)
651 { 651 {
652 int i; 652 int i;
653 653
654 for (i = count - 1; i >= 0; --i) 654 for (i = count - 1; i >= 0; --i)
655 crypto_engine_unregister_ahash 655 crypto_engine_unregister_ahash(&algs[i]);
656 } 656 }
657 EXPORT_SYMBOL_GPL(crypto_engine_unregister_aha 657 EXPORT_SYMBOL_GPL(crypto_engine_unregister_ahashes);
658 658
659 int crypto_engine_register_akcipher(struct akc 659 int crypto_engine_register_akcipher(struct akcipher_engine_alg *alg)
660 { 660 {
661 if (!alg->op.do_one_request) 661 if (!alg->op.do_one_request)
662 return -EINVAL; 662 return -EINVAL;
663 663
664 alg->base.base.cra_flags |= CRYPTO_ALG 664 alg->base.base.cra_flags |= CRYPTO_ALG_ENGINE;
665 665
666 return crypto_register_akcipher(&alg-> 666 return crypto_register_akcipher(&alg->base);
667 } 667 }
668 EXPORT_SYMBOL_GPL(crypto_engine_register_akcip 668 EXPORT_SYMBOL_GPL(crypto_engine_register_akcipher);
669 669
670 void crypto_engine_unregister_akcipher(struct 670 void crypto_engine_unregister_akcipher(struct akcipher_engine_alg *alg)
671 { 671 {
672 crypto_unregister_akcipher(&alg->base) 672 crypto_unregister_akcipher(&alg->base);
673 } 673 }
674 EXPORT_SYMBOL_GPL(crypto_engine_unregister_akc 674 EXPORT_SYMBOL_GPL(crypto_engine_unregister_akcipher);
675 675
676 int crypto_engine_register_kpp(struct kpp_engi 676 int crypto_engine_register_kpp(struct kpp_engine_alg *alg)
677 { 677 {
678 if (!alg->op.do_one_request) 678 if (!alg->op.do_one_request)
679 return -EINVAL; 679 return -EINVAL;
680 680
681 alg->base.base.cra_flags |= CRYPTO_ALG 681 alg->base.base.cra_flags |= CRYPTO_ALG_ENGINE;
682 682
683 return crypto_register_kpp(&alg->base) 683 return crypto_register_kpp(&alg->base);
684 } 684 }
685 EXPORT_SYMBOL_GPL(crypto_engine_register_kpp); 685 EXPORT_SYMBOL_GPL(crypto_engine_register_kpp);
686 686
687 void crypto_engine_unregister_kpp(struct kpp_e 687 void crypto_engine_unregister_kpp(struct kpp_engine_alg *alg)
688 { 688 {
689 crypto_unregister_kpp(&alg->base); 689 crypto_unregister_kpp(&alg->base);
690 } 690 }
691 EXPORT_SYMBOL_GPL(crypto_engine_unregister_kpp 691 EXPORT_SYMBOL_GPL(crypto_engine_unregister_kpp);
692 692
693 int crypto_engine_register_skcipher(struct skc 693 int crypto_engine_register_skcipher(struct skcipher_engine_alg *alg)
694 { 694 {
695 if (!alg->op.do_one_request) 695 if (!alg->op.do_one_request)
696 return -EINVAL; 696 return -EINVAL;
697 697
698 alg->base.base.cra_flags |= CRYPTO_ALG 698 alg->base.base.cra_flags |= CRYPTO_ALG_ENGINE;
699 699
700 return crypto_register_skcipher(&alg-> 700 return crypto_register_skcipher(&alg->base);
701 } 701 }
702 EXPORT_SYMBOL_GPL(crypto_engine_register_skcip 702 EXPORT_SYMBOL_GPL(crypto_engine_register_skcipher);
703 703
704 void crypto_engine_unregister_skcipher(struct 704 void crypto_engine_unregister_skcipher(struct skcipher_engine_alg *alg)
705 { 705 {
706 return crypto_unregister_skcipher(&alg 706 return crypto_unregister_skcipher(&alg->base);
707 } 707 }
708 EXPORT_SYMBOL_GPL(crypto_engine_unregister_skc 708 EXPORT_SYMBOL_GPL(crypto_engine_unregister_skcipher);
709 709
710 int crypto_engine_register_skciphers(struct sk 710 int crypto_engine_register_skciphers(struct skcipher_engine_alg *algs,
711 int count 711 int count)
712 { 712 {
713 int i, ret; 713 int i, ret;
714 714
715 for (i = 0; i < count; i++) { 715 for (i = 0; i < count; i++) {
716 ret = crypto_engine_register_s 716 ret = crypto_engine_register_skcipher(&algs[i]);
717 if (ret) 717 if (ret)
718 goto err; 718 goto err;
719 } 719 }
720 720
721 return 0; 721 return 0;
722 722
723 err: 723 err:
724 crypto_engine_unregister_skciphers(alg 724 crypto_engine_unregister_skciphers(algs, i);
725 725
726 return ret; 726 return ret;
727 } 727 }
728 EXPORT_SYMBOL_GPL(crypto_engine_register_skcip 728 EXPORT_SYMBOL_GPL(crypto_engine_register_skciphers);
729 729
730 void crypto_engine_unregister_skciphers(struct 730 void crypto_engine_unregister_skciphers(struct skcipher_engine_alg *algs,
731 int co 731 int count)
732 { 732 {
733 int i; 733 int i;
734 734
735 for (i = count - 1; i >= 0; --i) 735 for (i = count - 1; i >= 0; --i)
736 crypto_engine_unregister_skcip 736 crypto_engine_unregister_skcipher(&algs[i]);
737 } 737 }
738 EXPORT_SYMBOL_GPL(crypto_engine_unregister_skc 738 EXPORT_SYMBOL_GPL(crypto_engine_unregister_skciphers);
739 739
740 MODULE_LICENSE("GPL"); 740 MODULE_LICENSE("GPL");
741 MODULE_DESCRIPTION("Crypto hardware engine fra 741 MODULE_DESCRIPTION("Crypto hardware engine framework");
742 742
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.