keylen             53 arch/arm/crypto/crc32-ce-glue.c 			unsigned int keylen)
keylen             57 arch/arm/crypto/crc32-ce-glue.c 	if (keylen != sizeof(u32)) {
keylen            161 arch/arm/crypto/ghash-ce-glue.c 			const u8 *inkey, unsigned int keylen)
keylen            166 arch/arm/crypto/ghash-ce-glue.c 	if (keylen != GHASH_BLOCK_SIZE) {
keylen            295 arch/arm/crypto/ghash-ce-glue.c 			      unsigned int keylen)
keylen            304 arch/arm/crypto/ghash-ce-glue.c 	err = crypto_ahash_setkey(child, key, keylen);
keylen            226 arch/arm64/crypto/ghash-ce-glue.c 			  const u8 *inkey, unsigned int keylen)
keylen            249 arch/arm64/crypto/ghash-ce-glue.c 			const u8 *inkey, unsigned int keylen)
keylen            253 arch/arm64/crypto/ghash-ce-glue.c 	if (keylen != GHASH_BLOCK_SIZE) {
keylen            258 arch/arm64/crypto/ghash-ce-glue.c 	return __ghash_setkey(key, inkey, keylen);
keylen            304 arch/arm64/crypto/ghash-ce-glue.c 		      unsigned int keylen)
keylen            310 arch/arm64/crypto/ghash-ce-glue.c 	ret = aes_expandkey(&ctx->aes_key, inkey, keylen);
keylen            176 arch/mips/crypto/crc32-mips.c 			 unsigned int keylen)
keylen            180 arch/mips/crypto/crc32-mips.c 	if (keylen != sizeof(mctx->key)) {
keylen             40 arch/powerpc/boot/planetcore.c 	int keylen = strlen(key);
keylen             43 arch/powerpc/boot/planetcore.c 		if (!strncmp(table, key, keylen) && table[keylen] == '=')
keylen             44 arch/powerpc/boot/planetcore.c 			return table + keylen + 1;
keylen             72 arch/powerpc/crypto/crc32c-vpmsum_glue.c 			       unsigned int keylen)
keylen             76 arch/powerpc/crypto/crc32c-vpmsum_glue.c 	if (keylen != sizeof(u32)) {
keylen            794 arch/s390/crypto/aes_s390.c 			  unsigned int keylen)
keylen            798 arch/s390/crypto/aes_s390.c 	switch (keylen) {
keylen            812 arch/s390/crypto/aes_s390.c 	memcpy(ctx->key, key, keylen);
keylen            813 arch/s390/crypto/aes_s390.c 	ctx->key_len = keylen;
keylen             42 arch/s390/crypto/ghash_s390.c 			const u8 *key, unsigned int keylen)
keylen             46 arch/s390/crypto/ghash_s390.c 	if (keylen != GHASH_BLOCK_SIZE) {
keylen             52 arch/s390/crypto/paes_s390.c 	unsigned int keylen;
keylen             57 arch/s390/crypto/paes_s390.c 				  unsigned int keylen)
keylen             59 arch/s390/crypto/paes_s390.c 	if (keylen <= sizeof(kb->keybuf))
keylen             62 arch/s390/crypto/paes_s390.c 		kb->key = kmalloc(keylen, GFP_KERNEL);
keylen             66 arch/s390/crypto/paes_s390.c 	memcpy(kb->key, key, keylen);
keylen             67 arch/s390/crypto/paes_s390.c 	kb->keylen = keylen;
keylen             75 arch/s390/crypto/paes_s390.c 	    && kb->keylen > sizeof(kb->keybuf)) {
keylen            100 arch/s390/crypto/paes_s390.c 		ret = pkey_keyblob2pkey(kb->key, kb->keylen, pk);
keylen            437 arch/s390/crypto/paes_s390.c 	unsigned int keylen, offset, nbytes, n, k;
keylen            452 arch/s390/crypto/paes_s390.c 	keylen = (ctx->pk[0].type == PKEY_KEYTYPE_AES_128) ? 48 : 64;
keylen            457 arch/s390/crypto/paes_s390.c 	memcpy(pcc_param.key + offset, ctx->pk[1].protkey, keylen);
keylen            460 arch/s390/crypto/paes_s390.c 	memcpy(xts_param.key + offset, ctx->pk[0].protkey, keylen);
keylen             25 arch/s390/include/asm/pkey.h int pkey_keyblob2pkey(const u8 *key, u32 keylen,
keylen            196 arch/s390/include/uapi/asm/pkey.h 	__u32 keylen;			/* in: the key blob length */
keylen            225 arch/s390/include/uapi/asm/pkey.h 	__u32 keylen;		    /* in: available key blob buffer size */
keylen            256 arch/s390/include/uapi/asm/pkey.h 	__u32 keylen;		    /* in: available key blob buffer size  */
keylen            284 arch/s390/include/uapi/asm/pkey.h 	__u32 keylen;		    /* in: key blob size		 */
keylen            306 arch/s390/include/uapi/asm/pkey.h 	__u32 keylen;		     /* in: key blob size		   */
keylen            337 arch/s390/include/uapi/asm/pkey.h 	__u32 keylen;		   /* in: key blob size			      */
keylen             32 arch/sparc/crypto/crc32c_glue.c 				 unsigned int keylen)
keylen             36 arch/sparc/crypto/crc32c_glue.c 	if (keylen != sizeof(u32)) {
keylen             45 arch/sparc/crypto/des_glue.c 		       unsigned int keylen)
keylen            198 arch/sparc/crypto/des_glue.c 			    unsigned int keylen)
keylen            143 arch/x86/crypto/aegis128-aesni-glue.c 					unsigned int keylen)
keylen            147 arch/x86/crypto/aegis128-aesni-glue.c 	if (keylen != AEGIS128_KEY_SIZE) {
keylen            530 arch/x86/crypto/aesni-intel_glue.c 			    unsigned int keylen)
keylen            535 arch/x86/crypto/aesni-intel_glue.c 	err = xts_verify_key(tfm, key, keylen);
keylen            539 arch/x86/crypto/aesni-intel_glue.c 	keylen /= 2;
keylen            543 arch/x86/crypto/aesni-intel_glue.c 				 key, keylen);
keylen            549 arch/x86/crypto/aesni-intel_glue.c 				  key + keylen, keylen);
keylen             66 arch/x86/crypto/blowfish_glue.c 				    const u8 *key, unsigned int keylen)
keylen             68 arch/x86/crypto/blowfish_glue.c 	return blowfish_setkey(&tfm->base, key, keylen);
keylen            146 arch/x86/crypto/camellia_aesni_avx2_glue.c 			   unsigned int keylen)
keylen            148 arch/x86/crypto/camellia_aesni_avx2_glue.c 	return __camellia_setkey(crypto_skcipher_ctx(tfm), key, keylen,
keylen            150 arch/x86/crypto/camellia_aesni_avx_glue.c 			   unsigned int keylen)
keylen            152 arch/x86/crypto/camellia_aesni_avx_glue.c 	return __camellia_setkey(crypto_skcipher_ctx(tfm), key, keylen,
keylen            183 arch/x86/crypto/camellia_aesni_avx_glue.c 			unsigned int keylen)
keylen            189 arch/x86/crypto/camellia_aesni_avx_glue.c 	err = xts_verify_key(tfm, key, keylen);
keylen            194 arch/x86/crypto/camellia_aesni_avx_glue.c 	err = __camellia_setkey(&ctx->crypt_ctx, key, keylen / 2, flags);
keylen            199 arch/x86/crypto/camellia_aesni_avx_glue.c 	return __camellia_setkey(&ctx->tweak_ctx, key + keylen / 2, keylen / 2,
keylen             30 arch/x86/crypto/cast5_avx_glue.c 				 unsigned int keylen)
keylen             32 arch/x86/crypto/cast5_avx_glue.c 	return cast5_setkey(&tfm->base, key, keylen);
keylen             39 arch/x86/crypto/cast6_avx_glue.c 				 const u8 *key, unsigned int keylen)
keylen             41 arch/x86/crypto/cast6_avx_glue.c 	return cast6_setkey(&tfm->base, key, keylen);
keylen            177 arch/x86/crypto/cast6_avx_glue.c 			    unsigned int keylen)
keylen            183 arch/x86/crypto/cast6_avx_glue.c 	err = xts_verify_key(tfm, key, keylen);
keylen            188 arch/x86/crypto/cast6_avx_glue.c 	err = __cast6_setkey(&ctx->crypt_ctx, key, keylen / 2, flags);
keylen            193 arch/x86/crypto/cast6_avx_glue.c 	return __cast6_setkey(&ctx->tweak_ctx, key + keylen / 2, keylen / 2,
keylen             93 arch/x86/crypto/crc32-pclmul_glue.c 			unsigned int keylen)
keylen             97 arch/x86/crypto/crc32-pclmul_glue.c 	if (keylen != sizeof(u32)) {
keylen             90 arch/x86/crypto/crc32c-intel_glue.c 			unsigned int keylen)
keylen             94 arch/x86/crypto/crc32c-intel_glue.c 	if (keylen != sizeof(u32)) {
keylen            345 arch/x86/crypto/des3_ede_glue.c 			       unsigned int keylen)
keylen            351 arch/x86/crypto/des3_ede_glue.c 	err = des3_ede_expand_key(&ctx->enc, key, keylen);
keylen            380 arch/x86/crypto/des3_ede_glue.c 					unsigned int keylen)
keylen            382 arch/x86/crypto/des3_ede_glue.c 	return des3_ede_x86_setkey(&tfm->base, key, keylen);
keylen             54 arch/x86/crypto/ghash-clmulni-intel_glue.c 			const u8 *key, unsigned int keylen)
keylen             60 arch/x86/crypto/ghash-clmulni-intel_glue.c 	if (keylen != GHASH_BLOCK_SIZE) {
keylen            256 arch/x86/crypto/ghash-clmulni-intel_glue.c 			      unsigned int keylen)
keylen            265 arch/x86/crypto/ghash-clmulni-intel_glue.c 	err = crypto_ahash_setkey(child, key, keylen);
keylen             36 arch/x86/crypto/serpent_avx2_glue.c 				   const u8 *key, unsigned int keylen)
keylen             38 arch/x86/crypto/serpent_avx2_glue.c 	return __serpent_setkey(crypto_skcipher_ctx(tfm), key, keylen);
keylen             74 arch/x86/crypto/serpent_avx_glue.c 				   const u8 *key, unsigned int keylen)
keylen             76 arch/x86/crypto/serpent_avx_glue.c 	return __serpent_setkey(crypto_skcipher_ctx(tfm), key, keylen);
keylen             80 arch/x86/crypto/serpent_avx_glue.c 		       unsigned int keylen)
keylen             85 arch/x86/crypto/serpent_avx_glue.c 	err = xts_verify_key(tfm, key, keylen);
keylen             90 arch/x86/crypto/serpent_avx_glue.c 	err = __serpent_setkey(&ctx->crypt_ctx, key, keylen / 2);
keylen             95 arch/x86/crypto/serpent_avx_glue.c 	return __serpent_setkey(&ctx->tweak_ctx, key + keylen / 2, keylen / 2);
keylen             29 arch/x86/crypto/serpent_sse2_glue.c 				   const u8 *key, unsigned int keylen)
keylen             31 arch/x86/crypto/serpent_sse2_glue.c 	return __serpent_setkey(crypto_skcipher_ctx(tfm), key, keylen);
keylen             41 arch/x86/crypto/twofish_avx_glue.c 				   const u8 *key, unsigned int keylen)
keylen             43 arch/x86/crypto/twofish_avx_glue.c 	return twofish_setkey(&tfm->base, key, keylen);
keylen             70 arch/x86/crypto/twofish_avx_glue.c 			      unsigned int keylen)
keylen             76 arch/x86/crypto/twofish_avx_glue.c 	err = xts_verify_key(tfm, key, keylen);
keylen             81 arch/x86/crypto/twofish_avx_glue.c 	err = __twofish_setkey(&ctx->crypt_ctx, key, keylen / 2, flags);
keylen             86 arch/x86/crypto/twofish_avx_glue.c 	return __twofish_setkey(&ctx->tweak_ctx, key + keylen / 2, keylen / 2,
keylen             23 arch/x86/crypto/twofish_glue_3way.c 				   const u8 *key, unsigned int keylen)
keylen             25 arch/x86/crypto/twofish_glue_3way.c 	return twofish_setkey(&tfm->base, key, keylen);
keylen             32 arch/x86/include/asm/crypto/camellia.h 			       unsigned int keylen);
keylen             40 arch/x86/include/asm/crypto/serpent-avx.h 			      unsigned int keylen);
keylen           1183 block/sed-opal.c 	size_t keylen;
keylen           1190 block/sed-opal.c 	keylen = response_get_string(&dev->parsed, 4, &activekey);
keylen           1197 block/sed-opal.c 	dev->prev_data = kmemdup(activekey, keylen, GFP_KERNEL);
keylen           1202 block/sed-opal.c 	dev->prev_d_len = keylen;
keylen           1428 block/sed-opal.c 	size_t keylen = session->opal_key.key_len;
keylen           1455 block/sed-opal.c 	add_token_bytestring(&err, dev, key, keylen);
keylen            296 crypto/ablkcipher.c 			    unsigned int keylen)
keylen            304 crypto/ablkcipher.c 	absize = keylen + alignmask;
keylen            310 crypto/ablkcipher.c 	memcpy(alignbuffer, key, keylen);
keylen            311 crypto/ablkcipher.c 	ret = cipher->setkey(tfm, alignbuffer, keylen);
keylen            312 crypto/ablkcipher.c 	memset(alignbuffer, 0, keylen);
keylen            318 crypto/ablkcipher.c 		  unsigned int keylen)
keylen            323 crypto/ablkcipher.c 	if (keylen < cipher->min_keysize || keylen > cipher->max_keysize) {
keylen            329 crypto/ablkcipher.c 		return setkey_unaligned(tfm, key, keylen);
keylen            331 crypto/ablkcipher.c 	return cipher->setkey(tfm, key, keylen);
keylen            118 crypto/adiantum.c 			   unsigned int keylen)
keylen            136 crypto/adiantum.c 	err = crypto_skcipher_setkey(tctx->streamcipher, key, keylen);
keylen             28 crypto/aead.c  			    unsigned int keylen)
keylen             35 crypto/aead.c  	absize = keylen + alignmask;
keylen             41 crypto/aead.c  	memcpy(alignbuffer, key, keylen);
keylen             42 crypto/aead.c  	ret = crypto_aead_alg(tfm)->setkey(tfm, alignbuffer, keylen);
keylen             43 crypto/aead.c  	memset(alignbuffer, 0, keylen);
keylen             49 crypto/aead.c  		       const u8 *key, unsigned int keylen)
keylen             55 crypto/aead.c  		err = setkey_unaligned(tfm, key, keylen);
keylen             57 crypto/aead.c  		err = crypto_aead_alg(tfm)->setkey(tfm, key, keylen);
keylen            216 crypto/aead.c  			     const u8 *key, unsigned int keylen)
keylen            220 crypto/aead.c  	return crypto_aead_setkey(ctx->child, key, keylen);
keylen            370 crypto/aegis128-core.c 				  unsigned int keylen)
keylen            374 crypto/aegis128-core.c 	if (keylen != AEGIS128_KEY_SIZE) {
keylen            207 crypto/af_alg.c 		      unsigned int keylen)
keylen            214 crypto/af_alg.c 	key = sock_kmalloc(sk, keylen, GFP_KERNEL);
keylen            219 crypto/af_alg.c 	if (copy_from_user(key, ukey, keylen))
keylen            222 crypto/af_alg.c 	err = type->setkey(ask->private, key, keylen);
keylen            225 crypto/af_alg.c 	sock_kzfree_s(sk, key, keylen);
keylen            169 crypto/ahash.c 				unsigned int keylen)
keylen            176 crypto/ahash.c 	absize = keylen + alignmask;
keylen            182 crypto/ahash.c 	memcpy(alignbuffer, key, keylen);
keylen            183 crypto/ahash.c 	ret = tfm->setkey(tfm, alignbuffer, keylen);
keylen            189 crypto/ahash.c 			  unsigned int keylen)
keylen            204 crypto/ahash.c 			unsigned int keylen)
keylen            210 crypto/ahash.c 		err = ahash_setkey_unaligned(tfm, key, keylen);
keylen            212 crypto/ahash.c 		err = tfm->setkey(tfm, key, keylen);
keylen            518 crypto/algif_aead.c static int aead_setkey(void *private, const u8 *key, unsigned int keylen)
keylen            522 crypto/algif_aead.c 	return crypto_aead_setkey(tfm->aead, key, keylen);
keylen            411 crypto/algif_hash.c static int hash_setkey(void *private, const u8 *key, unsigned int keylen)
keylen            413 crypto/algif_hash.c 	return crypto_ahash_setkey(private, key, keylen);
keylen            314 crypto/algif_skcipher.c static int skcipher_setkey(void *private, const u8 *key, unsigned int keylen)
keylen            316 crypto/algif_skcipher.c 	return crypto_skcipher_setkey(private, key, keylen);
keylen            123 crypto/asymmetric_keys/pkcs8_parser.c 	pub->keylen = ctx.key_size;
keylen            122 crypto/asymmetric_keys/public_key.c 	key = kmalloc(pkey->keylen + sizeof(u32) * 2 + pkey->paramlen,
keylen            126 crypto/asymmetric_keys/public_key.c 	memcpy(key, pkey->key, pkey->keylen);
keylen            127 crypto/asymmetric_keys/public_key.c 	ptr = key + pkey->keylen;
keylen            133 crypto/asymmetric_keys/public_key.c 		ret = crypto_akcipher_set_priv_key(tfm, key, pkey->keylen);
keylen            135 crypto/asymmetric_keys/public_key.c 		ret = crypto_akcipher_set_pub_key(tfm, key, pkey->keylen);
keylen            192 crypto/asymmetric_keys/public_key.c 	key = kmalloc(pkey->keylen + sizeof(u32) * 2 + pkey->paramlen,
keylen            197 crypto/asymmetric_keys/public_key.c 	memcpy(key, pkey->key, pkey->keylen);
keylen            198 crypto/asymmetric_keys/public_key.c 	ptr = key + pkey->keylen;
keylen            204 crypto/asymmetric_keys/public_key.c 		ret = crypto_akcipher_set_priv_key(tfm, key, pkey->keylen);
keylen            206 crypto/asymmetric_keys/public_key.c 		ret = crypto_akcipher_set_pub_key(tfm, key, pkey->keylen);
keylen            283 crypto/asymmetric_keys/public_key.c 	key = kmalloc(pkey->keylen + sizeof(u32) * 2 + pkey->paramlen,
keylen            288 crypto/asymmetric_keys/public_key.c 	memcpy(key, pkey->key, pkey->keylen);
keylen            289 crypto/asymmetric_keys/public_key.c 	ptr = key + pkey->keylen;
keylen            295 crypto/asymmetric_keys/public_key.c 		ret = crypto_akcipher_set_priv_key(tfm, key, pkey->keylen);
keylen            297 crypto/asymmetric_keys/public_key.c 		ret = crypto_akcipher_set_pub_key(tfm, key, pkey->keylen);
keylen            109 crypto/asymmetric_keys/x509_cert_parser.c 	cert->pub->keylen = ctx->key_size;
keylen             47 crypto/authenc.c 			       unsigned int keylen)
keylen             52 crypto/authenc.c 	if (!RTA_OK(rta, keylen))
keylen             71 crypto/authenc.c 	keylen -= rta->rta_len;
keylen             73 crypto/authenc.c 	if (keylen < keys->enckeylen)
keylen             76 crypto/authenc.c 	keys->authkeylen = keylen - keys->enckeylen;
keylen             85 crypto/authenc.c 				 unsigned int keylen)
keylen             93 crypto/authenc.c 	if (crypto_authenc_extractkeys(&keys, key, keylen) != 0)
keylen             59 crypto/authencesn.c 				     unsigned int keylen)
keylen             67 crypto/authencesn.c 	if (crypto_authenc_extractkeys(&keys, key, keylen) != 0)
keylen            369 crypto/blkcipher.c 			    unsigned int keylen)
keylen            377 crypto/blkcipher.c 	absize = keylen + alignmask;
keylen            383 crypto/blkcipher.c 	memcpy(alignbuffer, key, keylen);
keylen            384 crypto/blkcipher.c 	ret = cipher->setkey(tfm, alignbuffer, keylen);
keylen            385 crypto/blkcipher.c 	memset(alignbuffer, 0, keylen);
keylen            390 crypto/blkcipher.c static int setkey(struct crypto_tfm *tfm, const u8 *key, unsigned int keylen)
keylen            395 crypto/blkcipher.c 	if (keylen < cipher->min_keysize || keylen > cipher->max_keysize) {
keylen            401 crypto/blkcipher.c 		return setkey_unaligned(tfm, key, keylen);
keylen            403 crypto/blkcipher.c 	return cipher->setkey(tfm, key, keylen);
keylen            407 crypto/blkcipher.c 			unsigned int keylen)
keylen            409 crypto/blkcipher.c 	return setkey(crypto_ablkcipher_tfm(tfm), key, keylen);
keylen            344 crypto/blowfish_common.c int blowfish_setkey(struct crypto_tfm *tfm, const u8 *key, unsigned int keylen)
keylen            364 crypto/blowfish_common.c 			((u32)key[(j + 1) % keylen] << 16) |
keylen            365 crypto/blowfish_common.c 			((u32)key[(j + 2) % keylen] << 8) |
keylen            366 crypto/blowfish_common.c 			((u32)key[(j + 3) % keylen]));
keylen            369 crypto/blowfish_common.c 		j = (j + 4) % keylen;
keylen            149 crypto/cast6_generic.c int cast6_setkey(struct crypto_tfm *tfm, const u8 *key, unsigned int keylen)
keylen            151 crypto/cast6_generic.c 	return __cast6_setkey(crypto_tfm_ctx(tfm), key, keylen,
keylen             89 crypto/ccm.c   			     unsigned int keylen)
keylen             99 crypto/ccm.c   	err = crypto_skcipher_setkey(ctr, key, keylen);
keylen            108 crypto/ccm.c   	err = crypto_ahash_setkey(mac, key, keylen);
keylen            603 crypto/ccm.c   				 unsigned int keylen)
keylen            609 crypto/ccm.c   	if (keylen < 3)
keylen            612 crypto/ccm.c   	keylen -= 3;
keylen            613 crypto/ccm.c   	memcpy(ctx->nonce, key + keylen, 3);
keylen            618 crypto/ccm.c   	err = crypto_aead_setkey(child, key, keylen);
keylen            833 crypto/ccm.c   				     const u8 *inkey, unsigned int keylen)
keylen            837 crypto/ccm.c   	return crypto_cipher_setkey(ctx->child, inkey, keylen);
keylen            477 crypto/chacha20poly1305.c 			     unsigned int keylen)
keylen            482 crypto/chacha20poly1305.c 	if (keylen != ctx->saltlen + CHACHA_KEY_SIZE)
keylen            485 crypto/chacha20poly1305.c 	keylen -= ctx->saltlen;
keylen            486 crypto/chacha20poly1305.c 	memcpy(ctx->salt, key + keylen, ctx->saltlen);
keylen            492 crypto/chacha20poly1305.c 	err = crypto_skcipher_setkey(ctx->chacha, key, keylen);
keylen             20 crypto/cipher.c 			    unsigned int keylen)
keylen             28 crypto/cipher.c 	absize = keylen + alignmask;
keylen             34 crypto/cipher.c 	memcpy(alignbuffer, key, keylen);
keylen             35 crypto/cipher.c 	ret = cia->cia_setkey(tfm, alignbuffer, keylen);
keylen             36 crypto/cipher.c 	memset(alignbuffer, 0, keylen);
keylen             42 crypto/cipher.c static int setkey(struct crypto_tfm *tfm, const u8 *key, unsigned int keylen)
keylen             48 crypto/cipher.c 	if (keylen < cia->cia_min_keysize || keylen > cia->cia_max_keysize) {
keylen             54 crypto/cipher.c 		return setkey_unaligned(tfm, key, keylen);
keylen             56 crypto/cipher.c 	return cia->cia_setkey(tfm, key, keylen);
keylen             50 crypto/cmac.c  				     const u8 *inkey, unsigned int keylen)
keylen             61 crypto/cmac.c  	err = crypto_cipher_setkey(ctx->child, inkey, keylen);
keylen             59 crypto/crc32_generic.c 			unsigned int keylen)
keylen             63 crypto/crc32_generic.c 	if (keylen != sizeof(u32)) {
keylen             73 crypto/crc32c_generic.c 			 unsigned int keylen)
keylen             77 crypto/crc32c_generic.c 	if (keylen != sizeof(mctx->key)) {
keylen            251 crypto/cryptd.c 				  const u8 *key, unsigned int keylen)
keylen            261 crypto/cryptd.c 	err = crypto_sync_skcipher_setkey(child, key, keylen);
keylen            490 crypto/cryptd.c 				   const u8 *key, unsigned int keylen)
keylen            499 crypto/cryptd.c 	err = crypto_shash_setkey(child, key, keylen);
keylen            735 crypto/cryptd.c 			      const u8 *key, unsigned int keylen)
keylen            740 crypto/cryptd.c 	return crypto_aead_setkey(child, key, keylen);
keylen             60 crypto/crypto_null.c 			    unsigned int keylen)
keylen             64 crypto/crypto_null.c 				unsigned int keylen)
keylen             68 crypto/crypto_null.c 		       unsigned int keylen)
keylen            170 crypto/ctr.c   				 const u8 *key, unsigned int keylen)
keylen            177 crypto/ctr.c   	if (keylen < CTR_RFC3686_NONCE_SIZE)
keylen            180 crypto/ctr.c   	memcpy(ctx->nonce, key + (keylen - CTR_RFC3686_NONCE_SIZE),
keylen            183 crypto/ctr.c   	keylen -= CTR_RFC3686_NONCE_SIZE;
keylen            188 crypto/ctr.c   	err = crypto_skcipher_setkey(child, key, keylen);
keylen             77 crypto/cts.c   			     unsigned int keylen)
keylen             86 crypto/cts.c   	err = crypto_skcipher_setkey(child, key, keylen);
keylen             20 crypto/des_generic.c 		      unsigned int keylen)
keylen             25 crypto/des_generic.c 	err = des_expand_key(dctx, key, keylen);
keylen             55 crypto/des_generic.c 			   unsigned int keylen)
keylen             60 crypto/des_generic.c 	err = des3_ede_expand_key(dctx, key, keylen);
keylen            191 crypto/ecrdsa.c 			      unsigned int keylen)
keylen            199 crypto/ecrdsa.c 	err = asn1_ber_decoder(&ecrdsa_pub_key_decoder, ctx, key, keylen);
keylen            205 crypto/ecrdsa.c 			  ecrdsa_unpack_u32(&algo, (u8 *)key + keylen));
keylen             66 crypto/essiv.c 				 const u8 *key, unsigned int keylen)
keylen             77 crypto/essiv.c 	err = crypto_skcipher_setkey(tctx->u.skcipher, key, keylen);
keylen             85 crypto/essiv.c 	err = crypto_shash_digest(desc, key, keylen, salt);
keylen            103 crypto/essiv.c 			     unsigned int keylen)
keylen            114 crypto/essiv.c 	err = crypto_aead_setkey(tctx->u.aead, key, keylen);
keylen            120 crypto/essiv.c 	if (crypto_authenc_extractkeys(&keys, key, keylen) != 0) {
keylen            303 crypto/fcrypt.c static int fcrypt_setkey(struct crypto_tfm *tfm, const u8 *key, unsigned int keylen)
keylen             94 crypto/gcm.c   			     unsigned int keylen)
keylen            113 crypto/gcm.c   	err = crypto_skcipher_setkey(ctr, key, keylen);
keylen            726 crypto/gcm.c   				 unsigned int keylen)
keylen            732 crypto/gcm.c   	if (keylen < 4)
keylen            735 crypto/gcm.c   	keylen -= 4;
keylen            736 crypto/gcm.c   	memcpy(ctx->nonce, key + keylen, 4);
keylen            741 crypto/gcm.c   	err = crypto_aead_setkey(child, key, keylen);
keylen            955 crypto/gcm.c   				 unsigned int keylen)
keylen            961 crypto/gcm.c   	if (keylen < 4)
keylen            964 crypto/gcm.c   	keylen -= 4;
keylen            965 crypto/gcm.c   	memcpy(ctx->nonce, key + keylen, 4);
keylen            970 crypto/gcm.c   	err = crypto_aead_setkey(child, key, keylen);
keylen             56 crypto/ghash-generic.c 			const u8 *key, unsigned int keylen)
keylen             61 crypto/ghash-generic.c 	if (keylen != GHASH_BLOCK_SIZE) {
keylen             41 crypto/hmac.c  		       const u8 *inkey, unsigned int keylen)
keylen             56 crypto/hmac.c  	if (keylen > bs) {
keylen             59 crypto/hmac.c  		err = crypto_shash_digest(shash, inkey, keylen, ipad);
keylen             63 crypto/hmac.c  		keylen = ds;
keylen             65 crypto/hmac.c  		memcpy(ipad, inkey, keylen);
keylen             67 crypto/hmac.c  	memset(ipad + keylen, 0, bs - keylen);
keylen             69 crypto/lrw.c   		  unsigned int keylen)
keylen             74 crypto/lrw.c   	const u8 *tweak = key + keylen - bsize;
keylen             81 crypto/lrw.c   	err = crypto_skcipher_setkey(child, key, keylen - bsize);
keylen            134 crypto/michael_mic.c 			  unsigned int keylen)
keylen            140 crypto/michael_mic.c 	if (keylen != 8) {
keylen            125 crypto/nhpoly1305.c 			     const u8 *key, unsigned int keylen)
keylen            130 crypto/nhpoly1305.c 	if (keylen != NHPOLY1305_KEY_SIZE)
keylen             44 crypto/pcrypt.c 			      const u8 *key, unsigned int keylen)
keylen             48 crypto/pcrypt.c 	return crypto_aead_setkey(ctx->child, key, keylen);
keylen            107 crypto/rsa-pkcs1pad.c 		unsigned int keylen)
keylen            114 crypto/rsa-pkcs1pad.c 	err = crypto_akcipher_set_pub_key(ctx->child, key, keylen);
keylen            128 crypto/rsa-pkcs1pad.c 		unsigned int keylen)
keylen            135 crypto/rsa-pkcs1pad.c 	err = crypto_akcipher_set_priv_key(ctx->child, key, keylen);
keylen            157 crypto/rsa.c   			   unsigned int keylen)
keylen            166 crypto/rsa.c   	ret = rsa_parse_pub_key(&raw_key, key, keylen);
keylen            191 crypto/rsa.c   			    unsigned int keylen)
keylen            200 crypto/rsa.c   	ret = rsa_parse_priv_key(&raw_key, key, keylen);
keylen            275 crypto/serpent_generic.c 		     unsigned int keylen)
keylen            284 crypto/serpent_generic.c 	for (i = 0; i < keylen; ++i)
keylen            446 crypto/serpent_generic.c int serpent_setkey(struct crypto_tfm *tfm, const u8 *key, unsigned int keylen)
keylen            448 crypto/serpent_generic.c 	return __serpent_setkey(crypto_tfm_ctx(tfm), key, keylen);
keylen            578 crypto/serpent_generic.c 			  unsigned int keylen)
keylen            583 crypto/serpent_generic.c 	for (i = 0; i < keylen; ++i)
keylen            584 crypto/serpent_generic.c 		rev_key[keylen - i - 1] = key[i];
keylen            586 crypto/serpent_generic.c 	return serpent_setkey(tfm, rev_key, keylen);
keylen             24 crypto/shash.c 		    unsigned int keylen)
keylen             31 crypto/shash.c 				  unsigned int keylen)
keylen             39 crypto/shash.c 	absize = keylen + (alignmask & ~(crypto_tfm_ctx_alignment() - 1));
keylen             45 crypto/shash.c 	memcpy(alignbuffer, key, keylen);
keylen             46 crypto/shash.c 	err = shash->setkey(tfm, alignbuffer, keylen);
keylen             59 crypto/shash.c 			unsigned int keylen)
keylen             66 crypto/shash.c 		err = shash_setkey_unaligned(tfm, key, keylen);
keylen             68 crypto/shash.c 		err = shash->setkey(tfm, key, keylen);
keylen            223 crypto/shash.c 			      unsigned int keylen)
keylen            227 crypto/shash.c 	return crypto_shash_setkey(*ctx, key, keylen);
keylen            599 crypto/skcipher.c 				     const u8 *key, unsigned int keylen)
keylen            608 crypto/skcipher.c 	err = crypto_blkcipher_setkey(blkcipher, key, keylen);
keylen            698 crypto/skcipher.c 				      const u8 *key, unsigned int keylen)
keylen            708 crypto/skcipher.c 	err = crypto_ablkcipher_setkey(ablkcipher, key, keylen);
keylen            798 crypto/skcipher.c 				     const u8 *key, unsigned int keylen)
keylen            806 crypto/skcipher.c 	absize = keylen + alignmask;
keylen            812 crypto/skcipher.c 	memcpy(alignbuffer, key, keylen);
keylen            813 crypto/skcipher.c 	ret = cipher->setkey(tfm, alignbuffer, keylen);
keylen            819 crypto/skcipher.c 			   unsigned int keylen)
keylen            825 crypto/skcipher.c 	if (keylen < cipher->min_keysize || keylen > cipher->max_keysize) {
keylen            831 crypto/skcipher.c 		err = skcipher_setkey_unaligned(tfm, key, keylen);
keylen            833 crypto/skcipher.c 		err = cipher->setkey(tfm, key, keylen);
keylen           1109 crypto/skcipher.c 				  unsigned int keylen)
keylen           1117 crypto/skcipher.c 	err = crypto_cipher_setkey(cipher, key, keylen);
keylen            430 crypto/vmac.c  		       const u8 *key, unsigned int keylen)
keylen            438 crypto/vmac.c  	if (keylen != VMAC_KEY_LEN) {
keylen            443 crypto/vmac.c  	err = crypto_cipher_setkey(tctx->cipher, key, keylen);
keylen             51 crypto/xcbc.c  				     const u8 *inkey, unsigned int keylen)
keylen             60 crypto/xcbc.c  	if ((err = crypto_cipher_setkey(ctx->child, inkey, keylen)))
keylen             41 crypto/xts.c   		  unsigned int keylen)
keylen             48 crypto/xts.c   	err = xts_verify_key(parent, key, keylen);
keylen             52 crypto/xts.c   	keylen /= 2;
keylen             63 crypto/xts.c   	err = crypto_cipher_setkey(tweak, key + keylen, keylen);
keylen             74 crypto/xts.c   	err = crypto_skcipher_setkey(child, key, keylen);
keylen             21 crypto/xxhash_generic.c 			 unsigned int keylen)
keylen             25 crypto/xxhash_generic.c 	if (keylen != sizeof(tctx->seed)) {
keylen            123 drivers/crypto/amcc/crypto4xx_alg.c 				unsigned int keylen,
keylen            131 drivers/crypto/amcc/crypto4xx_alg.c 	if (keylen != AES_KEYSIZE_256 &&
keylen            132 drivers/crypto/amcc/crypto4xx_alg.c 		keylen != AES_KEYSIZE_192 && keylen != AES_KEYSIZE_128) {
keylen            142 drivers/crypto/amcc/crypto4xx_alg.c 	rc = crypto4xx_alloc_sa(ctx, SA_AES128_LEN + (keylen-16) / 4);
keylen            164 drivers/crypto/amcc/crypto4xx_alg.c 				 key, keylen);
keylen            165 drivers/crypto/amcc/crypto4xx_alg.c 	sa->sa_contents.w = SA_AES_CONTENTS | (keylen << 2);
keylen            166 drivers/crypto/amcc/crypto4xx_alg.c 	sa->sa_command_1.bf.key_len = keylen >> 3;
keylen            181 drivers/crypto/amcc/crypto4xx_alg.c 			     const u8 *key, unsigned int keylen)
keylen            183 drivers/crypto/amcc/crypto4xx_alg.c 	return crypto4xx_setkey_aes(cipher, key, keylen, CRYPTO_MODE_CBC,
keylen            188 drivers/crypto/amcc/crypto4xx_alg.c 			     const u8 *key, unsigned int keylen)
keylen            190 drivers/crypto/amcc/crypto4xx_alg.c 	return crypto4xx_setkey_aes(cipher, key, keylen, CRYPTO_MODE_CFB,
keylen            195 drivers/crypto/amcc/crypto4xx_alg.c 			     const u8 *key, unsigned int keylen)
keylen            197 drivers/crypto/amcc/crypto4xx_alg.c 	return crypto4xx_setkey_aes(cipher, key, keylen, CRYPTO_MODE_ECB,
keylen            202 drivers/crypto/amcc/crypto4xx_alg.c 			     const u8 *key, unsigned int keylen)
keylen            204 drivers/crypto/amcc/crypto4xx_alg.c 	return crypto4xx_setkey_aes(cipher, key, keylen, CRYPTO_MODE_OFB,
keylen            209 drivers/crypto/amcc/crypto4xx_alg.c 			     const u8 *key, unsigned int keylen)
keylen            214 drivers/crypto/amcc/crypto4xx_alg.c 	rc = crypto4xx_setkey_aes(cipher, key, keylen - CTR_RFC3686_NONCE_SIZE,
keylen            219 drivers/crypto/amcc/crypto4xx_alg.c 	ctx->iv_nonce = cpu_to_le32p((u32 *)&key[keylen -
keylen            293 drivers/crypto/amcc/crypto4xx_alg.c 				       unsigned int keylen)
keylen            301 drivers/crypto/amcc/crypto4xx_alg.c 	rc = crypto_sync_skcipher_setkey(ctx->sw_cipher.cipher, key, keylen);
keylen            311 drivers/crypto/amcc/crypto4xx_alg.c 			     const u8 *key, unsigned int keylen)
keylen            316 drivers/crypto/amcc/crypto4xx_alg.c 	rc = crypto4xx_sk_setup_fallback(ctx, cipher, key, keylen);
keylen            320 drivers/crypto/amcc/crypto4xx_alg.c 	return crypto4xx_setkey_aes(cipher, key, keylen,
keylen            380 drivers/crypto/amcc/crypto4xx_alg.c 					 unsigned int keylen)
keylen            387 drivers/crypto/amcc/crypto4xx_alg.c 	rc = crypto_aead_setkey(ctx->sw_cipher.aead, key, keylen);
keylen            401 drivers/crypto/amcc/crypto4xx_alg.c 			     unsigned int keylen)
keylen            408 drivers/crypto/amcc/crypto4xx_alg.c 	rc = crypto4xx_aead_setup_fallback(ctx, cipher, key, keylen);
keylen            415 drivers/crypto/amcc/crypto4xx_alg.c 	rc = crypto4xx_alloc_sa(ctx, SA_AES128_CCM_LEN + (keylen - 16) / 4);
keylen            421 drivers/crypto/amcc/crypto4xx_alg.c 	sa->sa_contents.w = SA_AES_CCM_CONTENTS | (keylen << 2);
keylen            436 drivers/crypto/amcc/crypto4xx_alg.c 	sa->sa_command_1.bf.key_len = keylen >> 3;
keylen            438 drivers/crypto/amcc/crypto4xx_alg.c 	crypto4xx_memcpy_to_le32(get_dynamic_sa_key_field(sa), key, keylen);
keylen            456 drivers/crypto/amcc/crypto4xx_alg.c 	sa->sa_command_1.bf.key_len = keylen >> 3;
keylen            515 drivers/crypto/amcc/crypto4xx_alg.c static int crypto4xx_aes_gcm_validate_keylen(unsigned int keylen)
keylen            517 drivers/crypto/amcc/crypto4xx_alg.c 	switch (keylen) {
keylen            528 drivers/crypto/amcc/crypto4xx_alg.c 					     unsigned int keylen)
keylen            534 drivers/crypto/amcc/crypto4xx_alg.c 	rc = aes_expandkey(&ctx, key, keylen);
keylen            547 drivers/crypto/amcc/crypto4xx_alg.c 			     const u8 *key, unsigned int keylen)
keylen            554 drivers/crypto/amcc/crypto4xx_alg.c 	if (crypto4xx_aes_gcm_validate_keylen(keylen) != 0) {
keylen            559 drivers/crypto/amcc/crypto4xx_alg.c 	rc = crypto4xx_aead_setup_fallback(ctx, cipher, key, keylen);
keylen            566 drivers/crypto/amcc/crypto4xx_alg.c 	rc = crypto4xx_alloc_sa(ctx, SA_AES128_GCM_LEN + (keylen - 16) / 4);
keylen            572 drivers/crypto/amcc/crypto4xx_alg.c 	sa->sa_contents.w = SA_AES_GCM_CONTENTS | (keylen << 2);
keylen            585 drivers/crypto/amcc/crypto4xx_alg.c 	sa->sa_command_1.bf.key_len = keylen >> 3;
keylen            588 drivers/crypto/amcc/crypto4xx_alg.c 				 key, keylen);
keylen            591 drivers/crypto/amcc/crypto4xx_alg.c 		key, keylen);
keylen            163 drivers/crypto/amcc/crypto4xx_core.h 			     const u8 *key, unsigned int keylen);
keylen            165 drivers/crypto/amcc/crypto4xx_core.h 			     const u8 *key, unsigned int keylen);
keylen            167 drivers/crypto/amcc/crypto4xx_core.h 			     const u8 *key, unsigned int keylen);
keylen            169 drivers/crypto/amcc/crypto4xx_core.h 			     const u8 *key, unsigned int keylen);
keylen            171 drivers/crypto/amcc/crypto4xx_core.h 			     const u8 *key, unsigned int keylen);
keylen            173 drivers/crypto/amcc/crypto4xx_core.h 			     const u8 *key, unsigned int keylen);
keylen            236 drivers/crypto/amcc/crypto4xx_core.h 			     const u8 *key, unsigned int keylen);
keylen            240 drivers/crypto/amcc/crypto4xx_core.h 			     const u8 *key, unsigned int keylen);
keylen            106 drivers/crypto/atmel-aes.c 	int			keylen;
keylen            537 drivers/crypto/atmel-aes.c 				     const u32 *iv, const u32 *key, int keylen)
keylen            542 drivers/crypto/atmel-aes.c 	if (keylen == AES_KEYSIZE_128)
keylen            544 drivers/crypto/atmel-aes.c 	else if (keylen == AES_KEYSIZE_192)
keylen            561 drivers/crypto/atmel-aes.c 	atmel_aes_write_n(dd, AES_KEYWR(0), key, SIZE_IN_WORDS(keylen));
keylen            572 drivers/crypto/atmel-aes.c 				 dd->ctx->key, dd->ctx->keylen);
keylen           1135 drivers/crypto/atmel-aes.c 			   unsigned int keylen)
keylen           1139 drivers/crypto/atmel-aes.c 	if (keylen != AES_KEYSIZE_128 &&
keylen           1140 drivers/crypto/atmel-aes.c 	    keylen != AES_KEYSIZE_192 &&
keylen           1141 drivers/crypto/atmel-aes.c 	    keylen != AES_KEYSIZE_256) {
keylen           1146 drivers/crypto/atmel-aes.c 	memcpy(ctx->key, key, keylen);
keylen           1147 drivers/crypto/atmel-aes.c 	ctx->keylen = keylen;
keylen           1765 drivers/crypto/atmel-aes.c 				unsigned int keylen)
keylen           1769 drivers/crypto/atmel-aes.c 	if (keylen != AES_KEYSIZE_256 &&
keylen           1770 drivers/crypto/atmel-aes.c 	    keylen != AES_KEYSIZE_192 &&
keylen           1771 drivers/crypto/atmel-aes.c 	    keylen != AES_KEYSIZE_128) {
keylen           1776 drivers/crypto/atmel-aes.c 	memcpy(ctx->key, key, keylen);
keylen           1777 drivers/crypto/atmel-aes.c 	ctx->keylen = keylen;
keylen           1873 drivers/crypto/atmel-aes.c 				 ctx->key2, ctx->base.keylen);
keylen           1916 drivers/crypto/atmel-aes.c 				unsigned int keylen)
keylen           1921 drivers/crypto/atmel-aes.c 	err = xts_check_key(crypto_ablkcipher_tfm(tfm), key, keylen);
keylen           1925 drivers/crypto/atmel-aes.c 	memcpy(ctx->base.key, key, keylen/2);
keylen           1926 drivers/crypto/atmel-aes.c 	memcpy(ctx->key2, key + keylen/2, keylen/2);
keylen           1927 drivers/crypto/atmel-aes.c 	ctx->base.keylen = keylen/2;
keylen           2119 drivers/crypto/atmel-aes.c 				    unsigned int keylen)
keylen           2126 drivers/crypto/atmel-aes.c 	if (crypto_authenc_extractkeys(&keys, key, keylen) != 0)
keylen           2144 drivers/crypto/atmel-aes.c 	ctx->base.keylen = keys.enckeylen;
keylen             33 drivers/crypto/atmel-authenc.h 			     const u8 *key, unsigned int keylen,
keylen           1678 drivers/crypto/atmel-sha.c 	unsigned int		keylen;
keylen           1696 drivers/crypto/atmel-sha.c 					 unsigned int keylen)
keylen           1700 drivers/crypto/atmel-sha.c 	if (keylen > sizeof(hkey->buffer)) {
keylen           1701 drivers/crypto/atmel-sha.c 		hkey->keydup = kmemdup(key, keylen, GFP_KERNEL);
keylen           1706 drivers/crypto/atmel-sha.c 		memcpy(hkey->buffer, key, keylen);
keylen           1710 drivers/crypto/atmel-sha.c 	hkey->keylen = keylen;
keylen           1716 drivers/crypto/atmel-sha.c 					  unsigned int *keylen)
keylen           1721 drivers/crypto/atmel-sha.c 	*keylen = hkey->keylen;
keylen           1739 drivers/crypto/atmel-sha.c 				      const u8 *key, unsigned int keylen);
keylen           1757 drivers/crypto/atmel-sha.c 	unsigned int keylen;
keylen           1793 drivers/crypto/atmel-sha.c 	if (likely(!atmel_sha_hmac_key_get(&hmac->hkey, &key, &keylen)))
keylen           1797 drivers/crypto/atmel-sha.c 	if (unlikely(keylen > bs))
keylen           1798 drivers/crypto/atmel-sha.c 		return atmel_sha_hmac_prehash_key(dd, key, keylen);
keylen           1801 drivers/crypto/atmel-sha.c 	memcpy((u8 *)hmac->ipad, key, keylen);
keylen           1802 drivers/crypto/atmel-sha.c 	memset((u8 *)hmac->ipad + keylen, 0, bs - keylen);
keylen           1807 drivers/crypto/atmel-sha.c 				      const u8 *key, unsigned int keylen)
keylen           1809 drivers/crypto/atmel-sha.c 	return atmel_sha_cpu_hash(dd, key, keylen, true,
keylen           1917 drivers/crypto/atmel-sha.c 				 unsigned int keylen)
keylen           1921 drivers/crypto/atmel-sha.c 	return atmel_sha_hmac_key_set(&hmac->hkey, key, keylen);
keylen           2345 drivers/crypto/atmel-sha.c 			     const u8 *key, unsigned int keylen,
keylen           2353 drivers/crypto/atmel-sha.c 	err = crypto_ahash_setkey(tfm, key, keylen);
keylen             74 drivers/crypto/atmel-tdes.c 	int		keylen;
keylen            273 drivers/crypto/atmel-tdes.c 	if (dd->ctx->keylen > (DES_KEY_SIZE << 1)) {
keylen            276 drivers/crypto/atmel-tdes.c 	} else if (dd->ctx->keylen > DES_KEY_SIZE) {
keylen            307 drivers/crypto/atmel-tdes.c 						dd->ctx->keylen >> 2);
keylen            774 drivers/crypto/atmel-tdes.c 			   unsigned int keylen)
keylen            783 drivers/crypto/atmel-tdes.c 	memcpy(ctx->key, key, keylen);
keylen            784 drivers/crypto/atmel-tdes.c 	ctx->keylen = keylen;
keylen            790 drivers/crypto/atmel-tdes.c 			   unsigned int keylen)
keylen            799 drivers/crypto/atmel-tdes.c 	memcpy(ctx->key, key, keylen);
keylen            800 drivers/crypto/atmel-tdes.c 	ctx->keylen = keylen;
keylen           1598 drivers/crypto/axis/artpec6_crypto.c 			      unsigned int keylen)
keylen           1603 drivers/crypto/axis/artpec6_crypto.c 	switch (keylen) {
keylen           1614 drivers/crypto/axis/artpec6_crypto.c 	memcpy(ctx->aes_key, key, keylen);
keylen           1615 drivers/crypto/axis/artpec6_crypto.c 	ctx->key_length = keylen;
keylen           1621 drivers/crypto/axis/artpec6_crypto.c 			      unsigned int keylen)
keylen           1627 drivers/crypto/axis/artpec6_crypto.c 	ret = xts_check_key(&cipher->base, key, keylen);
keylen           1631 drivers/crypto/axis/artpec6_crypto.c 	switch (keylen) {
keylen           1642 drivers/crypto/axis/artpec6_crypto.c 	memcpy(ctx->aes_key, key, keylen);
keylen           1643 drivers/crypto/axis/artpec6_crypto.c 	ctx->key_length = keylen;
keylen           2231 drivers/crypto/axis/artpec6_crypto.c 		    const u8 *key, unsigned int keylen)
keylen           2237 drivers/crypto/axis/artpec6_crypto.c 	if (!keylen) {
keylen           2239 drivers/crypto/axis/artpec6_crypto.c 			keylen);
keylen           2247 drivers/crypto/axis/artpec6_crypto.c 	if (keylen > blocksize) {
keylen           2253 drivers/crypto/axis/artpec6_crypto.c 		ret = crypto_shash_digest(hdesc, key, keylen,
keylen           2259 drivers/crypto/axis/artpec6_crypto.c 		memcpy(tfm_ctx->hmac_key, key, keylen);
keylen           2260 drivers/crypto/axis/artpec6_crypto.c 		tfm_ctx->hmac_key_length = keylen;
keylen           1802 drivers/crypto/bcm/cipher.c 		      unsigned int keylen)
keylen           1816 drivers/crypto/bcm/cipher.c 			   unsigned int keylen)
keylen           1830 drivers/crypto/bcm/cipher.c 		      unsigned int keylen)
keylen           1836 drivers/crypto/bcm/cipher.c 		keylen = keylen / 2;
keylen           1838 drivers/crypto/bcm/cipher.c 	switch (keylen) {
keylen           1858 drivers/crypto/bcm/cipher.c 		      unsigned int keylen)
keylen           1870 drivers/crypto/bcm/cipher.c 		ctx->enckey[i + ARC4_STATE_SIZE] = key[i % keylen];
keylen           1878 drivers/crypto/bcm/cipher.c 			     unsigned int keylen)
keylen           1886 drivers/crypto/bcm/cipher.c 	flow_log("ablkcipher_setkey() keylen: %d\n", keylen);
keylen           1887 drivers/crypto/bcm/cipher.c 	flow_dump("  key: ", key, keylen);
keylen           1891 drivers/crypto/bcm/cipher.c 		err = des_setkey(cipher, key, keylen);
keylen           1894 drivers/crypto/bcm/cipher.c 		err = threedes_setkey(cipher, key, keylen);
keylen           1897 drivers/crypto/bcm/cipher.c 		err = aes_setkey(cipher, key, keylen);
keylen           1900 drivers/crypto/bcm/cipher.c 		err = rc4_setkey(cipher, key, keylen);
keylen           1911 drivers/crypto/bcm/cipher.c 		memcpy(ctx->enckey, key, keylen);
keylen           1912 drivers/crypto/bcm/cipher.c 		ctx->enckeylen = keylen;
keylen           1917 drivers/crypto/bcm/cipher.c 		unsigned int xts_keylen = keylen / 2;
keylen           2316 drivers/crypto/bcm/cipher.c 			unsigned int keylen)
keylen           2321 drivers/crypto/bcm/cipher.c 		 __func__, ahash, key, keylen);
keylen           2322 drivers/crypto/bcm/cipher.c 	flow_dump("  key: ", key, keylen);
keylen           2325 drivers/crypto/bcm/cipher.c 		switch (keylen) {
keylen           2343 drivers/crypto/bcm/cipher.c 	memcpy(ctx->authkey, key, keylen);
keylen           2344 drivers/crypto/bcm/cipher.c 	ctx->authkeylen = keylen;
keylen           2380 drivers/crypto/bcm/cipher.c 			     unsigned int keylen)
keylen           2390 drivers/crypto/bcm/cipher.c 		 __func__, ahash, key, keylen, blocksize, digestsize);
keylen           2391 drivers/crypto/bcm/cipher.c 	flow_dump("  key: ", key, keylen);
keylen           2393 drivers/crypto/bcm/cipher.c 	if (keylen > blocksize) {
keylen           2396 drivers/crypto/bcm/cipher.c 			rc = do_shash("md5", ctx->authkey, key, keylen, NULL,
keylen           2400 drivers/crypto/bcm/cipher.c 			rc = do_shash("sha1", ctx->authkey, key, keylen, NULL,
keylen           2404 drivers/crypto/bcm/cipher.c 			rc = do_shash("sha224", ctx->authkey, key, keylen, NULL,
keylen           2408 drivers/crypto/bcm/cipher.c 			rc = do_shash("sha256", ctx->authkey, key, keylen, NULL,
keylen           2412 drivers/crypto/bcm/cipher.c 			rc = do_shash("sha384", ctx->authkey, key, keylen, NULL,
keylen           2416 drivers/crypto/bcm/cipher.c 			rc = do_shash("sha512", ctx->authkey, key, keylen, NULL,
keylen           2420 drivers/crypto/bcm/cipher.c 			rc = do_shash("sha3-224", ctx->authkey, key, keylen,
keylen           2424 drivers/crypto/bcm/cipher.c 			rc = do_shash("sha3-256", ctx->authkey, key, keylen,
keylen           2428 drivers/crypto/bcm/cipher.c 			rc = do_shash("sha3-384", ctx->authkey, key, keylen,
keylen           2432 drivers/crypto/bcm/cipher.c 			rc = do_shash("sha3-512", ctx->authkey, key, keylen,
keylen           2449 drivers/crypto/bcm/cipher.c 		memcpy(ctx->authkey, key, keylen);
keylen           2450 drivers/crypto/bcm/cipher.c 		ctx->authkeylen = keylen;
keylen           2820 drivers/crypto/bcm/cipher.c 			       const u8 *key, unsigned int keylen)
keylen           2829 drivers/crypto/bcm/cipher.c 		 keylen);
keylen           2830 drivers/crypto/bcm/cipher.c 	flow_dump("  key: ", key, keylen);
keylen           2832 drivers/crypto/bcm/cipher.c 	ret = crypto_authenc_extractkeys(&keys, key, keylen);
keylen           2896 drivers/crypto/bcm/cipher.c 		ret = crypto_aead_setkey(ctx->fallback_cipher, key, keylen);
keylen           2924 drivers/crypto/bcm/cipher.c 			       const u8 *key, unsigned int keylen)
keylen           2932 drivers/crypto/bcm/cipher.c 	flow_log("%s() keylen:%u\n", __func__, keylen);
keylen           2933 drivers/crypto/bcm/cipher.c 	flow_dump("  key: ", key, keylen);
keylen           2936 drivers/crypto/bcm/cipher.c 		ctx->digestsize = keylen;
keylen           2938 drivers/crypto/bcm/cipher.c 	ctx->enckeylen = keylen;
keylen           2969 drivers/crypto/bcm/cipher.c 					 keylen + ctx->salt_len);
keylen           3011 drivers/crypto/bcm/cipher.c 			       const u8 *key, unsigned int keylen)
keylen           3018 drivers/crypto/bcm/cipher.c 	memcpy(ctx->salt, key + keylen - GCM_ESP_SALT_SIZE, GCM_ESP_SALT_SIZE);
keylen           3019 drivers/crypto/bcm/cipher.c 	keylen -= GCM_ESP_SALT_SIZE;
keylen           3024 drivers/crypto/bcm/cipher.c 	return aead_gcm_ccm_setkey(cipher, key, keylen);
keylen           3039 drivers/crypto/bcm/cipher.c 				  const u8 *key, unsigned int keylen)
keylen           3046 drivers/crypto/bcm/cipher.c 	memcpy(ctx->salt, key + keylen - GCM_ESP_SALT_SIZE, GCM_ESP_SALT_SIZE);
keylen           3047 drivers/crypto/bcm/cipher.c 	keylen -= GCM_ESP_SALT_SIZE;
keylen           3053 drivers/crypto/bcm/cipher.c 	return aead_gcm_ccm_setkey(cipher, key, keylen);
keylen           3068 drivers/crypto/bcm/cipher.c 			       const u8 *key, unsigned int keylen)
keylen           3075 drivers/crypto/bcm/cipher.c 	memcpy(ctx->salt, key + keylen - CCM_ESP_SALT_SIZE, CCM_ESP_SALT_SIZE);
keylen           3076 drivers/crypto/bcm/cipher.c 	keylen -= CCM_ESP_SALT_SIZE;
keylen           3080 drivers/crypto/bcm/cipher.c 	return aead_gcm_ccm_setkey(cipher, key, keylen);
keylen            187 drivers/crypto/caam/caamalg.c 	if (!ctx->cdata.keylen)
keylen            205 drivers/crypto/caam/caamalg.c 				ctx->cdata.keylen - CTR_RFC3686_NONCE_SIZE);
keylen            221 drivers/crypto/caam/caamalg.c 	data_len[1] = ctx->cdata.keylen;
keylen            315 drivers/crypto/caam/caamalg.c 			ctx->cdata.keylen;
keylen            317 drivers/crypto/caam/caamalg.c 	if (!ctx->cdata.keylen || !ctx->authsize)
keylen            380 drivers/crypto/caam/caamalg.c 			ctx->cdata.keylen;
keylen            382 drivers/crypto/caam/caamalg.c 	if (!ctx->cdata.keylen || !ctx->authsize)
keylen            448 drivers/crypto/caam/caamalg.c 			ctx->cdata.keylen;
keylen            450 drivers/crypto/caam/caamalg.c 	if (!ctx->cdata.keylen || !ctx->authsize)
keylen            514 drivers/crypto/caam/caamalg.c 	if (!ctx->cdata.keylen || !ctx->authsize)
keylen            545 drivers/crypto/caam/caamalg.c 			     unsigned int keylen)
keylen            551 drivers/crypto/caam/caamalg.c 	if (keylen != CHACHA_KEY_SIZE + saltlen) {
keylen            557 drivers/crypto/caam/caamalg.c 	ctx->cdata.keylen = keylen - saltlen;
keylen            563 drivers/crypto/caam/caamalg.c 			       const u8 *key, unsigned int keylen)
keylen            571 drivers/crypto/caam/caamalg.c 	if (crypto_authenc_extractkeys(&keys, key, keylen) != 0)
keylen            578 drivers/crypto/caam/caamalg.c 			     DUMP_PREFIX_ADDRESS, 16, 4, key, keylen, 1);
keylen            585 drivers/crypto/caam/caamalg.c 		ctx->adata.keylen = keys.authkeylen;
keylen            618 drivers/crypto/caam/caamalg.c 	ctx->cdata.keylen = keys.enckeylen;
keylen            628 drivers/crypto/caam/caamalg.c 			    unsigned int keylen)
keylen            633 drivers/crypto/caam/caamalg.c 	err = crypto_authenc_extractkeys(&keys, key, keylen);
keylen            638 drivers/crypto/caam/caamalg.c 	      aead_setkey(aead, key, keylen);
keylen            645 drivers/crypto/caam/caamalg.c 		      const u8 *key, unsigned int keylen)
keylen            651 drivers/crypto/caam/caamalg.c 	err = aes_check_keylen(keylen);
keylen            658 drivers/crypto/caam/caamalg.c 			     DUMP_PREFIX_ADDRESS, 16, 4, key, keylen, 1);
keylen            660 drivers/crypto/caam/caamalg.c 	memcpy(ctx->key, key, keylen);
keylen            661 drivers/crypto/caam/caamalg.c 	dma_sync_single_for_device(jrdev, ctx->key_dma, keylen, ctx->dir);
keylen            662 drivers/crypto/caam/caamalg.c 	ctx->cdata.keylen = keylen;
keylen            668 drivers/crypto/caam/caamalg.c 			  const u8 *key, unsigned int keylen)
keylen            674 drivers/crypto/caam/caamalg.c 	err = aes_check_keylen(keylen - 4);
keylen            681 drivers/crypto/caam/caamalg.c 			     DUMP_PREFIX_ADDRESS, 16, 4, key, keylen, 1);
keylen            683 drivers/crypto/caam/caamalg.c 	memcpy(ctx->key, key, keylen);
keylen            689 drivers/crypto/caam/caamalg.c 	ctx->cdata.keylen = keylen - 4;
keylen            690 drivers/crypto/caam/caamalg.c 	dma_sync_single_for_device(jrdev, ctx->key_dma, ctx->cdata.keylen,
keylen            696 drivers/crypto/caam/caamalg.c 			  const u8 *key, unsigned int keylen)
keylen            702 drivers/crypto/caam/caamalg.c 	err = aes_check_keylen(keylen - 4);
keylen            709 drivers/crypto/caam/caamalg.c 			     DUMP_PREFIX_ADDRESS, 16, 4, key, keylen, 1);
keylen            711 drivers/crypto/caam/caamalg.c 	memcpy(ctx->key, key, keylen);
keylen            717 drivers/crypto/caam/caamalg.c 	ctx->cdata.keylen = keylen - 4;
keylen            718 drivers/crypto/caam/caamalg.c 	dma_sync_single_for_device(jrdev, ctx->key_dma, ctx->cdata.keylen,
keylen            724 drivers/crypto/caam/caamalg.c 			   unsigned int keylen, const u32 ctx1_iv_off)
keylen            736 drivers/crypto/caam/caamalg.c 			     DUMP_PREFIX_ADDRESS, 16, 4, key, keylen, 1);
keylen            738 drivers/crypto/caam/caamalg.c 	ctx->cdata.keylen = keylen;
keylen            760 drivers/crypto/caam/caamalg.c 			       const u8 *key, unsigned int keylen)
keylen            764 drivers/crypto/caam/caamalg.c 	err = aes_check_keylen(keylen);
keylen            771 drivers/crypto/caam/caamalg.c 	return skcipher_setkey(skcipher, key, keylen, 0);
keylen            775 drivers/crypto/caam/caamalg.c 				   const u8 *key, unsigned int keylen)
keylen            786 drivers/crypto/caam/caamalg.c 	keylen -= CTR_RFC3686_NONCE_SIZE;
keylen            788 drivers/crypto/caam/caamalg.c 	err = aes_check_keylen(keylen);
keylen            795 drivers/crypto/caam/caamalg.c 	return skcipher_setkey(skcipher, key, keylen, ctx1_iv_off);
keylen            799 drivers/crypto/caam/caamalg.c 			       const u8 *key, unsigned int keylen)
keylen            811 drivers/crypto/caam/caamalg.c 	err = aes_check_keylen(keylen);
keylen            818 drivers/crypto/caam/caamalg.c 	return skcipher_setkey(skcipher, key, keylen, ctx1_iv_off);
keylen            822 drivers/crypto/caam/caamalg.c 				const u8 *key, unsigned int keylen)
keylen            824 drivers/crypto/caam/caamalg.c 	return skcipher_setkey(skcipher, key, keylen, 0);
keylen            828 drivers/crypto/caam/caamalg.c 			       const u8 *key, unsigned int keylen)
keylen            831 drivers/crypto/caam/caamalg.c 	       skcipher_setkey(skcipher, key, keylen, 0);
keylen            835 drivers/crypto/caam/caamalg.c 				const u8 *key, unsigned int keylen)
keylen            838 drivers/crypto/caam/caamalg.c 	       skcipher_setkey(skcipher, key, keylen, 0);
keylen            842 drivers/crypto/caam/caamalg.c 			       unsigned int keylen)
keylen            848 drivers/crypto/caam/caamalg.c 	if (keylen != 2 * AES_MIN_KEY_SIZE  && keylen != 2 * AES_MAX_KEY_SIZE) {
keylen            854 drivers/crypto/caam/caamalg.c 	ctx->cdata.keylen = keylen;
keylen           1173 drivers/crypto/caam/caamalg.c 		append_data(desc, ctx->key + ctx->cdata.keylen, 4);
keylen             69 drivers/crypto/caam/caamalg_desc.c 					  adata->keylen_pad, adata->keylen,
keylen             73 drivers/crypto/caam/caamalg_desc.c 			append_key(desc, adata->key_dma, adata->keylen,
keylen            148 drivers/crypto/caam/caamalg_desc.c 					  adata->keylen_pad, adata->keylen,
keylen            152 drivers/crypto/caam/caamalg_desc.c 			append_key(desc, adata->key_dma, adata->keylen,
keylen            216 drivers/crypto/caam/caamalg_desc.c 	unsigned int enckeylen = cdata->keylen;
keylen            236 drivers/crypto/caam/caamalg_desc.c 					  adata->keylen_pad, adata->keylen,
keylen            240 drivers/crypto/caam/caamalg_desc.c 			append_key(desc, adata->key_dma, adata->keylen,
keylen            646 drivers/crypto/caam/caamalg_desc.c 		append_key_as_imm(desc, cdata->key_virt, cdata->keylen,
keylen            647 drivers/crypto/caam/caamalg_desc.c 				  cdata->keylen, CLASS_1 | KEY_DEST_CLASS_REG);
keylen            649 drivers/crypto/caam/caamalg_desc.c 		append_key(desc, cdata->key_dma, cdata->keylen, CLASS_1 |
keylen            772 drivers/crypto/caam/caamalg_desc.c 		append_key_as_imm(desc, cdata->key_virt, cdata->keylen,
keylen            773 drivers/crypto/caam/caamalg_desc.c 				  cdata->keylen, CLASS_1 | KEY_DEST_CLASS_REG);
keylen            775 drivers/crypto/caam/caamalg_desc.c 		append_key(desc, cdata->key_dma, cdata->keylen, CLASS_1 |
keylen            871 drivers/crypto/caam/caamalg_desc.c 		append_key_as_imm(desc, cdata->key_virt, cdata->keylen,
keylen            872 drivers/crypto/caam/caamalg_desc.c 				  cdata->keylen, CLASS_1 | KEY_DEST_CLASS_REG);
keylen            874 drivers/crypto/caam/caamalg_desc.c 		append_key(desc, cdata->key_dma, cdata->keylen, CLASS_1 |
keylen            898 drivers/crypto/caam/caamalg_desc.c 					cdata->keylen), 4, FIFOLD_CLASS_CLASS1 |
keylen            979 drivers/crypto/caam/caamalg_desc.c 		append_key_as_imm(desc, cdata->key_virt, cdata->keylen,
keylen            980 drivers/crypto/caam/caamalg_desc.c 				  cdata->keylen, CLASS_1 |
keylen            983 drivers/crypto/caam/caamalg_desc.c 		append_key(desc, cdata->key_dma, cdata->keylen, CLASS_1 |
keylen           1007 drivers/crypto/caam/caamalg_desc.c 					cdata->keylen), 4, FIFOLD_CLASS_CLASS1 |
keylen           1074 drivers/crypto/caam/caamalg_desc.c 		append_key_as_imm(desc, cdata->key_virt, cdata->keylen,
keylen           1075 drivers/crypto/caam/caamalg_desc.c 				  cdata->keylen, CLASS_1 | KEY_DEST_CLASS_REG);
keylen           1077 drivers/crypto/caam/caamalg_desc.c 		append_key(desc, cdata->key_dma, cdata->keylen, CLASS_1 |
keylen           1091 drivers/crypto/caam/caamalg_desc.c 					cdata->keylen), 4, FIFOLD_CLASS_CLASS1 |
keylen           1157 drivers/crypto/caam/caamalg_desc.c 		append_key_as_imm(desc, cdata->key_virt, cdata->keylen,
keylen           1158 drivers/crypto/caam/caamalg_desc.c 				  cdata->keylen, CLASS_1 | KEY_DEST_CLASS_REG);
keylen           1160 drivers/crypto/caam/caamalg_desc.c 		append_key(desc, cdata->key_dma, cdata->keylen, CLASS_1 |
keylen           1174 drivers/crypto/caam/caamalg_desc.c 					cdata->keylen), 4, FIFOLD_CLASS_CLASS1 |
keylen           1255 drivers/crypto/caam/caamalg_desc.c 	append_key_as_imm(desc, cdata->key_virt, cdata->keylen, cdata->keylen,
keylen           1260 drivers/crypto/caam/caamalg_desc.c 		append_load_as_imm(desc, cdata->key_virt + cdata->keylen, 4,
keylen           1392 drivers/crypto/caam/caamalg_desc.c 	append_key_as_imm(desc, cdata->key_virt, cdata->keylen,
keylen           1393 drivers/crypto/caam/caamalg_desc.c 			  cdata->keylen, CLASS_1 | KEY_DEST_CLASS_REG);
keylen           1397 drivers/crypto/caam/caamalg_desc.c 		const u8 *nonce = cdata->key_virt + cdata->keylen;
keylen           1467 drivers/crypto/caam/caamalg_desc.c 	append_key_as_imm(desc, cdata->key_virt, cdata->keylen,
keylen           1468 drivers/crypto/caam/caamalg_desc.c 			  cdata->keylen, CLASS_1 | KEY_DEST_CLASS_REG);
keylen           1472 drivers/crypto/caam/caamalg_desc.c 		const u8 *nonce = cdata->key_virt + cdata->keylen;
keylen           1542 drivers/crypto/caam/caamalg_desc.c 	append_key_as_imm(desc, cdata->key_virt, cdata->keylen,
keylen           1543 drivers/crypto/caam/caamalg_desc.c 			  cdata->keylen, CLASS_1 | KEY_DEST_CLASS_REG);
keylen           1601 drivers/crypto/caam/caamalg_desc.c 	append_key_as_imm(desc, cdata->key_virt, cdata->keylen,
keylen           1602 drivers/crypto/caam/caamalg_desc.c 			  cdata->keylen, CLASS_1 | KEY_DEST_CLASS_REG);
keylen             87 drivers/crypto/caam/caamalg_qi.c 	if (!ctx->cdata.keylen || !ctx->authsize)
keylen            105 drivers/crypto/caam/caamalg_qi.c 				ctx->cdata.keylen - CTR_RFC3686_NONCE_SIZE);
keylen            121 drivers/crypto/caam/caamalg_qi.c 	data_len[1] = ctx->cdata.keylen;
keylen            188 drivers/crypto/caam/caamalg_qi.c 		       unsigned int keylen)
keylen            196 drivers/crypto/caam/caamalg_qi.c 	if (crypto_authenc_extractkeys(&keys, key, keylen) != 0)
keylen            203 drivers/crypto/caam/caamalg_qi.c 			     DUMP_PREFIX_ADDRESS, 16, 4, key, keylen, 1);
keylen            210 drivers/crypto/caam/caamalg_qi.c 		ctx->adata.keylen = keys.authkeylen;
keylen            243 drivers/crypto/caam/caamalg_qi.c 	ctx->cdata.keylen = keys.enckeylen;
keylen            277 drivers/crypto/caam/caamalg_qi.c 			    unsigned int keylen)
keylen            282 drivers/crypto/caam/caamalg_qi.c 	err = crypto_authenc_extractkeys(&keys, key, keylen);
keylen            287 drivers/crypto/caam/caamalg_qi.c 	      aead_setkey(aead, key, keylen);
keylen            298 drivers/crypto/caam/caamalg_qi.c 			ctx->cdata.keylen;
keylen            300 drivers/crypto/caam/caamalg_qi.c 	if (!ctx->cdata.keylen || !ctx->authsize)
keylen            352 drivers/crypto/caam/caamalg_qi.c 		      const u8 *key, unsigned int keylen)
keylen            358 drivers/crypto/caam/caamalg_qi.c 	ret = aes_check_keylen(keylen);
keylen            365 drivers/crypto/caam/caamalg_qi.c 			     DUMP_PREFIX_ADDRESS, 16, 4, key, keylen, 1);
keylen            367 drivers/crypto/caam/caamalg_qi.c 	memcpy(ctx->key, key, keylen);
keylen            368 drivers/crypto/caam/caamalg_qi.c 	dma_sync_single_for_device(jrdev->parent, ctx->key_dma, keylen,
keylen            370 drivers/crypto/caam/caamalg_qi.c 	ctx->cdata.keylen = keylen;
keylen            403 drivers/crypto/caam/caamalg_qi.c 			ctx->cdata.keylen;
keylen            405 drivers/crypto/caam/caamalg_qi.c 	if (!ctx->cdata.keylen || !ctx->authsize)
keylen            458 drivers/crypto/caam/caamalg_qi.c 			  const u8 *key, unsigned int keylen)
keylen            464 drivers/crypto/caam/caamalg_qi.c 	ret = aes_check_keylen(keylen - 4);
keylen            471 drivers/crypto/caam/caamalg_qi.c 			     DUMP_PREFIX_ADDRESS, 16, 4, key, keylen, 1);
keylen            473 drivers/crypto/caam/caamalg_qi.c 	memcpy(ctx->key, key, keylen);
keylen            478 drivers/crypto/caam/caamalg_qi.c 	ctx->cdata.keylen = keylen - 4;
keylen            480 drivers/crypto/caam/caamalg_qi.c 				   ctx->cdata.keylen, ctx->dir);
keylen            513 drivers/crypto/caam/caamalg_qi.c 			ctx->cdata.keylen;
keylen            515 drivers/crypto/caam/caamalg_qi.c 	if (!ctx->cdata.keylen || !ctx->authsize)
keylen            566 drivers/crypto/caam/caamalg_qi.c 			  const u8 *key, unsigned int keylen)
keylen            572 drivers/crypto/caam/caamalg_qi.c 	ret = aes_check_keylen(keylen - 4);
keylen            579 drivers/crypto/caam/caamalg_qi.c 			     DUMP_PREFIX_ADDRESS, 16, 4, key, keylen, 1);
keylen            581 drivers/crypto/caam/caamalg_qi.c 	memcpy(ctx->key, key, keylen);
keylen            586 drivers/crypto/caam/caamalg_qi.c 	ctx->cdata.keylen = keylen - 4;
keylen            588 drivers/crypto/caam/caamalg_qi.c 				   ctx->cdata.keylen, ctx->dir);
keylen            617 drivers/crypto/caam/caamalg_qi.c 			   unsigned int keylen, const u32 ctx1_iv_off)
keylen            629 drivers/crypto/caam/caamalg_qi.c 			     DUMP_PREFIX_ADDRESS, 16, 4, key, keylen, 1);
keylen            631 drivers/crypto/caam/caamalg_qi.c 	ctx->cdata.keylen = keylen;
keylen            667 drivers/crypto/caam/caamalg_qi.c 			       const u8 *key, unsigned int keylen)
keylen            671 drivers/crypto/caam/caamalg_qi.c 	err = aes_check_keylen(keylen);
keylen            678 drivers/crypto/caam/caamalg_qi.c 	return skcipher_setkey(skcipher, key, keylen, 0);
keylen            682 drivers/crypto/caam/caamalg_qi.c 				   const u8 *key, unsigned int keylen)
keylen            693 drivers/crypto/caam/caamalg_qi.c 	keylen -= CTR_RFC3686_NONCE_SIZE;
keylen            695 drivers/crypto/caam/caamalg_qi.c 	err = aes_check_keylen(keylen);
keylen            702 drivers/crypto/caam/caamalg_qi.c 	return skcipher_setkey(skcipher, key, keylen, ctx1_iv_off);
keylen            706 drivers/crypto/caam/caamalg_qi.c 			       const u8 *key, unsigned int keylen)
keylen            718 drivers/crypto/caam/caamalg_qi.c 	err = aes_check_keylen(keylen);
keylen            725 drivers/crypto/caam/caamalg_qi.c 	return skcipher_setkey(skcipher, key, keylen, ctx1_iv_off);
keylen            729 drivers/crypto/caam/caamalg_qi.c 				const u8 *key, unsigned int keylen)
keylen            732 drivers/crypto/caam/caamalg_qi.c 	       skcipher_setkey(skcipher, key, keylen, 0);
keylen            736 drivers/crypto/caam/caamalg_qi.c 			       const u8 *key, unsigned int keylen)
keylen            739 drivers/crypto/caam/caamalg_qi.c 	       skcipher_setkey(skcipher, key, keylen, 0);
keylen            743 drivers/crypto/caam/caamalg_qi.c 			       unsigned int keylen)
keylen            749 drivers/crypto/caam/caamalg_qi.c 	if (keylen != 2 * AES_MIN_KEY_SIZE  && keylen != 2 * AES_MAX_KEY_SIZE) {
keylen            754 drivers/crypto/caam/caamalg_qi.c 	ctx->cdata.keylen = keylen;
keylen            181 drivers/crypto/caam/caamalg_qi2.c 	if (!ctx->cdata.keylen || !ctx->authsize)
keylen            199 drivers/crypto/caam/caamalg_qi2.c 				ctx->cdata.keylen - CTR_RFC3686_NONCE_SIZE);
keylen            215 drivers/crypto/caam/caamalg_qi2.c 	data_len[1] = ctx->cdata.keylen;
keylen            281 drivers/crypto/caam/caamalg_qi2.c 		       unsigned int keylen)
keylen            287 drivers/crypto/caam/caamalg_qi2.c 	if (crypto_authenc_extractkeys(&keys, key, keylen) != 0)
keylen            294 drivers/crypto/caam/caamalg_qi2.c 			     DUMP_PREFIX_ADDRESS, 16, 4, key, keylen, 1);
keylen            296 drivers/crypto/caam/caamalg_qi2.c 	ctx->adata.keylen = keys.authkeylen;
keylen            311 drivers/crypto/caam/caamalg_qi2.c 	ctx->cdata.keylen = keys.enckeylen;
keylen            322 drivers/crypto/caam/caamalg_qi2.c 			    unsigned int keylen)
keylen            327 drivers/crypto/caam/caamalg_qi2.c 	err = crypto_authenc_extractkeys(&keys, key, keylen);
keylen            336 drivers/crypto/caam/caamalg_qi2.c 	      aead_setkey(aead, key, keylen);
keylen            594 drivers/crypto/caam/caamalg_qi2.c 	if (!ctx->cdata.keylen || !ctx->authsize)
keylen            631 drivers/crypto/caam/caamalg_qi2.c 			     unsigned int keylen)
keylen            637 drivers/crypto/caam/caamalg_qi2.c 	if (keylen != CHACHA_KEY_SIZE + saltlen) {
keylen            643 drivers/crypto/caam/caamalg_qi2.c 	ctx->cdata.keylen = keylen - saltlen;
keylen            656 drivers/crypto/caam/caamalg_qi2.c 			ctx->cdata.keylen;
keylen            658 drivers/crypto/caam/caamalg_qi2.c 	if (!ctx->cdata.keylen || !ctx->authsize)
keylen            721 drivers/crypto/caam/caamalg_qi2.c 		      const u8 *key, unsigned int keylen)
keylen            727 drivers/crypto/caam/caamalg_qi2.c 	ret = aes_check_keylen(keylen);
keylen            733 drivers/crypto/caam/caamalg_qi2.c 			     DUMP_PREFIX_ADDRESS, 16, 4, key, keylen, 1);
keylen            735 drivers/crypto/caam/caamalg_qi2.c 	memcpy(ctx->key, key, keylen);
keylen            736 drivers/crypto/caam/caamalg_qi2.c 	dma_sync_single_for_device(dev, ctx->key_dma, keylen, ctx->dir);
keylen            737 drivers/crypto/caam/caamalg_qi2.c 	ctx->cdata.keylen = keylen;
keylen            750 drivers/crypto/caam/caamalg_qi2.c 			ctx->cdata.keylen;
keylen            752 drivers/crypto/caam/caamalg_qi2.c 	if (!ctx->cdata.keylen || !ctx->authsize)
keylen            818 drivers/crypto/caam/caamalg_qi2.c 			  const u8 *key, unsigned int keylen)
keylen            824 drivers/crypto/caam/caamalg_qi2.c 	ret = aes_check_keylen(keylen - 4);
keylen            831 drivers/crypto/caam/caamalg_qi2.c 			     DUMP_PREFIX_ADDRESS, 16, 4, key, keylen, 1);
keylen            833 drivers/crypto/caam/caamalg_qi2.c 	memcpy(ctx->key, key, keylen);
keylen            838 drivers/crypto/caam/caamalg_qi2.c 	ctx->cdata.keylen = keylen - 4;
keylen            839 drivers/crypto/caam/caamalg_qi2.c 	dma_sync_single_for_device(dev, ctx->key_dma, ctx->cdata.keylen,
keylen            853 drivers/crypto/caam/caamalg_qi2.c 			ctx->cdata.keylen;
keylen            855 drivers/crypto/caam/caamalg_qi2.c 	if (!ctx->cdata.keylen || !ctx->authsize)
keylen            919 drivers/crypto/caam/caamalg_qi2.c 			  const u8 *key, unsigned int keylen)
keylen            925 drivers/crypto/caam/caamalg_qi2.c 	ret = aes_check_keylen(keylen - 4);
keylen            932 drivers/crypto/caam/caamalg_qi2.c 			     DUMP_PREFIX_ADDRESS, 16, 4, key, keylen, 1);
keylen            934 drivers/crypto/caam/caamalg_qi2.c 	memcpy(ctx->key, key, keylen);
keylen            939 drivers/crypto/caam/caamalg_qi2.c 	ctx->cdata.keylen = keylen - 4;
keylen            940 drivers/crypto/caam/caamalg_qi2.c 	dma_sync_single_for_device(dev, ctx->key_dma, ctx->cdata.keylen,
keylen            947 drivers/crypto/caam/caamalg_qi2.c 			   unsigned int keylen, const u32 ctx1_iv_off)
keylen            960 drivers/crypto/caam/caamalg_qi2.c 			     DUMP_PREFIX_ADDRESS, 16, 4, key, keylen, 1);
keylen            962 drivers/crypto/caam/caamalg_qi2.c 	ctx->cdata.keylen = keylen;
keylen            990 drivers/crypto/caam/caamalg_qi2.c 			       const u8 *key, unsigned int keylen)
keylen            994 drivers/crypto/caam/caamalg_qi2.c 	err = aes_check_keylen(keylen);
keylen           1001 drivers/crypto/caam/caamalg_qi2.c 	return skcipher_setkey(skcipher, key, keylen, 0);
keylen           1005 drivers/crypto/caam/caamalg_qi2.c 				   const u8 *key, unsigned int keylen)
keylen           1016 drivers/crypto/caam/caamalg_qi2.c 	keylen -= CTR_RFC3686_NONCE_SIZE;
keylen           1018 drivers/crypto/caam/caamalg_qi2.c 	err = aes_check_keylen(keylen);
keylen           1025 drivers/crypto/caam/caamalg_qi2.c 	return skcipher_setkey(skcipher, key, keylen, ctx1_iv_off);
keylen           1029 drivers/crypto/caam/caamalg_qi2.c 			       const u8 *key, unsigned int keylen)
keylen           1041 drivers/crypto/caam/caamalg_qi2.c 	err = aes_check_keylen(keylen);
keylen           1048 drivers/crypto/caam/caamalg_qi2.c 	return skcipher_setkey(skcipher, key, keylen, ctx1_iv_off);
keylen           1052 drivers/crypto/caam/caamalg_qi2.c 				    const u8 *key, unsigned int keylen)
keylen           1054 drivers/crypto/caam/caamalg_qi2.c 	if (keylen != CHACHA_KEY_SIZE) {
keylen           1060 drivers/crypto/caam/caamalg_qi2.c 	return skcipher_setkey(skcipher, key, keylen, 0);
keylen           1064 drivers/crypto/caam/caamalg_qi2.c 			       const u8 *key, unsigned int keylen)
keylen           1067 drivers/crypto/caam/caamalg_qi2.c 	       skcipher_setkey(skcipher, key, keylen, 0);
keylen           1071 drivers/crypto/caam/caamalg_qi2.c 			        const u8 *key, unsigned int keylen)
keylen           1074 drivers/crypto/caam/caamalg_qi2.c 	       skcipher_setkey(skcipher, key, keylen, 0);
keylen           1078 drivers/crypto/caam/caamalg_qi2.c 			       unsigned int keylen)
keylen           1085 drivers/crypto/caam/caamalg_qi2.c 	if (keylen != 2 * AES_MIN_KEY_SIZE  && keylen != 2 * AES_MAX_KEY_SIZE) {
keylen           1091 drivers/crypto/caam/caamalg_qi2.c 	ctx->cdata.keylen = keylen;
keylen           3163 drivers/crypto/caam/caamalg_qi2.c static int hash_digest_key(struct caam_hash_ctx *ctx, u32 *keylen, u8 *key,
keylen           3186 drivers/crypto/caam/caamalg_qi2.c 	key_dma = dma_map_single(ctx->dev, key, *keylen, DMA_BIDIRECTIONAL);
keylen           3199 drivers/crypto/caam/caamalg_qi2.c 	append_seq_fifo_load(desc, *keylen, FIFOLD_CLASS_CLASS2 |
keylen           3215 drivers/crypto/caam/caamalg_qi2.c 	dpaa2_fl_set_len(in_fle, *keylen);
keylen           3221 drivers/crypto/caam/caamalg_qi2.c 			     DUMP_PREFIX_ADDRESS, 16, 4, key, *keylen, 1);
keylen           3248 drivers/crypto/caam/caamalg_qi2.c 	dma_unmap_single(ctx->dev, key_dma, *keylen, DMA_BIDIRECTIONAL);
keylen           3254 drivers/crypto/caam/caamalg_qi2.c 	*keylen = digestsize;
keylen           3260 drivers/crypto/caam/caamalg_qi2.c 			unsigned int keylen)
keylen           3268 drivers/crypto/caam/caamalg_qi2.c 	dev_dbg(ctx->dev, "keylen %d blocksize %d\n", keylen, blocksize);
keylen           3270 drivers/crypto/caam/caamalg_qi2.c 	if (keylen > blocksize) {
keylen           3271 drivers/crypto/caam/caamalg_qi2.c 		hashed_key = kmemdup(key, keylen, GFP_KERNEL | GFP_DMA);
keylen           3274 drivers/crypto/caam/caamalg_qi2.c 		ret = hash_digest_key(ctx, &keylen, hashed_key, digestsize);
keylen           3280 drivers/crypto/caam/caamalg_qi2.c 	ctx->adata.keylen = keylen;
keylen           3295 drivers/crypto/caam/caamalg_qi2.c 	if (keylen > ctx->adata.keylen_pad) {
keylen           3296 drivers/crypto/caam/caamalg_qi2.c 		memcpy(ctx->key, key, keylen);
keylen            381 drivers/crypto/caam/caamhash.c static int hash_digest_key(struct caam_hash_ctx *ctx, u32 *keylen, u8 *key,
keylen            398 drivers/crypto/caam/caamhash.c 	key_dma = dma_map_single(jrdev, key, *keylen, DMA_BIDIRECTIONAL);
keylen            408 drivers/crypto/caam/caamhash.c 	append_seq_in_ptr(desc, key_dma, *keylen, 0);
keylen            409 drivers/crypto/caam/caamhash.c 	append_seq_fifo_load(desc, *keylen, FIFOLD_CLASS_CLASS2 |
keylen            416 drivers/crypto/caam/caamhash.c 			     DUMP_PREFIX_ADDRESS, 16, 4, key, *keylen, 1);
keylen            434 drivers/crypto/caam/caamhash.c 	dma_unmap_single(jrdev, key_dma, *keylen, DMA_BIDIRECTIONAL);
keylen            436 drivers/crypto/caam/caamhash.c 	*keylen = digestsize;
keylen            444 drivers/crypto/caam/caamhash.c 			const u8 *key, unsigned int keylen)
keylen            454 drivers/crypto/caam/caamhash.c 	dev_dbg(jrdev, "keylen %d\n", keylen);
keylen            456 drivers/crypto/caam/caamhash.c 	if (keylen > blocksize) {
keylen            457 drivers/crypto/caam/caamhash.c 		hashed_key = kmemdup(key, keylen, GFP_KERNEL | GFP_DMA);
keylen            460 drivers/crypto/caam/caamhash.c 		ret = hash_digest_key(ctx, &keylen, hashed_key, digestsize);
keylen            472 drivers/crypto/caam/caamhash.c 		ctx->adata.keylen = keylen;
keylen            479 drivers/crypto/caam/caamhash.c 		memcpy(ctx->key, key, keylen);
keylen            487 drivers/crypto/caam/caamhash.c 		if (keylen > ctx->adata.keylen_pad)
keylen            494 drivers/crypto/caam/caamhash.c 				    keylen, CAAM_MAX_HASH_KEY_SIZE);
keylen            508 drivers/crypto/caam/caamhash.c 			unsigned int keylen)
keylen            513 drivers/crypto/caam/caamhash.c 	if (keylen != AES_KEYSIZE_128) {
keylen            518 drivers/crypto/caam/caamhash.c 	memcpy(ctx->key, key, keylen);
keylen            519 drivers/crypto/caam/caamhash.c 	dma_sync_single_for_device(jrdev, ctx->adata.key_dma, keylen,
keylen            521 drivers/crypto/caam/caamhash.c 	ctx->adata.keylen = keylen;
keylen            524 drivers/crypto/caam/caamhash.c 			     DUMP_PREFIX_ADDRESS, 16, 4, ctx->key, keylen, 1);
keylen            530 drivers/crypto/caam/caamhash.c 			unsigned int keylen)
keylen            535 drivers/crypto/caam/caamhash.c 	err = aes_check_keylen(keylen);
keylen            543 drivers/crypto/caam/caamhash.c 	ctx->adata.keylen = keylen;
keylen            546 drivers/crypto/caam/caamhash.c 			     DUMP_PREFIX_ADDRESS, 16, 4, key, keylen, 1);
keylen             36 drivers/crypto/caam/caamhash_desc.c 	if (state != OP_ALG_AS_UPDATE && adata->keylen) {
keylen             46 drivers/crypto/caam/caamhash_desc.c 					  adata->keylen, CLASS_2 |
keylen             98 drivers/crypto/caam/caamhash_desc.c 		append_key_as_imm(desc, adata->key_virt, adata->keylen,
keylen             99 drivers/crypto/caam/caamhash_desc.c 				  adata->keylen, CLASS_1 | KEY_DEST_CLASS_REG);
keylen            103 drivers/crypto/caam/caamhash_desc.c 			append_key(desc, adata->key_dma, adata->keylen,
keylen            106 drivers/crypto/caam/caamhash_desc.c 			append_key_as_imm(desc, adata->key_virt, adata->keylen,
keylen            107 drivers/crypto/caam/caamhash_desc.c 					  adata->keylen, CLASS_1 |
keylen            138 drivers/crypto/caam/caamhash_desc.c 		append_fifo_store(desc, adata->key_dma, adata->keylen,
keylen            870 drivers/crypto/caam/caampkc.c 				unsigned int keylen)
keylen            880 drivers/crypto/caam/caampkc.c 	ret = rsa_parse_pub_key(&raw_key, key, keylen);
keylen            972 drivers/crypto/caam/caampkc.c 				 unsigned int keylen)
keylen            982 drivers/crypto/caam/caampkc.c 	ret = rsa_parse_priv_key(&raw_key, key, keylen);
keylen            506 drivers/crypto/caam/desc_constr.h 	unsigned int keylen;
keylen            575 drivers/crypto/caam/desc_constr.h 		if (adata->keylen > adata->keylen_pad) {
keylen            578 drivers/crypto/caam/desc_constr.h 					 OP_PCL_DKP_DST_IMM | adata->keylen);
keylen            586 drivers/crypto/caam/desc_constr.h 					 OP_PCL_DKP_DST_IMM | adata->keylen);
keylen            587 drivers/crypto/caam/desc_constr.h 			append_data(desc, adata->key_virt, adata->keylen);
keylen            590 drivers/crypto/caam/desc_constr.h 				 ALIGN(adata->keylen, CAAM_CMD_SZ)) /
keylen            600 drivers/crypto/caam/desc_constr.h 				 adata->keylen);
keylen             45 drivers/crypto/caam/key_gen.c 		  struct alginfo * const adata, const u8 *key_in, u32 keylen,
keylen             54 drivers/crypto/caam/key_gen.c 	adata->keylen = split_key_len(adata->algtype & OP_ALG_ALGSEL_MASK);
keylen             57 drivers/crypto/caam/key_gen.c 	local_max = max(keylen, adata->keylen_pad);
keylen             60 drivers/crypto/caam/key_gen.c 		adata->keylen, adata->keylen_pad);
keylen             62 drivers/crypto/caam/key_gen.c 			     DUMP_PREFIX_ADDRESS, 16, 4, key_in, keylen, 1);
keylen             73 drivers/crypto/caam/key_gen.c 	memcpy(key_out, key_in, keylen);
keylen             82 drivers/crypto/caam/key_gen.c 	append_key(desc, dma_addr, keylen, CLASS_2 | KEY_DEST_CLASS_REG);
keylen            100 drivers/crypto/caam/key_gen.c 	append_fifo_store(desc, dma_addr, adata->keylen,
keylen             47 drivers/crypto/caam/key_gen.h 		  struct alginfo * const adata, const u8 *key_in, u32 keylen,
keylen            231 drivers/crypto/cavium/cpt/cptvf_algs.c 		   u32 keylen)
keylen            237 drivers/crypto/cavium/cpt/cptvf_algs.c 	const u8 *key2 = key + (keylen / 2);
keylen            239 drivers/crypto/cavium/cpt/cptvf_algs.c 	err = xts_check_key(tfm, key, keylen);
keylen            242 drivers/crypto/cavium/cpt/cptvf_algs.c 	ctx->key_len = keylen;
keylen            243 drivers/crypto/cavium/cpt/cptvf_algs.c 	memcpy(ctx->enc_key, key1, keylen / 2);
keylen            244 drivers/crypto/cavium/cpt/cptvf_algs.c 	memcpy(ctx->enc_key + KEY2_OFFSET, key2, keylen / 2);
keylen            260 drivers/crypto/cavium/cpt/cptvf_algs.c static int cvm_validate_keylen(struct cvm_enc_ctx *ctx, u32 keylen)
keylen            262 drivers/crypto/cavium/cpt/cptvf_algs.c 	if ((keylen == 16) || (keylen == 24) || (keylen == 32)) {
keylen            263 drivers/crypto/cavium/cpt/cptvf_algs.c 		ctx->key_len = keylen;
keylen            288 drivers/crypto/cavium/cpt/cptvf_algs.c 		      u32 keylen, u8 cipher_type)
keylen            294 drivers/crypto/cavium/cpt/cptvf_algs.c 	if (!cvm_validate_keylen(ctx, keylen)) {
keylen            295 drivers/crypto/cavium/cpt/cptvf_algs.c 		memcpy(ctx->enc_key, key, keylen);
keylen            305 drivers/crypto/cavium/cpt/cptvf_algs.c 			      u32 keylen)
keylen            307 drivers/crypto/cavium/cpt/cptvf_algs.c 	return cvm_setkey(cipher, key, keylen, AES_CBC);
keylen            311 drivers/crypto/cavium/cpt/cptvf_algs.c 			      u32 keylen)
keylen            313 drivers/crypto/cavium/cpt/cptvf_algs.c 	return cvm_setkey(cipher, key, keylen, AES_ECB);
keylen            317 drivers/crypto/cavium/cpt/cptvf_algs.c 			      u32 keylen)
keylen            319 drivers/crypto/cavium/cpt/cptvf_algs.c 	return cvm_setkey(cipher, key, keylen, AES_CFB);
keylen            323 drivers/crypto/cavium/cpt/cptvf_algs.c 			       u32 keylen)
keylen            326 drivers/crypto/cavium/cpt/cptvf_algs.c 	       cvm_setkey(cipher, key, keylen, DES3_CBC);
keylen            330 drivers/crypto/cavium/cpt/cptvf_algs.c 			       u32 keylen)
keylen            333 drivers/crypto/cavium/cpt/cptvf_algs.c 	       cvm_setkey(cipher, key, keylen, DES3_ECB);
keylen             35 drivers/crypto/cavium/nitrox/nitrox_aead.c 				 unsigned int keylen)
keylen             42 drivers/crypto/cavium/nitrox/nitrox_aead.c 	aes_keylen = flexi_aes_keylen(keylen);
keylen             56 drivers/crypto/cavium/nitrox/nitrox_aead.c 	memcpy(fctx->crypto.u.key, key, keylen);
keylen            330 drivers/crypto/cavium/nitrox/nitrox_aead.c 				 unsigned int keylen)
keylen            336 drivers/crypto/cavium/nitrox/nitrox_aead.c 	if (keylen < GCM_AES_SALT_SIZE)
keylen            339 drivers/crypto/cavium/nitrox/nitrox_aead.c 	keylen -= GCM_AES_SALT_SIZE;
keylen            340 drivers/crypto/cavium/nitrox/nitrox_aead.c 	ret = nitrox_aes_gcm_setkey(aead, key, keylen);
keylen            344 drivers/crypto/cavium/nitrox/nitrox_aead.c 	memcpy(fctx->crypto.iv, key + keylen, GCM_AES_SALT_SIZE);
keylen            526 drivers/crypto/cavium/nitrox/nitrox_req.h static inline int flexi_aes_keylen(int keylen)
keylen            530 drivers/crypto/cavium/nitrox/nitrox_req.h 	switch (keylen) {
keylen             94 drivers/crypto/cavium/nitrox/nitrox_skcipher.c 					 unsigned int keylen)
keylen            119 drivers/crypto/cavium/nitrox/nitrox_skcipher.c 	memcpy(fctx->crypto.u.key, key, keylen);
keylen            125 drivers/crypto/cavium/nitrox/nitrox_skcipher.c 			     unsigned int keylen)
keylen            129 drivers/crypto/cavium/nitrox/nitrox_skcipher.c 	aes_keylen = flexi_aes_keylen(keylen);
keylen            134 drivers/crypto/cavium/nitrox/nitrox_skcipher.c 	return nitrox_skcipher_setkey(cipher, aes_keylen, key, keylen);
keylen            258 drivers/crypto/cavium/nitrox/nitrox_skcipher.c 			      const u8 *key, unsigned int keylen)
keylen            261 drivers/crypto/cavium/nitrox/nitrox_skcipher.c 	       nitrox_skcipher_setkey(cipher, 0, key, keylen);
keylen            275 drivers/crypto/cavium/nitrox/nitrox_skcipher.c 				 const u8 *key, unsigned int keylen)
keylen            282 drivers/crypto/cavium/nitrox/nitrox_skcipher.c 	ret = xts_check_key(tfm, key, keylen);
keylen            286 drivers/crypto/cavium/nitrox/nitrox_skcipher.c 	keylen /= 2;
keylen            288 drivers/crypto/cavium/nitrox/nitrox_skcipher.c 	aes_keylen = flexi_aes_keylen(keylen);
keylen            296 drivers/crypto/cavium/nitrox/nitrox_skcipher.c 	memcpy(fctx->auth.u.key2, (key + keylen), keylen);
keylen            298 drivers/crypto/cavium/nitrox/nitrox_skcipher.c 	return nitrox_skcipher_setkey(cipher, aes_keylen, key, keylen);
keylen            302 drivers/crypto/cavium/nitrox/nitrox_skcipher.c 					 const u8 *key, unsigned int keylen)
keylen            309 drivers/crypto/cavium/nitrox/nitrox_skcipher.c 	if (keylen < CTR_RFC3686_NONCE_SIZE)
keylen            314 drivers/crypto/cavium/nitrox/nitrox_skcipher.c 	memcpy(fctx->crypto.iv, key + (keylen - CTR_RFC3686_NONCE_SIZE),
keylen            317 drivers/crypto/cavium/nitrox/nitrox_skcipher.c 	keylen -= CTR_RFC3686_NONCE_SIZE;
keylen            319 drivers/crypto/cavium/nitrox/nitrox_skcipher.c 	aes_keylen = flexi_aes_keylen(keylen);
keylen            324 drivers/crypto/cavium/nitrox/nitrox_skcipher.c 	return nitrox_skcipher_setkey(cipher, aes_keylen, key, keylen);
keylen            127 drivers/crypto/ccp/ccp-crypto-rsa.c 			  unsigned int keylen, bool private)
keylen            138 drivers/crypto/ccp/ccp-crypto-rsa.c 		ret = rsa_parse_priv_key(&raw_key, key, keylen);
keylen            140 drivers/crypto/ccp/ccp-crypto-rsa.c 		ret = rsa_parse_pub_key(&raw_key, key, keylen);
keylen            182 drivers/crypto/ccp/ccp-crypto-rsa.c 			      unsigned int keylen)
keylen            184 drivers/crypto/ccp/ccp-crypto-rsa.c 	return ccp_rsa_setkey(tfm, key, keylen, true);
keylen            188 drivers/crypto/ccp/ccp-crypto-rsa.c 			     unsigned int keylen)
keylen            190 drivers/crypto/ccp/ccp-crypto-rsa.c 	return ccp_rsa_setkey(tfm, key, keylen, false);
keylen            414 drivers/crypto/ccree/cc_aead.c 				 unsigned int keylen)
keylen            444 drivers/crypto/ccree/cc_aead.c 	if (keylen != 0) {
keylen            446 drivers/crypto/ccree/cc_aead.c 		key = kmemdup(authkey, keylen, GFP_KERNEL);
keylen            450 drivers/crypto/ccree/cc_aead.c 		key_dma_addr = dma_map_single(dev, (void *)key, keylen,
keylen            454 drivers/crypto/ccree/cc_aead.c 				key, keylen);
keylen            458 drivers/crypto/ccree/cc_aead.c 		if (keylen > blocksize) {
keylen            478 drivers/crypto/ccree/cc_aead.c 				     key_dma_addr, keylen, NS_BIT);
keylen            504 drivers/crypto/ccree/cc_aead.c 				     keylen, NS_BIT);
keylen            507 drivers/crypto/ccree/cc_aead.c 				      keylen, NS_BIT, 0);
keylen            510 drivers/crypto/ccree/cc_aead.c 			if ((blocksize - keylen) != 0) {
keylen            513 drivers/crypto/ccree/cc_aead.c 					      (blocksize - keylen));
keylen            517 drivers/crypto/ccree/cc_aead.c 					       keylen),
keylen            518 drivers/crypto/ccree/cc_aead.c 					      (blocksize - keylen), NS_BIT, 0);
keylen            524 drivers/crypto/ccree/cc_aead.c 		set_din_const(&desc[idx], 0, (blocksize - keylen));
keylen            536 drivers/crypto/ccree/cc_aead.c 		dma_unmap_single(dev, key_dma_addr, keylen, DMA_TO_DEVICE);
keylen            544 drivers/crypto/ccree/cc_aead.c 			  unsigned int keylen)
keylen            555 drivers/crypto/ccree/cc_aead.c 		ctx, crypto_tfm_alg_name(crypto_aead_tfm(tfm)), key, keylen);
keylen            562 drivers/crypto/ccree/cc_aead.c 		rc = crypto_authenc_extractkeys(&keys, key, keylen);
keylen            587 drivers/crypto/ccree/cc_aead.c 		ctx->enc_keylen = keylen;
keylen            649 drivers/crypto/ccree/cc_aead.c 			       unsigned int keylen)
keylen            654 drivers/crypto/ccree/cc_aead.c 	err = crypto_authenc_extractkeys(&keys, key, keylen);
keylen            659 drivers/crypto/ccree/cc_aead.c 	      cc_aead_setkey(aead, key, keylen);
keylen            666 drivers/crypto/ccree/cc_aead.c 				 unsigned int keylen)
keylen            670 drivers/crypto/ccree/cc_aead.c 	if (keylen < 3)
keylen            673 drivers/crypto/ccree/cc_aead.c 	keylen -= 3;
keylen            674 drivers/crypto/ccree/cc_aead.c 	memcpy(ctx->ctr_nonce, key + keylen, 3);
keylen            676 drivers/crypto/ccree/cc_aead.c 	return cc_aead_setkey(tfm, key, keylen);
keylen           2139 drivers/crypto/ccree/cc_aead.c 				 unsigned int keylen)
keylen           2144 drivers/crypto/ccree/cc_aead.c 	dev_dbg(dev, "%s()  keylen %d, key %p\n", __func__, keylen, key);
keylen           2146 drivers/crypto/ccree/cc_aead.c 	if (keylen < 4)
keylen           2149 drivers/crypto/ccree/cc_aead.c 	keylen -= 4;
keylen           2150 drivers/crypto/ccree/cc_aead.c 	memcpy(ctx->ctr_nonce, key + keylen, 4);
keylen           2152 drivers/crypto/ccree/cc_aead.c 	return cc_aead_setkey(tfm, key, keylen);
keylen           2156 drivers/crypto/ccree/cc_aead.c 				 unsigned int keylen)
keylen           2161 drivers/crypto/ccree/cc_aead.c 	dev_dbg(dev, "%s()  keylen %d, key %p\n", __func__, keylen, key);
keylen           2163 drivers/crypto/ccree/cc_aead.c 	if (keylen < 4)
keylen           2166 drivers/crypto/ccree/cc_aead.c 	keylen -= 4;
keylen           2167 drivers/crypto/ccree/cc_aead.c 	memcpy(ctx->ctr_nonce, key + keylen, 4);
keylen           2169 drivers/crypto/ccree/cc_aead.c 	return cc_aead_setkey(tfm, key, keylen);
keylen             51 drivers/crypto/ccree/cc_cipher.c 	int keylen;
keylen            278 drivers/crypto/ccree/cc_cipher.c 			     unsigned int keylen)
keylen            286 drivers/crypto/ccree/cc_cipher.c 		ctx_p, crypto_tfm_alg_name(tfm), keylen);
keylen            287 drivers/crypto/ccree/cc_cipher.c 	dump_byte_array("key", (u8 *)key, keylen);
keylen            292 drivers/crypto/ccree/cc_cipher.c 	if (keylen != sizeof(hki)) {
keylen            293 drivers/crypto/ccree/cc_cipher.c 		dev_err(dev, "Unsupported protected key size %d.\n", keylen);
keylen            298 drivers/crypto/ccree/cc_cipher.c 	memcpy(&hki, key, keylen);
keylen            303 drivers/crypto/ccree/cc_cipher.c 	keylen = hki.keylen;
keylen            305 drivers/crypto/ccree/cc_cipher.c 	if (validate_keys_sizes(ctx_p, keylen)) {
keylen            306 drivers/crypto/ccree/cc_cipher.c 		dev_err(dev, "Unsupported key size %d.\n", keylen);
keylen            311 drivers/crypto/ccree/cc_cipher.c 	ctx_p->keylen = keylen;
keylen            380 drivers/crypto/ccree/cc_cipher.c 			    unsigned int keylen)
keylen            391 drivers/crypto/ccree/cc_cipher.c 		ctx_p, crypto_tfm_alg_name(tfm), keylen);
keylen            392 drivers/crypto/ccree/cc_cipher.c 	dump_byte_array("key", (u8 *)key, keylen);
keylen            396 drivers/crypto/ccree/cc_cipher.c 	if (validate_keys_sizes(ctx_p, keylen)) {
keylen            397 drivers/crypto/ccree/cc_cipher.c 		dev_err(dev, "Unsupported key size %d.\n", keylen);
keylen            410 drivers/crypto/ccree/cc_cipher.c 		if ((keylen == DES3_EDE_KEY_SIZE &&
keylen            419 drivers/crypto/ccree/cc_cipher.c 	    xts_check_key(tfm, key, keylen)) {
keylen            428 drivers/crypto/ccree/cc_cipher.c 	memcpy(ctx_p->user.key, key, keylen);
keylen            429 drivers/crypto/ccree/cc_cipher.c 	if (keylen == 24)
keylen            434 drivers/crypto/ccree/cc_cipher.c 		int key_len = keylen >> 1;
keylen            450 drivers/crypto/ccree/cc_cipher.c 	ctx_p->keylen = keylen;
keylen            592 drivers/crypto/ccree/cc_cipher.c 	unsigned int key_len = ctx_p->keylen;
keylen            673 drivers/crypto/ccree/cc_cipher.c 	unsigned int key_len = ctx_p->keylen;
keylen             32 drivers/crypto/ccree/cc_cipher.h 	u16 keylen;
keylen             70 drivers/crypto/ccree/cc_hash.c 	u32 keylen;
keylen            720 drivers/crypto/ccree/cc_hash.c 			  unsigned int keylen)
keylen            734 drivers/crypto/ccree/cc_hash.c 	dev_dbg(dev, "start keylen: %d", keylen);
keylen            744 drivers/crypto/ccree/cc_hash.c 	ctx->key_params.keylen = keylen;
keylen            749 drivers/crypto/ccree/cc_hash.c 	if (keylen) {
keylen            750 drivers/crypto/ccree/cc_hash.c 		ctx->key_params.key = kmemdup(key, keylen, GFP_KERNEL);
keylen            755 drivers/crypto/ccree/cc_hash.c 			dma_map_single(dev, (void *)ctx->key_params.key, keylen,
keylen            759 drivers/crypto/ccree/cc_hash.c 				ctx->key_params.key, keylen);
keylen            764 drivers/crypto/ccree/cc_hash.c 			&ctx->key_params.key_dma_addr, ctx->key_params.keylen);
keylen            766 drivers/crypto/ccree/cc_hash.c 		if (keylen > blocksize) {
keylen            787 drivers/crypto/ccree/cc_hash.c 				     ctx->key_params.key_dma_addr, keylen,
keylen            814 drivers/crypto/ccree/cc_hash.c 				     ctx->key_params.key_dma_addr, keylen,
keylen            818 drivers/crypto/ccree/cc_hash.c 				      keylen, NS_BIT, 0);
keylen            821 drivers/crypto/ccree/cc_hash.c 			if ((blocksize - keylen)) {
keylen            824 drivers/crypto/ccree/cc_hash.c 					      (blocksize - keylen));
keylen            828 drivers/crypto/ccree/cc_hash.c 					       keylen), (blocksize - keylen),
keylen            907 drivers/crypto/ccree/cc_hash.c 				 ctx->key_params.keylen, DMA_TO_DEVICE);
keylen            909 drivers/crypto/ccree/cc_hash.c 			&ctx->key_params.key_dma_addr, ctx->key_params.keylen);
keylen            918 drivers/crypto/ccree/cc_hash.c 			  const u8 *key, unsigned int keylen)
keylen            927 drivers/crypto/ccree/cc_hash.c 	dev_dbg(dev, "===== setkey (%d) ====\n", keylen);
keylen            929 drivers/crypto/ccree/cc_hash.c 	switch (keylen) {
keylen            938 drivers/crypto/ccree/cc_hash.c 	ctx->key_params.keylen = keylen;
keylen            940 drivers/crypto/ccree/cc_hash.c 	ctx->key_params.key = kmemdup(key, keylen, GFP_KERNEL);
keylen            945 drivers/crypto/ccree/cc_hash.c 		dma_map_single(dev, ctx->key_params.key, keylen, DMA_TO_DEVICE);
keylen            948 drivers/crypto/ccree/cc_hash.c 			key, keylen);
keylen            953 drivers/crypto/ccree/cc_hash.c 		&ctx->key_params.key_dma_addr, ctx->key_params.keylen);
keylen            959 drivers/crypto/ccree/cc_hash.c 		     keylen, NS_BIT);
keylen            962 drivers/crypto/ccree/cc_hash.c 	set_key_size_aes(&desc[idx], keylen);
keylen            997 drivers/crypto/ccree/cc_hash.c 			 ctx->key_params.keylen, DMA_TO_DEVICE);
keylen            999 drivers/crypto/ccree/cc_hash.c 		&ctx->key_params.key_dma_addr, ctx->key_params.keylen);
keylen           1007 drivers/crypto/ccree/cc_hash.c 			  const u8 *key, unsigned int keylen)
keylen           1012 drivers/crypto/ccree/cc_hash.c 	dev_dbg(dev, "===== setkey (%d) ====\n", keylen);
keylen           1016 drivers/crypto/ccree/cc_hash.c 	switch (keylen) {
keylen           1025 drivers/crypto/ccree/cc_hash.c 	ctx->key_params.keylen = keylen;
keylen           1030 drivers/crypto/ccree/cc_hash.c 				keylen, DMA_TO_DEVICE);
keylen           1032 drivers/crypto/ccree/cc_hash.c 	memcpy(ctx->opad_tmp_keys_buff, key, keylen);
keylen           1033 drivers/crypto/ccree/cc_hash.c 	if (keylen == 24) {
keylen           1039 drivers/crypto/ccree/cc_hash.c 				   keylen, DMA_TO_DEVICE);
keylen           1041 drivers/crypto/ccree/cc_hash.c 	ctx->key_params.keylen = keylen;
keylen           1066 drivers/crypto/ccree/cc_hash.c 	ctx->key_params.keylen = 0;
keylen           1073 drivers/crypto/ccree/cc_hash.c 	ctx->key_params.keylen = 0;
keylen           1236 drivers/crypto/ccree/cc_hash.c 		key_size = (ctx->key_params.keylen == 24) ? AES_MAX_KEY_SIZE :
keylen           1237 drivers/crypto/ccree/cc_hash.c 			ctx->key_params.keylen;
keylen           1238 drivers/crypto/ccree/cc_hash.c 		key_len =  ctx->key_params.keylen;
keylen           1385 drivers/crypto/ccree/cc_hash.c 		key_len = ctx->key_params.keylen;
keylen           1464 drivers/crypto/ccree/cc_hash.c 		key_len = ctx->key_params.keylen;
keylen           2192 drivers/crypto/ccree/cc_hash.c 		     ((ctx->key_params.keylen == 24) ? AES_MAX_KEY_SIZE :
keylen           2193 drivers/crypto/ccree/cc_hash.c 		      ctx->key_params.keylen), NS_BIT);
keylen           2197 drivers/crypto/ccree/cc_hash.c 	set_key_size_aes(&desc[idx], ctx->key_params.keylen);
keylen           2208 drivers/crypto/ccree/cc_hash.c 	set_key_size_aes(&desc[idx], ctx->key_params.keylen);
keylen            854 drivers/crypto/chelsio/chcr_algo.c static inline int chcr_keyctx_ck_size(unsigned int keylen)
keylen            858 drivers/crypto/chelsio/chcr_algo.c 	if (keylen == AES_KEYSIZE_128)
keylen            860 drivers/crypto/chelsio/chcr_algo.c 	else if (keylen == AES_KEYSIZE_192)
keylen            862 drivers/crypto/chelsio/chcr_algo.c 	else if (keylen == AES_KEYSIZE_256)
keylen            871 drivers/crypto/chelsio/chcr_algo.c 				       unsigned int keylen)
keylen            881 drivers/crypto/chelsio/chcr_algo.c 	err = crypto_sync_skcipher_setkey(ablkctx->sw_cipher, key, keylen);
keylen            891 drivers/crypto/chelsio/chcr_algo.c 			       unsigned int keylen)
keylen            898 drivers/crypto/chelsio/chcr_algo.c 	err = chcr_cipher_fallback_setkey(cipher, key, keylen);
keylen            902 drivers/crypto/chelsio/chcr_algo.c 	ck_size = chcr_keyctx_ck_size(keylen);
keylen            904 drivers/crypto/chelsio/chcr_algo.c 	memcpy(ablkctx->key, key, keylen);
keylen            905 drivers/crypto/chelsio/chcr_algo.c 	ablkctx->enckey_len = keylen;
keylen            906 drivers/crypto/chelsio/chcr_algo.c 	get_aes_decrypt_key(ablkctx->rrkey, ablkctx->key, keylen << 3);
keylen            908 drivers/crypto/chelsio/chcr_algo.c 			keylen + alignment) >> 4;
keylen            923 drivers/crypto/chelsio/chcr_algo.c 				   unsigned int keylen)
keylen            930 drivers/crypto/chelsio/chcr_algo.c 	err = chcr_cipher_fallback_setkey(cipher, key, keylen);
keylen            933 drivers/crypto/chelsio/chcr_algo.c 	ck_size = chcr_keyctx_ck_size(keylen);
keylen            935 drivers/crypto/chelsio/chcr_algo.c 	memcpy(ablkctx->key, key, keylen);
keylen            936 drivers/crypto/chelsio/chcr_algo.c 	ablkctx->enckey_len = keylen;
keylen            938 drivers/crypto/chelsio/chcr_algo.c 			keylen + alignment) >> 4;
keylen            954 drivers/crypto/chelsio/chcr_algo.c 				   unsigned int keylen)
keylen            961 drivers/crypto/chelsio/chcr_algo.c 	if (keylen < CTR_RFC3686_NONCE_SIZE)
keylen            963 drivers/crypto/chelsio/chcr_algo.c 	memcpy(ablkctx->nonce, key + (keylen - CTR_RFC3686_NONCE_SIZE),
keylen            966 drivers/crypto/chelsio/chcr_algo.c 	keylen -= CTR_RFC3686_NONCE_SIZE;
keylen            967 drivers/crypto/chelsio/chcr_algo.c 	err = chcr_cipher_fallback_setkey(cipher, key, keylen);
keylen            971 drivers/crypto/chelsio/chcr_algo.c 	ck_size = chcr_keyctx_ck_size(keylen);
keylen            973 drivers/crypto/chelsio/chcr_algo.c 	memcpy(ablkctx->key, key, keylen);
keylen            974 drivers/crypto/chelsio/chcr_algo.c 	ablkctx->enckey_len = keylen;
keylen            976 drivers/crypto/chelsio/chcr_algo.c 			keylen + alignment) >> 4;
keylen           1029 drivers/crypto/chelsio/chcr_algo.c 	unsigned int keylen;
keylen           1035 drivers/crypto/chelsio/chcr_algo.c 	keylen = ablkctx->enckey_len / 2;
keylen           1036 drivers/crypto/chelsio/chcr_algo.c 	key = ablkctx->key + keylen;
keylen           1037 drivers/crypto/chelsio/chcr_algo.c 	ret = aes_expandkey(&aes, key, keylen);
keylen           2100 drivers/crypto/chelsio/chcr_algo.c 			     unsigned int keylen)
keylen           2114 drivers/crypto/chelsio/chcr_algo.c 	if (keylen > bs) {
keylen           2115 drivers/crypto/chelsio/chcr_algo.c 		err = crypto_shash_digest(shash, key, keylen,
keylen           2119 drivers/crypto/chelsio/chcr_algo.c 		keylen = digestsize;
keylen           2121 drivers/crypto/chelsio/chcr_algo.c 		memcpy(hmacctx->ipad, key, keylen);
keylen           2123 drivers/crypto/chelsio/chcr_algo.c 	memset(hmacctx->ipad + keylen, 0, bs - keylen);
keylen           3268 drivers/crypto/chelsio/chcr_algo.c 				unsigned int keylen)
keylen           3274 drivers/crypto/chelsio/chcr_algo.c 	key_ctx_size = sizeof(struct _key_ctx) + roundup(keylen, 16) * 2;
keylen           3275 drivers/crypto/chelsio/chcr_algo.c 	if (keylen == AES_KEYSIZE_128) {
keylen           3278 drivers/crypto/chelsio/chcr_algo.c 	} else if (keylen == AES_KEYSIZE_192) {
keylen           3281 drivers/crypto/chelsio/chcr_algo.c 	} else if (keylen == AES_KEYSIZE_256) {
keylen           3291 drivers/crypto/chelsio/chcr_algo.c 	memcpy(aeadctx->key, key, keylen);
keylen           3292 drivers/crypto/chelsio/chcr_algo.c 	aeadctx->enckey_len = keylen;
keylen           3299 drivers/crypto/chelsio/chcr_algo.c 				unsigned int keylen)
keylen           3307 drivers/crypto/chelsio/chcr_algo.c 	error = crypto_aead_setkey(aeadctx->sw_cipher, key, keylen);
keylen           3313 drivers/crypto/chelsio/chcr_algo.c 	return chcr_ccm_common_setkey(aead, key, keylen);
keylen           3317 drivers/crypto/chelsio/chcr_algo.c 				    unsigned int keylen)
keylen           3322 drivers/crypto/chelsio/chcr_algo.c 	if (keylen < 3) {
keylen           3330 drivers/crypto/chelsio/chcr_algo.c 	error = crypto_aead_setkey(aeadctx->sw_cipher, key, keylen);
keylen           3336 drivers/crypto/chelsio/chcr_algo.c 	keylen -= 3;
keylen           3337 drivers/crypto/chelsio/chcr_algo.c 	memcpy(aeadctx->salt, key + keylen, 3);
keylen           3338 drivers/crypto/chelsio/chcr_algo.c 	return chcr_ccm_common_setkey(aead, key, keylen);
keylen           3342 drivers/crypto/chelsio/chcr_algo.c 			   unsigned int keylen)
keylen           3354 drivers/crypto/chelsio/chcr_algo.c 	ret = crypto_aead_setkey(aeadctx->sw_cipher, key, keylen);
keylen           3362 drivers/crypto/chelsio/chcr_algo.c 	    keylen > 3) {
keylen           3363 drivers/crypto/chelsio/chcr_algo.c 		keylen -= 4;  /* nonce/salt is present in the last 4 bytes */
keylen           3364 drivers/crypto/chelsio/chcr_algo.c 		memcpy(aeadctx->salt, key + keylen, 4);
keylen           3366 drivers/crypto/chelsio/chcr_algo.c 	if (keylen == AES_KEYSIZE_128) {
keylen           3368 drivers/crypto/chelsio/chcr_algo.c 	} else if (keylen == AES_KEYSIZE_192) {
keylen           3370 drivers/crypto/chelsio/chcr_algo.c 	} else if (keylen == AES_KEYSIZE_256) {
keylen           3374 drivers/crypto/chelsio/chcr_algo.c 		pr_err("GCM: Invalid key length %d\n", keylen);
keylen           3379 drivers/crypto/chelsio/chcr_algo.c 	memcpy(aeadctx->key, key, keylen);
keylen           3380 drivers/crypto/chelsio/chcr_algo.c 	aeadctx->enckey_len = keylen;
keylen           3381 drivers/crypto/chelsio/chcr_algo.c 	key_ctx_size = sizeof(struct _key_ctx) + roundup(keylen, 16) +
keylen           3390 drivers/crypto/chelsio/chcr_algo.c 	ret = aes_expandkey(&aes, key, keylen);
keylen           3404 drivers/crypto/chelsio/chcr_algo.c 				   unsigned int keylen)
keylen           3423 drivers/crypto/chelsio/chcr_algo.c 	err = crypto_aead_setkey(aeadctx->sw_cipher, key, keylen);
keylen           3430 drivers/crypto/chelsio/chcr_algo.c 	if (crypto_authenc_extractkeys(&keys, key, keylen) != 0) {
keylen           3539 drivers/crypto/chelsio/chcr_algo.c 					const u8 *key, unsigned int keylen)
keylen           3553 drivers/crypto/chelsio/chcr_algo.c 	err = crypto_aead_setkey(aeadctx->sw_cipher, key, keylen);
keylen           3560 drivers/crypto/chelsio/chcr_algo.c 	if (crypto_authenc_extractkeys(&keys, key, keylen) != 0) {
keylen            135 drivers/crypto/chelsio/chcr_ipsec.c 	int keylen = (x->aead->alg_key_len + 7) / 8;
keylen            142 drivers/crypto/chelsio/chcr_ipsec.c 	if (keylen > 3) {
keylen            143 drivers/crypto/chelsio/chcr_ipsec.c 		keylen -= 4;  /* nonce/salt is present in the last 4 bytes */
keylen            144 drivers/crypto/chelsio/chcr_ipsec.c 		memcpy(sa_entry->salt, key + keylen, 4);
keylen            147 drivers/crypto/chelsio/chcr_ipsec.c 	if (keylen == AES_KEYSIZE_128) {
keylen            149 drivers/crypto/chelsio/chcr_ipsec.c 	} else if (keylen == AES_KEYSIZE_192) {
keylen            151 drivers/crypto/chelsio/chcr_ipsec.c 	} else if (keylen == AES_KEYSIZE_256) {
keylen            154 drivers/crypto/chelsio/chcr_ipsec.c 		pr_err("GCM: Invalid key length %d\n", keylen);
keylen            159 drivers/crypto/chelsio/chcr_ipsec.c 	memcpy(sa_entry->key, key, keylen);
keylen            160 drivers/crypto/chelsio/chcr_ipsec.c 	sa_entry->enckey_len = keylen;
keylen            162 drivers/crypto/chelsio/chcr_ipsec.c 			      ((DIV_ROUND_UP(keylen, 16)) << 4) +
keylen            173 drivers/crypto/chelsio/chcr_ipsec.c 	ret = aes_expandkey(&aes, key, keylen);
keylen            169 drivers/crypto/chelsio/chtls/chtls.h 	u16 keylen;
keylen            484 drivers/crypto/chelsio/chtls/chtls.h int chtls_setkey(struct chtls_sock *csk, u32 keylen, u32 mode);
keylen            211 drivers/crypto/chelsio/chtls/chtls_hw.c 			  u32 keylen, u32 optname)
keylen            224 drivers/crypto/chelsio/chtls/chtls_hw.c 		       roundup(keylen, 16) + AEAD_H_SIZE;
keylen            226 drivers/crypto/chelsio/chtls/chtls_hw.c 	if (keylen == AES_KEYSIZE_128) {
keylen            229 drivers/crypto/chelsio/chtls/chtls_hw.c 		pr_err("GCM: Invalid key length %d\n", keylen);
keylen            232 drivers/crypto/chelsio/chtls/chtls_hw.c 	memcpy(key, gcm_ctx->key, keylen);
keylen            237 drivers/crypto/chelsio/chtls/chtls_hw.c 	ret = aes_expandkey(&aes, key, keylen);
keylen            244 drivers/crypto/chelsio/chtls/chtls_hw.c 	csk->tlshws.keylen = key_ctx_size;
keylen            262 drivers/crypto/chelsio/chtls/chtls_hw.c 	memcpy(kctx->key, gcm_ctx->key, keylen);
keylen            263 drivers/crypto/chelsio/chtls/chtls_hw.c 	memcpy(kctx->key + keylen, ghash_h, AEAD_H_SIZE);
keylen            265 drivers/crypto/chelsio/chtls/chtls_hw.c 	memset(gcm_ctx->key, 0, keylen);
keylen            291 drivers/crypto/chelsio/chtls/chtls_hw.c int chtls_setkey(struct chtls_sock *csk, u32 keylen, u32 optname)
keylen            306 drivers/crypto/chelsio/chtls/chtls_hw.c 	klen = roundup((keylen + AEAD_H_SIZE) + sizeof(*kctx), 32);
keylen            356 drivers/crypto/chelsio/chtls/chtls_hw.c 	ret = chtls_key_info(csk, kctx, keylen, optname);
keylen            300 drivers/crypto/chelsio/chtls/chtls_io.c 				ULPTX_LEN16_V(hws->keylen >> 4));
keylen            407 drivers/crypto/chelsio/chtls/chtls_io.c 			      FW_TLSTX_DATA_WR_KEYSIZE_V(hws->keylen >> 4));
keylen            488 drivers/crypto/chelsio/chtls/chtls_main.c 	int keylen;
keylen            527 drivers/crypto/chelsio/chtls/chtls_main.c 		keylen = TLS_CIPHER_AES_GCM_128_KEY_SIZE;
keylen            528 drivers/crypto/chelsio/chtls/chtls_main.c 		rc = chtls_setkey(csk, keylen, optname);
keylen            115 drivers/crypto/geode-aes.c 	tctx->keylen = len;
keylen            150 drivers/crypto/geode-aes.c 	tctx->keylen = len;
keylen            183 drivers/crypto/geode-aes.c 	if (unlikely(tctx->keylen != AES_KEYSIZE_128)) {
keylen            198 drivers/crypto/geode-aes.c 	if (unlikely(tctx->keylen != AES_KEYSIZE_128)) {
keylen            286 drivers/crypto/geode-aes.c 	if (unlikely(tctx->keylen != AES_KEYSIZE_128)) {
keylen             55 drivers/crypto/geode-aes.h 	u32 keylen;
keylen           1072 drivers/crypto/hifn_795x.c 		u8 *key, int keylen, u8 *iv, int ivsize, u16 mode)
keylen           1097 drivers/crypto/hifn_795x.c 	if (keylen) {
keylen           1098 drivers/crypto/hifn_795x.c 		memcpy(buf_pos, key, keylen);
keylen           1099 drivers/crypto/hifn_795x.c 		buf_pos += keylen;
keylen            144 drivers/crypto/hisilicon/sec/sec_algs.c 					  unsigned int keylen,
keylen            151 drivers/crypto/hisilicon/sec/sec_algs.c 	memcpy(ctx->key, key, keylen);
keylen            227 drivers/crypto/hisilicon/sec/sec_algs.c 				   const u8 *key, unsigned int keylen,
keylen            247 drivers/crypto/hisilicon/sec/sec_algs.c 	sec_alg_skcipher_init_context(tfm, key, keylen, alg);
keylen            253 drivers/crypto/hisilicon/sec/sec_algs.c 					   const u8 *key, unsigned int keylen)
keylen            257 drivers/crypto/hisilicon/sec/sec_algs.c 	switch (keylen) {
keylen            271 drivers/crypto/hisilicon/sec/sec_algs.c 	return sec_alg_skcipher_setkey(tfm, key, keylen, alg);
keylen            275 drivers/crypto/hisilicon/sec/sec_algs.c 					   const u8 *key, unsigned int keylen)
keylen            279 drivers/crypto/hisilicon/sec/sec_algs.c 	switch (keylen) {
keylen            293 drivers/crypto/hisilicon/sec/sec_algs.c 	return sec_alg_skcipher_setkey(tfm, key, keylen, alg);
keylen            297 drivers/crypto/hisilicon/sec/sec_algs.c 					   const u8 *key, unsigned int keylen)
keylen            301 drivers/crypto/hisilicon/sec/sec_algs.c 	switch (keylen) {
keylen            315 drivers/crypto/hisilicon/sec/sec_algs.c 	return sec_alg_skcipher_setkey(tfm, key, keylen, alg);
keylen            319 drivers/crypto/hisilicon/sec/sec_algs.c 					   const u8 *key, unsigned int keylen)
keylen            324 drivers/crypto/hisilicon/sec/sec_algs.c 	ret = xts_verify_key(tfm, key, keylen);
keylen            328 drivers/crypto/hisilicon/sec/sec_algs.c 	switch (keylen) {
keylen            339 drivers/crypto/hisilicon/sec/sec_algs.c 	return sec_alg_skcipher_setkey(tfm, key, keylen, alg);
keylen            343 drivers/crypto/hisilicon/sec/sec_algs.c 					   const u8 *key, unsigned int keylen)
keylen            346 drivers/crypto/hisilicon/sec/sec_algs.c 	       sec_alg_skcipher_setkey(tfm, key, keylen, SEC_C_DES_ECB_64);
keylen            350 drivers/crypto/hisilicon/sec/sec_algs.c 					   const u8 *key, unsigned int keylen)
keylen            353 drivers/crypto/hisilicon/sec/sec_algs.c 	       sec_alg_skcipher_setkey(tfm, key, keylen, SEC_C_DES_CBC_64);
keylen            357 drivers/crypto/hisilicon/sec/sec_algs.c 					    const u8 *key, unsigned int keylen)
keylen            360 drivers/crypto/hisilicon/sec/sec_algs.c 	       sec_alg_skcipher_setkey(tfm, key, keylen,
keylen            365 drivers/crypto/hisilicon/sec/sec_algs.c 					    const u8 *key, unsigned int keylen)
keylen            368 drivers/crypto/hisilicon/sec/sec_algs.c 	       sec_alg_skcipher_setkey(tfm, key, keylen,
keylen            817 drivers/crypto/inside-secure/safexcel.h int safexcel_hmac_setkey(const char *alg, const u8 *key, unsigned int keylen,
keylen           1284 drivers/crypto/inside-secure/safexcel_cipher.c 	unsigned int keylen;
keylen           1289 drivers/crypto/inside-secure/safexcel_cipher.c 	keylen = len - CTR_RFC3686_NONCE_SIZE;
keylen           1290 drivers/crypto/inside-secure/safexcel_cipher.c 	ret = aes_expandkey(&aes, key, keylen);
keylen           1297 drivers/crypto/inside-secure/safexcel_cipher.c 		for (i = 0; i < keylen / sizeof(u32); i++) {
keylen           1305 drivers/crypto/inside-secure/safexcel_cipher.c 	for (i = 0; i < keylen / sizeof(u32); i++)
keylen           1308 drivers/crypto/inside-secure/safexcel_cipher.c 	ctx->key_len = keylen;
keylen           1958 drivers/crypto/inside-secure/safexcel_cipher.c 	unsigned int keylen;
keylen           1966 drivers/crypto/inside-secure/safexcel_cipher.c 	keylen = (len >> 1);
keylen           1967 drivers/crypto/inside-secure/safexcel_cipher.c 	ret = aes_expandkey(&aes, key, keylen);
keylen           1974 drivers/crypto/inside-secure/safexcel_cipher.c 		for (i = 0; i < keylen / sizeof(u32); i++) {
keylen           1982 drivers/crypto/inside-secure/safexcel_cipher.c 	for (i = 0; i < keylen / sizeof(u32); i++)
keylen           1986 drivers/crypto/inside-secure/safexcel_cipher.c 	ret = aes_expandkey(&aes, (u8 *)(key + keylen), keylen);
keylen           1993 drivers/crypto/inside-secure/safexcel_cipher.c 		for (i = 0; i < keylen / sizeof(u32); i++) {
keylen           1994 drivers/crypto/inside-secure/safexcel_cipher.c 			if (ctx->key[i + keylen / sizeof(u32)] !=
keylen           2002 drivers/crypto/inside-secure/safexcel_cipher.c 	for (i = 0; i < keylen / sizeof(u32); i++)
keylen           2003 drivers/crypto/inside-secure/safexcel_cipher.c 		ctx->key[i + keylen / sizeof(u32)] =
keylen           2006 drivers/crypto/inside-secure/safexcel_cipher.c 	ctx->key_len = keylen << 1;
keylen            926 drivers/crypto/inside-secure/safexcel_hash.c 				  unsigned int keylen, u8 *ipad, u8 *opad)
keylen            933 drivers/crypto/inside-secure/safexcel_hash.c 	if (keylen <= blocksize) {
keylen            934 drivers/crypto/inside-secure/safexcel_hash.c 		memcpy(ipad, key, keylen);
keylen            936 drivers/crypto/inside-secure/safexcel_hash.c 		keydup = kmemdup(key, keylen, GFP_KERNEL);
keylen            942 drivers/crypto/inside-secure/safexcel_hash.c 		sg_init_one(&sg, keydup, keylen);
keylen            943 drivers/crypto/inside-secure/safexcel_hash.c 		ahash_request_set_crypt(areq, &sg, ipad, keylen);
keylen            953 drivers/crypto/inside-secure/safexcel_hash.c 		memzero_explicit(keydup, keylen);
keylen            959 drivers/crypto/inside-secure/safexcel_hash.c 		keylen = crypto_ahash_digestsize(crypto_ahash_reqtfm(areq));
keylen            962 drivers/crypto/inside-secure/safexcel_hash.c 	memset(ipad + keylen, 0, blocksize - keylen);
keylen           1006 drivers/crypto/inside-secure/safexcel_hash.c int safexcel_hmac_setkey(const char *alg, const u8 *key, unsigned int keylen,
keylen           1036 drivers/crypto/inside-secure/safexcel_hash.c 	ret = safexcel_hmac_init_pad(areq, blocksize, key, keylen, ipad, opad);
keylen           1057 drivers/crypto/inside-secure/safexcel_hash.c 				    unsigned int keylen, const char *alg,
keylen           1065 drivers/crypto/inside-secure/safexcel_hash.c 	ret = safexcel_hmac_setkey(alg, key, keylen, &istate, &ostate);
keylen           1081 drivers/crypto/inside-secure/safexcel_hash.c 				     unsigned int keylen)
keylen           1083 drivers/crypto/inside-secure/safexcel_hash.c 	return safexcel_hmac_alg_setkey(tfm, key, keylen, "safexcel-sha1",
keylen           1229 drivers/crypto/inside-secure/safexcel_hash.c 				       unsigned int keylen)
keylen           1231 drivers/crypto/inside-secure/safexcel_hash.c 	return safexcel_hmac_alg_setkey(tfm, key, keylen, "safexcel-sha224",
keylen           1299 drivers/crypto/inside-secure/safexcel_hash.c 				     unsigned int keylen)
keylen           1301 drivers/crypto/inside-secure/safexcel_hash.c 	return safexcel_hmac_alg_setkey(tfm, key, keylen, "safexcel-sha256",
keylen           1479 drivers/crypto/inside-secure/safexcel_hash.c 				       unsigned int keylen)
keylen           1481 drivers/crypto/inside-secure/safexcel_hash.c 	return safexcel_hmac_alg_setkey(tfm, key, keylen, "safexcel-sha512",
keylen           1549 drivers/crypto/inside-secure/safexcel_hash.c 				       unsigned int keylen)
keylen           1551 drivers/crypto/inside-secure/safexcel_hash.c 	return safexcel_hmac_alg_setkey(tfm, key, keylen, "safexcel-sha384",
keylen           1697 drivers/crypto/inside-secure/safexcel_hash.c 				     unsigned int keylen)
keylen           1699 drivers/crypto/inside-secure/safexcel_hash.c 	return safexcel_hmac_alg_setkey(tfm, key, keylen, "safexcel-md5",
keylen           1144 drivers/crypto/ixp4xx_crypto.c 			unsigned int keylen)
keylen           1149 drivers/crypto/ixp4xx_crypto.c 	if (crypto_authenc_extractkeys(&keys, key, keylen) != 0)
keylen           1172 drivers/crypto/ixp4xx_crypto.c 			    unsigned int keylen)
keylen           1178 drivers/crypto/ixp4xx_crypto.c 	err = crypto_authenc_extractkeys(&keys, key, keylen);
keylen           1120 drivers/crypto/marvell/hash.c 				  const u8 *key, unsigned int keylen,
keylen           1129 drivers/crypto/marvell/hash.c 	if (keylen <= blocksize) {
keylen           1130 drivers/crypto/marvell/hash.c 		memcpy(ipad, key, keylen);
keylen           1132 drivers/crypto/marvell/hash.c 		u8 *keydup = kmemdup(key, keylen, GFP_KERNEL);
keylen           1140 drivers/crypto/marvell/hash.c 		sg_init_one(&sg, keydup, keylen);
keylen           1141 drivers/crypto/marvell/hash.c 		ahash_request_set_crypt(req, &sg, ipad, keylen);
keylen           1156 drivers/crypto/marvell/hash.c 		keylen = crypto_ahash_digestsize(crypto_ahash_reqtfm(req));
keylen           1159 drivers/crypto/marvell/hash.c 	memset(ipad + keylen, 0, blocksize - keylen);
keylen           1171 drivers/crypto/marvell/hash.c 				const u8 *key, unsigned int keylen,
keylen           1203 drivers/crypto/marvell/hash.c 	ret = mv_cesa_ahmac_pad_init(req, key, keylen, ipad, opad, blocksize);
keylen           1248 drivers/crypto/marvell/hash.c 				    unsigned int keylen)
keylen           1254 drivers/crypto/marvell/hash.c 	ret = mv_cesa_ahmac_setkey("mv-md5", key, keylen, &istate, &ostate);
keylen           1318 drivers/crypto/marvell/hash.c 				     unsigned int keylen)
keylen           1324 drivers/crypto/marvell/hash.c 	ret = mv_cesa_ahmac_setkey("mv-sha1", key, keylen, &istate, &ostate);
keylen           1375 drivers/crypto/marvell/hash.c 				       unsigned int keylen)
keylen           1381 drivers/crypto/marvell/hash.c 	ret = mv_cesa_ahmac_setkey("mv-sha256", key, keylen, &istate, &ostate);
keylen            107 drivers/crypto/mediatek/mtk-aes.c 	u32 keylen;
keylen            426 drivers/crypto/mediatek/mtk-aes.c 	info->tfm[0] = AES_TFM_SIZE(ctx->keylen) | ctx->keymode;
keylen            453 drivers/crypto/mediatek/mtk-aes.c 	mtk_aes_write_state_le(info->state + ctx->keylen, req->info,
keylen            605 drivers/crypto/mediatek/mtk-aes.c 	mtk_aes_write_state_le(ctx->info.state + ctx->keylen, cctx->iv,
keylen            638 drivers/crypto/mediatek/mtk-aes.c 			  const u8 *key, u32 keylen)
keylen            642 drivers/crypto/mediatek/mtk-aes.c 	switch (keylen) {
keylen            658 drivers/crypto/mediatek/mtk-aes.c 	ctx->keylen = SIZE_IN_WORDS(keylen);
keylen            659 drivers/crypto/mediatek/mtk-aes.c 	mtk_aes_write_state_le(ctx->key, (const u32 *)key, keylen);
keylen            906 drivers/crypto/mediatek/mtk-aes.c 			ctx->keylen + SIZE_IN_WORDS(AES_BLOCK_SIZE + ivsize)) |
keylen            911 drivers/crypto/mediatek/mtk-aes.c 	mtk_aes_write_state_le(info->state + ctx->keylen + SIZE_IN_WORDS(
keylen           1013 drivers/crypto/mediatek/mtk-aes.c 			      u32 keylen)
keylen           1029 drivers/crypto/mediatek/mtk-aes.c 	switch (keylen) {
keylen           1045 drivers/crypto/mediatek/mtk-aes.c 	ctx->keylen = SIZE_IN_WORDS(keylen);
keylen           1051 drivers/crypto/mediatek/mtk-aes.c 	err = crypto_skcipher_setkey(ctr, key, keylen);
keylen           1076 drivers/crypto/mediatek/mtk-aes.c 	mtk_aes_write_state_le(ctx->key, (const u32 *)key, keylen);
keylen           1077 drivers/crypto/mediatek/mtk-aes.c 	mtk_aes_write_state_be(ctx->key + ctx->keylen, data->hash,
keylen            800 drivers/crypto/mediatek/mtk-sha.c 			  u32 keylen)
keylen            812 drivers/crypto/mediatek/mtk-sha.c 	if (keylen > bs) {
keylen            813 drivers/crypto/mediatek/mtk-sha.c 		err = crypto_shash_digest(shash, key, keylen, bctx->ipad);
keylen            816 drivers/crypto/mediatek/mtk-sha.c 		keylen = ds;
keylen            818 drivers/crypto/mediatek/mtk-sha.c 		memcpy(bctx->ipad, key, keylen);
keylen            821 drivers/crypto/mediatek/mtk-sha.c 	memset(bctx->ipad + keylen, 0, bs - keylen);
keylen            459 drivers/crypto/n2_core.c 				unsigned int keylen)
keylen            468 drivers/crypto/n2_core.c 	err = crypto_ahash_setkey(fallback_tfm, key, keylen);
keylen            477 drivers/crypto/n2_core.c 	if (keylen > bs) {
keylen            478 drivers/crypto/n2_core.c 		err = crypto_shash_digest(shash, key, keylen,
keylen            482 drivers/crypto/n2_core.c 		keylen = ds;
keylen            483 drivers/crypto/n2_core.c 	} else if (keylen <= N2_HASH_KEY_MAX)
keylen            484 drivers/crypto/n2_core.c 		memcpy(ctx->hash_key, key, keylen);
keylen            486 drivers/crypto/n2_core.c 	ctx->hash_key_len = keylen;
keylen            729 drivers/crypto/n2_core.c 			 unsigned int keylen)
keylen            737 drivers/crypto/n2_core.c 	switch (keylen) {
keylen            752 drivers/crypto/n2_core.c 	ctx->key_len = keylen;
keylen            753 drivers/crypto/n2_core.c 	memcpy(ctx->key.aes, key, keylen);
keylen            758 drivers/crypto/n2_core.c 			 unsigned int keylen)
keylen            771 drivers/crypto/n2_core.c 	ctx->key_len = keylen;
keylen            772 drivers/crypto/n2_core.c 	memcpy(ctx->key.des, key, keylen);
keylen            777 drivers/crypto/n2_core.c 			  unsigned int keylen)
keylen            790 drivers/crypto/n2_core.c 	ctx->key_len = keylen;
keylen            791 drivers/crypto/n2_core.c 	memcpy(ctx->key.des3, key, keylen);
keylen            796 drivers/crypto/n2_core.c 			  unsigned int keylen)
keylen            818 drivers/crypto/n2_core.c 		if (++k >= keylen)
keylen            195 drivers/crypto/omap-aes-gcm.c 	ret = crypto_skcipher_setkey(ctx->ctr, (u8 *)ctx->key, ctx->keylen);
keylen            373 drivers/crypto/omap-aes-gcm.c 			unsigned int keylen)
keylen            377 drivers/crypto/omap-aes-gcm.c 	if (keylen != AES_KEYSIZE_128 && keylen != AES_KEYSIZE_192 &&
keylen            378 drivers/crypto/omap-aes-gcm.c 	    keylen != AES_KEYSIZE_256)
keylen            381 drivers/crypto/omap-aes-gcm.c 	memcpy(ctx->key, key, keylen);
keylen            382 drivers/crypto/omap-aes-gcm.c 	ctx->keylen = keylen;
keylen            388 drivers/crypto/omap-aes-gcm.c 			    unsigned int keylen)
keylen            392 drivers/crypto/omap-aes-gcm.c 	if (keylen < 4)
keylen            395 drivers/crypto/omap-aes-gcm.c 	keylen -= 4;
keylen            396 drivers/crypto/omap-aes-gcm.c 	if (keylen != AES_KEYSIZE_128 && keylen != AES_KEYSIZE_192 &&
keylen            397 drivers/crypto/omap-aes-gcm.c 	    keylen != AES_KEYSIZE_256)
keylen            400 drivers/crypto/omap-aes-gcm.c 	memcpy(ctx->key, key, keylen);
keylen            401 drivers/crypto/omap-aes-gcm.c 	memcpy(ctx->nonce, key + keylen, 4);
keylen            402 drivers/crypto/omap-aes-gcm.c 	ctx->keylen = keylen;
keylen            133 drivers/crypto/omap-aes.c 	key32 = dd->ctx->keylen / sizeof(u32);
keylen            153 drivers/crypto/omap-aes.c 	val = FLD_VAL(((dd->ctx->keylen >> 3) - 1), 4, 3);
keylen            549 drivers/crypto/omap-aes.c 			   unsigned int keylen)
keylen            554 drivers/crypto/omap-aes.c 	if (keylen != AES_KEYSIZE_128 && keylen != AES_KEYSIZE_192 &&
keylen            555 drivers/crypto/omap-aes.c 		   keylen != AES_KEYSIZE_256)
keylen            558 drivers/crypto/omap-aes.c 	pr_debug("enter, keylen: %d\n", keylen);
keylen            560 drivers/crypto/omap-aes.c 	memcpy(ctx->key, key, keylen);
keylen            561 drivers/crypto/omap-aes.c 	ctx->keylen = keylen;
keylen            567 drivers/crypto/omap-aes.c 	ret = crypto_sync_skcipher_setkey(ctx->fallback, key, keylen);
keylen             97 drivers/crypto/omap-aes.h 	int		keylen;
keylen            200 drivers/crypto/omap-aes.h 			unsigned int keylen);
keylen            202 drivers/crypto/omap-aes.h 			    unsigned int keylen);
keylen             88 drivers/crypto/omap-des.c 	int		keylen;
keylen            256 drivers/crypto/omap-des.c 	key32 = dd->ctx->keylen / sizeof(u32);
keylen            650 drivers/crypto/omap-des.c 			   unsigned int keylen)
keylen            655 drivers/crypto/omap-des.c 	pr_debug("enter, keylen: %d\n", keylen);
keylen            661 drivers/crypto/omap-des.c 	memcpy(ctx->key, key, keylen);
keylen            662 drivers/crypto/omap-des.c 	ctx->keylen = keylen;
keylen            668 drivers/crypto/omap-des.c 			    unsigned int keylen)
keylen            673 drivers/crypto/omap-des.c 	pr_debug("enter, keylen: %d\n", keylen);
keylen            679 drivers/crypto/omap-des.c 	memcpy(ctx->key, key, keylen);
keylen            680 drivers/crypto/omap-des.c 	ctx->keylen = keylen;
keylen           1299 drivers/crypto/omap-sham.c 		      unsigned int keylen)
keylen           1320 drivers/crypto/omap-sham.c 	err = crypto_shash_setkey(tctx->fallback, key, keylen);
keylen           1324 drivers/crypto/omap-sham.c 	if (keylen > bs) {
keylen           1327 drivers/crypto/omap-sham.c 				key, keylen, bctx->ipad);
keylen           1330 drivers/crypto/omap-sham.c 		keylen = ds;
keylen           1332 drivers/crypto/omap-sham.c 		memcpy(bctx->ipad, key, keylen);
keylen           1335 drivers/crypto/omap-sham.c 	memset(bctx->ipad + keylen, 0, bs - keylen);
keylen            458 drivers/crypto/picoxcell_crypto.c 			     unsigned int keylen)
keylen            467 drivers/crypto/picoxcell_crypto.c 	err = crypto_aead_setkey(ctx->sw_cipher, key, keylen);
keylen            474 drivers/crypto/picoxcell_crypto.c 	if (crypto_authenc_extractkeys(&keys, key, keylen) != 0)
keylen            469 drivers/crypto/qat/qat_common/qat_algs.c 					const uint8_t *key, unsigned int keylen)
keylen            475 drivers/crypto/qat/qat_common/qat_algs.c 	memcpy(cd->aes.key, key, keylen);
keylen            481 drivers/crypto/qat/qat_common/qat_algs.c 	cd_ctrl->cipher_key_sz = keylen >> 3;
keylen            490 drivers/crypto/qat/qat_common/qat_algs.c 					unsigned int keylen, int mode)
keylen            496 drivers/crypto/qat/qat_common/qat_algs.c 	qat_alg_ablkcipher_init_com(ctx, req, enc_cd, key, keylen);
keylen            503 drivers/crypto/qat/qat_common/qat_algs.c 					unsigned int keylen, int mode)
keylen            509 drivers/crypto/qat/qat_common/qat_algs.c 	qat_alg_ablkcipher_init_com(ctx, req, dec_cd, key, keylen);
keylen            552 drivers/crypto/qat/qat_common/qat_algs.c 				      unsigned int keylen,  int mode)
keylen            557 drivers/crypto/qat/qat_common/qat_algs.c 	if (crypto_authenc_extractkeys(&keys, key, keylen))
keylen            582 drivers/crypto/qat/qat_common/qat_algs.c 					    unsigned int keylen,
keylen            587 drivers/crypto/qat/qat_common/qat_algs.c 	if (qat_alg_validate_key(keylen, &alg, mode))
keylen            590 drivers/crypto/qat/qat_common/qat_algs.c 	qat_alg_ablkcipher_init_enc(ctx, alg, key, keylen, mode);
keylen            591 drivers/crypto/qat/qat_common/qat_algs.c 	qat_alg_ablkcipher_init_dec(ctx, alg, key, keylen, mode);
keylen            599 drivers/crypto/qat/qat_common/qat_algs.c 			      unsigned int keylen)
keylen            608 drivers/crypto/qat/qat_common/qat_algs.c 	return qat_alg_aead_init_sessions(tfm, key, keylen,
keylen            613 drivers/crypto/qat/qat_common/qat_algs.c 			       unsigned int keylen)
keylen            641 drivers/crypto/qat/qat_common/qat_algs.c 	ret = qat_alg_aead_init_sessions(tfm, key, keylen,
keylen            665 drivers/crypto/qat/qat_common/qat_algs.c 			       unsigned int keylen)
keylen            670 drivers/crypto/qat/qat_common/qat_algs.c 		return qat_alg_aead_rekey(tfm, key, keylen);
keylen            672 drivers/crypto/qat/qat_common/qat_algs.c 		return qat_alg_aead_newkey(tfm, key, keylen);
keylen            953 drivers/crypto/qat/qat_common/qat_algs.c 				    const u8 *key, unsigned int keylen,
keylen            961 drivers/crypto/qat/qat_common/qat_algs.c 	return qat_alg_ablkcipher_init_sessions(ctx, key, keylen, mode);
keylen            965 drivers/crypto/qat/qat_common/qat_algs.c 				     const u8 *key, unsigned int keylen,
keylen            993 drivers/crypto/qat/qat_common/qat_algs.c 	ret = qat_alg_ablkcipher_init_sessions(ctx, key, keylen, mode);
keylen           1016 drivers/crypto/qat/qat_common/qat_algs.c 				     const u8 *key, unsigned int keylen,
keylen           1022 drivers/crypto/qat/qat_common/qat_algs.c 		return qat_alg_ablkcipher_rekey(ctx, key, keylen, mode);
keylen           1024 drivers/crypto/qat/qat_common/qat_algs.c 		return qat_alg_ablkcipher_newkey(ctx, key, keylen, mode);
keylen           1028 drivers/crypto/qat/qat_common/qat_algs.c 					 const u8 *key, unsigned int keylen)
keylen           1030 drivers/crypto/qat/qat_common/qat_algs.c 	return qat_alg_ablkcipher_setkey(tfm, key, keylen,
keylen           1035 drivers/crypto/qat/qat_common/qat_algs.c 					 const u8 *key, unsigned int keylen)
keylen           1037 drivers/crypto/qat/qat_common/qat_algs.c 	return qat_alg_ablkcipher_setkey(tfm, key, keylen,
keylen           1042 drivers/crypto/qat/qat_common/qat_algs.c 					 const u8 *key, unsigned int keylen)
keylen           1044 drivers/crypto/qat/qat_common/qat_algs.c 	return qat_alg_ablkcipher_setkey(tfm, key, keylen,
keylen           1202 drivers/crypto/qat/qat_common/qat_asym_algs.c 			  unsigned int keylen, bool private)
keylen           1212 drivers/crypto/qat/qat_common/qat_asym_algs.c 		ret = rsa_parse_priv_key(&rsa_key, key, keylen);
keylen           1214 drivers/crypto/qat/qat_common/qat_asym_algs.c 		ret = rsa_parse_pub_key(&rsa_key, key, keylen);
keylen           1249 drivers/crypto/qat/qat_common/qat_asym_algs.c 			     unsigned int keylen)
keylen           1251 drivers/crypto/qat/qat_common/qat_asym_algs.c 	return qat_rsa_setkey(tfm, key, keylen, false);
keylen           1255 drivers/crypto/qat/qat_common/qat_asym_algs.c 			      unsigned int keylen)
keylen           1257 drivers/crypto/qat/qat_common/qat_asym_algs.c 	return qat_rsa_setkey(tfm, key, keylen, true);
keylen            153 drivers/crypto/qce/ablkcipher.c 				 unsigned int keylen)
keylen            159 drivers/crypto/qce/ablkcipher.c 	if (!key || !keylen)
keylen            162 drivers/crypto/qce/ablkcipher.c 	switch (keylen) {
keylen            170 drivers/crypto/qce/ablkcipher.c 	ctx->enc_keylen = keylen;
keylen            171 drivers/crypto/qce/ablkcipher.c 	memcpy(ctx->enc_key, key, keylen);
keylen            174 drivers/crypto/qce/ablkcipher.c 	ret = crypto_sync_skcipher_setkey(ctx->fallback, key, keylen);
keylen            176 drivers/crypto/qce/ablkcipher.c 		ctx->enc_keylen = keylen;
keylen            181 drivers/crypto/qce/ablkcipher.c 			  unsigned int keylen)
keylen            190 drivers/crypto/qce/ablkcipher.c 	ctx->enc_keylen = keylen;
keylen            191 drivers/crypto/qce/ablkcipher.c 	memcpy(ctx->enc_key, key, keylen);
keylen            196 drivers/crypto/qce/ablkcipher.c 			   unsigned int keylen)
keylen            205 drivers/crypto/qce/ablkcipher.c 	ctx->enc_keylen = keylen;
keylen            206 drivers/crypto/qce/ablkcipher.c 	memcpy(ctx->enc_key, key, keylen);
keylen            318 drivers/crypto/qce/common.c 	unsigned int keylen;
keylen            326 drivers/crypto/qce/common.c 		keylen = ctx->enc_keylen / 2;
keylen            328 drivers/crypto/qce/common.c 		keylen = ctx->enc_keylen;
keylen            330 drivers/crypto/qce/common.c 	qce_cpu_to_be32p_array(enckey, ctx->enc_key, keylen);
keylen            331 drivers/crypto/qce/common.c 	enckey_words = keylen / sizeof(u32);
keylen            335 drivers/crypto/qce/common.c 	encr_cfg = qce_encr_cfg(flags, keylen);
keylen            345 drivers/crypto/qce/sha.c 				 unsigned int keylen)
keylen            361 drivers/crypto/qce/sha.c 	if (keylen <= blocksize) {
keylen            362 drivers/crypto/qce/sha.c 		memcpy(ctx->authkey, key, keylen);
keylen            388 drivers/crypto/qce/sha.c 	buf = kzalloc(keylen + QCE_MAX_ALIGN_SIZE, GFP_KERNEL);
keylen            394 drivers/crypto/qce/sha.c 	memcpy(buf, key, keylen);
keylen            395 drivers/crypto/qce/sha.c 	sg_init_one(&sg, buf, keylen);
keylen            396 drivers/crypto/qce/sha.c 	ahash_request_set_crypt(req, &sg, ctx->authkey, keylen);
keylen            246 drivers/crypto/rockchip/rk3288_crypto.h 	unsigned int			keylen;
keylen             31 drivers/crypto/rockchip/rk3288_crypto_ablkcipher.c 			 const u8 *key, unsigned int keylen)
keylen             36 drivers/crypto/rockchip/rk3288_crypto_ablkcipher.c 	if (keylen != AES_KEYSIZE_128 && keylen != AES_KEYSIZE_192 &&
keylen             37 drivers/crypto/rockchip/rk3288_crypto_ablkcipher.c 	    keylen != AES_KEYSIZE_256) {
keylen             41 drivers/crypto/rockchip/rk3288_crypto_ablkcipher.c 	ctx->keylen = keylen;
keylen             42 drivers/crypto/rockchip/rk3288_crypto_ablkcipher.c 	memcpy_toio(ctx->dev->reg + RK_CRYPTO_AES_KEY_0, key, keylen);
keylen             47 drivers/crypto/rockchip/rk3288_crypto_ablkcipher.c 			 const u8 *key, unsigned int keylen)
keylen             56 drivers/crypto/rockchip/rk3288_crypto_ablkcipher.c 	ctx->keylen = keylen;
keylen             57 drivers/crypto/rockchip/rk3288_crypto_ablkcipher.c 	memcpy_toio(ctx->dev->reg + RK_CRYPTO_TDES_KEY1_0, key, keylen);
keylen             62 drivers/crypto/rockchip/rk3288_crypto_ablkcipher.c 			  const u8 *key, unsigned int keylen)
keylen             71 drivers/crypto/rockchip/rk3288_crypto_ablkcipher.c 	ctx->keylen = keylen;
keylen             72 drivers/crypto/rockchip/rk3288_crypto_ablkcipher.c 	memcpy_toio(ctx->dev->reg + RK_CRYPTO_TDES_KEY1_0, key, keylen);
keylen            221 drivers/crypto/rockchip/rk3288_crypto_ablkcipher.c 		if (ctx->keylen == AES_KEYSIZE_192)
keylen            223 drivers/crypto/rockchip/rk3288_crypto_ablkcipher.c 		else if (ctx->keylen == AES_KEYSIZE_256)
keylen            256 drivers/crypto/s5p-sss.c 	int				keylen;
keylen           1839 drivers/crypto/s5p-sss.c 			unsigned int keylen)
keylen           1851 drivers/crypto/s5p-sss.c 	if (keylen == AES_KEYSIZE_256)
keylen           1853 drivers/crypto/s5p-sss.c 	else if (keylen == AES_KEYSIZE_192)
keylen           1858 drivers/crypto/s5p-sss.c 	memcpy_toio(keystart, key, keylen);
keylen           1952 drivers/crypto/s5p-sss.c 	if (dev->ctx->keylen == AES_KEYSIZE_192)
keylen           1954 drivers/crypto/s5p-sss.c 	else if (dev->ctx->keylen == AES_KEYSIZE_256)
keylen           1981 drivers/crypto/s5p-sss.c 	s5p_set_aes(dev, dev->ctx->aes_key, iv, ctr, dev->ctx->keylen);
keylen           2074 drivers/crypto/s5p-sss.c 			  const u8 *key, unsigned int keylen)
keylen           2079 drivers/crypto/s5p-sss.c 	if (keylen != AES_KEYSIZE_128 &&
keylen           2080 drivers/crypto/s5p-sss.c 	    keylen != AES_KEYSIZE_192 &&
keylen           2081 drivers/crypto/s5p-sss.c 	    keylen != AES_KEYSIZE_256)
keylen           2084 drivers/crypto/s5p-sss.c 	memcpy(ctx->aes_key, key, keylen);
keylen           2085 drivers/crypto/s5p-sss.c 	ctx->keylen = keylen;
keylen            147 drivers/crypto/sahara.c 	int keylen;
keylen            451 drivers/crypto/sahara.c 		memcpy(dev->key_base, ctx->key, ctx->keylen);
keylen            461 drivers/crypto/sahara.c 		dev->hw_desc[idx]->len2 = ctx->keylen;
keylen            601 drivers/crypto/sahara.c 			     unsigned int keylen)
keylen            606 drivers/crypto/sahara.c 	ctx->keylen = keylen;
keylen            609 drivers/crypto/sahara.c 	if (keylen == AES_KEYSIZE_128) {
keylen            610 drivers/crypto/sahara.c 		memcpy(ctx->key, key, keylen);
keylen            615 drivers/crypto/sahara.c 	if (keylen != AES_KEYSIZE_192 && keylen != AES_KEYSIZE_256)
keylen            625 drivers/crypto/sahara.c 	ret = crypto_sync_skcipher_setkey(ctx->fallback, key, keylen);
keylen            665 drivers/crypto/sahara.c 	if (unlikely(ctx->keylen != AES_KEYSIZE_128)) {
keylen            687 drivers/crypto/sahara.c 	if (unlikely(ctx->keylen != AES_KEYSIZE_128)) {
keylen            709 drivers/crypto/sahara.c 	if (unlikely(ctx->keylen != AES_KEYSIZE_128)) {
keylen            731 drivers/crypto/sahara.c 	if (unlikely(ctx->keylen != AES_KEYSIZE_128)) {
keylen             84 drivers/crypto/stm32/stm32-crc32.c 			    unsigned int keylen)
keylen             88 drivers/crypto/stm32/stm32-crc32.c 	if (keylen != sizeof(u32)) {
keylen            119 drivers/crypto/stm32/stm32-cryp.c 	int                     keylen;
keylen            423 drivers/crypto/stm32/stm32-cryp.c 		for (i = c->ctx->keylen / sizeof(u32); i > 0; i--, r_id -= 4)
keylen            551 drivers/crypto/stm32/stm32-cryp.c 	switch (cryp->ctx->keylen) {
keylen            673 drivers/crypto/stm32/stm32-cryp.c 	memset(cryp->ctx->key, 0, cryp->ctx->keylen);
keylen            747 drivers/crypto/stm32/stm32-cryp.c 			     unsigned int keylen)
keylen            751 drivers/crypto/stm32/stm32-cryp.c 	memcpy(ctx->key, key, keylen);
keylen            752 drivers/crypto/stm32/stm32-cryp.c 	ctx->keylen = keylen;
keylen            758 drivers/crypto/stm32/stm32-cryp.c 				 unsigned int keylen)
keylen            760 drivers/crypto/stm32/stm32-cryp.c 	if (keylen != AES_KEYSIZE_128 && keylen != AES_KEYSIZE_192 &&
keylen            761 drivers/crypto/stm32/stm32-cryp.c 	    keylen != AES_KEYSIZE_256)
keylen            764 drivers/crypto/stm32/stm32-cryp.c 		return stm32_cryp_setkey(tfm, key, keylen);
keylen            768 drivers/crypto/stm32/stm32-cryp.c 				 unsigned int keylen)
keylen            771 drivers/crypto/stm32/stm32-cryp.c 	       stm32_cryp_setkey(tfm, key, keylen);
keylen            775 drivers/crypto/stm32/stm32-cryp.c 				  unsigned int keylen)
keylen            778 drivers/crypto/stm32/stm32-cryp.c 	       stm32_cryp_setkey(tfm, key, keylen);
keylen            782 drivers/crypto/stm32/stm32-cryp.c 				      unsigned int keylen)
keylen            786 drivers/crypto/stm32/stm32-cryp.c 	if (keylen != AES_KEYSIZE_128 && keylen != AES_KEYSIZE_192 &&
keylen            787 drivers/crypto/stm32/stm32-cryp.c 	    keylen != AES_KEYSIZE_256)
keylen            790 drivers/crypto/stm32/stm32-cryp.c 	memcpy(ctx->key, key, keylen);
keylen            791 drivers/crypto/stm32/stm32-cryp.c 	ctx->keylen = keylen;
keylen            119 drivers/crypto/stm32/stm32-hash.c 	int			keylen;
keylen            228 drivers/crypto/stm32/stm32-hash.c 	int keylen = ctx->keylen;
keylen            231 drivers/crypto/stm32/stm32-hash.c 	if (keylen) {
keylen            232 drivers/crypto/stm32/stm32-hash.c 		stm32_hash_set_nblw(hdev, keylen);
keylen            234 drivers/crypto/stm32/stm32-hash.c 		while (keylen > 0) {
keylen            236 drivers/crypto/stm32/stm32-hash.c 			keylen -= 4;
keylen            281 drivers/crypto/stm32/stm32-hash.c 			if (ctx->keylen > HASH_LONG_KEY)
keylen            483 drivers/crypto/stm32/stm32-hash.c 	if (ctx->keylen < HASH_DMA_THRESHOLD || (hdev->dma_mode == 1)) {
keylen            490 drivers/crypto/stm32/stm32-hash.c 				    ALIGN(ctx->keylen, sizeof(u32)));
keylen            499 drivers/crypto/stm32/stm32-hash.c 		err = stm32_hash_xmit_dma(hdev, &rctx->sg_key, ctx->keylen, 0);
keylen           1020 drivers/crypto/stm32/stm32-hash.c 			     const u8 *key, unsigned int keylen)
keylen           1024 drivers/crypto/stm32/stm32-hash.c 	if (keylen <= HASH_MAX_KEY_SIZE) {
keylen           1025 drivers/crypto/stm32/stm32-hash.c 		memcpy(ctx->key, key, keylen);
keylen           1026 drivers/crypto/stm32/stm32-hash.c 		ctx->keylen = keylen;
keylen           1042 drivers/crypto/stm32/stm32-hash.c 	ctx->keylen = 0;
keylen             47 drivers/crypto/sunxi-ss/sun4i-ss-cipher.c 	for (i = 0; i < op->keylen; i += 4)
keylen            209 drivers/crypto/sunxi-ss/sun4i-ss-cipher.c 	for (i = 0; i < op->keylen; i += 4)
keylen            517 drivers/crypto/sunxi-ss/sun4i-ss-cipher.c 			unsigned int keylen)
keylen            522 drivers/crypto/sunxi-ss/sun4i-ss-cipher.c 	switch (keylen) {
keylen            533 drivers/crypto/sunxi-ss/sun4i-ss-cipher.c 		dev_err(ss->dev, "ERROR: Invalid keylen %u\n", keylen);
keylen            537 drivers/crypto/sunxi-ss/sun4i-ss-cipher.c 	op->keylen = keylen;
keylen            538 drivers/crypto/sunxi-ss/sun4i-ss-cipher.c 	memcpy(op->key, key, keylen);
keylen            543 drivers/crypto/sunxi-ss/sun4i-ss-cipher.c 	return crypto_sync_skcipher_setkey(op->fallback_tfm, key, keylen);
keylen            548 drivers/crypto/sunxi-ss/sun4i-ss-cipher.c 			unsigned int keylen)
keylen            557 drivers/crypto/sunxi-ss/sun4i-ss-cipher.c 	op->keylen = keylen;
keylen            558 drivers/crypto/sunxi-ss/sun4i-ss-cipher.c 	memcpy(op->key, key, keylen);
keylen            563 drivers/crypto/sunxi-ss/sun4i-ss-cipher.c 	return crypto_sync_skcipher_setkey(op->fallback_tfm, key, keylen);
keylen            568 drivers/crypto/sunxi-ss/sun4i-ss-cipher.c 			 unsigned int keylen)
keylen            577 drivers/crypto/sunxi-ss/sun4i-ss-cipher.c 	op->keylen = keylen;
keylen            578 drivers/crypto/sunxi-ss/sun4i-ss-cipher.c 	memcpy(op->key, key, keylen);
keylen            583 drivers/crypto/sunxi-ss/sun4i-ss-cipher.c 	return crypto_sync_skcipher_setkey(op->fallback_tfm, key, keylen);
keylen            160 drivers/crypto/sunxi-ss/sun4i-ss.h 	u32 keylen;
keylen            208 drivers/crypto/sunxi-ss/sun4i-ss.h 			unsigned int keylen);
keylen            210 drivers/crypto/sunxi-ss/sun4i-ss.h 			unsigned int keylen);
keylen            212 drivers/crypto/sunxi-ss/sun4i-ss.h 			 unsigned int keylen);
keylen            856 drivers/crypto/talitos.c 	unsigned int keylen;
keylen            889 drivers/crypto/talitos.c 		       const u8 *key, unsigned int keylen)
keylen            895 drivers/crypto/talitos.c 	if (crypto_authenc_extractkeys(&keys, key, keylen) != 0)
keylen            901 drivers/crypto/talitos.c 	if (ctx->keylen)
keylen            902 drivers/crypto/talitos.c 		dma_unmap_single(dev, ctx->dma_key, ctx->keylen, DMA_TO_DEVICE);
keylen            907 drivers/crypto/talitos.c 	ctx->keylen = keys.authkeylen + keys.enckeylen;
keylen            910 drivers/crypto/talitos.c 	ctx->dma_key = dma_map_single(dev, ctx->key, ctx->keylen,
keylen            923 drivers/crypto/talitos.c 			    const u8 *key, unsigned int keylen)
keylen            930 drivers/crypto/talitos.c 	err = crypto_authenc_extractkeys(&keys, key, keylen);
keylen            942 drivers/crypto/talitos.c 	if (ctx->keylen)
keylen            943 drivers/crypto/talitos.c 		dma_unmap_single(dev, ctx->dma_key, ctx->keylen, DMA_TO_DEVICE);
keylen            948 drivers/crypto/talitos.c 	ctx->keylen = keys.authkeylen + keys.enckeylen;
keylen            951 drivers/crypto/talitos.c 	ctx->dma_key = dma_map_single(dev, ctx->key, ctx->keylen,
keylen           1494 drivers/crypto/talitos.c 			     const u8 *key, unsigned int keylen)
keylen           1499 drivers/crypto/talitos.c 	if (ctx->keylen)
keylen           1500 drivers/crypto/talitos.c 		dma_unmap_single(dev, ctx->dma_key, ctx->keylen, DMA_TO_DEVICE);
keylen           1502 drivers/crypto/talitos.c 	memcpy(&ctx->key, key, keylen);
keylen           1503 drivers/crypto/talitos.c 	ctx->keylen = keylen;
keylen           1505 drivers/crypto/talitos.c 	ctx->dma_key = dma_map_single(dev, ctx->key, keylen, DMA_TO_DEVICE);
keylen           1511 drivers/crypto/talitos.c 				 const u8 *key, unsigned int keylen)
keylen           1514 drivers/crypto/talitos.c 	       ablkcipher_setkey(cipher, key, keylen);
keylen           1518 drivers/crypto/talitos.c 				  const u8 *key, unsigned int keylen)
keylen           1521 drivers/crypto/talitos.c 	       ablkcipher_setkey(cipher, key, keylen);
keylen           1525 drivers/crypto/talitos.c 				  const u8 *key, unsigned int keylen)
keylen           1527 drivers/crypto/talitos.c 	if (keylen == AES_KEYSIZE_128 || keylen == AES_KEYSIZE_192 ||
keylen           1528 drivers/crypto/talitos.c 	    keylen == AES_KEYSIZE_256)
keylen           1529 drivers/crypto/talitos.c 		return ablkcipher_setkey(cipher, key, keylen);
keylen           1593 drivers/crypto/talitos.c 	to_talitos_ptr(&desc->ptr[2], ctx->dma_key, ctx->keylen, is_sec1);
keylen           1815 drivers/crypto/talitos.c 	if (ctx->keylen)
keylen           1816 drivers/crypto/talitos.c 		to_talitos_ptr(&desc->ptr[2], ctx->dma_key, ctx->keylen,
keylen           2085 drivers/crypto/talitos.c 	if (ctx->keylen && (req_ctx->first || req_ctx->last))
keylen           2184 drivers/crypto/talitos.c static int keyhash(struct crypto_ahash *tfm, const u8 *key, unsigned int keylen,
keylen           2201 drivers/crypto/talitos.c 	ctx->keylen = 0;
keylen           2205 drivers/crypto/talitos.c 	sg_init_one(&sg[0], key, keylen);
keylen           2207 drivers/crypto/talitos.c 	ahash_request_set_crypt(req, sg, hash, keylen);
keylen           2216 drivers/crypto/talitos.c 			unsigned int keylen)
keylen           2223 drivers/crypto/talitos.c 	unsigned int keysize = keylen;
keylen           2227 drivers/crypto/talitos.c 	if (keylen <= blocksize)
keylen           2231 drivers/crypto/talitos.c 		ret = keyhash(tfm, key, keylen, hash);
keylen           2242 drivers/crypto/talitos.c 	if (ctx->keylen)
keylen           2243 drivers/crypto/talitos.c 		dma_unmap_single(dev, ctx->dma_key, ctx->keylen, DMA_TO_DEVICE);
keylen           2245 drivers/crypto/talitos.c 	ctx->keylen = keysize;
keylen           3070 drivers/crypto/talitos.c 	ctx->keylen = 0;
keylen           3082 drivers/crypto/talitos.c 	if (ctx->keylen)
keylen           3083 drivers/crypto/talitos.c 		dma_unmap_single(dev, ctx->dma_key, ctx->keylen, DMA_TO_DEVICE);
keylen             78 drivers/crypto/ux500/cryp/cryp_core.c 	u32 keylen;
keylen            339 drivers/crypto/ux500/cryp/cryp_core.c 	int num_of_regs = ctx->keylen / 8;
keylen            348 drivers/crypto/ux500/cryp/cryp_core.c 						   ctx->keylen);
keylen            350 drivers/crypto/ux500/cryp/cryp_core.c 		for (i = 0; i < ctx->keylen / 4; i++)
keylen            952 drivers/crypto/ux500/cryp/cryp_core.c 				 const u8 *key, unsigned int keylen)
keylen            959 drivers/crypto/ux500/cryp/cryp_core.c 	switch (keylen) {
keylen            978 drivers/crypto/ux500/cryp/cryp_core.c 	memcpy(ctx->key, key, keylen);
keylen            979 drivers/crypto/ux500/cryp/cryp_core.c 	ctx->keylen = keylen;
keylen            987 drivers/crypto/ux500/cryp/cryp_core.c 				 const u8 *key, unsigned int keylen)
keylen            998 drivers/crypto/ux500/cryp/cryp_core.c 	memcpy(ctx->key, key, keylen);
keylen            999 drivers/crypto/ux500/cryp/cryp_core.c 	ctx->keylen = keylen;
keylen           1006 drivers/crypto/ux500/cryp/cryp_core.c 				  const u8 *key, unsigned int keylen)
keylen           1017 drivers/crypto/ux500/cryp/cryp_core.c 	memcpy(ctx->key, key, keylen);
keylen           1018 drivers/crypto/ux500/cryp/cryp_core.c 	ctx->keylen = keylen;
keylen            330 drivers/crypto/ux500/hash/hash_alg.h 	u32			keylen;
keylen            247 drivers/crypto/ux500/hash/hash_core.c 		if (!ctx->keylen) {
keylen            427 drivers/crypto/ux500/hash/hash_core.c 			      const u8 *key, unsigned int keylen)
keylen            434 drivers/crypto/ux500/hash/hash_core.c 	while (keylen >= 4) {
keylen            438 drivers/crypto/ux500/hash/hash_core.c 		keylen -= 4;
keylen            443 drivers/crypto/ux500/hash/hash_core.c 	if (keylen) {
keylen            445 drivers/crypto/ux500/hash/hash_core.c 		while (keylen) {
keylen            446 drivers/crypto/ux500/hash/hash_core.c 			word |= (key[keylen - 1] << (8 * (keylen - 1)));
keylen            447 drivers/crypto/ux500/hash/hash_core.c 			keylen--;
keylen            485 drivers/crypto/ux500/hash/hash_core.c 		hash_hw_write_key(device_data, ctx->key, ctx->keylen);
keylen            556 drivers/crypto/ux500/hash/hash_core.c 		ctx->keylen = 0;
keylen            717 drivers/crypto/ux500/hash/hash_core.c 		if (device_data->current_ctx->keylen > HASH_BLOCK_SIZE) {
keylen            903 drivers/crypto/ux500/hash/hash_core.c 			hash_hw_write_key(device_data, ctx->key, ctx->keylen);
keylen            934 drivers/crypto/ux500/hash/hash_core.c 		unsigned int keylen = ctx->keylen;
keylen            938 drivers/crypto/ux500/hash/hash_core.c 			__func__, ctx->keylen);
keylen            939 drivers/crypto/ux500/hash/hash_core.c 		hash_hw_write_key(device_data, key, keylen);
keylen            984 drivers/crypto/ux500/hash/hash_core.c 	} else if (req->nbytes == 0 && ctx->keylen == 0) {
keylen           1011 drivers/crypto/ux500/hash/hash_core.c 	} else if (req->nbytes == 0 && ctx->keylen > 0) {
keylen           1036 drivers/crypto/ux500/hash/hash_core.c 		unsigned int keylen = ctx->keylen;
keylen           1040 drivers/crypto/ux500/hash/hash_core.c 			__func__, ctx->keylen);
keylen           1041 drivers/crypto/ux500/hash/hash_core.c 		hash_hw_write_key(device_data, key, keylen);
keylen           1334 drivers/crypto/ux500/hash/hash_core.c 		       const u8 *key, unsigned int keylen, int alg)
keylen           1342 drivers/crypto/ux500/hash/hash_core.c 	ctx->key = kmemdup(key, keylen, GFP_KERNEL);
keylen           1348 drivers/crypto/ux500/hash/hash_core.c 	ctx->keylen = keylen;
keylen           1476 drivers/crypto/ux500/hash/hash_core.c 			    const u8 *key, unsigned int keylen)
keylen           1478 drivers/crypto/ux500/hash/hash_core.c 	return hash_setkey(tfm, key, keylen, HASH_ALGO_SHA1);
keylen           1482 drivers/crypto/ux500/hash/hash_core.c 			      const u8 *key, unsigned int keylen)
keylen           1484 drivers/crypto/ux500/hash/hash_core.c 	return hash_setkey(tfm, key, keylen, HASH_ALGO_SHA256);
keylen            116 drivers/crypto/virtio/virtio_crypto_algs.c 		unsigned int keylen,
keylen            130 drivers/crypto/virtio/virtio_crypto_algs.c 	uint8_t *cipher_key = kmemdup(key, keylen, GFP_ATOMIC);
keylen            149 drivers/crypto/virtio/virtio_crypto_algs.c 	vcrypto->ctrl.u.sym_create_session.u.cipher.para.keylen =
keylen            150 drivers/crypto/virtio/virtio_crypto_algs.c 		cpu_to_le32(keylen);
keylen            158 drivers/crypto/virtio/virtio_crypto_algs.c 	sg_init_one(&key_sg, cipher_key, keylen);
keylen            266 drivers/crypto/virtio/virtio_crypto_algs.c 		const uint8_t *key, unsigned int keylen)
keylen            272 drivers/crypto/virtio/virtio_crypto_algs.c 	if (keylen > vcrypto->max_cipher_key_len) {
keylen            277 drivers/crypto/virtio/virtio_crypto_algs.c 	if (virtio_crypto_alg_validate_key(keylen, &alg))
keylen            282 drivers/crypto/virtio/virtio_crypto_algs.c 			alg, key, keylen, 1);
keylen            287 drivers/crypto/virtio/virtio_crypto_algs.c 			alg, key, keylen, 0);
keylen            302 drivers/crypto/virtio/virtio_crypto_algs.c 					 unsigned int keylen)
keylen            308 drivers/crypto/virtio/virtio_crypto_algs.c 	ret = virtio_crypto_alg_validate_key(keylen, &alg);
keylen            330 drivers/crypto/virtio/virtio_crypto_algs.c 	ret = virtio_crypto_alg_ablkcipher_init_sessions(ctx, key, keylen);
keylen             61 drivers/crypto/vmx/aes.c 			 unsigned int keylen)
keylen             69 drivers/crypto/vmx/aes.c 	ret = aes_p8_set_encrypt_key(key, keylen * 8, &ctx->enc_key);
keylen             70 drivers/crypto/vmx/aes.c 	ret |= aes_p8_set_decrypt_key(key, keylen * 8, &ctx->dec_key);
keylen             75 drivers/crypto/vmx/aes.c 	ret |= crypto_cipher_setkey(ctx->fallback, key, keylen);
keylen             52 drivers/crypto/vmx/aes_cbc.c 			     unsigned int keylen)
keylen             60 drivers/crypto/vmx/aes_cbc.c 	ret = aes_p8_set_encrypt_key(key, keylen * 8, &ctx->enc_key);
keylen             61 drivers/crypto/vmx/aes_cbc.c 	ret |= aes_p8_set_decrypt_key(key, keylen * 8, &ctx->dec_key);
keylen             66 drivers/crypto/vmx/aes_cbc.c 	ret |= crypto_skcipher_setkey(ctx->fallback, key, keylen);
keylen             51 drivers/crypto/vmx/aes_ctr.c 			     unsigned int keylen)
keylen             59 drivers/crypto/vmx/aes_ctr.c 	ret = aes_p8_set_encrypt_key(key, keylen * 8, &ctx->enc_key);
keylen             64 drivers/crypto/vmx/aes_ctr.c 	ret |= crypto_skcipher_setkey(ctx->fallback, key, keylen);
keylen             54 drivers/crypto/vmx/aes_xts.c 			     unsigned int keylen)
keylen             59 drivers/crypto/vmx/aes_xts.c 	ret = xts_verify_key(tfm, key, keylen);
keylen             66 drivers/crypto/vmx/aes_xts.c 	ret = aes_p8_set_encrypt_key(key + keylen/2, (keylen/2) * 8, &ctx->tweak_key);
keylen             67 drivers/crypto/vmx/aes_xts.c 	ret |= aes_p8_set_encrypt_key(key, (keylen/2) * 8, &ctx->enc_key);
keylen             68 drivers/crypto/vmx/aes_xts.c 	ret |= aes_p8_set_decrypt_key(key, (keylen/2) * 8, &ctx->dec_key);
keylen             73 drivers/crypto/vmx/aes_xts.c 	ret |= crypto_skcipher_setkey(ctx->fallback, key, keylen);
keylen             55 drivers/crypto/vmx/ghash.c 			   unsigned int keylen)
keylen             59 drivers/crypto/vmx/ghash.c 	if (keylen != GHASH_BLOCK_SIZE)
keylen            520 drivers/hv/hv_kvp.c 	int	keylen = 0;
keylen            596 drivers/hv/hv_kvp.c 	keylen = utf8s_to_utf16s(key_name, strlen(key_name), UTF16_HOST_ENDIAN,
keylen            599 drivers/hv/hv_kvp.c 	kvp_data->key_size = 2*(keylen + 1); /* utf16 encoding */
keylen            612 drivers/hv/hv_kvp.c 	if ((keylen < 0) || (valuelen < 0))
keylen            266 drivers/isdn/mISDN/dsp.h extern int dsp_bf_init(struct dsp *dsp, const u8 *key, unsigned int keylen);
keylen            599 drivers/isdn/mISDN/dsp_blowfish.c dsp_bf_init(struct dsp *dsp, const u8 *key, uint keylen)
keylen            606 drivers/isdn/mISDN/dsp_blowfish.c 	if (keylen < 4 || keylen > 56)
keylen            634 drivers/isdn/mISDN/dsp_blowfish.c 			((u32)key[(j + 1) % keylen] << 16) |
keylen            635 drivers/isdn/mISDN/dsp_blowfish.c 			((u32)key[(j + 2) % keylen] << 8) |
keylen            636 drivers/isdn/mISDN/dsp_blowfish.c 			((u32)key[(j + 3) % keylen]));
keylen            639 drivers/isdn/mISDN/dsp_blowfish.c 		j = (j + 4) % keylen;
keylen           2116 drivers/misc/altera-stapl/altera.c 			   char *key, char *value, int keylen, int vallen)
keylen           2192 drivers/misc/altera-stapl/altera.c 					keylen);
keylen             97 drivers/net/ppp/ppp_mppe.c 	unsigned keylen;	/* key length in bytes             */
keylen            135 drivers/net/ppp/ppp_mppe.c 			    state->keylen);
keylen            139 drivers/net/ppp/ppp_mppe.c 			    state->keylen);
keylen            153 drivers/net/ppp/ppp_mppe.c 		arc4_setkey(&state->arc4, state->sha1_digest, state->keylen);
keylen            155 drivers/net/ppp/ppp_mppe.c 			   state->keylen);
keylen            157 drivers/net/ppp/ppp_mppe.c 		memcpy(state->session_key, state->sha1_digest, state->keylen);
keylen            159 drivers/net/ppp/ppp_mppe.c 	if (state->keylen == 8) {
keylen            165 drivers/net/ppp/ppp_mppe.c 	arc4_setkey(&state->arc4, state->session_key, state->keylen);
keylen            262 drivers/net/ppp/ppp_mppe.c 		state->keylen = 16;
keylen            264 drivers/net/ppp/ppp_mppe.c 		state->keylen = 8;
keylen            278 drivers/net/ppp/ppp_mppe.c 		       debugstr, unit, (state->keylen == 16) ? 128 : 40,
keylen            232 drivers/net/wireless/ath/ath10k/mac.c 		.key_len = key->keylen,
keylen            566 drivers/net/wireless/ath/carl9170/carl9170.h 	const u8 ktype, const u8 keyidx, const u8 *keydata, const int keylen);
keylen            476 drivers/net/wireless/ath/carl9170/mac.c 			const int keylen)
keylen            489 drivers/net/wireless/ath/carl9170/mac.c 		memcpy(&key.key, keydata, keylen);
keylen           1248 drivers/net/wireless/ath/carl9170/main.c 					  min_t(u8, 16, key->keylen));
keylen            504 drivers/net/wireless/ath/key.c 	hk.kv_len = key->keylen;
keylen            505 drivers/net/wireless/ath/key.c 	if (key->keylen)
keylen            506 drivers/net/wireless/ath/key.c 		memcpy(hk.kv_val, key->key, key->keylen);
keylen            503 drivers/net/wireless/ath/wcn36xx/main.c 		    key_conf->keylen, key_conf->flags);
keylen            506 drivers/net/wireless/ath/wcn36xx/main.c 			 key_conf->keylen);
keylen            544 drivers/net/wireless/ath/wcn36xx/main.c 			memcpy(key, key_conf->key, key_conf->keylen);
keylen            560 drivers/net/wireless/ath/wcn36xx/main.c 				key_conf->keylen,
keylen            568 drivers/net/wireless/ath/wcn36xx/main.c 				key_conf->keylen,
keylen            579 drivers/net/wireless/ath/wcn36xx/main.c 						key_conf->keylen,
keylen           1722 drivers/net/wireless/ath/wcn36xx/smd.c 			   u8 keylen,
keylen           1745 drivers/net/wireless/ath/wcn36xx/smd.c 		msg_body.set_sta_key_params.key[0].length = keylen;
keylen           1746 drivers/net/wireless/ath/wcn36xx/smd.c 		memcpy(msg_body.set_sta_key_params.key[0].key, key, keylen);
keylen           1772 drivers/net/wireless/ath/wcn36xx/smd.c 			   u8 keylen,
keylen           1787 drivers/net/wireless/ath/wcn36xx/smd.c 	msg_body.keys[0].length = keylen;
keylen           1788 drivers/net/wireless/ath/wcn36xx/smd.c 	memcpy(msg_body.keys[0].key, key, keylen);
keylen             99 drivers/net/wireless/ath/wcn36xx/smd.h 			   u8 keylen,
keylen            106 drivers/net/wireless/ath/wcn36xx/smd.h 			   u8 keylen,
keylen           2142 drivers/net/wireless/atmel/at76c50x-usb.c 		 __func__, cmd, key->cipher, key->keyidx, key->keylen);
keylen           2154 drivers/net/wireless/atmel/at76c50x-usb.c 		memcpy(priv->wep_keys[key->keyidx], key->key, key->keylen);
keylen           2155 drivers/net/wireless/atmel/at76c50x-usb.c 		priv->wep_keys_len[key->keyidx] = key->keylen;
keylen           4235 drivers/net/wireless/broadcom/b43/main.c 					    key->key, key->keylen,
keylen           4240 drivers/net/wireless/broadcom/b43/main.c 					    key->key, key->keylen, NULL, key);
keylen           1296 drivers/net/wireless/cisco/airo.c static void emmh32_setseed(emmh32_context *context, u8 *pkey, int keylen,
keylen           1633 drivers/net/wireless/cisco/airo.c static void emmh32_setseed(emmh32_context *context, u8 *pkey, int keylen,
keylen           5205 drivers/net/wireless/cisco/airo.c 		       u16 keylen, int perm, int lock)
keylen           5211 drivers/net/wireless/cisco/airo.c 	if (WARN_ON(keylen == 0))
keylen           5217 drivers/net/wireless/cisco/airo.c 	wkr.klen = cpu_to_le16(keylen);
keylen           5218 drivers/net/wireless/cisco/airo.c 	memcpy(wkr.key, key, keylen);
keylen           5379 drivers/net/wireless/intel/ipw2x00/ipw2100.c 	int keylen = len ? (len <= 5 ? 5 : 13) : 0;
keylen           5389 drivers/net/wireless/intel/ipw2x00/ipw2100.c 		     idx, keylen, len);
keylen           5396 drivers/net/wireless/intel/ipw2x00/ipw2100.c 	wep_key->len = keylen;
keylen           5398 drivers/net/wireless/intel/ipw2x00/ipw2100.c 	if (keylen) {
keylen           5400 drivers/net/wireless/intel/ipw2x00/ipw2100.c 		memset(wep_key->key + len, 0, keylen - len);
keylen           5404 drivers/net/wireless/intel/ipw2x00/ipw2100.c 	if (keylen == 0)
keylen           5407 drivers/net/wireless/intel/ipw2x00/ipw2100.c 	else if (keylen == 5)
keylen            136 drivers/net/wireless/intel/iwlegacy/3945-mac.c 	il->stations[sta_id].keyinfo.keylen = keyconf->keylen;
keylen            137 drivers/net/wireless/intel/iwlegacy/3945-mac.c 	memcpy(il->stations[sta_id].keyinfo.key, keyconf->key, keyconf->keylen);
keylen            139 drivers/net/wireless/intel/iwlegacy/3945-mac.c 	memcpy(il->stations[sta_id].sta.key.key, keyconf->key, keyconf->keylen);
keylen            223 drivers/net/wireless/intel/iwlegacy/3945-mac.c 	      keyconf->cipher, keyconf->keylen, keyconf->keyidx, sta_id, ret);
keylen            361 drivers/net/wireless/intel/iwlegacy/3945-mac.c 		memcpy(tx_cmd->key, keyinfo->key, keyinfo->keylen);
keylen            377 drivers/net/wireless/intel/iwlegacy/3945-mac.c 		memcpy(&tx_cmd->key[3], keyinfo->key, keyinfo->keylen);
keylen           1605 drivers/net/wireless/intel/iwlegacy/4965-mac.c 		memcpy(tx_cmd->key, keyconf->key, keyconf->keylen);
keylen           1625 drivers/net/wireless/intel/iwlegacy/4965-mac.c 		memcpy(&tx_cmd->key[3], keyconf->key, keyconf->keylen);
keylen           3204 drivers/net/wireless/intel/iwlegacy/4965-mac.c 	int len = keyconf->keylen;
keylen           3210 drivers/net/wireless/intel/iwlegacy/4965-mac.c 		D_WEP("Bad WEP key length %d\n", keyconf->keylen);
keylen           3243 drivers/net/wireless/intel/iwlegacy/4965-mac.c 	if (keyconf->keylen == WEP_KEY_LEN_128)
keylen           3252 drivers/net/wireless/intel/iwlegacy/4965-mac.c 	il->stations[sta_id].keyinfo.keylen = keyconf->keylen;
keylen           3255 drivers/net/wireless/intel/iwlegacy/4965-mac.c 	memcpy(il->stations[sta_id].keyinfo.key, keyconf->key, keyconf->keylen);
keylen           3258 drivers/net/wireless/intel/iwlegacy/4965-mac.c 	       keyconf->keylen);
keylen           3302 drivers/net/wireless/intel/iwlegacy/4965-mac.c 	il->stations[sta_id].keyinfo.keylen = keyconf->keylen;
keylen           3304 drivers/net/wireless/intel/iwlegacy/4965-mac.c 	memcpy(il->stations[sta_id].keyinfo.key, keyconf->key, keyconf->keylen);
keylen           3306 drivers/net/wireless/intel/iwlegacy/4965-mac.c 	memcpy(il->stations[sta_id].sta.key.key, keyconf->key, keyconf->keylen);
keylen           3350 drivers/net/wireless/intel/iwlegacy/4965-mac.c 	il->stations[sta_id].keyinfo.keylen = 16;
keylen           3500 drivers/net/wireless/intel/iwlegacy/4965-mac.c 	      keyconf->cipher, keyconf->keylen, keyconf->keyidx, sta_id, ret);
keylen            652 drivers/net/wireless/intel/iwlegacy/common.h 	int keylen;
keylen           1027 drivers/net/wireless/intel/iwlwifi/dvm/sta.c 	if (keyconf->keylen != WEP_KEY_LEN_128 &&
keylen           1028 drivers/net/wireless/intel/iwlwifi/dvm/sta.c 	    keyconf->keylen != WEP_KEY_LEN_64) {
keylen           1030 drivers/net/wireless/intel/iwlwifi/dvm/sta.c 			      "Bad WEP key length %d\n", keyconf->keylen);
keylen           1036 drivers/net/wireless/intel/iwlwifi/dvm/sta.c 	ctx->wep_keys[keyconf->keyidx].key_size = keyconf->keylen;
keylen           1038 drivers/net/wireless/intel/iwlwifi/dvm/sta.c 							keyconf->keylen);
keylen           1042 drivers/net/wireless/intel/iwlwifi/dvm/sta.c 		keyconf->keylen, keyconf->keyidx, ret);
keylen           1101 drivers/net/wireless/intel/iwlwifi/dvm/sta.c 		memcpy(sta_cmd.key.key, keyconf->key, keyconf->keylen);
keylen           1108 drivers/net/wireless/intel/iwlwifi/dvm/sta.c 		memcpy(sta_cmd.key.key, keyconf->key, keyconf->keylen);
keylen           1115 drivers/net/wireless/intel/iwlwifi/dvm/sta.c 		memcpy(&sta_cmd.key.key[3], keyconf->key, keyconf->keylen);
keylen           1255 drivers/net/wireless/intel/iwlwifi/dvm/sta.c 		      keyconf->cipher, keyconf->keylen, keyconf->keyidx,
keylen            201 drivers/net/wireless/intel/iwlwifi/dvm/tx.c 		memcpy(tx_cmd->key, keyconf->key, keyconf->keylen);
keylen            218 drivers/net/wireless/intel/iwlwifi/dvm/tx.c 		memcpy(&tx_cmd->key[3], keyconf->key, keyconf->keylen);
keylen            200 drivers/net/wireless/intel/iwlwifi/mvm/d3.c 			.wep_key.key_size = key->keylen,
keylen            211 drivers/net/wireless/intel/iwlwifi/mvm/d3.c 		memcpy(&wkc.wep_key.key[3], key->key, key->keylen);
keylen           1480 drivers/net/wireless/intel/iwlwifi/mvm/d3.c 			conf.conf.keylen = WLAN_KEY_LEN_CCMP;
keylen           1485 drivers/net/wireless/intel/iwlwifi/mvm/d3.c 			conf.conf.keylen = WLAN_KEY_LEN_TKIP;
keylen           1543 drivers/net/wireless/intel/iwlwifi/mvm/mvm.h 	memcpy(tx_cmd->key, keyconf->key, keyconf->keylen);
keylen           3241 drivers/net/wireless/intel/iwlwifi/mvm/sta.c 		memcpy(u.cmd.common.key, key->key, key->keylen);
keylen           3245 drivers/net/wireless/intel/iwlwifi/mvm/sta.c 		memcpy(u.cmd.common.key, key->key, key->keylen);
keylen           3254 drivers/net/wireless/intel/iwlwifi/mvm/sta.c 		memcpy(u.cmd.common.key + 3, key->key, key->keylen);
keylen           3261 drivers/net/wireless/intel/iwlwifi/mvm/sta.c 		memcpy(u.cmd.common.key, key->key, key->keylen);
keylen           3267 drivers/net/wireless/intel/iwlwifi/mvm/sta.c 		memcpy(u.cmd.common.key, key->key, key->keylen);
keylen           3350 drivers/net/wireless/intel/iwlwifi/mvm/sta.c 		memcpy(igtk_cmd.igtk, keyconf->key, keyconf->keylen);
keylen           3559 drivers/net/wireless/intel/iwlwifi/mvm/sta.c 		      keyconf->cipher, keyconf->keylen, keyconf->keyidx,
keylen            465 drivers/net/wireless/intel/iwlwifi/mvm/tx.c 		memcpy(&tx_cmd->key[3], keyconf->key, keyconf->keylen);
keylen            329 drivers/net/wireless/intersil/hostap/hostap_main.c 	int i, keylen, len, idx;
keylen            384 drivers/net/wireless/intersil/hostap/hostap_main.c 	keylen = 6; /* first 5 octets */
keylen            388 drivers/net/wireless/intersil/hostap/hostap_main.c 		keylen = WEP_KEY_LEN + 1; /* first 13 octets */
keylen            399 drivers/net/wireless/intersil/hostap/hostap_main.c 					 keybuf, keylen)) {
keylen            401 drivers/net/wireless/intersil/hostap/hostap_main.c 			       i, keylen);
keylen            858 drivers/net/wireless/intersil/orinoco/hw.c 			int keylen;
keylen            862 drivers/net/wireless/intersil/orinoco/hw.c 			keylen = priv->keys[priv->tx_key].key_len;
keylen            864 drivers/net/wireless/intersil/orinoco/hw.c 			if (keylen > LARGE_KEY_SIZE) {
keylen            866 drivers/net/wireless/intersil/orinoco/hw.c 				       priv->ndev->name, priv->tx_key, keylen);
keylen            868 drivers/net/wireless/intersil/orinoco/hw.c 			} else if (keylen > SMALL_KEY_SIZE)
keylen            869 drivers/net/wireless/intersil/orinoco/hw.c 				keylen = LARGE_KEY_SIZE;
keylen            870 drivers/net/wireless/intersil/orinoco/hw.c 			else if (keylen > 0)
keylen            871 drivers/net/wireless/intersil/orinoco/hw.c 				keylen = SMALL_KEY_SIZE;
keylen            873 drivers/net/wireless/intersil/orinoco/hw.c 				keylen = 0;
keylen            884 drivers/net/wireless/intersil/orinoco/hw.c 						HERMES_BYTES_TO_RECLEN(keylen),
keylen            589 drivers/net/wireless/intersil/p54/main.c 			     key->keylen, addr, key->key);
keylen            909 drivers/net/wireless/intersil/p54/txrx.c 		txhdr->key_len = min((u8)16, info->control.hw_key->keylen);
keylen           1003 drivers/net/wireless/marvell/libertas/cfg.c 	cmd.param.keylen = cpu_to_le16(key_len);
keylen            820 drivers/net/wireless/marvell/libertas/host.h 	__le16 keylen;
keylen           4291 drivers/net/wireless/marvell/mwl8k.c 	cmd->key_len = cpu_to_le16(key->keylen);
keylen           4355 drivers/net/wireless/marvell/mwl8k.c 						sizeof(*key) + key->keylen);
keylen           4359 drivers/net/wireless/marvell/mwl8k.c 		keymlen = key->keylen;
keylen           4366 drivers/net/wireless/marvell/mwl8k.c 		keymlen = key->keylen;
keylen            727 drivers/net/wireless/mediatek/mt76/mt7603/mac.c 	if (key->keylen > 32)
keylen            730 drivers/net/wireless/mediatek/mt76/mt7603/mac.c 	memcpy(key_data, key->key, key->keylen);
keylen            636 drivers/net/wireless/mediatek/mt76/mt7615/mac.c 	if (key->keylen > sizeof(data))
keylen            649 drivers/net/wireless/mediatek/mt76/mt7615/mac.c 			memcpy(data, key->key, key->keylen);
keylen             17 drivers/net/wireless/mediatek/mt76/mt76x02_mac.c 	if (key->keylen > 32)
keylen             20 drivers/net/wireless/mediatek/mt76/mt76x02_mac.c 	memcpy(key_data, key->key, key->keylen);
keylen            511 drivers/net/wireless/mediatek/mt7601u/mac.c 	if (key->keylen > 32)
keylen            514 drivers/net/wireless/mediatek/mt7601u/mac.c 	memcpy(key_data, key->key, key->keylen);
keylen            462 drivers/net/wireless/ralink/rt2x00/rt2x00mac.c 	if (key->keylen > 32)
keylen            484 drivers/net/wireless/ralink/rt2x00/rt2x00mac.c 		memcpy_tkip(&crypto, &key->key[0], key->keylen);
keylen            486 drivers/net/wireless/ralink/rt2x00/rt2x00mac.c 		memcpy(crypto.key, &key->key[0], key->keylen);
keylen           1625 drivers/net/wireless/realtek/rtlwifi/core.c 			       key->key, key->keylen);
keylen           1626 drivers/net/wireless/realtek/rtlwifi/core.c 			rtlpriv->sec.key_len[key_idx] = key->keylen;
keylen           1635 drivers/net/wireless/realtek/rtlwifi/core.c 			       key->key, key->keylen);
keylen           1636 drivers/net/wireless/realtek/rtlwifi/core.c 			rtlpriv->sec.key_len[key_idx] = key->keylen;
keylen           1652 drivers/net/wireless/realtek/rtlwifi/core.c 			       key->key, key->keylen);
keylen           1653 drivers/net/wireless/realtek/rtlwifi/core.c 			rtlpriv->sec.key_len[PAIRWISE_KEYIDX] = key->keylen;
keylen           1680 drivers/net/wireless/realtek/rtlwifi/core.c 		memset(rtlpriv->sec.key_buf[key_idx], 0, key->keylen);
keylen            959 drivers/net/wireless/rsi/rsi_91x_mac80211.c 		__func__, key->cipher, key_type, key->keylen);
keylen            974 drivers/net/wireless/rsi/rsi_91x_mac80211.c 						  key->keylen,
keylen            987 drivers/net/wireless/rsi/rsi_91x_mac80211.c 				  key->keylen,
keylen           1490 drivers/net/wireless/rsi/rsi_91x_mac80211.c 							 key->keylen,
keylen            711 drivers/net/wireless/st/cw1200/sta.c 			if (key->keylen > 16) {
keylen            722 drivers/net/wireless/st/cw1200/sta.c 				       &key->key[0], key->keylen);
keylen            723 drivers/net/wireless/st/cw1200/sta.c 				wsm_key->wep_pairwise.keylen = key->keylen;
keylen            727 drivers/net/wireless/st/cw1200/sta.c 				       &key->key[0], key->keylen);
keylen            728 drivers/net/wireless/st/cw1200/sta.c 				wsm_key->wep_group.keylen = key->keylen;
keylen           1017 drivers/net/wireless/st/cw1200/wsm.h 			u8 keylen;		/* Key length in bytes */
keylen           1022 drivers/net/wireless/st/cw1200/wsm.h 			u8 keylen;		/* Key length in bytes */
keylen            892 drivers/net/wireless/ti/wl1251/main.c 		     key->cipher, key->keyidx, key->keylen, key->flags);
keylen            893 drivers/net/wireless/ti/wl1251/main.c 	wl1251_dump(DEBUG_CRYPT, "KEY: ", key->key, key->keylen);
keylen            945 drivers/net/wireless/ti/wl1251/main.c 		memcpy(wl_cmd->key, key->key, key->keylen);
keylen            947 drivers/net/wireless/ti/wl1251/main.c 	wl_cmd->key_size = key->keylen;
keylen           3511 drivers/net/wireless/ti/wlcore/main.c 		     key_conf->keylen, key_conf->flags);
keylen           3512 drivers/net/wireless/ti/wlcore/main.c 	wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
keylen           3558 drivers/net/wireless/ti/wlcore/main.c 				 key_conf->keylen, key_conf->key,
keylen           3584 drivers/net/wireless/ti/wlcore/main.c 				     key_conf->keylen, key_conf->key,
keylen            305 drivers/s390/crypto/pkey_api.c static int pkey_nonccatok2pkey(const u8 *key, u32 keylen,
keylen            313 drivers/s390/crypto/pkey_api.c 		if (keylen != sizeof(struct protaeskeytoken))
keylen            333 drivers/s390/crypto/pkey_api.c static int pkey_ccainttok2pkey(const u8 *key, u32 keylen,
keylen            340 drivers/s390/crypto/pkey_api.c 		if (keylen != sizeof(struct secaeskeytoken))
keylen            344 drivers/s390/crypto/pkey_api.c 		if (keylen < hdr->len || keylen > MAXCCAVLSCTOKENSIZE)
keylen            359 drivers/s390/crypto/pkey_api.c int pkey_keyblob2pkey(const u8 *key, u32 keylen,
keylen            365 drivers/s390/crypto/pkey_api.c 	if (keylen < sizeof(struct keytoken_header)) {
keylen            366 drivers/s390/crypto/pkey_api.c 		DEBUG_ERR("%s invalid keylen %d\n", __func__, keylen);
keylen            372 drivers/s390/crypto/pkey_api.c 		rc = pkey_nonccatok2pkey(key, keylen, protkey);
keylen            375 drivers/s390/crypto/pkey_api.c 		rc = pkey_ccainttok2pkey(key, keylen, protkey);
keylen            483 drivers/s390/crypto/pkey_api.c static int pkey_verifykey2(const u8 *key, size_t keylen,
keylen            492 drivers/s390/crypto/pkey_api.c 	if (keylen < sizeof(struct keytoken_header) ||
keylen            568 drivers/s390/crypto/pkey_api.c 			      const u8 *key, size_t keylen,
keylen            578 drivers/s390/crypto/pkey_api.c 	if (keylen < sizeof(struct keytoken_header))
keylen            583 drivers/s390/crypto/pkey_api.c 		return pkey_nonccatok2pkey(key, keylen, pkey);
keylen            587 drivers/s390/crypto/pkey_api.c 			if (keylen != sizeof(struct secaeskeytoken))
keylen            593 drivers/s390/crypto/pkey_api.c 			if (keylen < hdr->len || keylen > MAXCCAVLSCTOKENSIZE)
keylen            627 drivers/s390/crypto/pkey_api.c static int pkey_apqns4key(const u8 *key, size_t keylen, u32 flags,
keylen            634 drivers/s390/crypto/pkey_api.c 	if (keylen < sizeof(struct keytoken_header) ||
keylen            716 drivers/s390/crypto/pkey_api.c static void *_copy_key_from_user(void __user *ukey, size_t keylen)
keylen            720 drivers/s390/crypto/pkey_api.c 	if (!ukey || keylen < MINKEYBLOBSIZE || keylen > KEYBLOBBUFSIZE)
keylen            722 drivers/s390/crypto/pkey_api.c 	kkey = kmalloc(keylen, GFP_KERNEL);
keylen            725 drivers/s390/crypto/pkey_api.c 	if (copy_from_user(kkey, ukey, keylen)) {
keylen            896 drivers/s390/crypto/pkey_api.c 		kkey = _copy_key_from_user(ktp.key, ktp.keylen);
keylen            899 drivers/s390/crypto/pkey_api.c 		rc = pkey_keyblob2pkey(kkey, ktp.keylen, &ktp.protkey);
keylen            935 drivers/s390/crypto/pkey_api.c 			if (kgs.keylen < klen) {
keylen            944 drivers/s390/crypto/pkey_api.c 		kgs.keylen = klen;
keylen            977 drivers/s390/crypto/pkey_api.c 			if (kcs.keylen < klen) {
keylen            986 drivers/s390/crypto/pkey_api.c 		kcs.keylen = klen;
keylen           1000 drivers/s390/crypto/pkey_api.c 		kkey = _copy_key_from_user(kvk.key, kvk.keylen);
keylen           1003 drivers/s390/crypto/pkey_api.c 		rc = pkey_verifykey2(kkey, kvk.keylen,
keylen           1025 drivers/s390/crypto/pkey_api.c 		kkey = _copy_key_from_user(ktp.key, ktp.keylen);
keylen           1031 drivers/s390/crypto/pkey_api.c 					kkey, ktp.keylen, &ktp.protkey);
keylen           1058 drivers/s390/crypto/pkey_api.c 		kkey = _copy_key_from_user(kak.key, kak.keylen);
keylen           1063 drivers/s390/crypto/pkey_api.c 		rc = pkey_apqns4key(kkey, kak.keylen, kak.flags,
keylen           1186 drivers/s390/crypto/zcrypt_ccamisc.c 				u16 keylen;
keylen           1279 drivers/s390/crypto/zcrypt_ccamisc.c 	switch (prepparm->vud.ckb.keylen) {
keylen           1297 drivers/s390/crypto/zcrypt_ccamisc.c 			  __func__, prepparm->vud.ckb.keylen);
keylen           1301 drivers/s390/crypto/zcrypt_ccamisc.c 	memcpy(protkey, prepparm->vud.ckb.key, prepparm->vud.ckb.keylen);
keylen           1303 drivers/s390/crypto/zcrypt_ccamisc.c 		*protkeylen = prepparm->vud.ckb.keylen;
keylen           1552 drivers/staging/rtl8188eu/core/rtw_mlme.c 	u8 keylen;
keylen           1592 drivers/staging/rtl8188eu/core/rtw_mlme.c 		keylen = 5;
keylen           1594 drivers/staging/rtl8188eu/core/rtw_mlme.c 		       &psecuritypriv->dot11DefKey[keyid].skey[0], keylen);
keylen           1597 drivers/staging/rtl8188eu/core/rtw_mlme.c 		keylen = 13;
keylen           1599 drivers/staging/rtl8188eu/core/rtw_mlme.c 		       &psecuritypriv->dot11DefKey[keyid].skey[0], keylen);
keylen           1602 drivers/staging/rtl8188eu/core/rtw_mlme.c 		keylen = 16;
keylen           1603 drivers/staging/rtl8188eu/core/rtw_mlme.c 		memcpy(&psetkeyparm->key, &psecuritypriv->dot118021XGrpKey[keyid], keylen);
keylen           1607 drivers/staging/rtl8188eu/core/rtw_mlme.c 		keylen = 16;
keylen           1608 drivers/staging/rtl8188eu/core/rtw_mlme.c 		memcpy(&psetkeyparm->key, &psecuritypriv->dot118021XGrpKey[keyid], keylen);
keylen           2117 drivers/staging/rtl8188eu/os_dep/ioctl_linux.c 	u8 keylen;
keylen           2145 drivers/staging/rtl8188eu/os_dep/ioctl_linux.c 		keylen = 5;
keylen           2148 drivers/staging/rtl8188eu/os_dep/ioctl_linux.c 		keylen = 13;
keylen           2154 drivers/staging/rtl8188eu/os_dep/ioctl_linux.c 		keylen = 16;
keylen           2157 drivers/staging/rtl8188eu/os_dep/ioctl_linux.c 	memcpy(&(psetkeyparm->key[0]), key, keylen);
keylen           2174 drivers/staging/rtl8188eu/os_dep/ioctl_linux.c static int set_wep_key(struct adapter *padapter, u8 *key, u8 keylen, int keyid)
keylen           2178 drivers/staging/rtl8188eu/os_dep/ioctl_linux.c 	switch (keylen) {
keylen           1181 drivers/staging/rtl8712/rtl871x_mlme.c 	u8 keylen;
keylen           1203 drivers/staging/rtl8712/rtl871x_mlme.c 		keylen = 5;
keylen           1205 drivers/staging/rtl8712/rtl871x_mlme.c 			psecuritypriv->DefKey[keyid].skey, keylen);
keylen           1208 drivers/staging/rtl8712/rtl871x_mlme.c 		keylen = 13;
keylen           1210 drivers/staging/rtl8712/rtl871x_mlme.c 			psecuritypriv->DefKey[keyid].skey, keylen);
keylen           1217 drivers/staging/rtl8712/rtl871x_mlme.c 		keylen = 16;
keylen           1219 drivers/staging/rtl8712/rtl871x_mlme.c 			&psecuritypriv->XGrpKey[keyid - 1], keylen);
keylen           1227 drivers/staging/rtl8712/rtl871x_mlme.c 		keylen = 16;
keylen           1229 drivers/staging/rtl8712/rtl871x_mlme.c 			&psecuritypriv->XGrpKey[keyid - 1], keylen);
keylen           1484 drivers/staging/rtl8723bs/core/rtw_ap.c 	u8 keylen;
keylen           1514 drivers/staging/rtl8723bs/core/rtw_ap.c 		keylen = 5;
keylen           1517 drivers/staging/rtl8723bs/core/rtw_ap.c 		keylen = 13;
keylen           1523 drivers/staging/rtl8723bs/core/rtw_ap.c 		keylen = 16;
keylen           1526 drivers/staging/rtl8723bs/core/rtw_ap.c 	memcpy(&(psetkeyparm->key[0]), key, keylen);
keylen           1553 drivers/staging/rtl8723bs/core/rtw_ap.c 	u8 keylen,
keylen           1560 drivers/staging/rtl8723bs/core/rtw_ap.c 	switch (keylen) {
keylen           2243 drivers/staging/rtl8723bs/core/rtw_mlme.c 	u8 keylen;
keylen           2274 drivers/staging/rtl8723bs/core/rtw_mlme.c 		keylen = 5;
keylen           2275 drivers/staging/rtl8723bs/core/rtw_mlme.c 		memcpy(&(psetkeyparm->key[0]), &(psecuritypriv->dot11DefKey[keyid].skey[0]), keylen);
keylen           2278 drivers/staging/rtl8723bs/core/rtw_mlme.c 		keylen = 13;
keylen           2279 drivers/staging/rtl8723bs/core/rtw_mlme.c 		memcpy(&(psetkeyparm->key[0]), &(psecuritypriv->dot11DefKey[keyid].skey[0]), keylen);
keylen           2282 drivers/staging/rtl8723bs/core/rtw_mlme.c 		keylen = 16;
keylen           2283 drivers/staging/rtl8723bs/core/rtw_mlme.c 		memcpy(&psetkeyparm->key, &psecuritypriv->dot118021XGrpKey[keyid], keylen);
keylen           2287 drivers/staging/rtl8723bs/core/rtw_mlme.c 		keylen = 16;
keylen           2288 drivers/staging/rtl8723bs/core/rtw_mlme.c 		memcpy(&psetkeyparm->key, &psecuritypriv->dot118021XGrpKey[keyid], keylen);
keylen             26 drivers/staging/rtl8723bs/include/rtw_ap.h int rtw_ap_set_wep_key(struct adapter *padapter, u8 *key, u8 keylen, int keyid, u8 set_tx);
keylen             79 drivers/staging/vt6655/key.c 		if (key->keylen == WLAN_KEY_LEN_WEP40)
keylen             81 drivers/staging/vt6655/key.c 		if (key->keylen == WLAN_KEY_LEN_WEP104)
keylen           1214 drivers/staging/vt6655/rxtx.c 		memcpy(key_buffer + 3, tx_key->key, tx_key->keylen);
keylen           1216 drivers/staging/vt6655/rxtx.c 		if (tx_key->keylen == WLAN_KEY_LEN_WEP40) {
keylen           1397 drivers/staging/vt6655/rxtx.c 		if (tx_key->keylen > 0)
keylen             95 drivers/staging/vt6656/key.c 		if (key->keylen == WLAN_KEY_LEN_WEP40)
keylen             97 drivers/staging/vt6656/key.c 		if (key->keylen == WLAN_KEY_LEN_WEP104)
keylen            727 drivers/staging/vt6656/rxtx.c 		memcpy(key_buffer + 3, tx_key->key, tx_key->keylen);
keylen            729 drivers/staging/vt6656/rxtx.c 		if (tx_key->keylen == WLAN_KEY_LEN_WEP40) {
keylen            961 drivers/staging/vt6656/rxtx.c 		if (tx_key->keylen > 0)
keylen            512 drivers/staging/wilc1000/wilc_wfi_cfgoperations.c 	int ret = 0, keylen = params->key_len;
keylen            562 drivers/staging/wilc1000/wilc_wfi_cfgoperations.c 				keylen = params->key_len - 16;
keylen            592 drivers/staging/wilc1000/wilc_wfi_cfgoperations.c 				keylen = params->key_len - 16;
keylen            599 drivers/staging/wilc1000/wilc_wfi_cfgoperations.c 			ret = wilc_add_rx_gtk(vif, params->key, keylen,
keylen            604 drivers/staging/wilc1000/wilc_wfi_cfgoperations.c 			ret = wilc_add_ptk(vif, params->key, keylen, mac_addr,
keylen            226 drivers/staging/wlan-ng/p80211netdev.h int wep_change_key(struct wlandevice *wlandev, int keynum, u8 *key, int keylen);
keylen            121 drivers/staging/wlan-ng/p80211wep.c int wep_change_key(struct wlandevice *wlandev, int keynum, u8 *key, int keylen)
keylen            123 drivers/staging/wlan-ng/p80211wep.c 	if (keylen < 0)
keylen            125 drivers/staging/wlan-ng/p80211wep.c 	if (keylen >= MAX_KEYLEN)
keylen            134 drivers/staging/wlan-ng/p80211wep.c 	wlandev->wep_keylens[keynum] = keylen;
keylen            135 drivers/staging/wlan-ng/p80211wep.c 	memcpy(wlandev->wep_keys[keynum], key, keylen);
keylen            147 drivers/staging/wlan-ng/p80211wep.c 	u32 i, j, k, crc, keylen;
keylen            167 drivers/staging/wlan-ng/p80211wep.c 	keylen = wlandev->wep_keylens[keyidx];
keylen            169 drivers/staging/wlan-ng/p80211wep.c 	if (keylen == 0)
keylen            173 drivers/staging/wlan-ng/p80211wep.c 	memcpy(key + 3, wlandev->wep_keys[keyidx], keylen);
keylen            175 drivers/staging/wlan-ng/p80211wep.c 	keylen += 3;		/* add in IV bytes */
keylen            182 drivers/staging/wlan-ng/p80211wep.c 		j = (j + s[i] + key[i % keylen]) & 0xff;
keylen            220 drivers/staging/wlan-ng/p80211wep.c 	u32 i, j, k, crc, keylen;
keylen            230 drivers/staging/wlan-ng/p80211wep.c 	keylen = wlandev->wep_keylens[keynum];
keylen            231 drivers/staging/wlan-ng/p80211wep.c 	if (keylen <= 0)
keylen            236 drivers/staging/wlan-ng/p80211wep.c 	while ((iv[1] == 0xff) && (iv[0] >= 3) && (iv[0] < keylen))
keylen            246 drivers/staging/wlan-ng/p80211wep.c 	memcpy(key + 3, wlandev->wep_keys[keynum], keylen);
keylen            248 drivers/staging/wlan-ng/p80211wep.c 	keylen += 3;		/* add in IV bytes */
keylen            255 drivers/staging/wlan-ng/p80211wep.c 		j = (j + s[i] + key[i % keylen]) & 0xff;
keylen            117 fs/befs/btree.c 			     int index, u16 * keylen);
keylen            335 fs/befs/btree.c 	u16 keylen;
keylen            346 fs/befs/btree.c 	thiskey = befs_bt_get_key(sb, node, last, &keylen);
keylen            348 fs/befs/btree.c 	eq = befs_compare_strings(thiskey, keylen, findkey, findkey_len);
keylen            363 fs/befs/btree.c 		thiskey = befs_bt_get_key(sb, node, mid, &keylen);
keylen            364 fs/befs/btree.c 		eq = befs_compare_strings(thiskey, keylen, findkey,
keylen            421 fs/befs/btree.c 	u16 keylen;
keylen            490 fs/befs/btree.c 	keystart = befs_bt_get_key(sb, this_node, cur_key, &keylen);
keylen            494 fs/befs/btree.c 		   (int)keylen);
keylen            496 fs/befs/btree.c 	if (bufsize < keylen + 1) {
keylen            498 fs/befs/btree.c 			   "for key of size %d", __func__, bufsize, keylen);
keylen            503 fs/befs/btree.c 	strlcpy(keybuf, keystart, keylen + 1);
keylen            505 fs/befs/btree.c 	*keysize = keylen;
keylen            508 fs/befs/btree.c 		   cur_key, keylen, keybuf, *value);
keylen            676 fs/befs/btree.c 		int index, u16 * keylen)
keylen            683 fs/befs/btree.c 		*keylen = 0;
keylen            695 fs/befs/btree.c 	*keylen = fs16_to_cpu(sb, keylen_index[index]) - prev_key_end;
keylen             30 fs/cachefiles/interface.c 	unsigned keylen, auxlen;
keylen             64 fs/cachefiles/interface.c 	keylen = cookie->key_len;
keylen             65 fs/cachefiles/interface.c 	if (keylen <= sizeof(cookie->inline_key))
keylen             69 fs/cachefiles/interface.c 	memcpy(buffer + 2, p, keylen);
keylen             71 fs/cachefiles/interface.c 	*(uint16_t *)buffer = keylen;
keylen             72 fs/cachefiles/interface.c 	((char *)buffer)[keylen + 2] = 0;
keylen             73 fs/cachefiles/interface.c 	((char *)buffer)[keylen + 3] = 0;
keylen             74 fs/cachefiles/interface.c 	((char *)buffer)[keylen + 4] = 0;
keylen             77 fs/cachefiles/interface.c 	key = cachefiles_cook_key(buffer, keylen + 2, object->type);
keylen            156 fs/cachefiles/internal.h extern char *cachefiles_cook_key(const u8 *raw, int keylen, uint8_t type);
keylen             33 fs/cachefiles/key.c char *cachefiles_cook_key(const u8 *raw, int keylen, uint8_t type)
keylen             40 fs/cachefiles/key.c 	_enter(",%d", keylen);
keylen             42 fs/cachefiles/key.c 	BUG_ON(keylen < 2 || keylen > 514);
keylen             46 fs/cachefiles/key.c 	for (loop = 2; loop < keylen; loop++) {
keylen             54 fs/cachefiles/key.c 		max = keylen - 2;
keylen             63 fs/cachefiles/key.c 		keylen = (keylen + 2) / 3;
keylen             65 fs/cachefiles/key.c 		max = keylen * 4;
keylen             98 fs/cachefiles/key.c 		for (loop = keylen; loop > 0; loop--) {
keylen            117 fs/cachefiles/key.c 		for (loop = keylen; loop > 0; loop--) {
keylen            249 fs/fscache/object-list.c 		uint16_t keylen = 0, auxlen = 0;
keylen            272 fs/fscache/object-list.c 			keylen = cookie->key_len;
keylen            277 fs/fscache/object-list.c 		if (keylen > 0 || auxlen > 0) {
keylen            279 fs/fscache/object-list.c 			p = keylen <= sizeof(cookie->inline_key) ?
keylen            281 fs/fscache/object-list.c 			for (; keylen > 0; keylen--)
keylen             46 fs/hfs/bfind.c 	u16 off, len, keylen;
keylen             57 fs/hfs/bfind.c 		keylen = hfs_brec_keylen(bnode, rec);
keylen             58 fs/hfs/bfind.c 		if (keylen == 0) {
keylen             62 fs/hfs/bfind.c 		hfs_bnode_read(bnode, fd->key, off, keylen);
keylen             76 fs/hfs/bfind.c 		keylen = hfs_brec_keylen(bnode, e);
keylen             77 fs/hfs/bfind.c 		if (keylen == 0) {
keylen             81 fs/hfs/bfind.c 		hfs_bnode_read(bnode, fd->key, off, keylen);
keylen             86 fs/hfs/bfind.c 	fd->keylength = keylen;
keylen             87 fs/hfs/bfind.c 	fd->entryoffset = off + keylen;
keylen             88 fs/hfs/bfind.c 	fd->entrylength = len - keylen;
keylen            167 fs/hfs/bfind.c 	u16 off, len, keylen;
keylen            212 fs/hfs/bfind.c 	keylen = hfs_brec_keylen(bnode, fd->record);
keylen            213 fs/hfs/bfind.c 	if (keylen == 0) {
keylen            218 fs/hfs/bfind.c 	fd->keylength = keylen;
keylen            219 fs/hfs/bfind.c 	fd->entryoffset = off + keylen;
keylen            220 fs/hfs/bfind.c 	fd->entrylength = len - keylen;
keylen            221 fs/hfs/bfind.c 	hfs_bnode_read(bnode, fd->key, off, keylen);
keylen            117 fs/hfsplus/bfind.c 	u16 off, len, keylen;
keylen            129 fs/hfsplus/bfind.c 		keylen = hfs_brec_keylen(bnode, rec);
keylen            130 fs/hfsplus/bfind.c 		if (keylen == 0) {
keylen            134 fs/hfsplus/bfind.c 		hfs_bnode_read(bnode, fd->key, off, keylen);
keylen            143 fs/hfsplus/bfind.c 		keylen = hfs_brec_keylen(bnode, e);
keylen            144 fs/hfsplus/bfind.c 		if (keylen == 0) {
keylen            148 fs/hfsplus/bfind.c 		hfs_bnode_read(bnode, fd->key, off, keylen);
keylen            154 fs/hfsplus/bfind.c 	fd->keylength = keylen;
keylen            155 fs/hfsplus/bfind.c 	fd->entryoffset = off + keylen;
keylen            156 fs/hfsplus/bfind.c 	fd->entrylength = len - keylen;
keylen            236 fs/hfsplus/bfind.c 	u16 off, len, keylen;
keylen            281 fs/hfsplus/bfind.c 	keylen = hfs_brec_keylen(bnode, fd->record);
keylen            282 fs/hfsplus/bfind.c 	if (keylen == 0) {
keylen            287 fs/hfsplus/bfind.c 	fd->keylength = keylen;
keylen            288 fs/hfsplus/bfind.c 	fd->entryoffset = off + keylen;
keylen            289 fs/hfsplus/bfind.c 	fd->entrylength = len - keylen;
keylen            290 fs/hfsplus/bfind.c 	hfs_bnode_read(bnode, fd->key, off, keylen);
keylen             71 fs/orangefs/downcall.h 	__s32 keylen;
keylen            533 fs/unicode/mkutf8data.c static int insert(struct tree *tree, char *key, int keylen, void *leaf)
keylen            540 fs/unicode/mkutf8data.c 	assert(keylen >= 1 && keylen <= 4);
keylen            544 fs/unicode/mkutf8data.c 	keybits = 8 * keylen;
keylen           1687 fs/unicode/mkutf8data.c 	int keylen;
keylen           1698 fs/unicode/mkutf8data.c 			keylen = utf8encode(keyval, unichar);
keylen           1702 fs/unicode/mkutf8data.c 			insert(&trees[i], keyval, keylen, data);
keylen            132 include/crypto/aead.h 	              unsigned int keylen);
keylen            282 include/crypto/aead.h 		       const u8 *key, unsigned int keylen);
keylen             37 include/crypto/aes.h static inline int aes_check_keylen(unsigned int keylen)
keylen             39 include/crypto/aes.h 	switch (keylen) {
keylen             98 include/crypto/akcipher.h 			   unsigned int keylen);
keylen            100 include/crypto/akcipher.h 			    unsigned int keylen);
keylen            388 include/crypto/akcipher.h 					      unsigned int keylen)
keylen            392 include/crypto/akcipher.h 	return alg->set_pub_key(tfm, key, keylen);
keylen            410 include/crypto/akcipher.h 					       unsigned int keylen)
keylen            414 include/crypto/akcipher.h 	return alg->set_priv_key(tfm, key, keylen);
keylen             30 include/crypto/authenc.h 			       unsigned int keylen);
keylen             19 include/crypto/cast5.h int cast5_setkey(struct crypto_tfm *tfm, const u8 *key, unsigned int keylen);
keylen             19 include/crypto/cast6.h 		   unsigned int keylen, u32 *flags);
keylen             20 include/crypto/cast6.h int cast6_setkey(struct crypto_tfm *tfm, const u8 *key, unsigned int keylen);
keylen             42 include/crypto/des.h int des_expand_key(struct des_ctx *ctx, const u8 *key, unsigned int keylen);
keylen             55 include/crypto/des.h 			unsigned int keylen);
keylen            137 include/crypto/hash.h 		      unsigned int keylen);
keylen            191 include/crypto/hash.h 		      unsigned int keylen);
keylen            212 include/crypto/hash.h 		      unsigned int keylen);
keylen            412 include/crypto/hash.h 			unsigned int keylen);
keylen            825 include/crypto/hash.h 			unsigned int keylen);
keylen             48 include/crypto/if_alg.h 	int (*setkey)(void *private, const u8 *key, unsigned int keylen);
keylen            133 include/crypto/internal/des.h 				      int keylen)
keylen            135 include/crypto/internal/des.h 	if (keylen != DES_KEY_SIZE) {
keylen            143 include/crypto/internal/des.h 				       int keylen)
keylen            145 include/crypto/internal/des.h 	if (keylen != DES3_EDE_KEY_SIZE) {
keylen             81 include/crypto/internal/hash.h 		    unsigned int keylen);
keylen             62 include/crypto/nhpoly1305.h 			     const u8 *key, unsigned int keylen);
keylen             24 include/crypto/public_key.h 	u32 keylen;
keylen             22 include/crypto/serpent.h 		     unsigned int keylen);
keylen             23 include/crypto/serpent.h int serpent_setkey(struct crypto_tfm *tfm, const u8 *key, unsigned int keylen);
keylen             39 include/crypto/skcipher.h 	              unsigned int keylen);
keylen            113 include/crypto/skcipher.h 	              unsigned int keylen);
keylen            401 include/crypto/skcipher.h 					 const u8 *key, unsigned int keylen)
keylen            403 include/crypto/skcipher.h 	return tfm->setkey(tfm, key, keylen);
keylen            407 include/crypto/skcipher.h 					 const u8 *key, unsigned int keylen)
keylen            409 include/crypto/skcipher.h 	return crypto_skcipher_setkey(&tfm->base, key, keylen);
keylen             14 include/crypto/xts.h 				const u8 *key, unsigned int keylen)
keylen             22 include/crypto/xts.h 	if (keylen % 2) {
keylen             29 include/crypto/xts.h 	    !crypto_memneq(key, key + (keylen / 2), keylen / 2)) {
keylen             38 include/crypto/xts.h 				 const u8 *key, unsigned int keylen)
keylen             44 include/crypto/xts.h 	if (keylen % 2) {
keylen             52 include/crypto/xts.h 	    !crypto_memneq(key, key + (keylen / 2), keylen / 2)) {
keylen             40 include/keys/trusted.h 			unsigned int keylen, unsigned char *h1,
keylen             46 include/keys/trusted.h 			  unsigned int keylen, ...);
keylen            234 include/linux/crypto.h 	              unsigned int keylen);
keylen            256 include/linux/crypto.h 	              unsigned int keylen);
keylen            320 include/linux/crypto.h 	                  unsigned int keylen);
keylen            720 include/linux/crypto.h 	              unsigned int keylen);
keylen            733 include/linux/crypto.h 		      unsigned int keylen);
keylen            742 include/linux/crypto.h 	                  const u8 *key, unsigned int keylen);
keylen           1056 include/linux/crypto.h 					   const u8 *key, unsigned int keylen)
keylen           1060 include/linux/crypto.h 	return crt->setkey(crt->base, key, keylen);
keylen           1460 include/linux/crypto.h 					  const u8 *key, unsigned int keylen)
keylen           1463 include/linux/crypto.h 						 key, keylen);
keylen           1745 include/linux/crypto.h                                        const u8 *key, unsigned int keylen)
keylen           1748 include/linux/crypto.h 						  key, keylen);
keylen             18 include/linux/evm.h extern int evm_set_key(void *key, size_t keylen);
keylen             48 include/linux/evm.h static inline int evm_set_key(void *key, size_t keylen)
keylen           1762 include/net/mac80211.h 	u8 keylen;
keylen             18 include/net/netfilter/nf_conntrack_count.h 					    unsigned int keylen);
keylen           1540 include/net/tcp.h 	u8			keylen;
keylen             85 include/uapi/linux/virtio_crypto.h 	__le32 keylen;
keylen            288 include/xen/interface/io/netif.h 					unsigned int keylen,
keylen            298 include/xen/interface/io/netif.h 		prefix |= (keyi < keylen) ? key[keyi] : 0;
keylen            316 include/xen/interface/io/netif.h 		prefix |= (keyi < keylen) ? key[keyi] : 0;
keylen            483 lib/assoc_array.c 	size_t keylen;
keylen            741 lib/assoc_array.c 	keylen = round_up(diff, ASSOC_ARRAY_KEY_CHUNK_SIZE);
keylen            742 lib/assoc_array.c 	keylen >>= ASSOC_ARRAY_KEY_CHUNK_SHIFT;
keylen            745 lib/assoc_array.c 			 keylen * sizeof(unsigned long), GFP_KERNEL);
keylen            763 lib/assoc_array.c 	for (i = 0; i < keylen; i++)
keylen            769 lib/assoc_array.c 		pr_devel("blank off [%zu] %d: %lx\n", keylen - 1, level, blank);
keylen            770 lib/assoc_array.c 		new_s0->index_key[keylen - 1] &= ~blank;
keylen            800 lib/assoc_array.c 	size_t keylen;
keylen            849 lib/assoc_array.c 		keylen = round_up(diff, ASSOC_ARRAY_KEY_CHUNK_SIZE);
keylen            850 lib/assoc_array.c 		keylen >>= ASSOC_ARRAY_KEY_CHUNK_SHIFT;
keylen            853 lib/assoc_array.c 				 keylen * sizeof(unsigned long), GFP_KERNEL);
keylen            867 lib/assoc_array.c 		       keylen * sizeof(unsigned long));
keylen            870 lib/assoc_array.c 		pr_devel("blank off [%zu] %d: %lx\n", keylen - 1, diff, blank);
keylen            871 lib/assoc_array.c 		new_s0->index_key[keylen - 1] &= ~blank;
keylen            899 lib/assoc_array.c 		keylen = round_up(shortcut->skip_to_level, ASSOC_ARRAY_KEY_CHUNK_SIZE);
keylen            900 lib/assoc_array.c 		keylen >>= ASSOC_ARRAY_KEY_CHUNK_SHIFT;
keylen            903 lib/assoc_array.c 				 keylen * sizeof(unsigned long), GFP_KERNEL);
keylen            916 lib/assoc_array.c 		       keylen * sizeof(unsigned long));
keylen           1465 lib/assoc_array.c 	int keylen, slot, nr_free, next_slot, i;
keylen           1491 lib/assoc_array.c 		keylen = round_up(shortcut->skip_to_level, ASSOC_ARRAY_KEY_CHUNK_SIZE);
keylen           1492 lib/assoc_array.c 		keylen >>= ASSOC_ARRAY_KEY_CHUNK_SHIFT;
keylen           1494 lib/assoc_array.c 				keylen * sizeof(unsigned long), GFP_KERNEL);
keylen           1499 lib/assoc_array.c 					 keylen * sizeof(unsigned long)));
keylen             50 lib/btree.c    	int keylen;
keylen             56 lib/btree.c    	.keylen = 1,
keylen             64 lib/btree.c    	.keylen = LONG_PER_U64,
keylen             71 lib/btree.c    	.keylen = 2 * LONG_PER_U64,
keylen            140 lib/btree.c    	for (i = geo->keylen - 1; i >= 0; i--) {
keylen            150 lib/btree.c    	return &node[n * geo->keylen];
keylen            161 lib/btree.c    	longcpy(bkey(geo, node, n), key, geo->keylen);
keylen            172 lib/btree.c    	longset(bkey(geo, node, n), 0, geo->keylen);
keylen            219 lib/btree.c    	longcpy(key, bkey(geo, node, 0), geo->keylen);
keylen            227 lib/btree.c    	return longcmp(bkey(geo, node, pos), key, geo->keylen);
keylen            234 lib/btree.c    	for (i = 0; i < geo->keylen; i++)
keylen            323 lib/btree.c    	longcpy(key, __key, geo->keylen);
keylen            347 lib/btree.c    				longcpy(__key, bkey(geo, node, i), geo->keylen);
keylen            355 lib/btree.c    		longcpy(key, retry_key, geo->keylen);
keylen            669 lib/btree.c    		longcpy(dup, key, geo->keylen);
keylen            699 lib/crypto/des.c int des_expand_key(struct des_ctx *ctx, const u8 *key, unsigned int keylen)
keylen            701 lib/crypto/des.c 	if (keylen != DES_KEY_SIZE)
keylen            824 lib/crypto/des.c 			unsigned int keylen)
keylen            829 lib/crypto/des.c 	if (keylen != DES3_EDE_KEY_SIZE)
keylen            832 lib/crypto/des.c 	err = des3_ede_verify_key(key, keylen, true);
keylen            869 net/ipv4/esp4.c 	unsigned int keylen;
keylen            903 net/ipv4/esp4.c 	keylen = (x->aalg ? (x->aalg->alg_key_len + 7) / 8 : 0) +
keylen            906 net/ipv4/esp4.c 	key = kmalloc(keylen, GFP_KERNEL);
keylen            945 net/ipv4/esp4.c 	err = crypto_aead_setkey(aead, key, keylen);
keylen           3849 net/ipv4/tcp.c 	sg_init_one(&sg, key->key, key->keylen);
keylen           3850 net/ipv4/tcp.c 	ahash_request_set_crypt(hp->md5_req, &sg, NULL, key->keylen);
keylen             43 net/ipv4/tcp_diag.c 	info->tcpm_keylen = key->keylen;
keylen             44 net/ipv4/tcp_diag.c 	memcpy(info->tcpm_key, key->key, key->keylen);
keylen           1082 net/ipv4/tcp_ipv4.c 		key->keylen = newkeylen;
keylen           1107 net/ipv4/tcp_ipv4.c 	key->keylen = newkeylen;
keylen           1483 net/ipv4/tcp_ipv4.c 			       AF_INET, 32, key->key, key->keylen, GFP_ATOMIC);
keylen            764 net/ipv6/esp6.c 	unsigned int keylen;
keylen            798 net/ipv6/esp6.c 	keylen = (x->aalg ? (x->aalg->alg_key_len + 7) / 8 : 0) +
keylen            801 net/ipv6/esp6.c 	key = kmalloc(keylen, GFP_KERNEL);
keylen            840 net/ipv6/esp6.c 	err = crypto_aead_setkey(aead, key, keylen);
keylen           1281 net/ipv6/tcp_ipv6.c 			       AF_INET6, 128, key->key, key->keylen,
keylen            650 net/mac80211/cfg.c 	params.key_len = key->conf.keylen;
keylen             62 net/mac80211/debugfs_key.c KEY_CONF_FILE(keylen, D);
keylen            303 net/mac80211/debugfs_key.c 	int i, bufsize = 2 * key->conf.keylen + 2;
keylen            311 net/mac80211/debugfs_key.c 	for (i = 0; i < key->conf.keylen; i++)
keylen            350 net/mac80211/debugfs_key.c 	DEBUGFS_ADD(keylen);
keylen            523 net/mac80211/key.c 	key->conf.keylen = key_len;
keylen            737 net/mac80211/key.c 	if (!old || new->conf.keylen != old->conf.keylen)
keylen            750 net/mac80211/key.c 	    new->conf.keylen == WLAN_KEY_LEN_TKIP &&
keylen            760 net/mac80211/key.c 	return !crypto_memneq(tk_old, tk_new, new->conf.keylen);
keylen           1252 net/mac80211/key.c 				  keyconf->keylen, keyconf->key,
keylen             33 net/mac80211/wep.c static inline bool ieee80211_wep_weak_iv(u32 iv, int keylen)
keylen             42 net/mac80211/wep.c 		if (B >= 3 && B < 3 + keylen)
keylen             50 net/mac80211/wep.c 				 int keylen, int keyidx, u8 *iv)
keylen             53 net/mac80211/wep.c 	if (ieee80211_wep_weak_iv(local->wep_iv, keylen))
keylen             68 net/mac80211/wep.c 				int keylen, int keyidx)
keylen             89 net/mac80211/wep.c 	ieee80211_wep_get_iv(local, keylen, keyidx, newhdr + hdrlen);
keylen            135 net/mac80211/wep.c 			  const u8 *key, int keylen, int keyidx)
keylen            144 net/mac80211/wep.c 	iv = ieee80211_wep_add_iv(local, skb, keylen, keyidx);
keylen            154 net/mac80211/wep.c 	memcpy(rc4key + 3, key, keylen);
keylen            159 net/mac80211/wep.c 	return ieee80211_wep_encrypt_data(&local->wep_tx_ctx, rc4key, keylen + 3,
keylen            219 net/mac80211/wep.c 	klen = 3 + key->conf.keylen;
keylen            225 net/mac80211/wep.c 	memcpy(rc4key + 3, key->conf.key, key->conf.keylen);
keylen            279 net/mac80211/wep.c 					  tx->key->conf.keylen,
keylen            285 net/mac80211/wep.c 					  tx->key->conf.keylen,
keylen             21 net/mac80211/wep.h 			  const u8 *key, int keylen, int keyidx);
keylen             59 net/netfilter/nf_conncount.c 	unsigned int keylen;
keylen            313 net/netfilter/nf_conncount.c 	u8 keylen = data->keylen;
keylen            325 net/netfilter/nf_conncount.c 		diff = key_diff(key, rbconn->key, keylen);
keylen            370 net/netfilter/nf_conncount.c 	memcpy(rbconn->key, key, sizeof(u32) * keylen);
keylen            395 net/netfilter/nf_conncount.c 	u8 keylen = data->keylen;
keylen            397 net/netfilter/nf_conncount.c 	hash = jhash2(key, data->keylen, conncount_rnd) % CONNCOUNT_SLOTS;
keylen            406 net/netfilter/nf_conncount.c 		diff = key_diff(key, rbconn->key, keylen);
keylen            517 net/netfilter/nf_conncount.c 					    unsigned int keylen)
keylen            522 net/netfilter/nf_conncount.c 	if (keylen % sizeof(u32) ||
keylen            523 net/netfilter/nf_conncount.c 	    keylen / sizeof(u32) > MAX_KEYLEN ||
keylen            524 net/netfilter/nf_conncount.c 	    keylen == 0)
keylen            542 net/netfilter/nf_conncount.c 	data->keylen = keylen / sizeof(u32);
keylen             88 net/netfilter/xt_connlimit.c 	unsigned int keylen;
keylen             90 net/netfilter/xt_connlimit.c 	keylen = sizeof(u32);
keylen             92 net/netfilter/xt_connlimit.c 		keylen += sizeof(struct in6_addr);
keylen             94 net/netfilter/xt_connlimit.c 		keylen += sizeof(struct in_addr);
keylen             97 net/netfilter/xt_connlimit.c 	info->data = nf_conncount_init(par->net, par->family, keylen);
keylen            589 net/sunrpc/auth_gss/gss_krb5_mech.c 	int keylen;
keylen            624 net/sunrpc/auth_gss/gss_krb5_mech.c 	keylen = ctx->gk5e->keylength;
keylen            626 net/sunrpc/auth_gss/gss_krb5_mech.c 	p = simple_get_bytes(p, end, ctx->Ksess, keylen);
keylen            154 net/wireless/lib80211_crypt_ccmp.c 			      u8 *aeskey, int keylen, void *priv)
keylen            163 net/wireless/lib80211_crypt_ccmp.c 	if (aeskey != NULL && keylen >= CCMP_TK_LEN)
keylen            284 net/wireless/lib80211_crypt_tkip.c 			      u8 * rc4key, int keylen, void *priv)
keylen            295 net/wireless/lib80211_crypt_tkip.c 	if (rc4key == NULL || keylen < 16)
keylen             64 net/wireless/lib80211_crypt_wep.c 			       u8 *key, int keylen, void *priv)
keylen             52 security/integrity/evm/evm_crypto.c int evm_set_key(void *key, size_t keylen)
keylen             60 security/integrity/evm/evm_crypto.c 	if (keylen > MAX_KEY_SIZE)
keylen             62 security/integrity/evm/evm_crypto.c 	memcpy(evmkey, key, keylen);
keylen            339 security/keys/encrypted-keys/encrypted.c static int calc_hmac(u8 *digest, const u8 *key, unsigned int keylen,
keylen            352 security/keys/encrypted-keys/encrypted.c 	err = crypto_shash_setkey(tfm, key, keylen);
keylen             76 security/keys/trusted.c 		       unsigned int keylen, ...)
keylen             90 security/keys/trusted.c 	ret = crypto_shash_setkey(hmacalg, key, keylen);
keylen             97 security/keys/trusted.c 	va_start(argp, keylen);
keylen            123 security/keys/trusted.c 			unsigned int keylen, unsigned char *h1,
keylen            165 security/keys/trusted.c 		ret = TSS_rawhmac(digest, key, keylen, SHA1_DIGEST_SIZE,
keylen            181 security/keys/trusted.c 			  unsigned int keylen, ...)
keylen            229 security/keys/trusted.c 	va_start(argp, keylen);
keylen            245 security/keys/trusted.c 	ret = TSS_rawhmac(testhmac, key, keylen, SHA1_DIGEST_SIZE, paramdigest,
keylen            868 security/keys/trusted.c 	long keylen;
keylen            884 security/keys/trusted.c 		ret = kstrtol(c, 10, &keylen);
keylen            885 security/keys/trusted.c 		if (ret < 0 || keylen < MIN_KEY_SIZE || keylen > MAX_KEY_SIZE)
keylen            887 security/keys/trusted.c 		p->key_len = keylen;
keylen            206 tools/testing/selftests/net/nettest.c 	int keylen = password ? strlen(password) : 0;
keylen            211 tools/testing/selftests/net/nettest.c 	md5sig.tcpm_keylen = keylen;
keylen            213 tools/testing/selftests/net/nettest.c 	if (keylen)
keylen            214 tools/testing/selftests/net/nettest.c 		memcpy(md5sig.tcpm_key, password, keylen);
keylen             87 tools/testing/selftests/pidfd/pidfd_open_test.c static pid_t get_pid_from_fdinfo_file(int pidfd, const char *key, size_t keylen)
keylen            105 tools/testing/selftests/pidfd/pidfd_open_test.c 		if (strncmp(line, key, keylen))