staging: ccree: no need for braces for single statements (a8f6cbaa) · Commits · 戴 / test

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 @@ data_size_err:
		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 @@ fail_unmap_din:
		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 @@ fail_unmap_din:
		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);

Admin message