From: Boris Brezillon Subject: Re: [PATCH v2 05/10] crypto: marvell: Move tdma chain out of mv_cesa_tdma_req and remove it Date: Fri, 17 Jun 2016 15:02:44 +0200 Message-ID: <20160617150244.12f3b575@bbrezillon> References: <1466162649-29911-1-git-send-email-romain.perier@free-electrons.com> <1466162649-29911-6-git-send-email-romain.perier@free-electrons.com> Mime-Version: 1.0 Content-Type: text/plain; charset=US-ASCII Content-Transfer-Encoding: 7bit Cc: Arnaud Ebalard , Gregory Clement , Thomas Petazzoni , "David S. Miller" , Russell King , linux-crypto@vger.kernel.org, linux-arm-kernel@lists.infradead.org To: Romain Perier Return-path: Received: from down.free-electrons.com ([37.187.137.238]:51670 "EHLO mail.free-electrons.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1751309AbcFQNCw (ORCPT ); Fri, 17 Jun 2016 09:02:52 -0400 In-Reply-To: <1466162649-29911-6-git-send-email-romain.perier@free-electrons.com> Sender: linux-crypto-owner@vger.kernel.org List-ID: On Fri, 17 Jun 2016 13:24:04 +0200 Romain Perier wrote: > Currently, the only way to access the tdma chain is to use the 'req' > union from a mv_cesa_{ablkcipher,ahash}. This will soon become a problem > if we want to handle the TDMA chaining vs standard/non-DMA processing in > a generic way (with generic functions at the cesa.c level detecting > whether the request should be queued at the DMA level or not). Hence the > decision to move the chain field a the mv_cesa_req level at the expense > of adding 2 void * fields to all request contexts (including non-DMA > ones) and to remove the type completly. To limit the overhead, we get > rid of the type field, which can now be deduced from the req->chain.first > value. Once these changes are done the union is no longer needed, so > remove it and move mv_cesa_ablkcipher_std_req and mv_cesa_req > to mv_cesa_ablkcipher_req directly. There are also no needs to keep the > 'base' field into the union of mv_cesa_ahash_req, so move it into the > upper structure. > > Signed-off-by: Romain Perier Acked-by: Boris Brezillon > --- > > Changes in v2: > - Reworded the commit log > - In mv_cesa_ablkcipher_req moved 'base' and 'std' into the upper > structure. Also removed the union > - Removed 'base' from mv_cesa_ablkcipher_std_req > - In mv_cesa_hash_req moved 'base' into the upper structure > - Remove 'base' from mv_cesa_ahash_std_req and mv_cesa_ahash_dma_req > - Cosmetic changes: variables renaming, missing blank lines > - Replaced the test in mv_cesa_ahash_req_init from > 'mv_cesa_req_get_type == CESA_DMA_REQ' to 'cesa_dev->caps->has_tdma', > now mv_cesa_hash_dma_req_init is really called. > > drivers/crypto/marvell/cesa.c | 3 +- > drivers/crypto/marvell/cesa.h | 44 ++++++++++----------------- > drivers/crypto/marvell/cipher.c | 66 +++++++++++++++++++++-------------------- > drivers/crypto/marvell/hash.c | 64 ++++++++++++++++++--------------------- > drivers/crypto/marvell/tdma.c | 8 ++--- > 5 files changed, 85 insertions(+), 100 deletions(-) > > diff --git a/drivers/crypto/marvell/cesa.c b/drivers/crypto/marvell/cesa.c > index 93700cd..fe04d1b 100644 > --- a/drivers/crypto/marvell/cesa.c > +++ b/drivers/crypto/marvell/cesa.c > @@ -111,7 +111,8 @@ static irqreturn_t mv_cesa_int(int irq, void *priv) > return ret; > } > > -int mv_cesa_queue_req(struct crypto_async_request *req) > +int mv_cesa_queue_req(struct crypto_async_request *req, > + struct mv_cesa_req *creq) > { > int ret; > int i; > diff --git a/drivers/crypto/marvell/cesa.h b/drivers/crypto/marvell/cesa.h > index 685a627..e67e3f1 100644 > --- a/drivers/crypto/marvell/cesa.h > +++ b/drivers/crypto/marvell/cesa.h > @@ -509,21 +509,11 @@ enum mv_cesa_req_type { > > /** > * struct mv_cesa_req - CESA request > - * @type: request type > * @engine: engine associated with this request > + * @chain: list of tdma descriptors associated with this request > */ > struct mv_cesa_req { > - enum mv_cesa_req_type type; > struct mv_cesa_engine *engine; > -}; > - > -/** > - * struct mv_cesa_tdma_req - CESA TDMA request > - * @base: base information > - * @chain: TDMA chain > - */ > -struct mv_cesa_tdma_req { > - struct mv_cesa_req base; > struct mv_cesa_tdma_chain chain; > }; > > @@ -540,13 +530,11 @@ struct mv_cesa_sg_std_iter { > > /** > * struct mv_cesa_ablkcipher_std_req - cipher standard request > - * @base: base information > * @op: operation context > * @offset: current operation offset > * @size: size of the crypto operation > */ > struct mv_cesa_ablkcipher_std_req { > - struct mv_cesa_req base; > struct mv_cesa_op_ctx op; > unsigned int offset; > unsigned int size; > @@ -560,34 +548,27 @@ struct mv_cesa_ablkcipher_std_req { > * @dst_nents: number of entries in the dest sg list > */ > struct mv_cesa_ablkcipher_req { > - union { > - struct mv_cesa_req base; > - struct mv_cesa_tdma_req dma; > - struct mv_cesa_ablkcipher_std_req std; > - } req; > + struct mv_cesa_req base; > + struct mv_cesa_ablkcipher_std_req std; > int src_nents; > int dst_nents; > }; > > /** > * struct mv_cesa_ahash_std_req - standard hash request > - * @base: base information > * @offset: current operation offset > */ > struct mv_cesa_ahash_std_req { > - struct mv_cesa_req base; > unsigned int offset; > }; > > /** > * struct mv_cesa_ahash_dma_req - DMA hash request > - * @base: base information > * @padding: padding buffer > * @padding_dma: DMA address of the padding buffer > * @cache_dma: DMA address of the cache buffer > */ > struct mv_cesa_ahash_dma_req { > - struct mv_cesa_tdma_req base; > u8 *padding; > dma_addr_t padding_dma; > u8 *cache; > @@ -606,8 +587,8 @@ struct mv_cesa_ahash_dma_req { > * @state: hash state > */ > struct mv_cesa_ahash_req { > + struct mv_cesa_req base; > union { > - struct mv_cesa_req base; > struct mv_cesa_ahash_dma_req dma; > struct mv_cesa_ahash_std_req std; > } req; > @@ -625,6 +606,12 @@ struct mv_cesa_ahash_req { > > extern struct mv_cesa_dev *cesa_dev; > > +static inline enum mv_cesa_req_type > +mv_cesa_req_get_type(struct mv_cesa_req *req) > +{ > + return req->chain.first ? CESA_DMA_REQ : CESA_STD_REQ; > +} > + > static inline void mv_cesa_update_op_cfg(struct mv_cesa_op_ctx *op, > u32 cfg, u32 mask) > { > @@ -697,7 +684,8 @@ static inline bool mv_cesa_mac_op_is_first_frag(const struct mv_cesa_op_ctx *op) > CESA_SA_DESC_CFG_FIRST_FRAG; > } > > -int mv_cesa_queue_req(struct crypto_async_request *req); > +int mv_cesa_queue_req(struct crypto_async_request *req, > + struct mv_cesa_req *creq); > > /* > * Helper function that indicates whether a crypto request needs to be > @@ -767,9 +755,9 @@ static inline bool mv_cesa_req_dma_iter_next_op(struct mv_cesa_dma_iter *iter) > return iter->op_len; > } > > -void mv_cesa_dma_step(struct mv_cesa_tdma_req *dreq); > +void mv_cesa_dma_step(struct mv_cesa_req *dreq); > > -static inline int mv_cesa_dma_process(struct mv_cesa_tdma_req *dreq, > +static inline int mv_cesa_dma_process(struct mv_cesa_req *dreq, > u32 status) > { > if (!(status & CESA_SA_INT_ACC0_IDMA_DONE)) > @@ -781,10 +769,10 @@ static inline int mv_cesa_dma_process(struct mv_cesa_tdma_req *dreq, > return 0; > } > > -void mv_cesa_dma_prepare(struct mv_cesa_tdma_req *dreq, > +void mv_cesa_dma_prepare(struct mv_cesa_req *dreq, > struct mv_cesa_engine *engine); > +void mv_cesa_dma_cleanup(struct mv_cesa_req *dreq); > > -void mv_cesa_dma_cleanup(struct mv_cesa_tdma_req *dreq); > > static inline void > mv_cesa_tdma_desc_iter_init(struct mv_cesa_tdma_chain *chain) > diff --git a/drivers/crypto/marvell/cipher.c b/drivers/crypto/marvell/cipher.c > index ded5feb..ffe0f4a 100644 > --- a/drivers/crypto/marvell/cipher.c > +++ b/drivers/crypto/marvell/cipher.c > @@ -70,22 +70,22 @@ mv_cesa_ablkcipher_dma_cleanup(struct ablkcipher_request *req) > dma_unmap_sg(cesa_dev->dev, req->src, creq->src_nents, > DMA_BIDIRECTIONAL); > } > - mv_cesa_dma_cleanup(&creq->req.dma); > + mv_cesa_dma_cleanup(&creq->base); > } > > static inline void mv_cesa_ablkcipher_cleanup(struct ablkcipher_request *req) > { > struct mv_cesa_ablkcipher_req *creq = ablkcipher_request_ctx(req); > > - if (creq->req.base.type == CESA_DMA_REQ) > + if (mv_cesa_req_get_type(&creq->base) == CESA_DMA_REQ) > mv_cesa_ablkcipher_dma_cleanup(req); > } > > static void mv_cesa_ablkcipher_std_step(struct ablkcipher_request *req) > { > struct mv_cesa_ablkcipher_req *creq = ablkcipher_request_ctx(req); > - struct mv_cesa_ablkcipher_std_req *sreq = &creq->req.std; > - struct mv_cesa_engine *engine = sreq->base.engine; > + struct mv_cesa_ablkcipher_std_req *sreq = &creq->std; > + struct mv_cesa_engine *engine = creq->base.engine; > size_t len = min_t(size_t, req->nbytes - sreq->offset, > CESA_SA_SRAM_PAYLOAD_SIZE); > > @@ -115,8 +115,8 @@ static int mv_cesa_ablkcipher_std_process(struct ablkcipher_request *req, > u32 status) > { > struct mv_cesa_ablkcipher_req *creq = ablkcipher_request_ctx(req); > - struct mv_cesa_ablkcipher_std_req *sreq = &creq->req.std; > - struct mv_cesa_engine *engine = sreq->base.engine; > + struct mv_cesa_ablkcipher_std_req *sreq = &creq->std; > + struct mv_cesa_engine *engine = creq->base.engine; > size_t len; > unsigned int ivsize; > > @@ -140,21 +140,19 @@ static int mv_cesa_ablkcipher_process(struct crypto_async_request *req, > { > struct ablkcipher_request *ablkreq = ablkcipher_request_cast(req); > struct mv_cesa_ablkcipher_req *creq = ablkcipher_request_ctx(ablkreq); > - struct mv_cesa_tdma_req *dreq; > + struct mv_cesa_req *basereq = &creq->base; > unsigned int ivsize; > int ret; > > - if (creq->req.base.type == CESA_STD_REQ) > + if (mv_cesa_req_get_type(basereq) == CESA_STD_REQ) > return mv_cesa_ablkcipher_std_process(ablkreq, status); > > - ret = mv_cesa_dma_process(&creq->req.dma, status); > + ret = mv_cesa_dma_process(basereq, status); > if (ret) > return ret; > > - dreq = &creq->req.dma; > - ivsize = > - crypto_ablkcipher_ivsize(crypto_ablkcipher_reqtfm(ablkreq)); > - memcpy_fromio(ablkreq->info, dreq->chain.last->data, ivsize); > + ivsize = crypto_ablkcipher_ivsize(crypto_ablkcipher_reqtfm(ablkreq)); > + memcpy_fromio(ablkreq->info, basereq->chain.last->data, ivsize); > > return 0; > } > @@ -164,8 +162,8 @@ static void mv_cesa_ablkcipher_step(struct crypto_async_request *req) > struct ablkcipher_request *ablkreq = ablkcipher_request_cast(req); > struct mv_cesa_ablkcipher_req *creq = ablkcipher_request_ctx(ablkreq); > > - if (creq->req.base.type == CESA_DMA_REQ) > - mv_cesa_dma_step(&creq->req.dma); > + if (mv_cesa_req_get_type(&creq->base) == CESA_DMA_REQ) > + mv_cesa_dma_step(&creq->base); > else > mv_cesa_ablkcipher_std_step(ablkreq); > } > @@ -174,17 +172,17 @@ static inline void > mv_cesa_ablkcipher_dma_prepare(struct ablkcipher_request *req) > { > struct mv_cesa_ablkcipher_req *creq = ablkcipher_request_ctx(req); > - struct mv_cesa_tdma_req *dreq = &creq->req.dma; > + struct mv_cesa_req *basereq = &creq->base; > > - mv_cesa_dma_prepare(dreq, dreq->base.engine); > + mv_cesa_dma_prepare(basereq, basereq->engine); > } > > static inline void > mv_cesa_ablkcipher_std_prepare(struct ablkcipher_request *req) > { > struct mv_cesa_ablkcipher_req *creq = ablkcipher_request_ctx(req); > - struct mv_cesa_ablkcipher_std_req *sreq = &creq->req.std; > - struct mv_cesa_engine *engine = sreq->base.engine; > + struct mv_cesa_ablkcipher_std_req *sreq = &creq->std; > + struct mv_cesa_engine *engine = creq->base.engine; > > sreq->size = 0; > sreq->offset = 0; > @@ -197,9 +195,9 @@ static inline void mv_cesa_ablkcipher_prepare(struct crypto_async_request *req, > { > struct ablkcipher_request *ablkreq = ablkcipher_request_cast(req); > struct mv_cesa_ablkcipher_req *creq = ablkcipher_request_ctx(ablkreq); > - creq->req.base.engine = engine; > + creq->base.engine = engine; > > - if (creq->req.base.type == CESA_DMA_REQ) > + if (mv_cesa_req_get_type(&creq->base) == CESA_DMA_REQ) > mv_cesa_ablkcipher_dma_prepare(ablkreq); > else > mv_cesa_ablkcipher_std_prepare(ablkreq); > @@ -302,16 +300,15 @@ static int mv_cesa_ablkcipher_dma_req_init(struct ablkcipher_request *req, > struct mv_cesa_ablkcipher_req *creq = ablkcipher_request_ctx(req); > gfp_t flags = (req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP) ? > GFP_KERNEL : GFP_ATOMIC; > - struct mv_cesa_tdma_req *dreq = &creq->req.dma; > + struct mv_cesa_req *basereq = &creq->base; > struct mv_cesa_ablkcipher_dma_iter iter; > struct mv_cesa_tdma_chain chain; > bool skip_ctx = false; > int ret; > unsigned int ivsize; > > - dreq->base.type = CESA_DMA_REQ; > - dreq->chain.first = NULL; > - dreq->chain.last = NULL; > + basereq->chain.first = NULL; > + basereq->chain.last = NULL; > > if (req->src != req->dst) { > ret = dma_map_sg(cesa_dev->dev, req->src, creq->src_nents, > @@ -374,12 +371,12 @@ static int mv_cesa_ablkcipher_dma_req_init(struct ablkcipher_request *req, > if (ret) > goto err_free_tdma; > > - dreq->chain = chain; > + basereq->chain = chain; > > return 0; > > err_free_tdma: > - mv_cesa_dma_cleanup(dreq); > + mv_cesa_dma_cleanup(basereq); > if (req->dst != req->src) > dma_unmap_sg(cesa_dev->dev, req->dst, creq->dst_nents, > DMA_FROM_DEVICE); > @@ -396,11 +393,13 @@ mv_cesa_ablkcipher_std_req_init(struct ablkcipher_request *req, > const struct mv_cesa_op_ctx *op_templ) > { > struct mv_cesa_ablkcipher_req *creq = ablkcipher_request_ctx(req); > - struct mv_cesa_ablkcipher_std_req *sreq = &creq->req.std; > + struct mv_cesa_ablkcipher_std_req *sreq = &creq->std; > + struct mv_cesa_req *basereq = &creq->base; > > - sreq->base.type = CESA_STD_REQ; > sreq->op = *op_templ; > sreq->skip_ctx = false; > + basereq->chain.first = NULL; > + basereq->chain.last = NULL; > > return 0; > } > @@ -442,6 +441,7 @@ static int mv_cesa_ablkcipher_req_init(struct ablkcipher_request *req, > static int mv_cesa_des_op(struct ablkcipher_request *req, > struct mv_cesa_op_ctx *tmpl) > { > + struct mv_cesa_ablkcipher_req *creq = ablkcipher_request_ctx(req); > struct mv_cesa_des_ctx *ctx = crypto_tfm_ctx(req->base.tfm); > int ret; > > @@ -454,7 +454,7 @@ static int mv_cesa_des_op(struct ablkcipher_request *req, > if (ret) > return ret; > > - ret = mv_cesa_queue_req(&req->base); > + ret = mv_cesa_queue_req(&req->base, &creq->base); > if (mv_cesa_req_needs_cleanup(&req->base, ret)) > mv_cesa_ablkcipher_cleanup(req); > > @@ -562,6 +562,7 @@ struct crypto_alg mv_cesa_cbc_des_alg = { > static int mv_cesa_des3_op(struct ablkcipher_request *req, > struct mv_cesa_op_ctx *tmpl) > { > + struct mv_cesa_ablkcipher_req *creq = ablkcipher_request_ctx(req); > struct mv_cesa_des3_ctx *ctx = crypto_tfm_ctx(req->base.tfm); > int ret; > > @@ -574,7 +575,7 @@ static int mv_cesa_des3_op(struct ablkcipher_request *req, > if (ret) > return ret; > > - ret = mv_cesa_queue_req(&req->base); > + ret = mv_cesa_queue_req(&req->base, &creq->base); > if (mv_cesa_req_needs_cleanup(&req->base, ret)) > mv_cesa_ablkcipher_cleanup(req); > > @@ -688,6 +689,7 @@ struct crypto_alg mv_cesa_cbc_des3_ede_alg = { > static int mv_cesa_aes_op(struct ablkcipher_request *req, > struct mv_cesa_op_ctx *tmpl) > { > + struct mv_cesa_ablkcipher_req *creq = ablkcipher_request_ctx(req); > struct mv_cesa_aes_ctx *ctx = crypto_tfm_ctx(req->base.tfm); > int ret, i; > u32 *key; > @@ -716,7 +718,7 @@ static int mv_cesa_aes_op(struct ablkcipher_request *req, > if (ret) > return ret; > > - ret = mv_cesa_queue_req(&req->base); > + ret = mv_cesa_queue_req(&req->base, &creq->base); > if (mv_cesa_req_needs_cleanup(&req->base, ret)) > mv_cesa_ablkcipher_cleanup(req); > > diff --git a/drivers/crypto/marvell/hash.c b/drivers/crypto/marvell/hash.c > index 80bddd7..21a4737 100644 > --- a/drivers/crypto/marvell/hash.c > +++ b/drivers/crypto/marvell/hash.c > @@ -103,14 +103,14 @@ static inline void mv_cesa_ahash_dma_cleanup(struct ahash_request *req) > > dma_unmap_sg(cesa_dev->dev, req->src, creq->src_nents, DMA_TO_DEVICE); > mv_cesa_ahash_dma_free_cache(&creq->req.dma); > - mv_cesa_dma_cleanup(&creq->req.dma.base); > + mv_cesa_dma_cleanup(&creq->base); > } > > static inline void mv_cesa_ahash_cleanup(struct ahash_request *req) > { > struct mv_cesa_ahash_req *creq = ahash_request_ctx(req); > > - if (creq->req.base.type == CESA_DMA_REQ) > + if (mv_cesa_req_get_type(&creq->base) == CESA_DMA_REQ) > mv_cesa_ahash_dma_cleanup(req); > } > > @@ -118,7 +118,7 @@ static void mv_cesa_ahash_last_cleanup(struct ahash_request *req) > { > struct mv_cesa_ahash_req *creq = ahash_request_ctx(req); > > - if (creq->req.base.type == CESA_DMA_REQ) > + if (mv_cesa_req_get_type(&creq->base) == CESA_DMA_REQ) > mv_cesa_ahash_dma_last_cleanup(req); > } > > @@ -157,7 +157,7 @@ static void mv_cesa_ahash_std_step(struct ahash_request *req) > { > struct mv_cesa_ahash_req *creq = ahash_request_ctx(req); > struct mv_cesa_ahash_std_req *sreq = &creq->req.std; > - struct mv_cesa_engine *engine = sreq->base.engine; > + struct mv_cesa_engine *engine = creq->base.engine; > struct mv_cesa_op_ctx *op; > unsigned int new_cache_ptr = 0; > u32 frag_mode; > @@ -256,16 +256,16 @@ static int mv_cesa_ahash_std_process(struct ahash_request *req, u32 status) > static inline void mv_cesa_ahash_dma_prepare(struct ahash_request *req) > { > struct mv_cesa_ahash_req *creq = ahash_request_ctx(req); > - struct mv_cesa_tdma_req *dreq = &creq->req.dma.base; > + struct mv_cesa_req *basereq = &creq->base; > > - mv_cesa_dma_prepare(dreq, dreq->base.engine); > + mv_cesa_dma_prepare(basereq, basereq->engine); > } > > static void mv_cesa_ahash_std_prepare(struct ahash_request *req) > { > struct mv_cesa_ahash_req *creq = ahash_request_ctx(req); > struct mv_cesa_ahash_std_req *sreq = &creq->req.std; > - struct mv_cesa_engine *engine = sreq->base.engine; > + struct mv_cesa_engine *engine = creq->base.engine; > > sreq->offset = 0; > mv_cesa_adjust_op(engine, &creq->op_tmpl); > @@ -277,8 +277,8 @@ static void mv_cesa_ahash_step(struct crypto_async_request *req) > struct ahash_request *ahashreq = ahash_request_cast(req); > struct mv_cesa_ahash_req *creq = ahash_request_ctx(ahashreq); > > - if (creq->req.base.type == CESA_DMA_REQ) > - mv_cesa_dma_step(&creq->req.dma.base); > + if (mv_cesa_req_get_type(&creq->base) == CESA_DMA_REQ) > + mv_cesa_dma_step(&creq->base); > else > mv_cesa_ahash_std_step(ahashreq); > } > @@ -287,12 +287,12 @@ static int mv_cesa_ahash_process(struct crypto_async_request *req, u32 status) > { > struct ahash_request *ahashreq = ahash_request_cast(req); > struct mv_cesa_ahash_req *creq = ahash_request_ctx(ahashreq); > - struct mv_cesa_engine *engine = creq->req.base.engine; > + struct mv_cesa_engine *engine = creq->base.engine; > unsigned int digsize; > int ret, i; > > - if (creq->req.base.type == CESA_DMA_REQ) > - ret = mv_cesa_dma_process(&creq->req.dma.base, status); > + if (mv_cesa_req_get_type(&creq->base) == CESA_DMA_REQ) > + ret = mv_cesa_dma_process(&creq->base, status); > else > ret = mv_cesa_ahash_std_process(ahashreq, status); > > @@ -338,9 +338,9 @@ static void mv_cesa_ahash_prepare(struct crypto_async_request *req, > unsigned int digsize; > int i; > > - creq->req.base.engine = engine; > + creq->base.engine = engine; > > - if (creq->req.base.type == CESA_DMA_REQ) > + if (mv_cesa_req_get_type(&creq->base) == CESA_DMA_REQ) > mv_cesa_ahash_dma_prepare(ahashreq); > else > mv_cesa_ahash_std_prepare(ahashreq); > @@ -555,15 +555,14 @@ static int mv_cesa_ahash_dma_req_init(struct ahash_request *req) > struct mv_cesa_ahash_req *creq = ahash_request_ctx(req); > gfp_t flags = (req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP) ? > GFP_KERNEL : GFP_ATOMIC; > - struct mv_cesa_ahash_dma_req *ahashdreq = &creq->req.dma; > - struct mv_cesa_tdma_req *dreq = &ahashdreq->base; > + struct mv_cesa_req *basereq = &creq->base; > struct mv_cesa_ahash_dma_iter iter; > struct mv_cesa_op_ctx *op = NULL; > unsigned int frag_len; > int ret; > > - dreq->chain.first = NULL; > - dreq->chain.last = NULL; > + basereq->chain.first = NULL; > + basereq->chain.last = NULL; > > if (creq->src_nents) { > ret = dma_map_sg(cesa_dev->dev, req->src, creq->src_nents, > @@ -574,14 +573,14 @@ static int mv_cesa_ahash_dma_req_init(struct ahash_request *req) > } > } > > - mv_cesa_tdma_desc_iter_init(&dreq->chain); > + mv_cesa_tdma_desc_iter_init(&basereq->chain); > mv_cesa_ahash_req_iter_init(&iter, req); > > /* > * Add the cache (left-over data from a previous block) first. > * This will never overflow the SRAM size. > */ > - ret = mv_cesa_ahash_dma_add_cache(&dreq->chain, &iter, creq, flags); > + ret = mv_cesa_ahash_dma_add_cache(&basereq->chain, &iter, creq, flags); > if (ret) > goto err_free_tdma; > > @@ -592,7 +591,7 @@ static int mv_cesa_ahash_dma_req_init(struct ahash_request *req) > * data. We intentionally do not add the final op block. > */ > while (true) { > - ret = mv_cesa_dma_add_op_transfers(&dreq->chain, > + ret = mv_cesa_dma_add_op_transfers(&basereq->chain, > &iter.base, > &iter.src, flags); > if (ret) > @@ -603,7 +602,7 @@ static int mv_cesa_ahash_dma_req_init(struct ahash_request *req) > if (!mv_cesa_ahash_req_iter_next_op(&iter)) > break; > > - op = mv_cesa_dma_add_frag(&dreq->chain, &creq->op_tmpl, > + op = mv_cesa_dma_add_frag(&basereq->chain, &creq->op_tmpl, > frag_len, flags); > if (IS_ERR(op)) { > ret = PTR_ERR(op); > @@ -621,10 +620,10 @@ static int mv_cesa_ahash_dma_req_init(struct ahash_request *req) > * operation, which depends whether this is the final request. > */ > if (creq->last_req) > - op = mv_cesa_ahash_dma_last_req(&dreq->chain, &iter, creq, > + op = mv_cesa_ahash_dma_last_req(&basereq->chain, &iter, creq, > frag_len, flags); > else if (frag_len) > - op = mv_cesa_dma_add_frag(&dreq->chain, &creq->op_tmpl, > + op = mv_cesa_dma_add_frag(&basereq->chain, &creq->op_tmpl, > frag_len, flags); > > if (IS_ERR(op)) { > @@ -634,7 +633,7 @@ static int mv_cesa_ahash_dma_req_init(struct ahash_request *req) > > if (op) { > /* Add dummy desc to wait for crypto operation end */ > - ret = mv_cesa_dma_add_dummy_end(&dreq->chain, flags); > + ret = mv_cesa_dma_add_dummy_end(&basereq->chain, flags); > if (ret) > goto err_free_tdma; > } > @@ -648,7 +647,7 @@ static int mv_cesa_ahash_dma_req_init(struct ahash_request *req) > return 0; > > err_free_tdma: > - mv_cesa_dma_cleanup(dreq); > + mv_cesa_dma_cleanup(basereq); > dma_unmap_sg(cesa_dev->dev, req->src, creq->src_nents, DMA_TO_DEVICE); > > err: > @@ -662,11 +661,6 @@ static int mv_cesa_ahash_req_init(struct ahash_request *req, bool *cached) > struct mv_cesa_ahash_req *creq = ahash_request_ctx(req); > int ret; > > - if (cesa_dev->caps->has_tdma) > - creq->req.base.type = CESA_DMA_REQ; > - else > - creq->req.base.type = CESA_STD_REQ; > - > creq->src_nents = sg_nents_for_len(req->src, req->nbytes); > if (creq->src_nents < 0) { > dev_err(cesa_dev->dev, "Invalid number of src SG"); > @@ -680,7 +674,7 @@ static int mv_cesa_ahash_req_init(struct ahash_request *req, bool *cached) > if (*cached) > return 0; > > - if (creq->req.base.type == CESA_DMA_REQ) > + if (cesa_dev->caps->has_tdma) > ret = mv_cesa_ahash_dma_req_init(req); > > return ret; > @@ -700,7 +694,7 @@ static int mv_cesa_ahash_update(struct ahash_request *req) > if (cached) > return 0; > > - ret = mv_cesa_queue_req(&req->base); > + ret = mv_cesa_queue_req(&req->base, &creq->base); > if (mv_cesa_req_needs_cleanup(&req->base, ret)) > mv_cesa_ahash_cleanup(req); > > @@ -725,7 +719,7 @@ static int mv_cesa_ahash_final(struct ahash_request *req) > if (cached) > return 0; > > - ret = mv_cesa_queue_req(&req->base); > + ret = mv_cesa_queue_req(&req->base, &creq->base); > if (mv_cesa_req_needs_cleanup(&req->base, ret)) > mv_cesa_ahash_cleanup(req); > > @@ -750,7 +744,7 @@ static int mv_cesa_ahash_finup(struct ahash_request *req) > if (cached) > return 0; > > - ret = mv_cesa_queue_req(&req->base); > + ret = mv_cesa_queue_req(&req->base, &creq->base); > if (mv_cesa_req_needs_cleanup(&req->base, ret)) > mv_cesa_ahash_cleanup(req); > > diff --git a/drivers/crypto/marvell/tdma.c b/drivers/crypto/marvell/tdma.c > index 01dda58..9d944ad 100644 > --- a/drivers/crypto/marvell/tdma.c > +++ b/drivers/crypto/marvell/tdma.c > @@ -37,9 +37,9 @@ bool mv_cesa_req_dma_iter_next_transfer(struct mv_cesa_dma_iter *iter, > return true; > } > > -void mv_cesa_dma_step(struct mv_cesa_tdma_req *dreq) > +void mv_cesa_dma_step(struct mv_cesa_req *dreq) > { > - struct mv_cesa_engine *engine = dreq->base.engine; > + struct mv_cesa_engine *engine = dreq->engine; > > writel_relaxed(0, engine->regs + CESA_SA_CFG); > > @@ -58,7 +58,7 @@ void mv_cesa_dma_step(struct mv_cesa_tdma_req *dreq) > writel(CESA_SA_CMD_EN_CESA_SA_ACCL0, engine->regs + CESA_SA_CMD); > } > > -void mv_cesa_dma_cleanup(struct mv_cesa_tdma_req *dreq) > +void mv_cesa_dma_cleanup(struct mv_cesa_req *dreq) > { > struct mv_cesa_tdma_desc *tdma; > > @@ -82,7 +82,7 @@ void mv_cesa_dma_cleanup(struct mv_cesa_tdma_req *dreq) > dreq->chain.last = NULL; > } > > -void mv_cesa_dma_prepare(struct mv_cesa_tdma_req *dreq, > +void mv_cesa_dma_prepare(struct mv_cesa_req *dreq, > struct mv_cesa_engine *engine) > { > struct mv_cesa_tdma_desc *tdma;