forked from ~ljy/RK356X_SDK_RELEASE

blame | history | patch | commit | commitdiff
hc
2024-12-19 9370bb92b2d16684ee45cf24e879c93c509162da 
 kernel/drivers/crypto/omap-des.c
....@@ -1,13 +1,9 @@
1
+// SPDX-License-Identifier: GPL-2.0-only
12 /*
23  * Support for OMAP DES and Triple DES HW acceleration.
34  *
45  * Copyright (c) 2013 Texas Instruments Incorporated
56  * Author: Joel Fernandes <joelf@ti.com>
6
- *
7
- * This program is free software; you can redistribute it and/or modify
8
- * it under the terms of the GNU General Public License version 2 as published
9
- * by the Free Software Foundation.
10
- *
117  */
128 
139 #define pr_fmt(fmt) "%s: " fmt, __func__
....@@ -37,7 +33,8 @@
3733 #include <linux/crypto.h>
3834 #include <linux/interrupt.h>
3935 #include <crypto/scatterwalk.h>
40
-#include <crypto/des.h>
36
+#include <crypto/internal/des.h>
37
+#include <crypto/internal/skcipher.h>
4138 #include <crypto/algapi.h>
4239 #include <crypto/engine.h>
4340 
....@@ -90,7 +87,7 @@
9087 	struct omap_des_dev *dd;
9188 
9289 	int		keylen;
93
-	u32		key[(3 * DES_KEY_SIZE) / sizeof(u32)];
90
+	__le32		key[(3 * DES_KEY_SIZE) / sizeof(u32)];
9491 	unsigned long	flags;
9592 };
9693 
....@@ -102,7 +99,7 @@
10299 #define OMAP_DES_CACHE_SIZE	0
103100 
104101 struct omap_des_algs_info {
105
-	struct crypto_alg	*algs_list;
102
+	struct skcipher_alg	*algs_list;
106103 	unsigned int		size;
107104 	unsigned int		registered;
108105 };
....@@ -143,7 +140,7 @@
143140 
144141 	struct tasklet_struct	done_task;
145142 
146
-	struct ablkcipher_request	*req;
143
+	struct skcipher_request	*req;
147144 	struct crypto_engine		*engine;
148145 	/*
149146 	 * total is used by PIO mode for book keeping so introduce
....@@ -265,8 +262,8 @@
265262 			       __le32_to_cpu(dd->ctx->key[i]));
266263 	}
267264 
268
-	if ((dd->flags & FLAGS_CBC) && dd->req->info)
269
-		omap_des_write_n(dd, DES_REG_IV(dd, 0), dd->req->info, 2);
265
+	if ((dd->flags & FLAGS_CBC) && dd->req->iv)
266
+		omap_des_write_n(dd, DES_REG_IV(dd, 0), (void *)dd->req->iv, 2);
270267 
271268 	if (dd->flags & FLAGS_CBC)
272269 		val |= DES_REG_CTRL_CBC;
....@@ -460,11 +457,11 @@
460457 
461458 static int omap_des_crypt_dma_start(struct omap_des_dev *dd)
462459 {
463
-	struct crypto_tfm *tfm = crypto_ablkcipher_tfm(
464
-					crypto_ablkcipher_reqtfm(dd->req));
460
+	struct crypto_tfm *tfm = crypto_skcipher_tfm(
461
+					crypto_skcipher_reqtfm(dd->req));
465462 	int err;
466463 
467
-	pr_debug("total: %d\n", dd->total);
464
+	pr_debug("total: %zd\n", dd->total);
468465 
469466 	if (!dd->pio_only) {
470467 		err = dma_map_sg(dd->dev, dd->in_sg, dd->in_sg_len,
....@@ -495,11 +492,11 @@
495492 
496493 static void omap_des_finish_req(struct omap_des_dev *dd, int err)
497494 {
498
-	struct ablkcipher_request *req = dd->req;
495
+	struct skcipher_request *req = dd->req;
499496 
500497 	pr_debug("err: %d\n", err);
501498 
502
-	crypto_finalize_ablkcipher_request(dd->engine, req, err);
499
+	crypto_finalize_skcipher_request(dd->engine, req, err);
503500 
504501 	pm_runtime_mark_last_busy(dd->dev);
505502 	pm_runtime_put_autosuspend(dd->dev);
....@@ -507,7 +504,7 @@
507504 
508505 static int omap_des_crypt_dma_stop(struct omap_des_dev *dd)
509506 {
510
-	pr_debug("total: %d\n", dd->total);
507
+	pr_debug("total: %zd\n", dd->total);
511508 
512509 	omap_des_dma_stop(dd);
513510 
....@@ -518,10 +515,10 @@
518515 }
519516 
520517 static int omap_des_handle_queue(struct omap_des_dev *dd,
521
-				 struct ablkcipher_request *req)
518
+				 struct skcipher_request *req)
522519 {
523520 	if (req)
524
-		return crypto_transfer_ablkcipher_request_to_engine(dd->engine, req);
521
+		return crypto_transfer_skcipher_request_to_engine(dd->engine, req);
525522 
526523 	return 0;
527524 }
....@@ -529,9 +526,9 @@
529526 static int omap_des_prepare_req(struct crypto_engine *engine,
530527 				void *areq)
531528 {
532
-	struct ablkcipher_request *req = container_of(areq, struct ablkcipher_request, base);
533
-	struct omap_des_ctx *ctx = crypto_ablkcipher_ctx(
534
-			crypto_ablkcipher_reqtfm(req));
529
+	struct skcipher_request *req = container_of(areq, struct skcipher_request, base);
530
+	struct omap_des_ctx *ctx = crypto_skcipher_ctx(
531
+			crypto_skcipher_reqtfm(req));
535532 	struct omap_des_dev *dd = omap_des_find_dev(ctx);
536533 	struct omap_des_reqctx *rctx;
537534 	int ret;
....@@ -542,8 +539,8 @@
542539 
543540 	/* assign new request to device */
544541 	dd->req = req;
545
-	dd->total = req->nbytes;
546
-	dd->total_save = req->nbytes;
542
+	dd->total = req->cryptlen;
543
+	dd->total_save = req->cryptlen;
547544 	dd->in_sg = req->src;
548545 	dd->out_sg = req->dst;
549546 	dd->orig_out = req->dst;
....@@ -572,8 +569,8 @@
572569 	if (dd->out_sg_len < 0)
573570 		return dd->out_sg_len;
574571 
575
-	rctx = ablkcipher_request_ctx(req);
576
-	ctx = crypto_ablkcipher_ctx(crypto_ablkcipher_reqtfm(req));
572
+	rctx = skcipher_request_ctx(req);
573
+	ctx = crypto_skcipher_ctx(crypto_skcipher_reqtfm(req));
577574 	rctx->mode &= FLAGS_MODE_MASK;
578575 	dd->flags = (dd->flags & ~FLAGS_MODE_MASK) | rctx->mode;
579576 
....@@ -586,9 +583,9 @@
586583 static int omap_des_crypt_req(struct crypto_engine *engine,
587584 			      void *areq)
588585 {
589
-	struct ablkcipher_request *req = container_of(areq, struct ablkcipher_request, base);
590
-	struct omap_des_ctx *ctx = crypto_ablkcipher_ctx(
591
-			crypto_ablkcipher_reqtfm(req));
586
+	struct skcipher_request *req = container_of(areq, struct skcipher_request, base);
587
+	struct omap_des_ctx *ctx = crypto_skcipher_ctx(
588
+			crypto_skcipher_reqtfm(req));
592589 	struct omap_des_dev *dd = omap_des_find_dev(ctx);
593590 
594591 	if (!dd)
....@@ -600,6 +597,7 @@
600597 static void omap_des_done_task(unsigned long data)
601598 {
602599 	struct omap_des_dev *dd = (struct omap_des_dev *)data;
600
+	int i;
603601 
604602 	pr_debug("enter done_task\n");
605603 
....@@ -618,26 +616,32 @@
618616 	omap_crypto_cleanup(&dd->out_sgl, dd->orig_out, 0, dd->total_save,
619617 			    FLAGS_OUT_DATA_ST_SHIFT, dd->flags);
620618 
619
+	if ((dd->flags & FLAGS_CBC) && dd->req->iv)
620
+		for (i = 0; i < 2; i++)
621
+			((u32 *)dd->req->iv)[i] =
622
+				omap_des_read(dd, DES_REG_IV(dd, i));
623
+
621624 	omap_des_finish_req(dd, 0);
622625 
623626 	pr_debug("exit\n");
624627 }
625628 
626
-static int omap_des_crypt(struct ablkcipher_request *req, unsigned long mode)
629
+static int omap_des_crypt(struct skcipher_request *req, unsigned long mode)
627630 {
628
-	struct omap_des_ctx *ctx = crypto_ablkcipher_ctx(
629
-			crypto_ablkcipher_reqtfm(req));
630
-	struct omap_des_reqctx *rctx = ablkcipher_request_ctx(req);
631
+	struct omap_des_ctx *ctx = crypto_skcipher_ctx(
632
+			crypto_skcipher_reqtfm(req));
633
+	struct omap_des_reqctx *rctx = skcipher_request_ctx(req);
631634 	struct omap_des_dev *dd;
632635 
633
-	pr_debug("nbytes: %d, enc: %d, cbc: %d\n", req->nbytes,
636
+	pr_debug("nbytes: %d, enc: %d, cbc: %d\n", req->cryptlen,
634637 		 !!(mode & FLAGS_ENCRYPT),
635638 		 !!(mode & FLAGS_CBC));
636639 
637
-	if (!IS_ALIGNED(req->nbytes, DES_BLOCK_SIZE)) {
638
-		pr_err("request size is not exact amount of DES blocks\n");
640
+	if (!req->cryptlen)
641
+		return 0;
642
+
643
+	if (!IS_ALIGNED(req->cryptlen, DES_BLOCK_SIZE))
639644 		return -EINVAL;
640
-	}
641645 
642646 	dd = omap_des_find_dev(ctx);
643647 	if (!dd)
....@@ -650,27 +654,17 @@
650654 
651655 /* ********************** ALG API ************************************ */
652656 
653
-static int omap_des_setkey(struct crypto_ablkcipher *cipher, const u8 *key,
657
+static int omap_des_setkey(struct crypto_skcipher *cipher, const u8 *key,
654658 			   unsigned int keylen)
655659 {
656
-	struct omap_des_ctx *ctx = crypto_ablkcipher_ctx(cipher);
657
-	struct crypto_tfm *tfm = crypto_ablkcipher_tfm(cipher);
658
-
659
-	if (keylen != DES_KEY_SIZE && keylen != (3*DES_KEY_SIZE))
660
-		return -EINVAL;
660
+	struct omap_des_ctx *ctx = crypto_skcipher_ctx(cipher);
661
+	int err;
661662 
662663 	pr_debug("enter, keylen: %d\n", keylen);
663664 
664
-	/* Do we need to test against weak key? */
665
-	if (tfm->crt_flags & CRYPTO_TFM_REQ_WEAK_KEY) {
666
-		u32 tmp[DES_EXPKEY_WORDS];
667
-		int ret = des_ekey(tmp, key);
668
-
669
-		if (!ret) {
670
-			tfm->crt_flags |= CRYPTO_TFM_RES_WEAK_KEY;
671
-			return -EINVAL;
672
-		}
673
-	}
665
+	err = verify_skcipher_des_key(cipher, key);
666
+	if (err)
667
+		return err;
674668 
675669 	memcpy(ctx->key, key, keylen);
676670 	ctx->keylen = keylen;
....@@ -678,22 +672,40 @@
678672 	return 0;
679673 }
680674 
681
-static int omap_des_ecb_encrypt(struct ablkcipher_request *req)
675
+static int omap_des3_setkey(struct crypto_skcipher *cipher, const u8 *key,
676
+			    unsigned int keylen)
677
+{
678
+	struct omap_des_ctx *ctx = crypto_skcipher_ctx(cipher);
679
+	int err;
680
+
681
+	pr_debug("enter, keylen: %d\n", keylen);
682
+
683
+	err = verify_skcipher_des3_key(cipher, key);
684
+	if (err)
685
+		return err;
686
+
687
+	memcpy(ctx->key, key, keylen);
688
+	ctx->keylen = keylen;
689
+
690
+	return 0;
691
+}
692
+
693
+static int omap_des_ecb_encrypt(struct skcipher_request *req)
682694 {
683695 	return omap_des_crypt(req, FLAGS_ENCRYPT);
684696 }
685697 
686
-static int omap_des_ecb_decrypt(struct ablkcipher_request *req)
698
+static int omap_des_ecb_decrypt(struct skcipher_request *req)
687699 {
688700 	return omap_des_crypt(req, 0);
689701 }
690702 
691
-static int omap_des_cbc_encrypt(struct ablkcipher_request *req)
703
+static int omap_des_cbc_encrypt(struct skcipher_request *req)
692704 {
693705 	return omap_des_crypt(req, FLAGS_ENCRYPT | FLAGS_CBC);
694706 }
695707 
696
-static int omap_des_cbc_decrypt(struct ablkcipher_request *req)
708
+static int omap_des_cbc_decrypt(struct skcipher_request *req)
697709 {
698710 	return omap_des_crypt(req, FLAGS_CBC);
699711 }
....@@ -703,13 +715,13 @@
703715 static int omap_des_crypt_req(struct crypto_engine *engine,
704716 			      void *areq);
705717 
706
-static int omap_des_cra_init(struct crypto_tfm *tfm)
718
+static int omap_des_init_tfm(struct crypto_skcipher *tfm)
707719 {
708
-	struct omap_des_ctx *ctx = crypto_tfm_ctx(tfm);
720
+	struct omap_des_ctx *ctx = crypto_skcipher_ctx(tfm);
709721 
710722 	pr_debug("enter\n");
711723 
712
-	tfm->crt_ablkcipher.reqsize = sizeof(struct omap_des_reqctx);
724
+	crypto_skcipher_set_reqsize(tfm, sizeof(struct omap_des_reqctx));
713725 
714726 	ctx->enginectx.op.prepare_request = omap_des_prepare_req;
715727 	ctx->enginectx.op.unprepare_request = NULL;
....@@ -718,103 +730,78 @@
718730 	return 0;
719731 }
720732 
721
-static void omap_des_cra_exit(struct crypto_tfm *tfm)
722
-{
723
-	pr_debug("enter\n");
724
-}
725
-
726733 /* ********************** ALGS ************************************ */
727734 
728
-static struct crypto_alg algs_ecb_cbc[] = {
735
+static struct skcipher_alg algs_ecb_cbc[] = {
729736 {
730
-	.cra_name		= "ecb(des)",
731
-	.cra_driver_name	= "ecb-des-omap",
732
-	.cra_priority		= 100,
733
-	.cra_flags		= CRYPTO_ALG_TYPE_ABLKCIPHER |
734
-				  CRYPTO_ALG_KERN_DRIVER_ONLY |
737
+	.base.cra_name		= "ecb(des)",
738
+	.base.cra_driver_name	= "ecb-des-omap",
739
+	.base.cra_priority	= 100,
740
+	.base.cra_flags		= CRYPTO_ALG_KERN_DRIVER_ONLY |
735741 				  CRYPTO_ALG_ASYNC,
736
-	.cra_blocksize		= DES_BLOCK_SIZE,
737
-	.cra_ctxsize		= sizeof(struct omap_des_ctx),
738
-	.cra_alignmask		= 0,
739
-	.cra_type		= &crypto_ablkcipher_type,
740
-	.cra_module		= THIS_MODULE,
741
-	.cra_init		= omap_des_cra_init,
742
-	.cra_exit		= omap_des_cra_exit,
743
-	.cra_u.ablkcipher = {
744
-		.min_keysize	= DES_KEY_SIZE,
745
-		.max_keysize	= DES_KEY_SIZE,
746
-		.setkey		= omap_des_setkey,
747
-		.encrypt	= omap_des_ecb_encrypt,
748
-		.decrypt	= omap_des_ecb_decrypt,
749
-	}
742
+	.base.cra_blocksize	= DES_BLOCK_SIZE,
743
+	.base.cra_ctxsize	= sizeof(struct omap_des_ctx),
744
+	.base.cra_module	= THIS_MODULE,
745
+
746
+	.min_keysize		= DES_KEY_SIZE,
747
+	.max_keysize		= DES_KEY_SIZE,
748
+	.setkey			= omap_des_setkey,
749
+	.encrypt		= omap_des_ecb_encrypt,
750
+	.decrypt		= omap_des_ecb_decrypt,
751
+	.init			= omap_des_init_tfm,
750752 },
751753 {
752
-	.cra_name		= "cbc(des)",
753
-	.cra_driver_name	= "cbc-des-omap",
754
-	.cra_priority		= 100,
755
-	.cra_flags		= CRYPTO_ALG_TYPE_ABLKCIPHER |
756
-				  CRYPTO_ALG_KERN_DRIVER_ONLY |
754
+	.base.cra_name		= "cbc(des)",
755
+	.base.cra_driver_name	= "cbc-des-omap",
756
+	.base.cra_priority	= 100,
757
+	.base.cra_flags		= CRYPTO_ALG_KERN_DRIVER_ONLY |
757758 				  CRYPTO_ALG_ASYNC,
758
-	.cra_blocksize		= DES_BLOCK_SIZE,
759
-	.cra_ctxsize		= sizeof(struct omap_des_ctx),
760
-	.cra_alignmask		= 0,
761
-	.cra_type		= &crypto_ablkcipher_type,
762
-	.cra_module		= THIS_MODULE,
763
-	.cra_init		= omap_des_cra_init,
764
-	.cra_exit		= omap_des_cra_exit,
765
-	.cra_u.ablkcipher = {
766
-		.min_keysize	= DES_KEY_SIZE,
767
-		.max_keysize	= DES_KEY_SIZE,
768
-		.ivsize		= DES_BLOCK_SIZE,
769
-		.setkey		= omap_des_setkey,
770
-		.encrypt	= omap_des_cbc_encrypt,
771
-		.decrypt	= omap_des_cbc_decrypt,
772
-	}
759
+	.base.cra_blocksize	= DES_BLOCK_SIZE,
760
+	.base.cra_ctxsize	= sizeof(struct omap_des_ctx),
761
+	.base.cra_module	= THIS_MODULE,
762
+
763
+	.min_keysize		= DES_KEY_SIZE,
764
+	.max_keysize		= DES_KEY_SIZE,
765
+	.ivsize			= DES_BLOCK_SIZE,
766
+	.setkey			= omap_des_setkey,
767
+	.encrypt		= omap_des_cbc_encrypt,
768
+	.decrypt		= omap_des_cbc_decrypt,
769
+	.init			= omap_des_init_tfm,
773770 },
774771 {
775
-	.cra_name		= "ecb(des3_ede)",
776
-	.cra_driver_name	= "ecb-des3-omap",
777
-	.cra_priority		= 100,
778
-	.cra_flags		= CRYPTO_ALG_TYPE_ABLKCIPHER |
779
-				  CRYPTO_ALG_KERN_DRIVER_ONLY |
772
+	.base.cra_name		= "ecb(des3_ede)",
773
+	.base.cra_driver_name	= "ecb-des3-omap",
774
+	.base.cra_priority	= 100,
775
+	.base.cra_flags		= CRYPTO_ALG_KERN_DRIVER_ONLY |
780776 				  CRYPTO_ALG_ASYNC,
781
-	.cra_blocksize		= DES_BLOCK_SIZE,
782
-	.cra_ctxsize		= sizeof(struct omap_des_ctx),
783
-	.cra_alignmask		= 0,
784
-	.cra_type		= &crypto_ablkcipher_type,
785
-	.cra_module		= THIS_MODULE,
786
-	.cra_init		= omap_des_cra_init,
787
-	.cra_exit		= omap_des_cra_exit,
788
-	.cra_u.ablkcipher = {
789
-		.min_keysize	= 3*DES_KEY_SIZE,
790
-		.max_keysize	= 3*DES_KEY_SIZE,
791
-		.setkey		= omap_des_setkey,
792
-		.encrypt	= omap_des_ecb_encrypt,
793
-		.decrypt	= omap_des_ecb_decrypt,
794
-	}
777
+	.base.cra_blocksize	= DES3_EDE_BLOCK_SIZE,
778
+	.base.cra_ctxsize	= sizeof(struct omap_des_ctx),
779
+	.base.cra_module	= THIS_MODULE,
780
+
781
+	.min_keysize		= DES3_EDE_KEY_SIZE,
782
+	.max_keysize		= DES3_EDE_KEY_SIZE,
783
+	.setkey			= omap_des3_setkey,
784
+	.encrypt		= omap_des_ecb_encrypt,
785
+	.decrypt		= omap_des_ecb_decrypt,
786
+	.init			= omap_des_init_tfm,
795787 },
796788 {
797
-	.cra_name		= "cbc(des3_ede)",
798
-	.cra_driver_name	= "cbc-des3-omap",
799
-	.cra_priority		= 100,
800
-	.cra_flags		= CRYPTO_ALG_TYPE_ABLKCIPHER |
801
-				  CRYPTO_ALG_KERN_DRIVER_ONLY |
789
+	.base.cra_name		= "cbc(des3_ede)",
790
+	.base.cra_driver_name	= "cbc-des3-omap",
791
+	.base.cra_priority	= 100,
792
+	.base.cra_flags		= CRYPTO_ALG_KERN_DRIVER_ONLY |
802793 				  CRYPTO_ALG_ASYNC,
803
-	.cra_blocksize		= DES_BLOCK_SIZE,
804
-	.cra_ctxsize		= sizeof(struct omap_des_ctx),
805
-	.cra_alignmask		= 0,
806
-	.cra_type		= &crypto_ablkcipher_type,
807
-	.cra_module		= THIS_MODULE,
808
-	.cra_init		= omap_des_cra_init,
809
-	.cra_exit		= omap_des_cra_exit,
810
-	.cra_u.ablkcipher = {
811
-		.min_keysize	= 3*DES_KEY_SIZE,
812
-		.max_keysize	= 3*DES_KEY_SIZE,
813
-		.ivsize		= DES_BLOCK_SIZE,
814
-		.setkey		= omap_des_setkey,
815
-		.encrypt	= omap_des_cbc_encrypt,
816
-		.decrypt	= omap_des_cbc_decrypt,
817
-	}
794
+	.base.cra_blocksize	= DES3_EDE_BLOCK_SIZE,
795
+	.base.cra_ctxsize	= sizeof(struct omap_des_ctx),
796
+	.base.cra_module	= THIS_MODULE,
797
+
798
+	.min_keysize		= DES3_EDE_KEY_SIZE,
799
+	.max_keysize		= DES3_EDE_KEY_SIZE,
800
+	.ivsize			= DES3_EDE_BLOCK_SIZE,
801
+	.setkey			= omap_des3_setkey,
802
+	.encrypt		= omap_des_cbc_encrypt,
803
+	.decrypt		= omap_des_cbc_decrypt,
804
+	.init			= omap_des_init_tfm,
818805 }
819806 };
820807 
....@@ -972,7 +959,7 @@
972959 {
973960 	struct device *dev = &pdev->dev;
974961 	struct omap_des_dev *dd;
975
-	struct crypto_alg *algp;
962
+	struct skcipher_alg *algp;
976963 	struct resource *res;
977964 	int err = -ENOMEM, i, j, irq = -1;
978965 	u32 reg;
....@@ -1034,7 +1021,6 @@
10341021 
10351022 		irq = platform_get_irq(pdev, 0);
10361023 		if (irq < 0) {
1037
-			dev_err(dev, "can't get IRQ resource: %d\n", irq);
10381024 			err = irq;
10391025 			goto err_irq;
10401026 		}
....@@ -1049,9 +1035,9 @@
10491035 
10501036 
10511037 	INIT_LIST_HEAD(&dd->list);
1052
-	spin_lock(&list_lock);
1038
+	spin_lock_bh(&list_lock);
10531039 	list_add_tail(&dd->list, &dev_list);
1054
-	spin_unlock(&list_lock);
1040
+	spin_unlock_bh(&list_lock);
10551041 
10561042 	/* Initialize des crypto engine */
10571043 	dd->engine = crypto_engine_alloc_init(dev, 1);
....@@ -1068,10 +1054,9 @@
10681054 		for (j = 0; j < dd->pdata->algs_info[i].size; j++) {
10691055 			algp = &dd->pdata->algs_info[i].algs_list[j];
10701056 
1071
-			pr_debug("reg alg: %s\n", algp->cra_name);
1072
-			INIT_LIST_HEAD(&algp->cra_list);
1057
+			pr_debug("reg alg: %s\n", algp->base.cra_name);
10731058 
1074
-			err = crypto_register_alg(algp);
1059
+			err = crypto_register_skcipher(algp);
10751060 			if (err)
10761061 				goto err_algs;
10771062 
....@@ -1084,7 +1069,7 @@
10841069 err_algs:
10851070 	for (i = dd->pdata->algs_info_size - 1; i >= 0; i--)
10861071 		for (j = dd->pdata->algs_info[i].registered - 1; j >= 0; j--)
1087
-			crypto_unregister_alg(
1072
+			crypto_unregister_skcipher(
10881073 					&dd->pdata->algs_info[i].algs_list[j]);
10891074 
10901075 err_engine:
....@@ -1111,13 +1096,13 @@
11111096 	if (!dd)
11121097 		return -ENODEV;
11131098 
1114
-	spin_lock(&list_lock);
1099
+	spin_lock_bh(&list_lock);
11151100 	list_del(&dd->list);
1116
-	spin_unlock(&list_lock);
1101
+	spin_unlock_bh(&list_lock);
11171102 
11181103 	for (i = dd->pdata->algs_info_size - 1; i >= 0; i--)
11191104 		for (j = dd->pdata->algs_info[i].registered - 1; j >= 0; j--)
1120
-			crypto_unregister_alg(
1105
+			crypto_unregister_skcipher(
11211106 					&dd->pdata->algs_info[i].algs_list[j]);
11221107 
11231108 	tasklet_kill(&dd->done_task);