forked from ~ljy/RK356X_SDK_RELEASE

blame | history | patch | commit | commitdiff
hc
2023-12-11 d2ccde1c8e90d38cee87a1b0309ad2827f3fd30d 
 kernel/drivers/crypto/cavium/cpt/cptvf_algs.c
....@@ -1,18 +1,13 @@
1
+// SPDX-License-Identifier: GPL-2.0-only
12 
23 /*
34  * Copyright (C) 2016 Cavium, Inc.
4
- *
5
- * This program is free software; you can redistribute it and/or modify it
6
- * under the terms of version 2 of the GNU General Public License
7
- * as published by the Free Software Foundation.
85  */
96 
107 #include <crypto/aes.h>
118 #include <crypto/algapi.h>
129 #include <crypto/authenc.h>
13
-#include <crypto/cryptd.h>
14
-#include <crypto/crypto_wq.h>
15
-#include <crypto/des.h>
10
+#include <crypto/internal/des.h>
1611 #include <crypto/xts.h>
1712 #include <linux/crypto.h>
1813 #include <linux/err.h>
....@@ -97,17 +92,17 @@
9792 	}
9893 }
9994 
100
-static inline u32 create_ctx_hdr(struct ablkcipher_request *req, u32 enc,
95
+static inline u32 create_ctx_hdr(struct skcipher_request *req, u32 enc,
10196 				 u32 *argcnt)
10297 {
103
-	struct crypto_ablkcipher *tfm = crypto_ablkcipher_reqtfm(req);
104
-	struct cvm_enc_ctx *ctx = crypto_ablkcipher_ctx(tfm);
105
-	struct cvm_req_ctx *rctx = ablkcipher_request_ctx(req);
98
+	struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
99
+	struct cvm_enc_ctx *ctx = crypto_skcipher_ctx(tfm);
100
+	struct cvm_req_ctx *rctx = skcipher_request_ctx(req);
106101 	struct fc_context *fctx = &rctx->fctx;
107
-	u64 *offset_control = &rctx->control_word;
108
-	u32 enc_iv_len = crypto_ablkcipher_ivsize(tfm);
102
+	u32 enc_iv_len = crypto_skcipher_ivsize(tfm);
109103 	struct cpt_request_info *req_info = &rctx->cpt_req;
110
-	u64 *ctrl_flags = NULL;
104
+	__be64 *ctrl_flags = NULL;
105
+	__be64 *offset_control;
111106 
112107 	req_info->ctrl.s.grp = 0;
113108 	req_info->ctrl.s.dma_mode = DMA_GATHER_SCATTER;
....@@ -120,7 +115,7 @@
120115 	else
121116 		req_info->req.opcode.s.minor = 3;
122117 
123
-	req_info->req.param1 = req->nbytes; /* Encryption Data length */
118
+	req_info->req.param1 = req->cryptlen; /* Encryption Data length */
124119 	req_info->req.param2 = 0; /*Auth data length */
125120 
126121 	fctx->enc.enc_ctrl.e.enc_cipher = ctx->cipher_type;
....@@ -131,9 +126,10 @@
131126 		memcpy(fctx->enc.encr_key, ctx->enc_key, ctx->key_len * 2);
132127 	else
133128 		memcpy(fctx->enc.encr_key, ctx->enc_key, ctx->key_len);
134
-	ctrl_flags = (u64 *)&fctx->enc.enc_ctrl.flags;
135
-	*ctrl_flags = cpu_to_be64(*ctrl_flags);
129
+	ctrl_flags = (__be64 *)&fctx->enc.enc_ctrl.flags;
130
+	*ctrl_flags = cpu_to_be64(fctx->enc.enc_ctrl.flags);
136131 
132
+	offset_control = (__be64 *)&rctx->control_word;
137133 	*offset_control = cpu_to_be64(((u64)(enc_iv_len) << 16));
138134 	/* Storing  Packet Data Information in offset
139135 	 * Control Word First 8 bytes
....@@ -152,32 +148,32 @@
152148 	return 0;
153149 }
154150 
155
-static inline u32 create_input_list(struct ablkcipher_request  *req, u32 enc,
151
+static inline u32 create_input_list(struct skcipher_request  *req, u32 enc,
156152 				    u32 enc_iv_len)
157153 {
158
-	struct cvm_req_ctx *rctx = ablkcipher_request_ctx(req);
154
+	struct cvm_req_ctx *rctx = skcipher_request_ctx(req);
159155 	struct cpt_request_info *req_info = &rctx->cpt_req;
160156 	u32 argcnt =  0;
161157 
162158 	create_ctx_hdr(req, enc, &argcnt);
163
-	update_input_iv(req_info, req->info, enc_iv_len, &argcnt);
164
-	update_input_data(req_info, req->src, req->nbytes, &argcnt);
159
+	update_input_iv(req_info, req->iv, enc_iv_len, &argcnt);
160
+	update_input_data(req_info, req->src, req->cryptlen, &argcnt);
165161 	req_info->incnt = argcnt;
166162 
167163 	return 0;
168164 }
169165 
170
-static inline void store_cb_info(struct ablkcipher_request *req,
166
+static inline void store_cb_info(struct skcipher_request *req,
171167 				 struct cpt_request_info *req_info)
172168 {
173169 	req_info->callback = (void *)cvm_callback;
174170 	req_info->callback_arg = (void *)&req->base;
175171 }
176172 
177
-static inline void create_output_list(struct ablkcipher_request *req,
173
+static inline void create_output_list(struct skcipher_request *req,
178174 				      u32 enc_iv_len)
179175 {
180
-	struct cvm_req_ctx *rctx = ablkcipher_request_ctx(req);
176
+	struct cvm_req_ctx *rctx = skcipher_request_ctx(req);
181177 	struct cpt_request_info *req_info = &rctx->cpt_req;
182178 	u32 argcnt = 0;
183179 
....@@ -189,16 +185,16 @@
189185 	 * [ 16 Bytes/     [   Request Enc/Dec/ DATA Len AES CBC ]
190186 	 */
191187 	/* Reading IV information */
192
-	update_output_iv(req_info, req->info, enc_iv_len, &argcnt);
193
-	update_output_data(req_info, req->dst, req->nbytes, &argcnt);
188
+	update_output_iv(req_info, req->iv, enc_iv_len, &argcnt);
189
+	update_output_data(req_info, req->dst, req->cryptlen, &argcnt);
194190 	req_info->outcnt = argcnt;
195191 }
196192 
197
-static inline int cvm_enc_dec(struct ablkcipher_request *req, u32 enc)
193
+static inline int cvm_enc_dec(struct skcipher_request *req, u32 enc)
198194 {
199
-	struct crypto_ablkcipher *tfm = crypto_ablkcipher_reqtfm(req);
200
-	struct cvm_req_ctx *rctx = ablkcipher_request_ctx(req);
201
-	u32 enc_iv_len = crypto_ablkcipher_ivsize(tfm);
195
+	struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
196
+	struct cvm_req_ctx *rctx = skcipher_request_ctx(req);
197
+	u32 enc_iv_len = crypto_skcipher_ivsize(tfm);
202198 	struct fc_context *fctx = &rctx->fctx;
203199 	struct cpt_request_info *req_info = &rctx->cpt_req;
204200 	void *cdev = NULL;
....@@ -223,20 +219,20 @@
223219 		return -EINPROGRESS;
224220 }
225221 
226
-static int cvm_encrypt(struct ablkcipher_request *req)
222
+static int cvm_encrypt(struct skcipher_request *req)
227223 {
228224 	return cvm_enc_dec(req, true);
229225 }
230226 
231
-static int cvm_decrypt(struct ablkcipher_request *req)
227
+static int cvm_decrypt(struct skcipher_request *req)
232228 {
233229 	return cvm_enc_dec(req, false);
234230 }
235231 
236
-static int cvm_xts_setkey(struct crypto_ablkcipher *cipher, const u8 *key,
232
+static int cvm_xts_setkey(struct crypto_skcipher *cipher, const u8 *key,
237233 		   u32 keylen)
238234 {
239
-	struct crypto_tfm *tfm = crypto_ablkcipher_tfm(cipher);
235
+	struct crypto_tfm *tfm = crypto_skcipher_tfm(cipher);
240236 	struct cvm_enc_ctx *ctx = crypto_tfm_ctx(tfm);
241237 	int err;
242238 	const u8 *key1 = key;
....@@ -290,10 +286,10 @@
290286 	return -EINVAL;
291287 }
292288 
293
-static int cvm_setkey(struct crypto_ablkcipher *cipher, const u8 *key,
289
+static int cvm_setkey(struct crypto_skcipher *cipher, const u8 *key,
294290 		      u32 keylen, u8 cipher_type)
295291 {
296
-	struct crypto_tfm *tfm = crypto_ablkcipher_tfm(cipher);
292
+	struct crypto_tfm *tfm = crypto_skcipher_tfm(cipher);
297293 	struct cvm_enc_ctx *ctx = crypto_tfm_ctx(tfm);
298294 
299295 	ctx->cipher_type = cipher_type;
....@@ -301,199 +297,166 @@
301297 		memcpy(ctx->enc_key, key, keylen);
302298 		return 0;
303299 	} else {
304
-		crypto_ablkcipher_set_flags(cipher,
305
-					    CRYPTO_TFM_RES_BAD_KEY_LEN);
306300 		return -EINVAL;
307301 	}
308302 }
309303 
310
-static int cvm_cbc_aes_setkey(struct crypto_ablkcipher *cipher, const u8 *key,
304
+static int cvm_cbc_aes_setkey(struct crypto_skcipher *cipher, const u8 *key,
311305 			      u32 keylen)
312306 {
313307 	return cvm_setkey(cipher, key, keylen, AES_CBC);
314308 }
315309 
316
-static int cvm_ecb_aes_setkey(struct crypto_ablkcipher *cipher, const u8 *key,
310
+static int cvm_ecb_aes_setkey(struct crypto_skcipher *cipher, const u8 *key,
317311 			      u32 keylen)
318312 {
319313 	return cvm_setkey(cipher, key, keylen, AES_ECB);
320314 }
321315 
322
-static int cvm_cfb_aes_setkey(struct crypto_ablkcipher *cipher, const u8 *key,
316
+static int cvm_cfb_aes_setkey(struct crypto_skcipher *cipher, const u8 *key,
323317 			      u32 keylen)
324318 {
325319 	return cvm_setkey(cipher, key, keylen, AES_CFB);
326320 }
327321 
328
-static int cvm_cbc_des3_setkey(struct crypto_ablkcipher *cipher, const u8 *key,
322
+static int cvm_cbc_des3_setkey(struct crypto_skcipher *cipher, const u8 *key,
329323 			       u32 keylen)
330324 {
331
-	return cvm_setkey(cipher, key, keylen, DES3_CBC);
325
+	return verify_skcipher_des3_key(cipher, key) ?:
326
+	       cvm_setkey(cipher, key, keylen, DES3_CBC);
332327 }
333328 
334
-static int cvm_ecb_des3_setkey(struct crypto_ablkcipher *cipher, const u8 *key,
329
+static int cvm_ecb_des3_setkey(struct crypto_skcipher *cipher, const u8 *key,
335330 			       u32 keylen)
336331 {
337
-	return cvm_setkey(cipher, key, keylen, DES3_ECB);
332
+	return verify_skcipher_des3_key(cipher, key) ?:
333
+	       cvm_setkey(cipher, key, keylen, DES3_ECB);
338334 }
339335 
340
-static int cvm_enc_dec_init(struct crypto_tfm *tfm)
336
+static int cvm_enc_dec_init(struct crypto_skcipher *tfm)
341337 {
342
-	struct cvm_enc_ctx *ctx = crypto_tfm_ctx(tfm);
343
-
344
-	memset(ctx, 0, sizeof(*ctx));
345
-	tfm->crt_ablkcipher.reqsize = sizeof(struct cvm_req_ctx) +
346
-					sizeof(struct ablkcipher_request);
347
-	/* Additional memory for ablkcipher_request is
348
-	 * allocated since the cryptd daemon uses
349
-	 * this memory for request_ctx information
350
-	 */
338
+	crypto_skcipher_set_reqsize(tfm, sizeof(struct cvm_req_ctx));
351339 
352340 	return 0;
353341 }
354342 
355
-static struct crypto_alg algs[] = { {
356
-	.cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
357
-	.cra_blocksize = AES_BLOCK_SIZE,
358
-	.cra_ctxsize = sizeof(struct cvm_enc_ctx),
359
-	.cra_alignmask = 7,
360
-	.cra_priority = 4001,
361
-	.cra_name = "xts(aes)",
362
-	.cra_driver_name = "cavium-xts-aes",
363
-	.cra_type = &crypto_ablkcipher_type,
364
-	.cra_u = {
365
-		.ablkcipher = {
366
-			.ivsize = AES_BLOCK_SIZE,
367
-			.min_keysize = 2 * AES_MIN_KEY_SIZE,
368
-			.max_keysize = 2 * AES_MAX_KEY_SIZE,
369
-			.setkey = cvm_xts_setkey,
370
-			.encrypt = cvm_encrypt,
371
-			.decrypt = cvm_decrypt,
372
-		},
373
-	},
374
-	.cra_init = cvm_enc_dec_init,
375
-	.cra_module = THIS_MODULE,
343
+static struct skcipher_alg algs[] = { {
344
+	.base.cra_flags		= CRYPTO_ALG_ASYNC |
345
+				  CRYPTO_ALG_ALLOCATES_MEMORY,
346
+	.base.cra_blocksize	= AES_BLOCK_SIZE,
347
+	.base.cra_ctxsize	= sizeof(struct cvm_enc_ctx),
348
+	.base.cra_alignmask	= 7,
349
+	.base.cra_priority	= 4001,
350
+	.base.cra_name		= "xts(aes)",
351
+	.base.cra_driver_name	= "cavium-xts-aes",
352
+	.base.cra_module	= THIS_MODULE,
353
+
354
+	.ivsize			= AES_BLOCK_SIZE,
355
+	.min_keysize		= 2 * AES_MIN_KEY_SIZE,
356
+	.max_keysize		= 2 * AES_MAX_KEY_SIZE,
357
+	.setkey			= cvm_xts_setkey,
358
+	.encrypt		= cvm_encrypt,
359
+	.decrypt		= cvm_decrypt,
360
+	.init			= cvm_enc_dec_init,
376361 }, {
377
-	.cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
378
-	.cra_blocksize = AES_BLOCK_SIZE,
379
-	.cra_ctxsize = sizeof(struct cvm_enc_ctx),
380
-	.cra_alignmask = 7,
381
-	.cra_priority = 4001,
382
-	.cra_name = "cbc(aes)",
383
-	.cra_driver_name = "cavium-cbc-aes",
384
-	.cra_type = &crypto_ablkcipher_type,
385
-	.cra_u = {
386
-		.ablkcipher = {
387
-			.ivsize = AES_BLOCK_SIZE,
388
-			.min_keysize = AES_MIN_KEY_SIZE,
389
-			.max_keysize = AES_MAX_KEY_SIZE,
390
-			.setkey = cvm_cbc_aes_setkey,
391
-			.encrypt = cvm_encrypt,
392
-			.decrypt = cvm_decrypt,
393
-		},
394
-	},
395
-	.cra_init = cvm_enc_dec_init,
396
-	.cra_module = THIS_MODULE,
362
+	.base.cra_flags		= CRYPTO_ALG_ASYNC |
363
+				  CRYPTO_ALG_ALLOCATES_MEMORY,
364
+	.base.cra_blocksize	= AES_BLOCK_SIZE,
365
+	.base.cra_ctxsize	= sizeof(struct cvm_enc_ctx),
366
+	.base.cra_alignmask	= 7,
367
+	.base.cra_priority	= 4001,
368
+	.base.cra_name		= "cbc(aes)",
369
+	.base.cra_driver_name	= "cavium-cbc-aes",
370
+	.base.cra_module	= THIS_MODULE,
371
+
372
+	.ivsize			= AES_BLOCK_SIZE,
373
+	.min_keysize		= AES_MIN_KEY_SIZE,
374
+	.max_keysize		= AES_MAX_KEY_SIZE,
375
+	.setkey			= cvm_cbc_aes_setkey,
376
+	.encrypt		= cvm_encrypt,
377
+	.decrypt		= cvm_decrypt,
378
+	.init			= cvm_enc_dec_init,
397379 }, {
398
-	.cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
399
-	.cra_blocksize = AES_BLOCK_SIZE,
400
-	.cra_ctxsize = sizeof(struct cvm_enc_ctx),
401
-	.cra_alignmask = 7,
402
-	.cra_priority = 4001,
403
-	.cra_name = "ecb(aes)",
404
-	.cra_driver_name = "cavium-ecb-aes",
405
-	.cra_type = &crypto_ablkcipher_type,
406
-	.cra_u = {
407
-		.ablkcipher = {
408
-			.ivsize = AES_BLOCK_SIZE,
409
-			.min_keysize = AES_MIN_KEY_SIZE,
410
-			.max_keysize = AES_MAX_KEY_SIZE,
411
-			.setkey = cvm_ecb_aes_setkey,
412
-			.encrypt = cvm_encrypt,
413
-			.decrypt = cvm_decrypt,
414
-		},
415
-	},
416
-	.cra_init = cvm_enc_dec_init,
417
-	.cra_module = THIS_MODULE,
380
+	.base.cra_flags		= CRYPTO_ALG_ASYNC |
381
+				  CRYPTO_ALG_ALLOCATES_MEMORY,
382
+	.base.cra_blocksize	= AES_BLOCK_SIZE,
383
+	.base.cra_ctxsize	= sizeof(struct cvm_enc_ctx),
384
+	.base.cra_alignmask	= 7,
385
+	.base.cra_priority	= 4001,
386
+	.base.cra_name		= "ecb(aes)",
387
+	.base.cra_driver_name	= "cavium-ecb-aes",
388
+	.base.cra_module	= THIS_MODULE,
389
+
390
+	.min_keysize		= AES_MIN_KEY_SIZE,
391
+	.max_keysize		= AES_MAX_KEY_SIZE,
392
+	.setkey			= cvm_ecb_aes_setkey,
393
+	.encrypt		= cvm_encrypt,
394
+	.decrypt		= cvm_decrypt,
395
+	.init			= cvm_enc_dec_init,
418396 }, {
419
-	.cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
420
-	.cra_blocksize = AES_BLOCK_SIZE,
421
-	.cra_ctxsize = sizeof(struct cvm_enc_ctx),
422
-	.cra_alignmask = 7,
423
-	.cra_priority = 4001,
424
-	.cra_name = "cfb(aes)",
425
-	.cra_driver_name = "cavium-cfb-aes",
426
-	.cra_type = &crypto_ablkcipher_type,
427
-	.cra_u = {
428
-		.ablkcipher = {
429
-			.ivsize = AES_BLOCK_SIZE,
430
-			.min_keysize = AES_MIN_KEY_SIZE,
431
-			.max_keysize = AES_MAX_KEY_SIZE,
432
-			.setkey = cvm_cfb_aes_setkey,
433
-			.encrypt = cvm_encrypt,
434
-			.decrypt = cvm_decrypt,
435
-		},
436
-	},
437
-	.cra_init = cvm_enc_dec_init,
438
-	.cra_module = THIS_MODULE,
397
+	.base.cra_flags		= CRYPTO_ALG_ASYNC |
398
+				  CRYPTO_ALG_ALLOCATES_MEMORY,
399
+	.base.cra_blocksize	= AES_BLOCK_SIZE,
400
+	.base.cra_ctxsize	= sizeof(struct cvm_enc_ctx),
401
+	.base.cra_alignmask	= 7,
402
+	.base.cra_priority	= 4001,
403
+	.base.cra_name		= "cfb(aes)",
404
+	.base.cra_driver_name	= "cavium-cfb-aes",
405
+	.base.cra_module	= THIS_MODULE,
406
+
407
+	.ivsize			= AES_BLOCK_SIZE,
408
+	.min_keysize		= AES_MIN_KEY_SIZE,
409
+	.max_keysize		= AES_MAX_KEY_SIZE,
410
+	.setkey			= cvm_cfb_aes_setkey,
411
+	.encrypt		= cvm_encrypt,
412
+	.decrypt		= cvm_decrypt,
413
+	.init			= cvm_enc_dec_init,
439414 }, {
440
-	.cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
441
-	.cra_blocksize = DES3_EDE_BLOCK_SIZE,
442
-	.cra_ctxsize = sizeof(struct cvm_des3_ctx),
443
-	.cra_alignmask = 7,
444
-	.cra_priority = 4001,
445
-	.cra_name = "cbc(des3_ede)",
446
-	.cra_driver_name = "cavium-cbc-des3_ede",
447
-	.cra_type = &crypto_ablkcipher_type,
448
-	.cra_u = {
449
-		.ablkcipher = {
450
-			.min_keysize = DES3_EDE_KEY_SIZE,
451
-			.max_keysize = DES3_EDE_KEY_SIZE,
452
-			.ivsize = DES_BLOCK_SIZE,
453
-			.setkey = cvm_cbc_des3_setkey,
454
-			.encrypt = cvm_encrypt,
455
-			.decrypt = cvm_decrypt,
456
-		},
457
-	},
458
-	.cra_init = cvm_enc_dec_init,
459
-	.cra_module = THIS_MODULE,
415
+	.base.cra_flags		= CRYPTO_ALG_ASYNC |
416
+				  CRYPTO_ALG_ALLOCATES_MEMORY,
417
+	.base.cra_blocksize	= DES3_EDE_BLOCK_SIZE,
418
+	.base.cra_ctxsize	= sizeof(struct cvm_des3_ctx),
419
+	.base.cra_alignmask	= 7,
420
+	.base.cra_priority	= 4001,
421
+	.base.cra_name		= "cbc(des3_ede)",
422
+	.base.cra_driver_name	= "cavium-cbc-des3_ede",
423
+	.base.cra_module	= THIS_MODULE,
424
+
425
+	.min_keysize		= DES3_EDE_KEY_SIZE,
426
+	.max_keysize		= DES3_EDE_KEY_SIZE,
427
+	.ivsize			= DES_BLOCK_SIZE,
428
+	.setkey			= cvm_cbc_des3_setkey,
429
+	.encrypt		= cvm_encrypt,
430
+	.decrypt		= cvm_decrypt,
431
+	.init			= cvm_enc_dec_init,
460432 }, {
461
-	.cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
462
-	.cra_blocksize = DES3_EDE_BLOCK_SIZE,
463
-	.cra_ctxsize = sizeof(struct cvm_des3_ctx),
464
-	.cra_alignmask = 7,
465
-	.cra_priority = 4001,
466
-	.cra_name = "ecb(des3_ede)",
467
-	.cra_driver_name = "cavium-ecb-des3_ede",
468
-	.cra_type = &crypto_ablkcipher_type,
469
-	.cra_u = {
470
-		.ablkcipher = {
471
-			.min_keysize = DES3_EDE_KEY_SIZE,
472
-			.max_keysize = DES3_EDE_KEY_SIZE,
473
-			.ivsize = DES_BLOCK_SIZE,
474
-			.setkey = cvm_ecb_des3_setkey,
475
-			.encrypt = cvm_encrypt,
476
-			.decrypt = cvm_decrypt,
477
-		},
478
-	},
479
-	.cra_init = cvm_enc_dec_init,
480
-	.cra_module = THIS_MODULE,
433
+	.base.cra_flags		= CRYPTO_ALG_ASYNC |
434
+				  CRYPTO_ALG_ALLOCATES_MEMORY,
435
+	.base.cra_blocksize	= DES3_EDE_BLOCK_SIZE,
436
+	.base.cra_ctxsize	= sizeof(struct cvm_des3_ctx),
437
+	.base.cra_alignmask	= 7,
438
+	.base.cra_priority	= 4001,
439
+	.base.cra_name		= "ecb(des3_ede)",
440
+	.base.cra_driver_name	= "cavium-ecb-des3_ede",
441
+	.base.cra_module	= THIS_MODULE,
442
+
443
+	.min_keysize		= DES3_EDE_KEY_SIZE,
444
+	.max_keysize		= DES3_EDE_KEY_SIZE,
445
+	.ivsize			= DES_BLOCK_SIZE,
446
+	.setkey			= cvm_ecb_des3_setkey,
447
+	.encrypt		= cvm_encrypt,
448
+	.decrypt		= cvm_decrypt,
449
+	.init			= cvm_enc_dec_init,
481450 } };
482451 
483452 static inline int cav_register_algs(void)
484453 {
485
-	int err = 0;
486
-
487
-	err = crypto_register_algs(algs, ARRAY_SIZE(algs));
488
-	if (err)
489
-		return err;
490
-
491
-	return 0;
454
+	return crypto_register_skciphers(algs, ARRAY_SIZE(algs));
492455 }
493456 
494457 static inline void cav_unregister_algs(void)
495458 {
496
-	crypto_unregister_algs(algs, ARRAY_SIZE(algs));
459
+	crypto_unregister_skciphers(algs, ARRAY_SIZE(algs));
497460 }
498461 
499462 int cvm_crypto_init(struct cpt_vf *cptvf)