Commit 97855e7f authored by Herbert Xu's avatar Herbert Xu
Browse files

crypto: crypto4xx - Remove ahash-related code 



The hash implementation in crypto4xx has been disabled since 2009.
As nobody has tried to fix this remove all the dead code.

Signed-off-by: default avatarHerbert Xu <herbert@gondor.apana.org.au>
parent 7916eddc

drivers/crypto/amcc/crypto4xx_alg.c

+0 −106
Original line number Diff line number Diff line
@@ -12,9 +12,6 @@ 
#include <linux/interrupt.h>

#include <linux/spinlock_types.h>

#include <linux/scatterlist.h>

#include <linux/crypto.h>

#include <linux/hash.h>

#include <crypto/internal/hash.h>

#include <linux/dma-mapping.h>

#include <crypto/algapi.h>

#include <crypto/aead.h>
@@ -602,106 +599,3 @@ int crypto4xx_decrypt_aes_gcm(struct aead_request *req) 
{

	return crypto4xx_crypt_aes_gcm(req, true);

}
 


/*

 * HASH SHA1 Functions

 */

static int crypto4xx_hash_alg_init(struct crypto_tfm *tfm,

				   unsigned int sa_len,

				   unsigned char ha,

				   unsigned char hm)

{

	struct crypto_alg *alg = tfm->__crt_alg;

	struct crypto4xx_alg *my_alg;

	struct crypto4xx_ctx *ctx = crypto_tfm_ctx(tfm);

	struct dynamic_sa_hash160 *sa;

	int rc;



	my_alg = container_of(__crypto_ahash_alg(alg), struct crypto4xx_alg,

			      alg.u.hash);

	ctx->dev   = my_alg->dev;



	/* Create SA */

	if (ctx->sa_in || ctx->sa_out)

		crypto4xx_free_sa(ctx);



	rc = crypto4xx_alloc_sa(ctx, sa_len);

	if (rc)

		return rc;



	crypto_ahash_set_reqsize(__crypto_ahash_cast(tfm),

				 sizeof(struct crypto4xx_ctx));

	sa = (struct dynamic_sa_hash160 *)ctx->sa_in;

	set_dynamic_sa_command_0(&sa->ctrl, SA_SAVE_HASH, SA_NOT_SAVE_IV,

				 SA_NOT_LOAD_HASH, SA_LOAD_IV_FROM_SA,

				 SA_NO_HEADER_PROC, ha, SA_CIPHER_ALG_NULL,

				 SA_PAD_TYPE_ZERO, SA_OP_GROUP_BASIC,

				 SA_OPCODE_HASH, DIR_INBOUND);

	set_dynamic_sa_command_1(&sa->ctrl, 0, SA_HASH_MODE_HASH,

				 CRYPTO_FEEDBACK_MODE_NO_FB, SA_EXTENDED_SN_OFF,

				 SA_SEQ_MASK_OFF, SA_MC_ENABLE,

				 SA_NOT_COPY_PAD, SA_NOT_COPY_PAYLOAD,

				 SA_NOT_COPY_HDR);

	/* Need to zero hash digest in SA */

	memset(sa->inner_digest, 0, sizeof(sa->inner_digest));

	memset(sa->outer_digest, 0, sizeof(sa->outer_digest));



	return 0;

}



int crypto4xx_hash_init(struct ahash_request *req)

{

	struct crypto4xx_ctx *ctx = crypto_tfm_ctx(req->base.tfm);

	int ds;

	struct dynamic_sa_ctl *sa;



	sa = ctx->sa_in;

	ds = crypto_ahash_digestsize(

			__crypto_ahash_cast(req->base.tfm));

	sa->sa_command_0.bf.digest_len = ds >> 2;

	sa->sa_command_0.bf.load_hash_state = SA_LOAD_HASH_FROM_SA;



	return 0;

}



int crypto4xx_hash_update(struct ahash_request *req)

{

	struct crypto_ahash *ahash = crypto_ahash_reqtfm(req);

	struct crypto4xx_ctx *ctx = crypto_tfm_ctx(req->base.tfm);

	struct scatterlist dst;

	unsigned int ds = crypto_ahash_digestsize(ahash);



	sg_init_one(&dst, req->result, ds);



	return crypto4xx_build_pd(&req->base, ctx, req->src, &dst,

				  req->nbytes, NULL, 0, ctx->sa_in,

				  ctx->sa_len, 0, NULL);

}



int crypto4xx_hash_final(struct ahash_request *req)

{

	return 0;

}



int crypto4xx_hash_digest(struct ahash_request *req)

{

	struct crypto_ahash *ahash = crypto_ahash_reqtfm(req);

	struct crypto4xx_ctx *ctx = crypto_tfm_ctx(req->base.tfm);

	struct scatterlist dst;

	unsigned int ds = crypto_ahash_digestsize(ahash);



	sg_init_one(&dst, req->result, ds);



	return crypto4xx_build_pd(&req->base, ctx, req->src, &dst,

				  req->nbytes, NULL, 0, ctx->sa_in,

				  ctx->sa_len, 0, NULL);

}



/*

 * SHA1 Algorithm

 */

int crypto4xx_sha1_alg_init(struct crypto_tfm *tfm)

{

	return crypto4xx_hash_alg_init(tfm, SA_HASH160_LEN, SA_HASH_ALG_SHA1,

				       SA_HASH_MODE_HASH);

}

drivers/crypto/amcc/crypto4xx_core.c

+1 −42
Original line number Diff line number Diff line
@@ -485,18 +485,6 @@ static void crypto4xx_copy_pkt_to_dst(struct crypto4xx_device *dev, 
	}

}



static void crypto4xx_copy_digest_to_dst(void *dst,

					struct pd_uinfo *pd_uinfo,

					struct crypto4xx_ctx *ctx)

{

	struct dynamic_sa_ctl *sa = (struct dynamic_sa_ctl *) ctx->sa_in;



	if (sa->sa_command_0.bf.hash_alg == SA_HASH_ALG_SHA1) {

		memcpy(dst, pd_uinfo->sr_va->save_digest,

		       SA_HASH_ALG_SHA1_DIGEST_SIZE);

	}

}



static void crypto4xx_ret_sg_desc(struct crypto4xx_device *dev,

				  struct pd_uinfo *pd_uinfo)

{
@@ -549,23 +537,6 @@ static void crypto4xx_cipher_done(struct crypto4xx_device *dev, 
	skcipher_request_complete(req, 0);

}



static void crypto4xx_ahash_done(struct crypto4xx_device *dev,

				struct pd_uinfo *pd_uinfo)

{

	struct crypto4xx_ctx *ctx;

	struct ahash_request *ahash_req;



	ahash_req = ahash_request_cast(pd_uinfo->async_req);

	ctx = crypto_ahash_ctx(crypto_ahash_reqtfm(ahash_req));



	crypto4xx_copy_digest_to_dst(ahash_req->result, pd_uinfo, ctx);

	crypto4xx_ret_sg_desc(dev, pd_uinfo);



	if (pd_uinfo->state & PD_ENTRY_BUSY)

		ahash_request_complete(ahash_req, -EINPROGRESS);

	ahash_request_complete(ahash_req, 0);

}



static void crypto4xx_aead_done(struct crypto4xx_device *dev,

				struct pd_uinfo *pd_uinfo,

				struct ce_pd *pd)
@@ -642,9 +613,6 @@ static void crypto4xx_pd_done(struct crypto4xx_device *dev, u32 idx) 
	case CRYPTO_ALG_TYPE_AEAD:

		crypto4xx_aead_done(dev, pd_uinfo, pd);

		break;

	case CRYPTO_ALG_TYPE_AHASH:

		crypto4xx_ahash_done(dev, pd_uinfo);

		break;

	}

}
@@ -912,8 +880,7 @@ int crypto4xx_build_pd(struct crypto_async_request *req, 
	}



	pd->pd_ctl.w = PD_CTL_HOST_READY |

		((crypto_tfm_alg_type(req->tfm) == CRYPTO_ALG_TYPE_AHASH) ||

		 (crypto_tfm_alg_type(req->tfm) == CRYPTO_ALG_TYPE_AEAD) ?

		((crypto_tfm_alg_type(req->tfm) == CRYPTO_ALG_TYPE_AEAD) ?

			PD_CTL_HASH_FINAL : 0);

	pd->pd_ctl_len.w = 0x00400000 | (assoclen + datalen);

	pd_uinfo->state = PD_ENTRY_INUSE | (is_busy ? PD_ENTRY_BUSY : 0);
@@ -1019,10 +986,6 @@ static int crypto4xx_register_alg(struct crypto4xx_device *sec_dev, 
			rc = crypto_register_aead(&alg->alg.u.aead);

			break;



		case CRYPTO_ALG_TYPE_AHASH:

			rc = crypto_register_ahash(&alg->alg.u.hash);

			break;



		case CRYPTO_ALG_TYPE_RNG:

			rc = crypto_register_rng(&alg->alg.u.rng);

			break;
@@ -1048,10 +1011,6 @@ static void crypto4xx_unregister_alg(struct crypto4xx_device *sec_dev) 
	list_for_each_entry_safe(alg, tmp, &sec_dev->alg_list, entry) {

		list_del(&alg->entry);

		switch (alg->alg.type) {

		case CRYPTO_ALG_TYPE_AHASH:

			crypto_unregister_ahash(&alg->alg.u.hash);

			break;



		case CRYPTO_ALG_TYPE_AEAD:

			crypto_unregister_aead(&alg->alg.u.aead);

			break;

drivers/crypto/amcc/crypto4xx_core.h

+0 −7
Original line number Diff line number Diff line
@@ -16,7 +16,6 @@ 
#include <linux/ratelimit.h>

#include <linux/mutex.h>

#include <linux/scatterlist.h>

#include <crypto/internal/hash.h>

#include <crypto/internal/aead.h>

#include <crypto/internal/rng.h>

#include <crypto/internal/skcipher.h>
@@ -135,7 +134,6 @@ struct crypto4xx_alg_common { 
	u32 type;

	union {

		struct skcipher_alg cipher;

		struct ahash_alg hash;

		struct aead_alg aead;

		struct rng_alg rng;

	} u;
@@ -183,11 +181,6 @@ int crypto4xx_encrypt_noiv_block(struct skcipher_request *req); 
int crypto4xx_decrypt_noiv_block(struct skcipher_request *req);

int crypto4xx_rfc3686_encrypt(struct skcipher_request *req);

int crypto4xx_rfc3686_decrypt(struct skcipher_request *req);

int crypto4xx_sha1_alg_init(struct crypto_tfm *tfm);

int crypto4xx_hash_digest(struct ahash_request *req);

int crypto4xx_hash_final(struct ahash_request *req);

int crypto4xx_hash_update(struct ahash_request *req);

int crypto4xx_hash_init(struct ahash_request *req);



/*

 * Note: Only use this function to copy items that is word aligned.