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

staging: ccree: simplify access to struct device 



Introduce a function to retrieve struct device from private
data structure in preparation to replacing custom logging
macros with proper dev_dbg and friends which require struct
device.

Signed-off-by: default avatarGilad Ben-Yossef <gilad@benyossef.com>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
parent 613fa6f1

drivers/staging/ccree/ssi_aead.c

+5 −6
Original line number Diff line number Diff line
@@ -92,13 +92,12 @@ static inline bool valid_assoclen(struct aead_request *req) 


static void ssi_aead_exit(struct crypto_aead *tfm)

{

	struct device *dev = NULL;

	struct ssi_aead_ctx *ctx = crypto_aead_ctx(tfm);

	struct device *dev = drvdata_to_dev(ctx->drvdata);



	SSI_LOG_DEBUG("Clearing context @%p for %s\n",

		      crypto_aead_ctx(tfm), crypto_tfm_alg_name(&tfm->base));



	dev = &ctx->drvdata->plat_dev->dev;

	/* Unmap enckey buffer */

	if (ctx->enckey) {

		dma_free_coherent(dev, AES_MAX_KEY_SIZE, ctx->enckey, ctx->enckey_dma_addr);
@@ -146,11 +145,12 @@ static void ssi_aead_exit(struct crypto_aead *tfm) 


static int ssi_aead_init(struct crypto_aead *tfm)

{

	struct device *dev;

	struct aead_alg *alg = crypto_aead_alg(tfm);

	struct ssi_aead_ctx *ctx = crypto_aead_ctx(tfm);

	struct ssi_crypto_alg *ssi_alg =

			container_of(alg, struct ssi_crypto_alg, aead_alg);

	struct device *dev = drvdata_to_dev(ssi_alg->drvdata);



	SSI_LOG_DEBUG("Initializing context @%p for %s\n", ctx, crypto_tfm_alg_name(&tfm->base));



	/* Initialize modes in instance */
@@ -158,7 +158,6 @@ static int ssi_aead_init(struct crypto_aead *tfm) 
	ctx->flow_mode = ssi_alg->flow_mode;

	ctx->auth_mode = ssi_alg->auth_mode;

	ctx->drvdata = ssi_alg->drvdata;

	dev = &ctx->drvdata->plat_dev->dev;

	crypto_aead_set_reqsize(tfm, sizeof(struct aead_req_ctx));



	/* Allocate key buffer, cache line aligned */
@@ -426,7 +425,7 @@ ssi_get_plain_hmac_key(struct crypto_aead *tfm, const u8 *key, unsigned int keyl 
{

	dma_addr_t key_dma_addr = 0;

	struct ssi_aead_ctx *ctx = crypto_aead_ctx(tfm);

	struct device *dev = &ctx->drvdata->plat_dev->dev;

	struct device *dev = drvdata_to_dev(ctx->drvdata);

	u32 larval_addr = ssi_ahash_get_larval_digest_sram_addr(

					ctx->drvdata, ctx->auth_mode);

	struct ssi_crypto_req ssi_req = {};
@@ -1952,7 +1951,7 @@ static int ssi_aead_process(struct aead_request *req, enum drv_crypto_direction 
	struct crypto_aead *tfm = crypto_aead_reqtfm(req);

	struct ssi_aead_ctx *ctx = crypto_aead_ctx(tfm);

	struct aead_req_ctx *areq_ctx = aead_request_ctx(req);

	struct device *dev = &ctx->drvdata->plat_dev->dev;

	struct device *dev = drvdata_to_dev(ctx->drvdata);

	struct ssi_crypto_req ssi_req = {};



	SSI_LOG_DEBUG("%s context=%p req=%p iv=%p src=%p src_ofs=%d dst=%p dst_ofs=%d cryptolen=%d\n",

drivers/staging/ccree/ssi_buffer_mgr.c

+7 −7
Original line number Diff line number Diff line
@@ -514,7 +514,7 @@ int ssi_buffer_mgr_map_blkcipher_request( 
	struct blkcipher_req_ctx *req_ctx = (struct blkcipher_req_ctx *)ctx;

	struct mlli_params *mlli_params = &req_ctx->mlli_params;

	struct buff_mgr_handle *buff_mgr = drvdata->buff_mgr_handle;

	struct device *dev = &drvdata->plat_dev->dev;

	struct device *dev = drvdata_to_dev(drvdata);

	struct buffer_array sg_data;

	u32 dummy = 0;

	int rc = 0;
@@ -770,7 +770,7 @@ static inline int ssi_buffer_mgr_aead_chain_iv( 
{

	struct aead_req_ctx *areq_ctx = aead_request_ctx(req);

	unsigned int hw_iv_size = areq_ctx->hw_iv_size;

	struct device *dev = &drvdata->plat_dev->dev;

	struct device *dev = drvdata_to_dev(drvdata);

	int rc = 0;



	if (unlikely(!req->iv)) {
@@ -1110,7 +1110,7 @@ static inline int ssi_buffer_mgr_aead_chain_data( 
	bool is_last_table, bool do_chain)

{

	struct aead_req_ctx *areq_ctx = aead_request_ctx(req);

	struct device *dev = &drvdata->plat_dev->dev;

	struct device *dev = drvdata_to_dev(drvdata);

	enum drv_crypto_direction direct = areq_ctx->gen_ctx.op_type;

	unsigned int authsize = areq_ctx->req_authsize;

	int src_last_bytes = 0, dst_last_bytes = 0;
@@ -1279,7 +1279,7 @@ int ssi_buffer_mgr_map_aead_request( 
{

	struct aead_req_ctx *areq_ctx = aead_request_ctx(req);

	struct mlli_params *mlli_params = &areq_ctx->mlli_params;

	struct device *dev = &drvdata->plat_dev->dev;

	struct device *dev = drvdata_to_dev(drvdata);

	struct buffer_array sg_data;

	unsigned int authsize = areq_ctx->req_authsize;

	struct buff_mgr_handle *buff_mgr = drvdata->buff_mgr_handle;
@@ -1490,7 +1490,7 @@ int ssi_buffer_mgr_map_hash_request_final( 
	struct ssi_drvdata *drvdata, void *ctx, struct scatterlist *src, unsigned int nbytes, bool do_update)

{

	struct ahash_req_ctx *areq_ctx = (struct ahash_req_ctx *)ctx;

	struct device *dev = &drvdata->plat_dev->dev;

	struct device *dev = drvdata_to_dev(drvdata);

	u8 *curr_buff = areq_ctx->buff_index ? areq_ctx->buff1 :

			areq_ctx->buff0;

	u32 *curr_buff_cnt = areq_ctx->buff_index ? &areq_ctx->buff1_cnt :
@@ -1580,7 +1580,7 @@ int ssi_buffer_mgr_map_hash_request_update( 
	struct ssi_drvdata *drvdata, void *ctx, struct scatterlist *src, unsigned int nbytes, unsigned int block_size)

{

	struct ahash_req_ctx *areq_ctx = (struct ahash_req_ctx *)ctx;

	struct device *dev = &drvdata->plat_dev->dev;

	struct device *dev = drvdata_to_dev(drvdata);

	u8 *curr_buff = areq_ctx->buff_index ? areq_ctx->buff1 :

			areq_ctx->buff0;

	u32 *curr_buff_cnt = areq_ctx->buff_index ? &areq_ctx->buff1_cnt :
@@ -1755,7 +1755,7 @@ void ssi_buffer_mgr_unmap_hash_request( 
int ssi_buffer_mgr_init(struct ssi_drvdata *drvdata)

{

	struct buff_mgr_handle *buff_mgr_handle;

	struct device *dev = &drvdata->plat_dev->dev;

	struct device *dev = drvdata_to_dev(drvdata);



	buff_mgr_handle = kmalloc(sizeof(*buff_mgr_handle), GFP_KERNEL);

	if (!buff_mgr_handle)

drivers/staging/ccree/ssi_cipher.c

+4 −9
Original line number Diff line number Diff line
@@ -181,7 +181,7 @@ static int ssi_blkcipher_init(struct crypto_tfm *tfm) 
	struct crypto_alg *alg = tfm->__crt_alg;

	struct ssi_crypto_alg *ssi_alg =

			container_of(alg, struct ssi_crypto_alg, crypto_alg);

	struct device *dev;

	struct device *dev = drvdata_to_dev(ssi_alg->drvdata);

	int rc = 0;

	unsigned int max_key_buf_size = get_max_keysize(tfm);
@@ -191,7 +191,6 @@ static int ssi_blkcipher_init(struct crypto_tfm *tfm) 
	ctx_p->cipher_mode = ssi_alg->cipher_mode;

	ctx_p->flow_mode = ssi_alg->flow_mode;

	ctx_p->drvdata = ssi_alg->drvdata;

	dev = &ctx_p->drvdata->plat_dev->dev;



	/* Allocate key buffer, cache line aligned */

	ctx_p->user.key = kmalloc(max_key_buf_size, GFP_KERNEL | GFP_DMA);
@@ -230,7 +229,7 @@ static int ssi_blkcipher_init(struct crypto_tfm *tfm) 
static void ssi_blkcipher_exit(struct crypto_tfm *tfm)

{

	struct ssi_ablkcipher_ctx *ctx_p = crypto_tfm_ctx(tfm);

	struct device *dev = &ctx_p->drvdata->plat_dev->dev;

	struct device *dev = drvdata_to_dev(ctx_p->drvdata);

	unsigned int max_key_buf_size = get_max_keysize(tfm);



	SSI_LOG_DEBUG("Clearing context @%p for %s\n",
@@ -298,7 +297,7 @@ static int ssi_blkcipher_setkey(struct crypto_tfm *tfm, 
				unsigned int keylen)

{

	struct ssi_ablkcipher_ctx *ctx_p = crypto_tfm_ctx(tfm);

	struct device *dev = &ctx_p->drvdata->plat_dev->dev;

	struct device *dev = drvdata_to_dev(ctx_p->drvdata);

	u32 tmp[DES_EXPKEY_WORDS];

	unsigned int max_key_buf_size = get_max_keysize(tfm);
@@ -738,7 +737,7 @@ static int ssi_blkcipher_process( 
	enum drv_crypto_direction direction)

{

	struct ssi_ablkcipher_ctx *ctx_p = crypto_tfm_ctx(tfm);

	struct device *dev = &ctx_p->drvdata->plat_dev->dev;

	struct device *dev = drvdata_to_dev(ctx_p->drvdata);

	struct cc_hw_desc desc[MAX_ABLKCIPHER_SEQ_LEN];

	struct ssi_crypto_req ssi_req = {};

	int rc, seq_len = 0, cts_restore_flag = 0;
@@ -1281,10 +1280,6 @@ int ssi_ablkcipher_free(struct ssi_drvdata *drvdata) 
	struct ssi_crypto_alg *t_alg, *n;

	struct ssi_blkcipher_handle *blkcipher_handle =

						drvdata->blkcipher_handle;

	struct device *dev;



	dev = &drvdata->plat_dev->dev;



	if (blkcipher_handle) {

		/* Remove registered algs */

		list_for_each_entry_safe(t_alg, n,

drivers/staging/ccree/ssi_driver.c

+10 −12
Original line number Diff line number Diff line
@@ -229,14 +229,13 @@ static int init_cc_resources(struct platform_device *plat_dev) 
	u32 signature_val;

	int rc = 0;



	new_drvdata = devm_kzalloc(&plat_dev->dev, sizeof(*new_drvdata),

				   GFP_KERNEL);

	new_drvdata = devm_kzalloc(dev, sizeof(*new_drvdata), GFP_KERNEL);

	if (!new_drvdata) {

		SSI_LOG_ERR("Failed to allocate drvdata");

		rc = -ENOMEM;

		goto post_drvdata_err;

	}

	dev_set_drvdata(&plat_dev->dev, new_drvdata);

	dev_set_drvdata(dev, new_drvdata);

	new_drvdata->plat_dev = plat_dev;



	new_drvdata->clk = of_clk_get(np, 0);
@@ -246,8 +245,7 @@ static int init_cc_resources(struct platform_device *plat_dev) 
	/* First CC registers space */

	req_mem_cc_regs = platform_get_resource(plat_dev, IORESOURCE_MEM, 0);

	/* Map registers space */

	new_drvdata->cc_base = devm_ioremap_resource(&plat_dev->dev,

						     req_mem_cc_regs);

	new_drvdata->cc_base = devm_ioremap_resource(dev, req_mem_cc_regs);

	if (IS_ERR(new_drvdata->cc_base)) {

		SSI_LOG_ERR("Failed to ioremap registers");

		rc = PTR_ERR(new_drvdata->cc_base);
@@ -271,7 +269,7 @@ static int init_cc_resources(struct platform_device *plat_dev) 
		goto post_drvdata_err;

	}



	rc = devm_request_irq(&plat_dev->dev, new_drvdata->irq, cc_isr,

	rc = devm_request_irq(dev, new_drvdata->irq, cc_isr,

			      IRQF_SHARED, "arm_cc7x", new_drvdata);

	if (rc) {

		SSI_LOG_ERR("Could not register to interrupt %d\n",
@@ -284,11 +282,11 @@ static int init_cc_resources(struct platform_device *plat_dev) 
	if (rc)

		goto post_drvdata_err;



	if (!new_drvdata->plat_dev->dev.dma_mask)

		new_drvdata->plat_dev->dev.dma_mask = &new_drvdata->plat_dev->dev.coherent_dma_mask;

	if (!dev->dma_mask)

		dev->dma_mask = &dev->coherent_dma_mask;



	if (!new_drvdata->plat_dev->dev.coherent_dma_mask)

		new_drvdata->plat_dev->dev.coherent_dma_mask = DMA_BIT_MASK(DMA_BIT_MASK_LEN);

	if (!dev->coherent_dma_mask)

		dev->coherent_dma_mask = DMA_BIT_MASK(DMA_BIT_MASK_LEN);



	/* Verify correct mapping */

	signature_val = CC_HAL_READ_REGISTER(CC_REG_OFFSET(HOST_RGF, HOST_SIGNATURE));
@@ -311,7 +309,7 @@ static int init_cc_resources(struct platform_device *plat_dev) 
	}



#ifdef ENABLE_CC_SYSFS

	rc = ssi_sysfs_init(&plat_dev->dev.kobj, new_drvdata);

	rc = ssi_sysfs_init(&dev->kobj, new_drvdata);

	if (unlikely(rc != 0)) {

		SSI_LOG_ERR("init_stat_db failed\n");

		goto post_regs_err;
@@ -415,7 +413,7 @@ static int init_cc_resources(struct platform_device *plat_dev) 
	cc_clk_off(new_drvdata);

post_drvdata_err:

	SSI_LOG_ERR("ccree init error occurred!\n");

	dev_set_drvdata(&plat_dev->dev, NULL);

	dev_set_drvdata(dev, NULL);

	return rc;

}

drivers/staging/ccree/ssi_driver.h

+6 −0
Original line number Diff line number Diff line
@@ -37,6 +37,7 @@ 
#include <crypto/hash.h>

#include <linux/version.h>

#include <linux/clk.h>

#include <linux/platform_device.h>



/* Registers definitions from shared/hw/ree_include */

#include "dx_reg_base_host.h"
@@ -184,6 +185,11 @@ struct async_gen_req_ctx { 
	enum drv_crypto_direction op_type;

};



static inline struct device *drvdata_to_dev(struct ssi_drvdata *drvdata)

{

	return &drvdata->plat_dev->dev;

}



#ifdef DX_DUMP_BYTES

void dump_byte_array(const char *name, const u8 *the_array, unsigned long size);

#else