Refactor descriptor creation in caamalg and caamhash, i.e.
create whole descriptors in the same place / function.
This makes the code more comprehensible and easier to maintain.

Signed-off-by: Horia Geanta <horia.gea...@freescale.com>
---
 drivers/crypto/caam/caamalg.c  | 244 +++++++++++++++------------
 drivers/crypto/caam/caamhash.c | 368 ++++++++++++++---------------------------
 2 files changed, 262 insertions(+), 350 deletions(-)

diff --git a/drivers/crypto/caam/caamalg.c b/drivers/crypto/caam/caamalg.c
index cd1ba573c633..9090fc8c04e0 100644
--- a/drivers/crypto/caam/caamalg.c
+++ b/drivers/crypto/caam/caamalg.c
@@ -94,57 +94,6 @@
 static struct list_head alg_list;
 static const bool ps = (sizeof(dma_addr_t) == sizeof(u64));
 
-/* Set DK bit in class 1 operation if shared */
-static inline void append_dec_op1(struct program *p, u32 type)
-{
-       LABEL(jump_cmd);
-       REFERENCE(pjump_cmd);
-       LABEL(uncond_jump_cmd);
-       REFERENCE(puncond_jump_cmd);
-
-       /* DK bit is valid only for AES */
-       if ((type & OP_ALG_ALGSEL_MASK) != OP_ALG_ALGSEL_AES) {
-               ALG_OPERATION(p, type & OP_ALG_ALGSEL_MASK,
-                             type & OP_ALG_AAI_MASK, OP_ALG_AS_INITFINAL,
-                             ICV_CHECK_DISABLE, DIR_DEC);
-               return;
-       }
-
-       pjump_cmd = JUMP(p, jump_cmd, LOCAL_JUMP, ALL_TRUE, SHRD);
-       ALG_OPERATION(p, type & OP_ALG_ALGSEL_MASK, type & OP_ALG_AAI_MASK,
-                     OP_ALG_AS_INITFINAL, ICV_CHECK_DISABLE, DIR_DEC);
-       puncond_jump_cmd = JUMP(p, uncond_jump_cmd, LOCAL_JUMP, ALL_TRUE, 0);
-       SET_LABEL(p, jump_cmd);
-       ALG_OPERATION(p, type & OP_ALG_ALGSEL_MASK,
-                     (type & OP_ALG_AAI_MASK) | OP_ALG_AAI_DK,
-                     OP_ALG_AS_INITFINAL, ICV_CHECK_DISABLE, DIR_DEC);
-       SET_LABEL(p, uncond_jump_cmd);
-
-       PATCH_JUMP(p, pjump_cmd, jump_cmd);
-       PATCH_JUMP(p, puncond_jump_cmd, uncond_jump_cmd);
-}
-
-/*
- * For aead encrypt and decrypt, read iv for both classes
- */
-static inline void aead_append_ld_iv(struct program *p, u32 ivsize)
-{
-       SEQLOAD(p, CONTEXT1, 0, ivsize, 0);
-       MOVE(p, CONTEXT1, 0, IFIFOAB2, 0, ivsize, IMMED);
-}
-
-/*
- * For ablkcipher encrypt and decrypt, read from req->src and
- * write to req->dst
- */
-static inline void ablkcipher_append_src_dst(struct program *p)
-{
-       MATHB(p, SEQINSZ, ADD, MATH0, VSEQOUTSZ, 4, 0);
-       MATHB(p, SEQINSZ, ADD, MATH0, VSEQINSZ, 4, 0);
-       SEQFIFOLOAD(p, MSG1, 0, VLF | LAST1);
-       SEQFIFOSTORE(p, MSG, 0, 0, VLF);
-}
-
 /*
  * If all data, including src (with assoc and iv) or dst (with iv only) are
  * contiguous
@@ -173,39 +122,6 @@ struct caam_ctx {
        unsigned int authsize;
 };
 
-static void append_key_aead(struct program *p, struct caam_ctx *ctx,
-                           int keys_fit_inline)
-{
-       if (keys_fit_inline) {
-               KEY(p, MDHA_SPLIT_KEY, ENC, (uintptr_t)ctx->key,
-                   ctx->split_key_len, IMMED | COPY);
-               KEY(p, KEY1, 0, (uintptr_t)(ctx->key + ctx->split_key_pad_len),
-                   ctx->enckeylen, IMMED | COPY);
-       } else {
-               KEY(p, MDHA_SPLIT_KEY, ENC, ctx->key_dma, ctx->split_key_len,
-                   0);
-               KEY(p, KEY1, 0, ctx->key_dma + ctx->split_key_pad_len,
-                   ctx->enckeylen, 0);
-       }
-}
-
-static void init_sh_desc_key_aead(struct program *p, struct caam_ctx *ctx,
-                                 int keys_fit_inline)
-{
-       LABEL(key_jump_cmd);
-       REFERENCE(pkey_jump_cmd);
-
-       SHR_HDR(p, SHR_SERIAL, 1, 0);
-
-       /* Skip if already shared */
-       pkey_jump_cmd = JUMP(p, key_jump_cmd, LOCAL_JUMP, ALL_TRUE, SHRD);
-
-       append_key_aead(p, ctx, keys_fit_inline);
-
-       SET_LABEL(p, key_jump_cmd);
-       PATCH_JUMP(p, pkey_jump_cmd, key_jump_cmd);
-}
-
 static int aead_null_set_sh_desc(struct crypto_aead *aead)
 {
        struct aead_tfm *tfm = &aead->base.crt_aead;
@@ -419,6 +335,12 @@ static int aead_set_sh_desc(struct crypto_aead *aead)
        struct program prg;
        struct program *p = &prg;
        unsigned desc_bytes;
+       LABEL(skip_key_load);
+       REFERENCE(pskip_key_load);
+       LABEL(set_dk);
+       REFERENCE(pset_dk);
+       LABEL(skip_dk);
+       REFERENCE(pskip_dk);
 
        if (!ctx->authsize)
                return 0;
@@ -442,7 +364,24 @@ static int aead_set_sh_desc(struct crypto_aead *aead)
        if (ps)
                PROGRAM_SET_36BIT_ADDR(p);
 
-       init_sh_desc_key_aead(p, ctx, keys_fit_inline);
+       SHR_HDR(p, SHR_SERIAL, 1, 0);
+
+       /* Skip key loading if already shared */
+       pskip_key_load = JUMP(p, skip_key_load, LOCAL_JUMP, ALL_TRUE, SHRD);
+
+       if (keys_fit_inline) {
+               KEY(p, MDHA_SPLIT_KEY, ENC, (uintptr_t)ctx->key,
+                   ctx->split_key_len, IMMED | COPY);
+               KEY(p, KEY1, 0, (uintptr_t)(ctx->key + ctx->split_key_pad_len),
+                   ctx->enckeylen, IMMED | COPY);
+       } else {
+               KEY(p, MDHA_SPLIT_KEY, ENC, ctx->key_dma, ctx->split_key_len,
+                   0);
+               KEY(p, KEY1, 0, ctx->key_dma + ctx->split_key_pad_len,
+                   ctx->enckeylen, 0);
+       }
+
+       SET_LABEL(p, skip_key_load);
 
        /* Class 2 operation */
        ALG_OPERATION(p, ctx->class2_alg_type & OP_ALG_ALGSEL_MASK,
@@ -460,7 +399,10 @@ static int aead_set_sh_desc(struct crypto_aead *aead)
 
        /* read assoc before reading payload */
        SEQFIFOLOAD(p, MSG2, 0 , VLF);
-       aead_append_ld_iv(p, tfm->ivsize);
+
+       /* read iv for both classes */
+       SEQLOAD(p, CONTEXT1, 0, tfm->ivsize, 0);
+       MOVE(p, CONTEXT1, 0, IFIFOAB2, 0, tfm->ivsize, IMMED);
 
        /* Class 1 operation */
        ALG_OPERATION(p, ctx->class1_alg_type & OP_ALG_ALGSEL_MASK,
@@ -478,6 +420,8 @@ static int aead_set_sh_desc(struct crypto_aead *aead)
        /* Write ICV */
        SEQSTORE(p, CONTEXT2, 0, ctx->authsize, 0);
 
+       PATCH_JUMP(p, pskip_key_load, skip_key_load);
+
        PROGRAM_FINALIZE(p);
 
        desc_bytes = DESC_BYTES(desc);
@@ -508,7 +452,25 @@ static int aead_set_sh_desc(struct crypto_aead *aead)
        if (ps)
                PROGRAM_SET_36BIT_ADDR(p);
 
-       init_sh_desc_key_aead(p, ctx, keys_fit_inline);
+       /* aead_decrypt shared descriptor */
+       SHR_HDR(p, SHR_SERIAL, 1, 0);
+
+       /* Skip key loading if already shared */
+       pskip_key_load = JUMP(p, skip_key_load, LOCAL_JUMP, ALL_TRUE, SHRD);
+
+       if (keys_fit_inline) {
+               KEY(p, MDHA_SPLIT_KEY, ENC, (uintptr_t)ctx->key,
+                   ctx->split_key_len, IMMED | COPY);
+               KEY(p, KEY1, 0, (uintptr_t)(ctx->key + ctx->split_key_pad_len),
+                   ctx->enckeylen, IMMED | COPY);
+       } else {
+               KEY(p, MDHA_SPLIT_KEY, ENC, ctx->key_dma, ctx->split_key_len,
+                   0);
+               KEY(p, KEY1, 0, ctx->key_dma + ctx->split_key_pad_len,
+                   ctx->enckeylen, 0);
+       }
+
+       SET_LABEL(p, skip_key_load);
 
        /* Class 2 operation */
        ALG_OPERATION(p, ctx->class2_alg_type & OP_ALG_ALGSEL_MASK,
@@ -525,9 +487,28 @@ static int aead_set_sh_desc(struct crypto_aead *aead)
        /* read assoc before reading payload */
        SEQFIFOLOAD(p, MSG2, 0 , VLF);
 
-       aead_append_ld_iv(p, tfm->ivsize);
-
-       append_dec_op1(p, ctx->class1_alg_type);
+       /* read iv for both classes */
+       SEQLOAD(p, CONTEXT1, 0, tfm->ivsize, 0);
+       MOVE(p, CONTEXT1, 0, IFIFOAB2, 0, tfm->ivsize, IMMED);
+
+       /* Set DK bit in class 1 operation if shared (AES only) */
+       if ((ctx->class1_alg_type & OP_ALG_ALGSEL_MASK) == OP_ALG_ALGSEL_AES) {
+               pset_dk = JUMP(p, set_dk, LOCAL_JUMP, ALL_TRUE, SHRD);
+               ALG_OPERATION(p, ctx->class1_alg_type & OP_ALG_ALGSEL_MASK,
+                             ctx->class1_alg_type & OP_ALG_AAI_MASK,
+                             OP_ALG_AS_INITFINAL, ICV_CHECK_DISABLE, DIR_DEC);
+               pskip_dk = JUMP(p, skip_dk, LOCAL_JUMP, ALL_TRUE, 0);
+               SET_LABEL(p, set_dk);
+               ALG_OPERATION(p, ctx->class1_alg_type & OP_ALG_ALGSEL_MASK,
+                             (ctx->class1_alg_type & OP_ALG_AAI_MASK) |
+                              OP_ALG_AAI_DK, OP_ALG_AS_INITFINAL,
+                             ICV_CHECK_DISABLE, DIR_DEC);
+               SET_LABEL(p, skip_dk);
+       } else {
+               ALG_OPERATION(p, ctx->class1_alg_type & OP_ALG_ALGSEL_MASK,
+                             ctx->class1_alg_type & OP_ALG_AAI_MASK,
+                             OP_ALG_AS_INITFINAL, ICV_CHECK_DISABLE, DIR_DEC);
+       }
 
        /* Read and write cryptlen bytes */
        MATHB(p, ZERO, ADD, MATH2, VSEQINSZ, CAAM_CMD_SZ, 0);
@@ -540,6 +521,10 @@ static int aead_set_sh_desc(struct crypto_aead *aead)
        /* Load ICV */
        SEQFIFOLOAD(p, ICV2, ctx->authsize, LAST2);
 
+       PATCH_JUMP(p, pskip_key_load, skip_key_load);
+       PATCH_JUMP(p, pset_dk, set_dk);
+       PATCH_JUMP(p, pskip_dk, skip_dk);
+
        PROGRAM_FINALIZE(p);
 
        desc_bytes = DESC_BYTES(desc);
@@ -570,7 +555,25 @@ static int aead_set_sh_desc(struct crypto_aead *aead)
        if (ps)
                PROGRAM_SET_36BIT_ADDR(p);
 
-       init_sh_desc_key_aead(p, ctx, keys_fit_inline);
+       SHR_HDR(p, SHR_SERIAL, 1, 0);
+
+       /* Skip key loading if already shared */
+       pskip_key_load = JUMP(p, skip_key_load, LOCAL_JUMP, ALL_TRUE, SHRD);
+
+       if (keys_fit_inline) {
+               KEY(p, MDHA_SPLIT_KEY, ENC, (uintptr_t)ctx->key,
+                   ctx->split_key_len, IMMED | COPY);
+               KEY(p, KEY1, 0,
+                   (uintptr_t)(ctx->key + ctx->split_key_pad_len),
+                   ctx->enckeylen, IMMED | COPY);
+       } else {
+               KEY(p, MDHA_SPLIT_KEY, ENC, ctx->key_dma, ctx->split_key_len,
+                   0);
+               KEY(p, KEY1, 0, ctx->key_dma + ctx->split_key_pad_len,
+                   ctx->enckeylen, 0);
+       }
+
+       SET_LABEL(p, skip_key_load);
 
        /* Generate IV */
        geniv = NFIFOENTRY_STYPE_PAD | NFIFOENTRY_DEST_DECO |
@@ -625,6 +628,8 @@ static int aead_set_sh_desc(struct crypto_aead *aead)
        /* Write ICV */
        SEQSTORE(p, CONTEXT2, 0, ctx->authsize, 0);
 
+       PATCH_JUMP(p, pskip_key_load, skip_key_load);
+
        PROGRAM_FINALIZE(p);
 
        desc_bytes = DESC_BYTES(desc);
@@ -735,8 +740,12 @@ static int ablkcipher_setkey(struct crypto_ablkcipher 
*ablkcipher,
        struct program prg;
        struct program *p = &prg;
        unsigned desc_bytes;
-       LABEL(key_jump_cmd);
-       REFERENCE(pkey_jump_cmd);
+       LABEL(skip_key_load);
+       REFERENCE(pskip_key_load);
+       LABEL(set_dk);
+       REFERENCE(pset_dk);
+       LABEL(skip_dk);
+       REFERENCE(pskip_dk);
 
 #ifdef DEBUG
        print_hex_dump(KERN_ERR, "key in @"__stringify(__LINE__)": ",
@@ -759,13 +768,14 @@ static int ablkcipher_setkey(struct crypto_ablkcipher 
*ablkcipher,
                PROGRAM_SET_36BIT_ADDR(p);
 
        SHR_HDR(p, SHR_SERIAL, 1, 0);
-       /* Skip if already shared */
-       pkey_jump_cmd = JUMP(p, key_jump_cmd, LOCAL_JUMP, ALL_TRUE, SHRD);
+
+       /* Skip key loading if already shared */
+       pskip_key_load = JUMP(p, skip_key_load, LOCAL_JUMP, ALL_TRUE, SHRD);
 
        /* Load class1 key only */
        KEY(p, KEY1, 0, (uintptr_t)ctx->key, ctx->enckeylen, IMMED | COPY);
 
-       SET_LABEL(p, key_jump_cmd);
+       SET_LABEL(p, skip_key_load);
 
        /* Load IV */
        SEQLOAD(p, CONTEXT1, 0, tfm->ivsize, 0);
@@ -776,9 +786,12 @@ static int ablkcipher_setkey(struct crypto_ablkcipher 
*ablkcipher,
                      OP_ALG_AS_INITFINAL, ICV_CHECK_DISABLE, DIR_ENC);
 
        /* Perform operation */
-       ablkcipher_append_src_dst(p);
+       MATHB(p, SEQINSZ, ADD, MATH0, VSEQOUTSZ, 4, 0);
+       MATHB(p, SEQINSZ, ADD, MATH0, VSEQINSZ, 4, 0);
+       SEQFIFOLOAD(p, MSG1, 0, VLF | LAST1);
+       SEQFIFOSTORE(p, MSG, 0, 0, VLF);
 
-       PATCH_JUMP(p, pkey_jump_cmd, key_jump_cmd);
+       PATCH_JUMP(p, pskip_key_load, skip_key_load);
 
        PROGRAM_FINALIZE(p);
 
@@ -803,24 +816,45 @@ static int ablkcipher_setkey(struct crypto_ablkcipher 
*ablkcipher,
 
        SHR_HDR(p, SHR_SERIAL, 1, 0);
 
-       /* Skip if already shared */
-       pkey_jump_cmd = JUMP(p, key_jump_cmd, LOCAL_JUMP, ALL_TRUE, SHRD);
+       /* Skip key loading if already shared */
+       pskip_key_load = JUMP(p, skip_key_load, LOCAL_JUMP, ALL_TRUE, SHRD);
 
        /* Load class1 key only */
        KEY(p, KEY1, 0, (uintptr_t)ctx->key, ctx->enckeylen, IMMED | COPY);
 
-       SET_LABEL(p, key_jump_cmd);
+       SET_LABEL(p, skip_key_load);
 
        /* load IV */
        SEQLOAD(p, CONTEXT1, 0, tfm->ivsize, 0);
 
-       /* Choose operation */
-       append_dec_op1(p, ctx->class1_alg_type);
+       /* Set DK bit in class 1 operation if shared (AES only) */
+       if ((ctx->class1_alg_type & OP_ALG_ALGSEL_MASK) == OP_ALG_ALGSEL_AES) {
+               pset_dk = JUMP(p, set_dk, LOCAL_JUMP, ALL_TRUE, SHRD);
+               ALG_OPERATION(p, ctx->class1_alg_type & OP_ALG_ALGSEL_MASK,
+                             ctx->class1_alg_type & OP_ALG_AAI_MASK,
+                             OP_ALG_AS_INITFINAL, ICV_CHECK_DISABLE, DIR_DEC);
+               pskip_dk = JUMP(p, skip_dk, LOCAL_JUMP, ALL_TRUE, 0);
+               SET_LABEL(p, set_dk);
+               ALG_OPERATION(p, ctx->class1_alg_type & OP_ALG_ALGSEL_MASK,
+                             (ctx->class1_alg_type & OP_ALG_AAI_MASK) |
+                              OP_ALG_AAI_DK, OP_ALG_AS_INITFINAL,
+                             ICV_CHECK_DISABLE, DIR_DEC);
+               SET_LABEL(p, skip_dk);
+       } else {
+               ALG_OPERATION(p, ctx->class1_alg_type & OP_ALG_ALGSEL_MASK,
+                             ctx->class1_alg_type & OP_ALG_AAI_MASK,
+                             OP_ALG_AS_INITFINAL, ICV_CHECK_DISABLE, DIR_DEC);
+       }
 
        /* Perform operation */
-       ablkcipher_append_src_dst(p);
+       MATHB(p, SEQINSZ, ADD, MATH0, VSEQOUTSZ, 4, 0);
+       MATHB(p, SEQINSZ, ADD, MATH0, VSEQINSZ, 4, 0);
+       SEQFIFOLOAD(p, MSG1, 0, VLF | LAST1);
+       SEQFIFOSTORE(p, MSG, 0, 0, VLF);
 
-       PATCH_JUMP(p, pkey_jump_cmd, key_jump_cmd);
+       PATCH_JUMP(p, pskip_key_load, skip_key_load);
+       PATCH_JUMP(p, pset_dk, set_dk);
+       PATCH_JUMP(p, pskip_dk, skip_dk);
 
        PROGRAM_FINALIZE(p);
 
diff --git a/drivers/crypto/caam/caamhash.c b/drivers/crypto/caam/caamhash.c
index 529e3ca92406..0e5d7ef33ff8 100644
--- a/drivers/crypto/caam/caamhash.c
+++ b/drivers/crypto/caam/caamhash.c
@@ -137,36 +137,6 @@ struct caam_hash_state {
 
 /* Common job descriptor seq in/out ptr routines */
 
-/* Map state->caam_ctx, and append seq_out_ptr command that points to it */
-static inline int map_seq_out_ptr_ctx(struct program *p, struct device *jrdev,
-                                     struct caam_hash_state *state,
-                                     int ctx_len)
-{
-       state->ctx_dma = dma_map_single(jrdev, state->caam_ctx,
-                                       ctx_len, DMA_FROM_DEVICE);
-       if (dma_mapping_error(jrdev, state->ctx_dma)) {
-               dev_err(jrdev, "unable to map ctx\n");
-               return -ENOMEM;
-       }
-
-       SEQOUTPTR(p, state->ctx_dma, ctx_len, EXT);
-
-       return 0;
-}
-
-/* Map req->result, and append seq_out_ptr command that points to it */
-static inline dma_addr_t map_seq_out_ptr_result(struct program *p,
-                                               struct device *jrdev,
-                                               u8 *result, int digestsize)
-{
-       dma_addr_t dst_dma;
-
-       dst_dma = dma_map_single(jrdev, result, digestsize, DMA_FROM_DEVICE);
-       SEQOUTPTR(p, dst_dma, digestsize, EXT);
-
-       return dst_dma;
-}
-
 /* Map current buffer in state and put it in link table */
 static inline dma_addr_t buf_map_to_sec4_sg(struct device *jrdev,
                                            struct sec4_sg_entry *sec4_sg,
@@ -225,64 +195,46 @@ static inline int ctx_map_to_sec4_sg(u32 *desc, struct 
device *jrdev,
        return 0;
 }
 
-/* Common shared descriptor commands */
-static inline void append_key_ahash(struct program *p,
-                                   struct caam_hash_ctx *ctx)
+/*
+ * For ahash update, final and finup (import_ctx = true)
+ *     import context, read and write to seqout
+ * For ahash firsts and digest (import_ctx = false)
+ *     read and write to seqout
+ */
+static inline void ahash_gen_sh_desc(u32 *desc, u32 state, int digestsize,
+                                    struct caam_hash_ctx *ctx, bool import_ctx)
 {
-       KEY(p, MDHA_SPLIT_KEY, ENC, (uintptr_t)ctx->key,
-           ctx->split_key_len, IMMED | COPY);
-}
+       u32 op = ctx->alg_type;
+       struct program prg;
+       struct program *p = &prg;
+       LABEL(skip_key_load);
+       REFERENCE(pskip_key_load);
 
-/* Append key if it has been set */
-static inline void init_sh_desc_key_ahash(struct program *p,
-                                         struct caam_hash_ctx *ctx)
-{
-       LABEL(key_jump_cmd);
-       REFERENCE(pkey_jump_cmd);
+       PROGRAM_CNTXT_INIT(p, desc, 0);
+       if (ps)
+               PROGRAM_SET_36BIT_ADDR(p);
 
        SHR_HDR(p, SHR_SERIAL, 1, 0);
 
-       if (ctx->split_key_len) {
-               /* Skip if already shared */
-               pkey_jump_cmd = JUMP(p, key_jump_cmd, LOCAL_JUMP, ALL_TRUE,
-                                    SHRD);
+       /* Append key if it has been set; ahash update excluded */
+       if ((state != OP_ALG_AS_UPDATE) && (ctx->split_key_len)) {
+               /* Skip key loading if already shared */
+               pskip_key_load = JUMP(p, skip_key_load, LOCAL_JUMP, ALL_TRUE,
+                                     SHRD);
 
-               append_key_ahash(p, ctx);
+               KEY(p, MDHA_SPLIT_KEY, ENC, (uintptr_t)ctx->key,
+                   ctx->split_key_len, IMMED | COPY);
 
-               SET_LABEL(p, key_jump_cmd);
+               SET_LABEL(p, skip_key_load);
 
-               PATCH_JUMP(p, pkey_jump_cmd, key_jump_cmd);
-       }
-}
+               PATCH_JUMP(p, pskip_key_load, skip_key_load);
 
-/*
- * For ahash read data from seqin following state->caam_ctx,
- * and write resulting class2 context to seqout, which may be state->caam_ctx
- * or req->result
- */
-static inline void ahash_append_load_str(struct program *p, int digestsize)
-{
-       /* Calculate remaining bytes to read */
-       MATHB(p, SEQINSZ, ADD, MATH0, VSEQINSZ, CAAM_CMD_SZ, 0);
-
-       /* Read remaining bytes */
-       SEQFIFOLOAD(p, MSG2, 0, VLF | LAST2);
-
-       /* Store class2 context bytes */
-       SEQSTORE(p, CONTEXT2, 0, digestsize, 0);
-}
-
-/*
- * For ahash update, final and finup, import context, read and write to seqout
- */
-static inline void ahash_ctx_data_to_out(struct program *p, u32 op, u32 state,
-                                        int digestsize,
-                                        struct caam_hash_ctx *ctx)
-{
-       init_sh_desc_key_ahash(p, ctx);
+               op |= OP_ALG_AAI_HMAC_PRECOMP;
+       }
 
-       /* Import context from software */
-       SEQLOAD(p, CONTEXT2, 0, ctx->ctx_len, 0);
+       /* If needed, import context from software */
+       if (import_ctx)
+               SEQLOAD(p, CONTEXT2, 0, ctx->ctx_len, 0);
 
        /* Class 2 operation */
        ALG_OPERATION(p, op & OP_ALG_ALGSEL_MASK, op & OP_ALG_AAI_MASK, state,
@@ -290,24 +242,15 @@ static inline void ahash_ctx_data_to_out(struct program 
*p, u32 op, u32 state,
 
        /*
         * Load from buf and/or src and write to req->result or state->context
+        * Calculate remaining bytes to read
         */
-       ahash_append_load_str(p, digestsize);
-}
-
-/* For ahash firsts and digest, read and write to seqout */
-static inline void ahash_data_to_out(struct program *p, u32 op, u32 state,
-                                    int digestsize, struct caam_hash_ctx *ctx)
-{
-       init_sh_desc_key_ahash(p, ctx);
-
-       /* Class 2 operation */
-       ALG_OPERATION(p, op & OP_ALG_ALGSEL_MASK, op & OP_ALG_AAI_MASK, state,
-                     ICV_CHECK_DISABLE, DIR_ENC);
+       MATHB(p, SEQINSZ, ADD, MATH0, VSEQINSZ, CAAM_CMD_SZ, 0);
+       /* Read remaining bytes */
+       SEQFIFOLOAD(p, MSG2, 0, VLF | LAST2);
+       /* Store class2 context bytes */
+       SEQSTORE(p, CONTEXT2, 0, digestsize, 0);
 
-       /*
-        * Load from buf and/or src and write to req->result or state->context
-        */
-       ahash_append_load_str(p, digestsize);
+       PROGRAM_FINALIZE(p);
 }
 
 static int ahash_set_sh_desc(struct crypto_ahash *ahash)
@@ -315,35 +258,11 @@ static int ahash_set_sh_desc(struct crypto_ahash *ahash)
        struct caam_hash_ctx *ctx = crypto_ahash_ctx(ahash);
        int digestsize = crypto_ahash_digestsize(ahash);
        struct device *jrdev = ctx->jrdev;
-       u32 have_key = 0;
        u32 *desc;
-       struct program prg;
-       struct program *p = &prg;
-
-       if (ctx->split_key_len)
-               have_key = OP_ALG_AAI_HMAC_PRECOMP;
 
        /* ahash_update shared descriptor */
        desc = ctx->sh_desc_update;
-       PROGRAM_CNTXT_INIT(p, desc, 0);
-       if (ps)
-               PROGRAM_SET_36BIT_ADDR(p);
-
-       SHR_HDR(p, SHR_SERIAL, 1, 0);
-
-       /* Import context from software */
-       SEQLOAD(p, CONTEXT2, 0, ctx->ctx_len, 0);
-
-       /* Class 2 operation */
-       ALG_OPERATION(p, ctx->alg_type & OP_ALG_ALGSEL_MASK,
-                     ctx->alg_type & OP_ALG_AAI_MASK, OP_ALG_AS_UPDATE,
-                     ICV_CHECK_DISABLE, DIR_ENC);
-
-       /* Load data and write to result or context */
-       ahash_append_load_str(p, ctx->ctx_len);
-
-       PROGRAM_FINALIZE(p);
-
+       ahash_gen_sh_desc(desc, OP_ALG_AS_UPDATE, ctx->ctx_len, ctx, true);
        ctx->sh_desc_update_dma = dma_map_single(jrdev, desc, DESC_BYTES(desc),
                                                 DMA_TO_DEVICE);
        if (dma_mapping_error(jrdev, ctx->sh_desc_update_dma)) {
@@ -358,15 +277,7 @@ static int ahash_set_sh_desc(struct crypto_ahash *ahash)
 
        /* ahash_update_first shared descriptor */
        desc = ctx->sh_desc_update_first;
-       PROGRAM_CNTXT_INIT(p, desc, 0);
-       if (ps)
-               PROGRAM_SET_36BIT_ADDR(p);
-
-       ahash_data_to_out(p, have_key | ctx->alg_type, OP_ALG_AS_INIT,
-                         ctx->ctx_len, ctx);
-
-       PROGRAM_FINALIZE(p);
-
+       ahash_gen_sh_desc(desc,  OP_ALG_AS_INIT, ctx->ctx_len, ctx, false);
        ctx->sh_desc_update_first_dma = dma_map_single(jrdev, desc,
                                                       DESC_BYTES(desc),
                                                       DMA_TO_DEVICE);
@@ -382,15 +293,7 @@ static int ahash_set_sh_desc(struct crypto_ahash *ahash)
 
        /* ahash_final shared descriptor */
        desc = ctx->sh_desc_fin;
-       PROGRAM_CNTXT_INIT(p, desc, 0);
-       if (ps)
-               PROGRAM_SET_36BIT_ADDR(p);
-
-       ahash_ctx_data_to_out(p, have_key | ctx->alg_type, OP_ALG_AS_FINALIZE,
-                             digestsize, ctx);
-
-       PROGRAM_FINALIZE(p);
-
+       ahash_gen_sh_desc(desc, OP_ALG_AS_FINALIZE, digestsize, ctx, true);
        ctx->sh_desc_fin_dma = dma_map_single(jrdev, desc, DESC_BYTES(desc),
                                              DMA_TO_DEVICE);
        if (dma_mapping_error(jrdev, ctx->sh_desc_fin_dma)) {
@@ -404,15 +307,7 @@ static int ahash_set_sh_desc(struct crypto_ahash *ahash)
 
        /* ahash_finup shared descriptor */
        desc = ctx->sh_desc_finup;
-       PROGRAM_CNTXT_INIT(p, desc, 0);
-       if (ps)
-               PROGRAM_SET_36BIT_ADDR(p);
-
-       ahash_ctx_data_to_out(p, have_key | ctx->alg_type, OP_ALG_AS_FINALIZE,
-                             digestsize, ctx);
-
-       PROGRAM_FINALIZE(p);
-
+       ahash_gen_sh_desc(desc, OP_ALG_AS_FINALIZE, digestsize, ctx, true);
        ctx->sh_desc_finup_dma = dma_map_single(jrdev, desc, DESC_BYTES(desc),
                                                DMA_TO_DEVICE);
        if (dma_mapping_error(jrdev, ctx->sh_desc_finup_dma)) {
@@ -426,15 +321,7 @@ static int ahash_set_sh_desc(struct crypto_ahash *ahash)
 
        /* ahash_digest shared descriptor */
        desc = ctx->sh_desc_digest;
-       PROGRAM_CNTXT_INIT(p, desc, 0);
-       if (ps)
-               PROGRAM_SET_36BIT_ADDR(p);
-
-       ahash_data_to_out(p, have_key | ctx->alg_type, OP_ALG_AS_INITFINAL,
-                         digestsize, ctx);
-
-       PROGRAM_FINALIZE(p);
-
+       ahash_gen_sh_desc(desc, OP_ALG_AS_INITFINAL, digestsize, ctx, false);
        ctx->sh_desc_digest_dma = dma_map_single(jrdev, desc, DESC_BYTES(desc),
                                                 DMA_TO_DEVICE);
        if (dma_mapping_error(jrdev, ctx->sh_desc_digest_dma)) {
@@ -891,7 +778,6 @@ static int ahash_update_ctx(struct ahash_request *req)
                SEQINPTR(p, edesc->sec4_sg_dma, ctx->ctx_len + to_hash,
                         SGF | EXT);
                SEQOUTPTR(p, state->ctx_dma, ctx->ctx_len, EXT);
-
                PROGRAM_FINALIZE(p);
 
 #ifdef DEBUG
@@ -956,17 +842,17 @@ static int ahash_final_ctx(struct ahash_request *req)
                return -ENOMEM;
        }
 
-       sh_len = DESC_LEN(sh_desc);
        desc = edesc->hw_desc;
-       PROGRAM_CNTXT_INIT(p, desc, sh_len);
-       if (ps)
-               PROGRAM_SET_36BIT_ADDR(p);
-
-       JOB_HDR(p, SHR_DEFER, sh_len, ptr, REO | SHR);
-
        edesc->sec4_sg_bytes = sec4_sg_bytes;
        edesc->sec4_sg = (void *)edesc + sizeof(struct ahash_edesc) +
                         DESC_JOB_IO_LEN;
+       edesc->dst_dma = dma_map_single(jrdev, req->result, digestsize,
+                                       DMA_FROM_DEVICE);
+       if (dma_mapping_error(jrdev, edesc->dst_dma)) {
+               dev_err(jrdev, "unable to map dst\n");
+               return -ENOMEM;
+       }
+
        edesc->src_nents = 0;
 
        ret = ctx_map_to_sec4_sg(desc, jrdev, state, ctx->ctx_len,
@@ -979,6 +865,12 @@ static int ahash_final_ctx(struct ahash_request *req)
                                                last_buflen);
        (edesc->sec4_sg + sec4_sg_bytes - 1)->len |= SEC4_SG_LEN_FIN;
 
+       sh_len = DESC_LEN(sh_desc);
+       PROGRAM_CNTXT_INIT(p, desc, sh_len);
+       if (ps)
+               PROGRAM_SET_36BIT_ADDR(p);
+       JOB_HDR(p, SHR_DEFER, sh_len, ptr, REO | SHR);
+
        edesc->sec4_sg_dma = dma_map_single(jrdev, edesc->sec4_sg,
                                            sec4_sg_bytes, DMA_TO_DEVICE);
        if (dma_mapping_error(jrdev, edesc->sec4_sg_dma)) {
@@ -987,14 +879,7 @@ static int ahash_final_ctx(struct ahash_request *req)
        }
 
        SEQINPTR(p, edesc->sec4_sg_dma, ctx->ctx_len + buflen, SGF | EXT);
-
-       edesc->dst_dma = map_seq_out_ptr_result(p, jrdev, req->result,
-                                               digestsize);
-       if (dma_mapping_error(jrdev, edesc->dst_dma)) {
-               dev_err(jrdev, "unable to map dst\n");
-               return -ENOMEM;
-       }
-
+       SEQOUTPTR(p, edesc->dst_dma, digestsize, EXT);
        PROGRAM_FINALIZE(p);
 
 #ifdef DEBUG
@@ -1050,19 +935,18 @@ static int ahash_finup_ctx(struct ahash_request *req)
                return -ENOMEM;
        }
 
-       sh_len = DESC_LEN(sh_desc);
        desc = edesc->hw_desc;
-       PROGRAM_CNTXT_INIT(p, desc, sh_len);
-       if (ps)
-               PROGRAM_SET_36BIT_ADDR(p);
-
-       JOB_HDR(p, SHR_DEFER, sh_len, ptr, REO | SHR);
-
        edesc->src_nents = src_nents;
        edesc->chained = chained;
        edesc->sec4_sg_bytes = sec4_sg_bytes;
        edesc->sec4_sg = (void *)edesc + sizeof(struct ahash_edesc) +
                         DESC_JOB_IO_LEN;
+       edesc->dst_dma = dma_map_single(jrdev, req->result, digestsize,
+                                       DMA_FROM_DEVICE);
+       if (dma_mapping_error(jrdev, edesc->dst_dma)) {
+               dev_err(jrdev, "unable to map dst\n");
+               return -ENOMEM;
+       }
 
        ret = ctx_map_to_sec4_sg(desc, jrdev, state, ctx->ctx_len,
                                 edesc->sec4_sg, DMA_TO_DEVICE);
@@ -1076,6 +960,12 @@ static int ahash_finup_ctx(struct ahash_request *req)
        src_map_to_sec4_sg(jrdev, req->src, src_nents, edesc->sec4_sg +
                           sec4_sg_src_index, chained);
 
+       sh_len = DESC_LEN(sh_desc);
+       PROGRAM_CNTXT_INIT(p, desc, sh_len);
+       if (ps)
+               PROGRAM_SET_36BIT_ADDR(p);
+       JOB_HDR(p, SHR_DEFER, sh_len, ptr, REO | SHR);
+
        edesc->sec4_sg_dma = dma_map_single(jrdev, edesc->sec4_sg,
                                            sec4_sg_bytes, DMA_TO_DEVICE);
        if (dma_mapping_error(jrdev, edesc->sec4_sg_dma)) {
@@ -1085,14 +975,7 @@ static int ahash_finup_ctx(struct ahash_request *req)
 
        SEQINPTR(p, edesc->sec4_sg_dma, ctx->ctx_len + buflen + req->nbytes,
                 SGF | EXT);
-
-       edesc->dst_dma = map_seq_out_ptr_result(p, jrdev, req->result,
-                                               digestsize);
-       if (dma_mapping_error(jrdev, edesc->dst_dma)) {
-               dev_err(jrdev, "unable to map dst\n");
-               return -ENOMEM;
-       }
-
+       SEQOUTPTR(p, edesc->dst_dma, digestsize, EXT);
        PROGRAM_FINALIZE(p);
 
 #ifdef DEBUG
@@ -1146,17 +1029,16 @@ static int ahash_digest(struct ahash_request *req)
        edesc->sec4_sg = (void *)edesc + sizeof(struct ahash_edesc) +
                          DESC_JOB_IO_LEN;
        edesc->sec4_sg_bytes = sec4_sg_bytes;
+       edesc->dst_dma = dma_map_single(jrdev, req->result, digestsize,
+                                       DMA_FROM_DEVICE);
+       if (dma_mapping_error(jrdev, edesc->dst_dma)) {
+               dev_err(jrdev, "unable to map dst\n");
+               return -ENOMEM;
+       }
+
        edesc->src_nents = src_nents;
        edesc->chained = chained;
-
-       sh_len = DESC_LEN(sh_desc);
        desc = edesc->hw_desc;
-       PROGRAM_CNTXT_INIT(p, desc, sh_len);
-       if (ps)
-               PROGRAM_SET_36BIT_ADDR(p);
-
-       JOB_HDR(p, SHR_DEFER, sh_len, ptr, REO | SHR);
-
        if (src_nents) {
                sg_to_sec4_sg_last(req->src, src_nents, edesc->sec4_sg, 0);
                edesc->sec4_sg_dma = dma_map_single(jrdev, edesc->sec4_sg,
@@ -1170,15 +1052,14 @@ static int ahash_digest(struct ahash_request *req)
        } else {
                src_dma = sg_dma_address(req->src);
        }
-       SEQINPTR(p, src_dma, req->nbytes, options);
-
-       edesc->dst_dma = map_seq_out_ptr_result(p, jrdev, req->result,
-                                               digestsize);
-       if (dma_mapping_error(jrdev, edesc->dst_dma)) {
-               dev_err(jrdev, "unable to map dst\n");
-               return -ENOMEM;
-       }
 
+       sh_len = DESC_LEN(sh_desc);
+       PROGRAM_CNTXT_INIT(p, desc, sh_len);
+       if (ps)
+               PROGRAM_SET_36BIT_ADDR(p);
+       JOB_HDR(p, SHR_DEFER, sh_len, ptr, REO | SHR);
+       SEQINPTR(p, src_dma, req->nbytes, options);
+       SEQOUTPTR(p, edesc->dst_dma, digestsize, EXT);
        PROGRAM_FINALIZE(p);
 
 #ifdef DEBUG
@@ -1225,33 +1106,30 @@ static int ahash_final_no_ctx(struct ahash_request *req)
                return -ENOMEM;
        }
 
-       sh_len = DESC_LEN(sh_desc);
+       edesc->src_nents = 0;
        desc = edesc->hw_desc;
-       PROGRAM_CNTXT_INIT(p, desc, sh_len);
-       if (ps)
-               PROGRAM_SET_36BIT_ADDR(p);
-
-       JOB_HDR(p, SHR_DEFER, sh_len, ptr, REO | SHR);
-
        state->buf_dma = dma_map_single(jrdev, buf, buflen, DMA_TO_DEVICE);
        if (dma_mapping_error(jrdev, state->buf_dma)) {
                dev_err(jrdev, "unable to map src\n");
                return -ENOMEM;
        }
 
-       SEQINPTR(p, state->buf_dma, buflen, EXT);
-
-       edesc->dst_dma = map_seq_out_ptr_result(p, jrdev, req->result,
-                                               digestsize);
+       edesc->dst_dma = dma_map_single(jrdev, req->result, digestsize,
+                                       DMA_FROM_DEVICE);
        if (dma_mapping_error(jrdev, edesc->dst_dma)) {
                dev_err(jrdev, "unable to map dst\n");
                return -ENOMEM;
        }
 
+       sh_len = DESC_LEN(sh_desc);
+       PROGRAM_CNTXT_INIT(p, desc, sh_len);
+       if (ps)
+               PROGRAM_SET_36BIT_ADDR(p);
+       JOB_HDR(p, SHR_DEFER, sh_len, ptr, REO | SHR);
+       SEQINPTR(p, state->buf_dma, buflen, EXT);
+       SEQOUTPTR(p, edesc->dst_dma, digestsize, EXT);
        PROGRAM_FINALIZE(p);
 
-       edesc->src_nents = 0;
-
 #ifdef DEBUG
        print_hex_dump(KERN_ERR, "jobdesc@"__stringify(__LINE__)": ",
                       DUMP_PREFIX_ADDRESS, 16, 4, desc, DESC_BYTES(desc), 1);
@@ -1314,6 +1192,7 @@ static int ahash_update_no_ctx(struct ahash_request *req)
                        return -ENOMEM;
                }
 
+               desc = edesc->hw_desc;
                edesc->src_nents = src_nents;
                edesc->chained = chained;
                edesc->sec4_sg_bytes = sec4_sg_bytes;
@@ -1331,12 +1210,17 @@ static int ahash_update_no_ctx(struct ahash_request 
*req)
                        state->current_buf = !state->current_buf;
                }
 
+               state->ctx_dma = dma_map_single(jrdev, state->caam_ctx,
+                                               ctx->ctx_len, DMA_FROM_DEVICE);
+               if (dma_mapping_error(jrdev, state->ctx_dma)) {
+                       dev_err(jrdev, "unable to map ctx\n");
+                       return -ENOMEM;
+               }
+
                sh_len = DESC_LEN(sh_desc);
-               desc = edesc->hw_desc;
                PROGRAM_CNTXT_INIT(p, desc, sh_len);
                if (ps)
                        PROGRAM_SET_36BIT_ADDR(p);
-
                JOB_HDR(p, SHR_DEFER, sh_len, ptr, REO | SHR);
 
                edesc->sec4_sg_dma = dma_map_single(jrdev, edesc->sec4_sg,
@@ -1348,11 +1232,7 @@ static int ahash_update_no_ctx(struct ahash_request *req)
                }
 
                SEQINPTR(p, edesc->sec4_sg_dma, to_hash, SGF | EXT);
-
-               ret = map_seq_out_ptr_ctx(p, jrdev, state, ctx->ctx_len);
-               if (ret)
-                       return ret;
-
+               SEQOUTPTR(p, state->ctx_dma, ctx->ctx_len, EXT);
                PROGRAM_FINALIZE(p);
 
 #ifdef DEBUG
@@ -1425,19 +1305,18 @@ static int ahash_finup_no_ctx(struct ahash_request *req)
                return -ENOMEM;
        }
 
-       sh_len = DESC_LEN(sh_desc);
        desc = edesc->hw_desc;
-       PROGRAM_CNTXT_INIT(p, desc, sh_len);
-       if (ps)
-               PROGRAM_SET_36BIT_ADDR(p);
-
-       JOB_HDR(p, SHR_DEFER, sh_len, ptr, REO | SHR);
-
        edesc->src_nents = src_nents;
        edesc->chained = chained;
        edesc->sec4_sg_bytes = sec4_sg_bytes;
        edesc->sec4_sg = (void *)edesc + sizeof(struct ahash_edesc) +
                         DESC_JOB_IO_LEN;
+       edesc->dst_dma = dma_map_single(jrdev, req->result, digestsize,
+                                       DMA_FROM_DEVICE);
+       if (dma_mapping_error(jrdev, edesc->dst_dma)) {
+               dev_err(jrdev, "unable to map dst\n");
+               return -ENOMEM;
+       }
 
        state->buf_dma = try_buf_map_to_sec4_sg(jrdev, edesc->sec4_sg, buf,
                                                state->buf_dma, buflen,
@@ -1446,6 +1325,12 @@ static int ahash_finup_no_ctx(struct ahash_request *req)
        src_map_to_sec4_sg(jrdev, req->src, src_nents, edesc->sec4_sg + 1,
                           chained);
 
+       sh_len = DESC_LEN(sh_desc);
+       PROGRAM_CNTXT_INIT(p, desc, sh_len);
+       if (ps)
+               PROGRAM_SET_36BIT_ADDR(p);
+       JOB_HDR(p, SHR_DEFER, sh_len, ptr, REO | SHR);
+
        edesc->sec4_sg_dma = dma_map_single(jrdev, edesc->sec4_sg,
                                            sec4_sg_bytes, DMA_TO_DEVICE);
        if (dma_mapping_error(jrdev, edesc->sec4_sg_dma)) {
@@ -1454,14 +1339,7 @@ static int ahash_finup_no_ctx(struct ahash_request *req)
        }
 
        SEQINPTR(p, edesc->sec4_sg_dma, buflen + req->nbytes, SGF | EXT);
-
-       edesc->dst_dma = map_seq_out_ptr_result(p, jrdev, req->result,
-                                               digestsize);
-       if (dma_mapping_error(jrdev, edesc->dst_dma)) {
-               dev_err(jrdev, "unable to map dst\n");
-               return -ENOMEM;
-       }
-
+       SEQOUTPTR(p, edesc->dst_dma, digestsize, EXT);
        PROGRAM_FINALIZE(p);
 
 #ifdef DEBUG
@@ -1528,12 +1406,19 @@ static int ahash_update_first(struct ahash_request *req)
                        return -ENOMEM;
                }
 
+               desc = edesc->hw_desc;
                edesc->src_nents = src_nents;
                edesc->chained = chained;
                edesc->sec4_sg_bytes = sec4_sg_bytes;
                edesc->sec4_sg = (void *)edesc + sizeof(struct ahash_edesc) +
                                 DESC_JOB_IO_LEN;
                edesc->dst_dma = 0;
+               state->ctx_dma = dma_map_single(jrdev, state->caam_ctx,
+                                               ctx->ctx_len, DMA_FROM_DEVICE);
+               if (dma_mapping_error(jrdev, state->ctx_dma)) {
+                       dev_err(jrdev, "unable to map ctx\n");
+                       return -ENOMEM;
+               }
 
                if (src_nents) {
                        sg_to_sec4_sg_last(req->src, src_nents,
@@ -1556,19 +1441,12 @@ static int ahash_update_first(struct ahash_request *req)
                        sg_copy_part(next_buf, req->src, to_hash, req->nbytes);
 
                sh_len = DESC_LEN(sh_desc);
-               desc = edesc->hw_desc;
                PROGRAM_CNTXT_INIT(p, desc, sh_len);
                if (ps)
                        PROGRAM_SET_36BIT_ADDR(p);
-
                JOB_HDR(p, SHR_DEFER, sh_len, ptr, REO | SHR);
-
                SEQINPTR(p, src_dma, to_hash, options);
-
-               ret = map_seq_out_ptr_ctx(p, jrdev, state, ctx->ctx_len);
-               if (ret)
-                       return ret;
-
+               SEQOUTPTR(p, state->ctx_dma, ctx->ctx_len, EXT);
                PROGRAM_FINALIZE(p);
 
 #ifdef DEBUG
-- 
1.8.3.1

--
To unsubscribe from this list: send the line "unsubscribe linux-crypto" in
the body of a message to majord...@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Reply via email to