[mirror_ubuntu-artful-kernel.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>
#include <asm/facility.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,
	CRYPT_S390_KMCTR = 0x0600
};

/*
 * 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 KMCTR (CIPHER MESSAGE WITH COUNTER)
 * instruction
 */
enum crypt_s390_kmctr_func {
	KMCTR_QUERY            = CRYPT_S390_KMCTR | 0x0,
	KMCTR_DEA_ENCRYPT      = CRYPT_S390_KMCTR | 0x1,
	KMCTR_DEA_DECRYPT      = CRYPT_S390_KMCTR | 0x1 | 0x80,
	KMCTR_TDEA_128_ENCRYPT = CRYPT_S390_KMCTR | 0x2,
	KMCTR_TDEA_128_DECRYPT = CRYPT_S390_KMCTR | 0x2 | 0x80,
	KMCTR_TDEA_192_ENCRYPT = CRYPT_S390_KMCTR | 0x3,
	KMCTR_TDEA_192_DECRYPT = CRYPT_S390_KMCTR | 0x3 | 0x80,
	KMCTR_AES_128_ENCRYPT  = CRYPT_S390_KMCTR | 0x12,
	KMCTR_AES_128_DECRYPT  = CRYPT_S390_KMCTR | 0x12 | 0x80,
	KMCTR_AES_192_ENCRYPT  = CRYPT_S390_KMCTR | 0x13,
	KMCTR_AES_192_DECRYPT  = CRYPT_S390_KMCTR | 0x13 | 0x80,
	KMCTR_AES_256_ENCRYPT  = CRYPT_S390_KMCTR | 0x14,
	KMCTR_AES_256_DECRYPT  = CRYPT_S390_KMCTR | 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,
	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_kmctr:
 * @func: the function code passed to KMCTR; see crypt_s390_kmctr_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
 * @counter: address of counter value
 *
 * Executes the KMCTR (CIPHER MESSAGE WITH COUNTER) 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_kmctr(long func, void *param, u8 *dest,
				 const u8 *src, long src_len, u8 *counter)
{
	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;
	register u8 *__ctr asm("6") = counter;
	int ret = -1;

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