[PATCH 25/29] crypto: talitos - Dispatch pointer helpers through ptr_ops

[Paul Louvel]

Replace all direct calls to to_talitos_ptr(), copy_talitos_ptr(),
from_talitos_ptr_len(), to_talitos_ptr_ext_set() and
to_talitos_ptr_ext_or() with indirect calls through ctx->ptr_ops
or priv->ptr_ops.

Signed-off-by: Paul Louvel <paul.louvel@xxxxxxxxxxx>
---
 drivers/crypto/talitos/talitos-aead.c     | 18 ++++++------
 drivers/crypto/talitos/talitos-hash.c     | 24 ++++++++--------
 drivers/crypto/talitos/talitos-skcipher.c |  4 +--
 drivers/crypto/talitos/talitos.c          | 47 ++++++++++++++++---------------
 4 files changed, 46 insertions(+), 47 deletions(-)

diff --git a/drivers/crypto/talitos/talitos-aead.c b/drivers/crypto/talitos/talitos-aead.c
index cd1b8e6d371b..b585abdd2275 100644
--- a/drivers/crypto/talitos/talitos-aead.c
+++ b/drivers/crypto/talitos/talitos-aead.c
@@ -216,7 +216,7 @@ static int ipsec_esp(struct talitos_edesc *edesc, struct aead_request *areq,
 	dma_addr_t dma_icv = edesc->dma_link_tbl + edesc->dma_len - authsize;
 
 	/* hmac key */
-	to_talitos_ptr(&desc->ptr[0], ctx->dma_key, ctx->authkeylen, is_sec1);
+	ctx->ptr_ops->to_talitos_ptr(&desc->ptr[0], ctx->dma_key, ctx->authkeylen);
 
 	sg_count = edesc->src_nents ?: 1;
 	if (is_sec1 && sg_count > 1)
@@ -237,11 +237,11 @@ static int ipsec_esp(struct talitos_edesc *edesc, struct aead_request *areq,
 	}
 
 	/* cipher iv */
-	to_talitos_ptr(civ_ptr, edesc->iv_dma, ivsize, is_sec1);
+	ctx->ptr_ops->to_talitos_ptr(civ_ptr, edesc->iv_dma, ivsize);
 
 	/* cipher key */
-	to_talitos_ptr(ckey_ptr, ctx->dma_key  + ctx->authkeylen,
-		       ctx->enckeylen, is_sec1);
+	ctx->ptr_ops->to_talitos_ptr(ckey_ptr, ctx->dma_key  + ctx->authkeylen,
+		       ctx->enckeylen);
 
 	/*
 	 * cipher in
@@ -281,15 +281,15 @@ static int ipsec_esp(struct talitos_edesc *edesc, struct aead_request *areq,
 		struct talitos_ptr *tbl_ptr = &edesc->link_tbl[tbl_off];
 
 		/* Add an entry to the link table for ICV data */
-		to_talitos_ptr_ext_set(tbl_ptr - 1, 0, is_sec1);
-		to_talitos_ptr_ext_set(tbl_ptr, DESC_PTR_LNKTBL_RET, is_sec1);
+		ctx->ptr_ops->to_talitos_ptr_ext_set(tbl_ptr - 1, 0);
+		ctx->ptr_ops->to_talitos_ptr_ext_set(tbl_ptr, DESC_PTR_LNKTBL_RET);
 
 		/* icv data follows link tables */
-		to_talitos_ptr(tbl_ptr, dma_icv, authsize, is_sec1);
-		to_talitos_ptr_ext_or(&desc->ptr[5], authsize, is_sec1);
+		ctx->ptr_ops->to_talitos_ptr(tbl_ptr, dma_icv, authsize);
+		ctx->ptr_ops->to_talitos_ptr_ext_or(&desc->ptr[5], authsize);
 		sync_needed = true;
 	} else if (!encrypt) {
-		to_talitos_ptr(&desc->ptr[6], dma_icv, authsize, is_sec1);
+		ctx->ptr_ops->to_talitos_ptr(&desc->ptr[6], dma_icv, authsize);
 		sync_needed = true;
 	} else if (!is_ipsec_esp) {
 		talitos_sg_map(dev, areq->dst, authsize, edesc, &desc->ptr[6],
diff --git a/drivers/crypto/talitos/talitos-hash.c b/drivers/crypto/talitos/talitos-hash.c
index 9e6d849c3123..026eebf037f5 100644
--- a/drivers/crypto/talitos/talitos-hash.c
+++ b/drivers/crypto/talitos/talitos-hash.c
@@ -36,32 +36,30 @@ struct talitos_export_state {
 	unsigned int to_hash_later;
 };
 
-static void common_nonsnoop_hash_unmap(struct device *dev,
+static void common_nonsnoop_hash_unmap(struct talitos_ctx *ctx,
 				       struct talitos_edesc *edesc,
 				       struct ahash_request *areq)
 {
 	struct talitos_ahash_req_ctx *req_ctx = ahash_request_ctx(areq);
 	struct crypto_ahash *tfm = crypto_ahash_reqtfm(areq);
-	struct talitos_private *priv = dev_get_drvdata(dev);
-	bool is_sec1 = has_ftr_sec1(priv);
 	struct talitos_desc *desc = &edesc->desc;
 
-	unmap_single_talitos_ptr(dev, &desc->ptr[5], DMA_FROM_DEVICE);
+	unmap_single_talitos_ptr(ctx->dev, &desc->ptr[5], DMA_FROM_DEVICE);
 
 	if (edesc->last && req_ctx->last_request)
 		memcpy(areq->result, req_ctx->hw_context,
 		       crypto_ahash_digestsize(tfm));
 
 	if (edesc->src)
-		talitos_sg_unmap(dev, edesc, edesc->src, NULL, 0, 0);
+		talitos_sg_unmap(ctx->dev, edesc, edesc->src, NULL, 0, 0);
 
 	/* When using hashctx-in, must unmap it. */
-	if (from_talitos_ptr_len(&desc->ptr[1], is_sec1))
-		unmap_single_talitos_ptr(dev, &desc->ptr[1],
+	if (ctx->ptr_ops->from_talitos_ptr_len(&desc->ptr[1]))
+		unmap_single_talitos_ptr(ctx->dev, &desc->ptr[1],
 					 DMA_TO_DEVICE);
 
 	if (edesc->dma_len)
-		dma_unmap_single(dev, edesc->dma_link_tbl, edesc->dma_len,
+		dma_unmap_single(ctx->dev, edesc->dma_link_tbl, edesc->dma_len,
 				 DMA_BIDIRECTIONAL);
 }
 
@@ -72,7 +70,7 @@ static void free_edesc_list_from(struct ahash_request *areq, struct talitos_edes
 
 	while (edesc) {
 		next = edesc->next_desc;
-		common_nonsnoop_hash_unmap(ctx->dev, edesc, areq);
+		common_nonsnoop_hash_unmap(ctx, edesc, areq);
 		kfree(edesc);
 		edesc = next;
 	}
@@ -97,7 +95,7 @@ static void ahash_done(struct device *dev,
 	} else {
 		next = edesc->next_desc;
 
-		common_nonsnoop_hash_unmap(dev, edesc, areq);
+		common_nonsnoop_hash_unmap(ctx, edesc, areq);
 		kfree(edesc);
 
 		if (err)
@@ -167,8 +165,8 @@ static void common_nonsnoop_hash(struct talitos_edesc *edesc,
 
 	/* HMAC key */
 	if (ctx->keylen)
-		to_talitos_ptr(&desc->ptr[2], ctx->dma_key, ctx->keylen,
-			       is_sec1);
+		ctx->ptr_ops->to_talitos_ptr(&desc->ptr[2], ctx->dma_key,
+					     ctx->keylen);
 
 	sg_count = edesc->src_nents ?: 1;
 	if (is_sec1 && sg_count > 1)
@@ -199,7 +197,7 @@ static void common_nonsnoop_hash(struct talitos_edesc *edesc,
 
 	/* last DWORD empty */
 
-	if (is_sec1 && from_talitos_ptr_len(&desc->ptr[3], true) == 0)
+	if (is_sec1 && ctx->ptr_ops->from_talitos_ptr_len(&desc->ptr[3]) == 0)
 		talitos_handle_buggy_hash(ctx, edesc, &desc->ptr[3]);
 
 	if (sync_needed)
diff --git a/drivers/crypto/talitos/talitos-skcipher.c b/drivers/crypto/talitos/talitos-skcipher.c
index b12191243aae..a96f827c7b93 100644
--- a/drivers/crypto/talitos/talitos-skcipher.c
+++ b/drivers/crypto/talitos/talitos-skcipher.c
@@ -67,10 +67,10 @@ static int common_nonsnoop(struct talitos_edesc *edesc,
 	/* first DWORD empty */
 
 	/* cipher iv */
-	to_talitos_ptr(&desc->ptr[1], edesc->iv_dma, ivsize, is_sec1);
+	ctx->ptr_ops->to_talitos_ptr(&desc->ptr[1], edesc->iv_dma, ivsize);
 
 	/* cipher key */
-	to_talitos_ptr(&desc->ptr[2], ctx->dma_key, ctx->keylen, is_sec1);
+	ctx->ptr_ops->to_talitos_ptr(&desc->ptr[2], ctx->dma_key, ctx->keylen);
 
 	sg_count = edesc->src_nents ?: 1;
 	if (is_sec1 && sg_count > 1)
diff --git a/drivers/crypto/talitos/talitos.c b/drivers/crypto/talitos/talitos.c
index 0e4bd130ac6d..ff88f3dc3869 100644
--- a/drivers/crypto/talitos/talitos.c
+++ b/drivers/crypto/talitos/talitos.c
@@ -97,9 +97,8 @@ static void __map_single_talitos_ptr(struct device *dev,
 {
 	dma_addr_t dma_addr = dma_map_single_attrs(dev, data, len, dir, attrs);
 	struct talitos_private *priv = dev_get_drvdata(dev);
-	bool is_sec1 = has_ftr_sec1(priv);
 
-	to_talitos_ptr(ptr, dma_addr, len, is_sec1);
+	priv->ptr_ops->to_talitos_ptr(ptr, dma_addr, len);
 }
 
 void map_single_talitos_ptr(struct device *dev,
@@ -127,10 +126,9 @@ void unmap_single_talitos_ptr(struct device *dev,
 			      enum dma_data_direction dir)
 {
 	struct talitos_private *priv = dev_get_drvdata(dev);
-	bool is_sec1 = has_ftr_sec1(priv);
 
 	dma_unmap_single(dev, be32_to_cpu(ptr->ptr),
-			 from_talitos_ptr_len(ptr, is_sec1), dir);
+			 priv->ptr_ops->from_talitos_ptr_len(ptr), dir);
 }
 
 /*
@@ -455,7 +453,8 @@ void talitos_sg_unmap(struct device *dev,
  * convert scatterlist to SEC h/w link table format
  * stop at cryptlen bytes
  */
-static int sg_to_link_tbl_offset(struct scatterlist *sg, int sg_count,
+static int sg_to_link_tbl_offset(const struct talitos_ptr_ops *ptr_ops,
+				 struct scatterlist *sg, int sg_count,
 				 unsigned int offset, int datalen, int elen,
 				 struct talitos_ptr *link_tbl_ptr, int align)
 {
@@ -478,16 +477,16 @@ static int sg_to_link_tbl_offset(struct scatterlist *sg, int sg_count,
 			len = cryptlen;
 
 		if (datalen > 0 && len > datalen) {
-			to_talitos_ptr(link_tbl_ptr + count,
-				       sg_dma_address(sg) + offset, datalen, 0);
-			to_talitos_ptr_ext_set(link_tbl_ptr + count, 0, 0);
+			ptr_ops->to_talitos_ptr(link_tbl_ptr + count,
+				       sg_dma_address(sg) + offset, datalen);
+			ptr_ops->to_talitos_ptr_ext_set(link_tbl_ptr + count, 0);
 			count++;
 			len -= datalen;
 			offset += datalen;
 		}
-		to_talitos_ptr(link_tbl_ptr + count,
-			       sg_dma_address(sg) + offset, sg_next(sg) ? len : len + padding, 0);
-		to_talitos_ptr_ext_set(link_tbl_ptr + count, 0, 0);
+		ptr_ops->to_talitos_ptr(link_tbl_ptr + count,
+			       sg_dma_address(sg) + offset, sg_next(sg) ? len : len + padding);
+		ptr_ops->to_talitos_ptr_ext_set(link_tbl_ptr + count, 0);
 		count++;
 		cryptlen -= len;
 		datalen -= len;
@@ -499,8 +498,8 @@ static int sg_to_link_tbl_offset(struct scatterlist *sg, int sg_count,
 
 	/* tag end of link table */
 	if (count > 0)
-		to_talitos_ptr_ext_set(link_tbl_ptr + count - 1,
-				       DESC_PTR_LNKTBL_RET, 0);
+		ptr_ops->to_talitos_ptr_ext_set(link_tbl_ptr + count - 1,
+				       DESC_PTR_LNKTBL_RET);
 
 	return count;
 }
@@ -512,32 +511,34 @@ int talitos_sg_map_ext(struct device *dev, struct scatterlist *src,
 			      bool force, int align)
 {
 	struct talitos_private *priv = dev_get_drvdata(dev);
+	const struct talitos_ptr_ops *ptr_ops = priv->ptr_ops;
 	bool is_sec1 = has_ftr_sec1(priv);
 	int aligned_len = ALIGN(len, align);
 
 	if (!src) {
-		to_talitos_ptr(ptr, 0, 0, is_sec1);
+		ptr_ops->to_talitos_ptr(ptr, 0, 0);
 		return 1;
 	}
-	to_talitos_ptr_ext_set(ptr, elen, is_sec1);
+	ptr_ops->to_talitos_ptr_ext_set(ptr, elen);
 	if (sg_count == 1 && !force) {
-		to_talitos_ptr(ptr, sg_dma_address(src) + offset, aligned_len, is_sec1);
+		ptr_ops->to_talitos_ptr(ptr, sg_dma_address(src) + offset, aligned_len);
 		return sg_count;
 	}
 	if (is_sec1) {
-		to_talitos_ptr(ptr, edesc->dma_link_tbl + offset, aligned_len, is_sec1);
+		ptr_ops->to_talitos_ptr(ptr, edesc->dma_link_tbl + offset, aligned_len);
 		return sg_count;
 	}
-	sg_count = sg_to_link_tbl_offset(src, sg_count, offset, len, elen,
-					 &edesc->link_tbl[tbl_off], align);
+	sg_count = sg_to_link_tbl_offset(ptr_ops, src, sg_count, offset,
+					 len, elen, &edesc->link_tbl[tbl_off],
+					 align);
 	if (sg_count == 1 && !force) {
 		/* Only one segment now, so no link tbl needed*/
-		copy_talitos_ptr(ptr, &edesc->link_tbl[tbl_off], is_sec1);
+		ptr_ops->copy_talitos_ptr(ptr, &edesc->link_tbl[tbl_off]);
 		return sg_count;
 	}
-	to_talitos_ptr(ptr, edesc->dma_link_tbl +
-			    tbl_off * sizeof(struct talitos_ptr), aligned_len, is_sec1);
-	to_talitos_ptr_ext_or(ptr, DESC_PTR_LNKTBL_JUMP, is_sec1);
+	ptr_ops->to_talitos_ptr(ptr, edesc->dma_link_tbl +
+			    tbl_off * sizeof(struct talitos_ptr), aligned_len);
+	ptr_ops->to_talitos_ptr_ext_or(ptr, DESC_PTR_LNKTBL_JUMP);
 
 	return sg_count;
 }

-- 
2.54.0