Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

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

staging: ccree: remove last remnants of sash algo 



The hash code had some left overs from a misguided attempt
to support shash API with the HW. Remove the code handling
this.

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

drivers/staging/ccree/ssi_hash.c

+127 −321
Original line number Diff line number Diff line
@@ -76,15 +76,11 @@ static void ssi_hash_create_cmac_setup(struct ahash_request *areq, 


struct ssi_hash_alg {

	struct list_head entry;

	bool synchronize;

	int hash_mode;

	int hw_mode;

	int inter_digestsize;

	struct ssi_drvdata *drvdata;

	union {

	struct ahash_alg ahash_alg;

		struct shash_alg shash_alg;

	};

};
@@ -112,8 +108,6 @@ struct ssi_hash_ctx { 
	bool is_hmac;

};



static const struct crypto_type crypto_shash_type;



static void ssi_hash_create_data_desc(

	struct ahash_req_ctx *areq_ctx,

	struct ssi_hash_ctx *ctx,
@@ -1015,15 +1009,9 @@ static int ssi_hash_setkey(void *hash, 
	 SSI_LOG_DEBUG("ssi_hash_setkey: start keylen: %d", keylen);



	CHECK_AND_RETURN_UPON_FIPS_ERROR();

	if (synchronize) {

		ctx = crypto_shash_ctx(((struct crypto_shash *)hash));

		blocksize = crypto_tfm_alg_blocksize(&((struct crypto_shash *)hash)->base);

		digestsize = crypto_shash_digestsize(((struct crypto_shash *)hash));

	} else {

	ctx = crypto_ahash_ctx(((struct crypto_ahash *)hash));

	blocksize = crypto_tfm_alg_blocksize(&((struct crypto_ahash *)hash)->base);

	digestsize = crypto_ahash_digestsize(((struct crypto_ahash *)hash));

	}



	larval_addr = ssi_ahash_get_larval_digest_sram_addr(

					ctx->drvdata, ctx->hash_mode);
@@ -1184,13 +1172,8 @@ static int ssi_hash_setkey(void *hash, 
	rc = send_request(ctx->drvdata, &ssi_req, desc, idx, 0);



out:

	if (rc != 0) {

		if (synchronize) {

			crypto_shash_set_flags((struct crypto_shash *)hash, CRYPTO_TFM_RES_BAD_KEY_LEN);

		} else {

	if (rc)

		crypto_ahash_set_flags((struct crypto_ahash *)hash, CRYPTO_TFM_RES_BAD_KEY_LEN);

		}

	}



	if (ctx->key_params.key_dma_addr) {

		dma_unmap_single(&ctx->drvdata->plat_dev->dev,
@@ -1395,23 +1378,6 @@ static int ssi_hash_alloc_ctx(struct ssi_hash_ctx *ctx) 
	return -ENOMEM;

}



static int ssi_shash_cra_init(struct crypto_tfm *tfm)

{

	struct ssi_hash_ctx *ctx = crypto_tfm_ctx(tfm);

	struct shash_alg * shash_alg =

		container_of(tfm->__crt_alg, struct shash_alg, base);

	struct ssi_hash_alg *ssi_alg =

			container_of(shash_alg, struct ssi_hash_alg, shash_alg);



	CHECK_AND_RETURN_UPON_FIPS_ERROR();

	ctx->hash_mode = ssi_alg->hash_mode;

	ctx->hw_mode = ssi_alg->hw_mode;

	ctx->inter_digestsize = ssi_alg->inter_digestsize;

	ctx->drvdata = ssi_alg->drvdata;



	return ssi_hash_alloc_ctx(ctx);

}



static int ssi_ahash_cra_init(struct crypto_tfm *tfm)

{

	struct ssi_hash_ctx *ctx = crypto_tfm_ctx(tfm);
@@ -1764,100 +1730,6 @@ static int ssi_mac_digest(struct ahash_request *req) 
	return rc;

}



//shash wrap functions

#ifdef SYNC_ALGS

static int ssi_shash_digest(struct shash_desc *desc,

			    const u8 *data, unsigned int len, u8 *out)

{

	struct ahash_req_ctx *state = shash_desc_ctx(desc);

	struct crypto_shash *tfm = desc->tfm;

	struct ssi_hash_ctx *ctx = crypto_shash_ctx(tfm);

	u32 digestsize = crypto_shash_digestsize(tfm);

	struct scatterlist src;



	if (len == 0) {

		return ssi_hash_digest(state, ctx, digestsize, NULL, 0, out, NULL);

	}



	/* sg_init_one may crash when len is 0 (depends on kernel configuration) */

	sg_init_one(&src, (const void *)data, len);



	return ssi_hash_digest(state, ctx, digestsize, &src, len, out, NULL);

}



static int ssi_shash_update(struct shash_desc *desc,

						const u8 *data, unsigned int len)

{

	struct ahash_req_ctx *state = shash_desc_ctx(desc);

	struct crypto_shash *tfm = desc->tfm;

	struct ssi_hash_ctx *ctx = crypto_shash_ctx(tfm);

	u32 blocksize = crypto_tfm_alg_blocksize(&tfm->base);

	struct scatterlist src;



	sg_init_one(&src, (const void *)data, len);



	return ssi_hash_update(state, ctx, blocksize, &src, len, NULL);

}



static int ssi_shash_finup(struct shash_desc *desc,

			   const u8 *data, unsigned int len, u8 *out)

{

	struct ahash_req_ctx *state = shash_desc_ctx(desc);

	struct crypto_shash *tfm = desc->tfm;

	struct ssi_hash_ctx *ctx = crypto_shash_ctx(tfm);

	u32 digestsize = crypto_shash_digestsize(tfm);

	struct scatterlist src;



	sg_init_one(&src, (const void *)data, len);



	return ssi_hash_finup(state, ctx, digestsize, &src, len, out, NULL);

}



static int ssi_shash_final(struct shash_desc *desc, u8 *out)

{

	struct ahash_req_ctx *state = shash_desc_ctx(desc);

	struct crypto_shash *tfm = desc->tfm;

	struct ssi_hash_ctx *ctx = crypto_shash_ctx(tfm);

	u32 digestsize = crypto_shash_digestsize(tfm);



	return ssi_hash_final(state, ctx, digestsize, NULL, 0, out, NULL);

}



static int ssi_shash_init(struct shash_desc *desc)

{

	struct ahash_req_ctx *state = shash_desc_ctx(desc);

	struct crypto_shash *tfm = desc->tfm;

	struct ssi_hash_ctx *ctx = crypto_shash_ctx(tfm);



	return ssi_hash_init(state, ctx);

}



#ifdef EXPORT_FIXED

static int ssi_shash_export(struct shash_desc *desc, void *out)

{

	struct crypto_shash *tfm = desc->tfm;

	struct ssi_hash_ctx *ctx = crypto_shash_ctx(tfm);



	return ssi_hash_export(ctx, out);

}



static int ssi_shash_import(struct shash_desc *desc, const void *in)

{

	struct crypto_shash *tfm = desc->tfm;

	struct ssi_hash_ctx *ctx = crypto_shash_ctx(tfm);



	return ssi_hash_import(ctx, in);

}

#endif



static int ssi_shash_setkey(struct crypto_shash *tfm,

			    const u8 *key, unsigned int keylen)

{

	return ssi_hash_setkey((void *) tfm, key, keylen, true);

}



#endif /* SYNC_ALGS */



//ahash wrap functions

static int ssi_ahash_digest(struct ahash_request *req)

{
@@ -1941,10 +1813,7 @@ struct ssi_hash_template { 
	char hmac_driver_name[CRYPTO_MAX_ALG_NAME];

	unsigned int blocksize;

	bool synchronize;

	union {

	struct ahash_alg template_ahash;

		struct shash_alg template_shash;

	};

	int hash_mode;

	int hw_mode;

	int inter_digestsize;
@@ -1961,7 +1830,6 @@ static struct ssi_hash_template driver_hash[] = { 
		.hmac_driver_name = "hmac-sha1-dx",

		.blocksize = SHA1_BLOCK_SIZE,

		.synchronize = false,

		{

		.template_ahash = {

			.init = ssi_ahash_init,

			.update = ssi_ahash_update,
@@ -1978,7 +1846,6 @@ static struct ssi_hash_template driver_hash[] = { 
				.statesize = sizeof(struct sha1_state),

			},

		},

		},

		.hash_mode = DRV_HASH_SHA1,

		.hw_mode = DRV_HASH_HW_SHA1,

		.inter_digestsize = SHA1_DIGEST_SIZE,
@@ -1989,8 +1856,6 @@ static struct ssi_hash_template driver_hash[] = { 
		.hmac_name = "hmac(sha256)",

		.hmac_driver_name = "hmac-sha256-dx",

		.blocksize = SHA256_BLOCK_SIZE,

		.synchronize = false,

		{

		.template_ahash = {

			.init = ssi_ahash_init,

			.update = ssi_ahash_update,
@@ -2007,7 +1872,6 @@ static struct ssi_hash_template driver_hash[] = { 
				.statesize = sizeof(struct sha256_state),

			},

		},

		},

		.hash_mode = DRV_HASH_SHA256,

		.hw_mode = DRV_HASH_HW_SHA256,

		.inter_digestsize = SHA256_DIGEST_SIZE,
@@ -2018,8 +1882,6 @@ static struct ssi_hash_template driver_hash[] = { 
		.hmac_name = "hmac(sha224)",

		.hmac_driver_name = "hmac-sha224-dx",

		.blocksize = SHA224_BLOCK_SIZE,

		.synchronize = false,

		{

		.template_ahash = {

			.init = ssi_ahash_init,

			.update = ssi_ahash_update,
@@ -2036,7 +1898,6 @@ static struct ssi_hash_template driver_hash[] = { 
				.statesize = sizeof(struct sha256_state),

			},

		},

		},

		.hash_mode = DRV_HASH_SHA224,

		.hw_mode = DRV_HASH_HW_SHA256,

		.inter_digestsize = SHA256_DIGEST_SIZE,
@@ -2048,8 +1909,6 @@ static struct ssi_hash_template driver_hash[] = { 
		.hmac_name = "hmac(sha384)",

		.hmac_driver_name = "hmac-sha384-dx",

		.blocksize = SHA384_BLOCK_SIZE,

		.synchronize = false,

		{

		.template_ahash = {

			.init = ssi_ahash_init,

			.update = ssi_ahash_update,
@@ -2066,7 +1925,6 @@ static struct ssi_hash_template driver_hash[] = { 
				.statesize = sizeof(struct sha512_state),

			},

		},

		},

		.hash_mode = DRV_HASH_SHA384,

		.hw_mode = DRV_HASH_HW_SHA512,

		.inter_digestsize = SHA512_DIGEST_SIZE,
@@ -2077,8 +1935,6 @@ static struct ssi_hash_template driver_hash[] = { 
		.hmac_name = "hmac(sha512)",

		.hmac_driver_name = "hmac-sha512-dx",

		.blocksize = SHA512_BLOCK_SIZE,

		.synchronize = false,

		{

		.template_ahash = {

			.init = ssi_ahash_init,

			.update = ssi_ahash_update,
@@ -2095,7 +1951,6 @@ static struct ssi_hash_template driver_hash[] = { 
				.statesize = sizeof(struct sha512_state),

			},

		},

		},

		.hash_mode = DRV_HASH_SHA512,

		.hw_mode = DRV_HASH_HW_SHA512,

		.inter_digestsize = SHA512_DIGEST_SIZE,
@@ -2107,8 +1962,6 @@ static struct ssi_hash_template driver_hash[] = { 
		.hmac_name = "hmac(md5)",

		.hmac_driver_name = "hmac-md5-dx",

		.blocksize = MD5_HMAC_BLOCK_SIZE,

		.synchronize = false,

		{

		.template_ahash = {

			.init = ssi_ahash_init,

			.update = ssi_ahash_update,
@@ -2125,7 +1978,6 @@ static struct ssi_hash_template driver_hash[] = { 
				.statesize = sizeof(struct md5_state),

			},

		},

		},

		.hash_mode = DRV_HASH_MD5,

		.hw_mode = DRV_HASH_HW_MD5,

		.inter_digestsize = MD5_DIGEST_SIZE,
@@ -2134,8 +1986,6 @@ static struct ssi_hash_template driver_hash[] = { 
		.name = "xcbc(aes)",

		.driver_name = "xcbc-aes-dx",

		.blocksize = AES_BLOCK_SIZE,

		.synchronize = false,

		{

		.template_ahash = {

			.init = ssi_ahash_init,

			.update = ssi_mac_update,
@@ -2152,7 +2002,6 @@ static struct ssi_hash_template driver_hash[] = { 
				.statesize = sizeof(struct aeshash_state),

			},

		},

		},

		.hash_mode = DRV_HASH_NULL,

		.hw_mode = DRV_CIPHER_XCBC_MAC,

		.inter_digestsize = AES_BLOCK_SIZE,
@@ -2162,8 +2011,6 @@ static struct ssi_hash_template driver_hash[] = { 
		.name = "cmac(aes)",

		.driver_name = "cmac-aes-dx",

		.blocksize = AES_BLOCK_SIZE,

		.synchronize = false,

		{

		.template_ahash = {

			.init = ssi_ahash_init,

			.update = ssi_mac_update,
@@ -2180,7 +2027,6 @@ static struct ssi_hash_template driver_hash[] = { 
				.statesize = sizeof(struct aeshash_state),

			},

		},

		},

		.hash_mode = DRV_HASH_NULL,

		.hw_mode = DRV_CIPHER_CMAC,

		.inter_digestsize = AES_BLOCK_SIZE,
@@ -2194,6 +2040,7 @@ ssi_hash_create_alg(struct ssi_hash_template *template, bool keyed) 
{

	struct ssi_hash_alg *t_crypto_alg;

	struct crypto_alg *alg;

	struct ahash_alg *halg;



	t_crypto_alg = kzalloc(sizeof(struct ssi_hash_alg), GFP_KERNEL);

	if (!t_crypto_alg) {
@@ -2201,20 +2048,9 @@ ssi_hash_create_alg(struct ssi_hash_template *template, bool keyed) 
		return ERR_PTR(-ENOMEM);

	}



	t_crypto_alg->synchronize = template->synchronize;

	if (template->synchronize) {

		struct shash_alg *halg;

		t_crypto_alg->shash_alg = template->template_shash;

		halg = &t_crypto_alg->shash_alg;

		alg = &halg->base;

		if (!keyed) halg->setkey = NULL;

	} else {

		struct ahash_alg *halg;

	t_crypto_alg->ahash_alg = template->template_ahash;

	halg = &t_crypto_alg->ahash_alg;

	alg = &halg->halg.base;

		if (!keyed) halg->setkey = NULL;

	}



	if (keyed) {

		snprintf(alg->cra_name, CRYPTO_MAX_ALG_NAME, "%s",
@@ -2222,6 +2058,7 @@ ssi_hash_create_alg(struct ssi_hash_template *template, bool keyed) 
		snprintf(alg->cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s",

			 template->hmac_driver_name);

	} else {

		halg->setkey = NULL;

		snprintf(alg->cra_name, CRYPTO_MAX_ALG_NAME, "%s",

			 template->name);

		snprintf(alg->cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s",
@@ -2234,17 +2071,10 @@ ssi_hash_create_alg(struct ssi_hash_template *template, bool keyed) 
	alg->cra_alignmask = 0;

	alg->cra_exit = ssi_hash_cra_exit;



	if (template->synchronize) {

		alg->cra_init = ssi_shash_cra_init;

		alg->cra_flags = CRYPTO_ALG_TYPE_SHASH |

			CRYPTO_ALG_KERN_DRIVER_ONLY;

		alg->cra_type = &crypto_shash_type;

	} else {

	alg->cra_init = ssi_ahash_cra_init;

	alg->cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_TYPE_AHASH |

			CRYPTO_ALG_KERN_DRIVER_ONLY;

	alg->cra_type = &crypto_ahash_type;

	}



	t_crypto_alg->hash_mode = template->hash_mode;

	t_crypto_alg->hw_mode = template->hw_mode;
@@ -2429,24 +2259,15 @@ int ssi_hash_alloc(struct ssi_drvdata *drvdata) 
			}

			t_alg->drvdata = drvdata;



			if (t_alg->synchronize) {

				rc = crypto_register_shash(&t_alg->shash_alg);

				if (unlikely(rc != 0)) {

					SSI_LOG_ERR("%s alg registration failed\n",

						t_alg->shash_alg.base.cra_driver_name);

					kfree(t_alg);

					goto fail;

				} else

					list_add_tail(&t_alg->entry, &hash_handle->hash_list);

			} else {

			rc = crypto_register_ahash(&t_alg->ahash_alg);

				if (unlikely(rc != 0)) {

			if (unlikely(rc)) {

				SSI_LOG_ERR("%s alg registration failed\n",

						t_alg->ahash_alg.halg.base.cra_driver_name);

					    driver_hash[alg].driver_name);

				kfree(t_alg);

				goto fail;

				} else

					list_add_tail(&t_alg->entry, &hash_handle->hash_list);

			} else {

				list_add_tail(&t_alg->entry,

					      &hash_handle->hash_list);

			}

		}
@@ -2460,24 +2281,13 @@ int ssi_hash_alloc(struct ssi_drvdata *drvdata) 
		}

		t_alg->drvdata = drvdata;



		if (t_alg->synchronize) {

			rc = crypto_register_shash(&t_alg->shash_alg);

			if (unlikely(rc != 0)) {

				SSI_LOG_ERR("%s alg registration failed\n",

					t_alg->shash_alg.base.cra_driver_name);

				kfree(t_alg);

				goto fail;

			} else

				list_add_tail(&t_alg->entry, &hash_handle->hash_list);



		} else {

		rc = crypto_register_ahash(&t_alg->ahash_alg);

			if (unlikely(rc != 0)) {

		if (unlikely(rc)) {

			SSI_LOG_ERR("%s alg registration failed\n",

					t_alg->ahash_alg.halg.base.cra_driver_name);

				    driver_hash[alg].driver_name);

			kfree(t_alg);

			goto fail;

			} else

		} else {

			list_add_tail(&t_alg->entry, &hash_handle->hash_list);

		}

	}
@@ -2501,11 +2311,7 @@ int ssi_hash_free(struct ssi_drvdata *drvdata) 
	if (hash_handle != NULL) {



		list_for_each_entry_safe(t_hash_alg, hash_n, &hash_handle->hash_list, entry) {

			if (t_hash_alg->synchronize) {

				crypto_unregister_shash(&t_hash_alg->shash_alg);

			} else {

			crypto_unregister_ahash(&t_hash_alg->ahash_alg);

			}

			list_del(&t_hash_alg->entry);

			kfree(t_hash_alg);

		}