[linux-2.6-block.git] / arch / s390 / crypto / crypt_s390.h

/*
 * Cryptographic API.
 *
 * Support for s390 cryptographic instructions.
 *
 *   Copyright IBM Corp. 2003,2007
 *   Author(s): Thomas Spatzier
 *		Jan Glauber (jan.glauber@de.ibm.com)
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the Free
 * Software Foundation; either version 2 of the License, or (at your option)
 * any later version.
 *
 */
#ifndef _CRYPTO_ARCH_S390_CRYPT_S390_H
#define _CRYPTO_ARCH_S390_CRYPT_S390_H

#include <asm/errno.h>

#define CRYPT_S390_OP_MASK 0xFF00
#define CRYPT_S390_FUNC_MASK 0x00FF

#define CRYPT_S390_PRIORITY 300
#define CRYPT_S390_COMPOSITE_PRIORITY 400

#define CRYPT_S390_MSA	0x1
#define CRYPT_S390_MSA3	0x2
#define CRYPT_S390_MSA4	0x4

/* s390 cryptographic operations */
enum crypt_s390_operations {
	CRYPT_S390_KM   = 0x0100,
	CRYPT_S390_KMC  = 0x0200,
	CRYPT_S390_KIMD = 0x0300,
	CRYPT_S390_KLMD = 0x0400,
	CRYPT_S390_KMAC = 0x0500
};

/*
 * function codes for KM (CIPHER MESSAGE) instruction
 * 0x80 is the decipher modifier bit
 */
enum crypt_s390_km_func {
	KM_QUERY	    = CRYPT_S390_KM | 0x0,
	KM_DEA_ENCRYPT      = CRYPT_S390_KM | 0x1,
	KM_DEA_DECRYPT      = CRYPT_S390_KM | 0x1 | 0x80,
	KM_TDEA_128_ENCRYPT = CRYPT_S390_KM | 0x2,
	KM_TDEA_128_DECRYPT = CRYPT_S390_KM | 0x2 | 0x80,
	KM_TDEA_192_ENCRYPT = CRYPT_S390_KM | 0x3,
	KM_TDEA_192_DECRYPT = CRYPT_S390_KM | 0x3 | 0x80,
	KM_AES_128_ENCRYPT  = CRYPT_S390_KM | 0x12,
	KM_AES_128_DECRYPT  = CRYPT_S390_KM | 0x12 | 0x80,
	KM_AES_192_ENCRYPT  = CRYPT_S390_KM | 0x13,
	KM_AES_192_DECRYPT  = CRYPT_S390_KM | 0x13 | 0x80,
	KM_AES_256_ENCRYPT  = CRYPT_S390_KM | 0x14,
	KM_AES_256_DECRYPT  = CRYPT_S390_KM | 0x14 | 0x80,
	KM_XTS_128_ENCRYPT  = CRYPT_S390_KM | 0x32,
	KM_XTS_128_DECRYPT  = CRYPT_S390_KM | 0x32 | 0x80,
	KM_XTS_256_ENCRYPT  = CRYPT_S390_KM | 0x34,
	KM_XTS_256_DECRYPT  = CRYPT_S390_KM | 0x34 | 0x80,
};

/*
 * function codes for KMC (CIPHER MESSAGE WITH CHAINING)
 * instruction
 */
enum crypt_s390_kmc_func {
	KMC_QUERY            = CRYPT_S390_KMC | 0x0,
	KMC_DEA_ENCRYPT      = CRYPT_S390_KMC | 0x1,
	KMC_DEA_DECRYPT      = CRYPT_S390_KMC | 0x1 | 0x80,
	KMC_TDEA_128_ENCRYPT = CRYPT_S390_KMC | 0x2,
	KMC_TDEA_128_DECRYPT = CRYPT_S390_KMC | 0x2 | 0x80,
	KMC_TDEA_192_ENCRYPT = CRYPT_S390_KMC | 0x3,
	KMC_TDEA_192_DECRYPT = CRYPT_S390_KMC | 0x3 | 0x80,
	KMC_AES_128_ENCRYPT  = CRYPT_S390_KMC | 0x12,
	KMC_AES_128_DECRYPT  = CRYPT_S390_KMC | 0x12 | 0x80,
	KMC_AES_192_ENCRYPT  = CRYPT_S390_KMC | 0x13,
	KMC_AES_192_DECRYPT  = CRYPT_S390_KMC | 0x13 | 0x80,
	KMC_AES_256_ENCRYPT  = CRYPT_S390_KMC | 0x14,
	KMC_AES_256_DECRYPT  = CRYPT_S390_KMC | 0x14 | 0x80,
	KMC_PRNG	     = CRYPT_S390_KMC | 0x43,
};

/*
 * function codes for KIMD (COMPUTE INTERMEDIATE MESSAGE DIGEST)
 * instruction
 */
enum crypt_s390_kimd_func {
	KIMD_QUERY   = CRYPT_S390_KIMD | 0,
	KIMD_SHA_1   = CRYPT_S390_KIMD | 1,
	KIMD_SHA_256 = CRYPT_S390_KIMD | 2,
	KIMD_SHA_512 = CRYPT_S390_KIMD | 3,
	KIMD_GHASH   = CRYPT_S390_KIMD | 65,
};

/*
 * function codes for KLMD (COMPUTE LAST MESSAGE DIGEST)
 * instruction
 */
enum crypt_s390_klmd_func {
	KLMD_QUERY   = CRYPT_S390_KLMD | 0,
	KLMD_SHA_1   = CRYPT_S390_KLMD | 1,
	KLMD_SHA_256 = CRYPT_S390_KLMD | 2,
	KLMD_SHA_512 = CRYPT_S390_KLMD | 3,
};

/*
 * function codes for KMAC (COMPUTE MESSAGE AUTHENTICATION CODE)
 * instruction
 */
enum crypt_s390_kmac_func {
	KMAC_QUERY    = CRYPT_S390_KMAC | 0,
	KMAC_DEA      = CRYPT_S390_KMAC | 1,
	KMAC_TDEA_128 = CRYPT_S390_KMAC | 2,
	KMAC_TDEA_192 = CRYPT_S390_KMAC | 3
};

/**
 * crypt_s390_km:
 * @func: the function code passed to KM; see crypt_s390_km_func
 * @param: address of parameter block; see POP for details on each func
 * @dest: address of destination memory area
 * @src: address of source memory area
 * @src_len: length of src operand in bytes
 *
 * Executes the KM (CIPHER MESSAGE) operation of the CPU.
 *
 * Returns -1 for failure, 0 for the query func, number of processed
 * bytes for encryption/decryption funcs
 */
static inline int crypt_s390_km(long func, void *param,
				u8 *dest, const u8 *src, long src_len)
{
	register long __func asm("0") = func & CRYPT_S390_FUNC_MASK;
	register void *__param asm("1") = param;
	register const u8 *__src asm("2") = src;
	register long __src_len asm("3") = src_len;
	register u8 *__dest asm("4") = dest;
	int ret;

	asm volatile(
		"0:	.insn	rre,0xb92e0000,%3,%1 \n" /* KM opcode */
		"1:	brc	1,0b \n" /* handle partial completion */
		"	la	%0,0\n"
		"2:\n"
		EX_TABLE(0b,2b) EX_TABLE(1b,2b)
		: "=d" (ret), "+a" (__src), "+d" (__src_len), "+a" (__dest)
		: "d" (__func), "a" (__param), "0" (-1) : "cc", "memory");
	if (ret < 0)
		return ret;
	return (func & CRYPT_S390_FUNC_MASK) ? src_len - __src_len : __src_len;
}

/**
 * crypt_s390_kmc:
 * @func: the function code passed to KM; see crypt_s390_kmc_func
 * @param: address of parameter block; see POP for details on each func
 * @dest: address of destination memory area
 * @src: address of source memory area
 * @src_len: length of src operand in bytes
 *
 * Executes the KMC (CIPHER MESSAGE WITH CHAINING) operation of the CPU.
 *
 * Returns -1 for failure, 0 for the query func, number of processed
 * bytes for encryption/decryption funcs
 */
static inline int crypt_s390_kmc(long func, void *param,
				 u8 *dest, const u8 *src, long src_len)
{
	register long __func asm("0") = func & CRYPT_S390_FUNC_MASK;
	register void *__param asm("1") = param;
	register const u8 *__src asm("2") = src;
	register long __src_len asm("3") = src_len;
	register u8 *__dest asm("4") = dest;
	int ret;

	asm volatile(
		"0:	.insn	rre,0xb92f0000,%3,%1 \n" /* KMC opcode */
		"1:	brc	1,0b \n" /* handle partial completion */
		"	la	%0,0\n"
		"2:\n"
		EX_TABLE(0b,2b) EX_TABLE(1b,2b)
		: "=d" (ret), "+a" (__src), "+d" (__src_len), "+a" (__dest)
		: "d" (__func), "a" (__param), "0" (-1) : "cc", "memory");
	if (ret < 0)
		return ret;
	return (func & CRYPT_S390_FUNC_MASK) ? src_len - __src_len : __src_len;
}

/**
 * crypt_s390_kimd:
 * @func: the function code passed to KM; see crypt_s390_kimd_func
 * @param: address of parameter block; see POP for details on each func
 * @src: address of source memory area
 * @src_len: length of src operand in bytes
 *
 * Executes the KIMD (COMPUTE INTERMEDIATE MESSAGE DIGEST) operation
 * of the CPU.
 *
 * Returns -1 for failure, 0 for the query func, number of processed
 * bytes for digest funcs
 */
static inline int crypt_s390_kimd(long func, void *param,
				  const u8 *src, long src_len)
{
	register long __func asm("0") = func & CRYPT_S390_FUNC_MASK;
	register void *__param asm("1") = param;
	register const u8 *__src asm("2") = src;
	register long __src_len asm("3") = src_len;
	int ret;

	asm volatile(
		"0:	.insn	rre,0xb93e0000,%1,%1 \n" /* KIMD opcode */
		"1:	brc	1,0b \n" /* handle partial completion */
		"	la	%0,0\n"
		"2:\n"
		EX_TABLE(0b,2b) EX_TABLE(1b,2b)
		: "=d" (ret), "+a" (__src), "+d" (__src_len)
		: "d" (__func), "a" (__param), "0" (-1) : "cc", "memory");
	if (ret < 0)
		return ret;
	return (func & CRYPT_S390_FUNC_MASK) ? src_len - __src_len : __src_len;
}

/**
 * crypt_s390_klmd:
 * @func: the function code passed to KM; see crypt_s390_klmd_func
 * @param: address of parameter block; see POP for details on each func
 * @src: address of source memory area
 * @src_len: length of src operand in bytes
 *
 * Executes the KLMD (COMPUTE LAST MESSAGE DIGEST) operation of the CPU.
 *
 * Returns -1 for failure, 0 for the query func, number of processed
 * bytes for digest funcs
 */
static inline int crypt_s390_klmd(long func, void *param,
				  const u8 *src, long src_len)
{
	register long __func asm("0") = func & CRYPT_S390_FUNC_MASK;
	register void *__param asm("1") = param;
	register const u8 *__src asm("2") = src;
	register long __src_len asm("3") = src_len;
	int ret;

	asm volatile(
		"0:	.insn	rre,0xb93f0000,%1,%1 \n" /* KLMD opcode */
		"1:	brc	1,0b \n" /* handle partial completion */
		"	la	%0,0\n"
		"2:\n"
		EX_TABLE(0b,2b) EX_TABLE(1b,2b)
		: "=d" (ret), "+a" (__src), "+d" (__src_len)
		: "d" (__func), "a" (__param), "0" (-1) : "cc", "memory");
	if (ret < 0)
		return ret;
	return (func & CRYPT_S390_FUNC_MASK) ? src_len - __src_len : __src_len;
}

/**
 * crypt_s390_kmac:
 * @func: the function code passed to KM; see crypt_s390_klmd_func
 * @param: address of parameter block; see POP for details on each func
 * @src: address of source memory area
 * @src_len: length of src operand in bytes
 *
 * Executes the KMAC (COMPUTE MESSAGE AUTHENTICATION CODE) operation
 * of the CPU.
 *
 * Returns -1 for failure, 0 for the query func, number of processed
 * bytes for digest funcs
 */
static inline int crypt_s390_kmac(long func, void *param,
				  const u8 *src, long src_len)
{
	register long __func asm("0") = func & CRYPT_S390_FUNC_MASK;
	register void *__param asm("1") = param;
	register const u8 *__src asm("2") = src;
	register long __src_len asm("3") = src_len;
	int ret;

	asm volatile(
		"0:	.insn	rre,0xb91e0000,%1,%1 \n" /* KLAC opcode */
		"1:	brc	1,0b \n" /* handle partial completion */
		"	la	%0,0\n"
		"2:\n"
		EX_TABLE(0b,2b) EX_TABLE(1b,2b)
		: "=d" (ret), "+a" (__src), "+d" (__src_len)
		: "d" (__func), "a" (__param), "0" (-1) : "cc", "memory");
	if (ret < 0)
		return ret;
	return (func & CRYPT_S390_FUNC_MASK) ? src_len - __src_len : __src_len;
}

/**
 * crypt_s390_func_available:
 * @func: the function code of the specific function; 0 if op in general
 *
 * Tests if a specific crypto function is implemented on the machine.
 *
 * Returns 1 if func available; 0 if func or op in general not available
 */
static inline int crypt_s390_func_available(int func,
					    unsigned int facility_mask)
{
	unsigned char status[16];
	int ret;

	if (facility_mask & CRYPT_S390_MSA && !test_facility(17))
		return 0;
	if (facility_mask & CRYPT_S390_MSA3 && !test_facility(76))
		return 0;
	if (facility_mask & CRYPT_S390_MSA4 && !test_facility(77))
		return 0;

	switch (func & CRYPT_S390_OP_MASK) {
	case CRYPT_S390_KM:
		ret = crypt_s390_km(KM_QUERY, &status, NULL, NULL, 0);
		break;
	case CRYPT_S390_KMC:
		ret = crypt_s390_kmc(KMC_QUERY, &status, NULL, NULL, 0);
		break;
	case CRYPT_S390_KIMD:
		ret = crypt_s390_kimd(KIMD_QUERY, &status, NULL, 0);
		break;
	case CRYPT_S390_KLMD:
		ret = crypt_s390_klmd(KLMD_QUERY, &status, NULL, 0);
		break;
	case CRYPT_S390_KMAC:
		ret = crypt_s390_kmac(KMAC_QUERY, &status, NULL, 0);
		break;
	default:
		return 0;
	}
	if (ret < 0)
		return 0;
	func &= CRYPT_S390_FUNC_MASK;
	func &= 0x7f;		/* mask modifier bit */
	return (status[func >> 3] & (0x80 >> (func & 7))) != 0;
}

/**
 * crypt_s390_pcc:
 * @func: the function code passed to KM; see crypt_s390_km_func
 * @param: address of parameter block; see POP for details on each func
 *
 * Executes the PCC (PERFORM CRYPTOGRAPHIC COMPUTATION) operation of the CPU.
 *
 * Returns -1 for failure, 0 for success.
 */
static inline int crypt_s390_pcc(long func, void *param)
{
	register long __func asm("0") = func & 0x7f; /* encrypt or decrypt */
	register void *__param asm("1") = param;
	int ret = -1;

	asm volatile(
		"0:	.insn	rre,0xb92c0000,0,0 \n" /* PCC opcode */
		"1:	brc	1,0b \n" /* handle partial completion */
		"	la	%0,0\n"
		"2:\n"
		EX_TABLE(0b,2b) EX_TABLE(1b,2b)
		: "+d" (ret)
		: "d" (__func), "a" (__param) : "cc", "memory");
	return ret;
}


#endif	/* _CRYPTO_ARCH_S390_CRYPT_S390_H */
Commit	Line	Data
1da177e4 LT	1	/*
	2	* Cryptographic API.
	3	*
c1e26e1e	4	* Support for s390 cryptographic instructions.
1da177e4	5	*
86aa9fc2 JG	6	* Copyright IBM Corp. 2003,2007
	7	* Author(s): Thomas Spatzier
	8	* Jan Glauber (jan.glauber@de.ibm.com)
1da177e4 LT	9	*
	10	* This program is free software; you can redistribute it and/or modify it
	11	* under the terms of the GNU General Public License as published by the Free
	12	* Software Foundation; either version 2 of the License, or (at your option)
	13	* any later version.
	14	*
	15	*/
c1e26e1e JG	16	#ifndef _CRYPTO_ARCH_S390_CRYPT_S390_H
c1e26e1e JG	17	#define _CRYPTO_ARCH_S390_CRYPT_S390_H
1da177e4 LT	18
	19	#include <asm/errno.h>
	20
c1e26e1e JG	21	#define CRYPT_S390_OP_MASK 0xFF00
c1e26e1e JG	22	#define CRYPT_S390_FUNC_MASK 0x00FF
1da177e4	23
65b75c36	24	#define CRYPT_S390_PRIORITY 300
a9e62fad	25	#define CRYPT_S390_COMPOSITE_PRIORITY 400
65b75c36	26
1822bc90 JG	27	#define CRYPT_S390_MSA 0x1
	28	#define CRYPT_S390_MSA3 0x2
	29	#define CRYPT_S390_MSA4 0x4
	30
bccdbdc9	31	/* s390 cryptographic operations */
c1e26e1e JG	32	enum crypt_s390_operations {
	33	CRYPT_S390_KM = 0x0100,
	34	CRYPT_S390_KMC = 0x0200,
	35	CRYPT_S390_KIMD = 0x0300,
	36	CRYPT_S390_KLMD = 0x0400,
	37	CRYPT_S390_KMAC = 0x0500
1da177e4 LT	38	};
1da177e4 LT	39
86aa9fc2 JG	40	/*
86aa9fc2 JG	41	* function codes for KM (CIPHER MESSAGE) instruction
c1e26e1e JG	42	* 0x80 is the decipher modifier bit
	43	*/
	44	enum crypt_s390_km_func {
bf754ae8 JG	45	KM_QUERY = CRYPT_S390_KM \| 0x0,
	46	KM_DEA_ENCRYPT = CRYPT_S390_KM \| 0x1,
	47	KM_DEA_DECRYPT = CRYPT_S390_KM \| 0x1 \| 0x80,
	48	KM_TDEA_128_ENCRYPT = CRYPT_S390_KM \| 0x2,
	49	KM_TDEA_128_DECRYPT = CRYPT_S390_KM \| 0x2 \| 0x80,
	50	KM_TDEA_192_ENCRYPT = CRYPT_S390_KM \| 0x3,
	51	KM_TDEA_192_DECRYPT = CRYPT_S390_KM \| 0x3 \| 0x80,
	52	KM_AES_128_ENCRYPT = CRYPT_S390_KM \| 0x12,
	53	KM_AES_128_DECRYPT = CRYPT_S390_KM \| 0x12 \| 0x80,
	54	KM_AES_192_ENCRYPT = CRYPT_S390_KM \| 0x13,
	55	KM_AES_192_DECRYPT = CRYPT_S390_KM \| 0x13 \| 0x80,
	56	KM_AES_256_ENCRYPT = CRYPT_S390_KM \| 0x14,
	57	KM_AES_256_DECRYPT = CRYPT_S390_KM \| 0x14 \| 0x80,
99d97222 GS	58	KM_XTS_128_ENCRYPT = CRYPT_S390_KM \| 0x32,
	59	KM_XTS_128_DECRYPT = CRYPT_S390_KM \| 0x32 \| 0x80,
	60	KM_XTS_256_ENCRYPT = CRYPT_S390_KM \| 0x34,
	61	KM_XTS_256_DECRYPT = CRYPT_S390_KM \| 0x34 \| 0x80,
1da177e4 LT	62	};
1da177e4 LT	63
86aa9fc2 JG	64	/*
86aa9fc2 JG	65	* function codes for KMC (CIPHER MESSAGE WITH CHAINING)
c1e26e1e JG	66	* instruction
	67	*/
	68	enum crypt_s390_kmc_func {
bf754ae8 JG	69	KMC_QUERY = CRYPT_S390_KMC \| 0x0,
	70	KMC_DEA_ENCRYPT = CRYPT_S390_KMC \| 0x1,
	71	KMC_DEA_DECRYPT = CRYPT_S390_KMC \| 0x1 \| 0x80,
	72	KMC_TDEA_128_ENCRYPT = CRYPT_S390_KMC \| 0x2,
	73	KMC_TDEA_128_DECRYPT = CRYPT_S390_KMC \| 0x2 \| 0x80,
	74	KMC_TDEA_192_ENCRYPT = CRYPT_S390_KMC \| 0x3,
	75	KMC_TDEA_192_DECRYPT = CRYPT_S390_KMC \| 0x3 \| 0x80,
	76	KMC_AES_128_ENCRYPT = CRYPT_S390_KMC \| 0x12,
	77	KMC_AES_128_DECRYPT = CRYPT_S390_KMC \| 0x12 \| 0x80,
	78	KMC_AES_192_ENCRYPT = CRYPT_S390_KMC \| 0x13,
	79	KMC_AES_192_DECRYPT = CRYPT_S390_KMC \| 0x13 \| 0x80,
	80	KMC_AES_256_ENCRYPT = CRYPT_S390_KMC \| 0x14,
	81	KMC_AES_256_DECRYPT = CRYPT_S390_KMC \| 0x14 \| 0x80,
1b278294	82	KMC_PRNG = CRYPT_S390_KMC \| 0x43,
1da177e4 LT	83	};
1da177e4 LT	84
86aa9fc2 JG	85	/*
86aa9fc2 JG	86	* function codes for KIMD (COMPUTE INTERMEDIATE MESSAGE DIGEST)
c1e26e1e JG	87	* instruction
	88	*/
	89	enum crypt_s390_kimd_func {
	90	KIMD_QUERY = CRYPT_S390_KIMD \| 0,
	91	KIMD_SHA_1 = CRYPT_S390_KIMD \| 1,
0a497c17	92	KIMD_SHA_256 = CRYPT_S390_KIMD \| 2,
291dc7c0	93	KIMD_SHA_512 = CRYPT_S390_KIMD \| 3,
df1309ce	94	KIMD_GHASH = CRYPT_S390_KIMD \| 65,
1da177e4 LT	95	};
1da177e4 LT	96
86aa9fc2 JG	97	/*
86aa9fc2 JG	98	* function codes for KLMD (COMPUTE LAST MESSAGE DIGEST)
c1e26e1e JG	99	* instruction
	100	*/
	101	enum crypt_s390_klmd_func {
	102	KLMD_QUERY = CRYPT_S390_KLMD \| 0,
	103	KLMD_SHA_1 = CRYPT_S390_KLMD \| 1,
0a497c17	104	KLMD_SHA_256 = CRYPT_S390_KLMD \| 2,
291dc7c0	105	KLMD_SHA_512 = CRYPT_S390_KLMD \| 3,
1da177e4 LT	106	};
1da177e4 LT	107
86aa9fc2 JG	108	/*
86aa9fc2 JG	109	* function codes for KMAC (COMPUTE MESSAGE AUTHENTICATION CODE)
c1e26e1e JG	110	* instruction
	111	*/
	112	enum crypt_s390_kmac_func {
	113	KMAC_QUERY = CRYPT_S390_KMAC \| 0,
	114	KMAC_DEA = CRYPT_S390_KMAC \| 1,
	115	KMAC_TDEA_128 = CRYPT_S390_KMAC \| 2,
	116	KMAC_TDEA_192 = CRYPT_S390_KMAC \| 3
1da177e4 LT	117	};
1da177e4 LT	118
86aa9fc2 JG	119	/**
	120	* crypt_s390_km:
	121	* @func: the function code passed to KM; see crypt_s390_km_func
	122	* @param: address of parameter block; see POP for details on each func
	123	* @dest: address of destination memory area
	124	* @src: address of source memory area
	125	* @src_len: length of src operand in bytes
	126	*
c1e26e1e	127	* Executes the KM (CIPHER MESSAGE) operation of the CPU.
86aa9fc2 JG	128	*
	129	* Returns -1 for failure, 0 for the query func, number of processed
	130	* bytes for encryption/decryption funcs
1da177e4	131	*/
86aa9fc2 JG	132	static inline int crypt_s390_km(long func, void *param,
86aa9fc2 JG	133	u8 dest, const u8 src, long src_len)
1da177e4	134	{
c1e26e1e	135	register long __func asm("0") = func & CRYPT_S390_FUNC_MASK;
86aa9fc2 JG	136	register void *__param asm("1") = param;
86aa9fc2 JG	137	register const u8 *__src asm("2") = src;
1da177e4	138	register long __src_len asm("3") = src_len;
86aa9fc2	139	register u8 *__dest asm("4") = dest;
1da177e4 LT	140	int ret;
1da177e4 LT	141
94c12cc7 MS	142	asm volatile(
94c12cc7 MS	143	"0: .insn rre,0xb92e0000,%3,%1 \n" /* KM opcode */
c1e26e1e	144	"1: brc 1,0b \n" /* handle partial completion */
86aa9fc2 JG	145	" la %0,0\n"
	146	"2:\n"
	147	EX_TABLE(0b,2b) EX_TABLE(1b,2b)
94c12cc7	148	: "=d" (ret), "+a" (__src), "+d" (__src_len), "+a" (__dest)
86aa9fc2	149	: "d" (__func), "a" (__param), "0" (-1) : "cc", "memory");
94c12cc7 MS	150	if (ret < 0)
	151	return ret;
	152	return (func & CRYPT_S390_FUNC_MASK) ? src_len - __src_len : __src_len;
1da177e4 LT	153	}
1da177e4 LT	154
86aa9fc2 JG	155	/**
	156	* crypt_s390_kmc:
	157	* @func: the function code passed to KM; see crypt_s390_kmc_func
	158	* @param: address of parameter block; see POP for details on each func
	159	* @dest: address of destination memory area
	160	* @src: address of source memory area
	161	* @src_len: length of src operand in bytes
	162	*
c1e26e1e	163	* Executes the KMC (CIPHER MESSAGE WITH CHAINING) operation of the CPU.
86aa9fc2 JG	164	*
	165	* Returns -1 for failure, 0 for the query func, number of processed
	166	* bytes for encryption/decryption funcs
1da177e4	167	*/
86aa9fc2 JG	168	static inline int crypt_s390_kmc(long func, void *param,
86aa9fc2 JG	169	u8 dest, const u8 src, long src_len)
1da177e4	170	{
c1e26e1e	171	register long __func asm("0") = func & CRYPT_S390_FUNC_MASK;
86aa9fc2 JG	172	register void *__param asm("1") = param;
86aa9fc2 JG	173	register const u8 *__src asm("2") = src;
1da177e4	174	register long __src_len asm("3") = src_len;
86aa9fc2	175	register u8 *__dest asm("4") = dest;
1da177e4 LT	176	int ret;
1da177e4 LT	177
94c12cc7 MS	178	asm volatile(
94c12cc7 MS	179	"0: .insn rre,0xb92f0000,%3,%1 \n" /* KMC opcode */
c1e26e1e	180	"1: brc 1,0b \n" /* handle partial completion */
86aa9fc2 JG	181	" la %0,0\n"
	182	"2:\n"
	183	EX_TABLE(0b,2b) EX_TABLE(1b,2b)
94c12cc7	184	: "=d" (ret), "+a" (__src), "+d" (__src_len), "+a" (__dest)
86aa9fc2	185	: "d" (__func), "a" (__param), "0" (-1) : "cc", "memory");
94c12cc7 MS	186	if (ret < 0)
	187	return ret;
	188	return (func & CRYPT_S390_FUNC_MASK) ? src_len - __src_len : __src_len;
1da177e4 LT	189	}
1da177e4 LT	190
86aa9fc2 JG	191	/**
	192	* crypt_s390_kimd:
	193	* @func: the function code passed to KM; see crypt_s390_kimd_func
	194	* @param: address of parameter block; see POP for details on each func
	195	* @src: address of source memory area
	196	* @src_len: length of src operand in bytes
	197	*
1da177e4	198	* Executes the KIMD (COMPUTE INTERMEDIATE MESSAGE DIGEST) operation
c1e26e1e	199	* of the CPU.
86aa9fc2 JG	200	*
	201	* Returns -1 for failure, 0 for the query func, number of processed
	202	* bytes for digest funcs
1da177e4	203	*/
86aa9fc2 JG	204	static inline int crypt_s390_kimd(long func, void *param,
86aa9fc2 JG	205	const u8 *src, long src_len)
1da177e4	206	{
c1e26e1e	207	register long __func asm("0") = func & CRYPT_S390_FUNC_MASK;
86aa9fc2 JG	208	register void *__param asm("1") = param;
86aa9fc2 JG	209	register const u8 *__src asm("2") = src;
1da177e4 LT	210	register long __src_len asm("3") = src_len;
	211	int ret;
	212
94c12cc7 MS	213	asm volatile(
	214	"0: .insn rre,0xb93e0000,%1,%1 \n" /* KIMD opcode */
	215	"1: brc 1,0b \n" /* handle partial completion */
86aa9fc2 JG	216	" la %0,0\n"
	217	"2:\n"
	218	EX_TABLE(0b,2b) EX_TABLE(1b,2b)
94c12cc7	219	: "=d" (ret), "+a" (__src), "+d" (__src_len)
86aa9fc2	220	: "d" (__func), "a" (__param), "0" (-1) : "cc", "memory");
94c12cc7 MS	221	if (ret < 0)
	222	return ret;
	223	return (func & CRYPT_S390_FUNC_MASK) ? src_len - __src_len : __src_len;
1da177e4 LT	224	}
1da177e4 LT	225
86aa9fc2 JG	226	/**
	227	* crypt_s390_klmd:
	228	* @func: the function code passed to KM; see crypt_s390_klmd_func
	229	* @param: address of parameter block; see POP for details on each func
	230	* @src: address of source memory area
	231	* @src_len: length of src operand in bytes
	232	*
c1e26e1e	233	* Executes the KLMD (COMPUTE LAST MESSAGE DIGEST) operation of the CPU.
86aa9fc2 JG	234	*
	235	* Returns -1 for failure, 0 for the query func, number of processed
	236	* bytes for digest funcs
1da177e4	237	*/
86aa9fc2 JG	238	static inline int crypt_s390_klmd(long func, void *param,
86aa9fc2 JG	239	const u8 *src, long src_len)
1da177e4	240	{
c1e26e1e	241	register long __func asm("0") = func & CRYPT_S390_FUNC_MASK;
86aa9fc2 JG	242	register void *__param asm("1") = param;
86aa9fc2 JG	243	register const u8 *__src asm("2") = src;
1da177e4 LT	244	register long __src_len asm("3") = src_len;
	245	int ret;
	246
94c12cc7 MS	247	asm volatile(
	248	"0: .insn rre,0xb93f0000,%1,%1 \n" /* KLMD opcode */
	249	"1: brc 1,0b \n" /* handle partial completion */
86aa9fc2 JG	250	" la %0,0\n"
	251	"2:\n"
	252	EX_TABLE(0b,2b) EX_TABLE(1b,2b)
94c12cc7	253	: "=d" (ret), "+a" (__src), "+d" (__src_len)
86aa9fc2	254	: "d" (__func), "a" (__param), "0" (-1) : "cc", "memory");
94c12cc7 MS	255	if (ret < 0)
	256	return ret;
	257	return (func & CRYPT_S390_FUNC_MASK) ? src_len - __src_len : __src_len;
1da177e4 LT	258	}
1da177e4 LT	259
86aa9fc2 JG	260	/**
	261	* crypt_s390_kmac:
	262	* @func: the function code passed to KM; see crypt_s390_klmd_func
	263	* @param: address of parameter block; see POP for details on each func
	264	* @src: address of source memory area
	265	* @src_len: length of src operand in bytes
	266	*
1da177e4	267	* Executes the KMAC (COMPUTE MESSAGE AUTHENTICATION CODE) operation
c1e26e1e	268	* of the CPU.
86aa9fc2 JG	269	*
	270	* Returns -1 for failure, 0 for the query func, number of processed
	271	* bytes for digest funcs
1da177e4	272	*/
86aa9fc2 JG	273	static inline int crypt_s390_kmac(long func, void *param,
86aa9fc2 JG	274	const u8 *src, long src_len)
1da177e4	275	{
c1e26e1e	276	register long __func asm("0") = func & CRYPT_S390_FUNC_MASK;
86aa9fc2 JG	277	register void *__param asm("1") = param;
86aa9fc2 JG	278	register const u8 *__src asm("2") = src;
1da177e4 LT	279	register long __src_len asm("3") = src_len;
	280	int ret;
	281
94c12cc7 MS	282	asm volatile(
	283	"0: .insn rre,0xb91e0000,%1,%1 \n" /* KLAC opcode */
	284	"1: brc 1,0b \n" /* handle partial completion */
86aa9fc2 JG	285	" la %0,0\n"
	286	"2:\n"
	287	EX_TABLE(0b,2b) EX_TABLE(1b,2b)
94c12cc7	288	: "=d" (ret), "+a" (__src), "+d" (__src_len)
86aa9fc2	289	: "d" (__func), "a" (__param), "0" (-1) : "cc", "memory");
94c12cc7 MS	290	if (ret < 0)
	291	return ret;
	292	return (func & CRYPT_S390_FUNC_MASK) ? src_len - __src_len : __src_len;
1da177e4 LT	293	}
	294
	295	/**
86aa9fc2 JG	296	* crypt_s390_func_available:
	297	* @func: the function code of the specific function; 0 if op in general
	298	*
c1e26e1e	299	* Tests if a specific crypto function is implemented on the machine.
86aa9fc2 JG	300	*
86aa9fc2 JG	301	* Returns 1 if func available; 0 if func or op in general not available
1da177e4	302	*/
1822bc90 JG	303	static inline int crypt_s390_func_available(int func,
1822bc90 JG	304	unsigned int facility_mask)
1da177e4	305	{
86aa9fc2	306	unsigned char status[16];
1da177e4 LT	307	int ret;
1da177e4 LT	308
1822bc90 JG	309	if (facility_mask & CRYPT_S390_MSA && !test_facility(17))
	310	return 0;
	311	if (facility_mask & CRYPT_S390_MSA3 && !test_facility(76))
	312	return 0;
	313	if (facility_mask & CRYPT_S390_MSA4 && !test_facility(77))
a72f0dbf JG	314	return 0;
a72f0dbf JG	315
86aa9fc2 JG	316	switch (func & CRYPT_S390_OP_MASK) {
	317	case CRYPT_S390_KM:
	318	ret = crypt_s390_km(KM_QUERY, &status, NULL, NULL, 0);
	319	break;
	320	case CRYPT_S390_KMC:
	321	ret = crypt_s390_kmc(KMC_QUERY, &status, NULL, NULL, 0);
	322	break;
	323	case CRYPT_S390_KIMD:
	324	ret = crypt_s390_kimd(KIMD_QUERY, &status, NULL, 0);
	325	break;
	326	case CRYPT_S390_KLMD:
	327	ret = crypt_s390_klmd(KLMD_QUERY, &status, NULL, 0);
	328	break;
	329	case CRYPT_S390_KMAC:
	330	ret = crypt_s390_kmac(KMAC_QUERY, &status, NULL, 0);
	331	break;
	332	default:
	333	return 0;
1da177e4	334	}
86aa9fc2 JG	335	if (ret < 0)
	336	return 0;
	337	func &= CRYPT_S390_FUNC_MASK;
	338	func &= 0x7f; /* mask modifier bit */
	339	return (status[func >> 3] & (0x80 >> (func & 7))) != 0;
1da177e4 LT	340	}
1da177e4 LT	341
99d97222 GS	342	/**
	343	* crypt_s390_pcc:
	344	* @func: the function code passed to KM; see crypt_s390_km_func
	345	* @param: address of parameter block; see POP for details on each func
	346	*
	347	* Executes the PCC (PERFORM CRYPTOGRAPHIC COMPUTATION) operation of the CPU.
	348	*
	349	* Returns -1 for failure, 0 for success.
	350	*/
	351	static inline int crypt_s390_pcc(long func, void *param)
	352	{
	353	register long __func asm("0") = func & 0x7f; /* encrypt or decrypt */
	354	register void *__param asm("1") = param;
	355	int ret = -1;
	356
	357	asm volatile(
	358	"0: .insn rre,0xb92c0000,0,0 \n" /* PCC opcode */
	359	"1: brc 1,0b \n" /* handle partial completion */
	360	" la %0,0\n"
	361	"2:\n"
	362	EX_TABLE(0b,2b) EX_TABLE(1b,2b)
	363	: "+d" (ret)
	364	: "d" (__func), "a" (__param) : "cc", "memory");
	365	return ret;
	366	}
	367
	368
86aa9fc2	369	#endif /* _CRYPTO_ARCH_S390_CRYPT_S390_H */