alg                65 arch/arm/crypto/sha1-ce-glue.c static struct shash_alg alg = {
alg                83 arch/arm/crypto/sha1-ce-glue.c 	return crypto_register_shash(&alg);
alg                88 arch/arm/crypto/sha1-ce-glue.c 	crypto_unregister_shash(&alg);
alg                54 arch/arm/crypto/sha1_glue.c static struct shash_alg alg = {
alg                73 arch/arm/crypto/sha1_glue.c 	return crypto_register_shash(&alg);
alg                79 arch/arm/crypto/sha1_glue.c 	crypto_unregister_shash(&alg);
alg                71 arch/arm/crypto/sha1_neon_glue.c static struct shash_alg alg = {
alg                92 arch/arm/crypto/sha1_neon_glue.c 	return crypto_register_shash(&alg);
alg                97 arch/arm/crypto/sha1_neon_glue.c 	crypto_unregister_shash(&alg);
alg                89 arch/arm64/crypto/sha1-ce-glue.c static struct shash_alg alg = {
alg               107 arch/arm64/crypto/sha1-ce-glue.c 	return crypto_register_shash(&alg);
alg               112 arch/arm64/crypto/sha1-ce-glue.c 	crypto_unregister_shash(&alg);
alg               172 arch/mips/cavium-octeon/crypto/octeon-md5.c static struct shash_alg alg = {
alg               194 arch/mips/cavium-octeon/crypto/octeon-md5.c 	return crypto_register_shash(&alg);
alg               199 arch/mips/cavium-octeon/crypto/octeon-md5.c 	crypto_unregister_shash(&alg);
alg               134 arch/powerpc/crypto/crc32c-vpmsum_glue.c static struct shash_alg alg = {
alg               160 arch/powerpc/crypto/crc32c-vpmsum_glue.c 	return crypto_register_shash(&alg);
alg               165 arch/powerpc/crypto/crc32c-vpmsum_glue.c 	crypto_unregister_shash(&alg);
alg                91 arch/powerpc/crypto/crct10dif-vpmsum_glue.c static struct shash_alg alg = {
alg               111 arch/powerpc/crypto/crct10dif-vpmsum_glue.c 	return crypto_register_shash(&alg);
alg               116 arch/powerpc/crypto/crct10dif-vpmsum_glue.c 	crypto_unregister_shash(&alg);
alg               124 arch/powerpc/crypto/md5-glue.c static struct shash_alg alg = {
alg               144 arch/powerpc/crypto/md5-glue.c 	return crypto_register_shash(&alg);
alg               149 arch/powerpc/crypto/md5-glue.c 	crypto_unregister_shash(&alg);
alg               170 arch/powerpc/crypto/sha1-spe-glue.c static struct shash_alg alg = {
alg               190 arch/powerpc/crypto/sha1-spe-glue.c 	return crypto_register_shash(&alg);
alg               195 arch/powerpc/crypto/sha1-spe-glue.c 	crypto_unregister_shash(&alg);
alg               118 arch/powerpc/crypto/sha1.c static struct shash_alg alg = {
alg               137 arch/powerpc/crypto/sha1.c 	return crypto_register_shash(&alg);
alg               142 arch/powerpc/crypto/sha1.c 	crypto_unregister_shash(&alg);
alg              1123 arch/s390/crypto/aes_s390.c static int aes_s390_register_alg(struct crypto_alg *alg)
alg              1127 arch/s390/crypto/aes_s390.c 	ret = crypto_register_alg(alg);
alg              1129 arch/s390/crypto/aes_s390.c 		aes_s390_algs_ptr[aes_s390_algs_num++] = alg;
alg               189 arch/s390/crypto/crc32-vx.c #define CRC32_VX_FINUP(alg, func)					      \
alg               190 arch/s390/crypto/crc32-vx.c 	static int alg ## _vx_finup(struct shash_desc *desc, const u8 *data,  \
alg               193 arch/s390/crypto/crc32-vx.c 		return __ ## alg ## _vx_finup(shash_desc_ctx(desc),	      \
alg               201 arch/s390/crypto/crc32-vx.c #define CRC32_VX_DIGEST(alg, func)					      \
alg               202 arch/s390/crypto/crc32-vx.c 	static int alg ## _vx_digest(struct shash_desc *desc, const u8 *data, \
alg               205 arch/s390/crypto/crc32-vx.c 		return __ ## alg ## _vx_finup(crypto_shash_ctx(desc->tfm),    \
alg               213 arch/s390/crypto/crc32-vx.c #define CRC32_VX_UPDATE(alg, func)					      \
alg               214 arch/s390/crypto/crc32-vx.c 	static int alg ## _vx_update(struct shash_desc *desc, const u8 *data, \
alg               490 arch/s390/crypto/des_s390.c static int des_s390_register_alg(struct crypto_alg *alg)
alg               494 arch/s390/crypto/des_s390.c 	ret = crypto_register_alg(alg);
alg               496 arch/s390/crypto/des_s390.c 		des_s390_algs_ptr[des_s390_algs_num++] = alg;
alg               692 arch/s390/crypto/paes_s390.c static inline void __crypto_unregister_alg(struct crypto_alg *alg)
alg               694 arch/s390/crypto/paes_s390.c 	if (!list_empty(&alg->cra_list))
alg               695 arch/s390/crypto/paes_s390.c 		crypto_unregister_alg(alg);
alg                68 arch/s390/crypto/sha1_s390.c static struct shash_alg alg = {
alg                90 arch/s390/crypto/sha1_s390.c 	return crypto_register_shash(&alg);
alg                95 arch/s390/crypto/sha1_s390.c 	crypto_unregister_shash(&alg);
alg               124 arch/sparc/crypto/crc32c_glue.c static struct shash_alg alg = {
alg               164 arch/sparc/crypto/crc32c_glue.c 		return crypto_register_shash(&alg);
alg               172 arch/sparc/crypto/crc32c_glue.c 	crypto_unregister_shash(&alg);
alg               135 arch/sparc/crypto/md5_glue.c static struct shash_alg alg = {
alg               171 arch/sparc/crypto/md5_glue.c 		return crypto_register_shash(&alg);
alg               179 arch/sparc/crypto/md5_glue.c 	crypto_unregister_shash(&alg);
alg               130 arch/sparc/crypto/sha1_glue.c static struct shash_alg alg = {
alg               166 arch/sparc/crypto/sha1_glue.c 		return crypto_register_shash(&alg);
alg               174 arch/sparc/crypto/sha1_glue.c 	crypto_unregister_shash(&alg);
alg               153 arch/x86/crypto/crc32-pclmul_glue.c static struct shash_alg alg = {
alg               188 arch/x86/crypto/crc32-pclmul_glue.c 	return crypto_register_shash(&alg);
alg               193 arch/x86/crypto/crc32-pclmul_glue.c 	crypto_unregister_shash(&alg);
alg               204 arch/x86/crypto/crc32c-intel_glue.c static struct shash_alg alg = {
alg               237 arch/x86/crypto/crc32c-intel_glue.c 		alg.update = crc32c_pcl_intel_update;
alg               238 arch/x86/crypto/crc32c-intel_glue.c 		alg.finup = crc32c_pcl_intel_finup;
alg               239 arch/x86/crypto/crc32c-intel_glue.c 		alg.digest = crc32c_pcl_intel_digest;
alg               242 arch/x86/crypto/crc32c-intel_glue.c 	return crypto_register_shash(&alg);
alg               247 arch/x86/crypto/crc32c-intel_glue.c 	crypto_unregister_shash(&alg);
alg                99 arch/x86/crypto/crct10dif-pclmul_glue.c static struct shash_alg alg = {
alg               127 arch/x86/crypto/crct10dif-pclmul_glue.c 	return crypto_register_shash(&alg);
alg               132 arch/x86/crypto/crct10dif-pclmul_glue.c 	crypto_unregister_shash(&alg);
alg               160 arch/x86/crypto/poly1305_glue.c static struct shash_alg alg = {
alg               184 arch/x86/crypto/poly1305_glue.c 	alg.descsize = sizeof(struct poly1305_simd_desc_ctx);
alg               186 arch/x86/crypto/poly1305_glue.c 		alg.descsize += 10 * sizeof(u32);
alg               188 arch/x86/crypto/poly1305_glue.c 	return crypto_register_shash(&alg);
alg               193 arch/x86/crypto/poly1305_glue.c 	crypto_unregister_shash(&alg);
alg                64 arch/x86/crypto/twofish_glue.c static struct crypto_alg alg = {
alg                86 arch/x86/crypto/twofish_glue.c 	return crypto_register_alg(&alg);
alg                91 arch/x86/crypto/twofish_glue.c 	crypto_unregister_alg(&alg);
alg                95 crypto/842.c   static struct crypto_alg alg = {
alg               126 crypto/842.c   	ret = crypto_register_alg(&alg);
alg               132 crypto/842.c   		crypto_unregister_alg(&alg);
alg               142 crypto/842.c   	crypto_unregister_alg(&alg);
alg               334 crypto/ablkcipher.c static unsigned int crypto_ablkcipher_ctxsize(struct crypto_alg *alg, u32 type,
alg               337 crypto/ablkcipher.c 	return alg->cra_ctxsize;
alg               343 crypto/ablkcipher.c 	struct ablkcipher_alg *alg = &tfm->__crt_alg->cra_ablkcipher;
alg               346 crypto/ablkcipher.c 	if (alg->ivsize > PAGE_SIZE / 8)
alg               350 crypto/ablkcipher.c 	crt->encrypt = alg->encrypt;
alg               351 crypto/ablkcipher.c 	crt->decrypt = alg->decrypt;
alg               353 crypto/ablkcipher.c 	crt->ivsize = alg->ivsize;
alg               359 crypto/ablkcipher.c static int crypto_ablkcipher_report(struct sk_buff *skb, struct crypto_alg *alg)
alg               368 crypto/ablkcipher.c 	rblkcipher.blocksize = alg->cra_blocksize;
alg               369 crypto/ablkcipher.c 	rblkcipher.min_keysize = alg->cra_ablkcipher.min_keysize;
alg               370 crypto/ablkcipher.c 	rblkcipher.max_keysize = alg->cra_ablkcipher.max_keysize;
alg               371 crypto/ablkcipher.c 	rblkcipher.ivsize = alg->cra_ablkcipher.ivsize;
alg               377 crypto/ablkcipher.c static int crypto_ablkcipher_report(struct sk_buff *skb, struct crypto_alg *alg)
alg               383 crypto/ablkcipher.c static void crypto_ablkcipher_show(struct seq_file *m, struct crypto_alg *alg)
alg               385 crypto/ablkcipher.c static void crypto_ablkcipher_show(struct seq_file *m, struct crypto_alg *alg)
alg               387 crypto/ablkcipher.c 	struct ablkcipher_alg *ablkcipher = &alg->cra_ablkcipher;
alg               390 crypto/ablkcipher.c 	seq_printf(m, "async        : %s\n", alg->cra_flags & CRYPTO_ALG_ASYNC ?
alg               392 crypto/ablkcipher.c 	seq_printf(m, "blocksize    : %u\n", alg->cra_blocksize);
alg                27 crypto/acompress.c static int crypto_acomp_report(struct sk_buff *skb, struct crypto_alg *alg)
alg                38 crypto/acompress.c static int crypto_acomp_report(struct sk_buff *skb, struct crypto_alg *alg)
alg                44 crypto/acompress.c static void crypto_acomp_show(struct seq_file *m, struct crypto_alg *alg)
alg                47 crypto/acompress.c static void crypto_acomp_show(struct seq_file *m, struct crypto_alg *alg)
alg                55 crypto/acompress.c 	struct acomp_alg *alg = crypto_acomp_alg(acomp);
alg                57 crypto/acompress.c 	alg->exit(acomp);
alg                63 crypto/acompress.c 	struct acomp_alg *alg = crypto_acomp_alg(acomp);
alg                68 crypto/acompress.c 	acomp->compress = alg->compress;
alg                69 crypto/acompress.c 	acomp->decompress = alg->decompress;
alg                70 crypto/acompress.c 	acomp->dst_free = alg->dst_free;
alg                71 crypto/acompress.c 	acomp->reqsize = alg->reqsize;
alg                73 crypto/acompress.c 	if (alg->exit)
alg                76 crypto/acompress.c 	if (alg->init)
alg                77 crypto/acompress.c 		return alg->init(acomp);
alg                82 crypto/acompress.c static unsigned int crypto_acomp_extsize(struct crypto_alg *alg)
alg                84 crypto/acompress.c 	int extsize = crypto_alg_extsize(alg);
alg                86 crypto/acompress.c 	if (alg->cra_type != &crypto_acomp_type)
alg               142 crypto/acompress.c int crypto_register_acomp(struct acomp_alg *alg)
alg               144 crypto/acompress.c 	struct crypto_alg *base = &alg->base;
alg               154 crypto/acompress.c int crypto_unregister_acomp(struct acomp_alg *alg)
alg               156 crypto/acompress.c 	return crypto_unregister_alg(&alg->base);
alg               557 crypto/adiantum.c 	blockcipher_alg = ictx->blockcipher_spawn.alg;
alg               586 crypto/adiantum.c 	if (snprintf(inst->alg.base.cra_name, CRYPTO_MAX_ALG_NAME,
alg               590 crypto/adiantum.c 	if (snprintf(inst->alg.base.cra_driver_name, CRYPTO_MAX_ALG_NAME,
alg               597 crypto/adiantum.c 	inst->alg.base.cra_flags = streamcipher_alg->base.cra_flags &
alg               599 crypto/adiantum.c 	inst->alg.base.cra_blocksize = BLOCKCIPHER_BLOCK_SIZE;
alg               600 crypto/adiantum.c 	inst->alg.base.cra_ctxsize = sizeof(struct adiantum_tfm_ctx);
alg               601 crypto/adiantum.c 	inst->alg.base.cra_alignmask = streamcipher_alg->base.cra_alignmask |
alg               609 crypto/adiantum.c 	inst->alg.base.cra_priority = (4 * streamcipher_alg->base.cra_priority +
alg               613 crypto/adiantum.c 	inst->alg.setkey = adiantum_setkey;
alg               614 crypto/adiantum.c 	inst->alg.encrypt = adiantum_encrypt;
alg               615 crypto/adiantum.c 	inst->alg.decrypt = adiantum_decrypt;
alg               616 crypto/adiantum.c 	inst->alg.init = adiantum_init_tfm;
alg               617 crypto/adiantum.c 	inst->alg.exit = adiantum_exit_tfm;
alg               618 crypto/adiantum.c 	inst->alg.min_keysize = crypto_skcipher_alg_min_keysize(streamcipher_alg);
alg               619 crypto/adiantum.c 	inst->alg.max_keysize = crypto_skcipher_alg_max_keysize(streamcipher_alg);
alg               620 crypto/adiantum.c 	inst->alg.ivsize = TWEAK_SIZE;
alg                91 crypto/aead.c  	struct crypto_alg *alg = aead->base.__crt_alg;
alg                95 crypto/aead.c  	crypto_stats_get(alg);
alg               100 crypto/aead.c  	crypto_stats_aead_encrypt(cryptlen, alg, ret);
alg               108 crypto/aead.c  	struct crypto_alg *alg = aead->base.__crt_alg;
alg               112 crypto/aead.c  	crypto_stats_get(alg);
alg               119 crypto/aead.c  	crypto_stats_aead_decrypt(cryptlen, alg, ret);
alg               127 crypto/aead.c  	struct aead_alg *alg = crypto_aead_alg(aead);
alg               129 crypto/aead.c  	alg->exit(aead);
alg               135 crypto/aead.c  	struct aead_alg *alg = crypto_aead_alg(aead);
alg               139 crypto/aead.c  	aead->authsize = alg->maxauthsize;
alg               141 crypto/aead.c  	if (alg->exit)
alg               144 crypto/aead.c  	if (alg->init)
alg               145 crypto/aead.c  		return alg->init(aead);
alg               151 crypto/aead.c  static int crypto_aead_report(struct sk_buff *skb, struct crypto_alg *alg)
alg               154 crypto/aead.c  	struct aead_alg *aead = container_of(alg, struct aead_alg, base);
alg               161 crypto/aead.c  	raead.blocksize = alg->cra_blocksize;
alg               168 crypto/aead.c  static int crypto_aead_report(struct sk_buff *skb, struct crypto_alg *alg)
alg               174 crypto/aead.c  static void crypto_aead_show(struct seq_file *m, struct crypto_alg *alg)
alg               176 crypto/aead.c  static void crypto_aead_show(struct seq_file *m, struct crypto_alg *alg)
alg               178 crypto/aead.c  	struct aead_alg *aead = container_of(alg, struct aead_alg, base);
alg               181 crypto/aead.c  	seq_printf(m, "async        : %s\n", alg->cra_flags & CRYPTO_ALG_ASYNC ?
alg               183 crypto/aead.c  	seq_printf(m, "blocksize    : %u\n", alg->cra_blocksize);
alg               238 crypto/aead.c  	struct aead_alg *alg;
alg               268 crypto/aead.c  	alg = crypto_spawn_aead_alg(spawn);
alg               270 crypto/aead.c  	ivsize = crypto_aead_alg_ivsize(alg);
alg               271 crypto/aead.c  	maxauthsize = crypto_aead_alg_maxauthsize(alg);
alg               278 crypto/aead.c  	if (snprintf(inst->alg.base.cra_name, CRYPTO_MAX_ALG_NAME,
alg               279 crypto/aead.c  		     "%s(%s)", tmpl->name, alg->base.cra_name) >=
alg               282 crypto/aead.c  	if (snprintf(inst->alg.base.cra_driver_name, CRYPTO_MAX_ALG_NAME,
alg               283 crypto/aead.c  		     "%s(%s)", tmpl->name, alg->base.cra_driver_name) >=
alg               287 crypto/aead.c  	inst->alg.base.cra_flags = alg->base.cra_flags & CRYPTO_ALG_ASYNC;
alg               288 crypto/aead.c  	inst->alg.base.cra_priority = alg->base.cra_priority;
alg               289 crypto/aead.c  	inst->alg.base.cra_blocksize = alg->base.cra_blocksize;
alg               290 crypto/aead.c  	inst->alg.base.cra_alignmask = alg->base.cra_alignmask;
alg               291 crypto/aead.c  	inst->alg.base.cra_ctxsize = sizeof(struct aead_geniv_ctx);
alg               293 crypto/aead.c  	inst->alg.setkey = aead_geniv_setkey;
alg               294 crypto/aead.c  	inst->alg.setauthsize = aead_geniv_setauthsize;
alg               296 crypto/aead.c  	inst->alg.ivsize = ivsize;
alg               297 crypto/aead.c  	inst->alg.maxauthsize = maxauthsize;
alg               385 crypto/aead.c  static int aead_prepare_alg(struct aead_alg *alg)
alg               387 crypto/aead.c  	struct crypto_alg *base = &alg->base;
alg               389 crypto/aead.c  	if (max3(alg->maxauthsize, alg->ivsize, alg->chunksize) >
alg               393 crypto/aead.c  	if (!alg->chunksize)
alg               394 crypto/aead.c  		alg->chunksize = base->cra_blocksize;
alg               403 crypto/aead.c  int crypto_register_aead(struct aead_alg *alg)
alg               405 crypto/aead.c  	struct crypto_alg *base = &alg->base;
alg               408 crypto/aead.c  	err = aead_prepare_alg(alg);
alg               416 crypto/aead.c  void crypto_unregister_aead(struct aead_alg *alg)
alg               418 crypto/aead.c  	crypto_unregister_alg(&alg->base);
alg               456 crypto/aead.c  	err = aead_prepare_alg(&inst->alg);
alg               196 crypto/ahash.c 	const struct hash_alg_common *alg = crypto_hash_alg_common(tfm);
alg               199 crypto/ahash.c 	    !(alg->base.cra_flags & CRYPTO_ALG_OPTIONAL_KEY))
alg               374 crypto/ahash.c 	struct crypto_alg *alg = tfm->base.__crt_alg;
alg               378 crypto/ahash.c 	crypto_stats_get(alg);
alg               380 crypto/ahash.c 	crypto_stats_ahash_final(nbytes, ret, alg);
alg               388 crypto/ahash.c 	struct crypto_alg *alg = tfm->base.__crt_alg;
alg               392 crypto/ahash.c 	crypto_stats_get(alg);
alg               394 crypto/ahash.c 	crypto_stats_ahash_final(nbytes, ret, alg);
alg               402 crypto/ahash.c 	struct crypto_alg *alg = tfm->base.__crt_alg;
alg               406 crypto/ahash.c 	crypto_stats_get(alg);
alg               411 crypto/ahash.c 	crypto_stats_ahash_final(nbytes, ret, alg);
alg               481 crypto/ahash.c 	struct ahash_alg *alg = crypto_ahash_alg(hash);
alg               488 crypto/ahash.c 	hash->init = alg->init;
alg               489 crypto/ahash.c 	hash->update = alg->update;
alg               490 crypto/ahash.c 	hash->final = alg->final;
alg               491 crypto/ahash.c 	hash->finup = alg->finup ?: ahash_def_finup;
alg               492 crypto/ahash.c 	hash->digest = alg->digest;
alg               493 crypto/ahash.c 	hash->export = alg->export;
alg               494 crypto/ahash.c 	hash->import = alg->import;
alg               496 crypto/ahash.c 	if (alg->setkey) {
alg               497 crypto/ahash.c 		hash->setkey = alg->setkey;
alg               504 crypto/ahash.c static unsigned int crypto_ahash_extsize(struct crypto_alg *alg)
alg               506 crypto/ahash.c 	if (alg->cra_type != &crypto_ahash_type)
alg               509 crypto/ahash.c 	return crypto_alg_extsize(alg);
alg               513 crypto/ahash.c static int crypto_ahash_report(struct sk_buff *skb, struct crypto_alg *alg)
alg               521 crypto/ahash.c 	rhash.blocksize = alg->cra_blocksize;
alg               522 crypto/ahash.c 	rhash.digestsize = __crypto_hash_alg_common(alg)->digestsize;
alg               527 crypto/ahash.c static int crypto_ahash_report(struct sk_buff *skb, struct crypto_alg *alg)
alg               533 crypto/ahash.c static void crypto_ahash_show(struct seq_file *m, struct crypto_alg *alg)
alg               535 crypto/ahash.c static void crypto_ahash_show(struct seq_file *m, struct crypto_alg *alg)
alg               538 crypto/ahash.c 	seq_printf(m, "async        : %s\n", alg->cra_flags & CRYPTO_ALG_ASYNC ?
alg               540 crypto/ahash.c 	seq_printf(m, "blocksize    : %u\n", alg->cra_blocksize);
alg               542 crypto/ahash.c 		   __crypto_hash_alg_common(alg)->digestsize);
alg               572 crypto/ahash.c static int ahash_prepare_alg(struct ahash_alg *alg)
alg               574 crypto/ahash.c 	struct crypto_alg *base = &alg->halg.base;
alg               576 crypto/ahash.c 	if (alg->halg.digestsize > HASH_MAX_DIGESTSIZE ||
alg               577 crypto/ahash.c 	    alg->halg.statesize > HASH_MAX_STATESIZE ||
alg               578 crypto/ahash.c 	    alg->halg.statesize == 0)
alg               588 crypto/ahash.c int crypto_register_ahash(struct ahash_alg *alg)
alg               590 crypto/ahash.c 	struct crypto_alg *base = &alg->halg.base;
alg               593 crypto/ahash.c 	err = ahash_prepare_alg(alg);
alg               601 crypto/ahash.c int crypto_unregister_ahash(struct ahash_alg *alg)
alg               603 crypto/ahash.c 	return crypto_unregister_alg(&alg->halg.base);
alg               641 crypto/ahash.c 	err = ahash_prepare_alg(&inst->alg);
alg               657 crypto/ahash.c 			    struct hash_alg_common *alg,
alg               660 crypto/ahash.c 	return crypto_init_spawn2(&spawn->base, &alg->base, inst,
alg               667 crypto/ahash.c 	struct crypto_alg *alg;
alg               669 crypto/ahash.c 	alg = crypto_attr_alg2(rta, &crypto_ahash_type, type, mask);
alg               670 crypto/ahash.c 	return IS_ERR(alg) ? ERR_CAST(alg) : __crypto_hash_alg_common(alg);
alg               676 crypto/ahash.c 	struct crypto_alg *alg = &halg->base;
alg               678 crypto/ahash.c 	if (alg->cra_type != &crypto_ahash_type)
alg               679 crypto/ahash.c 		return crypto_shash_alg_has_setkey(__crypto_shash_alg(alg));
alg               681 crypto/ahash.c 	return __crypto_ahash_alg(alg)->setkey != NULL;
alg                24 crypto/akcipher.c static int crypto_akcipher_report(struct sk_buff *skb, struct crypto_alg *alg)
alg                36 crypto/akcipher.c static int crypto_akcipher_report(struct sk_buff *skb, struct crypto_alg *alg)
alg                42 crypto/akcipher.c static void crypto_akcipher_show(struct seq_file *m, struct crypto_alg *alg)
alg                45 crypto/akcipher.c static void crypto_akcipher_show(struct seq_file *m, struct crypto_alg *alg)
alg                53 crypto/akcipher.c 	struct akcipher_alg *alg = crypto_akcipher_alg(akcipher);
alg                55 crypto/akcipher.c 	alg->exit(akcipher);
alg                61 crypto/akcipher.c 	struct akcipher_alg *alg = crypto_akcipher_alg(akcipher);
alg                63 crypto/akcipher.c 	if (alg->exit)
alg                66 crypto/akcipher.c 	if (alg->init)
alg                67 crypto/akcipher.c 		return alg->init(akcipher);
alg               108 crypto/akcipher.c static void akcipher_prepare_alg(struct akcipher_alg *alg)
alg               110 crypto/akcipher.c 	struct crypto_alg *base = &alg->base;
alg               122 crypto/akcipher.c int crypto_register_akcipher(struct akcipher_alg *alg)
alg               124 crypto/akcipher.c 	struct crypto_alg *base = &alg->base;
alg               126 crypto/akcipher.c 	if (!alg->sign)
alg               127 crypto/akcipher.c 		alg->sign = akcipher_default_op;
alg               128 crypto/akcipher.c 	if (!alg->verify)
alg               129 crypto/akcipher.c 		alg->verify = akcipher_default_op;
alg               130 crypto/akcipher.c 	if (!alg->encrypt)
alg               131 crypto/akcipher.c 		alg->encrypt = akcipher_default_op;
alg               132 crypto/akcipher.c 	if (!alg->decrypt)
alg               133 crypto/akcipher.c 		alg->decrypt = akcipher_default_op;
alg               135 crypto/akcipher.c 	akcipher_prepare_alg(alg);
alg               140 crypto/akcipher.c void crypto_unregister_akcipher(struct akcipher_alg *alg)
alg               142 crypto/akcipher.c 	crypto_unregister_alg(&alg->base);
alg               149 crypto/akcipher.c 	akcipher_prepare_alg(&inst->alg);
alg                31 crypto/algapi.c static int crypto_check_alg(struct crypto_alg *alg)
alg                33 crypto/algapi.c 	crypto_check_module_sig(alg->cra_module);
alg                35 crypto/algapi.c 	if (!alg->cra_name[0] || !alg->cra_driver_name[0])
alg                38 crypto/algapi.c 	if (alg->cra_alignmask & (alg->cra_alignmask + 1))
alg                42 crypto/algapi.c 	if (alg->cra_alignmask > MAX_ALGAPI_ALIGNMASK)
alg                45 crypto/algapi.c 	if (alg->cra_blocksize > MAX_ALGAPI_BLOCKSIZE)
alg                49 crypto/algapi.c 	if (!alg->cra_type && (alg->cra_flags & CRYPTO_ALG_TYPE_MASK) ==
alg                51 crypto/algapi.c 		if (alg->cra_alignmask > MAX_CIPHER_ALIGNMASK)
alg                54 crypto/algapi.c 		if (alg->cra_blocksize > MAX_CIPHER_BLOCKSIZE)
alg                58 crypto/algapi.c 	if (alg->cra_priority < 0)
alg                61 crypto/algapi.c 	refcount_set(&alg->cra_refcnt, 1);
alg                68 crypto/algapi.c 	if (!inst->alg.cra_type->free) {
alg                73 crypto/algapi.c 	inst->alg.cra_type->free(inst);
alg                76 crypto/algapi.c static void crypto_destroy_instance(struct crypto_alg *alg)
alg                78 crypto/algapi.c 	struct crypto_instance *inst = (void *)alg;
alg                85 crypto/algapi.c static struct list_head *crypto_more_spawns(struct crypto_alg *alg,
alg                98 crypto/algapi.c 	if (spawn->alg && &n->list != stack && !n->alg)
alg                99 crypto/algapi.c 		n->alg = (n->list.next == stack) ? alg :
alg               100 crypto/algapi.c 			 &list_next_entry(n, list)->inst->alg;
alg               104 crypto/algapi.c 	return &n->list == stack ? top : &n->inst->alg.cra_users;
alg               112 crypto/algapi.c 	if (crypto_is_dead(&inst->alg))
alg               115 crypto/algapi.c 	inst->alg.cra_flags |= CRYPTO_ALG_DEAD;
alg               122 crypto/algapi.c 	list_move(&inst->alg.cra_list, list);
alg               124 crypto/algapi.c 	inst->alg.cra_destroy = crypto_destroy_instance;
alg               126 crypto/algapi.c 	BUG_ON(!list_empty(&inst->alg.cra_users));
alg               129 crypto/algapi.c void crypto_remove_spawns(struct crypto_alg *alg, struct list_head *list,
alg               132 crypto/algapi.c 	u32 new_type = (nalg ?: alg)->cra_flags;
alg               139 crypto/algapi.c 	spawns = &alg->cra_users;
alg               141 crypto/algapi.c 		if ((spawn->alg->cra_flags ^ new_type) & spawn->mask)
alg               156 crypto/algapi.c 			BUG_ON(&inst->alg == alg);
alg               160 crypto/algapi.c 			if (&inst->alg == nalg)
alg               163 crypto/algapi.c 			spawn->alg = NULL;
alg               164 crypto/algapi.c 			spawns = &inst->alg.cra_users;
alg               178 crypto/algapi.c 	} while ((spawns = crypto_more_spawns(alg, &stack, &top,
alg               182 crypto/algapi.c 		if (spawn->alg)
alg               183 crypto/algapi.c 			list_move(&spawn->list, &spawn->alg->cra_users);
alg               190 crypto/algapi.c static struct crypto_larval *__crypto_register_alg(struct crypto_alg *alg)
alg               196 crypto/algapi.c 	if (crypto_is_dead(alg))
alg               199 crypto/algapi.c 	INIT_LIST_HEAD(&alg->cra_users);
alg               202 crypto/algapi.c 	alg->cra_flags &= ~CRYPTO_ALG_TESTED;
alg               207 crypto/algapi.c 		if (q == alg)
alg               214 crypto/algapi.c 			if (!strcmp(alg->cra_driver_name, q->cra_driver_name))
alg               219 crypto/algapi.c 		if (!strcmp(q->cra_driver_name, alg->cra_name) ||
alg               220 crypto/algapi.c 		    !strcmp(q->cra_name, alg->cra_driver_name))
alg               224 crypto/algapi.c 	larval = crypto_larval_alloc(alg->cra_name,
alg               225 crypto/algapi.c 				     alg->cra_flags | CRYPTO_ALG_TESTED, 0);
alg               230 crypto/algapi.c 	larval->adult = crypto_mod_get(alg);
alg               234 crypto/algapi.c 	refcount_set(&larval->alg.cra_refcnt, 1);
alg               235 crypto/algapi.c 	memcpy(larval->alg.cra_driver_name, alg->cra_driver_name,
alg               237 crypto/algapi.c 	larval->alg.cra_priority = alg->cra_priority;
alg               239 crypto/algapi.c 	list_add(&alg->cra_list, &crypto_alg_list);
alg               240 crypto/algapi.c 	list_add(&larval->alg.cra_list, &crypto_alg_list);
alg               242 crypto/algapi.c 	crypto_stats_init(alg);
alg               257 crypto/algapi.c 	struct crypto_alg *alg;
alg               278 crypto/algapi.c 	alg = test->adult;
alg               279 crypto/algapi.c 	if (err || list_empty(&alg->cra_list))
alg               282 crypto/algapi.c 	alg->cra_flags |= CRYPTO_ALG_TESTED;
alg               290 crypto/algapi.c 		if (strcmp(alg->cra_name, q->cra_name))
alg               293 crypto/algapi.c 		if (q->cra_priority > alg->cra_priority) {
alg               300 crypto/algapi.c 		if (q == alg)
alg               314 crypto/algapi.c 			if (strcmp(alg->cra_name, q->cra_name) &&
alg               315 crypto/algapi.c 			    strcmp(alg->cra_driver_name, q->cra_name))
alg               320 crypto/algapi.c 			if ((q->cra_flags ^ alg->cra_flags) & larval->mask)
alg               323 crypto/algapi.c 			if (best && crypto_mod_get(alg))
alg               324 crypto/algapi.c 				larval->adult = alg;
alg               331 crypto/algapi.c 		if (strcmp(alg->cra_name, q->cra_name))
alg               334 crypto/algapi.c 		if (strcmp(alg->cra_driver_name, q->cra_driver_name) &&
alg               335 crypto/algapi.c 		    q->cra_priority > alg->cra_priority)
alg               338 crypto/algapi.c 		crypto_remove_spawns(q, &list, alg);
alg               353 crypto/algapi.c 	struct crypto_alg *alg;
alg               356 crypto/algapi.c 	list_for_each_entry_safe(alg, n, list, cra_list) {
alg               357 crypto/algapi.c 		list_del_init(&alg->cra_list);
alg               358 crypto/algapi.c 		crypto_alg_put(alg);
alg               371 crypto/algapi.c 		crypto_alg_tested(larval->alg.cra_driver_name, 0);
alg               380 crypto/algapi.c 	crypto_larval_kill(&larval->alg);
alg               383 crypto/algapi.c int crypto_register_alg(struct crypto_alg *alg)
alg               388 crypto/algapi.c 	alg->cra_flags &= ~CRYPTO_ALG_DEAD;
alg               389 crypto/algapi.c 	err = crypto_check_alg(alg);
alg               394 crypto/algapi.c 	larval = __crypto_register_alg(alg);
alg               405 crypto/algapi.c static int crypto_remove_alg(struct crypto_alg *alg, struct list_head *list)
alg               407 crypto/algapi.c 	if (unlikely(list_empty(&alg->cra_list)))
alg               410 crypto/algapi.c 	alg->cra_flags |= CRYPTO_ALG_DEAD;
alg               412 crypto/algapi.c 	list_del_init(&alg->cra_list);
alg               413 crypto/algapi.c 	crypto_remove_spawns(alg, list, NULL);
alg               418 crypto/algapi.c int crypto_unregister_alg(struct crypto_alg *alg)
alg               424 crypto/algapi.c 	ret = crypto_remove_alg(alg, &list);
alg               430 crypto/algapi.c 	BUG_ON(refcount_read(&alg->cra_refcnt) != 1);
alg               431 crypto/algapi.c 	if (alg->cra_destroy)
alg               432 crypto/algapi.c 		alg->cra_destroy(alg);
alg               528 crypto/algapi.c 		int err = crypto_remove_alg(&inst->alg, &users);
alg               536 crypto/algapi.c 		BUG_ON(refcount_read(&inst->alg.cra_refcnt) != 1);
alg               584 crypto/algapi.c 	err = crypto_check_alg(&inst->alg);
alg               588 crypto/algapi.c 	inst->alg.cra_module = tmpl->module;
alg               589 crypto/algapi.c 	inst->alg.cra_flags |= CRYPTO_ALG_INSTANCE;
alg               593 crypto/algapi.c 	larval = __crypto_register_alg(&inst->alg);
alg               621 crypto/algapi.c 	crypto_remove_spawns(&inst->alg, &list, NULL);
alg               632 crypto/algapi.c int crypto_init_spawn(struct crypto_spawn *spawn, struct crypto_alg *alg,
alg               644 crypto/algapi.c 	if (!crypto_is_moribund(alg)) {
alg               645 crypto/algapi.c 		list_add(&spawn->list, &alg->cra_users);
alg               646 crypto/algapi.c 		spawn->alg = alg;
alg               655 crypto/algapi.c int crypto_init_spawn2(struct crypto_spawn *spawn, struct crypto_alg *alg,
alg               661 crypto/algapi.c 	if ((alg->cra_flags ^ frontend->type) & frontend->maskset)
alg               665 crypto/algapi.c 	err = crypto_init_spawn(spawn, alg, inst, frontend->maskset);
alg               675 crypto/algapi.c 	struct crypto_alg *alg;
alg               678 crypto/algapi.c 	alg = crypto_find_alg(name, spawn->frontend, type, mask);
alg               679 crypto/algapi.c 	if (IS_ERR(alg))
alg               680 crypto/algapi.c 		return PTR_ERR(alg);
alg               682 crypto/algapi.c 	err = crypto_init_spawn(spawn, alg, spawn->inst, mask);
alg               683 crypto/algapi.c 	crypto_mod_put(alg);
alg               691 crypto/algapi.c 	if (spawn->alg)
alg               699 crypto/algapi.c 	struct crypto_alg *alg;
alg               702 crypto/algapi.c 	alg = spawn->alg;
alg               703 crypto/algapi.c 	if (alg && !crypto_mod_get(alg)) {
alg               704 crypto/algapi.c 		alg->cra_flags |= CRYPTO_ALG_DYING;
alg               705 crypto/algapi.c 		alg = NULL;
alg               709 crypto/algapi.c 	return alg ?: ERR_PTR(-EAGAIN);
alg               715 crypto/algapi.c 	struct crypto_alg *alg;
alg               718 crypto/algapi.c 	alg = crypto_spawn_alg(spawn);
alg               719 crypto/algapi.c 	if (IS_ERR(alg))
alg               720 crypto/algapi.c 		return ERR_CAST(alg);
alg               723 crypto/algapi.c 	if (unlikely((alg->cra_flags ^ type) & mask))
alg               726 crypto/algapi.c 	tfm = __crypto_alloc_tfm(alg, type, mask);
alg               733 crypto/algapi.c 	crypto_mod_put(alg);
alg               740 crypto/algapi.c 	struct crypto_alg *alg;
alg               743 crypto/algapi.c 	alg = crypto_spawn_alg(spawn);
alg               744 crypto/algapi.c 	if (IS_ERR(alg))
alg               745 crypto/algapi.c 		return ERR_CAST(alg);
alg               747 crypto/algapi.c 	tfm = crypto_create_tfm(alg, spawn->frontend);
alg               754 crypto/algapi.c 	crypto_mod_put(alg);
alg               855 crypto/algapi.c 			struct crypto_alg *alg)
alg               857 crypto/algapi.c 	if (snprintf(inst->alg.cra_name, CRYPTO_MAX_ALG_NAME, "%s(%s)", name,
alg               858 crypto/algapi.c 		     alg->cra_name) >= CRYPTO_MAX_ALG_NAME)
alg               861 crypto/algapi.c 	if (snprintf(inst->alg.cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s(%s)",
alg               862 crypto/algapi.c 		     name, alg->cra_driver_name) >= CRYPTO_MAX_ALG_NAME)
alg               869 crypto/algapi.c void *crypto_alloc_instance(const char *name, struct crypto_alg *alg,
alg               883 crypto/algapi.c 	err = crypto_inst_setname(inst, name, alg);
alg              1030 crypto/algapi.c unsigned int crypto_alg_extsize(struct crypto_alg *alg)
alg              1032 crypto/algapi.c 	return alg->cra_ctxsize +
alg              1033 crypto/algapi.c 	       (alg->cra_alignmask & ~(crypto_tfm_ctx_alignment() - 1));
alg              1041 crypto/algapi.c 	struct crypto_alg *alg = crypto_find_alg(name, frontend, type, mask);
alg              1043 crypto/algapi.c 	if (!IS_ERR(alg)) {
alg              1044 crypto/algapi.c 		crypto_mod_put(alg);
alg              1053 crypto/algapi.c void crypto_stats_init(struct crypto_alg *alg)
alg              1055 crypto/algapi.c 	memset(&alg->stats, 0, sizeof(alg->stats));
alg              1059 crypto/algapi.c void crypto_stats_get(struct crypto_alg *alg)
alg              1061 crypto/algapi.c 	crypto_alg_get(alg);
alg              1066 crypto/algapi.c 				     struct crypto_alg *alg)
alg              1069 crypto/algapi.c 		atomic64_inc(&alg->stats.cipher.err_cnt);
alg              1071 crypto/algapi.c 		atomic64_inc(&alg->stats.cipher.encrypt_cnt);
alg              1072 crypto/algapi.c 		atomic64_add(nbytes, &alg->stats.cipher.encrypt_tlen);
alg              1074 crypto/algapi.c 	crypto_alg_put(alg);
alg              1079 crypto/algapi.c 				     struct crypto_alg *alg)
alg              1082 crypto/algapi.c 		atomic64_inc(&alg->stats.cipher.err_cnt);
alg              1084 crypto/algapi.c 		atomic64_inc(&alg->stats.cipher.decrypt_cnt);
alg              1085 crypto/algapi.c 		atomic64_add(nbytes, &alg->stats.cipher.decrypt_tlen);
alg              1087 crypto/algapi.c 	crypto_alg_put(alg);
alg              1091 crypto/algapi.c void crypto_stats_aead_encrypt(unsigned int cryptlen, struct crypto_alg *alg,
alg              1095 crypto/algapi.c 		atomic64_inc(&alg->stats.aead.err_cnt);
alg              1097 crypto/algapi.c 		atomic64_inc(&alg->stats.aead.encrypt_cnt);
alg              1098 crypto/algapi.c 		atomic64_add(cryptlen, &alg->stats.aead.encrypt_tlen);
alg              1100 crypto/algapi.c 	crypto_alg_put(alg);
alg              1104 crypto/algapi.c void crypto_stats_aead_decrypt(unsigned int cryptlen, struct crypto_alg *alg,
alg              1108 crypto/algapi.c 		atomic64_inc(&alg->stats.aead.err_cnt);
alg              1110 crypto/algapi.c 		atomic64_inc(&alg->stats.aead.decrypt_cnt);
alg              1111 crypto/algapi.c 		atomic64_add(cryptlen, &alg->stats.aead.decrypt_tlen);
alg              1113 crypto/algapi.c 	crypto_alg_put(alg);
alg              1118 crypto/algapi.c 				   struct crypto_alg *alg)
alg              1121 crypto/algapi.c 		atomic64_inc(&alg->stats.akcipher.err_cnt);
alg              1123 crypto/algapi.c 		atomic64_inc(&alg->stats.akcipher.encrypt_cnt);
alg              1124 crypto/algapi.c 		atomic64_add(src_len, &alg->stats.akcipher.encrypt_tlen);
alg              1126 crypto/algapi.c 	crypto_alg_put(alg);
alg              1131 crypto/algapi.c 				   struct crypto_alg *alg)
alg              1134 crypto/algapi.c 		atomic64_inc(&alg->stats.akcipher.err_cnt);
alg              1136 crypto/algapi.c 		atomic64_inc(&alg->stats.akcipher.decrypt_cnt);
alg              1137 crypto/algapi.c 		atomic64_add(src_len, &alg->stats.akcipher.decrypt_tlen);
alg              1139 crypto/algapi.c 	crypto_alg_put(alg);
alg              1143 crypto/algapi.c void crypto_stats_akcipher_sign(int ret, struct crypto_alg *alg)
alg              1146 crypto/algapi.c 		atomic64_inc(&alg->stats.akcipher.err_cnt);
alg              1148 crypto/algapi.c 		atomic64_inc(&alg->stats.akcipher.sign_cnt);
alg              1149 crypto/algapi.c 	crypto_alg_put(alg);
alg              1153 crypto/algapi.c void crypto_stats_akcipher_verify(int ret, struct crypto_alg *alg)
alg              1156 crypto/algapi.c 		atomic64_inc(&alg->stats.akcipher.err_cnt);
alg              1158 crypto/algapi.c 		atomic64_inc(&alg->stats.akcipher.verify_cnt);
alg              1159 crypto/algapi.c 	crypto_alg_put(alg);
alg              1163 crypto/algapi.c void crypto_stats_compress(unsigned int slen, int ret, struct crypto_alg *alg)
alg              1166 crypto/algapi.c 		atomic64_inc(&alg->stats.compress.err_cnt);
alg              1168 crypto/algapi.c 		atomic64_inc(&alg->stats.compress.compress_cnt);
alg              1169 crypto/algapi.c 		atomic64_add(slen, &alg->stats.compress.compress_tlen);
alg              1171 crypto/algapi.c 	crypto_alg_put(alg);
alg              1175 crypto/algapi.c void crypto_stats_decompress(unsigned int slen, int ret, struct crypto_alg *alg)
alg              1178 crypto/algapi.c 		atomic64_inc(&alg->stats.compress.err_cnt);
alg              1180 crypto/algapi.c 		atomic64_inc(&alg->stats.compress.decompress_cnt);
alg              1181 crypto/algapi.c 		atomic64_add(slen, &alg->stats.compress.decompress_tlen);
alg              1183 crypto/algapi.c 	crypto_alg_put(alg);
alg              1188 crypto/algapi.c 			       struct crypto_alg *alg)
alg              1191 crypto/algapi.c 		atomic64_inc(&alg->stats.hash.err_cnt);
alg              1193 crypto/algapi.c 		atomic64_add(nbytes, &alg->stats.hash.hash_tlen);
alg              1194 crypto/algapi.c 	crypto_alg_put(alg);
alg              1199 crypto/algapi.c 			      struct crypto_alg *alg)
alg              1202 crypto/algapi.c 		atomic64_inc(&alg->stats.hash.err_cnt);
alg              1204 crypto/algapi.c 		atomic64_inc(&alg->stats.hash.hash_cnt);
alg              1205 crypto/algapi.c 		atomic64_add(nbytes, &alg->stats.hash.hash_tlen);
alg              1207 crypto/algapi.c 	crypto_alg_put(alg);
alg              1211 crypto/algapi.c void crypto_stats_kpp_set_secret(struct crypto_alg *alg, int ret)
alg              1214 crypto/algapi.c 		atomic64_inc(&alg->stats.kpp.err_cnt);
alg              1216 crypto/algapi.c 		atomic64_inc(&alg->stats.kpp.setsecret_cnt);
alg              1217 crypto/algapi.c 	crypto_alg_put(alg);
alg              1221 crypto/algapi.c void crypto_stats_kpp_generate_public_key(struct crypto_alg *alg, int ret)
alg              1224 crypto/algapi.c 		atomic64_inc(&alg->stats.kpp.err_cnt);
alg              1226 crypto/algapi.c 		atomic64_inc(&alg->stats.kpp.generate_public_key_cnt);
alg              1227 crypto/algapi.c 	crypto_alg_put(alg);
alg              1231 crypto/algapi.c void crypto_stats_kpp_compute_shared_secret(struct crypto_alg *alg, int ret)
alg              1234 crypto/algapi.c 		atomic64_inc(&alg->stats.kpp.err_cnt);
alg              1236 crypto/algapi.c 		atomic64_inc(&alg->stats.kpp.compute_shared_secret_cnt);
alg              1237 crypto/algapi.c 	crypto_alg_put(alg);
alg              1241 crypto/algapi.c void crypto_stats_rng_seed(struct crypto_alg *alg, int ret)
alg              1244 crypto/algapi.c 		atomic64_inc(&alg->stats.rng.err_cnt);
alg              1246 crypto/algapi.c 		atomic64_inc(&alg->stats.rng.seed_cnt);
alg              1247 crypto/algapi.c 	crypto_alg_put(alg);
alg              1251 crypto/algapi.c void crypto_stats_rng_generate(struct crypto_alg *alg, unsigned int dlen,
alg              1255 crypto/algapi.c 		atomic64_inc(&alg->stats.rng.err_cnt);
alg              1257 crypto/algapi.c 		atomic64_inc(&alg->stats.rng.generate_cnt);
alg              1258 crypto/algapi.c 		atomic64_add(dlen, &alg->stats.rng.generate_tlen);
alg              1260 crypto/algapi.c 	crypto_alg_put(alg);
alg              1265 crypto/algapi.c 				   struct crypto_alg *alg)
alg              1268 crypto/algapi.c 		atomic64_inc(&alg->stats.cipher.err_cnt);
alg              1270 crypto/algapi.c 		atomic64_inc(&alg->stats.cipher.encrypt_cnt);
alg              1271 crypto/algapi.c 		atomic64_add(cryptlen, &alg->stats.cipher.encrypt_tlen);
alg              1273 crypto/algapi.c 	crypto_alg_put(alg);
alg              1278 crypto/algapi.c 				   struct crypto_alg *alg)
alg              1281 crypto/algapi.c 		atomic64_inc(&alg->stats.cipher.err_cnt);
alg              1283 crypto/algapi.c 		atomic64_inc(&alg->stats.cipher.decrypt_cnt);
alg              1284 crypto/algapi.c 		atomic64_add(cryptlen, &alg->stats.cipher.decrypt_tlen);
alg              1286 crypto/algapi.c 	crypto_alg_put(alg);
alg                36 crypto/algboss.c 		} alg;
alg                53 crypto/algboss.c 	char alg[CRYPTO_MAX_ALG_NAME];
alg                85 crypto/algboss.c 	crypto_alg_put(&param->larval->alg);
alg                94 crypto/algboss.c 	const char *name = larval->alg.cra_name;
alg               145 crypto/algboss.c 			param->attrs[i].alg.attr.rta_len =
alg               146 crypto/algboss.c 				sizeof(param->attrs[i].alg);
alg               147 crypto/algboss.c 			param->attrs[i].alg.attr.rta_type = CRYPTOA_ALG;
alg               148 crypto/algboss.c 			memcpy(param->attrs[i].alg.data.name, name, len);
alg               177 crypto/algboss.c 	param->type.data.type = larval->alg.cra_flags & ~CRYPTO_ALG_TESTED;
alg               181 crypto/algboss.c 	param->otype = larval->alg.cra_flags;
alg               184 crypto/algboss.c 	crypto_alg_get(&larval->alg);
alg               196 crypto/algboss.c 	crypto_alg_put(&larval->alg);
alg               218 crypto/algboss.c 	err = alg_test(param->driver, param->alg, type, CRYPTO_ALG_TESTED);
alg               227 crypto/algboss.c static int cryptomgr_schedule_test(struct crypto_alg *alg)
alg               240 crypto/algboss.c 	memcpy(param->driver, alg->cra_driver_name, sizeof(param->driver));
alg               241 crypto/algboss.c 	memcpy(param->alg, alg->cra_name, sizeof(param->alg));
alg               242 crypto/algboss.c 	type = alg->cra_flags;
alg                33 crypto/api.c   static struct crypto_alg *crypto_larval_wait(struct crypto_alg *alg);
alg                35 crypto/api.c   struct crypto_alg *crypto_mod_get(struct crypto_alg *alg)
alg                37 crypto/api.c   	return try_module_get(alg->cra_module) ? crypto_alg_get(alg) : NULL;
alg                41 crypto/api.c   void crypto_mod_put(struct crypto_alg *alg)
alg                43 crypto/api.c   	struct module *module = alg->cra_module;
alg                45 crypto/api.c   	crypto_alg_put(alg);
alg                52 crypto/api.c   	return larval->alg.cra_driver_name[0];
alg                58 crypto/api.c   	struct crypto_alg *q, *alg = NULL;
alg                84 crypto/api.c   		if (alg)
alg                85 crypto/api.c   			crypto_mod_put(alg);
alg                86 crypto/api.c   		alg = q;
alg                92 crypto/api.c   	return alg;
alg                95 crypto/api.c   static void crypto_larval_destroy(struct crypto_alg *alg)
alg                97 crypto/api.c   	struct crypto_larval *larval = (void *)alg;
alg                99 crypto/api.c   	BUG_ON(!crypto_is_larval(alg));
alg               114 crypto/api.c   	larval->alg.cra_flags = CRYPTO_ALG_LARVAL | type;
alg               115 crypto/api.c   	larval->alg.cra_priority = -1;
alg               116 crypto/api.c   	larval->alg.cra_destroy = crypto_larval_destroy;
alg               118 crypto/api.c   	strlcpy(larval->alg.cra_name, name, CRYPTO_MAX_ALG_NAME);
alg               128 crypto/api.c   	struct crypto_alg *alg;
alg               135 crypto/api.c   	refcount_set(&larval->alg.cra_refcnt, 2);
alg               138 crypto/api.c   	alg = __crypto_alg_lookup(name, type, mask);
alg               139 crypto/api.c   	if (!alg) {
alg               140 crypto/api.c   		alg = &larval->alg;
alg               141 crypto/api.c   		list_add(&alg->cra_list, &crypto_alg_list);
alg               145 crypto/api.c   	if (alg != &larval->alg) {
alg               147 crypto/api.c   		if (crypto_is_larval(alg))
alg               148 crypto/api.c   			alg = crypto_larval_wait(alg);
alg               151 crypto/api.c   	return alg;
alg               154 crypto/api.c   void crypto_larval_kill(struct crypto_alg *alg)
alg               156 crypto/api.c   	struct crypto_larval *larval = (void *)alg;
alg               159 crypto/api.c   	list_del(&alg->cra_list);
alg               162 crypto/api.c   	crypto_alg_put(alg);
alg               166 crypto/api.c   static struct crypto_alg *crypto_larval_wait(struct crypto_alg *alg)
alg               168 crypto/api.c   	struct crypto_larval *larval = (void *)alg;
alg               174 crypto/api.c   	alg = larval->adult;
alg               176 crypto/api.c   		alg = ERR_PTR(-EINTR);
alg               178 crypto/api.c   		alg = ERR_PTR(-ETIMEDOUT);
alg               179 crypto/api.c   	else if (!alg)
alg               180 crypto/api.c   		alg = ERR_PTR(-ENOENT);
alg               181 crypto/api.c   	else if (IS_ERR(alg))
alg               184 crypto/api.c   		 !(alg->cra_flags & CRYPTO_ALG_TESTED))
alg               185 crypto/api.c   		alg = ERR_PTR(-EAGAIN);
alg               186 crypto/api.c   	else if (!crypto_mod_get(alg))
alg               187 crypto/api.c   		alg = ERR_PTR(-EAGAIN);
alg               188 crypto/api.c   	crypto_mod_put(&larval->alg);
alg               190 crypto/api.c   	return alg;
alg               196 crypto/api.c   	struct crypto_alg *alg;
alg               203 crypto/api.c   	alg = __crypto_alg_lookup(name, type | test, mask | test);
alg               204 crypto/api.c   	if (!alg && test) {
alg               205 crypto/api.c   		alg = __crypto_alg_lookup(name, type, mask);
alg               206 crypto/api.c   		if (alg && !crypto_is_larval(alg)) {
alg               208 crypto/api.c   			crypto_mod_put(alg);
alg               209 crypto/api.c   			alg = ERR_PTR(-ELIBBAD);
alg               214 crypto/api.c   	return alg;
alg               220 crypto/api.c   	struct crypto_alg *alg;
alg               228 crypto/api.c   	alg = crypto_alg_lookup(name, type, mask);
alg               229 crypto/api.c   	if (!alg && !(mask & CRYPTO_NOLOAD)) {
alg               236 crypto/api.c   		alg = crypto_alg_lookup(name, type, mask);
alg               239 crypto/api.c   	if (!IS_ERR_OR_NULL(alg) && crypto_is_larval(alg))
alg               240 crypto/api.c   		alg = crypto_larval_wait(alg);
alg               241 crypto/api.c   	else if (!alg)
alg               242 crypto/api.c   		alg = crypto_larval_add(name, type, mask);
alg               244 crypto/api.c   	return alg;
alg               263 crypto/api.c   	struct crypto_alg *alg;
alg               284 crypto/api.c   		alg = crypto_larval_wait(larval);
alg               287 crypto/api.c   		alg = ERR_PTR(-ENOENT);
alg               290 crypto/api.c   	return alg;
alg               324 crypto/api.c   static unsigned int crypto_ctxsize(struct crypto_alg *alg, u32 type, u32 mask)
alg               326 crypto/api.c   	const struct crypto_type *type_obj = alg->cra_type;
alg               329 crypto/api.c   	len = alg->cra_alignmask & ~(crypto_tfm_ctx_alignment() - 1);
alg               331 crypto/api.c   		return len + type_obj->ctxsize(alg, type, mask);
alg               333 crypto/api.c   	switch (alg->cra_flags & CRYPTO_ALG_TYPE_MASK) {
alg               338 crypto/api.c   		len += crypto_cipher_ctxsize(alg);
alg               342 crypto/api.c   		len += crypto_compress_ctxsize(alg);
alg               349 crypto/api.c   static void crypto_shoot_alg(struct crypto_alg *alg)
alg               352 crypto/api.c   	alg->cra_flags |= CRYPTO_ALG_DYING;
alg               356 crypto/api.c   struct crypto_tfm *__crypto_alloc_tfm(struct crypto_alg *alg, u32 type,
alg               363 crypto/api.c   	tfm_size = sizeof(*tfm) + crypto_ctxsize(alg, type, mask);
alg               368 crypto/api.c   	tfm->__crt_alg = alg;
alg               374 crypto/api.c   	if (!tfm->exit && alg->cra_init && (err = alg->cra_init(tfm)))
alg               383 crypto/api.c   		crypto_shoot_alg(alg);
alg               420 crypto/api.c   		struct crypto_alg *alg;
alg               422 crypto/api.c   		alg = crypto_alg_mod_lookup(alg_name, type, mask);
alg               423 crypto/api.c   		if (IS_ERR(alg)) {
alg               424 crypto/api.c   			err = PTR_ERR(alg);
alg               428 crypto/api.c   		tfm = __crypto_alloc_tfm(alg, type, mask);
alg               432 crypto/api.c   		crypto_mod_put(alg);
alg               448 crypto/api.c   void *crypto_create_tfm(struct crypto_alg *alg,
alg               458 crypto/api.c   	total = tfmsize + sizeof(*tfm) + frontend->extsize(alg);
alg               465 crypto/api.c   	tfm->__crt_alg = alg;
alg               471 crypto/api.c   	if (!tfm->exit && alg->cra_init && (err = alg->cra_init(tfm)))
alg               480 crypto/api.c   		crypto_shoot_alg(alg);
alg               531 crypto/api.c   		struct crypto_alg *alg;
alg               533 crypto/api.c   		alg = crypto_find_alg(alg_name, frontend, type, mask);
alg               534 crypto/api.c   		if (IS_ERR(alg)) {
alg               535 crypto/api.c   			err = PTR_ERR(alg);
alg               539 crypto/api.c   		tfm = crypto_create_tfm(alg, frontend);
alg               543 crypto/api.c   		crypto_mod_put(alg);
alg               569 crypto/api.c   	struct crypto_alg *alg;
alg               574 crypto/api.c   	alg = tfm->__crt_alg;
alg               576 crypto/api.c   	if (!tfm->exit && alg->cra_exit)
alg               577 crypto/api.c   		alg->cra_exit(tfm);
alg               579 crypto/api.c   	crypto_mod_put(alg);
alg               587 crypto/api.c   	struct crypto_alg *alg = crypto_alg_mod_lookup(name, type, mask);
alg               589 crypto/api.c   	if (!IS_ERR(alg)) {
alg               590 crypto/api.c   		crypto_mod_put(alg);
alg               439 crypto/authenc.c 	if (snprintf(inst->alg.base.cra_name, CRYPTO_MAX_ALG_NAME,
alg               445 crypto/authenc.c 	if (snprintf(inst->alg.base.cra_driver_name, CRYPTO_MAX_ALG_NAME,
alg               450 crypto/authenc.c 	inst->alg.base.cra_flags = (auth_base->cra_flags |
alg               452 crypto/authenc.c 	inst->alg.base.cra_priority = enc->base.cra_priority * 10 +
alg               454 crypto/authenc.c 	inst->alg.base.cra_blocksize = enc->base.cra_blocksize;
alg               455 crypto/authenc.c 	inst->alg.base.cra_alignmask = auth_base->cra_alignmask |
alg               457 crypto/authenc.c 	inst->alg.base.cra_ctxsize = sizeof(struct crypto_authenc_ctx);
alg               459 crypto/authenc.c 	inst->alg.ivsize = crypto_skcipher_alg_ivsize(enc);
alg               460 crypto/authenc.c 	inst->alg.chunksize = crypto_skcipher_alg_chunksize(enc);
alg               461 crypto/authenc.c 	inst->alg.maxauthsize = auth->digestsize;
alg               463 crypto/authenc.c 	inst->alg.init = crypto_authenc_init_tfm;
alg               464 crypto/authenc.c 	inst->alg.exit = crypto_authenc_exit_tfm;
alg               466 crypto/authenc.c 	inst->alg.setkey = crypto_authenc_setkey;
alg               467 crypto/authenc.c 	inst->alg.encrypt = crypto_authenc_encrypt;
alg               468 crypto/authenc.c 	inst->alg.decrypt = crypto_authenc_decrypt;
alg               454 crypto/authencesn.c 	if (snprintf(inst->alg.base.cra_name, CRYPTO_MAX_ALG_NAME,
alg               459 crypto/authencesn.c 	if (snprintf(inst->alg.base.cra_driver_name, CRYPTO_MAX_ALG_NAME,
alg               464 crypto/authencesn.c 	inst->alg.base.cra_flags = (auth_base->cra_flags |
alg               466 crypto/authencesn.c 	inst->alg.base.cra_priority = enc->base.cra_priority * 10 +
alg               468 crypto/authencesn.c 	inst->alg.base.cra_blocksize = enc->base.cra_blocksize;
alg               469 crypto/authencesn.c 	inst->alg.base.cra_alignmask = auth_base->cra_alignmask |
alg               471 crypto/authencesn.c 	inst->alg.base.cra_ctxsize = sizeof(struct crypto_authenc_esn_ctx);
alg               473 crypto/authencesn.c 	inst->alg.ivsize = crypto_skcipher_alg_ivsize(enc);
alg               474 crypto/authencesn.c 	inst->alg.chunksize = crypto_skcipher_alg_chunksize(enc);
alg               475 crypto/authencesn.c 	inst->alg.maxauthsize = auth->digestsize;
alg               477 crypto/authencesn.c 	inst->alg.init = crypto_authenc_esn_init_tfm;
alg               478 crypto/authencesn.c 	inst->alg.exit = crypto_authenc_esn_exit_tfm;
alg               480 crypto/authencesn.c 	inst->alg.setkey = crypto_authenc_esn_setkey;
alg               481 crypto/authencesn.c 	inst->alg.setauthsize = crypto_authenc_esn_setauthsize;
alg               482 crypto/authencesn.c 	inst->alg.encrypt = crypto_authenc_esn_encrypt;
alg               483 crypto/authencesn.c 	inst->alg.decrypt = crypto_authenc_esn_decrypt;
alg               415 crypto/blkcipher.c 	struct blkcipher_alg *alg = &tfm->__crt_alg->cra_blkcipher;
alg               423 crypto/blkcipher.c 	return alg->encrypt(&desc, req->dst, req->src, req->nbytes);
alg               429 crypto/blkcipher.c 	struct blkcipher_alg *alg = &tfm->__crt_alg->cra_blkcipher;
alg               436 crypto/blkcipher.c 	return alg->decrypt(&desc, req->dst, req->src, req->nbytes);
alg               439 crypto/blkcipher.c static unsigned int crypto_blkcipher_ctxsize(struct crypto_alg *alg, u32 type,
alg               442 crypto/blkcipher.c 	struct blkcipher_alg *cipher = &alg->cra_blkcipher;
alg               443 crypto/blkcipher.c 	unsigned int len = alg->cra_ctxsize;
alg               447 crypto/blkcipher.c 		len = ALIGN(len, (unsigned long)alg->cra_alignmask + 1);
alg               457 crypto/blkcipher.c 	struct blkcipher_alg *alg = &tfm->__crt_alg->cra_blkcipher;
alg               463 crypto/blkcipher.c 	crt->ivsize = alg->ivsize;
alg               471 crypto/blkcipher.c 	struct blkcipher_alg *alg = &tfm->__crt_alg->cra_blkcipher;
alg               476 crypto/blkcipher.c 	crt->encrypt = alg->encrypt;
alg               477 crypto/blkcipher.c 	crt->decrypt = alg->decrypt;
alg               489 crypto/blkcipher.c 	struct blkcipher_alg *alg = &tfm->__crt_alg->cra_blkcipher;
alg               491 crypto/blkcipher.c 	if (alg->ivsize > PAGE_SIZE / 8)
alg               501 crypto/blkcipher.c static int crypto_blkcipher_report(struct sk_buff *skb, struct crypto_alg *alg)
alg               510 crypto/blkcipher.c 	rblkcipher.blocksize = alg->cra_blocksize;
alg               511 crypto/blkcipher.c 	rblkcipher.min_keysize = alg->cra_blkcipher.min_keysize;
alg               512 crypto/blkcipher.c 	rblkcipher.max_keysize = alg->cra_blkcipher.max_keysize;
alg               513 crypto/blkcipher.c 	rblkcipher.ivsize = alg->cra_blkcipher.ivsize;
alg               519 crypto/blkcipher.c static int crypto_blkcipher_report(struct sk_buff *skb, struct crypto_alg *alg)
alg               525 crypto/blkcipher.c static void crypto_blkcipher_show(struct seq_file *m, struct crypto_alg *alg)
alg               527 crypto/blkcipher.c static void crypto_blkcipher_show(struct seq_file *m, struct crypto_alg *alg)
alg               530 crypto/blkcipher.c 	seq_printf(m, "blocksize    : %u\n", alg->cra_blocksize);
alg               531 crypto/blkcipher.c 	seq_printf(m, "min keysize  : %u\n", alg->cra_blkcipher.min_keysize);
alg               532 crypto/blkcipher.c 	seq_printf(m, "max keysize  : %u\n", alg->cra_blkcipher.max_keysize);
alg               533 crypto/blkcipher.c 	seq_printf(m, "ivsize       : %u\n", alg->cra_blkcipher.ivsize);
alg               104 crypto/blowfish_generic.c static struct crypto_alg alg = {
alg               123 crypto/blowfish_generic.c 	return crypto_register_alg(&alg);
alg               128 crypto/blowfish_generic.c 	crypto_unregister_alg(&alg);
alg               509 crypto/cast5_generic.c static struct crypto_alg alg = {
alg               531 crypto/cast5_generic.c 	return crypto_register_alg(&alg);
alg               536 crypto/cast5_generic.c 	crypto_unregister_alg(&alg);
alg               252 crypto/cast6_generic.c static struct crypto_alg alg = {
alg               273 crypto/cast6_generic.c 	return crypto_register_alg(&alg);
alg               278 crypto/cast6_generic.c 	crypto_unregister_alg(&alg);
alg                54 crypto/cbc.c   	struct crypto_alg *alg;
alg                57 crypto/cbc.c   	inst = skcipher_alloc_instance_simple(tmpl, tb, &alg);
alg                62 crypto/cbc.c   	if (!is_power_of_2(alg->cra_blocksize))
alg                65 crypto/cbc.c   	inst->alg.encrypt = crypto_cbc_encrypt;
alg                66 crypto/cbc.c   	inst->alg.decrypt = crypto_cbc_decrypt;
alg                76 crypto/cbc.c   	crypto_mod_put(alg);
alg               519 crypto/ccm.c   	if (snprintf(inst->alg.base.cra_name, CRYPTO_MAX_ALG_NAME,
alg               523 crypto/ccm.c   	if (snprintf(inst->alg.base.cra_driver_name, CRYPTO_MAX_ALG_NAME,
alg               528 crypto/ccm.c   	inst->alg.base.cra_flags = ctr->base.cra_flags & CRYPTO_ALG_ASYNC;
alg               529 crypto/ccm.c   	inst->alg.base.cra_priority = (mac->base.cra_priority +
alg               531 crypto/ccm.c   	inst->alg.base.cra_blocksize = 1;
alg               532 crypto/ccm.c   	inst->alg.base.cra_alignmask = mac->base.cra_alignmask |
alg               534 crypto/ccm.c   	inst->alg.ivsize = 16;
alg               535 crypto/ccm.c   	inst->alg.chunksize = crypto_skcipher_alg_chunksize(ctr);
alg               536 crypto/ccm.c   	inst->alg.maxauthsize = 16;
alg               537 crypto/ccm.c   	inst->alg.base.cra_ctxsize = sizeof(struct crypto_ccm_ctx);
alg               538 crypto/ccm.c   	inst->alg.init = crypto_ccm_init_tfm;
alg               539 crypto/ccm.c   	inst->alg.exit = crypto_ccm_exit_tfm;
alg               540 crypto/ccm.c   	inst->alg.setkey = crypto_ccm_setkey;
alg               541 crypto/ccm.c   	inst->alg.setauthsize = crypto_ccm_setauthsize;
alg               542 crypto/ccm.c   	inst->alg.encrypt = crypto_ccm_encrypt;
alg               543 crypto/ccm.c   	inst->alg.decrypt = crypto_ccm_decrypt;
alg               750 crypto/ccm.c   	struct aead_alg *alg;
alg               776 crypto/ccm.c   	alg = crypto_spawn_aead_alg(spawn);
alg               781 crypto/ccm.c   	if (crypto_aead_alg_ivsize(alg) != 16)
alg               785 crypto/ccm.c   	if (alg->base.cra_blocksize != 1)
alg               789 crypto/ccm.c   	if (snprintf(inst->alg.base.cra_name, CRYPTO_MAX_ALG_NAME,
alg               790 crypto/ccm.c   		     "rfc4309(%s)", alg->base.cra_name) >=
alg               792 crypto/ccm.c   	    snprintf(inst->alg.base.cra_driver_name, CRYPTO_MAX_ALG_NAME,
alg               793 crypto/ccm.c   		     "rfc4309(%s)", alg->base.cra_driver_name) >=
alg               797 crypto/ccm.c   	inst->alg.base.cra_flags = alg->base.cra_flags & CRYPTO_ALG_ASYNC;
alg               798 crypto/ccm.c   	inst->alg.base.cra_priority = alg->base.cra_priority;
alg               799 crypto/ccm.c   	inst->alg.base.cra_blocksize = 1;
alg               800 crypto/ccm.c   	inst->alg.base.cra_alignmask = alg->base.cra_alignmask;
alg               802 crypto/ccm.c   	inst->alg.ivsize = 8;
alg               803 crypto/ccm.c   	inst->alg.chunksize = crypto_aead_alg_chunksize(alg);
alg               804 crypto/ccm.c   	inst->alg.maxauthsize = 16;
alg               806 crypto/ccm.c   	inst->alg.base.cra_ctxsize = sizeof(struct crypto_rfc4309_ctx);
alg               808 crypto/ccm.c   	inst->alg.init = crypto_rfc4309_init_tfm;
alg               809 crypto/ccm.c   	inst->alg.exit = crypto_rfc4309_exit_tfm;
alg               811 crypto/ccm.c   	inst->alg.setkey = crypto_rfc4309_setkey;
alg               812 crypto/ccm.c   	inst->alg.setauthsize = crypto_rfc4309_setauthsize;
alg               813 crypto/ccm.c   	inst->alg.encrypt = crypto_rfc4309_encrypt;
alg               814 crypto/ccm.c   	inst->alg.decrypt = crypto_rfc4309_decrypt;
alg               920 crypto/ccm.c   	struct crypto_alg *alg;
alg               927 crypto/ccm.c   	alg = crypto_get_attr_alg(tb, CRYPTO_ALG_TYPE_CIPHER,
alg               929 crypto/ccm.c   	if (IS_ERR(alg))
alg               930 crypto/ccm.c   		return PTR_ERR(alg);
alg               932 crypto/ccm.c   	inst = shash_alloc_instance("cbcmac", alg);
alg               937 crypto/ccm.c   	err = crypto_init_spawn(shash_instance_ctx(inst), alg,
alg               943 crypto/ccm.c   	inst->alg.base.cra_priority = alg->cra_priority;
alg               944 crypto/ccm.c   	inst->alg.base.cra_blocksize = 1;
alg               946 crypto/ccm.c   	inst->alg.digestsize = alg->cra_blocksize;
alg               947 crypto/ccm.c   	inst->alg.descsize = ALIGN(sizeof(struct cbcmac_desc_ctx),
alg               948 crypto/ccm.c   				   alg->cra_alignmask + 1) +
alg               949 crypto/ccm.c   			     alg->cra_blocksize;
alg               951 crypto/ccm.c   	inst->alg.base.cra_ctxsize = sizeof(struct cbcmac_tfm_ctx);
alg               952 crypto/ccm.c   	inst->alg.base.cra_init = cbcmac_init_tfm;
alg               953 crypto/ccm.c   	inst->alg.base.cra_exit = cbcmac_exit_tfm;
alg               955 crypto/ccm.c   	inst->alg.init = crypto_cbcmac_digest_init;
alg               956 crypto/ccm.c   	inst->alg.update = crypto_cbcmac_digest_update;
alg               957 crypto/ccm.c   	inst->alg.final = crypto_cbcmac_digest_final;
alg               958 crypto/ccm.c   	inst->alg.setkey = crypto_cbcmac_digest_setkey;
alg               967 crypto/ccm.c   	crypto_mod_put(alg);
alg               203 crypto/cfb.c   	struct crypto_alg *alg;
alg               206 crypto/cfb.c   	inst = skcipher_alloc_instance_simple(tmpl, tb, &alg);
alg               211 crypto/cfb.c   	inst->alg.base.cra_blocksize = 1;
alg               217 crypto/cfb.c   	inst->alg.chunksize = alg->cra_blocksize;
alg               219 crypto/cfb.c   	inst->alg.encrypt = crypto_cfb_encrypt;
alg               220 crypto/cfb.c   	inst->alg.decrypt = crypto_cfb_decrypt;
alg               226 crypto/cfb.c   	crypto_mod_put(alg);
alg               634 crypto/chacha20poly1305.c 	if (snprintf(inst->alg.base.cra_name, CRYPTO_MAX_ALG_NAME,
alg               638 crypto/chacha20poly1305.c 	if (snprintf(inst->alg.base.cra_driver_name, CRYPTO_MAX_ALG_NAME,
alg               643 crypto/chacha20poly1305.c 	inst->alg.base.cra_flags = (chacha->base.cra_flags | poly->cra_flags) &
alg               645 crypto/chacha20poly1305.c 	inst->alg.base.cra_priority = (chacha->base.cra_priority +
alg               647 crypto/chacha20poly1305.c 	inst->alg.base.cra_blocksize = 1;
alg               648 crypto/chacha20poly1305.c 	inst->alg.base.cra_alignmask = chacha->base.cra_alignmask |
alg               650 crypto/chacha20poly1305.c 	inst->alg.base.cra_ctxsize = sizeof(struct chachapoly_ctx) +
alg               652 crypto/chacha20poly1305.c 	inst->alg.ivsize = ivsize;
alg               653 crypto/chacha20poly1305.c 	inst->alg.chunksize = crypto_skcipher_alg_chunksize(chacha);
alg               654 crypto/chacha20poly1305.c 	inst->alg.maxauthsize = POLY1305_DIGEST_SIZE;
alg               655 crypto/chacha20poly1305.c 	inst->alg.init = chachapoly_init;
alg               656 crypto/chacha20poly1305.c 	inst->alg.exit = chachapoly_exit;
alg               657 crypto/chacha20poly1305.c 	inst->alg.encrypt = chachapoly_encrypt;
alg               658 crypto/chacha20poly1305.c 	inst->alg.decrypt = chachapoly_decrypt;
alg               659 crypto/chacha20poly1305.c 	inst->alg.setkey = chachapoly_setkey;
alg               660 crypto/chacha20poly1305.c 	inst->alg.setauthsize = chachapoly_setauthsize;
alg               225 crypto/cmac.c  	struct crypto_alg *alg;
alg               233 crypto/cmac.c  	alg = crypto_get_attr_alg(tb, CRYPTO_ALG_TYPE_CIPHER,
alg               235 crypto/cmac.c  	if (IS_ERR(alg))
alg               236 crypto/cmac.c  		return PTR_ERR(alg);
alg               238 crypto/cmac.c  	switch (alg->cra_blocksize) {
alg               247 crypto/cmac.c  	inst = shash_alloc_instance("cmac", alg);
alg               252 crypto/cmac.c  	err = crypto_init_spawn(shash_instance_ctx(inst), alg,
alg               258 crypto/cmac.c  	alignmask = alg->cra_alignmask;
alg               259 crypto/cmac.c  	inst->alg.base.cra_alignmask = alignmask;
alg               260 crypto/cmac.c  	inst->alg.base.cra_priority = alg->cra_priority;
alg               261 crypto/cmac.c  	inst->alg.base.cra_blocksize = alg->cra_blocksize;
alg               263 crypto/cmac.c  	inst->alg.digestsize = alg->cra_blocksize;
alg               264 crypto/cmac.c  	inst->alg.descsize =
alg               267 crypto/cmac.c  		+ alg->cra_blocksize * 2;
alg               269 crypto/cmac.c  	inst->alg.base.cra_ctxsize =
alg               273 crypto/cmac.c  		+ alg->cra_blocksize * 2;
alg               275 crypto/cmac.c  	inst->alg.base.cra_init = cmac_init_tfm;
alg               276 crypto/cmac.c  	inst->alg.base.cra_exit = cmac_exit_tfm;
alg               278 crypto/cmac.c  	inst->alg.init = crypto_cmac_digest_init;
alg               279 crypto/cmac.c  	inst->alg.update = crypto_cmac_digest_update;
alg               280 crypto/cmac.c  	inst->alg.final = crypto_cmac_digest_final;
alg               281 crypto/cmac.c  	inst->alg.setkey = crypto_cmac_digest_setkey;
alg               290 crypto/cmac.c  	crypto_mod_put(alg);
alg               118 crypto/crc32_generic.c static struct shash_alg alg = {
alg               141 crypto/crc32_generic.c 	return crypto_register_shash(&alg);
alg               146 crypto/crc32_generic.c 	crypto_unregister_shash(&alg);
alg               132 crypto/crc32c_generic.c static struct shash_alg alg = {
alg               155 crypto/crc32c_generic.c 	return crypto_register_shash(&alg);
alg               160 crypto/crc32c_generic.c 	crypto_unregister_shash(&alg);
alg                88 crypto/crct10dif_generic.c static struct shash_alg alg = {
alg               107 crypto/crct10dif_generic.c 	return crypto_register_shash(&alg);
alg               112 crypto/crct10dif_generic.c 	crypto_unregister_shash(&alg);
alg               208 crypto/cryptd.c 				struct crypto_alg *alg)
alg               210 crypto/cryptd.c 	if (snprintf(inst->alg.cra_driver_name, CRYPTO_MAX_ALG_NAME,
alg               212 crypto/cryptd.c 		     alg->cra_driver_name) >= CRYPTO_MAX_ALG_NAME)
alg               215 crypto/cryptd.c 	memcpy(inst->alg.cra_name, alg->cra_name, CRYPTO_MAX_ALG_NAME);
alg               217 crypto/cryptd.c 	inst->alg.cra_priority = alg->cra_priority + 50;
alg               218 crypto/cryptd.c 	inst->alg.cra_blocksize = alg->cra_blocksize;
alg               219 crypto/cryptd.c 	inst->alg.cra_alignmask = alg->cra_alignmask;
alg               224 crypto/cryptd.c static void *cryptd_alloc_instance(struct crypto_alg *alg, unsigned int head,
alg               237 crypto/cryptd.c 	err = cryptd_init_instance(inst, alg);
alg               402 crypto/cryptd.c 	struct skcipher_alg *alg;
alg               429 crypto/cryptd.c 	alg = crypto_spawn_skcipher_alg(&ctx->spawn);
alg               430 crypto/cryptd.c 	err = cryptd_init_instance(skcipher_crypto_instance(inst), &alg->base);
alg               434 crypto/cryptd.c 	inst->alg.base.cra_flags = CRYPTO_ALG_ASYNC |
alg               435 crypto/cryptd.c 				   (alg->base.cra_flags & CRYPTO_ALG_INTERNAL);
alg               437 crypto/cryptd.c 	inst->alg.ivsize = crypto_skcipher_alg_ivsize(alg);
alg               438 crypto/cryptd.c 	inst->alg.chunksize = crypto_skcipher_alg_chunksize(alg);
alg               439 crypto/cryptd.c 	inst->alg.min_keysize = crypto_skcipher_alg_min_keysize(alg);
alg               440 crypto/cryptd.c 	inst->alg.max_keysize = crypto_skcipher_alg_max_keysize(alg);
alg               442 crypto/cryptd.c 	inst->alg.base.cra_ctxsize = sizeof(struct cryptd_skcipher_ctx);
alg               444 crypto/cryptd.c 	inst->alg.init = cryptd_skcipher_init_tfm;
alg               445 crypto/cryptd.c 	inst->alg.exit = cryptd_skcipher_exit_tfm;
alg               447 crypto/cryptd.c 	inst->alg.setkey = cryptd_skcipher_setkey;
alg               448 crypto/cryptd.c 	inst->alg.encrypt = cryptd_skcipher_encrypt_enqueue;
alg               449 crypto/cryptd.c 	inst->alg.decrypt = cryptd_skcipher_decrypt_enqueue;
alg               675 crypto/cryptd.c 	struct crypto_alg *alg;
alg               686 crypto/cryptd.c 	alg = &salg->base;
alg               687 crypto/cryptd.c 	inst = cryptd_alloc_instance(alg, ahash_instance_headroom(),
alg               701 crypto/cryptd.c 	inst->alg.halg.base.cra_flags = CRYPTO_ALG_ASYNC |
alg               702 crypto/cryptd.c 		(alg->cra_flags & (CRYPTO_ALG_INTERNAL |
alg               705 crypto/cryptd.c 	inst->alg.halg.digestsize = salg->digestsize;
alg               706 crypto/cryptd.c 	inst->alg.halg.statesize = salg->statesize;
alg               707 crypto/cryptd.c 	inst->alg.halg.base.cra_ctxsize = sizeof(struct cryptd_hash_ctx);
alg               709 crypto/cryptd.c 	inst->alg.halg.base.cra_init = cryptd_hash_init_tfm;
alg               710 crypto/cryptd.c 	inst->alg.halg.base.cra_exit = cryptd_hash_exit_tfm;
alg               712 crypto/cryptd.c 	inst->alg.init   = cryptd_hash_init_enqueue;
alg               713 crypto/cryptd.c 	inst->alg.update = cryptd_hash_update_enqueue;
alg               714 crypto/cryptd.c 	inst->alg.final  = cryptd_hash_final_enqueue;
alg               715 crypto/cryptd.c 	inst->alg.finup  = cryptd_hash_finup_enqueue;
alg               716 crypto/cryptd.c 	inst->alg.export = cryptd_hash_export;
alg               717 crypto/cryptd.c 	inst->alg.import = cryptd_hash_import;
alg               719 crypto/cryptd.c 		inst->alg.setkey = cryptd_hash_setkey;
alg               720 crypto/cryptd.c 	inst->alg.digest = cryptd_hash_digest_enqueue;
alg               730 crypto/cryptd.c 	crypto_mod_put(alg);
alg               858 crypto/cryptd.c 	struct aead_alg *alg;
alg               882 crypto/cryptd.c 	alg = crypto_spawn_aead_alg(&ctx->aead_spawn);
alg               883 crypto/cryptd.c 	err = cryptd_init_instance(aead_crypto_instance(inst), &alg->base);
alg               887 crypto/cryptd.c 	inst->alg.base.cra_flags = CRYPTO_ALG_ASYNC |
alg               888 crypto/cryptd.c 				   (alg->base.cra_flags & CRYPTO_ALG_INTERNAL);
alg               889 crypto/cryptd.c 	inst->alg.base.cra_ctxsize = sizeof(struct cryptd_aead_ctx);
alg               891 crypto/cryptd.c 	inst->alg.ivsize = crypto_aead_alg_ivsize(alg);
alg               892 crypto/cryptd.c 	inst->alg.maxauthsize = crypto_aead_alg_maxauthsize(alg);
alg               894 crypto/cryptd.c 	inst->alg.init = cryptd_aead_init_tfm;
alg               895 crypto/cryptd.c 	inst->alg.exit = cryptd_aead_exit_tfm;
alg               896 crypto/cryptd.c 	inst->alg.setkey = cryptd_aead_setkey;
alg               897 crypto/cryptd.c 	inst->alg.setauthsize = cryptd_aead_setauthsize;
alg               898 crypto/cryptd.c 	inst->alg.encrypt = cryptd_aead_encrypt_enqueue;
alg               899 crypto/cryptd.c 	inst->alg.decrypt = cryptd_aead_decrypt_enqueue;
alg               939 crypto/cryptd.c 	switch (inst->alg.cra_flags & CRYPTO_ALG_TYPE_MASK) {
alg                38 crypto/crypto_user_base.c 	struct crypto_alg *q, *alg = NULL;
alg                63 crypto/crypto_user_base.c 		alg = q;
alg                69 crypto/crypto_user_base.c 	return alg;
alg                72 crypto/crypto_user_base.c static int crypto_report_cipher(struct sk_buff *skb, struct crypto_alg *alg)
alg                80 crypto/crypto_user_base.c 	rcipher.blocksize = alg->cra_blocksize;
alg                81 crypto/crypto_user_base.c 	rcipher.min_keysize = alg->cra_cipher.cia_min_keysize;
alg                82 crypto/crypto_user_base.c 	rcipher.max_keysize = alg->cra_cipher.cia_max_keysize;
alg                88 crypto/crypto_user_base.c static int crypto_report_comp(struct sk_buff *skb, struct crypto_alg *alg)
alg                99 crypto/crypto_user_base.c static int crypto_report_one(struct crypto_alg *alg,
alg               104 crypto/crypto_user_base.c 	strscpy(ualg->cru_name, alg->cra_name, sizeof(ualg->cru_name));
alg               105 crypto/crypto_user_base.c 	strscpy(ualg->cru_driver_name, alg->cra_driver_name,
alg               107 crypto/crypto_user_base.c 	strscpy(ualg->cru_module_name, module_name(alg->cra_module),
alg               112 crypto/crypto_user_base.c 	ualg->cru_flags = alg->cra_flags;
alg               113 crypto/crypto_user_base.c 	ualg->cru_refcnt = refcount_read(&alg->cra_refcnt);
alg               115 crypto/crypto_user_base.c 	if (nla_put_u32(skb, CRYPTOCFGA_PRIORITY_VAL, alg->cra_priority))
alg               117 crypto/crypto_user_base.c 	if (alg->cra_flags & CRYPTO_ALG_LARVAL) {
alg               127 crypto/crypto_user_base.c 	if (alg->cra_type && alg->cra_type->report) {
alg               128 crypto/crypto_user_base.c 		if (alg->cra_type->report(skb, alg))
alg               134 crypto/crypto_user_base.c 	switch (alg->cra_flags & (CRYPTO_ALG_TYPE_MASK | CRYPTO_ALG_LARVAL)) {
alg               136 crypto/crypto_user_base.c 		if (crypto_report_cipher(skb, alg))
alg               141 crypto/crypto_user_base.c 		if (crypto_report_comp(skb, alg))
alg               154 crypto/crypto_user_base.c static int crypto_report_alg(struct crypto_alg *alg,
alg               172 crypto/crypto_user_base.c 	err = crypto_report_one(alg, ualg, skb);
alg               189 crypto/crypto_user_base.c 	struct crypto_alg *alg;
alg               197 crypto/crypto_user_base.c 	alg = crypto_alg_match(p, 0);
alg               198 crypto/crypto_user_base.c 	if (!alg)
alg               211 crypto/crypto_user_base.c 	err = crypto_report_alg(alg, &info);
alg               214 crypto/crypto_user_base.c 	crypto_mod_put(alg);
alg               229 crypto/crypto_user_base.c 	struct crypto_alg *alg;
alg               238 crypto/crypto_user_base.c 	list_for_each_entry(alg, &crypto_alg_list, cra_list) {
alg               240 crypto/crypto_user_base.c 			res = crypto_report_alg(alg, &info);
alg               263 crypto/crypto_user_base.c 	struct crypto_alg *alg;
alg               277 crypto/crypto_user_base.c 	alg = crypto_alg_match(p, 1);
alg               278 crypto/crypto_user_base.c 	if (!alg)
alg               283 crypto/crypto_user_base.c 	crypto_remove_spawns(alg, &list, NULL);
alg               286 crypto/crypto_user_base.c 		alg->cra_priority = nla_get_u32(priority);
alg               290 crypto/crypto_user_base.c 	crypto_mod_put(alg);
alg               299 crypto/crypto_user_base.c 	struct crypto_alg *alg;
alg               309 crypto/crypto_user_base.c 	alg = crypto_alg_match(p, 1);
alg               310 crypto/crypto_user_base.c 	if (!alg)
alg               319 crypto/crypto_user_base.c 	if (!(alg->cra_flags & CRYPTO_ALG_INSTANCE))
alg               323 crypto/crypto_user_base.c 	if (refcount_read(&alg->cra_refcnt) > 2)
alg               326 crypto/crypto_user_base.c 	err = crypto_unregister_instance((struct crypto_instance *)alg);
alg               329 crypto/crypto_user_base.c 	crypto_mod_put(alg);
alg               338 crypto/crypto_user_base.c 	struct crypto_alg *alg;
alg               354 crypto/crypto_user_base.c 	alg = crypto_alg_match(p, exact);
alg               355 crypto/crypto_user_base.c 	if (alg) {
alg               356 crypto/crypto_user_base.c 		crypto_mod_put(alg);
alg               365 crypto/crypto_user_base.c 	alg = crypto_alg_mod_lookup(name, p->cru_type, p->cru_mask);
alg               366 crypto/crypto_user_base.c 	if (IS_ERR(alg))
alg               367 crypto/crypto_user_base.c 		return PTR_ERR(alg);
alg               372 crypto/crypto_user_base.c 		alg->cra_priority = nla_get_u32(priority);
alg               376 crypto/crypto_user_base.c 	crypto_mod_put(alg);
alg               438 crypto/crypto_user_base.c 		struct crypto_alg *alg;
alg               445 crypto/crypto_user_base.c 		list_for_each_entry(alg, &crypto_alg_list, cra_list)
alg                31 crypto/crypto_user_stat.c static int crypto_report_aead(struct sk_buff *skb, struct crypto_alg *alg)
alg                39 crypto/crypto_user_stat.c 	raead.stat_encrypt_cnt = atomic64_read(&alg->stats.aead.encrypt_cnt);
alg                40 crypto/crypto_user_stat.c 	raead.stat_encrypt_tlen = atomic64_read(&alg->stats.aead.encrypt_tlen);
alg                41 crypto/crypto_user_stat.c 	raead.stat_decrypt_cnt = atomic64_read(&alg->stats.aead.decrypt_cnt);
alg                42 crypto/crypto_user_stat.c 	raead.stat_decrypt_tlen = atomic64_read(&alg->stats.aead.decrypt_tlen);
alg                43 crypto/crypto_user_stat.c 	raead.stat_err_cnt = atomic64_read(&alg->stats.aead.err_cnt);
alg                48 crypto/crypto_user_stat.c static int crypto_report_cipher(struct sk_buff *skb, struct crypto_alg *alg)
alg                56 crypto/crypto_user_stat.c 	rcipher.stat_encrypt_cnt = atomic64_read(&alg->stats.cipher.encrypt_cnt);
alg                57 crypto/crypto_user_stat.c 	rcipher.stat_encrypt_tlen = atomic64_read(&alg->stats.cipher.encrypt_tlen);
alg                58 crypto/crypto_user_stat.c 	rcipher.stat_decrypt_cnt =  atomic64_read(&alg->stats.cipher.decrypt_cnt);
alg                59 crypto/crypto_user_stat.c 	rcipher.stat_decrypt_tlen = atomic64_read(&alg->stats.cipher.decrypt_tlen);
alg                60 crypto/crypto_user_stat.c 	rcipher.stat_err_cnt =  atomic64_read(&alg->stats.cipher.err_cnt);
alg                65 crypto/crypto_user_stat.c static int crypto_report_comp(struct sk_buff *skb, struct crypto_alg *alg)
alg                72 crypto/crypto_user_stat.c 	rcomp.stat_compress_cnt = atomic64_read(&alg->stats.compress.compress_cnt);
alg                73 crypto/crypto_user_stat.c 	rcomp.stat_compress_tlen = atomic64_read(&alg->stats.compress.compress_tlen);
alg                74 crypto/crypto_user_stat.c 	rcomp.stat_decompress_cnt = atomic64_read(&alg->stats.compress.decompress_cnt);
alg                75 crypto/crypto_user_stat.c 	rcomp.stat_decompress_tlen = atomic64_read(&alg->stats.compress.decompress_tlen);
alg                76 crypto/crypto_user_stat.c 	rcomp.stat_err_cnt = atomic64_read(&alg->stats.compress.err_cnt);
alg                81 crypto/crypto_user_stat.c static int crypto_report_acomp(struct sk_buff *skb, struct crypto_alg *alg)
alg                88 crypto/crypto_user_stat.c 	racomp.stat_compress_cnt = atomic64_read(&alg->stats.compress.compress_cnt);
alg                89 crypto/crypto_user_stat.c 	racomp.stat_compress_tlen = atomic64_read(&alg->stats.compress.compress_tlen);
alg                90 crypto/crypto_user_stat.c 	racomp.stat_decompress_cnt =  atomic64_read(&alg->stats.compress.decompress_cnt);
alg                91 crypto/crypto_user_stat.c 	racomp.stat_decompress_tlen = atomic64_read(&alg->stats.compress.decompress_tlen);
alg                92 crypto/crypto_user_stat.c 	racomp.stat_err_cnt = atomic64_read(&alg->stats.compress.err_cnt);
alg                97 crypto/crypto_user_stat.c static int crypto_report_akcipher(struct sk_buff *skb, struct crypto_alg *alg)
alg               104 crypto/crypto_user_stat.c 	rakcipher.stat_encrypt_cnt = atomic64_read(&alg->stats.akcipher.encrypt_cnt);
alg               105 crypto/crypto_user_stat.c 	rakcipher.stat_encrypt_tlen = atomic64_read(&alg->stats.akcipher.encrypt_tlen);
alg               106 crypto/crypto_user_stat.c 	rakcipher.stat_decrypt_cnt = atomic64_read(&alg->stats.akcipher.decrypt_cnt);
alg               107 crypto/crypto_user_stat.c 	rakcipher.stat_decrypt_tlen = atomic64_read(&alg->stats.akcipher.decrypt_tlen);
alg               108 crypto/crypto_user_stat.c 	rakcipher.stat_sign_cnt = atomic64_read(&alg->stats.akcipher.sign_cnt);
alg               109 crypto/crypto_user_stat.c 	rakcipher.stat_verify_cnt = atomic64_read(&alg->stats.akcipher.verify_cnt);
alg               110 crypto/crypto_user_stat.c 	rakcipher.stat_err_cnt = atomic64_read(&alg->stats.akcipher.err_cnt);
alg               116 crypto/crypto_user_stat.c static int crypto_report_kpp(struct sk_buff *skb, struct crypto_alg *alg)
alg               124 crypto/crypto_user_stat.c 	rkpp.stat_setsecret_cnt = atomic64_read(&alg->stats.kpp.setsecret_cnt);
alg               125 crypto/crypto_user_stat.c 	rkpp.stat_generate_public_key_cnt = atomic64_read(&alg->stats.kpp.generate_public_key_cnt);
alg               126 crypto/crypto_user_stat.c 	rkpp.stat_compute_shared_secret_cnt = atomic64_read(&alg->stats.kpp.compute_shared_secret_cnt);
alg               127 crypto/crypto_user_stat.c 	rkpp.stat_err_cnt = atomic64_read(&alg->stats.kpp.err_cnt);
alg               132 crypto/crypto_user_stat.c static int crypto_report_ahash(struct sk_buff *skb, struct crypto_alg *alg)
alg               140 crypto/crypto_user_stat.c 	rhash.stat_hash_cnt = atomic64_read(&alg->stats.hash.hash_cnt);
alg               141 crypto/crypto_user_stat.c 	rhash.stat_hash_tlen = atomic64_read(&alg->stats.hash.hash_tlen);
alg               142 crypto/crypto_user_stat.c 	rhash.stat_err_cnt = atomic64_read(&alg->stats.hash.err_cnt);
alg               147 crypto/crypto_user_stat.c static int crypto_report_shash(struct sk_buff *skb, struct crypto_alg *alg)
alg               155 crypto/crypto_user_stat.c 	rhash.stat_hash_cnt =  atomic64_read(&alg->stats.hash.hash_cnt);
alg               156 crypto/crypto_user_stat.c 	rhash.stat_hash_tlen = atomic64_read(&alg->stats.hash.hash_tlen);
alg               157 crypto/crypto_user_stat.c 	rhash.stat_err_cnt = atomic64_read(&alg->stats.hash.err_cnt);
alg               162 crypto/crypto_user_stat.c static int crypto_report_rng(struct sk_buff *skb, struct crypto_alg *alg)
alg               170 crypto/crypto_user_stat.c 	rrng.stat_generate_cnt = atomic64_read(&alg->stats.rng.generate_cnt);
alg               171 crypto/crypto_user_stat.c 	rrng.stat_generate_tlen = atomic64_read(&alg->stats.rng.generate_tlen);
alg               172 crypto/crypto_user_stat.c 	rrng.stat_seed_cnt = atomic64_read(&alg->stats.rng.seed_cnt);
alg               173 crypto/crypto_user_stat.c 	rrng.stat_err_cnt = atomic64_read(&alg->stats.rng.err_cnt);
alg               178 crypto/crypto_user_stat.c static int crypto_reportstat_one(struct crypto_alg *alg,
alg               184 crypto/crypto_user_stat.c 	strscpy(ualg->cru_name, alg->cra_name, sizeof(ualg->cru_name));
alg               185 crypto/crypto_user_stat.c 	strscpy(ualg->cru_driver_name, alg->cra_driver_name,
alg               187 crypto/crypto_user_stat.c 	strscpy(ualg->cru_module_name, module_name(alg->cra_module),
alg               192 crypto/crypto_user_stat.c 	ualg->cru_flags = alg->cra_flags;
alg               193 crypto/crypto_user_stat.c 	ualg->cru_refcnt = refcount_read(&alg->cra_refcnt);
alg               195 crypto/crypto_user_stat.c 	if (nla_put_u32(skb, CRYPTOCFGA_PRIORITY_VAL, alg->cra_priority))
alg               197 crypto/crypto_user_stat.c 	if (alg->cra_flags & CRYPTO_ALG_LARVAL) {
alg               207 crypto/crypto_user_stat.c 	switch (alg->cra_flags & (CRYPTO_ALG_TYPE_MASK | CRYPTO_ALG_LARVAL)) {
alg               209 crypto/crypto_user_stat.c 		if (crypto_report_aead(skb, alg))
alg               213 crypto/crypto_user_stat.c 		if (crypto_report_cipher(skb, alg))
alg               217 crypto/crypto_user_stat.c 		if (crypto_report_cipher(skb, alg))
alg               221 crypto/crypto_user_stat.c 		if (crypto_report_cipher(skb, alg))
alg               225 crypto/crypto_user_stat.c 		if (crypto_report_comp(skb, alg))
alg               229 crypto/crypto_user_stat.c 		if (crypto_report_acomp(skb, alg))
alg               233 crypto/crypto_user_stat.c 		if (crypto_report_acomp(skb, alg))
alg               237 crypto/crypto_user_stat.c 		if (crypto_report_akcipher(skb, alg))
alg               241 crypto/crypto_user_stat.c 		if (crypto_report_kpp(skb, alg))
alg               245 crypto/crypto_user_stat.c 		if (crypto_report_ahash(skb, alg))
alg               249 crypto/crypto_user_stat.c 		if (crypto_report_shash(skb, alg))
alg               253 crypto/crypto_user_stat.c 		if (crypto_report_rng(skb, alg))
alg               258 crypto/crypto_user_stat.c 		       alg->cra_flags & (CRYPTO_ALG_TYPE_MASK | CRYPTO_ALG_LARVAL),
alg               269 crypto/crypto_user_stat.c static int crypto_reportstat_alg(struct crypto_alg *alg,
alg               287 crypto/crypto_user_stat.c 	err = crypto_reportstat_one(alg, ualg, skb);
alg               304 crypto/crypto_user_stat.c 	struct crypto_alg *alg;
alg               312 crypto/crypto_user_stat.c 	alg = crypto_alg_match(p, 0);
alg               313 crypto/crypto_user_stat.c 	if (!alg)
alg               326 crypto/crypto_user_stat.c 	err = crypto_reportstat_alg(alg, &info);
alg               329 crypto/crypto_user_stat.c 	crypto_mod_put(alg);
alg               129 crypto/ctr.c   	struct crypto_alg *alg;
alg               132 crypto/ctr.c   	inst = skcipher_alloc_instance_simple(tmpl, tb, &alg);
alg               138 crypto/ctr.c   	if (alg->cra_blocksize < 4)
alg               142 crypto/ctr.c   	if (alg->cra_blocksize % 4)
alg               146 crypto/ctr.c   	inst->alg.base.cra_blocksize = 1;
alg               152 crypto/ctr.c   	inst->alg.chunksize = alg->cra_blocksize;
alg               154 crypto/ctr.c   	inst->alg.encrypt = crypto_ctr_crypt;
alg               155 crypto/ctr.c   	inst->alg.decrypt = crypto_ctr_crypt;
alg               165 crypto/ctr.c   	crypto_mod_put(alg);
alg               267 crypto/ctr.c   	struct skcipher_alg *alg;
alg               300 crypto/ctr.c   	alg = crypto_spawn_skcipher_alg(spawn);
alg               304 crypto/ctr.c   	if (crypto_skcipher_alg_ivsize(alg) != CTR_RFC3686_BLOCK_SIZE)
alg               308 crypto/ctr.c   	if (alg->base.cra_blocksize != 1)
alg               312 crypto/ctr.c   	if (snprintf(inst->alg.base.cra_name, CRYPTO_MAX_ALG_NAME,
alg               313 crypto/ctr.c   		     "rfc3686(%s)", alg->base.cra_name) >= CRYPTO_MAX_ALG_NAME)
alg               315 crypto/ctr.c   	if (snprintf(inst->alg.base.cra_driver_name, CRYPTO_MAX_ALG_NAME,
alg               316 crypto/ctr.c   		     "rfc3686(%s)", alg->base.cra_driver_name) >=
alg               320 crypto/ctr.c   	inst->alg.base.cra_priority = alg->base.cra_priority;
alg               321 crypto/ctr.c   	inst->alg.base.cra_blocksize = 1;
alg               322 crypto/ctr.c   	inst->alg.base.cra_alignmask = alg->base.cra_alignmask;
alg               324 crypto/ctr.c   	inst->alg.base.cra_flags = alg->base.cra_flags & CRYPTO_ALG_ASYNC;
alg               326 crypto/ctr.c   	inst->alg.ivsize = CTR_RFC3686_IV_SIZE;
alg               327 crypto/ctr.c   	inst->alg.chunksize = crypto_skcipher_alg_chunksize(alg);
alg               328 crypto/ctr.c   	inst->alg.min_keysize = crypto_skcipher_alg_min_keysize(alg) +
alg               330 crypto/ctr.c   	inst->alg.max_keysize = crypto_skcipher_alg_max_keysize(alg) +
alg               333 crypto/ctr.c   	inst->alg.setkey = crypto_rfc3686_setkey;
alg               334 crypto/ctr.c   	inst->alg.encrypt = crypto_rfc3686_crypt;
alg               335 crypto/ctr.c   	inst->alg.decrypt = crypto_rfc3686_crypt;
alg               337 crypto/ctr.c   	inst->alg.base.cra_ctxsize = sizeof(struct crypto_rfc3686_ctx);
alg               339 crypto/ctr.c   	inst->alg.init = crypto_rfc3686_init_tfm;
alg               340 crypto/ctr.c   	inst->alg.exit = crypto_rfc3686_exit_tfm;
alg               333 crypto/cts.c   	struct skcipher_alg *alg;
alg               361 crypto/cts.c   	alg = crypto_spawn_skcipher_alg(spawn);
alg               364 crypto/cts.c   	if (crypto_skcipher_alg_ivsize(alg) != alg->base.cra_blocksize)
alg               367 crypto/cts.c   	if (strncmp(alg->base.cra_name, "cbc(", 4))
alg               371 crypto/cts.c   				  &alg->base);
alg               375 crypto/cts.c   	inst->alg.base.cra_flags = alg->base.cra_flags & CRYPTO_ALG_ASYNC;
alg               376 crypto/cts.c   	inst->alg.base.cra_priority = alg->base.cra_priority;
alg               377 crypto/cts.c   	inst->alg.base.cra_blocksize = alg->base.cra_blocksize;
alg               378 crypto/cts.c   	inst->alg.base.cra_alignmask = alg->base.cra_alignmask;
alg               380 crypto/cts.c   	inst->alg.ivsize = alg->base.cra_blocksize;
alg               381 crypto/cts.c   	inst->alg.chunksize = crypto_skcipher_alg_chunksize(alg);
alg               382 crypto/cts.c   	inst->alg.min_keysize = crypto_skcipher_alg_min_keysize(alg);
alg               383 crypto/cts.c   	inst->alg.max_keysize = crypto_skcipher_alg_max_keysize(alg);
alg               385 crypto/cts.c   	inst->alg.base.cra_ctxsize = sizeof(struct crypto_cts_ctx);
alg               387 crypto/cts.c   	inst->alg.init = crypto_cts_init_tfm;
alg               388 crypto/cts.c   	inst->alg.exit = crypto_cts_exit_tfm;
alg               390 crypto/cts.c   	inst->alg.setkey = crypto_cts_setkey;
alg               391 crypto/cts.c   	inst->alg.encrypt = crypto_cts_encrypt;
alg               392 crypto/cts.c   	inst->alg.decrypt = crypto_cts_decrypt;
alg               276 crypto/deflate.c static struct crypto_alg alg = {
alg               315 crypto/deflate.c 	ret = crypto_register_alg(&alg);
alg               321 crypto/deflate.c 		crypto_unregister_alg(&alg);
alg               330 crypto/deflate.c 	crypto_unregister_alg(&alg);
alg              2056 crypto/drbg.c  static inline void __init drbg_fill_array(struct rng_alg *alg,
alg              2062 crypto/drbg.c  	memcpy(alg->base.cra_name, "stdrng", 6);
alg              2064 crypto/drbg.c  		memcpy(alg->base.cra_driver_name, "drbg_pr_", 8);
alg              2067 crypto/drbg.c  		memcpy(alg->base.cra_driver_name, "drbg_nopr_", 10);
alg              2070 crypto/drbg.c  	memcpy(alg->base.cra_driver_name + pos, core->cra_name,
alg              2073 crypto/drbg.c  	alg->base.cra_priority = priority;
alg              2081 crypto/drbg.c  		alg->base.cra_priority += 200;
alg              2083 crypto/drbg.c  	alg->base.cra_ctxsize 	= sizeof(struct drbg_state);
alg              2084 crypto/drbg.c  	alg->base.cra_module	= THIS_MODULE;
alg              2085 crypto/drbg.c  	alg->base.cra_init	= drbg_kcapi_init;
alg              2086 crypto/drbg.c  	alg->base.cra_exit	= drbg_kcapi_cleanup;
alg              2087 crypto/drbg.c  	alg->generate		= drbg_kcapi_random;
alg              2088 crypto/drbg.c  	alg->seed		= drbg_kcapi_seed;
alg              2089 crypto/drbg.c  	alg->set_ent		= drbg_kcapi_set_entropy;
alg              2090 crypto/drbg.c  	alg->seedsize		= 0;
alg                64 crypto/ecb.c   	struct crypto_alg *alg;
alg                67 crypto/ecb.c   	inst = skcipher_alloc_instance_simple(tmpl, tb, &alg);
alg                71 crypto/ecb.c   	inst->alg.ivsize = 0; /* ECB mode doesn't take an IV */
alg                73 crypto/ecb.c   	inst->alg.encrypt = crypto_ecb_encrypt;
alg                74 crypto/ecb.c   	inst->alg.decrypt = crypto_ecb_decrypt;
alg                79 crypto/ecb.c   	crypto_mod_put(alg);
alg               124 crypto/echainiv.c 	if (inst->alg.ivsize & (sizeof(u64) - 1) || !inst->alg.ivsize)
alg               127 crypto/echainiv.c 	inst->alg.encrypt = echainiv_encrypt;
alg               128 crypto/echainiv.c 	inst->alg.decrypt = echainiv_decrypt;
alg               130 crypto/echainiv.c 	inst->alg.init = aead_init_geniv;
alg               131 crypto/echainiv.c 	inst->alg.exit = aead_exit_geniv;
alg               133 crypto/echainiv.c 	inst->alg.base.cra_ctxsize = sizeof(struct aead_geniv_ctx);
alg               134 crypto/echainiv.c 	inst->alg.base.cra_ctxsize += inst->alg.ivsize;
alg               430 crypto/essiv.c 	struct crypto_alg *alg;
alg               433 crypto/essiv.c 	alg = crypto_alg_mod_lookup(essiv_cipher_name,
alg               436 crypto/essiv.c 	if (IS_ERR(alg))
alg               439 crypto/essiv.c 	if (hash_alg->digestsize < alg->cra_cipher.cia_min_keysize ||
alg               440 crypto/essiv.c 	    hash_alg->digestsize > alg->cra_cipher.cia_max_keysize)
alg               443 crypto/essiv.c 	if (ivsize != alg->cra_blocksize)
alg               452 crypto/essiv.c 	crypto_mod_put(alg);
alg               495 crypto/essiv.c 		base = &skcipher_inst->alg.base;
alg               517 crypto/essiv.c 		base = &aead_inst->alg.base;
alg               590 crypto/essiv.c 		skcipher_inst->alg.setkey	= essiv_skcipher_setkey;
alg               591 crypto/essiv.c 		skcipher_inst->alg.encrypt	= essiv_skcipher_encrypt;
alg               592 crypto/essiv.c 		skcipher_inst->alg.decrypt	= essiv_skcipher_decrypt;
alg               593 crypto/essiv.c 		skcipher_inst->alg.init		= essiv_skcipher_init_tfm;
alg               594 crypto/essiv.c 		skcipher_inst->alg.exit		= essiv_skcipher_exit_tfm;
alg               596 crypto/essiv.c 		skcipher_inst->alg.min_keysize	= crypto_skcipher_alg_min_keysize(skcipher_alg);
alg               597 crypto/essiv.c 		skcipher_inst->alg.max_keysize	= crypto_skcipher_alg_max_keysize(skcipher_alg);
alg               598 crypto/essiv.c 		skcipher_inst->alg.ivsize	= ivsize;
alg               599 crypto/essiv.c 		skcipher_inst->alg.chunksize	= crypto_skcipher_alg_chunksize(skcipher_alg);
alg               600 crypto/essiv.c 		skcipher_inst->alg.walksize	= crypto_skcipher_alg_walksize(skcipher_alg);
alg               606 crypto/essiv.c 		aead_inst->alg.setkey		= essiv_aead_setkey;
alg               607 crypto/essiv.c 		aead_inst->alg.setauthsize	= essiv_aead_setauthsize;
alg               608 crypto/essiv.c 		aead_inst->alg.encrypt		= essiv_aead_encrypt;
alg               609 crypto/essiv.c 		aead_inst->alg.decrypt		= essiv_aead_decrypt;
alg               610 crypto/essiv.c 		aead_inst->alg.init		= essiv_aead_init_tfm;
alg               611 crypto/essiv.c 		aead_inst->alg.exit		= essiv_aead_exit_tfm;
alg               613 crypto/essiv.c 		aead_inst->alg.ivsize		= ivsize;
alg               614 crypto/essiv.c 		aead_inst->alg.maxauthsize	= crypto_aead_alg_maxauthsize(aead_alg);
alg               615 crypto/essiv.c 		aead_inst->alg.chunksize	= crypto_aead_alg_chunksize(aead_alg);
alg               645 crypto/gcm.c   	if (snprintf(inst->alg.base.cra_name, CRYPTO_MAX_ALG_NAME,
alg               649 crypto/gcm.c   	if (snprintf(inst->alg.base.cra_driver_name, CRYPTO_MAX_ALG_NAME,
alg               655 crypto/gcm.c   	inst->alg.base.cra_flags = (ghash->base.cra_flags |
alg               657 crypto/gcm.c   	inst->alg.base.cra_priority = (ghash->base.cra_priority +
alg               659 crypto/gcm.c   	inst->alg.base.cra_blocksize = 1;
alg               660 crypto/gcm.c   	inst->alg.base.cra_alignmask = ghash->base.cra_alignmask |
alg               662 crypto/gcm.c   	inst->alg.base.cra_ctxsize = sizeof(struct crypto_gcm_ctx);
alg               663 crypto/gcm.c   	inst->alg.ivsize = GCM_AES_IV_SIZE;
alg               664 crypto/gcm.c   	inst->alg.chunksize = crypto_skcipher_alg_chunksize(ctr);
alg               665 crypto/gcm.c   	inst->alg.maxauthsize = 16;
alg               666 crypto/gcm.c   	inst->alg.init = crypto_gcm_init_tfm;
alg               667 crypto/gcm.c   	inst->alg.exit = crypto_gcm_exit_tfm;
alg               668 crypto/gcm.c   	inst->alg.setkey = crypto_gcm_setkey;
alg               669 crypto/gcm.c   	inst->alg.setauthsize = crypto_gcm_setauthsize;
alg               670 crypto/gcm.c   	inst->alg.encrypt = crypto_gcm_encrypt;
alg               671 crypto/gcm.c   	inst->alg.decrypt = crypto_gcm_decrypt;
alg               872 crypto/gcm.c   	struct aead_alg *alg;
alg               898 crypto/gcm.c   	alg = crypto_spawn_aead_alg(spawn);
alg               903 crypto/gcm.c   	if (crypto_aead_alg_ivsize(alg) != GCM_AES_IV_SIZE)
alg               907 crypto/gcm.c   	if (alg->base.cra_blocksize != 1)
alg               911 crypto/gcm.c   	if (snprintf(inst->alg.base.cra_name, CRYPTO_MAX_ALG_NAME,
alg               912 crypto/gcm.c   		     "rfc4106(%s)", alg->base.cra_name) >=
alg               914 crypto/gcm.c   	    snprintf(inst->alg.base.cra_driver_name, CRYPTO_MAX_ALG_NAME,
alg               915 crypto/gcm.c   		     "rfc4106(%s)", alg->base.cra_driver_name) >=
alg               919 crypto/gcm.c   	inst->alg.base.cra_flags = alg->base.cra_flags & CRYPTO_ALG_ASYNC;
alg               920 crypto/gcm.c   	inst->alg.base.cra_priority = alg->base.cra_priority;
alg               921 crypto/gcm.c   	inst->alg.base.cra_blocksize = 1;
alg               922 crypto/gcm.c   	inst->alg.base.cra_alignmask = alg->base.cra_alignmask;
alg               924 crypto/gcm.c   	inst->alg.base.cra_ctxsize = sizeof(struct crypto_rfc4106_ctx);
alg               926 crypto/gcm.c   	inst->alg.ivsize = GCM_RFC4106_IV_SIZE;
alg               927 crypto/gcm.c   	inst->alg.chunksize = crypto_aead_alg_chunksize(alg);
alg               928 crypto/gcm.c   	inst->alg.maxauthsize = crypto_aead_alg_maxauthsize(alg);
alg               930 crypto/gcm.c   	inst->alg.init = crypto_rfc4106_init_tfm;
alg               931 crypto/gcm.c   	inst->alg.exit = crypto_rfc4106_exit_tfm;
alg               933 crypto/gcm.c   	inst->alg.setkey = crypto_rfc4106_setkey;
alg               934 crypto/gcm.c   	inst->alg.setauthsize = crypto_rfc4106_setauthsize;
alg               935 crypto/gcm.c   	inst->alg.encrypt = crypto_rfc4106_encrypt;
alg               936 crypto/gcm.c   	inst->alg.decrypt = crypto_rfc4106_decrypt;
alg              1108 crypto/gcm.c   	struct aead_alg *alg;
alg              1136 crypto/gcm.c   	alg = crypto_spawn_aead_alg(spawn);
alg              1141 crypto/gcm.c   	if (crypto_aead_alg_ivsize(alg) != GCM_AES_IV_SIZE)
alg              1145 crypto/gcm.c   	if (alg->base.cra_blocksize != 1)
alg              1149 crypto/gcm.c   	if (snprintf(inst->alg.base.cra_name, CRYPTO_MAX_ALG_NAME,
alg              1150 crypto/gcm.c   		     "rfc4543(%s)", alg->base.cra_name) >=
alg              1152 crypto/gcm.c   	    snprintf(inst->alg.base.cra_driver_name, CRYPTO_MAX_ALG_NAME,
alg              1153 crypto/gcm.c   		     "rfc4543(%s)", alg->base.cra_driver_name) >=
alg              1157 crypto/gcm.c   	inst->alg.base.cra_flags = alg->base.cra_flags & CRYPTO_ALG_ASYNC;
alg              1158 crypto/gcm.c   	inst->alg.base.cra_priority = alg->base.cra_priority;
alg              1159 crypto/gcm.c   	inst->alg.base.cra_blocksize = 1;
alg              1160 crypto/gcm.c   	inst->alg.base.cra_alignmask = alg->base.cra_alignmask;
alg              1162 crypto/gcm.c   	inst->alg.base.cra_ctxsize = sizeof(struct crypto_rfc4543_ctx);
alg              1164 crypto/gcm.c   	inst->alg.ivsize = GCM_RFC4543_IV_SIZE;
alg              1165 crypto/gcm.c   	inst->alg.chunksize = crypto_aead_alg_chunksize(alg);
alg              1166 crypto/gcm.c   	inst->alg.maxauthsize = crypto_aead_alg_maxauthsize(alg);
alg              1168 crypto/gcm.c   	inst->alg.init = crypto_rfc4543_init_tfm;
alg              1169 crypto/gcm.c   	inst->alg.exit = crypto_rfc4543_exit_tfm;
alg              1171 crypto/gcm.c   	inst->alg.setkey = crypto_rfc4543_setkey;
alg              1172 crypto/gcm.c   	inst->alg.setauthsize = crypto_rfc4543_setauthsize;
alg              1173 crypto/gcm.c   	inst->alg.encrypt = crypto_rfc4543_encrypt;
alg              1174 crypto/gcm.c   	inst->alg.decrypt = crypto_rfc4543_decrypt;
alg               173 crypto/hmac.c  	struct crypto_alg *alg;
alg               186 crypto/hmac.c  	alg = &salg->base;
alg               195 crypto/hmac.c  	if (ds > alg->cra_blocksize ||
alg               196 crypto/hmac.c  	    ss < alg->cra_blocksize)
alg               199 crypto/hmac.c  	inst = shash_alloc_instance("hmac", alg);
alg               209 crypto/hmac.c  	inst->alg.base.cra_priority = alg->cra_priority;
alg               210 crypto/hmac.c  	inst->alg.base.cra_blocksize = alg->cra_blocksize;
alg               211 crypto/hmac.c  	inst->alg.base.cra_alignmask = alg->cra_alignmask;
alg               213 crypto/hmac.c  	ss = ALIGN(ss, alg->cra_alignmask + 1);
alg               214 crypto/hmac.c  	inst->alg.digestsize = ds;
alg               215 crypto/hmac.c  	inst->alg.statesize = ss;
alg               217 crypto/hmac.c  	inst->alg.base.cra_ctxsize = sizeof(struct hmac_ctx) +
alg               220 crypto/hmac.c  	inst->alg.base.cra_init = hmac_init_tfm;
alg               221 crypto/hmac.c  	inst->alg.base.cra_exit = hmac_exit_tfm;
alg               223 crypto/hmac.c  	inst->alg.init = hmac_init;
alg               224 crypto/hmac.c  	inst->alg.update = hmac_update;
alg               225 crypto/hmac.c  	inst->alg.final = hmac_final;
alg               226 crypto/hmac.c  	inst->alg.finup = hmac_finup;
alg               227 crypto/hmac.c  	inst->alg.export = hmac_export;
alg               228 crypto/hmac.c  	inst->alg.import = hmac_import;
alg               229 crypto/hmac.c  	inst->alg.setkey = hmac_setkey;
alg               238 crypto/hmac.c  	crypto_mod_put(alg);
alg                28 crypto/internal.h 	struct crypto_alg alg;
alg                48 crypto/internal.h static inline unsigned int crypto_cipher_ctxsize(struct crypto_alg *alg)
alg                50 crypto/internal.h 	return alg->cra_ctxsize;
alg                53 crypto/internal.h static inline unsigned int crypto_compress_ctxsize(struct crypto_alg *alg)
alg                55 crypto/internal.h 	return alg->cra_ctxsize;
alg                58 crypto/internal.h struct crypto_alg *crypto_mod_get(struct crypto_alg *alg);
alg                65 crypto/internal.h void crypto_larval_kill(struct crypto_alg *alg);
alg                68 crypto/internal.h void crypto_remove_spawns(struct crypto_alg *alg, struct list_head *list,
alg                71 crypto/internal.h struct crypto_tfm *__crypto_alloc_tfm(struct crypto_alg *alg, u32 type,
alg                73 crypto/internal.h void *crypto_create_tfm(struct crypto_alg *alg,
alg                83 crypto/internal.h unsigned int crypto_alg_extsize(struct crypto_alg *alg);
alg                88 crypto/internal.h static inline struct crypto_alg *crypto_alg_get(struct crypto_alg *alg)
alg                90 crypto/internal.h 	refcount_inc(&alg->cra_refcnt);
alg                91 crypto/internal.h 	return alg;
alg                94 crypto/internal.h static inline void crypto_alg_put(struct crypto_alg *alg)
alg                96 crypto/internal.h 	if (refcount_dec_and_test(&alg->cra_refcnt) && alg->cra_destroy)
alg                97 crypto/internal.h 		alg->cra_destroy(alg);
alg               110 crypto/internal.h static inline int crypto_is_larval(struct crypto_alg *alg)
alg               112 crypto/internal.h 	return alg->cra_flags & CRYPTO_ALG_LARVAL;
alg               115 crypto/internal.h static inline int crypto_is_dead(struct crypto_alg *alg)
alg               117 crypto/internal.h 	return alg->cra_flags & CRYPTO_ALG_DEAD;
alg               120 crypto/internal.h static inline int crypto_is_moribund(struct crypto_alg *alg)
alg               122 crypto/internal.h 	return alg->cra_flags & (CRYPTO_ALG_DEAD | CRYPTO_ALG_DYING);
alg               266 crypto/keywrap.c 	struct crypto_alg *alg;
alg               269 crypto/keywrap.c 	inst = skcipher_alloc_instance_simple(tmpl, tb, &alg);
alg               275 crypto/keywrap.c 	if (alg->cra_blocksize != sizeof(struct crypto_kw_block))
alg               278 crypto/keywrap.c 	inst->alg.base.cra_blocksize = SEMIBSIZE;
alg               279 crypto/keywrap.c 	inst->alg.base.cra_alignmask = 0;
alg               280 crypto/keywrap.c 	inst->alg.ivsize = SEMIBSIZE;
alg               282 crypto/keywrap.c 	inst->alg.encrypt = crypto_kw_encrypt;
alg               283 crypto/keywrap.c 	inst->alg.decrypt = crypto_kw_decrypt;
alg               293 crypto/keywrap.c 	crypto_mod_put(alg);
alg                24 crypto/kpp.c   static int crypto_kpp_report(struct sk_buff *skb, struct crypto_alg *alg)
alg                35 crypto/kpp.c   static int crypto_kpp_report(struct sk_buff *skb, struct crypto_alg *alg)
alg                41 crypto/kpp.c   static void crypto_kpp_show(struct seq_file *m, struct crypto_alg *alg)
alg                44 crypto/kpp.c   static void crypto_kpp_show(struct seq_file *m, struct crypto_alg *alg)
alg                52 crypto/kpp.c   	struct kpp_alg *alg = crypto_kpp_alg(kpp);
alg                54 crypto/kpp.c   	alg->exit(kpp);
alg                60 crypto/kpp.c   	struct kpp_alg *alg = crypto_kpp_alg(kpp);
alg                62 crypto/kpp.c   	if (alg->exit)
alg                65 crypto/kpp.c   	if (alg->init)
alg                66 crypto/kpp.c   		return alg->init(kpp);
alg                90 crypto/kpp.c   static void kpp_prepare_alg(struct kpp_alg *alg)
alg                92 crypto/kpp.c   	struct crypto_alg *base = &alg->base;
alg                99 crypto/kpp.c   int crypto_register_kpp(struct kpp_alg *alg)
alg               101 crypto/kpp.c   	struct crypto_alg *base = &alg->base;
alg               103 crypto/kpp.c   	kpp_prepare_alg(alg);
alg               108 crypto/kpp.c   void crypto_unregister_kpp(struct kpp_alg *alg)
alg               110 crypto/kpp.c   	crypto_unregister_alg(&alg->base);
alg               303 crypto/lrw.c   	struct skcipher_alg *alg;
alg               343 crypto/lrw.c   	alg = crypto_skcipher_spawn_alg(spawn);
alg               346 crypto/lrw.c   	if (alg->base.cra_blocksize != LRW_BLOCK_SIZE)
alg               349 crypto/lrw.c   	if (crypto_skcipher_alg_ivsize(alg))
alg               353 crypto/lrw.c   				  &alg->base);
alg               358 crypto/lrw.c   	cipher_name = alg->base.cra_name;
alg               375 crypto/lrw.c   		if (snprintf(inst->alg.base.cra_name, CRYPTO_MAX_ALG_NAME,
alg               383 crypto/lrw.c   	inst->alg.base.cra_flags = alg->base.cra_flags & CRYPTO_ALG_ASYNC;
alg               384 crypto/lrw.c   	inst->alg.base.cra_priority = alg->base.cra_priority;
alg               385 crypto/lrw.c   	inst->alg.base.cra_blocksize = LRW_BLOCK_SIZE;
alg               386 crypto/lrw.c   	inst->alg.base.cra_alignmask = alg->base.cra_alignmask |
alg               389 crypto/lrw.c   	inst->alg.ivsize = LRW_BLOCK_SIZE;
alg               390 crypto/lrw.c   	inst->alg.min_keysize = crypto_skcipher_alg_min_keysize(alg) +
alg               392 crypto/lrw.c   	inst->alg.max_keysize = crypto_skcipher_alg_max_keysize(alg) +
alg               395 crypto/lrw.c   	inst->alg.base.cra_ctxsize = sizeof(struct priv);
alg               397 crypto/lrw.c   	inst->alg.init = init_tfm;
alg               398 crypto/lrw.c   	inst->alg.exit = exit_tfm;
alg               400 crypto/lrw.c   	inst->alg.setkey = setkey;
alg               401 crypto/lrw.c   	inst->alg.encrypt = encrypt;
alg               402 crypto/lrw.c   	inst->alg.decrypt = decrypt;
alg               110 crypto/lzo-rle.c static struct crypto_alg alg = {
alg               139 crypto/lzo-rle.c 	ret = crypto_register_alg(&alg);
alg               145 crypto/lzo-rle.c 		crypto_unregister_alg(&alg);
alg               154 crypto/lzo-rle.c 	crypto_unregister_alg(&alg);
alg               110 crypto/lzo.c   static struct crypto_alg alg = {
alg               139 crypto/lzo.c   	ret = crypto_register_alg(&alg);
alg               145 crypto/lzo.c   		crypto_unregister_alg(&alg);
alg               154 crypto/lzo.c   	crypto_unregister_alg(&alg);
alg               212 crypto/md4.c   static struct shash_alg alg = {
alg               228 crypto/md4.c   	return crypto_register_shash(&alg);
alg               233 crypto/md4.c   	crypto_unregister_shash(&alg);
alg               221 crypto/md5.c   static struct shash_alg alg = {
alg               240 crypto/md5.c   	return crypto_register_shash(&alg);
alg               245 crypto/md5.c   	crypto_unregister_shash(&alg);
alg               150 crypto/michael_mic.c static struct shash_alg alg = {
alg               169 crypto/michael_mic.c 	return crypto_register_shash(&alg);
alg               175 crypto/michael_mic.c 	crypto_unregister_shash(&alg);
alg                55 crypto/ofb.c   	struct crypto_alg *alg;
alg                58 crypto/ofb.c   	inst = skcipher_alloc_instance_simple(tmpl, tb, &alg);
alg                63 crypto/ofb.c   	inst->alg.base.cra_blocksize = 1;
alg                69 crypto/ofb.c   	inst->alg.chunksize = alg->cra_blocksize;
alg                71 crypto/ofb.c   	inst->alg.encrypt = crypto_ofb_crypt;
alg                72 crypto/ofb.c   	inst->alg.decrypt = crypto_ofb_crypt;
alg                78 crypto/ofb.c   	crypto_mod_put(alg);
alg               156 crypto/pcbc.c  	struct crypto_alg *alg;
alg               159 crypto/pcbc.c  	inst = skcipher_alloc_instance_simple(tmpl, tb, &alg);
alg               163 crypto/pcbc.c  	inst->alg.encrypt = crypto_pcbc_encrypt;
alg               164 crypto/pcbc.c  	inst->alg.decrypt = crypto_pcbc_decrypt;
alg               169 crypto/pcbc.c  	crypto_mod_put(alg);
alg               214 crypto/pcrypt.c 				struct crypto_alg *alg)
alg               216 crypto/pcrypt.c 	if (snprintf(inst->alg.cra_driver_name, CRYPTO_MAX_ALG_NAME,
alg               217 crypto/pcrypt.c 		     "pcrypt(%s)", alg->cra_driver_name) >= CRYPTO_MAX_ALG_NAME)
alg               220 crypto/pcrypt.c 	memcpy(inst->alg.cra_name, alg->cra_name, CRYPTO_MAX_ALG_NAME);
alg               222 crypto/pcrypt.c 	inst->alg.cra_priority = alg->cra_priority + 100;
alg               223 crypto/pcrypt.c 	inst->alg.cra_blocksize = alg->cra_blocksize;
alg               224 crypto/pcrypt.c 	inst->alg.cra_alignmask = alg->cra_alignmask;
alg               235 crypto/pcrypt.c 	struct aead_alg *alg;
alg               268 crypto/pcrypt.c 	alg = crypto_spawn_aead_alg(&ctx->spawn);
alg               269 crypto/pcrypt.c 	err = pcrypt_init_instance(aead_crypto_instance(inst), &alg->base);
alg               273 crypto/pcrypt.c 	inst->alg.base.cra_flags = CRYPTO_ALG_ASYNC;
alg               275 crypto/pcrypt.c 	inst->alg.ivsize = crypto_aead_alg_ivsize(alg);
alg               276 crypto/pcrypt.c 	inst->alg.maxauthsize = crypto_aead_alg_maxauthsize(alg);
alg               278 crypto/pcrypt.c 	inst->alg.base.cra_ctxsize = sizeof(struct pcrypt_aead_ctx);
alg               280 crypto/pcrypt.c 	inst->alg.init = pcrypt_aead_init_tfm;
alg               281 crypto/pcrypt.c 	inst->alg.exit = pcrypt_aead_exit_tfm;
alg               283 crypto/pcrypt.c 	inst->alg.setkey = pcrypt_aead_setkey;
alg               284 crypto/pcrypt.c 	inst->alg.setauthsize = pcrypt_aead_setauthsize;
alg               285 crypto/pcrypt.c 	inst->alg.encrypt = pcrypt_aead_encrypt;
alg               286 crypto/pcrypt.c 	inst->alg.decrypt = pcrypt_aead_decrypt;
alg                38 crypto/proc.c  	struct crypto_alg *alg = list_entry(p, struct crypto_alg, cra_list);
alg                40 crypto/proc.c  	seq_printf(m, "name         : %s\n", alg->cra_name);
alg                41 crypto/proc.c  	seq_printf(m, "driver       : %s\n", alg->cra_driver_name);
alg                42 crypto/proc.c  	seq_printf(m, "module       : %s\n", module_name(alg->cra_module));
alg                43 crypto/proc.c  	seq_printf(m, "priority     : %d\n", alg->cra_priority);
alg                44 crypto/proc.c  	seq_printf(m, "refcnt       : %u\n", refcount_read(&alg->cra_refcnt));
alg                46 crypto/proc.c  		   (alg->cra_flags & CRYPTO_ALG_TESTED) ?
alg                49 crypto/proc.c  		   (alg->cra_flags & CRYPTO_ALG_INTERNAL) ?
alg                52 crypto/proc.c  	if (alg->cra_flags & CRYPTO_ALG_LARVAL) {
alg                54 crypto/proc.c  		seq_printf(m, "flags        : 0x%x\n", alg->cra_flags);
alg                58 crypto/proc.c  	if (alg->cra_type && alg->cra_type->show) {
alg                59 crypto/proc.c  		alg->cra_type->show(m, alg);
alg                63 crypto/proc.c  	switch (alg->cra_flags & (CRYPTO_ALG_TYPE_MASK | CRYPTO_ALG_LARVAL)) {
alg                66 crypto/proc.c  		seq_printf(m, "blocksize    : %u\n", alg->cra_blocksize);
alg                68 crypto/proc.c  					alg->cra_cipher.cia_min_keysize);
alg                70 crypto/proc.c  					alg->cra_cipher.cia_max_keysize);
alg               293 crypto/rmd128.c static struct shash_alg alg = {
alg               309 crypto/rmd128.c 	return crypto_register_shash(&alg);
alg               314 crypto/rmd128.c 	crypto_unregister_shash(&alg);
alg               337 crypto/rmd160.c static struct shash_alg alg = {
alg               353 crypto/rmd160.c 	return crypto_register_shash(&alg);
alg               358 crypto/rmd160.c 	crypto_unregister_shash(&alg);
alg               312 crypto/rmd256.c static struct shash_alg alg = {
alg               328 crypto/rmd256.c 	return crypto_register_shash(&alg);
alg               333 crypto/rmd256.c 	crypto_unregister_shash(&alg);
alg               361 crypto/rmd320.c static struct shash_alg alg = {
alg               377 crypto/rmd320.c 	return crypto_register_shash(&alg);
alg               382 crypto/rmd320.c 	crypto_unregister_shash(&alg);
alg                33 crypto/rng.c   	struct crypto_alg *alg = tfm->base.__crt_alg;
alg                37 crypto/rng.c   	crypto_stats_get(alg);
alg                41 crypto/rng.c   			crypto_alg_put(alg);
alg                47 crypto/rng.c   			crypto_alg_put(alg);
alg                54 crypto/rng.c   	crypto_stats_rng_seed(alg, err);
alg                66 crypto/rng.c   static unsigned int seedsize(struct crypto_alg *alg)
alg                68 crypto/rng.c   	struct rng_alg *ralg = container_of(alg, struct rng_alg, base);
alg                74 crypto/rng.c   static int crypto_rng_report(struct sk_buff *skb, struct crypto_alg *alg)
alg                82 crypto/rng.c   	rrng.seedsize = seedsize(alg);
alg                87 crypto/rng.c   static int crypto_rng_report(struct sk_buff *skb, struct crypto_alg *alg)
alg                93 crypto/rng.c   static void crypto_rng_show(struct seq_file *m, struct crypto_alg *alg)
alg                95 crypto/rng.c   static void crypto_rng_show(struct seq_file *m, struct crypto_alg *alg)
alg                98 crypto/rng.c   	seq_printf(m, "seedsize     : %u\n", seedsize(alg));
alg               181 crypto/rng.c   int crypto_register_rng(struct rng_alg *alg)
alg               183 crypto/rng.c   	struct crypto_alg *base = &alg->base;
alg               185 crypto/rng.c   	if (alg->seedsize > PAGE_SIZE / 8)
alg               196 crypto/rng.c   void crypto_unregister_rng(struct rng_alg *alg)
alg               198 crypto/rng.c   	crypto_unregister_alg(&alg->base);
alg               650 crypto/rsa-pkcs1pad.c 		if (snprintf(inst->alg.base.cra_name,
alg               655 crypto/rsa-pkcs1pad.c 		if (snprintf(inst->alg.base.cra_driver_name,
alg               661 crypto/rsa-pkcs1pad.c 		if (snprintf(inst->alg.base.cra_name, CRYPTO_MAX_ALG_NAME,
alg               666 crypto/rsa-pkcs1pad.c 		if (snprintf(inst->alg.base.cra_driver_name,
alg               673 crypto/rsa-pkcs1pad.c 	inst->alg.base.cra_flags = rsa_alg->base.cra_flags & CRYPTO_ALG_ASYNC;
alg               674 crypto/rsa-pkcs1pad.c 	inst->alg.base.cra_priority = rsa_alg->base.cra_priority;
alg               675 crypto/rsa-pkcs1pad.c 	inst->alg.base.cra_ctxsize = sizeof(struct pkcs1pad_ctx);
alg               677 crypto/rsa-pkcs1pad.c 	inst->alg.init = pkcs1pad_init_tfm;
alg               678 crypto/rsa-pkcs1pad.c 	inst->alg.exit = pkcs1pad_exit_tfm;
alg               680 crypto/rsa-pkcs1pad.c 	inst->alg.encrypt = pkcs1pad_encrypt;
alg               681 crypto/rsa-pkcs1pad.c 	inst->alg.decrypt = pkcs1pad_decrypt;
alg               682 crypto/rsa-pkcs1pad.c 	inst->alg.sign = pkcs1pad_sign;
alg               683 crypto/rsa-pkcs1pad.c 	inst->alg.verify = pkcs1pad_verify;
alg               684 crypto/rsa-pkcs1pad.c 	inst->alg.set_pub_key = pkcs1pad_set_pub_key;
alg               685 crypto/rsa-pkcs1pad.c 	inst->alg.set_priv_key = pkcs1pad_set_priv_key;
alg               686 crypto/rsa-pkcs1pad.c 	inst->alg.max_size = pkcs1pad_get_max_size;
alg               687 crypto/rsa-pkcs1pad.c 	inst->alg.reqsize = sizeof(struct pkcs1pad_request) + rsa_alg->reqsize;
alg               179 crypto/salsa20_generic.c static struct skcipher_alg alg = {
alg               198 crypto/salsa20_generic.c 	return crypto_register_skcipher(&alg);
alg               203 crypto/salsa20_generic.c 	crypto_unregister_skcipher(&alg);
alg                42 crypto/scompress.c static int crypto_scomp_report(struct sk_buff *skb, struct crypto_alg *alg)
alg                54 crypto/scompress.c static int crypto_scomp_report(struct sk_buff *skb, struct crypto_alg *alg)
alg                60 crypto/scompress.c static void crypto_scomp_show(struct seq_file *m, struct crypto_alg *alg)
alg                63 crypto/scompress.c static void crypto_scomp_show(struct seq_file *m, struct crypto_alg *alg)
alg               257 crypto/scompress.c int crypto_register_scomp(struct scomp_alg *alg)
alg               259 crypto/scompress.c 	struct crypto_alg *base = &alg->base;
alg               269 crypto/scompress.c int crypto_unregister_scomp(struct scomp_alg *alg)
alg               271 crypto/scompress.c 	return crypto_unregister_alg(&alg->base);
alg               149 crypto/seqiv.c 	if (inst->alg.ivsize != sizeof(u64))
alg               152 crypto/seqiv.c 	inst->alg.encrypt = seqiv_aead_encrypt;
alg               153 crypto/seqiv.c 	inst->alg.decrypt = seqiv_aead_decrypt;
alg               155 crypto/seqiv.c 	inst->alg.init = aead_init_geniv;
alg               156 crypto/seqiv.c 	inst->alg.exit = aead_exit_geniv;
alg               158 crypto/seqiv.c 	inst->alg.base.cra_ctxsize = sizeof(struct aead_geniv_ctx);
alg               159 crypto/seqiv.c 	inst->alg.base.cra_ctxsize += inst->alg.ivsize;
alg                64 crypto/sha1_generic.c static struct shash_alg alg = {
alg                82 crypto/sha1_generic.c 	return crypto_register_shash(&alg);
alg                87 crypto/sha1_generic.c 	crypto_unregister_shash(&alg);
alg                51 crypto/shash.c static void shash_set_needkey(struct crypto_shash *tfm, struct shash_alg *alg)
alg                53 crypto/shash.c 	if (crypto_shash_alg_has_setkey(alg) &&
alg                54 crypto/shash.c 	    !(alg->base.cra_flags & CRYPTO_ALG_OPTIONAL_KEY))
alg               353 crypto/shash.c 	struct shash_alg *alg = __crypto_shash_alg(calg);
alg               375 crypto/shash.c 	if (crypto_shash_alg_has_setkey(alg))
alg               392 crypto/shash.c 	struct shash_alg *alg = crypto_shash_alg(hash);
alg               394 crypto/shash.c 	hash->descsize = alg->descsize;
alg               396 crypto/shash.c 	shash_set_needkey(hash, alg);
alg               402 crypto/shash.c static int crypto_shash_report(struct sk_buff *skb, struct crypto_alg *alg)
alg               405 crypto/shash.c 	struct shash_alg *salg = __crypto_shash_alg(alg);
alg               411 crypto/shash.c 	rhash.blocksize = alg->cra_blocksize;
alg               417 crypto/shash.c static int crypto_shash_report(struct sk_buff *skb, struct crypto_alg *alg)
alg               423 crypto/shash.c static void crypto_shash_show(struct seq_file *m, struct crypto_alg *alg)
alg               425 crypto/shash.c static void crypto_shash_show(struct seq_file *m, struct crypto_alg *alg)
alg               427 crypto/shash.c 	struct shash_alg *salg = __crypto_shash_alg(alg);
alg               430 crypto/shash.c 	seq_printf(m, "blocksize    : %u\n", alg->cra_blocksize);
alg               454 crypto/shash.c static int shash_prepare_alg(struct shash_alg *alg)
alg               456 crypto/shash.c 	struct crypto_alg *base = &alg->base;
alg               458 crypto/shash.c 	if (alg->digestsize > HASH_MAX_DIGESTSIZE ||
alg               459 crypto/shash.c 	    alg->descsize > HASH_MAX_DESCSIZE ||
alg               460 crypto/shash.c 	    alg->statesize > HASH_MAX_STATESIZE)
alg               463 crypto/shash.c 	if ((alg->export && !alg->import) || (alg->import && !alg->export))
alg               470 crypto/shash.c 	if (!alg->finup)
alg               471 crypto/shash.c 		alg->finup = shash_finup_unaligned;
alg               472 crypto/shash.c 	if (!alg->digest)
alg               473 crypto/shash.c 		alg->digest = shash_digest_unaligned;
alg               474 crypto/shash.c 	if (!alg->export) {
alg               475 crypto/shash.c 		alg->export = shash_default_export;
alg               476 crypto/shash.c 		alg->import = shash_default_import;
alg               477 crypto/shash.c 		alg->statesize = alg->descsize;
alg               479 crypto/shash.c 	if (!alg->setkey)
alg               480 crypto/shash.c 		alg->setkey = shash_no_setkey;
alg               485 crypto/shash.c int crypto_register_shash(struct shash_alg *alg)
alg               487 crypto/shash.c 	struct crypto_alg *base = &alg->base;
alg               490 crypto/shash.c 	err = shash_prepare_alg(alg);
alg               498 crypto/shash.c int crypto_unregister_shash(struct shash_alg *alg)
alg               500 crypto/shash.c 	return crypto_unregister_alg(&alg->base);
alg               545 crypto/shash.c 	err = shash_prepare_alg(&inst->alg);
alg               561 crypto/shash.c 			    struct shash_alg *alg,
alg               564 crypto/shash.c 	return crypto_init_spawn2(&spawn->base, &alg->base, inst,
alg               571 crypto/shash.c 	struct crypto_alg *alg;
alg               573 crypto/shash.c 	alg = crypto_attr_alg2(rta, &crypto_shash_type, type, mask);
alg               574 crypto/shash.c 	return IS_ERR(alg) ? ERR_CAST(alg) :
alg               575 crypto/shash.c 	       container_of(alg, struct shash_alg, base);
alg                43 crypto/simd.c  	struct skcipher_alg alg;
alg               120 crypto/simd.c  	struct skcipher_alg *alg;
alg               123 crypto/simd.c  	alg = crypto_skcipher_alg(tfm);
alg               124 crypto/simd.c  	salg = container_of(alg, struct simd_skcipher_alg, alg);
alg               150 crypto/simd.c  	struct skcipher_alg *alg;
alg               167 crypto/simd.c  	alg = &salg->alg;
alg               170 crypto/simd.c  	if (snprintf(alg->base.cra_name, CRYPTO_MAX_ALG_NAME, "%s", algname) >=
alg               174 crypto/simd.c  	if (snprintf(alg->base.cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s",
alg               178 crypto/simd.c  	alg->base.cra_flags = CRYPTO_ALG_ASYNC;
alg               179 crypto/simd.c  	alg->base.cra_priority = ialg->base.cra_priority;
alg               180 crypto/simd.c  	alg->base.cra_blocksize = ialg->base.cra_blocksize;
alg               181 crypto/simd.c  	alg->base.cra_alignmask = ialg->base.cra_alignmask;
alg               182 crypto/simd.c  	alg->base.cra_module = ialg->base.cra_module;
alg               183 crypto/simd.c  	alg->base.cra_ctxsize = sizeof(struct simd_skcipher_ctx);
alg               185 crypto/simd.c  	alg->ivsize = ialg->ivsize;
alg               186 crypto/simd.c  	alg->chunksize = ialg->chunksize;
alg               187 crypto/simd.c  	alg->min_keysize = ialg->min_keysize;
alg               188 crypto/simd.c  	alg->max_keysize = ialg->max_keysize;
alg               190 crypto/simd.c  	alg->init = simd_skcipher_init;
alg               191 crypto/simd.c  	alg->exit = simd_skcipher_exit;
alg               193 crypto/simd.c  	alg->setkey = simd_skcipher_setkey;
alg               194 crypto/simd.c  	alg->encrypt = simd_skcipher_encrypt;
alg               195 crypto/simd.c  	alg->decrypt = simd_skcipher_decrypt;
alg               197 crypto/simd.c  	err = crypto_register_skcipher(alg);
alg               227 crypto/simd.c  	crypto_unregister_skcipher(&salg->alg);
alg               286 crypto/simd.c  	struct aead_alg alg;
alg               371 crypto/simd.c  	struct aead_alg *alg;
alg               374 crypto/simd.c  	alg = crypto_aead_alg(tfm);
alg               375 crypto/simd.c  	salg = container_of(alg, struct simd_aead_alg, alg);
alg               400 crypto/simd.c  	struct aead_alg *alg;
alg               417 crypto/simd.c  	alg = &salg->alg;
alg               420 crypto/simd.c  	if (snprintf(alg->base.cra_name, CRYPTO_MAX_ALG_NAME, "%s", algname) >=
alg               424 crypto/simd.c  	if (snprintf(alg->base.cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s",
alg               428 crypto/simd.c  	alg->base.cra_flags = CRYPTO_ALG_ASYNC;
alg               429 crypto/simd.c  	alg->base.cra_priority = ialg->base.cra_priority;
alg               430 crypto/simd.c  	alg->base.cra_blocksize = ialg->base.cra_blocksize;
alg               431 crypto/simd.c  	alg->base.cra_alignmask = ialg->base.cra_alignmask;
alg               432 crypto/simd.c  	alg->base.cra_module = ialg->base.cra_module;
alg               433 crypto/simd.c  	alg->base.cra_ctxsize = sizeof(struct simd_aead_ctx);
alg               435 crypto/simd.c  	alg->ivsize = ialg->ivsize;
alg               436 crypto/simd.c  	alg->maxauthsize = ialg->maxauthsize;
alg               437 crypto/simd.c  	alg->chunksize = ialg->chunksize;
alg               439 crypto/simd.c  	alg->init = simd_aead_init;
alg               440 crypto/simd.c  	alg->exit = simd_aead_exit;
alg               442 crypto/simd.c  	alg->setkey = simd_aead_setkey;
alg               443 crypto/simd.c  	alg->setauthsize = simd_aead_setauthsize;
alg               444 crypto/simd.c  	alg->encrypt = simd_aead_encrypt;
alg               445 crypto/simd.c  	alg->decrypt = simd_aead_decrypt;
alg               447 crypto/simd.c  	err = crypto_register_aead(alg);
alg               477 crypto/simd.c  	crypto_unregister_aead(&salg->alg);
alg               581 crypto/skcipher.c static unsigned int crypto_skcipher_extsize(struct crypto_alg *alg)
alg               583 crypto/skcipher.c 	if (alg->cra_type == &crypto_blkcipher_type)
alg               586 crypto/skcipher.c 	if (alg->cra_type == &crypto_ablkcipher_type)
alg               589 crypto/skcipher.c 	return crypto_alg_extsize(alg);
alg               642 crypto/skcipher.c 	struct blkcipher_alg *alg = &tfm->__crt_alg->cra_blkcipher;
alg               644 crypto/skcipher.c 	return skcipher_crypt_blkcipher(req, alg->encrypt);
alg               651 crypto/skcipher.c 	struct blkcipher_alg *alg = &tfm->__crt_alg->cra_blkcipher;
alg               653 crypto/skcipher.c 	return skcipher_crypt_blkcipher(req, alg->decrypt);
alg               741 crypto/skcipher.c 	struct ablkcipher_alg *alg = &tfm->__crt_alg->cra_ablkcipher;
alg               743 crypto/skcipher.c 	return skcipher_crypt_ablkcipher(req, alg->encrypt);
alg               750 crypto/skcipher.c 	struct ablkcipher_alg *alg = &tfm->__crt_alg->cra_ablkcipher;
alg               752 crypto/skcipher.c 	return skcipher_crypt_ablkcipher(req, alg->decrypt);
alg               847 crypto/skcipher.c 	struct crypto_alg *alg = tfm->base.__crt_alg;
alg               851 crypto/skcipher.c 	crypto_stats_get(alg);
alg               856 crypto/skcipher.c 	crypto_stats_skcipher_encrypt(cryptlen, ret, alg);
alg               864 crypto/skcipher.c 	struct crypto_alg *alg = tfm->base.__crt_alg;
alg               868 crypto/skcipher.c 	crypto_stats_get(alg);
alg               873 crypto/skcipher.c 	crypto_stats_skcipher_decrypt(cryptlen, ret, alg);
alg               881 crypto/skcipher.c 	struct skcipher_alg *alg = crypto_skcipher_alg(skcipher);
alg               883 crypto/skcipher.c 	alg->exit(skcipher);
alg               889 crypto/skcipher.c 	struct skcipher_alg *alg = crypto_skcipher_alg(skcipher);
alg               898 crypto/skcipher.c 	skcipher->encrypt = alg->encrypt;
alg               899 crypto/skcipher.c 	skcipher->decrypt = alg->decrypt;
alg               900 crypto/skcipher.c 	skcipher->ivsize = alg->ivsize;
alg               901 crypto/skcipher.c 	skcipher->keysize = alg->max_keysize;
alg               905 crypto/skcipher.c 	if (alg->exit)
alg               908 crypto/skcipher.c 	if (alg->init)
alg               909 crypto/skcipher.c 		return alg->init(skcipher);
alg               922 crypto/skcipher.c static void crypto_skcipher_show(struct seq_file *m, struct crypto_alg *alg)
alg               924 crypto/skcipher.c static void crypto_skcipher_show(struct seq_file *m, struct crypto_alg *alg)
alg               926 crypto/skcipher.c 	struct skcipher_alg *skcipher = container_of(alg, struct skcipher_alg,
alg               931 crypto/skcipher.c 		   alg->cra_flags & CRYPTO_ALG_ASYNC ?  "yes" : "no");
alg               932 crypto/skcipher.c 	seq_printf(m, "blocksize    : %u\n", alg->cra_blocksize);
alg               941 crypto/skcipher.c static int crypto_skcipher_report(struct sk_buff *skb, struct crypto_alg *alg)
alg               944 crypto/skcipher.c 	struct skcipher_alg *skcipher = container_of(alg, struct skcipher_alg,
alg               952 crypto/skcipher.c 	rblkcipher.blocksize = alg->cra_blocksize;
alg               961 crypto/skcipher.c static int crypto_skcipher_report(struct sk_buff *skb, struct crypto_alg *alg)
alg              1027 crypto/skcipher.c static int skcipher_prepare_alg(struct skcipher_alg *alg)
alg              1029 crypto/skcipher.c 	struct crypto_alg *base = &alg->base;
alg              1031 crypto/skcipher.c 	if (alg->ivsize > PAGE_SIZE / 8 || alg->chunksize > PAGE_SIZE / 8 ||
alg              1032 crypto/skcipher.c 	    alg->walksize > PAGE_SIZE / 8)
alg              1035 crypto/skcipher.c 	if (!alg->chunksize)
alg              1036 crypto/skcipher.c 		alg->chunksize = base->cra_blocksize;
alg              1037 crypto/skcipher.c 	if (!alg->walksize)
alg              1038 crypto/skcipher.c 		alg->walksize = alg->chunksize;
alg              1047 crypto/skcipher.c int crypto_register_skcipher(struct skcipher_alg *alg)
alg              1049 crypto/skcipher.c 	struct crypto_alg *base = &alg->base;
alg              1052 crypto/skcipher.c 	err = skcipher_prepare_alg(alg);
alg              1060 crypto/skcipher.c void crypto_unregister_skcipher(struct skcipher_alg *alg)
alg              1062 crypto/skcipher.c 	crypto_unregister_alg(&alg->base);
alg              1100 crypto/skcipher.c 	err = skcipher_prepare_alg(&inst->alg);
alg              1215 crypto/skcipher.c 	inst->alg.base.cra_blocksize = cipher_alg->cra_blocksize;
alg              1216 crypto/skcipher.c 	inst->alg.base.cra_alignmask = cipher_alg->cra_alignmask;
alg              1217 crypto/skcipher.c 	inst->alg.base.cra_priority = cipher_alg->cra_priority;
alg              1218 crypto/skcipher.c 	inst->alg.min_keysize = cipher_alg->cra_cipher.cia_min_keysize;
alg              1219 crypto/skcipher.c 	inst->alg.max_keysize = cipher_alg->cra_cipher.cia_max_keysize;
alg              1220 crypto/skcipher.c 	inst->alg.ivsize = cipher_alg->cra_blocksize;
alg              1223 crypto/skcipher.c 	inst->alg.base.cra_ctxsize = sizeof(struct skcipher_ctx_simple);
alg              1224 crypto/skcipher.c 	inst->alg.setkey = skcipher_setkey_simple;
alg              1225 crypto/skcipher.c 	inst->alg.init = skcipher_init_tfm_simple;
alg              1226 crypto/skcipher.c 	inst->alg.exit = skcipher_exit_tfm_simple;
alg                61 crypto/tcrypt.c static char *alg = NULL;
alg              1647 crypto/tcrypt.c static inline int tcrypt_test(const char *alg)
alg              1651 crypto/tcrypt.c 	pr_debug("testing %s\n", alg);
alg              1653 crypto/tcrypt.c 	ret = alg_test(alg, alg, 0, 0);
alg              1660 crypto/tcrypt.c static int do_test(const char *alg, u32 type, u32 mask, int m, u32 num_mb)
alg              1667 crypto/tcrypt.c 		if (alg) {
alg              1668 crypto/tcrypt.c 			if (!crypto_has_alg(alg, type,
alg              2347 crypto/tcrypt.c 		if (alg) {
alg              2348 crypto/tcrypt.c 			test_hash_speed(alg, sec, generic_hash_speed_template);
alg              2470 crypto/tcrypt.c 		if (alg) {
alg              2471 crypto/tcrypt.c 			test_ahash_speed(alg, sec, generic_hash_speed_template);
alg              3035 crypto/tcrypt.c 	err = do_test(alg, type, mask, mode, num_mb);
alg              3070 crypto/tcrypt.c module_param(alg, charp, 0);
alg                62 crypto/testmgr.c int alg_test(const char *driver, const char *alg, u32 type, u32 mask)
alg               125 crypto/testmgr.c 	const char *alg;
alg              1816 crypto/testmgr.c 			       "unkeyed ones must come first\n", desc->alg);
alg              3474 crypto/testmgr.c 		       const char *alg)
alg              3515 crypto/testmgr.c 		       alg, err);
alg              3531 crypto/testmgr.c 			       alg);
alg              3553 crypto/testmgr.c 		       alg, err);
alg              3584 crypto/testmgr.c 			       alg, err);
alg              3600 crypto/testmgr.c 		       alg);
alg              3615 crypto/testmgr.c static int test_kpp(struct crypto_kpp *tfm, const char *alg,
alg              3621 crypto/testmgr.c 		ret = do_test_kpp(tfm, vecs++, alg);
alg              3624 crypto/testmgr.c 			       alg, i + 1, ret);
alg              3644 crypto/testmgr.c 		err = test_kpp(tfm, desc->alg, desc->suite.kpp.vecs,
alg              3831 crypto/testmgr.c static int test_akcipher(struct crypto_akcipher *tfm, const char *alg,
alg              3864 crypto/testmgr.c 		err = test_akcipher(tfm, desc->alg, desc->suite.akcipher.vecs,
alg              3882 crypto/testmgr.c 		.alg = "adiantum(xchacha12,aes)",
alg              3889 crypto/testmgr.c 		.alg = "adiantum(xchacha20,aes)",
alg              3896 crypto/testmgr.c 		.alg = "aegis128",
alg              3902 crypto/testmgr.c 		.alg = "ansi_cprng",
alg              3908 crypto/testmgr.c 		.alg = "authenc(hmac(md5),ecb(cipher_null))",
alg              3914 crypto/testmgr.c 		.alg = "authenc(hmac(sha1),cbc(aes))",
alg              3921 crypto/testmgr.c 		.alg = "authenc(hmac(sha1),cbc(des))",
alg              3927 crypto/testmgr.c 		.alg = "authenc(hmac(sha1),cbc(des3_ede))",
alg              3934 crypto/testmgr.c 		.alg = "authenc(hmac(sha1),ctr(aes))",
alg              3938 crypto/testmgr.c 		.alg = "authenc(hmac(sha1),ecb(cipher_null))",
alg              3944 crypto/testmgr.c 		.alg = "authenc(hmac(sha1),rfc3686(ctr(aes)))",
alg              3948 crypto/testmgr.c 		.alg = "authenc(hmac(sha224),cbc(des))",
alg              3954 crypto/testmgr.c 		.alg = "authenc(hmac(sha224),cbc(des3_ede))",
alg              3961 crypto/testmgr.c 		.alg = "authenc(hmac(sha256),cbc(aes))",
alg              3968 crypto/testmgr.c 		.alg = "authenc(hmac(sha256),cbc(des))",
alg              3974 crypto/testmgr.c 		.alg = "authenc(hmac(sha256),cbc(des3_ede))",
alg              3981 crypto/testmgr.c 		.alg = "authenc(hmac(sha256),ctr(aes))",
alg              3985 crypto/testmgr.c 		.alg = "authenc(hmac(sha256),rfc3686(ctr(aes)))",
alg              3989 crypto/testmgr.c 		.alg = "authenc(hmac(sha384),cbc(des))",
alg              3995 crypto/testmgr.c 		.alg = "authenc(hmac(sha384),cbc(des3_ede))",
alg              4002 crypto/testmgr.c 		.alg = "authenc(hmac(sha384),ctr(aes))",
alg              4006 crypto/testmgr.c 		.alg = "authenc(hmac(sha384),rfc3686(ctr(aes)))",
alg              4010 crypto/testmgr.c 		.alg = "authenc(hmac(sha512),cbc(aes))",
alg              4017 crypto/testmgr.c 		.alg = "authenc(hmac(sha512),cbc(des))",
alg              4023 crypto/testmgr.c 		.alg = "authenc(hmac(sha512),cbc(des3_ede))",
alg              4030 crypto/testmgr.c 		.alg = "authenc(hmac(sha512),ctr(aes))",
alg              4034 crypto/testmgr.c 		.alg = "authenc(hmac(sha512),rfc3686(ctr(aes)))",
alg              4038 crypto/testmgr.c 		.alg = "cbc(aes)",
alg              4045 crypto/testmgr.c 		.alg = "cbc(anubis)",
alg              4051 crypto/testmgr.c 		.alg = "cbc(blowfish)",
alg              4057 crypto/testmgr.c 		.alg = "cbc(camellia)",
alg              4063 crypto/testmgr.c 		.alg = "cbc(cast5)",
alg              4069 crypto/testmgr.c 		.alg = "cbc(cast6)",
alg              4075 crypto/testmgr.c 		.alg = "cbc(des)",
alg              4081 crypto/testmgr.c 		.alg = "cbc(des3_ede)",
alg              4091 crypto/testmgr.c 		.alg = "cbc(paes)",
alg              4098 crypto/testmgr.c 		.alg = "cbc(psm4)",
alg              4101 crypto/testmgr.c 		.alg = "cbc(serpent)",
alg              4107 crypto/testmgr.c 		.alg = "cbc(sm4)",
alg              4113 crypto/testmgr.c 		.alg = "cbc(twofish)",
alg              4119 crypto/testmgr.c 		.alg = "cbcmac(aes)",
alg              4126 crypto/testmgr.c 		.alg = "ccm(aes)",
alg              4134 crypto/testmgr.c 		.alg = "cfb(aes)",
alg              4141 crypto/testmgr.c 		.alg = "chacha20",
alg              4147 crypto/testmgr.c 		.alg = "cmac(aes)",
alg              4154 crypto/testmgr.c 		.alg = "cmac(des3_ede)",
alg              4161 crypto/testmgr.c 		.alg = "compress_null",
alg              4164 crypto/testmgr.c 		.alg = "crc32",
alg              4171 crypto/testmgr.c 		.alg = "crc32c",
alg              4178 crypto/testmgr.c 		.alg = "crct10dif",
alg              4185 crypto/testmgr.c 		.alg = "ctr(aes)",
alg              4192 crypto/testmgr.c 		.alg = "ctr(blowfish)",
alg              4198 crypto/testmgr.c 		.alg = "ctr(camellia)",
alg              4204 crypto/testmgr.c 		.alg = "ctr(cast5)",
alg              4210 crypto/testmgr.c 		.alg = "ctr(cast6)",
alg              4216 crypto/testmgr.c 		.alg = "ctr(des)",
alg              4222 crypto/testmgr.c 		.alg = "ctr(des3_ede)",
alg              4232 crypto/testmgr.c 		.alg = "ctr(paes)",
alg              4240 crypto/testmgr.c 		.alg = "ctr(psm4)",
alg              4243 crypto/testmgr.c 		.alg = "ctr(serpent)",
alg              4249 crypto/testmgr.c 		.alg = "ctr(sm4)",
alg              4255 crypto/testmgr.c 		.alg = "ctr(twofish)",
alg              4261 crypto/testmgr.c 		.alg = "cts(cbc(aes))",
alg              4271 crypto/testmgr.c 		.alg = "cts(cbc(paes))",
alg              4275 crypto/testmgr.c 		.alg = "deflate",
alg              4285 crypto/testmgr.c 		.alg = "dh",
alg              4292 crypto/testmgr.c 		.alg = "digest_null",
alg              4295 crypto/testmgr.c 		.alg = "drbg_nopr_ctr_aes128",
alg              4302 crypto/testmgr.c 		.alg = "drbg_nopr_ctr_aes192",
alg              4309 crypto/testmgr.c 		.alg = "drbg_nopr_ctr_aes256",
alg              4320 crypto/testmgr.c 		.alg = "drbg_nopr_hmac_sha1",
alg              4324 crypto/testmgr.c 		.alg = "drbg_nopr_hmac_sha256",
alg              4332 crypto/testmgr.c 		.alg = "drbg_nopr_hmac_sha384",
alg              4336 crypto/testmgr.c 		.alg = "drbg_nopr_hmac_sha512",
alg              4340 crypto/testmgr.c 		.alg = "drbg_nopr_sha1",
alg              4344 crypto/testmgr.c 		.alg = "drbg_nopr_sha256",
alg              4352 crypto/testmgr.c 		.alg = "drbg_nopr_sha384",
alg              4356 crypto/testmgr.c 		.alg = "drbg_nopr_sha512",
alg              4360 crypto/testmgr.c 		.alg = "drbg_pr_ctr_aes128",
alg              4368 crypto/testmgr.c 		.alg = "drbg_pr_ctr_aes192",
alg              4372 crypto/testmgr.c 		.alg = "drbg_pr_ctr_aes256",
alg              4376 crypto/testmgr.c 		.alg = "drbg_pr_hmac_sha1",
alg              4380 crypto/testmgr.c 		.alg = "drbg_pr_hmac_sha256",
alg              4388 crypto/testmgr.c 		.alg = "drbg_pr_hmac_sha384",
alg              4392 crypto/testmgr.c 		.alg = "drbg_pr_hmac_sha512",
alg              4396 crypto/testmgr.c 		.alg = "drbg_pr_sha1",
alg              4400 crypto/testmgr.c 		.alg = "drbg_pr_sha256",
alg              4408 crypto/testmgr.c 		.alg = "drbg_pr_sha384",
alg              4412 crypto/testmgr.c 		.alg = "drbg_pr_sha512",
alg              4416 crypto/testmgr.c 		.alg = "ecb(aes)",
alg              4423 crypto/testmgr.c 		.alg = "ecb(anubis)",
alg              4429 crypto/testmgr.c 		.alg = "ecb(arc4)",
alg              4436 crypto/testmgr.c 		.alg = "ecb(blowfish)",
alg              4442 crypto/testmgr.c 		.alg = "ecb(camellia)",
alg              4448 crypto/testmgr.c 		.alg = "ecb(cast5)",
alg              4454 crypto/testmgr.c 		.alg = "ecb(cast6)",
alg              4460 crypto/testmgr.c 		.alg = "ecb(cipher_null)",
alg              4464 crypto/testmgr.c 		.alg = "ecb(des)",
alg              4470 crypto/testmgr.c 		.alg = "ecb(des3_ede)",
alg              4477 crypto/testmgr.c 		.alg = "ecb(fcrypt)",
alg              4486 crypto/testmgr.c 		.alg = "ecb(khazad)",
alg              4495 crypto/testmgr.c 		.alg = "ecb(paes)",
alg              4499 crypto/testmgr.c 		.alg = "ecb(seed)",
alg              4505 crypto/testmgr.c 		.alg = "ecb(serpent)",
alg              4511 crypto/testmgr.c 		.alg = "ecb(sm4)",
alg              4517 crypto/testmgr.c 		.alg = "ecb(tea)",
alg              4523 crypto/testmgr.c 		.alg = "ecb(tnepres)",
alg              4529 crypto/testmgr.c 		.alg = "ecb(twofish)",
alg              4535 crypto/testmgr.c 		.alg = "ecb(xeta)",
alg              4541 crypto/testmgr.c 		.alg = "ecb(xtea)",
alg              4547 crypto/testmgr.c 		.alg = "ecdh",
alg              4554 crypto/testmgr.c 		.alg = "ecrdsa",
alg              4560 crypto/testmgr.c 		.alg = "essiv(authenc(hmac(sha256),cbc(aes)),sha256)",
alg              4567 crypto/testmgr.c 		.alg = "essiv(cbc(aes),sha256)",
alg              4574 crypto/testmgr.c 		.alg = "gcm(aes)",
alg              4582 crypto/testmgr.c 		.alg = "ghash",
alg              4589 crypto/testmgr.c 		.alg = "hmac(md5)",
alg              4595 crypto/testmgr.c 		.alg = "hmac(rmd128)",
alg              4601 crypto/testmgr.c 		.alg = "hmac(rmd160)",
alg              4607 crypto/testmgr.c 		.alg = "hmac(sha1)",
alg              4614 crypto/testmgr.c 		.alg = "hmac(sha224)",
alg              4621 crypto/testmgr.c 		.alg = "hmac(sha256)",
alg              4628 crypto/testmgr.c 		.alg = "hmac(sha3-224)",
alg              4635 crypto/testmgr.c 		.alg = "hmac(sha3-256)",
alg              4642 crypto/testmgr.c 		.alg = "hmac(sha3-384)",
alg              4649 crypto/testmgr.c 		.alg = "hmac(sha3-512)",
alg              4656 crypto/testmgr.c 		.alg = "hmac(sha384)",
alg              4663 crypto/testmgr.c 		.alg = "hmac(sha512)",
alg              4670 crypto/testmgr.c 		.alg = "hmac(streebog256)",
alg              4676 crypto/testmgr.c 		.alg = "hmac(streebog512)",
alg              4682 crypto/testmgr.c 		.alg = "jitterentropy_rng",
alg              4686 crypto/testmgr.c 		.alg = "kw(aes)",
alg              4693 crypto/testmgr.c 		.alg = "lrw(aes)",
alg              4700 crypto/testmgr.c 		.alg = "lrw(camellia)",
alg              4707 crypto/testmgr.c 		.alg = "lrw(cast6)",
alg              4714 crypto/testmgr.c 		.alg = "lrw(serpent)",
alg              4721 crypto/testmgr.c 		.alg = "lrw(twofish)",
alg              4728 crypto/testmgr.c 		.alg = "lz4",
alg              4738 crypto/testmgr.c 		.alg = "lz4hc",
alg              4748 crypto/testmgr.c 		.alg = "lzo",
alg              4758 crypto/testmgr.c 		.alg = "lzo-rle",
alg              4768 crypto/testmgr.c 		.alg = "md4",
alg              4774 crypto/testmgr.c 		.alg = "md5",
alg              4780 crypto/testmgr.c 		.alg = "michael_mic",
alg              4786 crypto/testmgr.c 		.alg = "nhpoly1305",
alg              4792 crypto/testmgr.c 		.alg = "ofb(aes)",
alg              4802 crypto/testmgr.c 		.alg = "ofb(paes)",
alg              4806 crypto/testmgr.c 		.alg = "pcbc(fcrypt)",
alg              4812 crypto/testmgr.c 		.alg = "pkcs1pad(rsa,sha224)",
alg              4816 crypto/testmgr.c 		.alg = "pkcs1pad(rsa,sha256)",
alg              4823 crypto/testmgr.c 		.alg = "pkcs1pad(rsa,sha384)",
alg              4827 crypto/testmgr.c 		.alg = "pkcs1pad(rsa,sha512)",
alg              4831 crypto/testmgr.c 		.alg = "poly1305",
alg              4837 crypto/testmgr.c 		.alg = "rfc3686(ctr(aes))",
alg              4844 crypto/testmgr.c 		.alg = "rfc4106(gcm(aes))",
alg              4852 crypto/testmgr.c 		.alg = "rfc4309(ccm(aes))",
alg              4860 crypto/testmgr.c 		.alg = "rfc4543(gcm(aes))",
alg              4867 crypto/testmgr.c 		.alg = "rfc7539(chacha20,poly1305)",
alg              4873 crypto/testmgr.c 		.alg = "rfc7539esp(chacha20,poly1305)",
alg              4879 crypto/testmgr.c 		.alg = "rmd128",
alg              4885 crypto/testmgr.c 		.alg = "rmd160",
alg              4891 crypto/testmgr.c 		.alg = "rmd256",
alg              4897 crypto/testmgr.c 		.alg = "rmd320",
alg              4903 crypto/testmgr.c 		.alg = "rsa",
alg              4910 crypto/testmgr.c 		.alg = "salsa20",
alg              4916 crypto/testmgr.c 		.alg = "sha1",
alg              4923 crypto/testmgr.c 		.alg = "sha224",
alg              4930 crypto/testmgr.c 		.alg = "sha256",
alg              4937 crypto/testmgr.c 		.alg = "sha3-224",
alg              4944 crypto/testmgr.c 		.alg = "sha3-256",
alg              4951 crypto/testmgr.c 		.alg = "sha3-384",
alg              4958 crypto/testmgr.c 		.alg = "sha3-512",
alg              4965 crypto/testmgr.c 		.alg = "sha384",
alg              4972 crypto/testmgr.c 		.alg = "sha512",
alg              4979 crypto/testmgr.c 		.alg = "sm3",
alg              4985 crypto/testmgr.c 		.alg = "streebog256",
alg              4991 crypto/testmgr.c 		.alg = "streebog512",
alg              4997 crypto/testmgr.c 		.alg = "tgr128",
alg              5003 crypto/testmgr.c 		.alg = "tgr160",
alg              5009 crypto/testmgr.c 		.alg = "tgr192",
alg              5015 crypto/testmgr.c 		.alg = "vmac64(aes)",
alg              5021 crypto/testmgr.c 		.alg = "wp256",
alg              5027 crypto/testmgr.c 		.alg = "wp384",
alg              5033 crypto/testmgr.c 		.alg = "wp512",
alg              5039 crypto/testmgr.c 		.alg = "xcbc(aes)",
alg              5045 crypto/testmgr.c 		.alg = "xchacha12",
alg              5051 crypto/testmgr.c 		.alg = "xchacha20",
alg              5057 crypto/testmgr.c 		.alg = "xts(aes)",
alg              5065 crypto/testmgr.c 		.alg = "xts(camellia)",
alg              5072 crypto/testmgr.c 		.alg = "xts(cast6)",
alg              5082 crypto/testmgr.c 		.alg = "xts(paes)",
alg              5086 crypto/testmgr.c 		.alg = "xts(serpent)",
alg              5093 crypto/testmgr.c 		.alg = "xts(twofish)",
alg              5100 crypto/testmgr.c 		.alg = "xts4096(paes)",
alg              5104 crypto/testmgr.c 		.alg = "xts512(paes)",
alg              5108 crypto/testmgr.c 		.alg = "xxhash64",
alg              5115 crypto/testmgr.c 		.alg = "zlib-deflate",
alg              5125 crypto/testmgr.c 		.alg = "zstd",
alg              5142 crypto/testmgr.c 		int diff = strcmp(alg_test_descs[i - 1].alg,
alg              5143 crypto/testmgr.c 				  alg_test_descs[i].alg);
alg              5147 crypto/testmgr.c 				alg_test_descs[i - 1].alg,
alg              5148 crypto/testmgr.c 				alg_test_descs[i].alg);
alg              5153 crypto/testmgr.c 				alg_test_descs[i].alg);
alg              5181 crypto/testmgr.c static int alg_find_test(const char *alg)
alg              5188 crypto/testmgr.c 		int diff = strcmp(alg_test_descs[i].alg, alg);
alg              5206 crypto/testmgr.c int alg_test(const char *driver, const char *alg, u32 type, u32 mask)
alg              5222 crypto/testmgr.c 		if (snprintf(nalg, sizeof(nalg), "ecb(%s)", alg) >=
alg              5237 crypto/testmgr.c 	i = alg_find_test(alg);
alg              5258 crypto/testmgr.c 		      driver, alg, fips_enabled ? "fips" : "panic_on_fail");
alg              5262 crypto/testmgr.c 		pr_info("alg: self-tests for %s (%s) passed\n", driver, alg);
alg              5267 crypto/testmgr.c 	printk(KERN_INFO "alg: No test for %s (%s)\n", alg, driver);
alg               168 crypto/twofish_generic.c static struct crypto_alg alg = {
alg               187 crypto/twofish_generic.c 	return crypto_register_alg(&alg);
alg               192 crypto/twofish_generic.c 	crypto_unregister_alg(&alg);
alg               623 crypto/vmac.c  	struct crypto_alg *alg;
alg               630 crypto/vmac.c  	alg = crypto_get_attr_alg(tb, CRYPTO_ALG_TYPE_CIPHER,
alg               632 crypto/vmac.c  	if (IS_ERR(alg))
alg               633 crypto/vmac.c  		return PTR_ERR(alg);
alg               636 crypto/vmac.c  	if (alg->cra_blocksize != VMAC_NONCEBYTES)
alg               639 crypto/vmac.c  	inst = shash_alloc_instance(tmpl->name, alg);
alg               644 crypto/vmac.c  	err = crypto_init_spawn(shash_instance_ctx(inst), alg,
alg               650 crypto/vmac.c  	inst->alg.base.cra_priority = alg->cra_priority;
alg               651 crypto/vmac.c  	inst->alg.base.cra_blocksize = alg->cra_blocksize;
alg               652 crypto/vmac.c  	inst->alg.base.cra_alignmask = alg->cra_alignmask;
alg               654 crypto/vmac.c  	inst->alg.base.cra_ctxsize = sizeof(struct vmac_tfm_ctx);
alg               655 crypto/vmac.c  	inst->alg.base.cra_init = vmac_init_tfm;
alg               656 crypto/vmac.c  	inst->alg.base.cra_exit = vmac_exit_tfm;
alg               658 crypto/vmac.c  	inst->alg.descsize = sizeof(struct vmac_desc_ctx);
alg               659 crypto/vmac.c  	inst->alg.digestsize = VMAC_TAG_LEN / 8;
alg               660 crypto/vmac.c  	inst->alg.init = vmac_init;
alg               661 crypto/vmac.c  	inst->alg.update = vmac_update;
alg               662 crypto/vmac.c  	inst->alg.final = vmac_final;
alg               663 crypto/vmac.c  	inst->alg.setkey = vmac_setkey;
alg               672 crypto/vmac.c  	crypto_mod_put(alg);
alg               191 crypto/xcbc.c  	struct crypto_alg *alg;
alg               199 crypto/xcbc.c  	alg = crypto_get_attr_alg(tb, CRYPTO_ALG_TYPE_CIPHER,
alg               201 crypto/xcbc.c  	if (IS_ERR(alg))
alg               202 crypto/xcbc.c  		return PTR_ERR(alg);
alg               204 crypto/xcbc.c  	switch(alg->cra_blocksize) {
alg               211 crypto/xcbc.c  	inst = shash_alloc_instance("xcbc", alg);
alg               216 crypto/xcbc.c  	err = crypto_init_spawn(shash_instance_ctx(inst), alg,
alg               222 crypto/xcbc.c  	alignmask = alg->cra_alignmask | 3;
alg               223 crypto/xcbc.c  	inst->alg.base.cra_alignmask = alignmask;
alg               224 crypto/xcbc.c  	inst->alg.base.cra_priority = alg->cra_priority;
alg               225 crypto/xcbc.c  	inst->alg.base.cra_blocksize = alg->cra_blocksize;
alg               227 crypto/xcbc.c  	inst->alg.digestsize = alg->cra_blocksize;
alg               228 crypto/xcbc.c  	inst->alg.descsize = ALIGN(sizeof(struct xcbc_desc_ctx),
alg               232 crypto/xcbc.c  			     alg->cra_blocksize * 2;
alg               234 crypto/xcbc.c  	inst->alg.base.cra_ctxsize = ALIGN(sizeof(struct xcbc_tfm_ctx),
alg               236 crypto/xcbc.c  				     alg->cra_blocksize * 2;
alg               237 crypto/xcbc.c  	inst->alg.base.cra_init = xcbc_init_tfm;
alg               238 crypto/xcbc.c  	inst->alg.base.cra_exit = xcbc_exit_tfm;
alg               240 crypto/xcbc.c  	inst->alg.init = crypto_xcbc_digest_init;
alg               241 crypto/xcbc.c  	inst->alg.update = crypto_xcbc_digest_update;
alg               242 crypto/xcbc.c  	inst->alg.final = crypto_xcbc_digest_final;
alg               243 crypto/xcbc.c  	inst->alg.setkey = crypto_xcbc_digest_setkey;
alg               252 crypto/xcbc.c  	crypto_mod_put(alg);
alg               342 crypto/xts.c   	struct skcipher_alg *alg;
alg               383 crypto/xts.c   	alg = crypto_skcipher_spawn_alg(&ctx->spawn);
alg               386 crypto/xts.c   	if (alg->base.cra_blocksize != XTS_BLOCK_SIZE)
alg               389 crypto/xts.c   	if (crypto_skcipher_alg_ivsize(alg))
alg               393 crypto/xts.c   				  &alg->base);
alg               398 crypto/xts.c   	cipher_name = alg->base.cra_name;
alg               415 crypto/xts.c   		if (snprintf(inst->alg.base.cra_name, CRYPTO_MAX_ALG_NAME,
alg               423 crypto/xts.c   	inst->alg.base.cra_flags = alg->base.cra_flags & CRYPTO_ALG_ASYNC;
alg               424 crypto/xts.c   	inst->alg.base.cra_priority = alg->base.cra_priority;
alg               425 crypto/xts.c   	inst->alg.base.cra_blocksize = XTS_BLOCK_SIZE;
alg               426 crypto/xts.c   	inst->alg.base.cra_alignmask = alg->base.cra_alignmask |
alg               429 crypto/xts.c   	inst->alg.ivsize = XTS_BLOCK_SIZE;
alg               430 crypto/xts.c   	inst->alg.min_keysize = crypto_skcipher_alg_min_keysize(alg) * 2;
alg               431 crypto/xts.c   	inst->alg.max_keysize = crypto_skcipher_alg_max_keysize(alg) * 2;
alg               433 crypto/xts.c   	inst->alg.base.cra_ctxsize = sizeof(struct priv);
alg               435 crypto/xts.c   	inst->alg.init = init_tfm;
alg               436 crypto/xts.c   	inst->alg.exit = exit_tfm;
alg               438 crypto/xts.c   	inst->alg.setkey = setkey;
alg               439 crypto/xts.c   	inst->alg.encrypt = encrypt;
alg               440 crypto/xts.c   	inst->alg.decrypt = decrypt;
alg                72 crypto/xxhash_generic.c static struct shash_alg alg = {
alg                93 crypto/xxhash_generic.c 	return crypto_register_shash(&alg);
alg                98 crypto/xxhash_generic.c 	crypto_unregister_shash(&alg);
alg               207 crypto/zstd.c  static struct crypto_alg alg = {
alg               236 crypto/zstd.c  	ret = crypto_register_alg(&alg);
alg               242 crypto/zstd.c  		crypto_unregister_alg(&alg);
alg               249 crypto/zstd.c  	crypto_unregister_alg(&alg);
alg              3824 drivers/block/drbd/drbd_receiver.c 		const char *alg, const char *name)
alg              3828 drivers/block/drbd/drbd_receiver.c 	if (!alg[0])
alg              3831 drivers/block/drbd/drbd_receiver.c 	tfm = crypto_alloc_shash(alg, 0, 0);
alg              3834 drivers/block/drbd/drbd_receiver.c 			alg, name, PTR_ERR(tfm));
alg               649 drivers/crypto/amcc/crypto4xx_alg.c 	struct crypto_alg *alg = tfm->__crt_alg;
alg               655 drivers/crypto/amcc/crypto4xx_alg.c 	my_alg = container_of(__crypto_ahash_alg(alg), struct crypto4xx_alg,
alg               656 drivers/crypto/amcc/crypto4xx_alg.c 			      alg.u.hash);
alg               946 drivers/crypto/amcc/crypto4xx_core.c 	struct skcipher_alg *alg = crypto_skcipher_alg(sk);
alg               950 drivers/crypto/amcc/crypto4xx_core.c 	if (alg->base.cra_flags & CRYPTO_ALG_NEED_FALLBACK) {
alg               952 drivers/crypto/amcc/crypto4xx_core.c 			crypto_alloc_sync_skcipher(alg->base.cra_name, 0,
alg               958 drivers/crypto/amcc/crypto4xx_core.c 	amcc_alg = container_of(alg, struct crypto4xx_alg, alg.u.cipher);
alg               979 drivers/crypto/amcc/crypto4xx_core.c 	struct aead_alg *alg = crypto_aead_alg(tfm);
alg               983 drivers/crypto/amcc/crypto4xx_core.c 	ctx->sw_cipher.aead = crypto_alloc_aead(alg->base.cra_name, 0,
alg               989 drivers/crypto/amcc/crypto4xx_core.c 	amcc_alg = container_of(alg, struct crypto4xx_alg, alg.u.aead);
alg              1009 drivers/crypto/amcc/crypto4xx_core.c 	struct crypto4xx_alg *alg;
alg              1014 drivers/crypto/amcc/crypto4xx_core.c 		alg = kzalloc(sizeof(struct crypto4xx_alg), GFP_KERNEL);
alg              1015 drivers/crypto/amcc/crypto4xx_core.c 		if (!alg)
alg              1018 drivers/crypto/amcc/crypto4xx_core.c 		alg->alg = crypto_alg[i];
alg              1019 drivers/crypto/amcc/crypto4xx_core.c 		alg->dev = sec_dev;
alg              1021 drivers/crypto/amcc/crypto4xx_core.c 		switch (alg->alg.type) {
alg              1023 drivers/crypto/amcc/crypto4xx_core.c 			rc = crypto_register_aead(&alg->alg.u.aead);
alg              1027 drivers/crypto/amcc/crypto4xx_core.c 			rc = crypto_register_ahash(&alg->alg.u.hash);
alg              1031 drivers/crypto/amcc/crypto4xx_core.c 			rc = crypto_register_rng(&alg->alg.u.rng);
alg              1035 drivers/crypto/amcc/crypto4xx_core.c 			rc = crypto_register_skcipher(&alg->alg.u.cipher);
alg              1040 drivers/crypto/amcc/crypto4xx_core.c 			kfree(alg);
alg              1042 drivers/crypto/amcc/crypto4xx_core.c 			list_add_tail(&alg->entry, &sec_dev->alg_list);
alg              1050 drivers/crypto/amcc/crypto4xx_core.c 	struct crypto4xx_alg *alg, *tmp;
alg              1052 drivers/crypto/amcc/crypto4xx_core.c 	list_for_each_entry_safe(alg, tmp, &sec_dev->alg_list, entry) {
alg              1053 drivers/crypto/amcc/crypto4xx_core.c 		list_del(&alg->entry);
alg              1054 drivers/crypto/amcc/crypto4xx_core.c 		switch (alg->alg.type) {
alg              1056 drivers/crypto/amcc/crypto4xx_core.c 			crypto_unregister_ahash(&alg->alg.u.hash);
alg              1060 drivers/crypto/amcc/crypto4xx_core.c 			crypto_unregister_aead(&alg->alg.u.aead);
alg              1064 drivers/crypto/amcc/crypto4xx_core.c 			crypto_unregister_rng(&alg->alg.u.rng);
alg              1068 drivers/crypto/amcc/crypto4xx_core.c 			crypto_unregister_skcipher(&alg->alg.u.cipher);
alg              1070 drivers/crypto/amcc/crypto4xx_core.c 		kfree(alg);
alg              1167 drivers/crypto/amcc/crypto4xx_core.c 	struct rng_alg *alg = crypto_rng_alg(tfm);
alg              1172 drivers/crypto/amcc/crypto4xx_core.c 	amcc_alg = container_of(alg, struct crypto4xx_alg, alg.u.rng);
alg               145 drivers/crypto/amcc/crypto4xx_core.h 	struct crypto4xx_alg_common alg;
alg               262 drivers/crypto/atmel-ecc.c 	const char *alg = kpp_alg_name(tfm);
alg               272 drivers/crypto/atmel-ecc.c 	fallback = crypto_alloc_kpp(alg, 0, CRYPTO_ALG_NEED_FALLBACK);
alg               275 drivers/crypto/atmel-ecc.c 			alg, PTR_ERR(fallback));
alg               168 drivers/crypto/bcm/cipher.c 	if (ctx->cipher.alg == CIPHER_ALG_RC4)
alg               329 drivers/crypto/bcm/cipher.c 	cipher_parms.alg = ctx->cipher.alg;
alg               394 drivers/crypto/bcm/cipher.c 	if (ctx->cipher.alg == CIPHER_ALG_RC4) {
alg               446 drivers/crypto/bcm/cipher.c 				     0, ctx->auth.alg, ctx->auth.mode,
alg               530 drivers/crypto/bcm/cipher.c 	if (ctx->cipher.alg == CIPHER_ALG_RC4)
alg               538 drivers/crypto/bcm/cipher.c 		   &iproc_priv.cipher_cnt[ctx->cipher.alg][ctx->cipher.mode]);
alg               740 drivers/crypto/bcm/cipher.c 	hash_parms.alg = ctx->auth.alg;
alg               809 drivers/crypto/bcm/cipher.c 	if (hash_parms.alg == HASH_ALG_AES)
alg               814 drivers/crypto/bcm/cipher.c 	digestsize = spu->spu_digest_size(ctx->digestsize, ctx->auth.alg,
alg               824 drivers/crypto/bcm/cipher.c 		hash_parms.pad_len = spu->spu_hash_pad_len(hash_parms.alg,
alg               834 drivers/crypto/bcm/cipher.c 	    (hash_parms.alg != HASH_ALG_AES)) {
alg               881 drivers/crypto/bcm/cipher.c 				     hash_parms.pad_len, ctx->auth.alg,
alg               941 drivers/crypto/bcm/cipher.c 	switch (ctx->auth.alg) {
alg               994 drivers/crypto/bcm/cipher.c 		if (ctx->auth.alg == HASH_ALG_MD5) {
alg              1015 drivers/crypto/bcm/cipher.c 		atomic_inc(&iproc_priv.hmac_cnt[ctx->auth.alg]);
alg              1018 drivers/crypto/bcm/cipher.c 		atomic_inc(&iproc_priv.hash_cnt[ctx->auth.alg]);
alg              1338 drivers/crypto/bcm/cipher.c 	cipher_parms.alg = ctx->cipher.alg;
alg              1346 drivers/crypto/bcm/cipher.c 	hash_parms.alg = ctx->auth.alg;
alg              1353 drivers/crypto/bcm/cipher.c 	if ((ctx->auth.alg == HASH_ALG_SHA224) &&
alg              1400 drivers/crypto/bcm/cipher.c 	if (ctx->auth.alg == HASH_ALG_AES)
alg              1489 drivers/crypto/bcm/cipher.c 				     ctx->auth.alg, ctx->auth.mode,
alg              1607 drivers/crypto/bcm/cipher.c 	if (ctx->cipher.alg == CIPHER_ALG_AES) {
alg              1687 drivers/crypto/bcm/cipher.c 	switch (rctx->ctx->alg->type) {
alg              1710 drivers/crypto/bcm/cipher.c 		switch (rctx->ctx->alg->type) {
alg              1889 drivers/crypto/bcm/cipher.c 	switch (ctx->cipher.alg) {
alg              1910 drivers/crypto/bcm/cipher.c 	if (ctx->cipher.alg != CIPHER_ALG_RC4) {
alg              1915 drivers/crypto/bcm/cipher.c 	if ((ctx->cipher.alg == CIPHER_ALG_AES) &&
alg              1932 drivers/crypto/bcm/cipher.c 	cipher_parms.alg = ctx->cipher.alg;
alg              2072 drivers/crypto/bcm/cipher.c 	if ((ctx->auth.alg == HASH_ALG_AES) &&
alg              2324 drivers/crypto/bcm/cipher.c 	if (ctx->auth.alg == HASH_ALG_AES) {
alg              2394 drivers/crypto/bcm/cipher.c 		switch (ctx->auth.alg) {
alg              2441 drivers/crypto/bcm/cipher.c 			       __func__, rc, hash_alg_name[ctx->auth.alg]);
alg              2616 drivers/crypto/bcm/cipher.c 	    ctx->cipher.alg == CIPHER_ALG_AES &&
alg              2848 drivers/crypto/bcm/cipher.c 	switch (ctx->alg->cipher_info.alg) {
alg              3129 drivers/crypto/bcm/cipher.c 	 .alg.aead = {
alg              3141 drivers/crypto/bcm/cipher.c 			 .alg = CIPHER_ALG_AES,
alg              3145 drivers/crypto/bcm/cipher.c 		       .alg = HASH_ALG_AES,
alg              3152 drivers/crypto/bcm/cipher.c 	 .alg.aead = {
alg              3164 drivers/crypto/bcm/cipher.c 			 .alg = CIPHER_ALG_AES,
alg              3168 drivers/crypto/bcm/cipher.c 		       .alg = HASH_ALG_AES,
alg              3175 drivers/crypto/bcm/cipher.c 	 .alg.aead = {
alg              3187 drivers/crypto/bcm/cipher.c 			 .alg = CIPHER_ALG_AES,
alg              3191 drivers/crypto/bcm/cipher.c 		       .alg = HASH_ALG_AES,
alg              3198 drivers/crypto/bcm/cipher.c 	 .alg.aead = {
alg              3210 drivers/crypto/bcm/cipher.c 			 .alg = CIPHER_ALG_AES,
alg              3214 drivers/crypto/bcm/cipher.c 		       .alg = HASH_ALG_AES,
alg              3221 drivers/crypto/bcm/cipher.c 	 .alg.aead = {
alg              3233 drivers/crypto/bcm/cipher.c 			 .alg = CIPHER_ALG_AES,
alg              3237 drivers/crypto/bcm/cipher.c 		       .alg = HASH_ALG_AES,
alg              3244 drivers/crypto/bcm/cipher.c 	 .alg.aead = {
alg              3256 drivers/crypto/bcm/cipher.c 			 .alg = CIPHER_ALG_AES,
alg              3260 drivers/crypto/bcm/cipher.c 		       .alg = HASH_ALG_MD5,
alg              3267 drivers/crypto/bcm/cipher.c 	 .alg.aead = {
alg              3279 drivers/crypto/bcm/cipher.c 			 .alg = CIPHER_ALG_AES,
alg              3283 drivers/crypto/bcm/cipher.c 		       .alg = HASH_ALG_SHA1,
alg              3290 drivers/crypto/bcm/cipher.c 	 .alg.aead = {
alg              3302 drivers/crypto/bcm/cipher.c 			 .alg = CIPHER_ALG_AES,
alg              3306 drivers/crypto/bcm/cipher.c 		       .alg = HASH_ALG_SHA256,
alg              3313 drivers/crypto/bcm/cipher.c 	 .alg.aead = {
alg              3325 drivers/crypto/bcm/cipher.c 			 .alg = CIPHER_ALG_DES,
alg              3329 drivers/crypto/bcm/cipher.c 		       .alg = HASH_ALG_MD5,
alg              3336 drivers/crypto/bcm/cipher.c 	 .alg.aead = {
alg              3348 drivers/crypto/bcm/cipher.c 			 .alg = CIPHER_ALG_DES,
alg              3352 drivers/crypto/bcm/cipher.c 		       .alg = HASH_ALG_SHA1,
alg              3359 drivers/crypto/bcm/cipher.c 	 .alg.aead = {
alg              3371 drivers/crypto/bcm/cipher.c 			 .alg = CIPHER_ALG_DES,
alg              3375 drivers/crypto/bcm/cipher.c 		       .alg = HASH_ALG_SHA224,
alg              3382 drivers/crypto/bcm/cipher.c 	 .alg.aead = {
alg              3394 drivers/crypto/bcm/cipher.c 			 .alg = CIPHER_ALG_DES,
alg              3398 drivers/crypto/bcm/cipher.c 		       .alg = HASH_ALG_SHA256,
alg              3405 drivers/crypto/bcm/cipher.c 	 .alg.aead = {
alg              3417 drivers/crypto/bcm/cipher.c 			 .alg = CIPHER_ALG_DES,
alg              3421 drivers/crypto/bcm/cipher.c 		       .alg = HASH_ALG_SHA384,
alg              3428 drivers/crypto/bcm/cipher.c 	 .alg.aead = {
alg              3440 drivers/crypto/bcm/cipher.c 			 .alg = CIPHER_ALG_DES,
alg              3444 drivers/crypto/bcm/cipher.c 		       .alg = HASH_ALG_SHA512,
alg              3451 drivers/crypto/bcm/cipher.c 	 .alg.aead = {
alg              3463 drivers/crypto/bcm/cipher.c 			 .alg = CIPHER_ALG_3DES,
alg              3467 drivers/crypto/bcm/cipher.c 		       .alg = HASH_ALG_MD5,
alg              3474 drivers/crypto/bcm/cipher.c 	 .alg.aead = {
alg              3486 drivers/crypto/bcm/cipher.c 			 .alg = CIPHER_ALG_3DES,
alg              3490 drivers/crypto/bcm/cipher.c 		       .alg = HASH_ALG_SHA1,
alg              3497 drivers/crypto/bcm/cipher.c 	 .alg.aead = {
alg              3509 drivers/crypto/bcm/cipher.c 			 .alg = CIPHER_ALG_3DES,
alg              3513 drivers/crypto/bcm/cipher.c 		       .alg = HASH_ALG_SHA224,
alg              3520 drivers/crypto/bcm/cipher.c 	 .alg.aead = {
alg              3532 drivers/crypto/bcm/cipher.c 			 .alg = CIPHER_ALG_3DES,
alg              3536 drivers/crypto/bcm/cipher.c 		       .alg = HASH_ALG_SHA256,
alg              3543 drivers/crypto/bcm/cipher.c 	 .alg.aead = {
alg              3555 drivers/crypto/bcm/cipher.c 			 .alg = CIPHER_ALG_3DES,
alg              3559 drivers/crypto/bcm/cipher.c 		       .alg = HASH_ALG_SHA384,
alg              3566 drivers/crypto/bcm/cipher.c 	 .alg.aead = {
alg              3578 drivers/crypto/bcm/cipher.c 			 .alg = CIPHER_ALG_3DES,
alg              3582 drivers/crypto/bcm/cipher.c 		       .alg = HASH_ALG_SHA512,
alg              3591 drivers/crypto/bcm/cipher.c 	 .alg.crypto = {
alg              3602 drivers/crypto/bcm/cipher.c 			 .alg = CIPHER_ALG_RC4,
alg              3606 drivers/crypto/bcm/cipher.c 		       .alg = HASH_ALG_NONE,
alg              3612 drivers/crypto/bcm/cipher.c 	 .alg.crypto = {
alg              3623 drivers/crypto/bcm/cipher.c 			 .alg = CIPHER_ALG_DES,
alg              3627 drivers/crypto/bcm/cipher.c 		       .alg = HASH_ALG_NONE,
alg              3633 drivers/crypto/bcm/cipher.c 	 .alg.crypto = {
alg              3644 drivers/crypto/bcm/cipher.c 			 .alg = CIPHER_ALG_DES,
alg              3648 drivers/crypto/bcm/cipher.c 		       .alg = HASH_ALG_NONE,
alg              3654 drivers/crypto/bcm/cipher.c 	 .alg.crypto = {
alg              3665 drivers/crypto/bcm/cipher.c 			 .alg = CIPHER_ALG_DES,
alg              3669 drivers/crypto/bcm/cipher.c 		       .alg = HASH_ALG_NONE,
alg              3675 drivers/crypto/bcm/cipher.c 	 .alg.crypto = {
alg              3686 drivers/crypto/bcm/cipher.c 			 .alg = CIPHER_ALG_3DES,
alg              3690 drivers/crypto/bcm/cipher.c 		       .alg = HASH_ALG_NONE,
alg              3696 drivers/crypto/bcm/cipher.c 	 .alg.crypto = {
alg              3707 drivers/crypto/bcm/cipher.c 			 .alg = CIPHER_ALG_3DES,
alg              3711 drivers/crypto/bcm/cipher.c 		       .alg = HASH_ALG_NONE,
alg              3717 drivers/crypto/bcm/cipher.c 	 .alg.crypto = {
alg              3728 drivers/crypto/bcm/cipher.c 			 .alg = CIPHER_ALG_3DES,
alg              3732 drivers/crypto/bcm/cipher.c 		       .alg = HASH_ALG_NONE,
alg              3738 drivers/crypto/bcm/cipher.c 	 .alg.crypto = {
alg              3749 drivers/crypto/bcm/cipher.c 			 .alg = CIPHER_ALG_AES,
alg              3753 drivers/crypto/bcm/cipher.c 		       .alg = HASH_ALG_NONE,
alg              3759 drivers/crypto/bcm/cipher.c 	 .alg.crypto = {
alg              3770 drivers/crypto/bcm/cipher.c 			 .alg = CIPHER_ALG_AES,
alg              3774 drivers/crypto/bcm/cipher.c 		       .alg = HASH_ALG_NONE,
alg              3780 drivers/crypto/bcm/cipher.c 	 .alg.crypto = {
alg              3791 drivers/crypto/bcm/cipher.c 			 .alg = CIPHER_ALG_AES,
alg              3795 drivers/crypto/bcm/cipher.c 		       .alg = HASH_ALG_NONE,
alg              3801 drivers/crypto/bcm/cipher.c 	 .alg.crypto = {
alg              3812 drivers/crypto/bcm/cipher.c 			 .alg = CIPHER_ALG_AES,
alg              3816 drivers/crypto/bcm/cipher.c 		       .alg = HASH_ALG_NONE,
alg              3822 drivers/crypto/bcm/cipher.c 	 .alg.crypto = {
alg              3833 drivers/crypto/bcm/cipher.c 			 .alg = CIPHER_ALG_AES,
alg              3837 drivers/crypto/bcm/cipher.c 		       .alg = HASH_ALG_NONE,
alg              3845 drivers/crypto/bcm/cipher.c 	 .alg.hash = {
alg              3855 drivers/crypto/bcm/cipher.c 			 .alg = CIPHER_ALG_NONE,
alg              3859 drivers/crypto/bcm/cipher.c 		       .alg = HASH_ALG_MD5,
alg              3865 drivers/crypto/bcm/cipher.c 	 .alg.hash = {
alg              3874 drivers/crypto/bcm/cipher.c 			 .alg = CIPHER_ALG_NONE,
alg              3878 drivers/crypto/bcm/cipher.c 		       .alg = HASH_ALG_MD5,
alg              3883 drivers/crypto/bcm/cipher.c 	 .alg.hash = {
alg              3892 drivers/crypto/bcm/cipher.c 			 .alg = CIPHER_ALG_NONE,
alg              3896 drivers/crypto/bcm/cipher.c 		       .alg = HASH_ALG_SHA1,
alg              3901 drivers/crypto/bcm/cipher.c 	 .alg.hash = {
alg              3910 drivers/crypto/bcm/cipher.c 			 .alg = CIPHER_ALG_NONE,
alg              3914 drivers/crypto/bcm/cipher.c 		       .alg = HASH_ALG_SHA1,
alg              3919 drivers/crypto/bcm/cipher.c 	 .alg.hash = {
alg              3928 drivers/crypto/bcm/cipher.c 			 .alg = CIPHER_ALG_NONE,
alg              3932 drivers/crypto/bcm/cipher.c 		       .alg = HASH_ALG_SHA224,
alg              3937 drivers/crypto/bcm/cipher.c 	 .alg.hash = {
alg              3946 drivers/crypto/bcm/cipher.c 			 .alg = CIPHER_ALG_NONE,
alg              3950 drivers/crypto/bcm/cipher.c 		       .alg = HASH_ALG_SHA224,
alg              3955 drivers/crypto/bcm/cipher.c 	 .alg.hash = {
alg              3964 drivers/crypto/bcm/cipher.c 			 .alg = CIPHER_ALG_NONE,
alg              3968 drivers/crypto/bcm/cipher.c 		       .alg = HASH_ALG_SHA256,
alg              3973 drivers/crypto/bcm/cipher.c 	 .alg.hash = {
alg              3982 drivers/crypto/bcm/cipher.c 			 .alg = CIPHER_ALG_NONE,
alg              3986 drivers/crypto/bcm/cipher.c 		       .alg = HASH_ALG_SHA256,
alg              3992 drivers/crypto/bcm/cipher.c 	 .alg.hash = {
alg              4001 drivers/crypto/bcm/cipher.c 			 .alg = CIPHER_ALG_NONE,
alg              4005 drivers/crypto/bcm/cipher.c 		       .alg = HASH_ALG_SHA384,
alg              4011 drivers/crypto/bcm/cipher.c 	 .alg.hash = {
alg              4020 drivers/crypto/bcm/cipher.c 			 .alg = CIPHER_ALG_NONE,
alg              4024 drivers/crypto/bcm/cipher.c 		       .alg = HASH_ALG_SHA384,
alg              4030 drivers/crypto/bcm/cipher.c 	 .alg.hash = {
alg              4039 drivers/crypto/bcm/cipher.c 			 .alg = CIPHER_ALG_NONE,
alg              4043 drivers/crypto/bcm/cipher.c 		       .alg = HASH_ALG_SHA512,
alg              4049 drivers/crypto/bcm/cipher.c 	 .alg.hash = {
alg              4058 drivers/crypto/bcm/cipher.c 			 .alg = CIPHER_ALG_NONE,
alg              4062 drivers/crypto/bcm/cipher.c 		       .alg = HASH_ALG_SHA512,
alg              4068 drivers/crypto/bcm/cipher.c 	 .alg.hash = {
alg              4077 drivers/crypto/bcm/cipher.c 			 .alg = CIPHER_ALG_NONE,
alg              4081 drivers/crypto/bcm/cipher.c 		       .alg = HASH_ALG_SHA3_224,
alg              4087 drivers/crypto/bcm/cipher.c 	 .alg.hash = {
alg              4096 drivers/crypto/bcm/cipher.c 			 .alg = CIPHER_ALG_NONE,
alg              4100 drivers/crypto/bcm/cipher.c 		       .alg = HASH_ALG_SHA3_224,
alg              4106 drivers/crypto/bcm/cipher.c 	 .alg.hash = {
alg              4115 drivers/crypto/bcm/cipher.c 			 .alg = CIPHER_ALG_NONE,
alg              4119 drivers/crypto/bcm/cipher.c 		       .alg = HASH_ALG_SHA3_256,
alg              4125 drivers/crypto/bcm/cipher.c 	 .alg.hash = {
alg              4134 drivers/crypto/bcm/cipher.c 			 .alg = CIPHER_ALG_NONE,
alg              4138 drivers/crypto/bcm/cipher.c 		       .alg = HASH_ALG_SHA3_256,
alg              4144 drivers/crypto/bcm/cipher.c 	 .alg.hash = {
alg              4153 drivers/crypto/bcm/cipher.c 			 .alg = CIPHER_ALG_NONE,
alg              4157 drivers/crypto/bcm/cipher.c 		       .alg = HASH_ALG_SHA3_384,
alg              4163 drivers/crypto/bcm/cipher.c 	 .alg.hash = {
alg              4172 drivers/crypto/bcm/cipher.c 			 .alg = CIPHER_ALG_NONE,
alg              4176 drivers/crypto/bcm/cipher.c 		       .alg = HASH_ALG_SHA3_384,
alg              4182 drivers/crypto/bcm/cipher.c 	 .alg.hash = {
alg              4191 drivers/crypto/bcm/cipher.c 			 .alg = CIPHER_ALG_NONE,
alg              4195 drivers/crypto/bcm/cipher.c 		       .alg = HASH_ALG_SHA3_512,
alg              4201 drivers/crypto/bcm/cipher.c 	 .alg.hash = {
alg              4210 drivers/crypto/bcm/cipher.c 			 .alg = CIPHER_ALG_NONE,
alg              4214 drivers/crypto/bcm/cipher.c 		       .alg = HASH_ALG_SHA3_512,
alg              4220 drivers/crypto/bcm/cipher.c 	 .alg.hash = {
alg              4229 drivers/crypto/bcm/cipher.c 			 .alg = CIPHER_ALG_NONE,
alg              4233 drivers/crypto/bcm/cipher.c 		       .alg = HASH_ALG_AES,
alg              4239 drivers/crypto/bcm/cipher.c 	 .alg.hash = {
alg              4248 drivers/crypto/bcm/cipher.c 			 .alg = CIPHER_ALG_NONE,
alg              4252 drivers/crypto/bcm/cipher.c 		       .alg = HASH_ALG_AES,
alg              4267 drivers/crypto/bcm/cipher.c 	ctx->alg = cipher_alg;
alg              4271 drivers/crypto/bcm/cipher.c 	ctx->max_payload = spu->spu_ctx_max_payload(ctx->cipher.alg,
alg              4287 drivers/crypto/bcm/cipher.c 	struct crypto_alg *alg = tfm->__crt_alg;
alg              4294 drivers/crypto/bcm/cipher.c 	cipher_alg = container_of(alg, struct iproc_alg_s, alg.crypto);
alg              4301 drivers/crypto/bcm/cipher.c 	struct crypto_alg *alg = tfm->__crt_alg;
alg              4304 drivers/crypto/bcm/cipher.c 	cipher_alg = container_of(__crypto_ahash_alg(alg), struct iproc_alg_s,
alg              4305 drivers/crypto/bcm/cipher.c 				  alg.hash);
alg              4324 drivers/crypto/bcm/cipher.c 	struct crypto_alg *alg = tfm->__crt_alg;
alg              4325 drivers/crypto/bcm/cipher.c 	struct aead_alg *aalg = container_of(alg, struct aead_alg, base);
alg              4327 drivers/crypto/bcm/cipher.c 						      alg.aead);
alg              4343 drivers/crypto/bcm/cipher.c 		if (alg->cra_flags & CRYPTO_ALG_NEED_FALLBACK) {
alg              4347 drivers/crypto/bcm/cipher.c 			    crypto_alloc_aead(alg->cra_name, 0,
alg              4352 drivers/crypto/bcm/cipher.c 				       __func__, alg->cra_name);
alg              4530 drivers/crypto/bcm/cipher.c 	struct crypto_alg *crypto = &driver_alg->alg.crypto;
alg              4534 drivers/crypto/bcm/cipher.c 	if ((driver_alg->cipher_info.alg == CIPHER_ALG_RC4) &&
alg              4564 drivers/crypto/bcm/cipher.c 	struct ahash_alg *hash = &driver_alg->alg.hash;
alg              4568 drivers/crypto/bcm/cipher.c 	if ((driver_alg->auth_info.alg == HASH_ALG_AES) &&
alg              4574 drivers/crypto/bcm/cipher.c 	if ((driver_alg->auth_info.alg >= HASH_ALG_SHA3_224) &&
alg              4593 drivers/crypto/bcm/cipher.c 		if ((driver_alg->auth_info.alg == HASH_ALG_AES) &&
alg              4620 drivers/crypto/bcm/cipher.c 	struct aead_alg *aead = &driver_alg->alg.aead;
alg              4684 drivers/crypto/bcm/cipher.c 			crypto_unregister_alg(&driver_algs[j].alg.crypto);
alg              4688 drivers/crypto/bcm/cipher.c 			crypto_unregister_ahash(&driver_algs[j].alg.hash);
alg              4692 drivers/crypto/bcm/cipher.c 			crypto_unregister_aead(&driver_algs[j].alg.aead);
alg              4841 drivers/crypto/bcm/cipher.c 			crypto_unregister_alg(&driver_algs[i].alg.crypto);
alg              4843 drivers/crypto/bcm/cipher.c 				driver_algs[i].alg.crypto.cra_driver_name);
alg              4847 drivers/crypto/bcm/cipher.c 			crypto_unregister_ahash(&driver_algs[i].alg.hash);
alg              4848 drivers/crypto/bcm/cipher.c 			cdn = driver_algs[i].alg.hash.halg.base.cra_driver_name;
alg              4853 drivers/crypto/bcm/cipher.c 			crypto_unregister_aead(&driver_algs[i].alg.aead);
alg              4855 drivers/crypto/bcm/cipher.c 				driver_algs[i].alg.aead.base.cra_driver_name);
alg                93 drivers/crypto/bcm/cipher.h 	enum spu_cipher_alg alg;
alg                98 drivers/crypto/bcm/cipher.h 	enum hash_alg alg;
alg               108 drivers/crypto/bcm/cipher.h 	} alg;
alg               190 drivers/crypto/bcm/cipher.h 	struct iproc_alg_s *alg;
alg               375 drivers/crypto/bcm/cipher.h 	u32 (*spu_digest_size)(u32 digest_size, enum hash_alg alg,
alg               560 drivers/crypto/bcm/spu.c u32 spum_digest_size(u32 alg_digest_size, enum hash_alg alg,
alg               569 drivers/crypto/bcm/spu.c 		if (alg == HASH_ALG_SHA224)
alg               571 drivers/crypto/bcm/spu.c 		else if (alg == HASH_ALG_SHA384)
alg               641 drivers/crypto/bcm/spu.c 	if ((hash_parms->alg == HASH_ALG_AES) &&
alg               651 drivers/crypto/bcm/spu.c 		 spu_alg_name(cipher_parms->alg, cipher_parms->mode),
alg               652 drivers/crypto/bcm/spu.c 		 cipher_parms->alg, cipher_parms->mode, cipher_parms->type);
alg               658 drivers/crypto/bcm/spu.c 		 hash_parms->alg, hash_parms->mode, hash_parms->type);
alg               694 drivers/crypto/bcm/spu.c 	cipher_bits |= cipher_parms->alg << CIPHER_ALG_SHIFT;
alg               699 drivers/crypto/bcm/spu.c 	cipher_bits |= hash_parms->alg << HASH_ALG_SHIFT;
alg               707 drivers/crypto/bcm/spu.c 	if (hash_parms->alg) {
alg               742 drivers/crypto/bcm/spu.c 	if (cipher_parms->alg) {
alg               848 drivers/crypto/bcm/spu.c 	flow_log("  cipher alg:%u mode:%u type %u\n", cipher_parms->alg,
alg               869 drivers/crypto/bcm/spu.c 	if (cipher_parms->alg) {
alg               888 drivers/crypto/bcm/spu.c 	cipher_bits |= cipher_parms->alg << CIPHER_ALG_SHIFT;
alg               893 drivers/crypto/bcm/spu.c 	if (cipher_parms->alg && cipher_parms->key_len)
alg               949 drivers/crypto/bcm/spu.c 	flow_log(" cipher alg: %u, cipher_type: %u\n", cipher_parms->alg,
alg               991 drivers/crypto/bcm/spu.c 	if (cipher_parms->alg && cipher_parms->iv_buf && cipher_parms->iv_len)
alg               116 drivers/crypto/bcm/spu.h 	enum spu_cipher_alg  alg;
alg               127 drivers/crypto/bcm/spu.h 	enum hash_alg  alg;
alg               238 drivers/crypto/bcm/spu.h u32 spum_digest_size(u32 alg_digest_size, enum hash_alg alg,
alg               917 drivers/crypto/bcm/spu2.c u32 spu2_digest_size(u32 alg_digest_size, enum hash_alg alg,
alg               980 drivers/crypto/bcm/spu2.c 	    (cipher_parms->alg == CIPHER_ALG_AES) &&
alg               990 drivers/crypto/bcm/spu2.c 	    (cipher_parms->alg == CIPHER_ALG_AES) &&
alg               997 drivers/crypto/bcm/spu2.c 	flow_log("  cipher alg:%u mode:%u type %u\n", cipher_parms->alg,
alg              1005 drivers/crypto/bcm/spu2.c 		 hash_parms->alg, hash_parms->mode, hash_parms->type);
alg              1019 drivers/crypto/bcm/spu2.c 	err = spu2_cipher_xlate(cipher_parms->alg, cipher_parms->mode,
alg              1054 drivers/crypto/bcm/spu2.c 	err = spu2_hash_xlate(hash_parms->alg, hash_parms->mode,
alg              1132 drivers/crypto/bcm/spu2.c 	flow_log("  cipher alg:%u mode:%u type %u\n", cipher_parms->alg,
alg              1139 drivers/crypto/bcm/spu2.c 	err = spu2_cipher_xlate(cipher_parms->alg, cipher_parms->mode,
alg              1197 drivers/crypto/bcm/spu2.c 	flow_log(" cipher alg: %u, cipher_type: %u\n", cipher_parms->alg,
alg              1222 drivers/crypto/bcm/spu2.c 	if (cipher_parms->alg && cipher_parms->iv_buf && cipher_parms->iv_len) {
alg               190 drivers/crypto/bcm/spu2.h u32 spu2_digest_size(u32 alg_digest_size, enum hash_alg alg,
alg               294 drivers/crypto/bcm/util.c char *spu_alg_name(enum spu_cipher_alg alg, enum spu_cipher_mode mode)
alg               296 drivers/crypto/bcm/util.c 	switch (alg) {
alg               357 drivers/crypto/bcm/util.c 	u32 alg;
alg               384 drivers/crypto/bcm/util.c 	for (alg = 0; alg < CIPHER_ALG_LAST; alg++) {
alg               386 drivers/crypto/bcm/util.c 			op_cnt = atomic_read(&ipriv->cipher_cnt[alg][mode]);
alg               391 drivers/crypto/bcm/util.c 			       spu_alg_name(alg, mode), op_cnt);
alg               398 drivers/crypto/bcm/util.c 	for (alg = 0; alg < HASH_ALG_LAST; alg++) {
alg               399 drivers/crypto/bcm/util.c 		op_cnt = atomic_read(&ipriv->hash_cnt[alg]);
alg               404 drivers/crypto/bcm/util.c 		       hash_alg_name[alg], op_cnt);
alg               413 drivers/crypto/bcm/util.c 	for (alg = 0; alg < HASH_ALG_LAST; alg++) {
alg               414 drivers/crypto/bcm/util.c 		op_cnt = atomic_read(&ipriv->hmac_cnt[alg]);
alg               419 drivers/crypto/bcm/util.c 		       hash_alg_name[alg], op_cnt);
alg               429 drivers/crypto/bcm/util.c 	for (alg = 0; alg < AEAD_TYPE_LAST; alg++) {
alg               430 drivers/crypto/bcm/util.c 		op_cnt = atomic_read(&ipriv->aead_cnt[alg]);
alg               435 drivers/crypto/bcm/util.c 		       aead_alg_name[alg], op_cnt);
alg                93 drivers/crypto/bcm/util.h char *spu_alg_name(enum spu_cipher_alg alg, enum spu_cipher_mode mode);
alg               169 drivers/crypto/caam/caamalg.c 	struct caam_aead_alg *alg = container_of(crypto_aead_alg(aead),
alg               181 drivers/crypto/caam/caamalg.c 	const bool is_rfc3686 = alg->caam.rfc3686;
alg               223 drivers/crypto/caam/caamalg.c 	if (alg->caam.geniv)
alg               264 drivers/crypto/caam/caamalg.c 			       ctx->authsize, alg->caam.geniv, is_rfc3686,
alg               269 drivers/crypto/caam/caamalg.c 	if (!alg->caam.geniv)
alg               727 drivers/crypto/caam/caamalg.c 	struct caam_skcipher_alg *alg =
alg               728 drivers/crypto/caam/caamalg.c 		container_of(crypto_skcipher_alg(skcipher), typeof(*alg),
alg               733 drivers/crypto/caam/caamalg.c 	const bool is_rfc3686 = alg->caam.rfc3686;
alg              1218 drivers/crypto/caam/caamalg.c 	struct caam_aead_alg *alg = container_of(crypto_aead_alg(aead),
alg              1225 drivers/crypto/caam/caamalg.c 	const bool is_rfc3686 = alg->caam.rfc3686;
alg              1255 drivers/crypto/caam/caamalg.c 	if (ivsize && ((is_rfc3686 && encrypt) || !alg->caam.geniv))
alg              3450 drivers/crypto/caam/caamalg.c 	struct skcipher_alg *alg = crypto_skcipher_alg(tfm);
alg              3452 drivers/crypto/caam/caamalg.c 		container_of(alg, typeof(*caam_alg), skcipher);
alg              3460 drivers/crypto/caam/caamalg.c 	struct aead_alg *alg = crypto_aead_alg(tfm);
alg              3462 drivers/crypto/caam/caamalg.c 		 container_of(alg, struct caam_aead_alg, aead);
alg              3507 drivers/crypto/caam/caamalg.c 	struct skcipher_alg *alg = &t_alg->skcipher;
alg              3509 drivers/crypto/caam/caamalg.c 	alg->base.cra_module = THIS_MODULE;
alg              3510 drivers/crypto/caam/caamalg.c 	alg->base.cra_priority = CAAM_CRA_PRIORITY;
alg              3511 drivers/crypto/caam/caamalg.c 	alg->base.cra_ctxsize = sizeof(struct caam_ctx);
alg              3512 drivers/crypto/caam/caamalg.c 	alg->base.cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_KERN_DRIVER_ONLY;
alg              3514 drivers/crypto/caam/caamalg.c 	alg->init = caam_cra_init;
alg              3515 drivers/crypto/caam/caamalg.c 	alg->exit = caam_cra_exit;
alg              3520 drivers/crypto/caam/caamalg.c 	struct aead_alg *alg = &t_alg->aead;
alg              3522 drivers/crypto/caam/caamalg.c 	alg->base.cra_module = THIS_MODULE;
alg              3523 drivers/crypto/caam/caamalg.c 	alg->base.cra_priority = CAAM_CRA_PRIORITY;
alg              3524 drivers/crypto/caam/caamalg.c 	alg->base.cra_ctxsize = sizeof(struct caam_ctx);
alg              3525 drivers/crypto/caam/caamalg.c 	alg->base.cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_KERN_DRIVER_ONLY;
alg              3527 drivers/crypto/caam/caamalg.c 	alg->init = caam_aead_init;
alg              3528 drivers/crypto/caam/caamalg.c 	alg->exit = caam_aead_exit;
alg                74 drivers/crypto/caam/caamalg_qi.c 	struct caam_aead_alg *alg = container_of(crypto_aead_alg(aead),
alg                75 drivers/crypto/caam/caamalg_qi.c 						 typeof(*alg), aead);
alg                84 drivers/crypto/caam/caamalg_qi.c 	const bool is_rfc3686 = alg->caam.rfc3686;
alg               123 drivers/crypto/caam/caamalg_qi.c 	if (alg->caam.geniv)
alg               152 drivers/crypto/caam/caamalg_qi.c 			       ivsize, ctx->authsize, alg->caam.geniv,
alg               156 drivers/crypto/caam/caamalg_qi.c 	if (!alg->caam.geniv)
alg               620 drivers/crypto/caam/caamalg_qi.c 	struct caam_skcipher_alg *alg =
alg               621 drivers/crypto/caam/caamalg_qi.c 		container_of(crypto_skcipher_alg(skcipher), typeof(*alg),
alg               625 drivers/crypto/caam/caamalg_qi.c 	const bool is_rfc3686 = alg->caam.rfc3686;
alg               943 drivers/crypto/caam/caamalg_qi.c 	struct caam_aead_alg *alg = container_of(crypto_aead_alg(aead),
alg               944 drivers/crypto/caam/caamalg_qi.c 						 typeof(*alg), aead);
alg              1037 drivers/crypto/caam/caamalg_qi.c 	if ((alg->caam.rfc3686 && encrypt) || !alg->caam.geniv)
alg              2462 drivers/crypto/caam/caamalg_qi.c 	struct skcipher_alg *alg = crypto_skcipher_alg(tfm);
alg              2464 drivers/crypto/caam/caamalg_qi.c 		container_of(alg, typeof(*caam_alg), skcipher);
alg              2472 drivers/crypto/caam/caamalg_qi.c 	struct aead_alg *alg = crypto_aead_alg(tfm);
alg              2473 drivers/crypto/caam/caamalg_qi.c 	struct caam_aead_alg *caam_alg = container_of(alg, typeof(*caam_alg),
alg              2522 drivers/crypto/caam/caamalg_qi.c 	struct skcipher_alg *alg = &t_alg->skcipher;
alg              2524 drivers/crypto/caam/caamalg_qi.c 	alg->base.cra_module = THIS_MODULE;
alg              2525 drivers/crypto/caam/caamalg_qi.c 	alg->base.cra_priority = CAAM_CRA_PRIORITY;
alg              2526 drivers/crypto/caam/caamalg_qi.c 	alg->base.cra_ctxsize = sizeof(struct caam_ctx);
alg              2527 drivers/crypto/caam/caamalg_qi.c 	alg->base.cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_KERN_DRIVER_ONLY;
alg              2529 drivers/crypto/caam/caamalg_qi.c 	alg->init = caam_cra_init;
alg              2530 drivers/crypto/caam/caamalg_qi.c 	alg->exit = caam_cra_exit;
alg              2535 drivers/crypto/caam/caamalg_qi.c 	struct aead_alg *alg = &t_alg->aead;
alg              2537 drivers/crypto/caam/caamalg_qi.c 	alg->base.cra_module = THIS_MODULE;
alg              2538 drivers/crypto/caam/caamalg_qi.c 	alg->base.cra_priority = CAAM_CRA_PRIORITY;
alg              2539 drivers/crypto/caam/caamalg_qi.c 	alg->base.cra_ctxsize = sizeof(struct caam_ctx);
alg              2540 drivers/crypto/caam/caamalg_qi.c 	alg->base.cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_KERN_DRIVER_ONLY;
alg              2542 drivers/crypto/caam/caamalg_qi.c 	alg->init = caam_aead_init;
alg              2543 drivers/crypto/caam/caamalg_qi.c 	alg->exit = caam_aead_exit;
alg               165 drivers/crypto/caam/caamalg_qi2.c 	struct caam_aead_alg *alg = container_of(crypto_aead_alg(aead),
alg               166 drivers/crypto/caam/caamalg_qi2.c 						 typeof(*alg), aead);
alg               179 drivers/crypto/caam/caamalg_qi2.c 	const bool is_rfc3686 = alg->caam.rfc3686;
alg               218 drivers/crypto/caam/caamalg_qi2.c 	if (desc_inline_query((alg->caam.geniv ? DESC_QI_AEAD_GIVENC_LEN :
alg               231 drivers/crypto/caam/caamalg_qi2.c 	if (alg->caam.geniv)
alg               259 drivers/crypto/caam/caamalg_qi2.c 			       ivsize, ctx->authsize, alg->caam.geniv,
alg               355 drivers/crypto/caam/caamalg_qi2.c 	struct caam_aead_alg *alg = container_of(crypto_aead_alg(aead),
alg               356 drivers/crypto/caam/caamalg_qi2.c 						 typeof(*alg), aead);
alg               443 drivers/crypto/caam/caamalg_qi2.c 	if ((alg->caam.rfc3686 && encrypt) || !alg->caam.geniv)
alg               500 drivers/crypto/caam/caamalg_qi2.c 	if ((alg->caam.class1_alg_type & OP_ALG_ALGSEL_MASK) ==
alg               950 drivers/crypto/caam/caamalg_qi2.c 	struct caam_skcipher_alg *alg =
alg               957 drivers/crypto/caam/caamalg_qi2.c 	const bool is_rfc3686 = alg->caam.rfc3686;
alg              1563 drivers/crypto/caam/caamalg_qi2.c 	struct skcipher_alg *alg = crypto_skcipher_alg(tfm);
alg              1565 drivers/crypto/caam/caamalg_qi2.c 		container_of(alg, typeof(*caam_alg), skcipher);
alg              1573 drivers/crypto/caam/caamalg_qi2.c 	struct aead_alg *alg = crypto_aead_alg(tfm);
alg              1574 drivers/crypto/caam/caamalg_qi2.c 	struct caam_aead_alg *caam_alg = container_of(alg, typeof(*caam_alg),
alg              2936 drivers/crypto/caam/caamalg_qi2.c 	struct skcipher_alg *alg = &t_alg->skcipher;
alg              2938 drivers/crypto/caam/caamalg_qi2.c 	alg->base.cra_module = THIS_MODULE;
alg              2939 drivers/crypto/caam/caamalg_qi2.c 	alg->base.cra_priority = CAAM_CRA_PRIORITY;
alg              2940 drivers/crypto/caam/caamalg_qi2.c 	alg->base.cra_ctxsize = sizeof(struct caam_ctx);
alg              2941 drivers/crypto/caam/caamalg_qi2.c 	alg->base.cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_KERN_DRIVER_ONLY;
alg              2943 drivers/crypto/caam/caamalg_qi2.c 	alg->init = caam_cra_init_skcipher;
alg              2944 drivers/crypto/caam/caamalg_qi2.c 	alg->exit = caam_cra_exit;
alg              2949 drivers/crypto/caam/caamalg_qi2.c 	struct aead_alg *alg = &t_alg->aead;
alg              2951 drivers/crypto/caam/caamalg_qi2.c 	alg->base.cra_module = THIS_MODULE;
alg              2952 drivers/crypto/caam/caamalg_qi2.c 	alg->base.cra_priority = CAAM_CRA_PRIORITY;
alg              2953 drivers/crypto/caam/caamalg_qi2.c 	alg->base.cra_ctxsize = sizeof(struct caam_ctx);
alg              2954 drivers/crypto/caam/caamalg_qi2.c 	alg->base.cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_KERN_DRIVER_ONLY;
alg              2956 drivers/crypto/caam/caamalg_qi2.c 	alg->init = caam_cra_init_aead;
alg              2957 drivers/crypto/caam/caamalg_qi2.c 	alg->exit = caam_cra_exit_aead;
alg              4515 drivers/crypto/caam/caamalg_qi2.c 	struct ahash_alg *alg =
alg              4518 drivers/crypto/caam/caamalg_qi2.c 		 container_of(alg, struct caam_hash_alg, ahash_alg);
alg              4532 drivers/crypto/caam/caamalg_qi2.c 	if (alg->setkey) {
alg              4589 drivers/crypto/caam/caamalg_qi2.c 	struct crypto_alg *alg;
alg              4597 drivers/crypto/caam/caamalg_qi2.c 	alg = &halg->halg.base;
alg              4600 drivers/crypto/caam/caamalg_qi2.c 		snprintf(alg->cra_name, CRYPTO_MAX_ALG_NAME, "%s",
alg              4602 drivers/crypto/caam/caamalg_qi2.c 		snprintf(alg->cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s",
alg              4605 drivers/crypto/caam/caamalg_qi2.c 		snprintf(alg->cra_name, CRYPTO_MAX_ALG_NAME, "%s",
alg              4607 drivers/crypto/caam/caamalg_qi2.c 		snprintf(alg->cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s",
alg              4611 drivers/crypto/caam/caamalg_qi2.c 	alg->cra_module = THIS_MODULE;
alg              4612 drivers/crypto/caam/caamalg_qi2.c 	alg->cra_init = caam_hash_cra_init;
alg              4613 drivers/crypto/caam/caamalg_qi2.c 	alg->cra_exit = caam_hash_cra_exit;
alg              4614 drivers/crypto/caam/caamalg_qi2.c 	alg->cra_ctxsize = sizeof(struct caam_hash_ctx);
alg              4615 drivers/crypto/caam/caamalg_qi2.c 	alg->cra_priority = CAAM_CRA_PRIORITY;
alg              4616 drivers/crypto/caam/caamalg_qi2.c 	alg->cra_blocksize = template->blocksize;
alg              4617 drivers/crypto/caam/caamalg_qi2.c 	alg->cra_alignmask = 0;
alg              4618 drivers/crypto/caam/caamalg_qi2.c 	alg->cra_flags = CRYPTO_ALG_ASYNC;
alg              5285 drivers/crypto/caam/caamalg_qi2.c 		struct caam_hash_template *alg = driver_hash + i;
alg              5288 drivers/crypto/caam/caamalg_qi2.c 		t_alg = caam_hash_alloc(dev, alg, true);
alg              5292 drivers/crypto/caam/caamalg_qi2.c 				 alg->driver_name, err);
alg              5307 drivers/crypto/caam/caamalg_qi2.c 		t_alg = caam_hash_alloc(dev, alg, false);
alg              5311 drivers/crypto/caam/caamalg_qi2.c 				 alg->driver_name, err);
alg              1812 drivers/crypto/caam/caamhash.c 	struct ahash_alg *alg =
alg              1815 drivers/crypto/caam/caamhash.c 		 container_of(alg, struct caam_hash_alg, ahash_alg);
alg              1852 drivers/crypto/caam/caamhash.c 			ctx->key_dir = alg->setkey ? DMA_TO_DEVICE : DMA_NONE;
alg              1907 drivers/crypto/caam/caamhash.c 	return alg->setkey ? 0 : ahash_set_sh_desc(ahash);
alg              1944 drivers/crypto/caam/caamhash.c 	struct crypto_alg *alg;
alg              1954 drivers/crypto/caam/caamhash.c 	alg = &halg->halg.base;
alg              1957 drivers/crypto/caam/caamhash.c 		snprintf(alg->cra_name, CRYPTO_MAX_ALG_NAME, "%s",
alg              1959 drivers/crypto/caam/caamhash.c 		snprintf(alg->cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s",
alg              1962 drivers/crypto/caam/caamhash.c 		snprintf(alg->cra_name, CRYPTO_MAX_ALG_NAME, "%s",
alg              1964 drivers/crypto/caam/caamhash.c 		snprintf(alg->cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s",
alg              1968 drivers/crypto/caam/caamhash.c 	alg->cra_module = THIS_MODULE;
alg              1969 drivers/crypto/caam/caamhash.c 	alg->cra_init = caam_hash_cra_init;
alg              1970 drivers/crypto/caam/caamhash.c 	alg->cra_exit = caam_hash_cra_exit;
alg              1971 drivers/crypto/caam/caamhash.c 	alg->cra_ctxsize = sizeof(struct caam_hash_ctx);
alg              1972 drivers/crypto/caam/caamhash.c 	alg->cra_priority = CAAM_CRA_PRIORITY;
alg              1973 drivers/crypto/caam/caamhash.c 	alg->cra_blocksize = template->blocksize;
alg              1974 drivers/crypto/caam/caamhash.c 	alg->cra_alignmask = 0;
alg              1975 drivers/crypto/caam/caamhash.c 	alg->cra_flags = CRYPTO_ALG_ASYNC;
alg              2021 drivers/crypto/caam/caamhash.c 		struct caam_hash_template *alg = driver_hash + i;
alg              2024 drivers/crypto/caam/caamhash.c 		if (is_mdha(alg->alg_type) &&
alg              2025 drivers/crypto/caam/caamhash.c 		    alg->template_ahash.halg.digestsize > md_limit)
alg              2029 drivers/crypto/caam/caamhash.c 		t_alg = caam_hash_alloc(alg, true);
alg              2033 drivers/crypto/caam/caamhash.c 				alg->hmac_driver_name);
alg              2046 drivers/crypto/caam/caamhash.c 		if ((alg->alg_type & OP_ALG_ALGSEL_MASK) == OP_ALG_ALGSEL_AES)
alg              2050 drivers/crypto/caam/caamhash.c 		t_alg = caam_hash_alloc(alg, false);
alg              2053 drivers/crypto/caam/caamhash.c 			pr_warn("%s alg allocation failed\n", alg->driver_name);
alg               260 drivers/crypto/ccp/ccp-crypto-aes-cmac.c 	struct ccp_crypto_ahash_alg *alg =
alg               282 drivers/crypto/ccp/ccp-crypto-aes-cmac.c 	ctx->u.aes.mode = alg->mode;
alg               352 drivers/crypto/ccp/ccp-crypto-aes-cmac.c 	struct ahash_alg *alg;
alg               364 drivers/crypto/ccp/ccp-crypto-aes-cmac.c 	alg = &ccp_alg->alg;
alg               365 drivers/crypto/ccp/ccp-crypto-aes-cmac.c 	alg->init = ccp_aes_cmac_init;
alg               366 drivers/crypto/ccp/ccp-crypto-aes-cmac.c 	alg->update = ccp_aes_cmac_update;
alg               367 drivers/crypto/ccp/ccp-crypto-aes-cmac.c 	alg->final = ccp_aes_cmac_final;
alg               368 drivers/crypto/ccp/ccp-crypto-aes-cmac.c 	alg->finup = ccp_aes_cmac_finup;
alg               369 drivers/crypto/ccp/ccp-crypto-aes-cmac.c 	alg->digest = ccp_aes_cmac_digest;
alg               370 drivers/crypto/ccp/ccp-crypto-aes-cmac.c 	alg->export = ccp_aes_cmac_export;
alg               371 drivers/crypto/ccp/ccp-crypto-aes-cmac.c 	alg->import = ccp_aes_cmac_import;
alg               372 drivers/crypto/ccp/ccp-crypto-aes-cmac.c 	alg->setkey = ccp_aes_cmac_setkey;
alg               374 drivers/crypto/ccp/ccp-crypto-aes-cmac.c 	halg = &alg->halg;
alg               390 drivers/crypto/ccp/ccp-crypto-aes-cmac.c 	ret = crypto_register_ahash(alg);
alg               214 drivers/crypto/ccp/ccp-crypto-aes-galois.c 	struct aead_alg *alg;
alg               226 drivers/crypto/ccp/ccp-crypto-aes-galois.c 	alg = &ccp_aead->alg;
alg               227 drivers/crypto/ccp/ccp-crypto-aes-galois.c 	*alg = *def->alg_defaults;
alg               228 drivers/crypto/ccp/ccp-crypto-aes-galois.c 	snprintf(alg->base.cra_name, CRYPTO_MAX_ALG_NAME, "%s", def->name);
alg               229 drivers/crypto/ccp/ccp-crypto-aes-galois.c 	snprintf(alg->base.cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s",
alg               231 drivers/crypto/ccp/ccp-crypto-aes-galois.c 	alg->base.cra_blocksize = def->blocksize;
alg               232 drivers/crypto/ccp/ccp-crypto-aes-galois.c 	alg->base.cra_ablkcipher.ivsize = def->ivsize;
alg               234 drivers/crypto/ccp/ccp-crypto-aes-galois.c 	ret = crypto_register_aead(alg);
alg               237 drivers/crypto/ccp/ccp-crypto-aes-galois.c 		       alg->base.cra_name, ret);
alg               231 drivers/crypto/ccp/ccp-crypto-aes-xts.c 	struct crypto_alg *alg;
alg               240 drivers/crypto/ccp/ccp-crypto-aes-xts.c 	alg = &ccp_alg->alg;
alg               242 drivers/crypto/ccp/ccp-crypto-aes-xts.c 	snprintf(alg->cra_name, CRYPTO_MAX_ALG_NAME, "%s", def->name);
alg               243 drivers/crypto/ccp/ccp-crypto-aes-xts.c 	snprintf(alg->cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s",
alg               245 drivers/crypto/ccp/ccp-crypto-aes-xts.c 	alg->cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC |
alg               248 drivers/crypto/ccp/ccp-crypto-aes-xts.c 	alg->cra_blocksize = AES_BLOCK_SIZE;
alg               249 drivers/crypto/ccp/ccp-crypto-aes-xts.c 	alg->cra_ctxsize = sizeof(struct ccp_ctx);
alg               250 drivers/crypto/ccp/ccp-crypto-aes-xts.c 	alg->cra_priority = CCP_CRA_PRIORITY;
alg               251 drivers/crypto/ccp/ccp-crypto-aes-xts.c 	alg->cra_type = &crypto_ablkcipher_type;
alg               252 drivers/crypto/ccp/ccp-crypto-aes-xts.c 	alg->cra_ablkcipher.setkey = ccp_aes_xts_setkey;
alg               253 drivers/crypto/ccp/ccp-crypto-aes-xts.c 	alg->cra_ablkcipher.encrypt = ccp_aes_xts_encrypt;
alg               254 drivers/crypto/ccp/ccp-crypto-aes-xts.c 	alg->cra_ablkcipher.decrypt = ccp_aes_xts_decrypt;
alg               255 drivers/crypto/ccp/ccp-crypto-aes-xts.c 	alg->cra_ablkcipher.min_keysize = AES_MIN_KEY_SIZE * 2;
alg               256 drivers/crypto/ccp/ccp-crypto-aes-xts.c 	alg->cra_ablkcipher.max_keysize = AES_MAX_KEY_SIZE * 2;
alg               257 drivers/crypto/ccp/ccp-crypto-aes-xts.c 	alg->cra_ablkcipher.ivsize = AES_BLOCK_SIZE;
alg               258 drivers/crypto/ccp/ccp-crypto-aes-xts.c 	alg->cra_init = ccp_aes_xts_cra_init;
alg               259 drivers/crypto/ccp/ccp-crypto-aes-xts.c 	alg->cra_exit = ccp_aes_xts_cra_exit;
alg               260 drivers/crypto/ccp/ccp-crypto-aes-xts.c 	alg->cra_module = THIS_MODULE;
alg               262 drivers/crypto/ccp/ccp-crypto-aes-xts.c 	ret = crypto_register_alg(alg);
alg               265 drivers/crypto/ccp/ccp-crypto-aes-xts.c 		       alg->cra_name, ret);
alg                41 drivers/crypto/ccp/ccp-crypto-aes.c 	struct ccp_crypto_ablkcipher_alg *alg =
alg                58 drivers/crypto/ccp/ccp-crypto-aes.c 	ctx->u.aes.mode = alg->mode;
alg               327 drivers/crypto/ccp/ccp-crypto-aes.c 	struct crypto_alg *alg;
alg               339 drivers/crypto/ccp/ccp-crypto-aes.c 	alg = &ccp_alg->alg;
alg               340 drivers/crypto/ccp/ccp-crypto-aes.c 	*alg = *def->alg_defaults;
alg               341 drivers/crypto/ccp/ccp-crypto-aes.c 	snprintf(alg->cra_name, CRYPTO_MAX_ALG_NAME, "%s", def->name);
alg               342 drivers/crypto/ccp/ccp-crypto-aes.c 	snprintf(alg->cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s",
alg               344 drivers/crypto/ccp/ccp-crypto-aes.c 	alg->cra_blocksize = def->blocksize;
alg               345 drivers/crypto/ccp/ccp-crypto-aes.c 	alg->cra_ablkcipher.ivsize = def->ivsize;
alg               347 drivers/crypto/ccp/ccp-crypto-aes.c 	ret = crypto_register_alg(alg);
alg               350 drivers/crypto/ccp/ccp-crypto-aes.c 		       alg->cra_name, ret);
alg                40 drivers/crypto/ccp/ccp-crypto-des3.c 	struct ccp_crypto_ablkcipher_alg *alg =
alg                52 drivers/crypto/ccp/ccp-crypto-des3.c 	ctx->u.des3.mode = alg->mode;
alg               190 drivers/crypto/ccp/ccp-crypto-des3.c 	struct crypto_alg *alg;
alg               202 drivers/crypto/ccp/ccp-crypto-des3.c 	alg = &ccp_alg->alg;
alg               203 drivers/crypto/ccp/ccp-crypto-des3.c 	*alg = *def->alg_defaults;
alg               204 drivers/crypto/ccp/ccp-crypto-des3.c 	snprintf(alg->cra_name, CRYPTO_MAX_ALG_NAME, "%s", def->name);
alg               205 drivers/crypto/ccp/ccp-crypto-des3.c 	snprintf(alg->cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s",
alg               207 drivers/crypto/ccp/ccp-crypto-des3.c 	alg->cra_blocksize = def->blocksize;
alg               208 drivers/crypto/ccp/ccp-crypto-des3.c 	alg->cra_ablkcipher.ivsize = def->ivsize;
alg               210 drivers/crypto/ccp/ccp-crypto-des3.c 	ret = crypto_register_alg(alg);
alg               213 drivers/crypto/ccp/ccp-crypto-des3.c 				alg->cra_name, ret);
alg               379 drivers/crypto/ccp/ccp-crypto-main.c 		crypto_unregister_ahash(&ahash_alg->alg);
alg               385 drivers/crypto/ccp/ccp-crypto-main.c 		crypto_unregister_alg(&ablk_alg->alg);
alg               391 drivers/crypto/ccp/ccp-crypto-main.c 		crypto_unregister_aead(&aead_alg->alg);
alg               397 drivers/crypto/ccp/ccp-crypto-main.c 		crypto_unregister_akcipher(&akc_alg->alg);
alg               249 drivers/crypto/ccp/ccp-crypto-rsa.c 	struct akcipher_alg *alg;
alg               258 drivers/crypto/ccp/ccp-crypto-rsa.c 	alg = &ccp_alg->alg;
alg               259 drivers/crypto/ccp/ccp-crypto-rsa.c 	*alg = *def->alg_defaults;
alg               260 drivers/crypto/ccp/ccp-crypto-rsa.c 	snprintf(alg->base.cra_name, CRYPTO_MAX_ALG_NAME, "%s", def->name);
alg               261 drivers/crypto/ccp/ccp-crypto-rsa.c 	snprintf(alg->base.cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s",
alg               263 drivers/crypto/ccp/ccp-crypto-rsa.c 	ret = crypto_register_akcipher(alg);
alg               266 drivers/crypto/ccp/ccp-crypto-rsa.c 		       alg->base.cra_name, ret);
alg               185 drivers/crypto/ccp/ccp-crypto-sha.c 	struct ccp_crypto_ahash_alg *alg =
alg               192 drivers/crypto/ccp/ccp-crypto-sha.c 	rctx->type = alg->type;
alg               339 drivers/crypto/ccp/ccp-crypto-sha.c 	struct ccp_crypto_ahash_alg *alg = ccp_crypto_ahash_alg(tfm);
alg               342 drivers/crypto/ccp/ccp-crypto-sha.c 	hmac_tfm = crypto_alloc_shash(alg->child_alg, 0, 0);
alg               345 drivers/crypto/ccp/ccp-crypto-sha.c 			alg->child_alg);
alg               421 drivers/crypto/ccp/ccp-crypto-sha.c 	struct ahash_alg *alg;
alg               436 drivers/crypto/ccp/ccp-crypto-sha.c 	alg = &ccp_alg->alg;
alg               437 drivers/crypto/ccp/ccp-crypto-sha.c 	alg->setkey = ccp_sha_setkey;
alg               439 drivers/crypto/ccp/ccp-crypto-sha.c 	halg = &alg->halg;
alg               448 drivers/crypto/ccp/ccp-crypto-sha.c 	ret = crypto_register_ahash(alg);
alg               465 drivers/crypto/ccp/ccp-crypto-sha.c 	struct ahash_alg *alg;
alg               478 drivers/crypto/ccp/ccp-crypto-sha.c 	alg = &ccp_alg->alg;
alg               479 drivers/crypto/ccp/ccp-crypto-sha.c 	alg->init = ccp_sha_init;
alg               480 drivers/crypto/ccp/ccp-crypto-sha.c 	alg->update = ccp_sha_update;
alg               481 drivers/crypto/ccp/ccp-crypto-sha.c 	alg->final = ccp_sha_final;
alg               482 drivers/crypto/ccp/ccp-crypto-sha.c 	alg->finup = ccp_sha_finup;
alg               483 drivers/crypto/ccp/ccp-crypto-sha.c 	alg->digest = ccp_sha_digest;
alg               484 drivers/crypto/ccp/ccp-crypto-sha.c 	alg->export = ccp_sha_export;
alg               485 drivers/crypto/ccp/ccp-crypto-sha.c 	alg->import = ccp_sha_import;
alg               487 drivers/crypto/ccp/ccp-crypto-sha.c 	halg = &alg->halg;
alg               505 drivers/crypto/ccp/ccp-crypto-sha.c 	ret = crypto_register_ahash(alg);
alg                39 drivers/crypto/ccp/ccp-crypto.h 	struct crypto_alg alg;
alg                47 drivers/crypto/ccp/ccp-crypto.h 	struct aead_alg alg;
alg                60 drivers/crypto/ccp/ccp-crypto.h 	struct ahash_alg alg;
alg                66 drivers/crypto/ccp/ccp-crypto.h 	struct akcipher_alg alg;
alg                72 drivers/crypto/ccp/ccp-crypto.h 	struct crypto_alg *alg = tfm->__crt_alg;
alg                74 drivers/crypto/ccp/ccp-crypto.h 	return container_of(alg, struct ccp_crypto_ablkcipher_alg, alg);
alg                80 drivers/crypto/ccp/ccp-crypto.h 	struct crypto_alg *alg = tfm->__crt_alg;
alg                83 drivers/crypto/ccp/ccp-crypto.h 	ahash_alg = container_of(alg, struct ahash_alg, halg.base);
alg                85 drivers/crypto/ccp/ccp-crypto.h 	return container_of(ahash_alg, struct ccp_crypto_ahash_alg, alg);
alg               131 drivers/crypto/ccree/cc_aead.c 	struct aead_alg *alg = crypto_aead_alg(tfm);
alg               134 drivers/crypto/ccree/cc_aead.c 			container_of(alg, struct cc_crypto_alg, aead_alg);
alg              2623 drivers/crypto/ccree/cc_aead.c 	struct aead_alg *alg;
alg              2629 drivers/crypto/ccree/cc_aead.c 	alg = &tmpl->template_aead;
alg              2631 drivers/crypto/ccree/cc_aead.c 	snprintf(alg->base.cra_name, CRYPTO_MAX_ALG_NAME, "%s", tmpl->name);
alg              2632 drivers/crypto/ccree/cc_aead.c 	snprintf(alg->base.cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s",
alg              2634 drivers/crypto/ccree/cc_aead.c 	alg->base.cra_module = THIS_MODULE;
alg              2635 drivers/crypto/ccree/cc_aead.c 	alg->base.cra_priority = CC_CRA_PRIO;
alg              2637 drivers/crypto/ccree/cc_aead.c 	alg->base.cra_ctxsize = sizeof(struct cc_aead_ctx);
alg              2638 drivers/crypto/ccree/cc_aead.c 	alg->base.cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_KERN_DRIVER_ONLY;
alg              2639 drivers/crypto/ccree/cc_aead.c 	alg->init = cc_aead_init;
alg              2640 drivers/crypto/ccree/cc_aead.c 	alg->exit = cc_aead_exit;
alg              2642 drivers/crypto/ccree/cc_aead.c 	t_alg->aead_alg = *alg;
alg              2677 drivers/crypto/ccree/cc_aead.c 	int alg;
alg              2699 drivers/crypto/ccree/cc_aead.c 	for (alg = 0; alg < ARRAY_SIZE(aead_algs); alg++) {
alg              2700 drivers/crypto/ccree/cc_aead.c 		if ((aead_algs[alg].min_hw_rev > drvdata->hw_rev) ||
alg              2701 drivers/crypto/ccree/cc_aead.c 		    !(drvdata->std_bodies & aead_algs[alg].std_body))
alg              2704 drivers/crypto/ccree/cc_aead.c 		t_alg = cc_create_aead_alg(&aead_algs[alg], dev);
alg              2708 drivers/crypto/ccree/cc_aead.c 				aead_algs[alg].driver_name);
alg                39 drivers/crypto/ccree/cc_cipher.c 	enum cc_cpp_alg alg;
alg               212 drivers/crypto/ccree/cc_cipher.c 	struct crypto_alg *alg = tfm->__crt_alg;
alg               214 drivers/crypto/ccree/cc_cipher.c 			container_of(alg, struct cc_crypto_alg,
alg               363 drivers/crypto/ccree/cc_cipher.c 			ctx_p->cpp.alg = CC_CPP_AES;
alg               365 drivers/crypto/ccree/cc_cipher.c 			ctx_p->cpp.alg = CC_CPP_SM4;
alg               368 drivers/crypto/ccree/cc_cipher.c 			ctx_p->cpp.alg, ctx_p->cpp.slot);
alg               906 drivers/crypto/ccree/cc_cipher.c 		cc_req.cpp.alg = ctx_p->cpp.alg;
alg              1639 drivers/crypto/ccree/cc_cipher.c 	struct skcipher_alg *alg;
alg              1645 drivers/crypto/ccree/cc_cipher.c 	alg = &t_alg->skcipher_alg;
alg              1647 drivers/crypto/ccree/cc_cipher.c 	memcpy(alg, &tmpl->template_skcipher, sizeof(*alg));
alg              1649 drivers/crypto/ccree/cc_cipher.c 	snprintf(alg->base.cra_name, CRYPTO_MAX_ALG_NAME, "%s", tmpl->name);
alg              1650 drivers/crypto/ccree/cc_cipher.c 	snprintf(alg->base.cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s",
alg              1652 drivers/crypto/ccree/cc_cipher.c 	alg->base.cra_module = THIS_MODULE;
alg              1653 drivers/crypto/ccree/cc_cipher.c 	alg->base.cra_priority = CC_CRA_PRIO;
alg              1654 drivers/crypto/ccree/cc_cipher.c 	alg->base.cra_blocksize = tmpl->blocksize;
alg              1655 drivers/crypto/ccree/cc_cipher.c 	alg->base.cra_alignmask = 0;
alg              1656 drivers/crypto/ccree/cc_cipher.c 	alg->base.cra_ctxsize = sizeof(struct cc_cipher_ctx);
alg              1658 drivers/crypto/ccree/cc_cipher.c 	alg->base.cra_init = cc_cipher_init;
alg              1659 drivers/crypto/ccree/cc_cipher.c 	alg->base.cra_exit = cc_cipher_exit;
alg              1660 drivers/crypto/ccree/cc_cipher.c 	alg->base.cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_KERN_DRIVER_ONLY;
alg              1694 drivers/crypto/ccree/cc_cipher.c 	int alg;
alg              1706 drivers/crypto/ccree/cc_cipher.c 	for (alg = 0; alg < ARRAY_SIZE(skcipher_algs); alg++) {
alg              1707 drivers/crypto/ccree/cc_cipher.c 		if ((skcipher_algs[alg].min_hw_rev > drvdata->hw_rev) ||
alg              1708 drivers/crypto/ccree/cc_cipher.c 		    !(drvdata->std_bodies & skcipher_algs[alg].std_body) ||
alg              1709 drivers/crypto/ccree/cc_cipher.c 		    (drvdata->sec_disabled && skcipher_algs[alg].sec_func))
alg              1712 drivers/crypto/ccree/cc_cipher.c 		dev_dbg(dev, "creating %s\n", skcipher_algs[alg].driver_name);
alg              1713 drivers/crypto/ccree/cc_cipher.c 		t_alg = cc_create_alg(&skcipher_algs[alg], dev);
alg              1717 drivers/crypto/ccree/cc_cipher.c 				skcipher_algs[alg].driver_name);
alg              1723 drivers/crypto/ccree/cc_cipher.c 			skcipher_algs[alg].driver_name);
alg               121 drivers/crypto/ccree/cc_driver.h 	enum cc_cpp_alg alg;
alg              1826 drivers/crypto/ccree/cc_hash.c 	struct crypto_alg *alg;
alg              1835 drivers/crypto/ccree/cc_hash.c 	alg = &halg->halg.base;
alg              1838 drivers/crypto/ccree/cc_hash.c 		snprintf(alg->cra_name, CRYPTO_MAX_ALG_NAME, "%s",
alg              1840 drivers/crypto/ccree/cc_hash.c 		snprintf(alg->cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s",
alg              1844 drivers/crypto/ccree/cc_hash.c 		snprintf(alg->cra_name, CRYPTO_MAX_ALG_NAME, "%s",
alg              1846 drivers/crypto/ccree/cc_hash.c 		snprintf(alg->cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s",
alg              1849 drivers/crypto/ccree/cc_hash.c 	alg->cra_module = THIS_MODULE;
alg              1850 drivers/crypto/ccree/cc_hash.c 	alg->cra_ctxsize = sizeof(struct cc_hash_ctx);
alg              1851 drivers/crypto/ccree/cc_hash.c 	alg->cra_priority = CC_CRA_PRIO;
alg              1852 drivers/crypto/ccree/cc_hash.c 	alg->cra_blocksize = template->blocksize;
alg              1853 drivers/crypto/ccree/cc_hash.c 	alg->cra_alignmask = 0;
alg              1854 drivers/crypto/ccree/cc_hash.c 	alg->cra_exit = cc_cra_exit;
alg              1856 drivers/crypto/ccree/cc_hash.c 	alg->cra_init = cc_cra_init;
alg              1857 drivers/crypto/ccree/cc_hash.c 	alg->cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_KERN_DRIVER_ONLY;
alg              2001 drivers/crypto/ccree/cc_hash.c 	int alg;
alg              2041 drivers/crypto/ccree/cc_hash.c 	for (alg = 0; alg < ARRAY_SIZE(driver_hash); alg++) {
alg              2043 drivers/crypto/ccree/cc_hash.c 		int hw_mode = driver_hash[alg].hw_mode;
alg              2046 drivers/crypto/ccree/cc_hash.c 		if ((driver_hash[alg].min_hw_rev > drvdata->hw_rev) ||
alg              2047 drivers/crypto/ccree/cc_hash.c 		    !(drvdata->std_bodies & driver_hash[alg].std_body))
alg              2050 drivers/crypto/ccree/cc_hash.c 		if (driver_hash[alg].is_mac) {
alg              2052 drivers/crypto/ccree/cc_hash.c 			t_alg = cc_alloc_hash_alg(&driver_hash[alg], dev, true);
alg              2056 drivers/crypto/ccree/cc_hash.c 					driver_hash[alg].driver_name);
alg              2064 drivers/crypto/ccree/cc_hash.c 					driver_hash[alg].driver_name);
alg              2077 drivers/crypto/ccree/cc_hash.c 		t_alg = cc_alloc_hash_alg(&driver_hash[alg], dev, false);
alg              2081 drivers/crypto/ccree/cc_hash.c 				driver_hash[alg].driver_name);
alg              2089 drivers/crypto/ccree/cc_hash.c 				driver_hash[alg].driver_name);
alg                78 drivers/crypto/ccree/cc_request_mgr.c static inline u32 cc_cpp_int_mask(enum cc_cpp_alg alg, int slot)
alg                80 drivers/crypto/ccree/cc_request_mgr.c 	alg = array_index_nospec(alg, CC_CPP_NUM_ALGS);
alg                83 drivers/crypto/ccree/cc_request_mgr.c 	return cc_cpp_int_masks[alg][slot];
alg               602 drivers/crypto/ccree/cc_request_mgr.c 				cc_req->cpp.slot, cc_req->cpp.alg);
alg               603 drivers/crypto/ccree/cc_request_mgr.c 			mask = cc_cpp_int_mask(cc_req->cpp.alg,
alg               170 drivers/crypto/chelsio/chcr_algo.c 	struct aead_alg *alg = crypto_aead_alg(aead);
alg               172 drivers/crypto/chelsio/chcr_algo.c 		container_of(alg, struct chcr_alg_template, alg.aead);
alg               371 drivers/crypto/chelsio/chcr_algo.c 	struct crypto_alg *alg = tfm->__crt_alg;
alg               373 drivers/crypto/chelsio/chcr_algo.c 		container_of(__crypto_ahash_alg(alg), struct chcr_alg_template,
alg               374 drivers/crypto/chelsio/chcr_algo.c 			     alg.hash);
alg               573 drivers/crypto/chelsio/chcr_algo.c 	struct crypto_alg *alg = tfm->__crt_alg;
alg               575 drivers/crypto/chelsio/chcr_algo.c 		container_of(alg, struct chcr_alg_template, alg.crypto);
alg              1403 drivers/crypto/chelsio/chcr_algo.c 	struct crypto_alg *alg = tfm->__crt_alg;
alg              1407 drivers/crypto/chelsio/chcr_algo.c 	ablkctx->sw_cipher = crypto_alloc_sync_skcipher(alg->cra_name, 0,
alg              1410 drivers/crypto/chelsio/chcr_algo.c 		pr_err("failed to allocate fallback for %s\n", alg->cra_name);
alg              1420 drivers/crypto/chelsio/chcr_algo.c 	struct crypto_alg *alg = tfm->__crt_alg;
alg              1430 drivers/crypto/chelsio/chcr_algo.c 		pr_err("failed to allocate fallback for %s\n", alg->cra_name);
alg              3098 drivers/crypto/chelsio/chcr_algo.c 	struct aead_alg *alg = crypto_aead_alg(tfm);
alg              3100 drivers/crypto/chelsio/chcr_algo.c 	aeadctx->sw_cipher = crypto_alloc_aead(alg->base.cra_name, 0,
alg              3707 drivers/crypto/chelsio/chcr_algo.c 		.alg.crypto = {
alg              3726 drivers/crypto/chelsio/chcr_algo.c 		.alg.crypto =   {
alg              3745 drivers/crypto/chelsio/chcr_algo.c 		.alg.crypto = {
alg              3765 drivers/crypto/chelsio/chcr_algo.c 		.alg.crypto = {
alg              3787 drivers/crypto/chelsio/chcr_algo.c 		.alg.hash = {
alg              3799 drivers/crypto/chelsio/chcr_algo.c 		.alg.hash = {
alg              3811 drivers/crypto/chelsio/chcr_algo.c 		.alg.hash = {
alg              3823 drivers/crypto/chelsio/chcr_algo.c 		.alg.hash = {
alg              3835 drivers/crypto/chelsio/chcr_algo.c 		.alg.hash = {
alg              3848 drivers/crypto/chelsio/chcr_algo.c 		.alg.hash = {
alg              3860 drivers/crypto/chelsio/chcr_algo.c 		.alg.hash = {
alg              3872 drivers/crypto/chelsio/chcr_algo.c 		.alg.hash = {
alg              3884 drivers/crypto/chelsio/chcr_algo.c 		.alg.hash = {
alg              3896 drivers/crypto/chelsio/chcr_algo.c 		.alg.hash = {
alg              3909 drivers/crypto/chelsio/chcr_algo.c 		.alg.aead = {
alg              3928 drivers/crypto/chelsio/chcr_algo.c 		.alg.aead = {
alg              3948 drivers/crypto/chelsio/chcr_algo.c 		.alg.aead = {
alg              3967 drivers/crypto/chelsio/chcr_algo.c 		.alg.aead = {
alg              3986 drivers/crypto/chelsio/chcr_algo.c 		.alg.aead = {
alg              4007 drivers/crypto/chelsio/chcr_algo.c 		.alg.aead = {
alg              4029 drivers/crypto/chelsio/chcr_algo.c 		.alg.aead = {
alg              4049 drivers/crypto/chelsio/chcr_algo.c 		.alg.aead = {
alg              4070 drivers/crypto/chelsio/chcr_algo.c 		.alg.aead = {
alg              4091 drivers/crypto/chelsio/chcr_algo.c 		.alg.aead = {
alg              4112 drivers/crypto/chelsio/chcr_algo.c 		.alg.aead = {
alg              4133 drivers/crypto/chelsio/chcr_algo.c 		.alg.aead = {
alg              4155 drivers/crypto/chelsio/chcr_algo.c 		.alg.aead = {
alg              4175 drivers/crypto/chelsio/chcr_algo.c 		.alg.aead = {
alg              4196 drivers/crypto/chelsio/chcr_algo.c 		.alg.aead = {
alg              4217 drivers/crypto/chelsio/chcr_algo.c 		.alg.aead = {
alg              4250 drivers/crypto/chelsio/chcr_algo.c 						&driver_algs[i].alg.crypto);
alg              4255 drivers/crypto/chelsio/chcr_algo.c 						&driver_algs[i].alg.aead);
alg              4260 drivers/crypto/chelsio/chcr_algo.c 						&driver_algs[i].alg.hash);
alg              4287 drivers/crypto/chelsio/chcr_algo.c 			driver_algs[i].alg.crypto.cra_priority =
alg              4289 drivers/crypto/chelsio/chcr_algo.c 			driver_algs[i].alg.crypto.cra_module = THIS_MODULE;
alg              4290 drivers/crypto/chelsio/chcr_algo.c 			driver_algs[i].alg.crypto.cra_flags =
alg              4293 drivers/crypto/chelsio/chcr_algo.c 			driver_algs[i].alg.crypto.cra_ctxsize =
alg              4296 drivers/crypto/chelsio/chcr_algo.c 			driver_algs[i].alg.crypto.cra_alignmask = 0;
alg              4297 drivers/crypto/chelsio/chcr_algo.c 			driver_algs[i].alg.crypto.cra_type =
alg              4299 drivers/crypto/chelsio/chcr_algo.c 			err = crypto_register_alg(&driver_algs[i].alg.crypto);
alg              4300 drivers/crypto/chelsio/chcr_algo.c 			name = driver_algs[i].alg.crypto.cra_driver_name;
alg              4303 drivers/crypto/chelsio/chcr_algo.c 			driver_algs[i].alg.aead.base.cra_flags =
alg              4305 drivers/crypto/chelsio/chcr_algo.c 			driver_algs[i].alg.aead.encrypt = chcr_aead_encrypt;
alg              4306 drivers/crypto/chelsio/chcr_algo.c 			driver_algs[i].alg.aead.decrypt = chcr_aead_decrypt;
alg              4307 drivers/crypto/chelsio/chcr_algo.c 			driver_algs[i].alg.aead.init = chcr_aead_cra_init;
alg              4308 drivers/crypto/chelsio/chcr_algo.c 			driver_algs[i].alg.aead.exit = chcr_aead_cra_exit;
alg              4309 drivers/crypto/chelsio/chcr_algo.c 			driver_algs[i].alg.aead.base.cra_module = THIS_MODULE;
alg              4310 drivers/crypto/chelsio/chcr_algo.c 			err = crypto_register_aead(&driver_algs[i].alg.aead);
alg              4311 drivers/crypto/chelsio/chcr_algo.c 			name = driver_algs[i].alg.aead.base.cra_driver_name;
alg              4314 drivers/crypto/chelsio/chcr_algo.c 			a_hash = &driver_algs[i].alg.hash;
alg              4339 drivers/crypto/chelsio/chcr_algo.c 			err = crypto_register_ahash(&driver_algs[i].alg.hash);
alg              4340 drivers/crypto/chelsio/chcr_algo.c 			ai = driver_algs[i].alg.hash.halg.base;
alg               308 drivers/crypto/chelsio/chcr_crypto.h 	} alg;
alg               599 drivers/crypto/hifn_795x.c 	struct crypto_alg	alg;
alg               626 drivers/crypto/hifn_795x.c #define crypto_alg_to_hifn(a)	container_of(a, struct hifn_crypto_alg, alg)
alg              2371 drivers/crypto/hifn_795x.c 	struct crypto_alg *alg = tfm->__crt_alg;
alg              2372 drivers/crypto/hifn_795x.c 	struct hifn_crypto_alg *ha = crypto_alg_to_hifn(alg);
alg              2382 drivers/crypto/hifn_795x.c 	struct hifn_crypto_alg *alg;
alg              2385 drivers/crypto/hifn_795x.c 	alg = kzalloc(sizeof(*alg), GFP_KERNEL);
alg              2386 drivers/crypto/hifn_795x.c 	if (!alg)
alg              2389 drivers/crypto/hifn_795x.c 	snprintf(alg->alg.cra_name, CRYPTO_MAX_ALG_NAME, "%s", t->name);
alg              2390 drivers/crypto/hifn_795x.c 	snprintf(alg->alg.cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s-%s",
alg              2393 drivers/crypto/hifn_795x.c 	alg->alg.cra_priority = 300;
alg              2394 drivers/crypto/hifn_795x.c 	alg->alg.cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER |
alg              2396 drivers/crypto/hifn_795x.c 	alg->alg.cra_blocksize = t->bsize;
alg              2397 drivers/crypto/hifn_795x.c 	alg->alg.cra_ctxsize = sizeof(struct hifn_context);
alg              2398 drivers/crypto/hifn_795x.c 	alg->alg.cra_alignmask = 0;
alg              2399 drivers/crypto/hifn_795x.c 	alg->alg.cra_type = &crypto_ablkcipher_type;
alg              2400 drivers/crypto/hifn_795x.c 	alg->alg.cra_module = THIS_MODULE;
alg              2401 drivers/crypto/hifn_795x.c 	alg->alg.cra_u.ablkcipher = t->ablkcipher;
alg              2402 drivers/crypto/hifn_795x.c 	alg->alg.cra_init = hifn_cra_init;
alg              2404 drivers/crypto/hifn_795x.c 	alg->dev = dev;
alg              2406 drivers/crypto/hifn_795x.c 	list_add_tail(&alg->entry, &dev->alg_list);
alg              2408 drivers/crypto/hifn_795x.c 	err = crypto_register_alg(&alg->alg);
alg              2410 drivers/crypto/hifn_795x.c 		list_del(&alg->entry);
alg              2411 drivers/crypto/hifn_795x.c 		kfree(alg);
alg              2423 drivers/crypto/hifn_795x.c 		crypto_unregister_alg(&a->alg);
alg               128 drivers/crypto/hisilicon/sec/sec_algs.c 					   enum sec_cipher_alg alg)
alg               130 drivers/crypto/hisilicon/sec/sec_algs.c 	const struct sec_c_alg_cfg *cfg = &sec_c_alg_cfgs[alg];
alg               145 drivers/crypto/hisilicon/sec/sec_algs.c 					  enum sec_cipher_alg alg)
alg               150 drivers/crypto/hisilicon/sec/sec_algs.c 	ctx->cipher_alg = alg;
alg               228 drivers/crypto/hisilicon/sec/sec_algs.c 				   enum sec_cipher_alg alg)
alg               247 drivers/crypto/hisilicon/sec/sec_algs.c 	sec_alg_skcipher_init_context(tfm, key, keylen, alg);
alg               255 drivers/crypto/hisilicon/sec/sec_algs.c 	enum sec_cipher_alg alg;
alg               259 drivers/crypto/hisilicon/sec/sec_algs.c 		alg = SEC_C_AES_ECB_128;
alg               262 drivers/crypto/hisilicon/sec/sec_algs.c 		alg = SEC_C_AES_ECB_192;
alg               265 drivers/crypto/hisilicon/sec/sec_algs.c 		alg = SEC_C_AES_ECB_256;
alg               271 drivers/crypto/hisilicon/sec/sec_algs.c 	return sec_alg_skcipher_setkey(tfm, key, keylen, alg);
alg               277 drivers/crypto/hisilicon/sec/sec_algs.c 	enum sec_cipher_alg alg;
alg               281 drivers/crypto/hisilicon/sec/sec_algs.c 		alg = SEC_C_AES_CBC_128;
alg               284 drivers/crypto/hisilicon/sec/sec_algs.c 		alg = SEC_C_AES_CBC_192;
alg               287 drivers/crypto/hisilicon/sec/sec_algs.c 		alg = SEC_C_AES_CBC_256;
alg               293 drivers/crypto/hisilicon/sec/sec_algs.c 	return sec_alg_skcipher_setkey(tfm, key, keylen, alg);
alg               299 drivers/crypto/hisilicon/sec/sec_algs.c 	enum sec_cipher_alg alg;
alg               303 drivers/crypto/hisilicon/sec/sec_algs.c 		alg = SEC_C_AES_CTR_128;
alg               306 drivers/crypto/hisilicon/sec/sec_algs.c 		alg = SEC_C_AES_CTR_192;
alg               309 drivers/crypto/hisilicon/sec/sec_algs.c 		alg = SEC_C_AES_CTR_256;
alg               315 drivers/crypto/hisilicon/sec/sec_algs.c 	return sec_alg_skcipher_setkey(tfm, key, keylen, alg);
alg               321 drivers/crypto/hisilicon/sec/sec_algs.c 	enum sec_cipher_alg alg;
alg               330 drivers/crypto/hisilicon/sec/sec_algs.c 		alg = SEC_C_AES_XTS_128;
alg               333 drivers/crypto/hisilicon/sec/sec_algs.c 		alg = SEC_C_AES_XTS_256;
alg               339 drivers/crypto/hisilicon/sec/sec_algs.c 	return sec_alg_skcipher_setkey(tfm, key, keylen, alg);
alg              1190 drivers/crypto/inside-secure/safexcel.c 			ret = crypto_register_skcipher(&safexcel_algs[i]->alg.skcipher);
alg              1192 drivers/crypto/inside-secure/safexcel.c 			ret = crypto_register_aead(&safexcel_algs[i]->alg.aead);
alg              1194 drivers/crypto/inside-secure/safexcel.c 			ret = crypto_register_ahash(&safexcel_algs[i]->alg.ahash);
alg              1211 drivers/crypto/inside-secure/safexcel.c 			crypto_unregister_skcipher(&safexcel_algs[j]->alg.skcipher);
alg              1213 drivers/crypto/inside-secure/safexcel.c 			crypto_unregister_aead(&safexcel_algs[j]->alg.aead);
alg              1215 drivers/crypto/inside-secure/safexcel.c 			crypto_unregister_ahash(&safexcel_algs[j]->alg.ahash);
alg              1233 drivers/crypto/inside-secure/safexcel.c 			crypto_unregister_skcipher(&safexcel_algs[i]->alg.skcipher);
alg              1235 drivers/crypto/inside-secure/safexcel.c 			crypto_unregister_aead(&safexcel_algs[i]->alg.aead);
alg              1237 drivers/crypto/inside-secure/safexcel.c 			crypto_unregister_ahash(&safexcel_algs[i]->alg.ahash);
alg               771 drivers/crypto/inside-secure/safexcel.h 	} alg;
alg               817 drivers/crypto/inside-secure/safexcel.h int safexcel_hmac_setkey(const char *alg, const u8 *key, unsigned int keylen,
alg                43 drivers/crypto/inside-secure/safexcel_cipher.c 	enum safexcel_cipher_alg alg;
alg               106 drivers/crypto/inside-secure/safexcel_cipher.c 		switch (ctx->alg) {
alg               330 drivers/crypto/inside-secure/safexcel_cipher.c 	switch (ctx->alg) {
alg               458 drivers/crypto/inside-secure/safexcel_cipher.c 	if (ctx->alg == SAFEXCEL_DES) {
alg               461 drivers/crypto/inside-secure/safexcel_cipher.c 	} else if (ctx->alg == SAFEXCEL_3DES) {
alg               464 drivers/crypto/inside-secure/safexcel_cipher.c 	} else if (ctx->alg == SAFEXCEL_AES) {
alg              1067 drivers/crypto/inside-secure/safexcel_cipher.c 			     alg.skcipher.base);
alg              1138 drivers/crypto/inside-secure/safexcel_cipher.c 	ctx->alg  = SAFEXCEL_AES;
alg              1146 drivers/crypto/inside-secure/safexcel_cipher.c 	.alg.skcipher = {
alg              1173 drivers/crypto/inside-secure/safexcel_cipher.c 	ctx->alg  = SAFEXCEL_AES;
alg              1181 drivers/crypto/inside-secure/safexcel_cipher.c 	.alg.skcipher = {
alg              1209 drivers/crypto/inside-secure/safexcel_cipher.c 	ctx->alg  = SAFEXCEL_AES;
alg              1217 drivers/crypto/inside-secure/safexcel_cipher.c 	.alg.skcipher = {
alg              1245 drivers/crypto/inside-secure/safexcel_cipher.c 	ctx->alg  = SAFEXCEL_AES;
alg              1253 drivers/crypto/inside-secure/safexcel_cipher.c 	.alg.skcipher = {
alg              1319 drivers/crypto/inside-secure/safexcel_cipher.c 	ctx->alg  = SAFEXCEL_AES;
alg              1327 drivers/crypto/inside-secure/safexcel_cipher.c 	.alg.skcipher = {
alg              1377 drivers/crypto/inside-secure/safexcel_cipher.c 	ctx->alg  = SAFEXCEL_DES;
alg              1385 drivers/crypto/inside-secure/safexcel_cipher.c 	.alg.skcipher = {
alg              1413 drivers/crypto/inside-secure/safexcel_cipher.c 	ctx->alg  = SAFEXCEL_DES;
alg              1421 drivers/crypto/inside-secure/safexcel_cipher.c 	.alg.skcipher = {
alg              1471 drivers/crypto/inside-secure/safexcel_cipher.c 	ctx->alg  = SAFEXCEL_3DES;
alg              1479 drivers/crypto/inside-secure/safexcel_cipher.c 	.alg.skcipher = {
alg              1507 drivers/crypto/inside-secure/safexcel_cipher.c 	ctx->alg  = SAFEXCEL_3DES;
alg              1515 drivers/crypto/inside-secure/safexcel_cipher.c 	.alg.skcipher = {
alg              1556 drivers/crypto/inside-secure/safexcel_cipher.c 			     alg.aead.base);
alg              1563 drivers/crypto/inside-secure/safexcel_cipher.c 	ctx->alg  = SAFEXCEL_AES; /* default */
alg              1584 drivers/crypto/inside-secure/safexcel_cipher.c 	.alg.aead = {
alg              1619 drivers/crypto/inside-secure/safexcel_cipher.c 	.alg.aead = {
alg              1654 drivers/crypto/inside-secure/safexcel_cipher.c 	.alg.aead = {
alg              1689 drivers/crypto/inside-secure/safexcel_cipher.c 	.alg.aead = {
alg              1724 drivers/crypto/inside-secure/safexcel_cipher.c 	.alg.aead = {
alg              1751 drivers/crypto/inside-secure/safexcel_cipher.c 	ctx->alg = SAFEXCEL_3DES; /* override default */
alg              1758 drivers/crypto/inside-secure/safexcel_cipher.c 	.alg.aead = {
alg              1792 drivers/crypto/inside-secure/safexcel_cipher.c 	.alg.aead = {
alg              1826 drivers/crypto/inside-secure/safexcel_cipher.c 	.alg.aead = {
alg              1860 drivers/crypto/inside-secure/safexcel_cipher.c 	.alg.aead = {
alg              1894 drivers/crypto/inside-secure/safexcel_cipher.c 	.alg.aead = {
alg              1928 drivers/crypto/inside-secure/safexcel_cipher.c 	.alg.aead = {
alg              2017 drivers/crypto/inside-secure/safexcel_cipher.c 	ctx->alg  = SAFEXCEL_AES;
alg              2042 drivers/crypto/inside-secure/safexcel_cipher.c 	.alg.skcipher = {
alg              2161 drivers/crypto/inside-secure/safexcel_cipher.c 	.alg.aead = {
alg              2284 drivers/crypto/inside-secure/safexcel_cipher.c 	.alg.aead = {
alg                21 drivers/crypto/inside-secure/safexcel_hash.c 	u32 alg;
alg                85 drivers/crypto/inside-secure/safexcel_hash.c 	cdesc->control_data.control0 |= ctx->alg;
alg               676 drivers/crypto/inside-secure/safexcel_hash.c 		if (ctx->alg == CONTEXT_CONTROL_CRYPTO_ALG_MD5)
alg               679 drivers/crypto/inside-secure/safexcel_hash.c 		else if (ctx->alg == CONTEXT_CONTROL_CRYPTO_ALG_SHA1)
alg               682 drivers/crypto/inside-secure/safexcel_hash.c 		else if (ctx->alg == CONTEXT_CONTROL_CRYPTO_ALG_SHA224)
alg               685 drivers/crypto/inside-secure/safexcel_hash.c 		else if (ctx->alg == CONTEXT_CONTROL_CRYPTO_ALG_SHA256)
alg               688 drivers/crypto/inside-secure/safexcel_hash.c 		else if (ctx->alg == CONTEXT_CONTROL_CRYPTO_ALG_SHA384)
alg               691 drivers/crypto/inside-secure/safexcel_hash.c 		else if (ctx->alg == CONTEXT_CONTROL_CRYPTO_ALG_SHA512)
alg               790 drivers/crypto/inside-secure/safexcel_hash.c 			     struct safexcel_alg_template, alg.ahash);
alg               808 drivers/crypto/inside-secure/safexcel_hash.c 	ctx->alg = CONTEXT_CONTROL_CRYPTO_ALG_SHA1;
alg               849 drivers/crypto/inside-secure/safexcel_hash.c 	.alg.ahash = {
alg               889 drivers/crypto/inside-secure/safexcel_hash.c 	ctx->alg = CONTEXT_CONTROL_CRYPTO_ALG_SHA1;
alg              1006 drivers/crypto/inside-secure/safexcel_hash.c int safexcel_hmac_setkey(const char *alg, const u8 *key, unsigned int keylen,
alg              1015 drivers/crypto/inside-secure/safexcel_hash.c 	tfm = crypto_alloc_ahash(alg, 0, 0);
alg              1057 drivers/crypto/inside-secure/safexcel_hash.c 				    unsigned int keylen, const char *alg,
alg              1065 drivers/crypto/inside-secure/safexcel_hash.c 	ret = safexcel_hmac_setkey(alg, key, keylen, &istate, &ostate);
alg              1090 drivers/crypto/inside-secure/safexcel_hash.c 	.alg.ahash = {
alg              1125 drivers/crypto/inside-secure/safexcel_hash.c 	ctx->alg = CONTEXT_CONTROL_CRYPTO_ALG_SHA256;
alg              1146 drivers/crypto/inside-secure/safexcel_hash.c 	.alg.ahash = {
alg              1180 drivers/crypto/inside-secure/safexcel_hash.c 	ctx->alg = CONTEXT_CONTROL_CRYPTO_ALG_SHA224;
alg              1201 drivers/crypto/inside-secure/safexcel_hash.c 	.alg.ahash = {
alg              1248 drivers/crypto/inside-secure/safexcel_hash.c 	ctx->alg = CONTEXT_CONTROL_CRYPTO_ALG_SHA224;
alg              1270 drivers/crypto/inside-secure/safexcel_hash.c 	.alg.ahash = {
alg              1318 drivers/crypto/inside-secure/safexcel_hash.c 	ctx->alg = CONTEXT_CONTROL_CRYPTO_ALG_SHA256;
alg              1340 drivers/crypto/inside-secure/safexcel_hash.c 	.alg.ahash = {
alg              1375 drivers/crypto/inside-secure/safexcel_hash.c 	ctx->alg = CONTEXT_CONTROL_CRYPTO_ALG_SHA512;
alg              1396 drivers/crypto/inside-secure/safexcel_hash.c 	.alg.ahash = {
alg              1430 drivers/crypto/inside-secure/safexcel_hash.c 	ctx->alg = CONTEXT_CONTROL_CRYPTO_ALG_SHA384;
alg              1451 drivers/crypto/inside-secure/safexcel_hash.c 	.alg.ahash = {
alg              1498 drivers/crypto/inside-secure/safexcel_hash.c 	ctx->alg = CONTEXT_CONTROL_CRYPTO_ALG_SHA512;
alg              1520 drivers/crypto/inside-secure/safexcel_hash.c 	.alg.ahash = {
alg              1568 drivers/crypto/inside-secure/safexcel_hash.c 	ctx->alg = CONTEXT_CONTROL_CRYPTO_ALG_SHA384;
alg              1590 drivers/crypto/inside-secure/safexcel_hash.c 	.alg.ahash = {
alg              1625 drivers/crypto/inside-secure/safexcel_hash.c 	ctx->alg = CONTEXT_CONTROL_CRYPTO_ALG_MD5;
alg              1646 drivers/crypto/inside-secure/safexcel_hash.c 	.alg.ahash = {
alg              1686 drivers/crypto/inside-secure/safexcel_hash.c 	ctx->alg = CONTEXT_CONTROL_CRYPTO_ALG_MD5;
alg              1716 drivers/crypto/inside-secure/safexcel_hash.c 	.alg.ahash = {
alg                96 drivers/crypto/mxs-dcp.c 	uint32_t			alg;
alg               575 drivers/crypto/mxs-dcp.c 	desc->control1 = actx->alg;
alg               589 drivers/crypto/mxs-dcp.c 			(actx->alg == MXS_DCP_CONTROL1_HASH_SELECT_SHA1) ?
alg               738 drivers/crypto/mxs-dcp.c 		actx->alg = MXS_DCP_CONTROL1_HASH_SELECT_SHA1;
alg               740 drivers/crypto/mxs-dcp.c 		actx->alg = MXS_DCP_CONTROL1_HASH_SELECT_SHA256;
alg               256 drivers/crypto/n2_core.c 	struct ahash_alg	alg;
alg               261 drivers/crypto/n2_core.c 	struct crypto_alg *alg = tfm->__crt_alg;
alg               264 drivers/crypto/n2_core.c 	ahash_alg = container_of(alg, struct ahash_alg, halg.base);
alg               266 drivers/crypto/n2_core.c 	return container_of(ahash_alg, struct n2_ahash_alg, alg);
alg               276 drivers/crypto/n2_core.c 	struct crypto_alg *alg = tfm->__crt_alg;
alg               279 drivers/crypto/n2_core.c 	ahash_alg = container_of(alg, struct ahash_alg, halg.base);
alg               281 drivers/crypto/n2_core.c 	return container_of(ahash_alg, struct n2_hmac_alg, derived.alg);
alg               714 drivers/crypto/n2_core.c 	struct crypto_alg	alg;
alg               719 drivers/crypto/n2_core.c 	struct crypto_alg *alg = tfm->__crt_alg;
alg               721 drivers/crypto/n2_core.c 	return container_of(alg, struct n2_cipher_alg, alg);
alg              1348 drivers/crypto/n2_core.c 	struct n2_ahash_alg *alg, *alg_tmp;
alg              1352 drivers/crypto/n2_core.c 		crypto_unregister_alg(&cipher->alg);
alg              1357 drivers/crypto/n2_core.c 		crypto_unregister_ahash(&hmac->derived.alg);
alg              1361 drivers/crypto/n2_core.c 	list_for_each_entry_safe(alg, alg_tmp, &ahash_algs, entry) {
alg              1362 drivers/crypto/n2_core.c 		crypto_unregister_ahash(&alg->alg);
alg              1363 drivers/crypto/n2_core.c 		list_del(&alg->entry);
alg              1364 drivers/crypto/n2_core.c 		kfree(alg);
alg              1377 drivers/crypto/n2_core.c 	struct crypto_alg *alg;
alg              1383 drivers/crypto/n2_core.c 	alg = &p->alg;
alg              1385 drivers/crypto/n2_core.c 	snprintf(alg->cra_name, CRYPTO_MAX_ALG_NAME, "%s", tmpl->name);
alg              1386 drivers/crypto/n2_core.c 	snprintf(alg->cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s-n2", tmpl->drv_name);
alg              1387 drivers/crypto/n2_core.c 	alg->cra_priority = N2_CRA_PRIORITY;
alg              1388 drivers/crypto/n2_core.c 	alg->cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER |
alg              1390 drivers/crypto/n2_core.c 	alg->cra_blocksize = tmpl->block_size;
alg              1392 drivers/crypto/n2_core.c 	alg->cra_ctxsize = sizeof(struct n2_cipher_context);
alg              1393 drivers/crypto/n2_core.c 	alg->cra_type = &crypto_ablkcipher_type;
alg              1394 drivers/crypto/n2_core.c 	alg->cra_u.ablkcipher = tmpl->ablkcipher;
alg              1395 drivers/crypto/n2_core.c 	alg->cra_init = n2_cipher_cra_init;
alg              1396 drivers/crypto/n2_core.c 	alg->cra_module = THIS_MODULE;
alg              1399 drivers/crypto/n2_core.c 	err = crypto_register_alg(alg);
alg              1401 drivers/crypto/n2_core.c 		pr_err("%s alg registration failed\n", alg->cra_name);
alg              1405 drivers/crypto/n2_core.c 		pr_info("%s alg registered\n", alg->cra_name);
alg              1420 drivers/crypto/n2_core.c 	p->child_alg = n2ahash->alg.halg.base.cra_name;
alg              1424 drivers/crypto/n2_core.c 	ahash = &p->derived.alg;
alg              1466 drivers/crypto/n2_core.c 	ahash = &p->alg;
alg               514 drivers/crypto/nx/nx.c static int nx_register_alg(struct crypto_alg *alg, u32 fc, u32 mode)
alg               517 drivers/crypto/nx/nx.c 	       crypto_register_alg(alg) : 0;
alg               520 drivers/crypto/nx/nx.c static int nx_register_aead(struct aead_alg *alg, u32 fc, u32 mode)
alg               523 drivers/crypto/nx/nx.c 	       crypto_register_aead(alg) : 0;
alg               526 drivers/crypto/nx/nx.c static int nx_register_shash(struct shash_alg *alg, u32 fc, u32 mode, int slot)
alg               531 drivers/crypto/nx/nx.c 	       crypto_register_shash(alg) : 0;
alg               534 drivers/crypto/nx/nx.c static void nx_unregister_alg(struct crypto_alg *alg, u32 fc, u32 mode)
alg               537 drivers/crypto/nx/nx.c 		crypto_unregister_alg(alg);
alg               540 drivers/crypto/nx/nx.c static void nx_unregister_aead(struct aead_alg *alg, u32 fc, u32 mode)
alg               543 drivers/crypto/nx/nx.c 		crypto_unregister_aead(alg);
alg               546 drivers/crypto/nx/nx.c static void nx_unregister_shash(struct shash_alg *alg, u32 fc, u32 mode,
alg               551 drivers/crypto/nx/nx.c 		crypto_unregister_shash(alg);
alg              2167 drivers/crypto/omap-sham.c 			struct ahash_alg *alg;
alg              2169 drivers/crypto/omap-sham.c 			alg = &dd->pdata->algs_info[i].algs_list[j];
alg              2170 drivers/crypto/omap-sham.c 			alg->export = omap_sham_export;
alg              2171 drivers/crypto/omap-sham.c 			alg->import = omap_sham_import;
alg              2172 drivers/crypto/omap-sham.c 			alg->halg.statesize = sizeof(struct omap_sham_reqctx) +
alg              2174 drivers/crypto/omap-sham.c 			err = crypto_register_ahash(alg);
alg                94 drivers/crypto/picoxcell_crypto.c 	struct aead_alg			alg;
alg               137 drivers/crypto/picoxcell_crypto.c 	struct crypto_alg		alg;
alg               176 drivers/crypto/picoxcell_crypto.c static inline struct spacc_alg *to_spacc_alg(struct crypto_alg *alg)
alg               178 drivers/crypto/picoxcell_crypto.c 	return alg ? container_of(alg, struct spacc_alg, alg) : NULL;
alg               181 drivers/crypto/picoxcell_crypto.c static inline struct spacc_aead *to_spacc_aead(struct aead_alg *alg)
alg               183 drivers/crypto/picoxcell_crypto.c 	return container_of(alg, struct spacc_aead, alg);
alg               514 drivers/crypto/picoxcell_crypto.c 	struct aead_alg *alg = crypto_aead_alg(aead);
alg               515 drivers/crypto/picoxcell_crypto.c 	struct spacc_aead *spacc_alg = to_spacc_aead(alg);
alg               562 drivers/crypto/picoxcell_crypto.c 	struct aead_alg *alg = crypto_aead_alg(aead);
alg               563 drivers/crypto/picoxcell_crypto.c 	struct spacc_aead *spacc_alg = to_spacc_aead(alg);
alg               633 drivers/crypto/picoxcell_crypto.c 	struct aead_alg *alg = crypto_aead_alg(aead);
alg               634 drivers/crypto/picoxcell_crypto.c 	struct spacc_engine *engine = to_spacc_aead(alg)->engine;
alg               679 drivers/crypto/picoxcell_crypto.c 	struct spacc_aead *alg = to_spacc_aead(crypto_aead_alg(aead));
alg               681 drivers/crypto/picoxcell_crypto.c 	return spacc_aead_setup(req, alg->type, 1);
alg               687 drivers/crypto/picoxcell_crypto.c 	struct spacc_aead  *alg = to_spacc_aead(crypto_aead_alg(aead));
alg               689 drivers/crypto/picoxcell_crypto.c 	return spacc_aead_setup(req, alg->type, 0);
alg               699 drivers/crypto/picoxcell_crypto.c 	struct aead_alg *alg = crypto_aead_alg(tfm);
alg               700 drivers/crypto/picoxcell_crypto.c 	struct spacc_aead *spacc_alg = to_spacc_aead(alg);
alg               705 drivers/crypto/picoxcell_crypto.c 	ctx->sw_cipher = crypto_alloc_aead(alg->base.cra_name, 0,
alg               849 drivers/crypto/picoxcell_crypto.c 	struct crypto_alg *alg = req->req->tfm->__crt_alg;
alg               850 drivers/crypto/picoxcell_crypto.c 	struct spacc_alg *spacc_alg = to_spacc_alg(alg);
alg               881 drivers/crypto/picoxcell_crypto.c 	struct crypto_alg *alg = req->req->tfm->__crt_alg;
alg               882 drivers/crypto/picoxcell_crypto.c 	struct spacc_alg *spacc_alg = to_spacc_alg(alg);
alg               887 drivers/crypto/picoxcell_crypto.c 		ctx->key_len, ablk_req->info, alg->cra_ablkcipher.ivsize,
alg               938 drivers/crypto/picoxcell_crypto.c 	struct crypto_alg *alg = req->base.tfm->__crt_alg;
alg               939 drivers/crypto/picoxcell_crypto.c 	struct spacc_engine *engine = to_spacc_alg(alg)->engine;
alg              1015 drivers/crypto/picoxcell_crypto.c 	struct crypto_alg *alg = tfm->__crt_alg;
alg              1016 drivers/crypto/picoxcell_crypto.c 	struct spacc_alg *spacc_alg = to_spacc_alg(alg);
alg              1021 drivers/crypto/picoxcell_crypto.c 	if (alg->cra_flags & CRYPTO_ALG_NEED_FALLBACK) {
alg              1023 drivers/crypto/picoxcell_crypto.c 			alg->cra_name, 0, CRYPTO_ALG_NEED_FALLBACK);
alg              1026 drivers/crypto/picoxcell_crypto.c 				 alg->cra_name);
alg              1049 drivers/crypto/picoxcell_crypto.c 	struct spacc_alg *alg = to_spacc_alg(tfm->__crt_alg);
alg              1051 drivers/crypto/picoxcell_crypto.c 	return spacc_ablk_setup(req, alg->type, 1);
alg              1058 drivers/crypto/picoxcell_crypto.c 	struct spacc_alg *alg = to_spacc_alg(tfm->__crt_alg);
alg              1060 drivers/crypto/picoxcell_crypto.c 	return spacc_ablk_setup(req, alg->type, 0);
alg              1137 drivers/crypto/picoxcell_crypto.c 	struct crypto_alg *alg = req->req->tfm->__crt_alg;
alg              1139 drivers/crypto/picoxcell_crypto.c 	if (CRYPTO_ALG_TYPE_AEAD == (CRYPTO_ALG_TYPE_MASK & alg->cra_flags))
alg              1235 drivers/crypto/picoxcell_crypto.c 		.alg = {
alg              1263 drivers/crypto/picoxcell_crypto.c 		.alg = {
alg              1289 drivers/crypto/picoxcell_crypto.c 		.alg = {
alg              1316 drivers/crypto/picoxcell_crypto.c 		.alg = {
alg              1342 drivers/crypto/picoxcell_crypto.c 		.alg = {
alg              1369 drivers/crypto/picoxcell_crypto.c 		.alg = {
alg              1401 drivers/crypto/picoxcell_crypto.c 		.alg = {
alg              1431 drivers/crypto/picoxcell_crypto.c 		.alg = {
alg              1461 drivers/crypto/picoxcell_crypto.c 		.alg = {
alg              1491 drivers/crypto/picoxcell_crypto.c 		.alg = {
alg              1521 drivers/crypto/picoxcell_crypto.c 		.alg = {
alg              1552 drivers/crypto/picoxcell_crypto.c 		.alg = {
alg              1583 drivers/crypto/picoxcell_crypto.c 		.alg = {
alg              1735 drivers/crypto/picoxcell_crypto.c 		err = crypto_register_alg(&engine->algs[i].alg);
alg              1743 drivers/crypto/picoxcell_crypto.c 				engine->algs[i].alg.cra_name);
alg              1746 drivers/crypto/picoxcell_crypto.c 				engine->algs[i].alg.cra_name);
alg              1752 drivers/crypto/picoxcell_crypto.c 		err = crypto_register_aead(&engine->aeads[i].alg);
alg              1760 drivers/crypto/picoxcell_crypto.c 				engine->aeads[i].alg.base.cra_name);
alg              1763 drivers/crypto/picoxcell_crypto.c 				engine->aeads[i].alg.base.cra_name);
alg              1782 drivers/crypto/picoxcell_crypto.c 	struct spacc_alg *alg, *next;
alg              1790 drivers/crypto/picoxcell_crypto.c 		crypto_unregister_aead(&aead->alg);
alg              1793 drivers/crypto/picoxcell_crypto.c 	list_for_each_entry_safe(alg, next, &engine->registered_algs, entry) {
alg              1794 drivers/crypto/picoxcell_crypto.c 		list_del(&alg->entry);
alg              1795 drivers/crypto/picoxcell_crypto.c 		crypto_unregister_alg(&alg->alg);
alg                66 drivers/crypto/qat/qat_common/qat_algs.c #define QAT_AES_HW_CONFIG_ENC(alg, mode) \
alg                67 drivers/crypto/qat/qat_common/qat_algs.c 	ICP_QAT_HW_CIPHER_CONFIG_BUILD(mode, alg, \
alg                71 drivers/crypto/qat/qat_common/qat_algs.c #define QAT_AES_HW_CONFIG_DEC(alg, mode) \
alg                72 drivers/crypto/qat/qat_common/qat_algs.c 	ICP_QAT_HW_CIPHER_CONFIG_BUILD(mode, alg, \
alg               294 drivers/crypto/qat/qat_common/qat_algs.c 					 int alg,
alg               313 drivers/crypto/qat/qat_common/qat_algs.c 	cipher->aes.cipher_config.val = QAT_AES_HW_CONFIG_ENC(alg, mode);
alg               375 drivers/crypto/qat/qat_common/qat_algs.c 					 int alg,
alg               399 drivers/crypto/qat/qat_common/qat_algs.c 	cipher->aes.cipher_config.val = QAT_AES_HW_CONFIG_DEC(alg, mode);
alg               489 drivers/crypto/qat/qat_common/qat_algs.c 					int alg, const uint8_t *key,
alg               498 drivers/crypto/qat/qat_common/qat_algs.c 	enc_cd->aes.cipher_config.val = QAT_AES_HW_CONFIG_ENC(alg, mode);
alg               502 drivers/crypto/qat/qat_common/qat_algs.c 					int alg, const uint8_t *key,
alg               514 drivers/crypto/qat/qat_common/qat_algs.c 					QAT_AES_HW_CONFIG_DEC(alg, mode);
alg               517 drivers/crypto/qat/qat_common/qat_algs.c 					QAT_AES_HW_CONFIG_ENC(alg, mode);
alg               520 drivers/crypto/qat/qat_common/qat_algs.c static int qat_alg_validate_key(int key_len, int *alg, int mode)
alg               525 drivers/crypto/qat/qat_common/qat_algs.c 			*alg = ICP_QAT_HW_CIPHER_ALGO_AES128;
alg               528 drivers/crypto/qat/qat_common/qat_algs.c 			*alg = ICP_QAT_HW_CIPHER_ALGO_AES192;
alg               531 drivers/crypto/qat/qat_common/qat_algs.c 			*alg = ICP_QAT_HW_CIPHER_ALGO_AES256;
alg               539 drivers/crypto/qat/qat_common/qat_algs.c 			*alg = ICP_QAT_HW_CIPHER_ALGO_AES128;
alg               542 drivers/crypto/qat/qat_common/qat_algs.c 			*alg = ICP_QAT_HW_CIPHER_ALGO_AES256;
alg               555 drivers/crypto/qat/qat_common/qat_algs.c 	int alg;
alg               560 drivers/crypto/qat/qat_common/qat_algs.c 	if (qat_alg_validate_key(keys.enckeylen, &alg, mode))
alg               563 drivers/crypto/qat/qat_common/qat_algs.c 	if (qat_alg_aead_init_enc_session(tfm, alg, &keys, mode))
alg               566 drivers/crypto/qat/qat_common/qat_algs.c 	if (qat_alg_aead_init_dec_session(tfm, alg, &keys, mode))
alg               585 drivers/crypto/qat/qat_common/qat_algs.c 	int alg;
alg               587 drivers/crypto/qat/qat_common/qat_algs.c 	if (qat_alg_validate_key(keylen, &alg, mode))
alg               590 drivers/crypto/qat/qat_common/qat_algs.c 	qat_alg_ablkcipher_init_enc(ctx, alg, key, keylen, mode);
alg               591 drivers/crypto/qat/qat_common/qat_algs.c 	qat_alg_ablkcipher_init_dec(ctx, alg, key, keylen, mode);
alg               358 drivers/crypto/qce/ablkcipher.c 	struct crypto_alg *alg;
alg               365 drivers/crypto/qce/ablkcipher.c 	alg = &tmpl->alg.crypto;
alg               367 drivers/crypto/qce/ablkcipher.c 	snprintf(alg->cra_name, CRYPTO_MAX_ALG_NAME, "%s", def->name);
alg               368 drivers/crypto/qce/ablkcipher.c 	snprintf(alg->cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s",
alg               371 drivers/crypto/qce/ablkcipher.c 	alg->cra_blocksize = def->blocksize;
alg               372 drivers/crypto/qce/ablkcipher.c 	alg->cra_ablkcipher.ivsize = def->ivsize;
alg               373 drivers/crypto/qce/ablkcipher.c 	alg->cra_ablkcipher.min_keysize = def->min_keysize;
alg               374 drivers/crypto/qce/ablkcipher.c 	alg->cra_ablkcipher.max_keysize = def->max_keysize;
alg               375 drivers/crypto/qce/ablkcipher.c 	alg->cra_ablkcipher.setkey = IS_3DES(def->flags) ? qce_des3_setkey :
alg               378 drivers/crypto/qce/ablkcipher.c 	alg->cra_ablkcipher.encrypt = qce_ablkcipher_encrypt;
alg               379 drivers/crypto/qce/ablkcipher.c 	alg->cra_ablkcipher.decrypt = qce_ablkcipher_decrypt;
alg               381 drivers/crypto/qce/ablkcipher.c 	alg->cra_priority = 300;
alg               382 drivers/crypto/qce/ablkcipher.c 	alg->cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC |
alg               384 drivers/crypto/qce/ablkcipher.c 	alg->cra_ctxsize = sizeof(struct qce_cipher_ctx);
alg               385 drivers/crypto/qce/ablkcipher.c 	alg->cra_alignmask = 0;
alg               386 drivers/crypto/qce/ablkcipher.c 	alg->cra_type = &crypto_ablkcipher_type;
alg               387 drivers/crypto/qce/ablkcipher.c 	alg->cra_module = THIS_MODULE;
alg               388 drivers/crypto/qce/ablkcipher.c 	alg->cra_init = qce_ablkcipher_init;
alg               389 drivers/crypto/qce/ablkcipher.c 	alg->cra_exit = qce_ablkcipher_exit;
alg               396 drivers/crypto/qce/ablkcipher.c 	ret = crypto_register_alg(alg);
alg               399 drivers/crypto/qce/ablkcipher.c 		dev_err(qce->dev, "%s registration failed\n", alg->cra_name);
alg               404 drivers/crypto/qce/ablkcipher.c 	dev_dbg(qce->dev, "%s is registered\n", alg->cra_name);
alg               413 drivers/crypto/qce/ablkcipher.c 		crypto_unregister_alg(&tmpl->alg.crypto);
alg                50 drivers/crypto/qce/cipher.h 	struct crypto_alg *alg = tfm->__crt_alg;
alg                51 drivers/crypto/qce/cipher.h 	return container_of(alg, struct qce_alg_template, alg.crypto);
alg                84 drivers/crypto/qce/common.h 	} alg;
alg               473 drivers/crypto/qce/sha.c 	struct ahash_alg *alg;
alg               483 drivers/crypto/qce/sha.c 	alg = &tmpl->alg.ahash;
alg               484 drivers/crypto/qce/sha.c 	alg->init = qce_ahash_init;
alg               485 drivers/crypto/qce/sha.c 	alg->update = qce_ahash_update;
alg               486 drivers/crypto/qce/sha.c 	alg->final = qce_ahash_final;
alg               487 drivers/crypto/qce/sha.c 	alg->digest = qce_ahash_digest;
alg               488 drivers/crypto/qce/sha.c 	alg->export = qce_ahash_export;
alg               489 drivers/crypto/qce/sha.c 	alg->import = qce_ahash_import;
alg               491 drivers/crypto/qce/sha.c 		alg->setkey = qce_ahash_hmac_setkey;
alg               492 drivers/crypto/qce/sha.c 	alg->halg.digestsize = def->digestsize;
alg               493 drivers/crypto/qce/sha.c 	alg->halg.statesize = def->statesize;
alg               495 drivers/crypto/qce/sha.c 	base = &alg->halg.base;
alg               513 drivers/crypto/qce/sha.c 	ret = crypto_register_ahash(alg);
alg               530 drivers/crypto/qce/sha.c 		crypto_unregister_ahash(&tmpl->alg.ahash);
alg                63 drivers/crypto/qce/sha.h 	struct ahash_alg *alg = container_of(crypto_hash_alg_common(ahash),
alg                66 drivers/crypto/qce/sha.h 	return container_of(alg, struct qce_alg_template, alg.ahash);
alg               268 drivers/crypto/rockchip/rk3288_crypto.c 					&rk_cipher_algs[i]->alg.crypto);
alg               271 drivers/crypto/rockchip/rk3288_crypto.c 					&rk_cipher_algs[i]->alg.hash);
alg               280 drivers/crypto/rockchip/rk3288_crypto.c 			crypto_unregister_alg(&rk_cipher_algs[k]->alg.crypto);
alg               282 drivers/crypto/rockchip/rk3288_crypto.c 			crypto_unregister_ahash(&rk_cipher_algs[i]->alg.hash);
alg               293 drivers/crypto/rockchip/rk3288_crypto.c 			crypto_unregister_alg(&rk_cipher_algs[i]->alg.crypto);
alg               295 drivers/crypto/rockchip/rk3288_crypto.c 			crypto_unregister_ahash(&rk_cipher_algs[i]->alg.hash);
alg               261 drivers/crypto/rockchip/rk3288_crypto.h 	} alg;
alg               381 drivers/crypto/rockchip/rk3288_crypto_ablkcipher.c 	struct crypto_alg *alg = tfm->__crt_alg;
alg               384 drivers/crypto/rockchip/rk3288_crypto_ablkcipher.c 	algt = container_of(alg, struct rk_crypto_tmp, alg.crypto);
alg               406 drivers/crypto/rockchip/rk3288_crypto_ablkcipher.c 	.alg.crypto = {
alg               431 drivers/crypto/rockchip/rk3288_crypto_ablkcipher.c 	.alg.crypto = {
alg               457 drivers/crypto/rockchip/rk3288_crypto_ablkcipher.c 	.alg.crypto = {
alg               482 drivers/crypto/rockchip/rk3288_crypto_ablkcipher.c 	.alg.crypto = {
alg               508 drivers/crypto/rockchip/rk3288_crypto_ablkcipher.c 	.alg.crypto = {
alg               534 drivers/crypto/rockchip/rk3288_crypto_ablkcipher.c 	.alg.crypto = {
alg               276 drivers/crypto/rockchip/rk3288_crypto_ahash.c 	struct ahash_alg *alg = __crypto_ahash_alg(tfm->__crt_alg);
alg               280 drivers/crypto/rockchip/rk3288_crypto_ahash.c 	algt = container_of(alg, struct rk_crypto_tmp, alg.hash);
alg               316 drivers/crypto/rockchip/rk3288_crypto_ahash.c 	.alg.hash = {
alg               346 drivers/crypto/rockchip/rk3288_crypto_ahash.c 	.alg.hash = {
alg               376 drivers/crypto/rockchip/rk3288_crypto_ahash.c 	.alg.hash = {
alg              2312 drivers/crypto/s5p-sss.c 			struct ahash_alg *alg;
alg              2314 drivers/crypto/s5p-sss.c 			alg = &algs_sha1_md5_sha256[hash_i];
alg              2315 drivers/crypto/s5p-sss.c 			err = crypto_register_ahash(alg);
alg              2318 drivers/crypto/s5p-sss.c 					alg->halg.base.cra_driver_name, err);
alg               153 drivers/crypto/sunxi-ss/sun4i-ss-cipher.c 	struct skcipher_alg *alg = crypto_skcipher_alg(tfm);
alg               182 drivers/crypto/sunxi-ss/sun4i-ss-cipher.c 	algt = container_of(alg, struct sun4i_ss_alg_template, alg.crypto);
alg               183 drivers/crypto/sunxi-ss/sun4i-ss-cipher.c 	if (areq->cryptlen % algt->alg.crypto.base.cra_blocksize)
alg               493 drivers/crypto/sunxi-ss/sun4i-ss-cipher.c 			    alg.crypto.base);
alg                28 drivers/crypto/sunxi-ss/sun4i-ss-core.c 	.alg.hash = {
alg                54 drivers/crypto/sunxi-ss/sun4i-ss-core.c 	.alg.hash = {
alg                79 drivers/crypto/sunxi-ss/sun4i-ss-core.c 	.alg.crypto = {
alg               101 drivers/crypto/sunxi-ss/sun4i-ss-core.c 	.alg.crypto = {
alg               122 drivers/crypto/sunxi-ss/sun4i-ss-core.c 	.alg.crypto = {
alg               144 drivers/crypto/sunxi-ss/sun4i-ss-core.c 	.alg.crypto = {
alg               165 drivers/crypto/sunxi-ss/sun4i-ss-core.c 	.alg.crypto = {
alg               187 drivers/crypto/sunxi-ss/sun4i-ss-core.c 	.alg.crypto = {
alg               210 drivers/crypto/sunxi-ss/sun4i-ss-core.c 	.alg.rng = {
alg               349 drivers/crypto/sunxi-ss/sun4i-ss-core.c 			err = crypto_register_skcipher(&ss_algs[i].alg.crypto);
alg               352 drivers/crypto/sunxi-ss/sun4i-ss-core.c 					ss_algs[i].alg.crypto.base.cra_name);
alg               357 drivers/crypto/sunxi-ss/sun4i-ss-core.c 			err = crypto_register_ahash(&ss_algs[i].alg.hash);
alg               360 drivers/crypto/sunxi-ss/sun4i-ss-core.c 					ss_algs[i].alg.hash.halg.base.cra_name);
alg               365 drivers/crypto/sunxi-ss/sun4i-ss-core.c 			err = crypto_register_rng(&ss_algs[i].alg.rng);
alg               368 drivers/crypto/sunxi-ss/sun4i-ss-core.c 					ss_algs[i].alg.rng.base.cra_name);
alg               380 drivers/crypto/sunxi-ss/sun4i-ss-core.c 			crypto_unregister_skcipher(&ss_algs[i].alg.crypto);
alg               383 drivers/crypto/sunxi-ss/sun4i-ss-core.c 			crypto_unregister_ahash(&ss_algs[i].alg.hash);
alg               386 drivers/crypto/sunxi-ss/sun4i-ss-core.c 			crypto_unregister_rng(&ss_algs[i].alg.rng);
alg               407 drivers/crypto/sunxi-ss/sun4i-ss-core.c 			crypto_unregister_skcipher(&ss_algs[i].alg.crypto);
alg               410 drivers/crypto/sunxi-ss/sun4i-ss-core.c 			crypto_unregister_ahash(&ss_algs[i].alg.hash);
alg               413 drivers/crypto/sunxi-ss/sun4i-ss-core.c 			crypto_unregister_rng(&ss_algs[i].alg.rng);
alg                20 drivers/crypto/sunxi-ss/sun4i-ss-hash.c 	struct ahash_alg *alg = __crypto_ahash_alg(tfm->__crt_alg);
alg                25 drivers/crypto/sunxi-ss/sun4i-ss-hash.c 	algt = container_of(alg, struct sun4i_ss_alg_template, alg.hash);
alg                38 drivers/crypto/sunxi-ss/sun4i-ss-hash.c 	struct ahash_alg *alg = __crypto_ahash_alg(tfm->base.__crt_alg);
alg                43 drivers/crypto/sunxi-ss/sun4i-ss-hash.c 	algt = container_of(alg, struct sun4i_ss_alg_template, alg.hash);
alg                 7 drivers/crypto/sunxi-ss/sun4i-ss-prng.c 	struct rng_alg *alg = crypto_rng_alg(tfm);
alg                 9 drivers/crypto/sunxi-ss/sun4i-ss-prng.c 	algt = container_of(alg, struct sun4i_ss_alg_template, alg.rng);
alg                19 drivers/crypto/sunxi-ss/sun4i-ss-prng.c 	struct rng_alg *alg = crypto_rng_alg(tfm);
alg                28 drivers/crypto/sunxi-ss/sun4i-ss-prng.c 	algt = container_of(alg, struct sun4i_ss_alg_template, alg.rng);
alg               154 drivers/crypto/sunxi-ss/sun4i-ss.h 	} alg;
alg              2259 drivers/crypto/talitos.c 	} alg;
alg              2266 drivers/crypto/talitos.c 		.alg.aead = {
alg              2287 drivers/crypto/talitos.c 		.alg.aead = {
alg              2307 drivers/crypto/talitos.c 		.alg.aead = {
alg              2331 drivers/crypto/talitos.c 		.alg.aead = {
alg              2354 drivers/crypto/talitos.c 		.alg.aead = {
alg              2375 drivers/crypto/talitos.c 		.alg.aead = {
alg              2395 drivers/crypto/talitos.c 		.alg.aead = {
alg              2419 drivers/crypto/talitos.c 		.alg.aead = {
alg              2442 drivers/crypto/talitos.c 		.alg.aead = {
alg              2463 drivers/crypto/talitos.c 		.alg.aead = {
alg              2483 drivers/crypto/talitos.c 		.alg.aead = {
alg              2507 drivers/crypto/talitos.c 		.alg.aead = {
alg              2530 drivers/crypto/talitos.c 		.alg.aead = {
alg              2550 drivers/crypto/talitos.c 		.alg.aead = {
alg              2573 drivers/crypto/talitos.c 		.alg.aead = {
alg              2593 drivers/crypto/talitos.c 		.alg.aead = {
alg              2616 drivers/crypto/talitos.c 		.alg.aead = {
alg              2637 drivers/crypto/talitos.c 		.alg.aead = {
alg              2657 drivers/crypto/talitos.c 		.alg.aead = {
alg              2680 drivers/crypto/talitos.c 		.alg.aead = {
alg              2703 drivers/crypto/talitos.c 		.alg.crypto = {
alg              2719 drivers/crypto/talitos.c 		.alg.crypto = {
alg              2737 drivers/crypto/talitos.c 		.alg.crypto = {
alg              2755 drivers/crypto/talitos.c 		.alg.crypto = {
alg              2771 drivers/crypto/talitos.c 		.alg.crypto = {
alg              2789 drivers/crypto/talitos.c 		.alg.crypto = {
alg              2806 drivers/crypto/talitos.c 		.alg.crypto = {
alg              2826 drivers/crypto/talitos.c 		.alg.hash = {
alg              2841 drivers/crypto/talitos.c 		.alg.hash = {
alg              2856 drivers/crypto/talitos.c 		.alg.hash = {
alg              2871 drivers/crypto/talitos.c 		.alg.hash = {
alg              2886 drivers/crypto/talitos.c 		.alg.hash = {
alg              2901 drivers/crypto/talitos.c 		.alg.hash = {
alg              2916 drivers/crypto/talitos.c 		.alg.hash = {
alg              2931 drivers/crypto/talitos.c 		.alg.hash = {
alg              2946 drivers/crypto/talitos.c 		.alg.hash = {
alg              2961 drivers/crypto/talitos.c 		.alg.hash = {
alg              2976 drivers/crypto/talitos.c 		.alg.hash = {
alg              2991 drivers/crypto/talitos.c 		.alg.hash = {
alg              3037 drivers/crypto/talitos.c 	struct crypto_alg *alg = tfm->__crt_alg;
alg              3041 drivers/crypto/talitos.c 	if ((alg->cra_flags & CRYPTO_ALG_TYPE_MASK) == CRYPTO_ALG_TYPE_AHASH)
alg              3042 drivers/crypto/talitos.c 		talitos_alg = container_of(__crypto_ahash_alg(alg),
alg              3044 drivers/crypto/talitos.c 					   algt.alg.hash);
alg              3046 drivers/crypto/talitos.c 		talitos_alg = container_of(alg, struct talitos_crypto_alg,
alg              3047 drivers/crypto/talitos.c 					   algt.alg.crypto);
alg              3054 drivers/crypto/talitos.c 	struct aead_alg *alg = crypto_aead_alg(tfm);
alg              3058 drivers/crypto/talitos.c 	talitos_alg = container_of(alg, struct talitos_crypto_alg,
alg              3059 drivers/crypto/talitos.c 				   algt.alg.aead);
alg              3118 drivers/crypto/talitos.c 			crypto_unregister_aead(&t_alg->algt.alg.aead);
alg              3121 drivers/crypto/talitos.c 			crypto_unregister_ahash(&t_alg->algt.alg.hash);
alg              3149 drivers/crypto/talitos.c 	struct crypto_alg *alg;
alg              3160 drivers/crypto/talitos.c 		alg = &t_alg->algt.alg.crypto;
alg              3161 drivers/crypto/talitos.c 		alg->cra_init = talitos_cra_init;
alg              3162 drivers/crypto/talitos.c 		alg->cra_exit = talitos_cra_exit;
alg              3163 drivers/crypto/talitos.c 		alg->cra_type = &crypto_ablkcipher_type;
alg              3164 drivers/crypto/talitos.c 		alg->cra_ablkcipher.setkey = alg->cra_ablkcipher.setkey ?:
alg              3166 drivers/crypto/talitos.c 		alg->cra_ablkcipher.encrypt = ablkcipher_encrypt;
alg              3167 drivers/crypto/talitos.c 		alg->cra_ablkcipher.decrypt = ablkcipher_decrypt;
alg              3170 drivers/crypto/talitos.c 		alg = &t_alg->algt.alg.aead.base;
alg              3171 drivers/crypto/talitos.c 		alg->cra_exit = talitos_cra_exit;
alg              3172 drivers/crypto/talitos.c 		t_alg->algt.alg.aead.init = talitos_cra_init_aead;
alg              3173 drivers/crypto/talitos.c 		t_alg->algt.alg.aead.setkey = t_alg->algt.alg.aead.setkey ?:
alg              3175 drivers/crypto/talitos.c 		t_alg->algt.alg.aead.encrypt = aead_encrypt;
alg              3176 drivers/crypto/talitos.c 		t_alg->algt.alg.aead.decrypt = aead_decrypt;
alg              3178 drivers/crypto/talitos.c 		    !strncmp(alg->cra_name, "authenc(hmac(sha224)", 20)) {
alg              3184 drivers/crypto/talitos.c 		alg = &t_alg->algt.alg.hash.halg.base;
alg              3185 drivers/crypto/talitos.c 		alg->cra_init = talitos_cra_init_ahash;
alg              3186 drivers/crypto/talitos.c 		alg->cra_exit = talitos_cra_exit;
alg              3187 drivers/crypto/talitos.c 		t_alg->algt.alg.hash.init = ahash_init;
alg              3188 drivers/crypto/talitos.c 		t_alg->algt.alg.hash.update = ahash_update;
alg              3189 drivers/crypto/talitos.c 		t_alg->algt.alg.hash.final = ahash_final;
alg              3190 drivers/crypto/talitos.c 		t_alg->algt.alg.hash.finup = ahash_finup;
alg              3191 drivers/crypto/talitos.c 		t_alg->algt.alg.hash.digest = ahash_digest;
alg              3192 drivers/crypto/talitos.c 		if (!strncmp(alg->cra_name, "hmac", 4))
alg              3193 drivers/crypto/talitos.c 			t_alg->algt.alg.hash.setkey = ahash_setkey;
alg              3194 drivers/crypto/talitos.c 		t_alg->algt.alg.hash.import = ahash_import;
alg              3195 drivers/crypto/talitos.c 		t_alg->algt.alg.hash.export = ahash_export;
alg              3198 drivers/crypto/talitos.c 		    !strncmp(alg->cra_name, "hmac", 4)) {
alg              3203 drivers/crypto/talitos.c 		    (!strcmp(alg->cra_name, "sha224") ||
alg              3204 drivers/crypto/talitos.c 		     !strcmp(alg->cra_name, "hmac(sha224)"))) {
alg              3205 drivers/crypto/talitos.c 			t_alg->algt.alg.hash.init = ahash_init_sha224_swinit;
alg              3218 drivers/crypto/talitos.c 	alg->cra_module = THIS_MODULE;
alg              3220 drivers/crypto/talitos.c 		alg->cra_priority = t_alg->algt.priority;
alg              3222 drivers/crypto/talitos.c 		alg->cra_priority = TALITOS_CRA_PRIORITY;
alg              3224 drivers/crypto/talitos.c 		alg->cra_alignmask = 3;
alg              3226 drivers/crypto/talitos.c 		alg->cra_alignmask = 0;
alg              3227 drivers/crypto/talitos.c 	alg->cra_ctxsize = sizeof(struct talitos_ctx);
alg              3228 drivers/crypto/talitos.c 	alg->cra_flags |= CRYPTO_ALG_KERN_DRIVER_ONLY;
alg              3453 drivers/crypto/talitos.c 			struct crypto_alg *alg = NULL;
alg              3466 drivers/crypto/talitos.c 						&t_alg->algt.alg.crypto);
alg              3467 drivers/crypto/talitos.c 				alg = &t_alg->algt.alg.crypto;
alg              3472 drivers/crypto/talitos.c 					&t_alg->algt.alg.aead);
alg              3473 drivers/crypto/talitos.c 				alg = &t_alg->algt.alg.aead.base;
alg              3478 drivers/crypto/talitos.c 						&t_alg->algt.alg.hash);
alg              3479 drivers/crypto/talitos.c 				alg = &t_alg->algt.alg.hash.halg.base;
alg              3484 drivers/crypto/talitos.c 					alg->cra_driver_name);
alg              1067 drivers/crypto/ux500/cryp/cryp_core.c 	struct crypto_alg *alg = tfm->__crt_alg;
alg              1068 drivers/crypto/ux500/cryp/cryp_core.c 	struct cryp_algo_template *cryp_alg = container_of(alg,
alg              1334 drivers/crypto/ux500/hash/hash_core.c 		       const u8 *key, unsigned int keylen, int alg)
alg              1345 drivers/crypto/ux500/hash/hash_core.c 		       __func__, alg);
alg              1495 drivers/crypto/ux500/hash/hash_core.c 	struct crypto_alg *alg = tfm->__crt_alg;
alg              1498 drivers/crypto/ux500/hash/hash_core.c 	hash_alg = container_of(__crypto_ahash_alg(alg),
alg                99 drivers/crypto/virtio/virtio_crypto_algs.c virtio_crypto_alg_validate_key(int key_len, uint32_t *alg)
alg               105 drivers/crypto/virtio/virtio_crypto_algs.c 		*alg = VIRTIO_CRYPTO_CIPHER_AES_CBC;
alg               115 drivers/crypto/virtio/virtio_crypto_algs.c 		uint32_t alg, const uint8_t *key,
alg               139 drivers/crypto/virtio/virtio_crypto_algs.c 	vcrypto->ctrl.header.algo = cpu_to_le32(alg);
alg               268 drivers/crypto/virtio/virtio_crypto_algs.c 	uint32_t alg;
alg               277 drivers/crypto/virtio/virtio_crypto_algs.c 	if (virtio_crypto_alg_validate_key(keylen, &alg))
alg               282 drivers/crypto/virtio/virtio_crypto_algs.c 			alg, key, keylen, 1);
alg               287 drivers/crypto/virtio/virtio_crypto_algs.c 			alg, key, keylen, 0);
alg               305 drivers/crypto/virtio/virtio_crypto_algs.c 	uint32_t alg;
alg               308 drivers/crypto/virtio/virtio_crypto_algs.c 	ret = virtio_crypto_alg_validate_key(keylen, &alg);
alg               317 drivers/crypto/virtio/virtio_crypto_algs.c 				      VIRTIO_CRYPTO_SERVICE_CIPHER, alg);
alg                29 drivers/crypto/vmx/aes.c 	const char *alg = crypto_tfm_alg_name(tfm);
alg                33 drivers/crypto/vmx/aes.c 	fallback = crypto_alloc_cipher(alg, 0, CRYPTO_ALG_NEED_FALLBACK);
alg                37 drivers/crypto/vmx/aes.c 		       alg, PTR_ERR(fallback));
alg              1406 drivers/infiniband/hw/qib/qib_file_ops.c 		      unsigned alg)
alg              1422 drivers/infiniband/hw/qib/qib_file_ops.c 	if (alg == QIB_PORT_ALG_ACROSS) {
alg              1588 drivers/infiniband/hw/qib/qib_file_ops.c 	unsigned swmajor, swminor, alg = QIB_PORT_ALG_ACROSS;
alg              1606 drivers/infiniband/hw/qib/qib_file_ops.c 		alg = uinfo->spu_port_alg;
alg              1635 drivers/infiniband/hw/qib/qib_file_ops.c 		ret = get_a_ctxt(fp, uinfo, alg);
alg               649 drivers/media/i2c/s5k5baf.c static void s5k5baf_hw_set_alg(struct s5k5baf *state, u16 alg, bool enable)
alg               658 drivers/media/i2c/s5k5baf.c 	new_alg = enable ? (cur_alg | alg) : (cur_alg & ~alg);
alg                64 drivers/media/platform/davinci/isif.c 		.alg = ISIF_ALAW,
alg               586 drivers/media/platform/davinci/isif.c 	if (module_params->compress.alg == ISIF_ALAW)
alg               593 drivers/media/platform/davinci/isif.c 	if (module_params->compress.alg == ISIF_DPCM) {
alg               732 drivers/media/platform/davinci/isif.c 			if ((isif_cfg.bayer.config_params.compress.alg !=
alg               734 drivers/media/platform/davinci/isif.c 			    (isif_cfg.bayer.config_params.compress.alg !=
alg               742 drivers/media/platform/davinci/isif.c 			isif_cfg.bayer.config_params.compress.alg =
alg               765 drivers/media/platform/davinci/isif.c 		if (isif_cfg.bayer.config_params.compress.alg == ISIF_ALAW ||
alg               766 drivers/media/platform/davinci/isif.c 		    isif_cfg.bayer.config_params.compress.alg == ISIF_DPCM)
alg               418 drivers/misc/xilinx_sdfec.c 	if (turbo.alg >= XSDFEC_TURBO_ALG_MAX)
alg               430 drivers/misc/xilinx_sdfec.c 		      turbo.alg;
alg               449 drivers/misc/xilinx_sdfec.c 	turbo_params.alg = reg_value & 0x1;
alg               265 drivers/net/ethernet/marvell/octeontx2/af/rvu_nix.c 	field.alg = NIX_LSOALG_ADD_PAYLEN;
alg               278 drivers/net/ethernet/marvell/octeontx2/af/rvu_nix.c 	field.alg = NIX_LSOALG_ADD_SEGNUM;
alg               293 drivers/net/ethernet/marvell/octeontx2/af/rvu_nix.c 	field.alg = NIX_LSOALG_ADD_OFFSET;
alg               302 drivers/net/ethernet/marvell/octeontx2/af/rvu_nix.c 	field.alg = NIX_LSOALG_TCP_FLAGS;
alg              1990 drivers/net/ethernet/marvell/octeontx2/af/rvu_nix.c static int set_flowkey_fields(struct nix_rx_flowkey_alg *alg, u32 flow_cfg)
alg              1998 drivers/net/ethernet/marvell/octeontx2/af/rvu_nix.c 	if (!alg)
alg              2004 drivers/net/ethernet/marvell/octeontx2/af/rvu_nix.c 	memset(alg, 0, sizeof(uint64_t) * FIELDS_PER_ALG);
alg              2100 drivers/net/ethernet/marvell/octeontx2/af/rvu_nix.c 			memcpy(&alg[nr_field], field, sizeof(*field));
alg              2192 drivers/net/ethernet/marvell/octeontx2/af/rvu_nix.c 	int alg, fid, rc;
alg              2195 drivers/net/ethernet/marvell/octeontx2/af/rvu_nix.c 	for (alg = 0; alg < NIX_FLOW_KEY_ALG_MAX; alg++) {
alg              2198 drivers/net/ethernet/marvell/octeontx2/af/rvu_nix.c 				    NIX_AF_RX_FLOW_KEY_ALGX_FIELDX(alg, fid),
alg               865 drivers/net/ethernet/marvell/octeontx2/af/rvu_struct.h 	u64 alg			: 3;
alg               877 drivers/net/ethernet/marvell/octeontx2/af/rvu_struct.h 	u64 alg			: 3;
alg               530 drivers/net/ethernet/mellanox/mlx5/core/fpga/tls.c 	MLX5_SET(tls_cmd, cmd, alg, MLX5_TLS_ALG_AES_GCM_128);
alg              1193 drivers/net/ethernet/toshiba/ps3_gelic_wireless.c 	__u16 alg;
alg              1201 drivers/net/ethernet/toshiba/ps3_gelic_wireless.c 	alg = ext->alg;
alg              1227 drivers/net/ethernet/toshiba/ps3_gelic_wireless.c 	if (alg == IW_ENCODE_ALG_NONE || (flags & IW_ENCODE_DISABLED)) {
alg              1233 drivers/net/ethernet/toshiba/ps3_gelic_wireless.c 	} else if (alg == IW_ENCODE_ALG_WEP) {
alg              1256 drivers/net/ethernet/toshiba/ps3_gelic_wireless.c 	} else if (alg == IW_ENCODE_ALG_PMK) {
alg              1311 drivers/net/ethernet/toshiba/ps3_gelic_wireless.c 		ext->alg = IW_ENCODE_ALG_WEP;
alg              1315 drivers/net/ethernet/toshiba/ps3_gelic_wireless.c 		ext->alg = IW_ENCODE_ALG_TKIP;
alg              1319 drivers/net/ethernet/toshiba/ps3_gelic_wireless.c 		ext->alg = IW_ENCODE_ALG_CCMP;
alg              1324 drivers/net/ethernet/toshiba/ps3_gelic_wireless.c 		ext->alg = IW_ENCODE_ALG_NONE;
alg              1836 drivers/net/wireless/atmel/atmel.c 	int idx, key_len, alg = ext->alg, set_key = 1;
alg              1848 drivers/net/wireless/atmel/atmel.c 	    alg = IW_ENCODE_ALG_NONE;
alg              1857 drivers/net/wireless/atmel/atmel.c 		switch (alg) {
alg              1914 drivers/net/wireless/atmel/atmel.c 		ext->alg = IW_ENCODE_ALG_NONE;
alg              1919 drivers/net/wireless/atmel/atmel.c 			ext->alg = IW_ENCODE_ALG_WEP;
alg              2696 drivers/net/wireless/atmel/atmel.c 	__le16 alg;
alg              2860 drivers/net/wireless/atmel/atmel.c 	auth.alg = cpu_to_le16(system);
alg              3030 drivers/net/wireless/atmel/atmel.c 	u16 system = le16_to_cpu(auth->alg);
alg              6472 drivers/net/wireless/cisco/airo.c 	int idx, key_len, alg = ext->alg, set_key = 1, rc;
alg              6493 drivers/net/wireless/cisco/airo.c 		alg = IW_ENCODE_ALG_NONE;
alg              6512 drivers/net/wireless/cisco/airo.c 		switch (alg) {
alg              6755 drivers/net/wireless/intel/ipw2x00/ipw2200.c 		if (ext->alg == IW_ENCODE_ALG_TKIP) {
alg               511 drivers/net/wireless/intel/ipw2x00/libipw_wx.c 	const char *alg, *module;
alg               532 drivers/net/wireless/intel/ipw2x00/libipw_wx.c 		if (idx != 0 && ext->alg != IW_ENCODE_ALG_WEP)
alg               542 drivers/net/wireless/intel/ipw2x00/libipw_wx.c 	    ext->alg == IW_ENCODE_ALG_NONE) {
alg               567 drivers/net/wireless/intel/ipw2x00/libipw_wx.c 	switch (ext->alg) {
alg               569 drivers/net/wireless/intel/ipw2x00/libipw_wx.c 		alg = "WEP";
alg               573 drivers/net/wireless/intel/ipw2x00/libipw_wx.c 		alg = "TKIP";
alg               577 drivers/net/wireless/intel/ipw2x00/libipw_wx.c 		alg = "CCMP";
alg               582 drivers/net/wireless/intel/ipw2x00/libipw_wx.c 				   dev->name, ext->alg);
alg               587 drivers/net/wireless/intel/ipw2x00/libipw_wx.c 	ops = lib80211_get_crypto_ops(alg);
alg               590 drivers/net/wireless/intel/ipw2x00/libipw_wx.c 		ops = lib80211_get_crypto_ops(alg);
alg               594 drivers/net/wireless/intel/ipw2x00/libipw_wx.c 				   dev->name, ext->alg);
alg               635 drivers/net/wireless/intel/ipw2x00/libipw_wx.c 	if (ext->alg != IW_ENCODE_ALG_NONE) {
alg               639 drivers/net/wireless/intel/ipw2x00/libipw_wx.c 		if (ext->alg == IW_ENCODE_ALG_WEP) {
alg               643 drivers/net/wireless/intel/ipw2x00/libipw_wx.c 		} else if (ext->alg == IW_ENCODE_ALG_TKIP) {
alg               647 drivers/net/wireless/intel/ipw2x00/libipw_wx.c 		} else if (ext->alg == IW_ENCODE_ALG_CCMP) {
alg               685 drivers/net/wireless/intel/ipw2x00/libipw_wx.c 	    ext->alg != IW_ENCODE_ALG_WEP)
alg               693 drivers/net/wireless/intel/ipw2x00/libipw_wx.c 		ext->alg = IW_ENCODE_ALG_NONE;
alg               698 drivers/net/wireless/intel/ipw2x00/libipw_wx.c 			ext->alg = IW_ENCODE_ALG_WEP;
alg               700 drivers/net/wireless/intel/ipw2x00/libipw_wx.c 			ext->alg = IW_ENCODE_ALG_TKIP;
alg               702 drivers/net/wireless/intel/ipw2x00/libipw_wx.c 			ext->alg = IW_ENCODE_ALG_CCMP;
alg               710 drivers/net/wireless/intel/ipw2x00/libipw_wx.c 		    (ext->alg == IW_ENCODE_ALG_TKIP ||
alg               711 drivers/net/wireless/intel/ipw2x00/libipw_wx.c 		     ext->alg == IW_ENCODE_ALG_CCMP))
alg               375 drivers/net/wireless/intersil/hostap/hostap_common.h 			u8 alg[HOSTAP_CRYPT_ALG_NAME_LEN];
alg              3209 drivers/net/wireless/intersil/hostap/hostap_ioctl.c 	const char *alg, *module;
alg              3244 drivers/net/wireless/intersil/hostap/hostap_ioctl.c 	    ext->alg == IW_ENCODE_ALG_NONE) {
alg              3250 drivers/net/wireless/intersil/hostap/hostap_ioctl.c 	switch (ext->alg) {
alg              3252 drivers/net/wireless/intersil/hostap/hostap_ioctl.c 		alg = "WEP";
alg              3256 drivers/net/wireless/intersil/hostap/hostap_ioctl.c 		alg = "TKIP";
alg              3260 drivers/net/wireless/intersil/hostap/hostap_ioctl.c 		alg = "CCMP";
alg              3265 drivers/net/wireless/intersil/hostap/hostap_ioctl.c 		       local->dev->name, ext->alg);
alg              3270 drivers/net/wireless/intersil/hostap/hostap_ioctl.c 	ops = lib80211_get_crypto_ops(alg);
alg              3273 drivers/net/wireless/intersil/hostap/hostap_ioctl.c 		ops = lib80211_get_crypto_ops(alg);
alg              3277 drivers/net/wireless/intersil/hostap/hostap_ioctl.c 		       local->dev->name, alg);
alg              3282 drivers/net/wireless/intersil/hostap/hostap_ioctl.c 	if (sta_ptr || ext->alg != IW_ENCODE_ALG_WEP) {
alg              3407 drivers/net/wireless/intersil/hostap/hostap_ioctl.c 		ext->alg = IW_ENCODE_ALG_NONE;
alg              3412 drivers/net/wireless/intersil/hostap/hostap_ioctl.c 			ext->alg = IW_ENCODE_ALG_WEP;
alg              3414 drivers/net/wireless/intersil/hostap/hostap_ioctl.c 			ext->alg = IW_ENCODE_ALG_TKIP;
alg              3416 drivers/net/wireless/intersil/hostap/hostap_ioctl.c 			ext->alg = IW_ENCODE_ALG_CCMP;
alg              3427 drivers/net/wireless/intersil/hostap/hostap_ioctl.c 			    (ext->alg == IW_ENCODE_ALG_TKIP ||
alg              3428 drivers/net/wireless/intersil/hostap/hostap_ioctl.c 			     ext->alg == IW_ENCODE_ALG_CCMP))
alg              3450 drivers/net/wireless/intersil/hostap/hostap_ioctl.c 	param->u.crypt.alg[HOSTAP_CRYPT_ALG_NAME_LEN - 1] = '\0';
alg              3476 drivers/net/wireless/intersil/hostap/hostap_ioctl.c 	if (strcmp(param->u.crypt.alg, "none") == 0) {
alg              3482 drivers/net/wireless/intersil/hostap/hostap_ioctl.c 	ops = lib80211_get_crypto_ops(param->u.crypt.alg);
alg              3483 drivers/net/wireless/intersil/hostap/hostap_ioctl.c 	if (ops == NULL && strcmp(param->u.crypt.alg, "WEP") == 0) {
alg              3485 drivers/net/wireless/intersil/hostap/hostap_ioctl.c 		ops = lib80211_get_crypto_ops(param->u.crypt.alg);
alg              3486 drivers/net/wireless/intersil/hostap/hostap_ioctl.c 	} else if (ops == NULL && strcmp(param->u.crypt.alg, "TKIP") == 0) {
alg              3488 drivers/net/wireless/intersil/hostap/hostap_ioctl.c 		ops = lib80211_get_crypto_ops(param->u.crypt.alg);
alg              3489 drivers/net/wireless/intersil/hostap/hostap_ioctl.c 	} else if (ops == NULL && strcmp(param->u.crypt.alg, "CCMP") == 0) {
alg              3491 drivers/net/wireless/intersil/hostap/hostap_ioctl.c 		ops = lib80211_get_crypto_ops(param->u.crypt.alg);
alg              3495 drivers/net/wireless/intersil/hostap/hostap_ioctl.c 		       local->dev->name, param->u.crypt.alg);
alg              3607 drivers/net/wireless/intersil/hostap/hostap_ioctl.c 		memcpy(param->u.crypt.alg, "none", 5);
alg              3611 drivers/net/wireless/intersil/hostap/hostap_ioctl.c 		strncpy(param->u.crypt.alg, (*crypt)->ops->name,
alg                31 drivers/net/wireless/intersil/orinoco/wext.c 			   enum orinoco_alg alg, const u8 *key, int key_len,
alg                59 drivers/net/wireless/intersil/orinoco/wext.c 	switch (alg) {
alg               727 drivers/net/wireless/intersil/orinoco/wext.c 	int idx, alg = ext->alg, set_key = 1;
alg               744 drivers/net/wireless/intersil/orinoco/wext.c 		alg = IW_ENCODE_ALG_NONE;
alg               746 drivers/net/wireless/intersil/orinoco/wext.c 	if (priv->has_wpa && (alg != IW_ENCODE_ALG_TKIP)) {
alg               753 drivers/net/wireless/intersil/orinoco/wext.c 		set_key = ((alg == IW_ENCODE_ALG_TKIP) ||
alg               759 drivers/net/wireless/intersil/orinoco/wext.c 		switch (alg) {
alg               846 drivers/net/wireless/intersil/orinoco/wext.c 		ext->alg = IW_ENCODE_ALG_NONE;
alg               851 drivers/net/wireless/intersil/orinoco/wext.c 		ext->alg = IW_ENCODE_ALG_WEP;
alg               857 drivers/net/wireless/intersil/orinoco/wext.c 		ext->alg = IW_ENCODE_ALG_TKIP;
alg              1545 drivers/net/wireless/intersil/prism54/isl_ioctl.c 	int idx, alg = ext->alg, set_key = 1;
alg              1566 drivers/net/wireless/intersil/prism54/isl_ioctl.c 		alg = IW_ENCODE_ALG_NONE;
alg              1578 drivers/net/wireless/intersil/prism54/isl_ioctl.c 		switch (alg) {
alg              1707 drivers/net/wireless/intersil/prism54/isl_ioctl.c 		ext->alg = IW_ENCODE_ALG_NONE;
alg              1726 drivers/net/wireless/intersil/prism54/isl_ioctl.c 			ext->alg = IW_ENCODE_ALG_TKIP;
alg              1730 drivers/net/wireless/intersil/prism54/isl_ioctl.c 			ext->alg = IW_ENCODE_ALG_WEP;
alg              2284 drivers/net/wireless/rndis_wlan.c 	int ret, alg, length, chan = -1;
alg              2296 drivers/net/wireless/rndis_wlan.c 		alg = RNDIS_WLAN_ALG_WEP;
alg              2299 drivers/net/wireless/rndis_wlan.c 		alg = RNDIS_WLAN_ALG_NONE;
alg              2324 drivers/net/wireless/rndis_wlan.c 	ret = set_encr_mode(usbdev, alg, RNDIS_WLAN_ALG_NONE);
alg               242 drivers/net/xen-netback/common.h 	unsigned int alg;
alg               420 drivers/net/xen-netback/common.h u32 xenvif_set_hash_alg(struct xenvif *vif, u32 alg);
alg               244 drivers/net/xen-netback/hash.c u32 xenvif_set_hash_alg(struct xenvif *vif, u32 alg)
alg               246 drivers/net/xen-netback/hash.c 	switch (alg) {
alg               255 drivers/net/xen-netback/hash.c 	vif->hash.alg = alg;
alg               262 drivers/net/xen-netback/hash.c 	if (vif->hash.alg == XEN_NETIF_CTRL_HASH_ALGORITHM_NONE)
alg               281 drivers/net/xen-netback/hash.c 	if (vif->hash.alg == XEN_NETIF_CTRL_HASH_ALGORITHM_NONE)
alg               387 drivers/net/xen-netback/hash.c 	switch (vif->hash.alg) {
alg               163 drivers/net/xen-netback/interface.c 	if (vif->hash.alg == XEN_NETIF_CTRL_HASH_ALGORITHM_NONE)
alg               224 drivers/net/xen-netback/interface.c 	if (vif->hash.alg == XEN_NETIF_CTRL_HASH_ALGORITHM_NONE)
alg              4084 drivers/scsi/aic7xxx/aic79xx_core.c 	     struct ahd_devinfo *devinfo, ahd_queue_alg alg)
alg              4088 drivers/scsi/aic7xxx/aic79xx_core.c 	ahd_platform_set_tags(ahd, sdev, devinfo, alg);
alg              1403 drivers/scsi/aic7xxx/aic79xx_osm.c 		      struct ahd_devinfo *devinfo, ahd_queue_alg alg)
alg              1417 drivers/scsi/aic7xxx/aic79xx_osm.c 	switch (alg) {
alg              1455 drivers/scsi/aic7xxx/aic79xx_osm.c 		} else if (alg == AHD_QUEUE_TAGGED) {
alg              2670 drivers/scsi/aic7xxx/aic7xxx_core.c 	     struct ahc_devinfo *devinfo, ahc_queue_alg alg)
alg              2674 drivers/scsi/aic7xxx/aic7xxx_core.c  	ahc_platform_set_tags(ahc, sdev, devinfo, alg);
alg              1271 drivers/scsi/aic7xxx/aic7xxx_osm.c 		      struct ahc_devinfo *devinfo, ahc_queue_alg alg)
alg              1282 drivers/scsi/aic7xxx/aic7xxx_osm.c 	switch (alg) {
alg              1320 drivers/scsi/aic7xxx/aic7xxx_osm.c 		} else if (alg == AHC_QUEUE_TAGGED) {
alg               321 drivers/staging/ks7010/ks_wlan.h 	u16 alg;
alg              1569 drivers/staging/ks7010/ks_wlan_net.c 	switch (enc->alg) {
alg              1611 drivers/staging/ks7010/ks_wlan_net.c 	key->alg = enc->alg;
alg               214 drivers/staging/rtl8188eu/include/ieee80211.h 			u8 alg[IEEE_CRYPT_ALG_NAME_LEN];
alg                22 drivers/staging/rtl8188eu/include/rtw_security.h #define is_wep_enc(alg) (((alg) == _WEP40_) || ((alg) == _WEP104_))
alg               359 drivers/staging/rtl8188eu/os_dep/ioctl_linux.c 	param->u.crypt.alg[IEEE_CRYPT_ALG_NAME_LEN - 1] = '\0';
alg               376 drivers/staging/rtl8188eu/os_dep/ioctl_linux.c 	if (strcmp(param->u.crypt.alg, "WEP") == 0) {
alg               443 drivers/staging/rtl8188eu/os_dep/ioctl_linux.c 				if (strcmp(param->u.crypt.alg, "none") != 0)
alg               453 drivers/staging/rtl8188eu/os_dep/ioctl_linux.c 					if (strcmp(param->u.crypt.alg, "TKIP") == 0) { /* set mic key */
alg               479 drivers/staging/rtl8188eu/os_dep/ioctl_linux.c 				if (strcmp(param->u.crypt.alg, "none") != 0)
alg              1877 drivers/staging/rtl8188eu/os_dep/ioctl_linux.c 	switch (pext->alg) {
alg              1897 drivers/staging/rtl8188eu/os_dep/ioctl_linux.c 	strlcpy((char *)param->u.crypt.alg, alg_name, IEEE_CRYPT_ALG_NAME_LEN);
alg              1905 drivers/staging/rtl8188eu/os_dep/ioctl_linux.c 	if ((pext->alg != IW_ENCODE_ALG_WEP) &&
alg              2115 drivers/staging/rtl8188eu/os_dep/ioctl_linux.c static int set_group_key(struct adapter *padapter, u8 *key, u8 alg, int keyid)
alg              2139 drivers/staging/rtl8188eu/os_dep/ioctl_linux.c 	psetkeyparm->algorithm = alg;
alg              2143 drivers/staging/rtl8188eu/os_dep/ioctl_linux.c 	switch (alg) {
alg              2176 drivers/staging/rtl8188eu/os_dep/ioctl_linux.c 	u8 alg;
alg              2180 drivers/staging/rtl8188eu/os_dep/ioctl_linux.c 		alg = _WEP40_;
alg              2183 drivers/staging/rtl8188eu/os_dep/ioctl_linux.c 		alg = _WEP104_;
alg              2186 drivers/staging/rtl8188eu/os_dep/ioctl_linux.c 		alg = _NO_PRIVACY_;
alg              2189 drivers/staging/rtl8188eu/os_dep/ioctl_linux.c 	return set_group_key(padapter, key, alg, keyid);
alg              2205 drivers/staging/rtl8188eu/os_dep/ioctl_linux.c 	param->u.crypt.alg[IEEE_CRYPT_ALG_NAME_LEN - 1] = '\0';
alg              2223 drivers/staging/rtl8188eu/os_dep/ioctl_linux.c 	if (strcmp(param->u.crypt.alg, "none") == 0 && (!psta)) {
alg              2229 drivers/staging/rtl8188eu/os_dep/ioctl_linux.c 	if (strcmp(param->u.crypt.alg, "WEP") == 0 && (!psta)) {
alg              2295 drivers/staging/rtl8188eu/os_dep/ioctl_linux.c 			if (strcmp(param->u.crypt.alg, "WEP") == 0) {
alg              2304 drivers/staging/rtl8188eu/os_dep/ioctl_linux.c 			} else if (strcmp(param->u.crypt.alg, "TKIP") == 0) {
alg              2314 drivers/staging/rtl8188eu/os_dep/ioctl_linux.c 			} else if (strcmp(param->u.crypt.alg, "CCMP") == 0) {
alg              2341 drivers/staging/rtl8188eu/os_dep/ioctl_linux.c 				if (strcmp(param->u.crypt.alg, "WEP") == 0) {
alg              2347 drivers/staging/rtl8188eu/os_dep/ioctl_linux.c 				} else if (strcmp(param->u.crypt.alg, "TKIP") == 0) {
alg              2357 drivers/staging/rtl8188eu/os_dep/ioctl_linux.c 				} else if (strcmp(param->u.crypt.alg, "CCMP") == 0) {
alg              2371 drivers/staging/rtl8188eu/os_dep/ioctl_linux.c 				if (strcmp(param->u.crypt.alg, "WEP") == 0) {
alg              2377 drivers/staging/rtl8188eu/os_dep/ioctl_linux.c 				} else if (strcmp(param->u.crypt.alg, "TKIP") == 0) {
alg              2388 drivers/staging/rtl8188eu/os_dep/ioctl_linux.c 				} else if (strcmp(param->u.crypt.alg, "CCMP") == 0) {
alg               889 drivers/staging/rtl8192e/rtl8192e/rtl_wx.c 		u8 idx = 0, alg = 0, group = 0;
alg               892 drivers/staging/rtl8192e/rtl8192e/rtl_wx.c 		     ext->alg == IW_ENCODE_ALG_NONE) {
alg               900 drivers/staging/rtl8192e/rtl8192e/rtl_wx.c 		alg = (ext->alg == IW_ENCODE_ALG_CCMP) ? KEY_TYPE_CCMP :
alg               901 drivers/staging/rtl8192e/rtl8192e/rtl_wx.c 		      ext->alg;
alg               908 drivers/staging/rtl8192e/rtl8192e/rtl_wx.c 		    (alg ==  KEY_TYPE_WEP40)) {
alg               909 drivers/staging/rtl8192e/rtl8192e/rtl_wx.c 			if ((ext->key_len == 13) && (alg == KEY_TYPE_WEP40))
alg               910 drivers/staging/rtl8192e/rtl8192e/rtl_wx.c 				alg = KEY_TYPE_WEP104;
alg               911 drivers/staging/rtl8192e/rtl8192e/rtl_wx.c 			ieee->pairwise_key_type = alg;
alg               916 drivers/staging/rtl8192e/rtl8192e/rtl_wx.c 		if ((alg & KEY_TYPE_WEP40) && (ieee->auth_mode != 2)) {
alg               918 drivers/staging/rtl8192e/rtl8192e/rtl_wx.c 				ieee->pairwise_key_type = alg = KEY_TYPE_WEP104;
alg               919 drivers/staging/rtl8192e/rtl8192e/rtl_wx.c 			rtl92e_set_key(dev, idx, idx, alg, zero, 0, key);
alg               920 drivers/staging/rtl8192e/rtl8192e/rtl_wx.c 			rtl92e_set_swcam(dev, idx, idx, alg, zero, 0, key, 0);
alg               922 drivers/staging/rtl8192e/rtl8192e/rtl_wx.c 			ieee->group_key_type = alg;
alg               923 drivers/staging/rtl8192e/rtl8192e/rtl_wx.c 			rtl92e_set_key(dev, idx, idx, alg, broadcast_addr, 0,
alg               925 drivers/staging/rtl8192e/rtl8192e/rtl_wx.c 			rtl92e_set_swcam(dev, idx, idx, alg, broadcast_addr, 0,
alg               931 drivers/staging/rtl8192e/rtl8192e/rtl_wx.c 			rtl92e_set_key(dev, 4, idx, alg,
alg               933 drivers/staging/rtl8192e/rtl8192e/rtl_wx.c 			rtl92e_set_swcam(dev, 4, idx, alg,
alg               519 drivers/staging/rtl8192e/rtllib_wx.c 	const char *alg, *module;
alg               539 drivers/staging/rtl8192e/rtllib_wx.c 		if (idx != 0 && ext->alg != IW_ENCODE_ALG_WEP)
alg               549 drivers/staging/rtl8192e/rtllib_wx.c 	    ext->alg == IW_ENCODE_ALG_NONE) {
alg               566 drivers/staging/rtl8192e/rtllib_wx.c 	switch (ext->alg) {
alg               568 drivers/staging/rtl8192e/rtllib_wx.c 		alg = "R-WEP";
alg               572 drivers/staging/rtl8192e/rtllib_wx.c 		alg = "R-TKIP";
alg               576 drivers/staging/rtl8192e/rtllib_wx.c 		alg = "R-CCMP";
alg               580 drivers/staging/rtl8192e/rtllib_wx.c 		netdev_dbg(ieee->dev, "Unknown crypto alg %d\n", ext->alg);
alg               584 drivers/staging/rtl8192e/rtllib_wx.c 	netdev_dbg(dev, "alg name:%s\n", alg);
alg               586 drivers/staging/rtl8192e/rtllib_wx.c 	ops = lib80211_get_crypto_ops(alg);
alg               593 drivers/staging/rtl8192e/rtllib_wx.c 		ops = lib80211_get_crypto_ops(alg);
alg               596 drivers/staging/rtl8192e/rtllib_wx.c 		netdev_info(dev, "========>unknown crypto alg %d\n", ext->alg);
alg               636 drivers/staging/rtl8192e/rtllib_wx.c 	if (ext->alg != IW_ENCODE_ALG_NONE) {
alg               639 drivers/staging/rtl8192e/rtllib_wx.c 		if (ext->alg == IW_ENCODE_ALG_WEP) {
alg               642 drivers/staging/rtl8192e/rtllib_wx.c 		} else if (ext->alg == IW_ENCODE_ALG_TKIP) {
alg               645 drivers/staging/rtl8192e/rtllib_wx.c 		} else if (ext->alg == IW_ENCODE_ALG_CCMP) {
alg               313 drivers/staging/rtl8192u/ieee80211/ieee80211.h 			u8 alg[IEEE_CRYPT_ALG_NAME_LEN];
alg               101 drivers/staging/rtl8192u/ieee80211/ieee80211_crypt.c 	struct ieee80211_crypto_alg *alg;
alg               106 drivers/staging/rtl8192u/ieee80211/ieee80211_crypt.c 	alg = kzalloc(sizeof(*alg), GFP_KERNEL);
alg               107 drivers/staging/rtl8192u/ieee80211/ieee80211_crypt.c 	if (!alg)
alg               110 drivers/staging/rtl8192u/ieee80211/ieee80211_crypt.c 	alg->ops = ops;
alg               113 drivers/staging/rtl8192u/ieee80211/ieee80211_crypt.c 	list_add(&alg->list, &hcrypt->algs);
alg               133 drivers/staging/rtl8192u/ieee80211/ieee80211_crypt.c 		struct ieee80211_crypto_alg *alg =
alg               135 drivers/staging/rtl8192u/ieee80211/ieee80211_crypt.c 		if (alg->ops == ops) {
alg               136 drivers/staging/rtl8192u/ieee80211/ieee80211_crypt.c 			list_del(&alg->list);
alg               137 drivers/staging/rtl8192u/ieee80211/ieee80211_crypt.c 			del_alg = alg;
alg               164 drivers/staging/rtl8192u/ieee80211/ieee80211_crypt.c 		struct ieee80211_crypto_alg *alg =
alg               166 drivers/staging/rtl8192u/ieee80211/ieee80211_crypt.c 		if (strcmp(alg->ops->name, name) == 0) {
alg               167 drivers/staging/rtl8192u/ieee80211/ieee80211_crypt.c 			found_alg = alg;
alg               226 drivers/staging/rtl8192u/ieee80211/ieee80211_crypt.c 		struct ieee80211_crypto_alg *alg =
alg               230 drivers/staging/rtl8192u/ieee80211/ieee80211_crypt.c 				alg->ops->name);
alg               231 drivers/staging/rtl8192u/ieee80211/ieee80211_crypt.c 		kfree(alg);
alg              2802 drivers/staging/rtl8192u/ieee80211/ieee80211_softmac.c 	param->u.crypt.alg[IEEE_CRYPT_ALG_NAME_LEN - 1] = '\0';
alg              2819 drivers/staging/rtl8192u/ieee80211/ieee80211_softmac.c 	if (strcmp(param->u.crypt.alg, "none") == 0) {
alg              2837 drivers/staging/rtl8192u/ieee80211/ieee80211_softmac.c 	    strcmp(param->u.crypt.alg, "TKIP"))
alg              2841 drivers/staging/rtl8192u/ieee80211/ieee80211_softmac.c 	if (!strcmp(param->u.crypt.alg, "WEP"))
alg              2843 drivers/staging/rtl8192u/ieee80211/ieee80211_softmac.c 	else if (!strcmp(param->u.crypt.alg, "TKIP"))
alg              2845 drivers/staging/rtl8192u/ieee80211/ieee80211_softmac.c 	else if (!strcmp(param->u.crypt.alg, "CCMP"))
alg              2848 drivers/staging/rtl8192u/ieee80211/ieee80211_softmac.c 		ops = try_then_request_module(ieee80211_get_crypto_ops(param->u.crypt.alg),
alg              2851 drivers/staging/rtl8192u/ieee80211/ieee80211_softmac.c 		printk("unknown crypto alg '%s'\n", param->u.crypt.alg);
alg              2906 drivers/staging/rtl8192u/ieee80211/ieee80211_softmac.c 	if (strcmp(param->u.crypt.alg, "WEP") == 0) {
alg              2909 drivers/staging/rtl8192u/ieee80211/ieee80211_softmac.c 	} else if (strcmp(param->u.crypt.alg, "TKIP") == 0) {
alg              2912 drivers/staging/rtl8192u/ieee80211/ieee80211_softmac.c 	} else if (strcmp(param->u.crypt.alg, "CCMP") == 0) {
alg               499 drivers/staging/rtl8192u/ieee80211/ieee80211_wx.c 	const char *alg, *module;
alg               521 drivers/staging/rtl8192u/ieee80211/ieee80211_wx.c 		if (idx != 0 && ext->alg != IW_ENCODE_ALG_WEP)
alg               533 drivers/staging/rtl8192u/ieee80211/ieee80211_wx.c 	    ext->alg == IW_ENCODE_ALG_NONE) {
alg               554 drivers/staging/rtl8192u/ieee80211/ieee80211_wx.c 	switch (ext->alg) {
alg               556 drivers/staging/rtl8192u/ieee80211/ieee80211_wx.c 		alg = "WEP";
alg               560 drivers/staging/rtl8192u/ieee80211/ieee80211_wx.c 		alg = "TKIP";
alg               564 drivers/staging/rtl8192u/ieee80211/ieee80211_wx.c 		alg = "CCMP";
alg               569 drivers/staging/rtl8192u/ieee80211/ieee80211_wx.c 				   dev->name, ext->alg);
alg               573 drivers/staging/rtl8192u/ieee80211/ieee80211_wx.c 	printk("alg name:%s\n", alg);
alg               575 drivers/staging/rtl8192u/ieee80211/ieee80211_wx.c 	ops = try_then_request_module(ieee80211_get_crypto_ops(alg), module);
alg               578 drivers/staging/rtl8192u/ieee80211/ieee80211_wx.c 				   dev->name, ext->alg);
alg               579 drivers/staging/rtl8192u/ieee80211/ieee80211_wx.c 		printk("========>unknown crypto alg %d\n", ext->alg);
alg               620 drivers/staging/rtl8192u/ieee80211/ieee80211_wx.c 	if (ext->alg != IW_ENCODE_ALG_NONE) {
alg               624 drivers/staging/rtl8192u/ieee80211/ieee80211_wx.c 		if (ext->alg == IW_ENCODE_ALG_WEP) {
alg               628 drivers/staging/rtl8192u/ieee80211/ieee80211_wx.c 		} else if (ext->alg == IW_ENCODE_ALG_TKIP) {
alg               632 drivers/staging/rtl8192u/ieee80211/ieee80211_wx.c 		} else if (ext->alg == IW_ENCODE_ALG_CCMP) {
alg               677 drivers/staging/rtl8192u/ieee80211/ieee80211_wx.c 	    ext->alg != IW_ENCODE_ALG_WEP)
alg               686 drivers/staging/rtl8192u/ieee80211/ieee80211_wx.c 		ext->alg = IW_ENCODE_ALG_NONE;
alg               691 drivers/staging/rtl8192u/ieee80211/ieee80211_wx.c 			ext->alg = IW_ENCODE_ALG_WEP;
alg               693 drivers/staging/rtl8192u/ieee80211/ieee80211_wx.c 			ext->alg = IW_ENCODE_ALG_TKIP;
alg               695 drivers/staging/rtl8192u/ieee80211/ieee80211_wx.c 			ext->alg = IW_ENCODE_ALG_CCMP;
alg               701 drivers/staging/rtl8192u/ieee80211/ieee80211_wx.c 		    (ext->alg == IW_ENCODE_ALG_TKIP ||
alg               702 drivers/staging/rtl8192u/ieee80211/ieee80211_wx.c 		     ext->alg == IW_ENCODE_ALG_CCMP))
alg              3552 drivers/staging/rtl8192u/r8192U_core.c 				if (strcmp(ipw->u.crypt.alg, "CCMP") == 0) {
alg              3554 drivers/staging/rtl8192u/r8192U_core.c 				} else if (strcmp(ipw->u.crypt.alg, "TKIP") == 0) {
alg              3556 drivers/staging/rtl8192u/r8192U_core.c 				} else if (strcmp(ipw->u.crypt.alg, "WEP") == 0) {
alg              3587 drivers/staging/rtl8192u/r8192U_core.c 				if (strcmp(ipw->u.crypt.alg, "CCMP") == 0) {
alg              3589 drivers/staging/rtl8192u/r8192U_core.c 				} else if (strcmp(ipw->u.crypt.alg, "TKIP") == 0) {
alg              3591 drivers/staging/rtl8192u/r8192U_core.c 				} else if (strcmp(ipw->u.crypt.alg, "WEP") == 0) {
alg               739 drivers/staging/rtl8192u/r8192U_wx.c 		u8 idx = 0, alg = 0, group = 0;
alg               741 drivers/staging/rtl8192u/r8192U_wx.c 		if ((encoding->flags & IW_ENCODE_DISABLED) || ext->alg == IW_ENCODE_ALG_NONE)
alg               746 drivers/staging/rtl8192u/r8192U_wx.c 		alg =  (ext->alg == IW_ENCODE_ALG_CCMP)?KEY_TYPE_CCMP:ext->alg;
alg               752 drivers/staging/rtl8192u/r8192U_wx.c 		if ((!group) || (IW_MODE_ADHOC == ieee->iw_mode) || (alg ==  KEY_TYPE_WEP40)) {
alg               753 drivers/staging/rtl8192u/r8192U_wx.c 			if ((ext->key_len == 13) && (alg == KEY_TYPE_WEP40))
alg               754 drivers/staging/rtl8192u/r8192U_wx.c 				alg = KEY_TYPE_WEP104;
alg               755 drivers/staging/rtl8192u/r8192U_wx.c 			ieee->pairwise_key_type = alg;
alg               760 drivers/staging/rtl8192u/r8192U_wx.c 		if ((alg & KEY_TYPE_WEP40) && (ieee->auth_mode != 2)) {
alg               765 drivers/staging/rtl8192u/r8192U_wx.c 					alg,	/* KeyType */
alg               770 drivers/staging/rtl8192u/r8192U_wx.c 			ieee->group_key_type = alg;
alg               774 drivers/staging/rtl8192u/r8192U_wx.c 					alg,	/* KeyType */
alg               782 drivers/staging/rtl8192u/r8192U_wx.c 					alg,	/* KeyType */
alg                94 drivers/staging/rtl8712/ieee80211.h 			u8 alg[IEEE_CRYPT_ALG_NAME_LEN];
alg                85 drivers/staging/rtl8712/rtl871x_ioctl_linux.c 	if (strcmp(param->u.crypt.alg, "TKIP") == 0) { /* set mic key */
alg               383 drivers/staging/rtl8712/rtl871x_ioctl_linux.c 	param->u.crypt.alg[IEEE_CRYPT_ALG_NAME_LEN - 1] = '\0';
alg               394 drivers/staging/rtl8712/rtl871x_ioctl_linux.c 	if (strcmp(param->u.crypt.alg, "WEP") == 0) {
alg              1768 drivers/staging/rtl8712/rtl871x_ioctl_linux.c 	switch (pext->alg) {
alg              1791 drivers/staging/rtl8712/rtl871x_ioctl_linux.c 	strlcpy((char *)param->u.crypt.alg, alg_name, IEEE_CRYPT_ALG_NAME_LEN);
alg              1479 drivers/staging/rtl8723bs/core/rtw_ap.c 	u8 alg,
alg              1505 drivers/staging/rtl8723bs/core/rtw_ap.c 	if (is_wep_enc(alg))
alg              1508 drivers/staging/rtl8723bs/core/rtw_ap.c 	psetkeyparm->algorithm = alg;
alg              1512 drivers/staging/rtl8723bs/core/rtw_ap.c 	switch (alg) {
alg              1543 drivers/staging/rtl8723bs/core/rtw_ap.c int rtw_ap_set_group_key(struct adapter *padapter, u8 *key, u8 alg, int keyid)
alg              1547 drivers/staging/rtl8723bs/core/rtw_ap.c 	return rtw_ap_set_key(padapter, key, alg, keyid, 1);
alg              1558 drivers/staging/rtl8723bs/core/rtw_ap.c 	u8 alg;
alg              1562 drivers/staging/rtl8723bs/core/rtw_ap.c 		alg = _WEP40_;
alg              1565 drivers/staging/rtl8723bs/core/rtw_ap.c 		alg = _WEP104_;
alg              1568 drivers/staging/rtl8723bs/core/rtw_ap.c 		alg = _NO_PRIVACY_;
alg              1573 drivers/staging/rtl8723bs/core/rtw_ap.c 	return rtw_ap_set_key(padapter, key, alg, keyid, set_tx);
alg               223 drivers/staging/rtl8723bs/include/ieee80211.h 			u8 alg[IEEE_CRYPT_ALG_NAME_LEN];
alg                25 drivers/staging/rtl8723bs/include/rtw_ap.h int rtw_ap_set_group_key(struct adapter *padapter, u8 *key, u8 alg, int keyid);
alg                20 drivers/staging/rtl8723bs/include/rtw_security.h #define is_wep_enc(alg) (((alg) == _WEP40_) || ((alg) == _WEP104_))
alg               598 drivers/staging/rtl8723bs/os_dep/ioctl_cfg80211.c 	param->u.crypt.alg[IEEE_CRYPT_ALG_NAME_LEN - 1] = '\0';
alg               627 drivers/staging/rtl8723bs/os_dep/ioctl_cfg80211.c 	if (strcmp(param->u.crypt.alg, "none") == 0 && (psta == NULL))
alg               637 drivers/staging/rtl8723bs/os_dep/ioctl_cfg80211.c 	if (strcmp(param->u.crypt.alg, "WEP") == 0 && (psta == NULL))
alg               690 drivers/staging/rtl8723bs/os_dep/ioctl_cfg80211.c 			if (strcmp(param->u.crypt.alg, "WEP") == 0)
alg               703 drivers/staging/rtl8723bs/os_dep/ioctl_cfg80211.c 			else if (strcmp(param->u.crypt.alg, "TKIP") == 0)
alg               719 drivers/staging/rtl8723bs/os_dep/ioctl_cfg80211.c 			else if (strcmp(param->u.crypt.alg, "CCMP") == 0)
alg               763 drivers/staging/rtl8723bs/os_dep/ioctl_cfg80211.c 				if (strcmp(param->u.crypt.alg, "WEP") == 0)
alg               773 drivers/staging/rtl8723bs/os_dep/ioctl_cfg80211.c 				else if (strcmp(param->u.crypt.alg, "TKIP") == 0)
alg               787 drivers/staging/rtl8723bs/os_dep/ioctl_cfg80211.c 				else if (strcmp(param->u.crypt.alg, "CCMP") == 0)
alg               810 drivers/staging/rtl8723bs/os_dep/ioctl_cfg80211.c 				if (strcmp(param->u.crypt.alg, "WEP") == 0)
alg               820 drivers/staging/rtl8723bs/os_dep/ioctl_cfg80211.c 				else if (strcmp(param->u.crypt.alg, "TKIP") == 0)
alg               834 drivers/staging/rtl8723bs/os_dep/ioctl_cfg80211.c 				else if (strcmp(param->u.crypt.alg, "CCMP") == 0)
alg               883 drivers/staging/rtl8723bs/os_dep/ioctl_cfg80211.c 	param->u.crypt.alg[IEEE_CRYPT_ALG_NAME_LEN - 1] = '\0';
alg               909 drivers/staging/rtl8723bs/os_dep/ioctl_cfg80211.c 	if (strcmp(param->u.crypt.alg, "WEP") == 0)
alg               968 drivers/staging/rtl8723bs/os_dep/ioctl_cfg80211.c 				if (strcmp(param->u.crypt.alg, "none") != 0)
alg               985 drivers/staging/rtl8723bs/os_dep/ioctl_cfg80211.c 					if (strcmp(param->u.crypt.alg, "TKIP") == 0)/* set mic key */
alg              1002 drivers/staging/rtl8723bs/os_dep/ioctl_cfg80211.c 					if (strcmp(param->u.crypt.alg, "TKIP") == 0 || strcmp(param->u.crypt.alg, "CCMP") == 0)
alg              1014 drivers/staging/rtl8723bs/os_dep/ioctl_cfg80211.c 					else if (strcmp(param->u.crypt.alg, "BIP") == 0)
alg              1038 drivers/staging/rtl8723bs/os_dep/ioctl_cfg80211.c 				if (strcmp(param->u.crypt.alg, "none") != 0)
alg              1112 drivers/staging/rtl8723bs/os_dep/ioctl_cfg80211.c 	strncpy((char *)param->u.crypt.alg, alg_name, IEEE_CRYPT_ALG_NAME_LEN);
alg               432 drivers/staging/rtl8723bs/os_dep/ioctl_linux.c 	param->u.crypt.alg[IEEE_CRYPT_ALG_NAME_LEN - 1] = '\0';
alg               454 drivers/staging/rtl8723bs/os_dep/ioctl_linux.c 	if (strcmp(param->u.crypt.alg, "WEP") == 0) {
alg               533 drivers/staging/rtl8723bs/os_dep/ioctl_linux.c 				if (strcmp(param->u.crypt.alg, "none") != 0)
alg               544 drivers/staging/rtl8723bs/os_dep/ioctl_linux.c 					if (strcmp(param->u.crypt.alg, "TKIP") == 0) { /* set mic key */
alg               558 drivers/staging/rtl8723bs/os_dep/ioctl_linux.c 					if (strcmp(param->u.crypt.alg, "TKIP") == 0 || strcmp(param->u.crypt.alg, "CCMP") == 0) {
alg               572 drivers/staging/rtl8723bs/os_dep/ioctl_linux.c 					} else if (strcmp(param->u.crypt.alg, "BIP") == 0) {
alg               592 drivers/staging/rtl8723bs/os_dep/ioctl_linux.c 				if (strcmp(param->u.crypt.alg, "none") != 0)
alg              2147 drivers/staging/rtl8723bs/os_dep/ioctl_linux.c 	switch (pext->alg) {
alg              2170 drivers/staging/rtl8723bs/os_dep/ioctl_linux.c 	strncpy((char *)param->u.crypt.alg, alg_name, IEEE_CRYPT_ALG_NAME_LEN);
alg              2178 drivers/staging/rtl8723bs/os_dep/ioctl_linux.c 	if ((pext->alg != IW_ENCODE_ALG_WEP) &&
alg              3452 drivers/staging/rtl8723bs/os_dep/ioctl_linux.c 	param->u.crypt.alg[IEEE_CRYPT_ALG_NAME_LEN - 1] = '\0';
alg              3477 drivers/staging/rtl8723bs/os_dep/ioctl_linux.c 	if (strcmp(param->u.crypt.alg, "none") == 0 && (psta == NULL)) {
alg              3491 drivers/staging/rtl8723bs/os_dep/ioctl_linux.c 	if (strcmp(param->u.crypt.alg, "WEP") == 0 && (psta == NULL)) {
alg              3564 drivers/staging/rtl8723bs/os_dep/ioctl_linux.c 			if (strcmp(param->u.crypt.alg, "WEP") == 0) {
alg              3573 drivers/staging/rtl8723bs/os_dep/ioctl_linux.c 			} else if (strcmp(param->u.crypt.alg, "TKIP") == 0) {
alg              3588 drivers/staging/rtl8723bs/os_dep/ioctl_linux.c 			else if (strcmp(param->u.crypt.alg, "CCMP") == 0) {
alg              3624 drivers/staging/rtl8723bs/os_dep/ioctl_linux.c 				if (strcmp(param->u.crypt.alg, "WEP") == 0) {
alg              3630 drivers/staging/rtl8723bs/os_dep/ioctl_linux.c 				} else if (strcmp(param->u.crypt.alg, "TKIP") == 0) {
alg              3642 drivers/staging/rtl8723bs/os_dep/ioctl_linux.c 				} else if (strcmp(param->u.crypt.alg, "CCMP") == 0) {
alg              3658 drivers/staging/rtl8723bs/os_dep/ioctl_linux.c 				if (strcmp(param->u.crypt.alg, "WEP") == 0) {
alg              3664 drivers/staging/rtl8723bs/os_dep/ioctl_linux.c 				} else if (strcmp(param->u.crypt.alg, "TKIP") == 0) {
alg              3676 drivers/staging/rtl8723bs/os_dep/ioctl_linux.c 				} else if (strcmp(param->u.crypt.alg, "CCMP") == 0) {
alg                25 fs/erofs/compress.h 	unsigned int alg;
alg               224 fs/erofs/decompressor.c 	const struct z_erofs_decompressor *alg = decompressors + rq->alg;
alg               247 fs/erofs/decompressor.c 		ret = alg->decompress(rq, dst);
alg               256 fs/erofs/decompressor.c 	ret = alg->prepare_destpages(rq, pagepool);
alg               281 fs/erofs/decompressor.c 	ret = alg->decompress(rq, dst + rq->pageofs_out);
alg               332 fs/erofs/decompressor.c 	if (rq->alg == Z_EROFS_COMPRESSION_SHIFTED)
alg               902 fs/erofs/zdata.c 					.alg = pcl->algorithmformat,
alg               119 fs/verity/fsverity_private.h const u8 *fsverity_prepare_hash_state(const struct fsverity_hash_alg *alg,
alg               124 fs/verity/fsverity_private.h int fsverity_hash_buffer(const struct fsverity_hash_alg *alg,
alg                42 fs/verity/hash_algs.c 	struct fsverity_hash_alg *alg;
alg                51 fs/verity/hash_algs.c 	alg = &fsverity_hash_algs[num];
alg                54 fs/verity/hash_algs.c 	tfm = READ_ONCE(alg->tfm);
alg                56 fs/verity/hash_algs.c 		return alg;
alg                61 fs/verity/hash_algs.c 	tfm = crypto_alloc_ahash(alg->name, 0, 0);
alg                66 fs/verity/hash_algs.c 				      alg->name);
alg                71 fs/verity/hash_algs.c 			     alg->name, PTR_ERR(tfm));
alg                76 fs/verity/hash_algs.c 	if (WARN_ON(alg->digest_size != crypto_ahash_digestsize(tfm)))
alg                78 fs/verity/hash_algs.c 	if (WARN_ON(alg->block_size != crypto_ahash_blocksize(tfm)))
alg                82 fs/verity/hash_algs.c 		alg->name, crypto_ahash_driver_name(tfm));
alg                85 fs/verity/hash_algs.c 	if (cmpxchg(&alg->tfm, NULL, tfm) != NULL)
alg                88 fs/verity/hash_algs.c 	return alg;
alg               104 fs/verity/hash_algs.c const u8 *fsverity_prepare_hash_state(const struct fsverity_hash_alg *alg,
alg               118 fs/verity/hash_algs.c 	hashstate = kmalloc(crypto_ahash_statesize(alg->tfm), GFP_KERNEL);
alg               122 fs/verity/hash_algs.c 	req = ahash_request_alloc(alg->tfm, GFP_KERNEL);
alg               135 fs/verity/hash_algs.c 	padded_salt_size = round_up(salt_size, alg->block_size);
alg               232 fs/verity/hash_algs.c int fsverity_hash_buffer(const struct fsverity_hash_alg *alg,
alg               240 fs/verity/hash_algs.c 	req = ahash_request_alloc(alg->tfm, GFP_KERNEL);
alg               265 fs/verity/hash_algs.c 		const struct fsverity_hash_alg *alg = &fsverity_hash_algs[i];
alg               267 fs/verity/hash_algs.c 		if (!alg->name)
alg               270 fs/verity/hash_algs.c 		BUG_ON(alg->digest_size > FS_VERITY_MAX_DIGEST_SIZE);
alg               277 fs/verity/hash_algs.c 		BUG_ON(!is_power_of_2(alg->digest_size));
alg               278 fs/verity/hash_algs.c 		BUG_ON(!is_power_of_2(alg->block_size));
alg               115 include/crypto/acompress.h static inline struct acomp_alg *__crypto_acomp_alg(struct crypto_alg *alg)
alg               117 include/crypto/acompress.h 	return container_of(alg, struct acomp_alg, base);
alg               244 include/crypto/acompress.h 	struct crypto_alg *alg = tfm->base.__crt_alg;
alg               248 include/crypto/acompress.h 	crypto_stats_get(alg);
alg               250 include/crypto/acompress.h 	crypto_stats_compress(slen, ret, alg);
alg               266 include/crypto/acompress.h 	struct crypto_alg *alg = tfm->base.__crt_alg;
alg               270 include/crypto/acompress.h 	crypto_stats_get(alg);
alg               272 include/crypto/acompress.h 	crypto_stats_decompress(slen, ret, alg);
alg               194 include/crypto/aead.h static inline unsigned int crypto_aead_alg_ivsize(struct aead_alg *alg)
alg               196 include/crypto/aead.h 	return alg->ivsize;
alg               139 include/crypto/akcipher.h static inline struct akcipher_alg *__crypto_akcipher_alg(struct crypto_alg *alg)
alg               141 include/crypto/akcipher.h 	return container_of(alg, struct akcipher_alg, base);
alg               270 include/crypto/akcipher.h 	struct akcipher_alg *alg = crypto_akcipher_alg(tfm);
alg               272 include/crypto/akcipher.h 	return alg->max_size(tfm);
alg               288 include/crypto/akcipher.h 	struct akcipher_alg *alg = crypto_akcipher_alg(tfm);
alg               294 include/crypto/akcipher.h 	ret = alg->encrypt(req);
alg               312 include/crypto/akcipher.h 	struct akcipher_alg *alg = crypto_akcipher_alg(tfm);
alg               318 include/crypto/akcipher.h 	ret = alg->decrypt(req);
alg               336 include/crypto/akcipher.h 	struct akcipher_alg *alg = crypto_akcipher_alg(tfm);
alg               341 include/crypto/akcipher.h 	ret = alg->sign(req);
alg               363 include/crypto/akcipher.h 	struct akcipher_alg *alg = crypto_akcipher_alg(tfm);
alg               368 include/crypto/akcipher.h 	ret = alg->verify(req);
alg               390 include/crypto/akcipher.h 	struct akcipher_alg *alg = crypto_akcipher_alg(tfm);
alg               392 include/crypto/akcipher.h 	return alg->set_pub_key(tfm, key, keylen);
alg               412 include/crypto/akcipher.h 	struct akcipher_alg *alg = crypto_akcipher_alg(tfm);
alg               414 include/crypto/akcipher.h 	return alg->set_priv_key(tfm, key, keylen);
alg                32 include/crypto/algapi.h 	unsigned int (*ctxsize)(struct crypto_alg *alg, u32 type, u32 mask);
alg                33 include/crypto/algapi.h 	unsigned int (*extsize)(struct crypto_alg *alg);
alg                36 include/crypto/algapi.h 	void (*show)(struct seq_file *m, struct crypto_alg *alg);
alg                37 include/crypto/algapi.h 	int (*report)(struct sk_buff *skb, struct crypto_alg *alg);
alg                47 include/crypto/algapi.h 	struct crypto_alg alg;
alg                69 include/crypto/algapi.h 	struct crypto_alg *alg;
alg               138 include/crypto/algapi.h void crypto_mod_put(struct crypto_alg *alg);
alg               150 include/crypto/algapi.h int crypto_init_spawn(struct crypto_spawn *spawn, struct crypto_alg *alg,
alg               152 include/crypto/algapi.h int crypto_init_spawn2(struct crypto_spawn *spawn, struct crypto_alg *alg,
alg               184 include/crypto/algapi.h 			struct crypto_alg *alg);
alg               185 include/crypto/algapi.h void *crypto_alloc_instance(const char *name, struct crypto_alg *alg,
alg               265 include/crypto/algapi.h 	return container_of(tfm->__crt_alg, struct crypto_instance, alg);
alg               312 include/crypto/hash.h 	struct crypto_alg *alg)
alg               314 include/crypto/hash.h 	return container_of(alg, struct hash_alg_common, base);
alg               529 include/crypto/hash.h 	struct crypto_alg *alg = tfm->base.__crt_alg;
alg               533 include/crypto/hash.h 	crypto_stats_get(alg);
alg               535 include/crypto/hash.h 	crypto_stats_ahash_update(nbytes, ret, alg);
alg               742 include/crypto/hash.h static inline struct shash_alg *__crypto_shash_alg(struct crypto_alg *alg)
alg               744 include/crypto/hash.h 	return container_of(alg, struct shash_alg, base);
alg                62 include/crypto/internal/acompress.h int crypto_register_acomp(struct acomp_alg *alg);
alg                74 include/crypto/internal/acompress.h int crypto_unregister_acomp(struct acomp_alg *alg);
alg                25 include/crypto/internal/aead.h 		struct aead_alg alg;
alg                45 include/crypto/internal/aead.h 	return container_of(&inst->alg.base, struct crypto_instance, alg);
alg                50 include/crypto/internal/aead.h 	return container_of(&inst->alg, struct aead_instance, alg.base);
alg               101 include/crypto/internal/aead.h 	return container_of(spawn->base.alg, struct aead_alg, base);
alg               116 include/crypto/internal/aead.h static inline unsigned int crypto_aead_alg_maxauthsize(struct aead_alg *alg)
alg               118 include/crypto/internal/aead.h 	return alg->maxauthsize;
alg               157 include/crypto/internal/aead.h static inline unsigned int crypto_aead_alg_chunksize(struct aead_alg *alg)
alg               159 include/crypto/internal/aead.h 	return alg->chunksize;
alg               178 include/crypto/internal/aead.h int crypto_register_aead(struct aead_alg *alg);
alg               179 include/crypto/internal/aead.h void crypto_unregister_aead(struct aead_alg *alg);
alg                20 include/crypto/internal/akcipher.h 		struct akcipher_alg alg;
alg                61 include/crypto/internal/akcipher.h 	return container_of(&inst->alg.base, struct crypto_instance, alg);
alg                67 include/crypto/internal/akcipher.h 	return container_of(&inst->alg, struct akcipher_instance, alg.base);
alg               105 include/crypto/internal/akcipher.h 	return container_of(spawn->base.alg, struct akcipher_alg, base);
alg               117 include/crypto/internal/akcipher.h int crypto_register_akcipher(struct akcipher_alg *alg);
alg               126 include/crypto/internal/akcipher.h void crypto_unregister_akcipher(struct akcipher_alg *alg);
alg                33 include/crypto/internal/hash.h 	struct ahash_alg alg;
alg                37 include/crypto/internal/hash.h 	struct shash_alg alg;
alg                72 include/crypto/internal/hash.h int crypto_register_ahash(struct ahash_alg *alg);
alg                73 include/crypto/internal/hash.h int crypto_unregister_ahash(struct ahash_alg *alg);
alg                83 include/crypto/internal/hash.h static inline bool crypto_shash_alg_has_setkey(struct shash_alg *alg)
alg                85 include/crypto/internal/hash.h 	return alg->setkey != shash_no_setkey;
alg                91 include/crypto/internal/hash.h 			    struct hash_alg_common *alg,
alg               101 include/crypto/internal/hash.h int crypto_register_shash(struct shash_alg *alg);
alg               102 include/crypto/internal/hash.h int crypto_unregister_shash(struct shash_alg *alg);
alg               110 include/crypto/internal/hash.h 			    struct shash_alg *alg,
alg               131 include/crypto/internal/hash.h static inline struct ahash_alg *__crypto_ahash_alg(struct crypto_alg *alg)
alg               133 include/crypto/internal/hash.h 	return container_of(__crypto_hash_alg_common(alg), struct ahash_alg,
alg               146 include/crypto/internal/hash.h 	return container_of(&inst->alg.halg.base, struct crypto_instance, alg);
alg               152 include/crypto/internal/hash.h 	return container_of(&inst->alg, struct ahash_instance, alg.halg.base);
alg               166 include/crypto/internal/hash.h 	const char *name, struct crypto_alg *alg)
alg               168 include/crypto/internal/hash.h 	return crypto_alloc_instance(name, alg, ahash_instance_headroom());
alg               207 include/crypto/internal/hash.h 	return container_of(&inst->alg.base, struct crypto_instance, alg);
alg               213 include/crypto/internal/hash.h 	return container_of(__crypto_shash_alg(&inst->alg),
alg               214 include/crypto/internal/hash.h 			    struct shash_instance, alg);
alg               223 include/crypto/internal/hash.h 	const char *name, struct crypto_alg *alg)
alg               225 include/crypto/internal/hash.h 	return crypto_alloc_instance(name, alg,
alg               226 include/crypto/internal/hash.h 				     sizeof(struct shash_alg) - sizeof(*alg));
alg                46 include/crypto/internal/kpp.h int crypto_register_kpp(struct kpp_alg *alg);
alg                57 include/crypto/internal/kpp.h void crypto_unregister_kpp(struct kpp_alg *alg);
alg                15 include/crypto/internal/rng.h int crypto_register_rng(struct rng_alg *alg);
alg                16 include/crypto/internal/rng.h void crypto_unregister_rng(struct rng_alg *alg);
alg                40 include/crypto/internal/scompress.h static inline struct scomp_alg *__crypto_scomp_alg(struct crypto_alg *alg)
alg                42 include/crypto/internal/scompress.h 	return container_of(alg, struct scomp_alg, base);
alg               106 include/crypto/internal/scompress.h int crypto_register_scomp(struct scomp_alg *alg);
alg               118 include/crypto/internal/scompress.h int crypto_unregister_scomp(struct scomp_alg *alg);
alg                22 include/crypto/internal/simd.h void simd_skcipher_free(struct simd_skcipher_alg *alg);
alg                40 include/crypto/internal/simd.h void simd_aead_free(struct simd_aead_alg *alg);
alg                26 include/crypto/internal/skcipher.h 		struct skcipher_alg alg;
alg                78 include/crypto/internal/skcipher.h 			    struct skcipher_instance, alg);
alg               108 include/crypto/internal/skcipher.h 	return container_of(spawn->base.alg, struct skcipher_alg, base);
alg               129 include/crypto/internal/skcipher.h int crypto_register_skcipher(struct skcipher_alg *alg);
alg               130 include/crypto/internal/skcipher.h void crypto_unregister_skcipher(struct skcipher_alg *alg);
alg               183 include/crypto/internal/skcipher.h 	struct skcipher_alg *alg)
alg               185 include/crypto/internal/skcipher.h 	if ((alg->base.cra_flags & CRYPTO_ALG_TYPE_MASK) ==
alg               187 include/crypto/internal/skcipher.h 		return alg->base.cra_blkcipher.min_keysize;
alg               189 include/crypto/internal/skcipher.h 	if (alg->base.cra_ablkcipher.encrypt)
alg               190 include/crypto/internal/skcipher.h 		return alg->base.cra_ablkcipher.min_keysize;
alg               192 include/crypto/internal/skcipher.h 	return alg->min_keysize;
alg               196 include/crypto/internal/skcipher.h 	struct skcipher_alg *alg)
alg               198 include/crypto/internal/skcipher.h 	if ((alg->base.cra_flags & CRYPTO_ALG_TYPE_MASK) ==
alg               200 include/crypto/internal/skcipher.h 		return alg->base.cra_blkcipher.max_keysize;
alg               202 include/crypto/internal/skcipher.h 	if (alg->base.cra_ablkcipher.encrypt)
alg               203 include/crypto/internal/skcipher.h 		return alg->base.cra_ablkcipher.max_keysize;
alg               205 include/crypto/internal/skcipher.h 	return alg->max_keysize;
alg               209 include/crypto/internal/skcipher.h 	struct skcipher_alg *alg)
alg               211 include/crypto/internal/skcipher.h 	if ((alg->base.cra_flags & CRYPTO_ALG_TYPE_MASK) ==
alg               213 include/crypto/internal/skcipher.h 		return alg->base.cra_blocksize;
alg               215 include/crypto/internal/skcipher.h 	if (alg->base.cra_ablkcipher.encrypt)
alg               216 include/crypto/internal/skcipher.h 		return alg->base.cra_blocksize;
alg               218 include/crypto/internal/skcipher.h 	return alg->walksize;
alg               112 include/crypto/kpp.h static inline struct kpp_alg *__crypto_kpp_alg(struct crypto_alg *alg)
alg               114 include/crypto/kpp.h 	return container_of(alg, struct kpp_alg, base);
alg               284 include/crypto/kpp.h 	struct kpp_alg *alg = crypto_kpp_alg(tfm);
alg               289 include/crypto/kpp.h 	ret = alg->set_secret(tfm, buffer, len);
alg               310 include/crypto/kpp.h 	struct kpp_alg *alg = crypto_kpp_alg(tfm);
alg               315 include/crypto/kpp.h 	ret = alg->generate_public_key(req);
alg               333 include/crypto/kpp.h 	struct kpp_alg *alg = crypto_kpp_alg(tfm);
alg               338 include/crypto/kpp.h 	ret = alg->compute_shared_secret(req);
alg               355 include/crypto/kpp.h 	struct kpp_alg *alg = crypto_kpp_alg(tfm);
alg               357 include/crypto/kpp.h 	return alg->max_size(tfm);
alg               138 include/crypto/rng.h 	struct crypto_alg *alg = tfm->base.__crt_alg;
alg               141 include/crypto/rng.h 	crypto_stats_get(alg);
alg               143 include/crypto/rng.h 	crypto_stats_rng_generate(alg, dlen, ret);
alg               259 include/crypto/skcipher.h static inline unsigned int crypto_skcipher_alg_ivsize(struct skcipher_alg *alg)
alg               261 include/crypto/skcipher.h 	if ((alg->base.cra_flags & CRYPTO_ALG_TYPE_MASK) ==
alg               263 include/crypto/skcipher.h 		return alg->base.cra_blkcipher.ivsize;
alg               265 include/crypto/skcipher.h 	if (alg->base.cra_ablkcipher.encrypt)
alg               266 include/crypto/skcipher.h 		return alg->base.cra_ablkcipher.ivsize;
alg               268 include/crypto/skcipher.h 	return alg->ivsize;
alg               308 include/crypto/skcipher.h 	struct skcipher_alg *alg)
alg               310 include/crypto/skcipher.h 	if ((alg->base.cra_flags & CRYPTO_ALG_TYPE_MASK) ==
alg               312 include/crypto/skcipher.h 		return alg->base.cra_blocksize;
alg               314 include/crypto/skcipher.h 	if (alg->base.cra_ablkcipher.encrypt)
alg               315 include/crypto/skcipher.h 		return alg->base.cra_blocksize;
alg               317 include/crypto/skcipher.h 	return alg->chunksize;
alg               120 include/linux/crush/crush.h extern const char *crush_bucket_alg_name(int alg);
alg               134 include/linux/crush/crush.h 	__u8 alg;        /* one of CRUSH_BUCKET_* */
alg               576 include/linux/crypto.h 	void (*cra_destroy)(struct crypto_alg *alg);
alg               595 include/linux/crypto.h void crypto_stats_init(struct crypto_alg *alg);
alg               596 include/linux/crypto.h void crypto_stats_get(struct crypto_alg *alg);
alg               597 include/linux/crypto.h void crypto_stats_ablkcipher_encrypt(unsigned int nbytes, int ret, struct crypto_alg *alg);
alg               598 include/linux/crypto.h void crypto_stats_ablkcipher_decrypt(unsigned int nbytes, int ret, struct crypto_alg *alg);
alg               599 include/linux/crypto.h void crypto_stats_aead_encrypt(unsigned int cryptlen, struct crypto_alg *alg, int ret);
alg               600 include/linux/crypto.h void crypto_stats_aead_decrypt(unsigned int cryptlen, struct crypto_alg *alg, int ret);
alg               601 include/linux/crypto.h void crypto_stats_ahash_update(unsigned int nbytes, int ret, struct crypto_alg *alg);
alg               602 include/linux/crypto.h void crypto_stats_ahash_final(unsigned int nbytes, int ret, struct crypto_alg *alg);
alg               603 include/linux/crypto.h void crypto_stats_akcipher_encrypt(unsigned int src_len, int ret, struct crypto_alg *alg);
alg               604 include/linux/crypto.h void crypto_stats_akcipher_decrypt(unsigned int src_len, int ret, struct crypto_alg *alg);
alg               605 include/linux/crypto.h void crypto_stats_akcipher_sign(int ret, struct crypto_alg *alg);
alg               606 include/linux/crypto.h void crypto_stats_akcipher_verify(int ret, struct crypto_alg *alg);
alg               607 include/linux/crypto.h void crypto_stats_compress(unsigned int slen, int ret, struct crypto_alg *alg);
alg               608 include/linux/crypto.h void crypto_stats_decompress(unsigned int slen, int ret, struct crypto_alg *alg);
alg               609 include/linux/crypto.h void crypto_stats_kpp_set_secret(struct crypto_alg *alg, int ret);
alg               610 include/linux/crypto.h void crypto_stats_kpp_generate_public_key(struct crypto_alg *alg, int ret);
alg               611 include/linux/crypto.h void crypto_stats_kpp_compute_shared_secret(struct crypto_alg *alg, int ret);
alg               612 include/linux/crypto.h void crypto_stats_rng_seed(struct crypto_alg *alg, int ret);
alg               613 include/linux/crypto.h void crypto_stats_rng_generate(struct crypto_alg *alg, unsigned int dlen, int ret);
alg               614 include/linux/crypto.h void crypto_stats_skcipher_encrypt(unsigned int cryptlen, int ret, struct crypto_alg *alg);
alg               615 include/linux/crypto.h void crypto_stats_skcipher_decrypt(unsigned int cryptlen, int ret, struct crypto_alg *alg);
alg               617 include/linux/crypto.h static inline void crypto_stats_init(struct crypto_alg *alg)
alg               619 include/linux/crypto.h static inline void crypto_stats_get(struct crypto_alg *alg)
alg               621 include/linux/crypto.h static inline void crypto_stats_ablkcipher_encrypt(unsigned int nbytes, int ret, struct crypto_alg *alg)
alg               623 include/linux/crypto.h static inline void crypto_stats_ablkcipher_decrypt(unsigned int nbytes, int ret, struct crypto_alg *alg)
alg               625 include/linux/crypto.h static inline void crypto_stats_aead_encrypt(unsigned int cryptlen, struct crypto_alg *alg, int ret)
alg               627 include/linux/crypto.h static inline void crypto_stats_aead_decrypt(unsigned int cryptlen, struct crypto_alg *alg, int ret)
alg               629 include/linux/crypto.h static inline void crypto_stats_ahash_update(unsigned int nbytes, int ret, struct crypto_alg *alg)
alg               631 include/linux/crypto.h static inline void crypto_stats_ahash_final(unsigned int nbytes, int ret, struct crypto_alg *alg)
alg               633 include/linux/crypto.h static inline void crypto_stats_akcipher_encrypt(unsigned int src_len, int ret, struct crypto_alg *alg)
alg               635 include/linux/crypto.h static inline void crypto_stats_akcipher_decrypt(unsigned int src_len, int ret, struct crypto_alg *alg)
alg               637 include/linux/crypto.h static inline void crypto_stats_akcipher_sign(int ret, struct crypto_alg *alg)
alg               639 include/linux/crypto.h static inline void crypto_stats_akcipher_verify(int ret, struct crypto_alg *alg)
alg               641 include/linux/crypto.h static inline void crypto_stats_compress(unsigned int slen, int ret, struct crypto_alg *alg)
alg               643 include/linux/crypto.h static inline void crypto_stats_decompress(unsigned int slen, int ret, struct crypto_alg *alg)
alg               645 include/linux/crypto.h static inline void crypto_stats_kpp_set_secret(struct crypto_alg *alg, int ret)
alg               647 include/linux/crypto.h static inline void crypto_stats_kpp_generate_public_key(struct crypto_alg *alg, int ret)
alg               649 include/linux/crypto.h static inline void crypto_stats_kpp_compute_shared_secret(struct crypto_alg *alg, int ret)
alg               651 include/linux/crypto.h static inline void crypto_stats_rng_seed(struct crypto_alg *alg, int ret)
alg               653 include/linux/crypto.h static inline void crypto_stats_rng_generate(struct crypto_alg *alg, unsigned int dlen, int ret)
alg               655 include/linux/crypto.h static inline void crypto_stats_skcipher_encrypt(unsigned int cryptlen, int ret, struct crypto_alg *alg)
alg               657 include/linux/crypto.h static inline void crypto_stats_skcipher_decrypt(unsigned int cryptlen, int ret, struct crypto_alg *alg)
alg               702 include/linux/crypto.h int crypto_register_alg(struct crypto_alg *alg);
alg               703 include/linux/crypto.h int crypto_unregister_alg(struct crypto_alg *alg);
alg               833 include/linux/crypto.h int alg_test(const char *driver, const char *alg, u32 type, u32 mask);
alg              1093 include/linux/crypto.h 	struct crypto_alg *alg = crt->base->base.__crt_alg;
alg              1097 include/linux/crypto.h 	crypto_stats_get(alg);
alg              1099 include/linux/crypto.h 	crypto_stats_ablkcipher_encrypt(nbytes, ret, alg);
alg              1118 include/linux/crypto.h 	struct crypto_alg *alg = crt->base->base.__crt_alg;
alg              1122 include/linux/crypto.h 	crypto_stats_get(alg);
alg              1124 include/linux/crypto.h 	crypto_stats_ablkcipher_decrypt(nbytes, ret, alg);
alg               603 include/linux/mlx5/mlx5_ifc_fpga.h 	u8         alg[4];
alg               394 include/media/davinci/isif.h 	__u8 alg;
alg              1748 include/net/xfrm.h static inline unsigned int aead_len(struct xfrm_algo_aead *alg)
alg              1750 include/net/xfrm.h 	return sizeof(*alg) + ((alg->alg_key_len + 7) / 8);
alg              1753 include/net/xfrm.h static inline unsigned int xfrm_alg_len(const struct xfrm_algo *alg)
alg              1755 include/net/xfrm.h 	return sizeof(*alg) + ((alg->alg_key_len + 7) / 8);
alg              1758 include/net/xfrm.h static inline unsigned int xfrm_alg_auth_len(const struct xfrm_algo_auth *alg)
alg              1760 include/net/xfrm.h 	return sizeof(*alg) + ((alg->alg_key_len + 7) / 8);
alg               830 include/uapi/linux/wireless.h 	__u16		alg; /* IW_ENCODE_ALG_* */
alg               141 include/uapi/misc/xilinx_sdfec.h 	__u32 alg;
alg                25 lib/crc-t10dif.c 	struct crypto_alg *alg = data;
alg                30 lib/crc-t10dif.c 	    strncmp(alg->cra_name, CRC_T10DIF_STRING, strlen(CRC_T10DIF_STRING)))
alg                11 net/ceph/crush/crush.c const char *crush_bucket_alg_name(int alg)
alg                13 net/ceph/crush/crush.c 	switch (alg) {
alg                33 net/ceph/crush/crush.c 	switch (b->alg) {
alg                86 net/ceph/crush/crush.c 	switch (b->alg) {
alg               384 net/ceph/crush/mapper.c 	switch (in->alg) {
alg               404 net/ceph/crush/mapper.c 		dprintk("unknown bucket %d alg %d\n", in->id, in->alg);
alg               710 net/ceph/crush/mapper.c 				if (in->alg == CRUSH_BUCKET_UNIFORM &&
alg               869 net/ceph/crush/mapper.c 		switch (map->buckets[b]->alg) {
alg               328 net/ceph/osdmap.c 		switch (c->buckets[b]->alg) {
alg               386 net/ceph/osdmap.c 		u32 alg;
alg               389 net/ceph/osdmap.c 		ceph_decode_32_safe(p, end, alg, bad);
alg               390 net/ceph/osdmap.c 		if (alg == 0) {
alg               397 net/ceph/osdmap.c 		switch (alg) {
alg               424 net/ceph/osdmap.c 		b->alg = ceph_decode_8(p);
alg               440 net/ceph/osdmap.c 		switch (b->alg) {
alg                85 net/mac80211/aead_api.c aead_key_setup_encrypt(const char *alg, const u8 key[],
alg                91 net/mac80211/aead_api.c 	tfm = crypto_alloc_aead(alg, 0, CRYPTO_ALG_ASYNC);
alg                10 net/mac80211/aead_api.h aead_key_setup_encrypt(const char *alg, const u8 key[],
alg               113 net/mac80211/rate.c 	struct rate_control_alg *alg;
alg               119 net/mac80211/rate.c 	list_for_each_entry(alg, &rate_ctrl_algs, list) {
alg               120 net/mac80211/rate.c 		if (!strcmp(alg->ops->name, ops->name)) {
alg               128 net/mac80211/rate.c 	alg = kzalloc(sizeof(*alg), GFP_KERNEL);
alg               129 net/mac80211/rate.c 	if (alg == NULL) {
alg               133 net/mac80211/rate.c 	alg->ops = ops;
alg               135 net/mac80211/rate.c 	list_add_tail(&alg->list, &rate_ctrl_algs);
alg               144 net/mac80211/rate.c 	struct rate_control_alg *alg;
alg               147 net/mac80211/rate.c 	list_for_each_entry(alg, &rate_ctrl_algs, list) {
alg               148 net/mac80211/rate.c 		if (alg->ops == ops) {
alg               149 net/mac80211/rate.c 			list_del(&alg->list);
alg               150 net/mac80211/rate.c 			kfree(alg);
alg               161 net/mac80211/rate.c 	struct rate_control_alg *alg;
alg               168 net/mac80211/rate.c 	list_for_each_entry(alg, &rate_ctrl_algs, list) {
alg               169 net/mac80211/rate.c 		if (!strcmp(alg->ops->name, name)) {
alg               170 net/mac80211/rate.c 			ops = alg->ops;
alg              8358 net/sctp/socket.c 	char alg[32];
alg              8362 net/sctp/socket.c 		sprintf(alg, "hmac(%s)", sp->sctp_hmac_alg);
alg              8363 net/sctp/socket.c 		tfm = crypto_alloc_shash(alg, 0, 0);
alg               201 net/sunrpc/auth_gss/gss_krb5_mech.c 	int			alg;
alg               203 net/sunrpc/auth_gss/gss_krb5_mech.c 	p = simple_get_bytes(p, end, &alg, sizeof(alg));
alg               207 net/sunrpc/auth_gss/gss_krb5_mech.c 	switch (alg) {
alg               212 net/sunrpc/auth_gss/gss_krb5_mech.c 		alg = ENCTYPE_DES_CBC_RAW;
alg               216 net/sunrpc/auth_gss/gss_krb5_mech.c 	if (!supported_gss_krb5_enctype(alg)) {
alg               218 net/sunrpc/auth_gss/gss_krb5_mech.c 			"encryption key algorithm %d\n", alg);
alg               169 net/wireless/lib80211.c 	struct lib80211_crypto_alg *alg;
alg               171 net/wireless/lib80211.c 	alg = kzalloc(sizeof(*alg), GFP_KERNEL);
alg               172 net/wireless/lib80211.c 	if (alg == NULL)
alg               175 net/wireless/lib80211.c 	alg->ops = ops;
alg               178 net/wireless/lib80211.c 	list_add(&alg->list, &lib80211_crypto_algs);
alg               190 net/wireless/lib80211.c 	struct lib80211_crypto_alg *alg;
alg               194 net/wireless/lib80211.c 	list_for_each_entry(alg, &lib80211_crypto_algs, list) {
alg               195 net/wireless/lib80211.c 		if (alg->ops == ops)
alg               204 net/wireless/lib80211.c 	list_del(&alg->list);
alg               206 net/wireless/lib80211.c 	kfree(alg);
alg               213 net/wireless/lib80211.c 	struct lib80211_crypto_alg *alg;
alg               217 net/wireless/lib80211.c 	list_for_each_entry(alg, &lib80211_crypto_algs, list) {
alg               218 net/wireless/lib80211.c 		if (strcmp(alg->ops->name, name) == 0)
alg               226 net/wireless/lib80211.c 	return alg->ops;
alg               647 net/wireless/wext-compat.c 	switch (ext->alg) {
alg                45 security/keys/trusted.c static struct sdesc *init_sdesc(struct crypto_shash *alg)
alg                50 security/keys/trusted.c 	size = sizeof(struct shash_desc) + crypto_shash_descsize(alg);
alg                54 security/keys/trusted.c 	sdesc->shash.tfm = alg;
alg               983 sound/soc/codecs/wm_adsp.c 		 event_id, ctl->alg_region.alg,
alg              1023 sound/soc/codecs/wm_adsp.c 		  reg, ctl->alg_region.alg,
alg              1384 sound/soc/codecs/wm_adsp.c 				  event, ctl->alg_region.alg, ret);
alg              1427 sound/soc/codecs/wm_adsp.c 			 dsp->name, region_name, alg_region->alg);
alg              1433 sound/soc/codecs/wm_adsp.c 				wm_adsp_fw_text[dsp->fw], alg_region->alg);
alg              1438 sound/soc/codecs/wm_adsp.c 				wm_adsp_fw_text[dsp->fw], alg_region->alg);
alg              1724 sound/soc/codecs/wm_adsp.c 		alg_region.alg = alg_blk.id;
alg              2005 sound/soc/codecs/wm_adsp.c 		    alg_region->alg == ctl->alg_region.alg &&
alg              2016 sound/soc/codecs/wm_adsp.c 	void *alg;
alg              2048 sound/soc/codecs/wm_adsp.c 	alg = kzalloc(len, GFP_KERNEL | GFP_DMA);
alg              2049 sound/soc/codecs/wm_adsp.c 	if (!alg)
alg              2054 sound/soc/codecs/wm_adsp.c 	ret = regmap_raw_read(dsp->regmap, reg, alg, len);
alg              2057 sound/soc/codecs/wm_adsp.c 		kfree(alg);
alg              2061 sound/soc/codecs/wm_adsp.c 	return alg;
alg              2070 sound/soc/codecs/wm_adsp.c 		if (id == alg_region->alg && type == alg_region->type)
alg              2088 sound/soc/codecs/wm_adsp.c 	alg_region->alg = be32_to_cpu(id);
alg              2199 sound/soc/codecs/wm_adsp.c 			  i, be32_to_cpu(adsp1_alg[i].alg.id),
alg              2200 sound/soc/codecs/wm_adsp.c 			  (be32_to_cpu(adsp1_alg[i].alg.ver) & 0xff0000) >> 16,
alg              2201 sound/soc/codecs/wm_adsp.c 			  (be32_to_cpu(adsp1_alg[i].alg.ver) & 0xff00) >> 8,
alg              2202 sound/soc/codecs/wm_adsp.c 			  be32_to_cpu(adsp1_alg[i].alg.ver) & 0xff,
alg              2207 sound/soc/codecs/wm_adsp.c 						   adsp1_alg[i].alg.id,
alg              2223 sound/soc/codecs/wm_adsp.c 					  be32_to_cpu(adsp1_alg[i].alg.id));
alg              2228 sound/soc/codecs/wm_adsp.c 						   adsp1_alg[i].alg.id,
alg              2244 sound/soc/codecs/wm_adsp.c 					  be32_to_cpu(adsp1_alg[i].alg.id));
alg              2306 sound/soc/codecs/wm_adsp.c 			  i, be32_to_cpu(adsp2_alg[i].alg.id),
alg              2307 sound/soc/codecs/wm_adsp.c 			  (be32_to_cpu(adsp2_alg[i].alg.ver) & 0xff0000) >> 16,
alg              2308 sound/soc/codecs/wm_adsp.c 			  (be32_to_cpu(adsp2_alg[i].alg.ver) & 0xff00) >> 8,
alg              2309 sound/soc/codecs/wm_adsp.c 			  be32_to_cpu(adsp2_alg[i].alg.ver) & 0xff,
alg              2315 sound/soc/codecs/wm_adsp.c 						   adsp2_alg[i].alg.id,
alg              2331 sound/soc/codecs/wm_adsp.c 					  be32_to_cpu(adsp2_alg[i].alg.id));
alg              2336 sound/soc/codecs/wm_adsp.c 						   adsp2_alg[i].alg.id,
alg              2352 sound/soc/codecs/wm_adsp.c 					  be32_to_cpu(adsp2_alg[i].alg.id));
alg              2357 sound/soc/codecs/wm_adsp.c 						   adsp2_alg[i].alg.id,
alg              2373 sound/soc/codecs/wm_adsp.c 					  be32_to_cpu(adsp2_alg[i].alg.id));
alg              2436 sound/soc/codecs/wm_adsp.c 			  i, be32_to_cpu(halo_alg[i].alg.id),
alg              2437 sound/soc/codecs/wm_adsp.c 			  (be32_to_cpu(halo_alg[i].alg.ver) & 0xff0000) >> 16,
alg              2438 sound/soc/codecs/wm_adsp.c 			  (be32_to_cpu(halo_alg[i].alg.ver) & 0xff00) >> 8,
alg              2439 sound/soc/codecs/wm_adsp.c 			  be32_to_cpu(halo_alg[i].alg.ver) & 0xff,
alg              2443 sound/soc/codecs/wm_adsp.c 		ret = wm_halo_create_regions(dsp, halo_alg[i].alg.id,
alg                47 sound/soc/codecs/wm_adsp.h 	unsigned int alg;
alg               111 sound/soc/codecs/wmfw.h 	struct wmfw_alg_hdr alg;
alg               117 sound/soc/codecs/wmfw.h 	struct wmfw_alg_hdr alg;
alg               124 sound/soc/codecs/wmfw.h 	struct wmfw_alg_hdr alg;
alg               116 tools/testing/selftests/bpf/test_tag.c 	static const struct sockaddr_alg alg = {
alg               127 tools/testing/selftests/bpf/test_tag.c 	ret = bind(fd_base, (struct sockaddr *)&alg, sizeof(alg));