crypto: hisilicon - redefine skcipher initiation

1.Define base initiation of QP for context which can be reused.
2.Define cipher initiation for other algorithms.

Signed-off-by: Zaibo Xu <xuzaibo@huawei.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>

diff --git a/drivers/crypto/hisilicon/sec2/sec_crypto.c b/drivers/crypto/hisilicon/sec2/sec_crypto.c
index 521bab86de39dc039bc5d7dbda547dc98f657cb1..f919deaba3ac5f1f227a9b8fd36026c238e0562a 100644 (file)
--- a/drivers/crypto/hisilicon/sec2/sec_crypto.c
+++ b/drivers/crypto/hisilicon/sec2/sec_crypto.c
@@ -273,25 +273,17 @@ static void sec_release_qp_ctx(struct sec_ctx *ctx,
        hisi_qm_release_qp(qp_ctx->qp);
 }
 
-static int sec_skcipher_init(struct crypto_skcipher *tfm)
+static int sec_ctx_base_init(struct sec_ctx *ctx)
 {
-       struct sec_ctx *ctx = crypto_skcipher_ctx(tfm);
-       struct sec_cipher_ctx *c_ctx;
        struct sec_dev *sec;
-       struct device *dev;
-       struct hisi_qm *qm;
        int i, ret;
 
-       crypto_skcipher_set_reqsize(tfm, sizeof(struct sec_req));
-
        sec = sec_find_device(cpu_to_node(smp_processor_id()));
        if (!sec) {
                pr_err("Can not find proper Hisilicon SEC device!\n");
                return -ENODEV;
        }
        ctx->sec = sec;
-       qm = &sec->qm;
-       dev = &qm->pdev->dev;
        ctx->hlf_q_num = sec->ctx_q_num >> 1;
 
        /* Half of queue depth is taken as fake requests limit in the queue. */
@@ -302,27 +294,12 @@ static int sec_skcipher_init(struct crypto_skcipher *tfm)
                return -ENOMEM;
 
        for (i = 0; i < sec->ctx_q_num; i++) {
-               ret = sec_create_qp_ctx(qm, ctx, i, 0);
+               ret = sec_create_qp_ctx(&sec->qm, ctx, i, 0);
                if (ret)
                        goto err_sec_release_qp_ctx;
        }
 
-       c_ctx = &ctx->c_ctx;
-       c_ctx->ivsize = crypto_skcipher_ivsize(tfm);
-       if (c_ctx->ivsize > SEC_IV_SIZE) {
-               dev_err(dev, "get error iv size!\n");
-               ret = -EINVAL;
-               goto err_sec_release_qp_ctx;
-       }
-       c_ctx->c_key = dma_alloc_coherent(dev, SEC_MAX_KEY_SIZE,
-                                         &c_ctx->c_key_dma, GFP_KERNEL);
-       if (!c_ctx->c_key) {
-               ret = -ENOMEM;
-               goto err_sec_release_qp_ctx;
-       }
-
        return 0;
-
 err_sec_release_qp_ctx:
        for (i = i - 1; i >= 0; i--)
                sec_release_qp_ctx(ctx, &ctx->qp_ctx[i]);
@@ -331,17 +308,9 @@ static int sec_skcipher_init(struct crypto_skcipher *tfm)
        return ret;
 }
 
-static void sec_skcipher_uninit(struct crypto_skcipher *tfm)
+static void sec_ctx_base_uninit(struct sec_ctx *ctx)
 {
-       struct sec_ctx *ctx = crypto_skcipher_ctx(tfm);
-       struct sec_cipher_ctx *c_ctx = &ctx->c_ctx;
-       int i = 0;
-
-       if (c_ctx->c_key) {
-               dma_free_coherent(SEC_CTX_DEV(ctx), SEC_MAX_KEY_SIZE,
-                                 c_ctx->c_key, c_ctx->c_key_dma);
-               c_ctx->c_key = NULL;
-       }
+       int i;
 
        for (i = 0; i < ctx->sec->ctx_q_num; i++)
                sec_release_qp_ctx(ctx, &ctx->qp_ctx[i]);
@@ -349,6 +318,63 @@ static void sec_skcipher_uninit(struct crypto_skcipher *tfm)
        kfree(ctx->qp_ctx);
 }
 
+static int sec_cipher_init(struct sec_ctx *ctx)
+{
+       struct sec_cipher_ctx *c_ctx = &ctx->c_ctx;
+
+       c_ctx->c_key = dma_alloc_coherent(SEC_CTX_DEV(ctx), SEC_MAX_KEY_SIZE,
+                                         &c_ctx->c_key_dma, GFP_KERNEL);
+       if (!c_ctx->c_key)
+               return -ENOMEM;
+
+       return 0;
+}
+
+static void sec_cipher_uninit(struct sec_ctx *ctx)
+{
+       struct sec_cipher_ctx *c_ctx = &ctx->c_ctx;
+
+       memzero_explicit(c_ctx->c_key, SEC_MAX_KEY_SIZE);
+       dma_free_coherent(SEC_CTX_DEV(ctx), SEC_MAX_KEY_SIZE,
+                         c_ctx->c_key, c_ctx->c_key_dma);
+}
+
+static int sec_skcipher_init(struct crypto_skcipher *tfm)
+{
+       struct sec_ctx *ctx = crypto_skcipher_ctx(tfm);
+       int ret;
+
+       ctx = crypto_skcipher_ctx(tfm);
+       crypto_skcipher_set_reqsize(tfm, sizeof(struct sec_req));
+       ctx->c_ctx.ivsize = crypto_skcipher_ivsize(tfm);
+       if (ctx->c_ctx.ivsize > SEC_IV_SIZE) {
+               dev_err(SEC_CTX_DEV(ctx), "get error skcipher iv size!\n");
+               return -EINVAL;
+       }
+
+       ret = sec_ctx_base_init(ctx);
+       if (ret)
+               return ret;
+
+       ret = sec_cipher_init(ctx);
+       if (ret)
+               goto err_cipher_init;
+
+       return 0;
+err_cipher_init:
+       sec_ctx_base_uninit(ctx);
+
+       return ret;
+}
+
+static void sec_skcipher_uninit(struct crypto_skcipher *tfm)
+{
+       struct sec_ctx *ctx = crypto_skcipher_ctx(tfm);
+
+       sec_cipher_uninit(ctx);
+       sec_ctx_base_uninit(ctx);
+}
+
 static int sec_skcipher_3des_setkey(struct sec_cipher_ctx *c_ctx,
                                    const u32 keylen,
                                    const enum sec_cmode c_mode)