crypto: talitos - rename first/last to first_desc/last_desc

Previous commit introduces a new last_request variable in the context
structure.

Renaming the first/last existing member variable in the context
structure to improve readability.

Cc: stable@vger.kernel.org
Signed-off-by: Paul Louvel <paul.louvel@bootlin.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>

diff --git a/drivers/crypto/talitos.c b/drivers/crypto/talitos.c
index 4c325fa0eac193c684ff41ab3004815e2bf8c8e1..bc61d0fe35140cc0970535b6ea584ecf5c768301 100644 (file)
--- a/drivers/crypto/talitos.c
+++ b/drivers/crypto/talitos.c
@@ -869,8 +869,8 @@ struct talitos_ahash_req_ctx {
        u8 buf[2][HASH_MAX_BLOCK_SIZE];
        int buf_idx;
        unsigned int swinit;
-       unsigned int first;
-       unsigned int last;
+       unsigned int first_desc;
+       unsigned int last_desc;
        unsigned int last_request;
        unsigned int to_hash_later;
        unsigned int nbuf;
@@ -889,8 +889,8 @@ struct talitos_export_state {
        u32 hw_context[TALITOS_MDEU_MAX_CONTEXT_SIZE / sizeof(u32)];
        u8 buf[HASH_MAX_BLOCK_SIZE];
        unsigned int swinit;
-       unsigned int first;
-       unsigned int last;
+       unsigned int first_desc;
+       unsigned int last_desc;
        unsigned int to_hash_later;
        unsigned int nbuf;
 };
@@ -1722,7 +1722,7 @@ static void common_nonsnoop_hash_unmap(struct device *dev,
        if (desc->next_desc &&
            desc->ptr[5].ptr != desc2->ptr[5].ptr)
                unmap_single_talitos_ptr(dev, &desc2->ptr[5], DMA_FROM_DEVICE);
-       if (req_ctx->last)
+       if (req_ctx->last_desc)
                memcpy(areq->result, req_ctx->hw_context,
                       crypto_ahash_digestsize(tfm));
 
@@ -1759,7 +1759,7 @@ static void ahash_done(struct device *dev,
                 container_of(desc, struct talitos_edesc, desc);
        struct talitos_ahash_req_ctx *req_ctx = ahash_request_ctx(areq);
 
-       if (!req_ctx->last && req_ctx->to_hash_later) {
+       if (!req_ctx->last_desc && req_ctx->to_hash_later) {
                /* Position any partial block for next update/final/finup */
                req_ctx->buf_idx = (req_ctx->buf_idx + 1) & 1;
                req_ctx->nbuf = req_ctx->to_hash_later;
@@ -1825,7 +1825,7 @@ static int common_nonsnoop_hash(struct talitos_edesc *edesc,
        /* first DWORD empty */
 
        /* hash context in */
-       if (!req_ctx->first || req_ctx->swinit) {
+       if (!req_ctx->first_desc || req_ctx->swinit) {
                map_single_talitos_ptr_nosync(dev, &desc->ptr[1],
                                              req_ctx->hw_context_size,
                                              req_ctx->hw_context,
@@ -1833,7 +1833,7 @@ static int common_nonsnoop_hash(struct talitos_edesc *edesc,
                req_ctx->swinit = 0;
        }
        /* Indicate next op is not the first. */
-       req_ctx->first = 0;
+       req_ctx->first_desc = 0;
 
        /* HMAC key */
        if (ctx->keylen)
@@ -1866,7 +1866,7 @@ static int common_nonsnoop_hash(struct talitos_edesc *edesc,
        /* fifth DWORD empty */
 
        /* hash/HMAC out -or- hash context out */
-       if (req_ctx->last)
+       if (req_ctx->last_desc)
                map_single_talitos_ptr(dev, &desc->ptr[5],
                                       crypto_ahash_digestsize(tfm),
                                       req_ctx->hw_context, DMA_FROM_DEVICE);
@@ -1908,7 +1908,7 @@ static int common_nonsnoop_hash(struct talitos_edesc *edesc,
                if (sg_count > 1)
                        sync_needed = true;
                copy_talitos_ptr(&desc2->ptr[5], &desc->ptr[5], is_sec1);
-               if (req_ctx->last)
+               if (req_ctx->last_desc)
                        map_single_talitos_ptr_nosync(dev, &desc->ptr[5],
                                                      req_ctx->hw_context_size,
                                                      req_ctx->hw_context,
@@ -1964,7 +1964,7 @@ static int ahash_process_req_one(struct ahash_request *areq, unsigned int nbytes
        bool is_sec1 = has_ftr_sec1(priv);
        u8 *ctx_buf = req_ctx->buf[req_ctx->buf_idx];
 
-       if (!req_ctx->last && (nbytes + req_ctx->nbuf <= blocksize)) {
+       if (!req_ctx->last_desc && (nbytes + req_ctx->nbuf <= blocksize)) {
                /* Buffer up to one whole block */
                nents = sg_nents_for_len(req_ctx->request_sl, nbytes);
                if (nents < 0) {
@@ -1981,7 +1981,7 @@ static int ahash_process_req_one(struct ahash_request *areq, unsigned int nbytes
        nbytes_to_hash = nbytes + req_ctx->nbuf;
        to_hash_later = nbytes_to_hash & (blocksize - 1);
 
-       if (req_ctx->last)
+       if (req_ctx->last_desc)
                to_hash_later = 0;
        else if (to_hash_later)
                /* There is a partial block. Hash the full block(s) now */
@@ -2041,19 +2041,19 @@ static int ahash_process_req_one(struct ahash_request *areq, unsigned int nbytes
        edesc->desc.hdr = ctx->desc_hdr_template;
 
        /* On last one, request SEC to pad; otherwise continue */
-       if (req_ctx->last)
+       if (req_ctx->last_desc)
                edesc->desc.hdr |= DESC_HDR_MODE0_MDEU_PAD;
        else
                edesc->desc.hdr |= DESC_HDR_MODE0_MDEU_CONT;
 
        /* request SEC to INIT hash. */
-       if (req_ctx->first && !req_ctx->swinit)
+       if (req_ctx->first_desc && !req_ctx->swinit)
                edesc->desc.hdr |= DESC_HDR_MODE0_MDEU_INIT;
 
        /* When the tfm context has a keylen, it's an HMAC.
         * A first or last (ie. not middle) descriptor must request HMAC.
         */
-       if (ctx->keylen && (req_ctx->first || req_ctx->last))
+       if (ctx->keylen && (req_ctx->first_desc || req_ctx->last_desc))
                edesc->desc.hdr |= DESC_HDR_MODE0_MDEU_HMAC;
 
        return common_nonsnoop_hash(edesc, req_ctx->areq, nbytes_to_hash, ahash_done);
@@ -2076,7 +2076,7 @@ static void sec1_ahash_process_remaining(struct work_struct *work)
                        req_ctx->remaining_ahash_request_bytes;
 
                if (req_ctx->last_request)
-                       req_ctx->last = 1;
+                       req_ctx->last_desc = 1;
        }
 
        err = ahash_process_req_one(req_ctx->areq,
@@ -2103,7 +2103,7 @@ static int ahash_process_req(struct ahash_request *areq, unsigned int nbytes)
                if (nbytes > TALITOS1_MAX_DATA_LEN)
                        nbytes = TALITOS1_MAX_DATA_LEN;
                else if (req_ctx->last_request)
-                       req_ctx->last = 1;
+                       req_ctx->last_desc = 1;
        }
 
        req_ctx->current_ahash_request_bytes = nbytes;
@@ -2124,14 +2124,14 @@ static int ahash_init(struct ahash_request *areq)
        /* Initialize the context */
        req_ctx->buf_idx = 0;
        req_ctx->nbuf = 0;
-       req_ctx->first = 1; /* first indicates h/w must init its context */
+       req_ctx->first_desc = 1; /* first_desc indicates h/w must init its context */
        req_ctx->swinit = 0; /* assume h/w init of context */
        size =  (crypto_ahash_digestsize(tfm) <= SHA256_DIGEST_SIZE)
                        ? TALITOS_MDEU_CONTEXT_SIZE_MD5_SHA1_SHA256
                        : TALITOS_MDEU_CONTEXT_SIZE_SHA384_SHA512;
        req_ctx->hw_context_size = size;
        req_ctx->last_request = 0;
-       req_ctx->last = 0;
+       req_ctx->last_desc = 0;
        INIT_WORK(&req_ctx->sec1_ahash_process_remaining, sec1_ahash_process_remaining);
 
        dma = dma_map_single(dev, req_ctx->hw_context, req_ctx->hw_context_size,
@@ -2224,8 +2224,8 @@ static int ahash_export(struct ahash_request *areq, void *out)
               req_ctx->hw_context_size);
        memcpy(export->buf, req_ctx->buf[req_ctx->buf_idx], req_ctx->nbuf);
        export->swinit = req_ctx->swinit;
-       export->first = req_ctx->first;
-       export->last = req_ctx->last;
+       export->first_desc = req_ctx->first_desc;
+       export->last_desc = req_ctx->last_desc;
        export->to_hash_later = req_ctx->to_hash_later;
        export->nbuf = req_ctx->nbuf;
 
@@ -2250,8 +2250,8 @@ static int ahash_import(struct ahash_request *areq, const void *in)
        memcpy(req_ctx->hw_context, export->hw_context, size);
        memcpy(req_ctx->buf[0], export->buf, export->nbuf);
        req_ctx->swinit = export->swinit;
-       req_ctx->first = export->first;
-       req_ctx->last = export->last;
+       req_ctx->first_desc = export->first_desc;
+       req_ctx->last_desc = export->last_desc;
        req_ctx->to_hash_later = export->to_hash_later;
        req_ctx->nbuf = export->nbuf;