Commit e1cb54fd authored by Gilad Ben-Yossef's avatar Gilad Ben-Yossef Committed by Greg Kroah-Hartman
Browse files

staging: ccree: make long func call sites readable 



The driver was using a function naming scheme
including common prefixes for driver global
functions based on the code module they came from.

The combination of long names with long common
prefixes made the whole thing too long for a human
to parse.

Switch to simple and shorter function naming
scheme. Where required, realign parameters and
add paranthesis for better code readability.

Signed-off-by: default avatarGilad Ben-Yossef <gilad@benyossef.com>
Reviewed-by: default avatarDan Carpenter <dan.carpenter@oracle.com>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
parent 988b9ea9

drivers/staging/ccree/ssi_aead.c

+18 −14
Original line number Diff line number Diff line
@@ -233,7 +233,7 @@ static void ssi_aead_complete(struct device *dev, void *ssi_req, void __iomem *c 
	struct ssi_aead_ctx *ctx = crypto_aead_ctx(tfm);

	int err = 0;



	ssi_buffer_mgr_unmap_aead_request(dev, areq);

	cc_unmap_aead_request(dev, areq);



	/* Restore ordinary iv pointer */

	areq->iv = areq_ctx->backup_iv;
@@ -246,17 +246,20 @@ static void ssi_aead_complete(struct device *dev, void *ssi_req, void __iomem *c 
			/* In case of payload authentication failure, MUST NOT

			 * revealed the decrypted message --> zero its memory.

			 */

			ssi_buffer_mgr_zero_sgl(areq->dst, areq_ctx->cryptlen);

			cc_zero_sgl(areq->dst, areq_ctx->cryptlen);

			err = -EBADMSG;

		}

	} else { /*ENCRYPT*/

		if (unlikely(areq_ctx->is_icv_fragmented))

			ssi_buffer_mgr_copy_scatterlist_portion(

				dev, areq_ctx->mac_buf, areq_ctx->dst_sgl,

				areq->cryptlen + areq_ctx->dst_offset,

				(areq->cryptlen + areq_ctx->dst_offset +

		if (unlikely(areq_ctx->is_icv_fragmented)) {

			cc_copy_sg_portion(dev, areq_ctx->mac_buf,

					   areq_ctx->dst_sgl,

					   (areq->cryptlen +

					    areq_ctx->dst_offset),

					   (areq->cryptlen +

					    areq_ctx->dst_offset +

					    ctx->authsize),

					   SSI_SG_FROM_BUF);

		}



		/* If an IV was generated, copy it back to the user provided buffer. */

		if (areq_ctx->backup_giv) {
@@ -2053,7 +2056,7 @@ static int ssi_aead_process(struct aead_request *req, enum drv_crypto_direction 
	}

#endif /*SSI_CC_HAS_AES_GCM*/



	rc = ssi_buffer_mgr_map_aead_request(ctx->drvdata, req);

	rc = cc_map_aead_request(ctx->drvdata, req);

	if (unlikely(rc != 0)) {

		dev_err(dev, "map_request() failed\n");

		goto exit;
@@ -2112,7 +2115,7 @@ static int ssi_aead_process(struct aead_request *req, enum drv_crypto_direction 
#endif

	default:

		dev_err(dev, "Unsupported authenc (%d)\n", ctx->auth_mode);

		ssi_buffer_mgr_unmap_aead_request(dev, req);

		cc_unmap_aead_request(dev, req);

		rc = -ENOTSUPP;

		goto exit;

	}
@@ -2123,7 +2126,7 @@ static int ssi_aead_process(struct aead_request *req, enum drv_crypto_direction 


	if (unlikely(rc != -EINPROGRESS)) {

		dev_err(dev, "send_request() failed (rc=%d)\n", rc);

		ssi_buffer_mgr_unmap_aead_request(dev, req);

		cc_unmap_aead_request(dev, req);

	}



exit:
@@ -2753,8 +2756,9 @@ int ssi_aead_alloc(struct ssi_drvdata *drvdata) 
	INIT_LIST_HEAD(&aead_handle->aead_list);

	drvdata->aead_handle = aead_handle;



	aead_handle->sram_workspace_addr = ssi_sram_mgr_alloc(

		drvdata, MAX_HMAC_DIGEST_SIZE);

	aead_handle->sram_workspace_addr = cc_sram_alloc(drvdata,

							 MAX_HMAC_DIGEST_SIZE);



	if (aead_handle->sram_workspace_addr == NULL_SRAM_ADDR) {

		dev_err(dev, "SRAM pool exhausted\n");

		rc = -ENOMEM;

drivers/staging/ccree/ssi_buffer_mgr.c

+188 −242

File changed.

Preview size limit exceeded, changes collapsed.

drivers/staging/ccree/ssi_buffer_mgr.h

+23 −26
Original line number Diff line number Diff line
@@ -50,42 +50,39 @@ struct mlli_params { 
	u32 mlli_len;

};



int ssi_buffer_mgr_init(struct ssi_drvdata *drvdata);

int cc_buffer_mgr_init(struct ssi_drvdata *drvdata);



int ssi_buffer_mgr_fini(struct ssi_drvdata *drvdata);

int cc_buffer_mgr_fini(struct ssi_drvdata *drvdata);



int ssi_buffer_mgr_map_blkcipher_request(

	struct ssi_drvdata *drvdata,

	void *ctx,

	unsigned int ivsize,

	unsigned int nbytes,

	void *info,

	struct scatterlist *src,

int cc_map_blkcipher_request(struct ssi_drvdata *drvdata, void *ctx,

			     unsigned int ivsize, unsigned int nbytes,

			     void *info, struct scatterlist *src,

			     struct scatterlist *dst);



void ssi_buffer_mgr_unmap_blkcipher_request(

	struct device *dev,

	void *ctx,

void cc_unmap_blkcipher_request(struct device *dev, void *ctx,

				unsigned int ivsize,

				struct scatterlist *src,

				struct scatterlist *dst);



int ssi_buffer_mgr_map_aead_request(struct ssi_drvdata *drvdata, struct aead_request *req);

int cc_map_aead_request(struct ssi_drvdata *drvdata, struct aead_request *req);



void ssi_buffer_mgr_unmap_aead_request(struct device *dev, struct aead_request *req);

void cc_unmap_aead_request(struct device *dev, struct aead_request *req);



int ssi_buffer_mgr_map_hash_request_final(struct ssi_drvdata *drvdata, void *ctx, struct scatterlist *src, unsigned int nbytes, bool do_update);

int cc_map_hash_request_final(struct ssi_drvdata *drvdata, void *ctx,

			      struct scatterlist *src, unsigned int nbytes,

			      bool do_update);



int ssi_buffer_mgr_map_hash_request_update(struct ssi_drvdata *drvdata, void *ctx, struct scatterlist *src, unsigned int nbytes, unsigned int block_size);

int cc_map_hash_request_update(struct ssi_drvdata *drvdata, void *ctx,

			       struct scatterlist *src, unsigned int nbytes,

			       unsigned int block_size);



void ssi_buffer_mgr_unmap_hash_request(struct device *dev, void *ctx, struct scatterlist *src, bool do_revert);

void cc_unmap_hash_request(struct device *dev, void *ctx,

			   struct scatterlist *src, bool do_revert);



void ssi_buffer_mgr_copy_scatterlist_portion(struct device *dev, u8 *dest,

					     struct scatterlist *sg,

					     u32 to_skip, u32 end,

					     enum ssi_sg_cpy_direct direct);

void cc_copy_sg_portion(struct device *dev, u8 *dest, struct scatterlist *sg,

			u32 to_skip, u32 end, enum ssi_sg_cpy_direct direct);



void ssi_buffer_mgr_zero_sgl(struct scatterlist *sgl, u32 data_len);

void cc_zero_sgl(struct scatterlist *sgl, u32 data_len);



#endif /*__BUFFER_MGR_H__*/

drivers/staging/ccree/ssi_cipher.c

+7 −6
Original line number Diff line number Diff line
@@ -694,7 +694,7 @@ static int ssi_blkcipher_complete(struct device *dev, 
	int completion_error = 0;

	struct ablkcipher_request *req = (struct ablkcipher_request *)areq;



	ssi_buffer_mgr_unmap_blkcipher_request(dev, req_ctx, ivsize, src, dst);

	cc_unmap_blkcipher_request(dev, req_ctx, ivsize, src, dst);

	kfree(req_ctx->iv);



	if (areq) {
@@ -786,9 +786,8 @@ static int ssi_blkcipher_process( 


	/* STAT_PHASE_1: Map buffers */



	rc = ssi_buffer_mgr_map_blkcipher_request(ctx_p->drvdata, req_ctx,

						  ivsize, nbytes, req_ctx->iv,

						  src, dst);

	rc = cc_map_blkcipher_request(ctx_p->drvdata, req_ctx, ivsize, nbytes,

				      req_ctx->iv, src, dst);

	if (unlikely(rc != 0)) {

		dev_err(dev, "map_request() failed\n");

		goto exit_process;
@@ -823,12 +822,14 @@ static int ssi_blkcipher_process( 
	if (areq) {

		if (unlikely(rc != -EINPROGRESS)) {

			/* Failed to send the request or request completed synchronously */

			ssi_buffer_mgr_unmap_blkcipher_request(dev, req_ctx, ivsize, src, dst);

			cc_unmap_blkcipher_request(dev, req_ctx, ivsize, src,

						   dst);

		}



	} else {

		if (rc != 0) {

			ssi_buffer_mgr_unmap_blkcipher_request(dev, req_ctx, ivsize, src, dst);

			cc_unmap_blkcipher_request(dev, req_ctx, ivsize, src,

						   dst);

		} else {

			rc = ssi_blkcipher_complete(dev, ctx_p, req_ctx, dst,

						    src, ivsize, NULL,

drivers/staging/ccree/ssi_driver.c

+9 −9
Original line number Diff line number Diff line
@@ -317,7 +317,7 @@ static int init_cc_resources(struct platform_device *plat_dev) 
	}



	new_drvdata->mlli_sram_addr =

		ssi_sram_mgr_alloc(new_drvdata, MAX_MLLI_BUFF_SIZE);

		cc_sram_alloc(new_drvdata, MAX_MLLI_BUFF_SIZE);

	if (unlikely(new_drvdata->mlli_sram_addr == NULL_SRAM_ADDR)) {

		dev_err(dev, "Failed to alloc MLLI Sram buffer\n");

		rc = -ENOMEM;
@@ -330,15 +330,15 @@ static int init_cc_resources(struct platform_device *plat_dev) 
		goto post_sram_mgr_err;

	}



	rc = ssi_buffer_mgr_init(new_drvdata);

	rc = cc_buffer_mgr_init(new_drvdata);

	if (unlikely(rc != 0)) {

		dev_err(dev, "buffer_mgr_init failed\n");

		goto post_req_mgr_err;

	}



	rc = ssi_power_mgr_init(new_drvdata);

	rc = cc_pm_init(new_drvdata);

	if (unlikely(rc != 0)) {

		dev_err(dev, "ssi_power_mgr_init failed\n");

		dev_err(dev, "cc_pm_init failed\n");

		goto post_buf_mgr_err;

	}
@@ -383,9 +383,9 @@ static int init_cc_resources(struct platform_device *plat_dev) 
post_ivgen_err:

	ssi_ivgen_fini(new_drvdata);

post_power_mgr_err:

	ssi_power_mgr_fini(new_drvdata);

	cc_pm_fini(new_drvdata);

post_buf_mgr_err:

	 ssi_buffer_mgr_fini(new_drvdata);

	 cc_buffer_mgr_fini(new_drvdata);

post_req_mgr_err:

	request_mgr_fini(new_drvdata);

post_sram_mgr_err:
@@ -418,8 +418,8 @@ static void cleanup_cc_resources(struct platform_device *plat_dev) 
	ssi_hash_free(drvdata);

	ssi_ablkcipher_free(drvdata);

	ssi_ivgen_fini(drvdata);

	ssi_power_mgr_fini(drvdata);

	ssi_buffer_mgr_fini(drvdata);

	cc_pm_fini(drvdata);

	cc_buffer_mgr_fini(drvdata);

	request_mgr_fini(drvdata);

	ssi_sram_mgr_fini(drvdata);

	ssi_fips_fini(drvdata);
@@ -500,7 +500,7 @@ static int cc7x_remove(struct platform_device *plat_dev) 


#if defined(CONFIG_PM_RUNTIME) || defined(CONFIG_PM_SLEEP)

static const struct dev_pm_ops arm_cc7x_driver_pm = {

	SET_RUNTIME_PM_OPS(ssi_power_mgr_runtime_suspend, ssi_power_mgr_runtime_resume, NULL)

	SET_RUNTIME_PM_OPS(cc_pm_suspend, cc_pm_resume, NULL)

};

#endif