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

/*
 * Cryptographic API.
 *
 * Support for s390 cryptographic instructions.
 *
 *   Copyright (C) 2003 IBM Deutschland GmbH, IBM Corporation
 *   Author(s): Thomas Spatzier (tspat@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

/* s930 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,
};

/* 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,
};

/* 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,
};

/* 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,
};

/* 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
};

/* status word for s390 crypto instructions' QUERY functions */
struct crypt_s390_query_status {
	u64 high;
	u64 low;
};

/*
 * Executes the KM (CIPHER MESSAGE) operation of the CPU.
 * @param func: the function code passed to KM; see crypt_s390_km_func
 * @param param: address of parameter block; see POP for details on each func
 * @param dest: address of destination memory area
 * @param src: address of source memory area
 * @param src_len: length of src operand in bytes
 * @returns < zero 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 */
		"	ahi	%0,%h7\n"
		"2:	ahi	%0,%h8\n"
		"3:\n"
		EX_TABLE(0b,3b) EX_TABLE(1b,2b)
		: "=d" (ret), "+a" (__src), "+d" (__src_len), "+a" (__dest)
		: "d" (__func), "a" (__param), "0" (-EFAULT),
		  "K" (ENOSYS), "K" (-ENOSYS + EFAULT) : "cc", "memory");
	if (ret < 0)
		return ret;
	return (func & CRYPT_S390_FUNC_MASK) ? src_len - __src_len : __src_len;
}

/*
 * Executes the KMC (CIPHER MESSAGE WITH CHAINING) operation of the CPU.
 * @param func: the function code passed to KM; see crypt_s390_kmc_func
 * @param param: address of parameter block; see POP for details on each func
 * @param dest: address of destination memory area
 * @param src: address of source memory area
 * @param src_len: length of src operand in bytes
 * @returns < zero 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 */
		"	ahi	%0,%h7\n"
		"2:	ahi	%0,%h8\n"
		"3:\n"
		EX_TABLE(0b,3b) EX_TABLE(1b,2b)
		: "=d" (ret), "+a" (__src), "+d" (__src_len), "+a" (__dest)
		: "d" (__func), "a" (__param), "0" (-EFAULT),
		  "K" (ENOSYS), "K" (-ENOSYS + EFAULT) : "cc", "memory");
	if (ret < 0)
		return ret;
	return (func & CRYPT_S390_FUNC_MASK) ? src_len - __src_len : __src_len;
}

/*
 * Executes the KIMD (COMPUTE INTERMEDIATE MESSAGE DIGEST) operation
 * of the CPU.
 * @param func: the function code passed to KM; see crypt_s390_kimd_func
 * @param param: address of parameter block; see POP for details on each func
 * @param src: address of source memory area
 * @param src_len: length of src operand in bytes
 * @returns < zero 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 */
		"	ahi	%0,%h6\n"
		"2:	ahi	%0,%h7\n"
		"3:\n"
		EX_TABLE(0b,3b) EX_TABLE(1b,2b)
		: "=d" (ret), "+a" (__src), "+d" (__src_len)
		: "d" (__func), "a" (__param), "0" (-EFAULT),
		  "K" (ENOSYS), "K" (-ENOSYS + EFAULT) : "cc", "memory");
	if (ret < 0)
		return ret;
	return (func & CRYPT_S390_FUNC_MASK) ? src_len - __src_len : __src_len;
}

/*
 * Executes the KLMD (COMPUTE LAST MESSAGE DIGEST) operation of the CPU.
 * @param func: the function code passed to KM; see crypt_s390_klmd_func
 * @param param: address of parameter block; see POP for details on each func
 * @param src: address of source memory area
 * @param src_len: length of src operand in bytes
 * @returns < zero 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 */
		"	ahi	%0,%h6\n"
		"2:	ahi	%0,%h7\n"
		"3:\n"
		EX_TABLE(0b,3b) EX_TABLE(1b,2b)
		: "=d" (ret), "+a" (__src), "+d" (__src_len)
		: "d" (__func), "a" (__param), "0" (-EFAULT),
		  "K" (ENOSYS), "K" (-ENOSYS + EFAULT) : "cc", "memory");
	if (ret < 0)
		return ret;
	return (func & CRYPT_S390_FUNC_MASK) ? src_len - __src_len : __src_len;
}

/*
 * Executes the KMAC (COMPUTE MESSAGE AUTHENTICATION CODE) operation
 * of the CPU.
 * @param func: the function code passed to KM; see crypt_s390_klmd_func
 * @param param: address of parameter block; see POP for details on each func
 * @param src: address of source memory area
 * @param src_len: length of src operand in bytes
 * @returns < zero 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 */
		"	ahi	%0,%h6\n"
		"2:	ahi	%0,%h7\n"
		"3:\n"
		EX_TABLE(0b,3b) EX_TABLE(1b,2b)
		: "=d" (ret), "+a" (__src), "+d" (__src_len)
		: "d" (__func), "a" (__param), "0" (-EFAULT),
		  "K" (ENOSYS), "K" (-ENOSYS + EFAULT) : "cc", "memory");
	if (ret < 0)
		return ret;
	return (func & CRYPT_S390_FUNC_MASK) ? src_len - __src_len : __src_len;
}

/**
 * Tests if a specific crypto function is implemented on the machine.
 * @param func:	the function code of the specific function; 0 if op in general
 * @return	1 if func available; 0 if func or op in general not available
 */
static inline int
crypt_s390_func_available(int func)
{
	int ret;

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