URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [arch/] [s390/] [crypto/] [crypt_s390.h] - Blame information for rev 63

Details | Compare with Previous | View Log


/*
 * 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
 
/* 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,
};
 
/*
 * 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,
};
 
/*
 * 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
};
 
/**
 * 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 char status[16];
        int ret;
 
        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;
}
 
#endif  /* _CRYPTO_ARCH_S390_CRYPT_S390_H */

Browse

Tools

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [arch/] [s390/] [crypto/] [crypt_s390.h] - Blame information for rev 63

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