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

staging: ccree: no need for braces for single statements 



Fix several cases of needless braces around single statement blocks.

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

drivers/staging/ccree/ssi_aead.c

+14 −24
Original line number Diff line number Diff line
@@ -243,13 +243,12 @@ static void ssi_aead_complete(struct device *dev, void *ssi_req, void __iomem *c 


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

		if (areq_ctx->backup_giv != NULL) {

			if (ctx->cipher_mode == DRV_CIPHER_CTR) {

			if (ctx->cipher_mode == DRV_CIPHER_CTR)

				memcpy(areq_ctx->backup_giv, areq_ctx->ctr_iv + CTR_RFC3686_NONCE_SIZE, CTR_RFC3686_IV_SIZE);

			} else if (ctx->cipher_mode == DRV_CIPHER_CCM) {

			else if (ctx->cipher_mode == DRV_CIPHER_CCM)

				memcpy(areq_ctx->backup_giv, areq_ctx->ctr_iv + CCM_BLOCK_IV_OFFSET, CCM_BLOCK_IV_SIZE);

		}

	}

	}



	aead_request_complete(areq, err);

}
@@ -521,9 +520,8 @@ ssi_get_plain_hmac_key(struct crypto_aead *tfm, const u8 *key, unsigned int keyl 
	if (unlikely(rc != 0))

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



	if (likely(key_dma_addr != 0)) {

	if (likely(key_dma_addr != 0))

		dma_unmap_single(dev, key_dma_addr, keylen, DMA_TO_DEVICE);

	}



	return rc;

}
@@ -928,11 +926,10 @@ static inline void ssi_aead_setup_cipher_desc( 
	set_flow_mode(&desc[idx], ctx->flow_mode);

	set_din_type(&desc[idx], DMA_DLLI, req_ctx->gen_ctx.iv_dma_addr,

		     hw_iv_size, NS_BIT);

	if (ctx->cipher_mode == DRV_CIPHER_CTR) {

	if (ctx->cipher_mode == DRV_CIPHER_CTR)

		set_setup_mode(&desc[idx], SETUP_LOAD_STATE1);

	} else {

	else

		set_setup_mode(&desc[idx], SETUP_LOAD_STATE0);

	}

	set_cipher_mode(&desc[idx], ctx->cipher_mode);

	idx++;
@@ -1375,9 +1372,9 @@ static int validate_data_size(struct ssi_aead_ctx *ctx, 
static unsigned int format_ccm_a0(u8 *pA0Buff, u32 headerSize)

{

	unsigned int len = 0;

	if (headerSize == 0) {

	if (headerSize == 0)

		return 0;

	}



	if (headerSize < ((1UL << 16) - (1UL << 8))) {

		len = 2;
@@ -1498,9 +1495,8 @@ static inline int ssi_aead_ccm( 
	}



	/* process the cipher */

	if (req_ctx->cryptlen != 0) {

	if (req_ctx->cryptlen != 0)

		ssi_aead_process_cipher_data_desc(req, cipher_flow_mode, desc, &idx);

	}



	/* Read temporal MAC */

	hw_desc_init(&desc[idx]);
@@ -1579,9 +1575,8 @@ static int config_ccm_adata(struct aead_request *req) 
		*b0 |= 64;  /* Enable bit 6 if Adata exists. */



	rc = set_msg_len(b0 + 16 - l, cryptlen, l);  /* Write L'. */

	if (rc != 0) {

	if (rc != 0)

		return rc;

	}

	 /* END of "taken from crypto/ccm.c" */



	/* l(a) - size of associated data. */
@@ -1861,9 +1856,8 @@ static inline void ssi_aead_dump_gcm( 
	SSI_LOG_DEBUG("cipher_mode %d, authsize %d, enc_keylen %d, assoclen %d, cryptlen %d\n", \

				 ctx->cipher_mode, ctx->authsize, ctx->enc_keylen, req->assoclen, req_ctx->cryptlen);



	if (ctx->enckey != NULL) {

	if (ctx->enckey != NULL)

		dump_byte_array("mac key", ctx->enckey, 16);

	}



	dump_byte_array("req->iv", req->iv, AES_BLOCK_SIZE);
@@ -1877,14 +1871,12 @@ static inline void ssi_aead_dump_gcm( 


	dump_byte_array("gcm_len_block", req_ctx->gcm_len_block.lenA, AES_BLOCK_SIZE);



	if (req->src != NULL && req->cryptlen) {

	if (req->src != NULL && req->cryptlen)

		dump_byte_array("req->src", sg_virt(req->src), req->cryptlen + req->assoclen);

	}



	if (req->dst != NULL) {

	if (req->dst != NULL)

		dump_byte_array("req->dst", sg_virt(req->dst), req->cryptlen + ctx->authsize + req->assoclen);

}

}

#endif



static int config_gcm_context(struct aead_request *req)
@@ -2083,14 +2075,12 @@ static int ssi_aead_process(struct aead_request *req, enum drv_crypto_direction 
#if (SSI_CC_HAS_AES_CCM || SSI_CC_HAS_AES_GCM)

	case DRV_HASH_NULL:

#if SSI_CC_HAS_AES_CCM

		if (ctx->cipher_mode == DRV_CIPHER_CCM) {

		if (ctx->cipher_mode == DRV_CIPHER_CCM)

			ssi_aead_ccm(req, desc, &seq_len);

		}

#endif /*SSI_CC_HAS_AES_CCM*/

#if SSI_CC_HAS_AES_GCM

		if (ctx->cipher_mode == DRV_CIPHER_GCTR) {

		if (ctx->cipher_mode == DRV_CIPHER_GCTR)

			ssi_aead_gcm(req, desc, &seq_len);

		}

#endif /*SSI_CC_HAS_AES_GCM*/

			break;

#endif

drivers/staging/ccree/ssi_buffer_mgr.c

+30 −40
Original line number Diff line number Diff line
@@ -94,11 +94,10 @@ static unsigned int ssi_buffer_mgr_get_sgl_nents( 
			sg_list = sg_next(sg_list);

		} else {

			sg_list = (struct scatterlist *)sg_page(sg_list);

			if (is_chained != NULL) {

			if (is_chained != NULL)

				*is_chained = true;

		}

	}

	}

	SSI_LOG_DEBUG("nents %d last bytes %d\n", nents, *lbytes);

	return nents;

}
@@ -155,9 +154,8 @@ static inline int ssi_buffer_mgr_render_buff_to_mlli( 


	/* Verify there is no memory overflow*/

	new_nents = (*curr_nents + buff_size / CC_MAX_MLLI_ENTRY_SIZE + 1);

	if (new_nents > MAX_NUM_OF_TOTAL_MLLI_ENTRIES) {

	if (new_nents > MAX_NUM_OF_TOTAL_MLLI_ENTRIES)

		return -ENOMEM;

	}



	/*handle buffer longer than 64 kbytes */

	while (buff_size > CC_MAX_MLLI_ENTRY_SIZE) {
@@ -201,9 +199,9 @@ static inline int ssi_buffer_mgr_render_scatterlist_to_mlli( 
		rc = ssi_buffer_mgr_render_buff_to_mlli(

			sg_dma_address(curr_sgl) + sglOffset, entry_data_len, curr_nents,

			&mlli_entry_p);

		if (rc != 0) {

		if (rc != 0)

			return rc;

		}



		sglOffset = 0;

	}

	*mlli_entry_pp = mlli_entry_p;
@@ -244,9 +242,8 @@ static int ssi_buffer_mgr_generate_mlli( 
				sg_data->entry[i].buffer_dma,

				sg_data->total_data_len[i], &total_nents,

				&mlli_p);

		if (rc != 0) {

		if (rc != 0)

			return rc;

		}



		/* set last bit in the current table */

		if (sg_data->mlli_nents[i] != NULL) {
@@ -326,9 +323,8 @@ ssi_buffer_mgr_dma_map_sg(struct device *dev, struct scatterlist *sg, u32 nents, 
	u32 i, j;

	struct scatterlist *l_sg = sg;

	for (i = 0; i < nents; i++) {

		if (l_sg == NULL) {

		if (l_sg == NULL)

			break;

		}

		if (unlikely(dma_map_sg(dev, l_sg, 1, direction) != 1)) {

			SSI_LOG_ERR("dma_map_page() sg buffer failed\n");

			goto err;
@@ -340,9 +336,8 @@ ssi_buffer_mgr_dma_map_sg(struct device *dev, struct scatterlist *sg, u32 nents, 
err:

	/* Restore mapped parts */

	for (j = 0; j < i; j++) {

		if (sg == NULL) {

		if (sg == NULL)

			break;

		}

		dma_unmap_sg(dev, sg, 1, direction);

		sg = sg_next(sg);

	}
@@ -687,9 +682,8 @@ void ssi_buffer_mgr_unmap_aead_request( 


	SSI_LOG_DEBUG("Unmapping src sgl: req->src=%pK areq_ctx->src.nents=%u areq_ctx->assoc.nents=%u assoclen:%u cryptlen=%u\n", sg_virt(req->src), areq_ctx->src.nents, areq_ctx->assoc.nents, req->assoclen, req->cryptlen);

	size_to_unmap = req->assoclen + req->cryptlen;

	if (areq_ctx->gen_ctx.op_type == DRV_CRYPTO_DIRECTION_ENCRYPT) {

	if (areq_ctx->gen_ctx.op_type == DRV_CRYPTO_DIRECTION_ENCRYPT)

		size_to_unmap += areq_ctx->req_authsize;

	}

	if (areq_ctx->is_gcm4543)

		size_to_unmap += crypto_aead_ivsize(tfm);
@@ -705,9 +699,9 @@ void ssi_buffer_mgr_unmap_aead_request( 
	    likely(req->src == req->dst))

	{

		u32 size_to_skip = req->assoclen;

		if (areq_ctx->is_gcm4543) {

		if (areq_ctx->is_gcm4543)

			size_to_skip += crypto_aead_ivsize(tfm);

		}



		/* copy mac to a temporary location to deal with possible

		 * data memory overriding that caused by cache coherence problem.

		 */
@@ -736,15 +730,13 @@ static inline int ssi_buffer_mgr_get_aead_icv_nents( 
	}



	for (i = 0 ; i < (sgl_nents - MAX_ICV_NENTS_SUPPORTED) ; i++) {

		if (sgl == NULL) {

		if (sgl == NULL)

			break;

		}

		sgl = sg_next(sgl);

	}



	if (sgl != NULL) {

	if (sgl != NULL)

		icv_max_size = sgl->length;

	}



	if (last_entry_data_size > authsize) {

		nents = 0; /* ICV attached to data in last entry (not fragmented!) */
@@ -827,9 +819,8 @@ static inline int ssi_buffer_mgr_aead_chain_assoc( 
	unsigned int sg_index = 0;

	u32 size_of_assoc = req->assoclen;



	if (areq_ctx->is_gcm4543) {

	if (areq_ctx->is_gcm4543)

		size_of_assoc += crypto_aead_ivsize(tfm);

	}



	if (sg_data == NULL) {

		rc = -EINVAL;
@@ -1035,9 +1026,9 @@ static inline int ssi_buffer_mgr_prepare_aead_data_mlli( 
			 * MAC verification upon request completion

			 */

			  u32 size_to_skip = req->assoclen;

			  if (areq_ctx->is_gcm4543) {

			  if (areq_ctx->is_gcm4543)

				  size_to_skip += crypto_aead_ivsize(tfm);

			  }



			  ssi_buffer_mgr_copy_scatterlist_portion(

				  areq_ctx->backup_mac, req->src,

				  size_to_skip + req->cryptlen - areq_ctx->req_authsize,
@@ -1110,9 +1101,10 @@ static inline int ssi_buffer_mgr_aead_chain_data( 
	bool chained = false;

	bool is_gcm4543 = areq_ctx->is_gcm4543;

	u32 size_to_skip = req->assoclen;

	if (is_gcm4543) {



	if (is_gcm4543)

		size_to_skip += crypto_aead_ivsize(tfm);

	}



	offset = size_to_skip;



	if (sg_data == NULL) {
@@ -1122,9 +1114,8 @@ static inline int ssi_buffer_mgr_aead_chain_data( 
	areq_ctx->srcSgl = req->src;

	areq_ctx->dstSgl = req->dst;



	if (is_gcm4543) {

	if (is_gcm4543)

		size_for_map += crypto_aead_ivsize(tfm);

	}



	size_for_map += (direct == DRV_CRYPTO_DIRECTION_ENCRYPT) ? authsize : 0;

	src_mapped_nents = ssi_buffer_mgr_get_sgl_nents(req->src, size_for_map, &src_last_bytes, &chained);
@@ -1155,9 +1146,8 @@ static inline int ssi_buffer_mgr_aead_chain_data( 
	if (req->src != req->dst) {

		size_for_map = req->assoclen + req->cryptlen;

		size_for_map += (direct == DRV_CRYPTO_DIRECTION_ENCRYPT) ? authsize : 0;

		if (is_gcm4543) {

		if (is_gcm4543)

			size_for_map += crypto_aead_ivsize(tfm);

		}



		rc = ssi_buffer_mgr_map_scatterlist(dev, req->dst, size_for_map,

			 DMA_BIDIRECTIONAL, &(areq_ctx->dst.nents),
@@ -1285,9 +1275,10 @@ int ssi_buffer_mgr_map_aead_request( 
	    likely(req->src == req->dst))

	{

		u32 size_to_skip = req->assoclen;

		if (is_gcm4543) {



		if (is_gcm4543)

			size_to_skip += crypto_aead_ivsize(tfm);

		}



		/* copy mac to a temporary location to deal with possible

		 * data memory overriding that caused by cache coherence problem.

		 */
@@ -1381,9 +1372,9 @@ int ssi_buffer_mgr_map_aead_request( 
#endif /*SSI_CC_HAS_AES_GCM*/



	size_to_map = req->cryptlen + req->assoclen;

	if (areq_ctx->gen_ctx.op_type == DRV_CRYPTO_DIRECTION_ENCRYPT) {

	if (areq_ctx->gen_ctx.op_type == DRV_CRYPTO_DIRECTION_ENCRYPT)

		size_to_map += authsize;

	}



	if (is_gcm4543)

		size_to_map += crypto_aead_ivsize(tfm);

	rc = ssi_buffer_mgr_map_scatterlist(dev, req->src,
@@ -1448,9 +1439,8 @@ int ssi_buffer_mgr_map_aead_request( 
		(areq_ctx->data_buff_type == SSI_DMA_BUF_MLLI))) {

		mlli_params->curr_pool = buff_mgr->mlli_buffs_pool;

		rc = ssi_buffer_mgr_generate_mlli(dev, &sg_data, mlli_params);

		if (unlikely(rc != 0)) {

		if (unlikely(rc != 0))

			goto aead_map_failure;

		}



		ssi_buffer_mgr_update_aead_mlli_nents(drvdata, req);

		SSI_LOG_DEBUG("assoc params mn %d\n", areq_ctx->assoc.mlli_nents);
@@ -1549,9 +1539,9 @@ int ssi_buffer_mgr_map_hash_request_final( 
	dma_unmap_sg(dev, src, areq_ctx->in_nents, DMA_TO_DEVICE);



unmap_curr_buff:

	if (*curr_buff_cnt != 0) {

	if (*curr_buff_cnt != 0)

		dma_unmap_sg(dev, areq_ctx->buff_sg, 1, DMA_TO_DEVICE);

	}



	return -ENOMEM;

}
@@ -1678,9 +1668,9 @@ int ssi_buffer_mgr_map_hash_request_update( 
	dma_unmap_sg(dev, src, areq_ctx->in_nents, DMA_TO_DEVICE);



unmap_curr_buff:

	if (*curr_buff_cnt != 0) {

	if (*curr_buff_cnt != 0)

		dma_unmap_sg(dev, areq_ctx->buff_sg, 1, DMA_TO_DEVICE);

	}



	return -ENOMEM;

}

drivers/staging/ccree/ssi_cipher.c

+14 −27
Original line number Diff line number Diff line
@@ -165,13 +165,11 @@ static unsigned int get_max_keysize(struct crypto_tfm *tfm) 
{

	struct ssi_crypto_alg *ssi_alg = container_of(tfm->__crt_alg, struct ssi_crypto_alg, crypto_alg);



	if ((ssi_alg->crypto_alg.cra_flags & CRYPTO_ALG_TYPE_MASK) == CRYPTO_ALG_TYPE_ABLKCIPHER) {

	if ((ssi_alg->crypto_alg.cra_flags & CRYPTO_ALG_TYPE_MASK) == CRYPTO_ALG_TYPE_ABLKCIPHER)

		return ssi_alg->crypto_alg.cra_ablkcipher.max_keysize;

	}



	if ((ssi_alg->crypto_alg.cra_flags & CRYPTO_ALG_TYPE_MASK) == CRYPTO_ALG_TYPE_BLKCIPHER) {

	if ((ssi_alg->crypto_alg.cra_flags & CRYPTO_ALG_TYPE_MASK) == CRYPTO_ALG_TYPE_BLKCIPHER)

		return ssi_alg->crypto_alg.cra_blkcipher.max_keysize;

	}



	return 0;

}
@@ -289,9 +287,8 @@ static int ssi_fips_verify_xts_keys(const u8 *key, unsigned int keylen) 
	/* Weak key is define as key that its first half (128/256 lsb) equals its second half (128/256 msb) */

	int singleKeySize = keylen >> 1;



	if (unlikely(memcmp(key, &key[singleKeySize], singleKeySize) == 0)) {

	if (unlikely(memcmp(key, &key[singleKeySize], singleKeySize) == 0))

		return -ENOEXEC;

	}

#endif /* CCREE_FIPS_SUPPORT */



	return 0;
@@ -333,9 +330,8 @@ static int ssi_blkcipher_setkey(struct crypto_tfm *tfm, 


#if SSI_CC_HAS_MULTI2

	/*last byte of key buffer is round number and should not be a part of key size*/

	if (ctx_p->flow_mode == S_DIN_to_MULTI2) {

	if (ctx_p->flow_mode == S_DIN_to_MULTI2)

		keylen -= 1;

	}

#endif /*SSI_CC_HAS_MULTI2*/



	if (unlikely(validate_keys_sizes(ctx_p, keylen) != 0)) {
@@ -658,9 +654,9 @@ ssi_blkcipher_create_data_desc( 
			     nbytes, NS_BIT);

		set_dout_dlli(&desc[*seq_size], sg_dma_address(dst),

			      nbytes, NS_BIT, (!areq ? 0 : 1));

		if (areq != NULL) {

		if (areq != NULL)

			set_queue_last_ind(&desc[*seq_size]);

		}



		set_flow_mode(&desc[*seq_size], flow_mode);

		(*seq_size)++;

	} else {
@@ -707,9 +703,9 @@ ssi_blkcipher_create_data_desc( 
				      req_ctx->out_mlli_nents, NS_BIT,

				      (!areq ? 0 : 1));

		}

		if (areq != NULL) {

		if (areq != NULL)

			set_queue_last_ind(&desc[*seq_size]);

		}



		set_flow_mode(&desc[*seq_size], flow_mode);

		(*seq_size)++;

	}
@@ -809,22 +805,13 @@ static int ssi_blkcipher_process( 


	/* Setup processing */

#if SSI_CC_HAS_MULTI2

	if (ctx_p->flow_mode == S_DIN_to_MULTI2) {

		ssi_blkcipher_create_multi2_setup_desc(tfm,

						       req_ctx,

						       ivsize,

						       desc,

						       &seq_len);

	} else

	if (ctx_p->flow_mode == S_DIN_to_MULTI2)

		ssi_blkcipher_create_multi2_setup_desc(tfm, req_ctx, ivsize,

						       desc, &seq_len);

	else

#endif /*SSI_CC_HAS_MULTI2*/

	{

		ssi_blkcipher_create_setup_desc(tfm,

						req_ctx,

						ivsize,

						nbytes,

						desc,

						&seq_len);

	}

		ssi_blkcipher_create_setup_desc(tfm, req_ctx, ivsize, nbytes,

						desc, &seq_len);

	/* Data processing */

	ssi_blkcipher_create_data_desc(tfm,

			      req_ctx,

drivers/staging/ccree/ssi_driver.c

+5 −4
Original line number Diff line number Diff line
@@ -205,16 +205,17 @@ int init_cc_regs(struct ssi_drvdata *drvdata, bool is_probe) 
	cache_params = (drvdata->coherent ? CC_COHERENT_CACHE_PARAMS : 0x0);



	val = CC_HAL_READ_REGISTER(CC_REG_OFFSET(CRY_KERNEL, AXIM_CACHE_PARAMS));

	if (is_probe) {



	if (is_probe)

		SSI_LOG_INFO("Cache params previous: 0x%08X\n", val);

	}



	CC_HAL_WRITE_REGISTER(CC_REG_OFFSET(CRY_KERNEL, AXIM_CACHE_PARAMS),

			      cache_params);

	val = CC_HAL_READ_REGISTER(CC_REG_OFFSET(CRY_KERNEL, AXIM_CACHE_PARAMS));

	if (is_probe) {



	if (is_probe)

		SSI_LOG_INFO("Cache params current: 0x%08X (expect: 0x%08X)\n",

			     val, cache_params);

	}



	return 0;

}

drivers/staging/ccree/ssi_fips.c

+2 −4
Original line number Diff line number Diff line
@@ -34,9 +34,8 @@ int ssi_fips_get_state(ssi_fips_state_t *p_state) 
{

	int rc = 0;



	if (p_state == NULL) {

	if (p_state == NULL)

		return -EINVAL;

	}



	rc = ssi_fips_ext_get_state(p_state);
@@ -53,9 +52,8 @@ int ssi_fips_get_error(ssi_fips_error_t *p_err) 
{

	int rc = 0;



	if (p_err == NULL) {

	if (p_err == NULL)

		return -EINVAL;

	}



	rc = ssi_fips_ext_get_error(p_err);