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