[PATCH] s390: sha256 support
[linux-2.6.git] / arch / s390 / crypto / crypt_s390.h
1 /*
2  * Cryptographic API.
3  *
4  * Support for s390 cryptographic instructions.
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  */
15 #ifndef _CRYPTO_ARCH_S390_CRYPT_S390_H
16 #define _CRYPTO_ARCH_S390_CRYPT_S390_H
17
18 #include <asm/errno.h>
19
20 #define CRYPT_S390_OP_MASK 0xFF00
21 #define CRYPT_S390_FUNC_MASK 0x00FF
22
23 /* s930 cryptographic operations */
24 enum crypt_s390_operations {
25         CRYPT_S390_KM   = 0x0100,
26         CRYPT_S390_KMC  = 0x0200,
27         CRYPT_S390_KIMD = 0x0300,
28         CRYPT_S390_KLMD = 0x0400,
29         CRYPT_S390_KMAC = 0x0500
30 };
31
32 /* function codes for KM (CIPHER MESSAGE) instruction
33  * 0x80 is the decipher modifier bit
34  */
35 enum crypt_s390_km_func {
36         KM_QUERY            = CRYPT_S390_KM | 0,
37         KM_DEA_ENCRYPT      = CRYPT_S390_KM | 1,
38         KM_DEA_DECRYPT      = CRYPT_S390_KM | 1 | 0x80,
39         KM_TDEA_128_ENCRYPT = CRYPT_S390_KM | 2,
40         KM_TDEA_128_DECRYPT = CRYPT_S390_KM | 2 | 0x80,
41         KM_TDEA_192_ENCRYPT = CRYPT_S390_KM | 3,
42         KM_TDEA_192_DECRYPT = CRYPT_S390_KM | 3 | 0x80,
43 };
44
45 /* function codes for KMC (CIPHER MESSAGE WITH CHAINING)
46  * instruction
47  */
48 enum crypt_s390_kmc_func {
49         KMC_QUERY            = CRYPT_S390_KMC | 0,
50         KMC_DEA_ENCRYPT      = CRYPT_S390_KMC | 1,
51         KMC_DEA_DECRYPT      = CRYPT_S390_KMC | 1 | 0x80,
52         KMC_TDEA_128_ENCRYPT = CRYPT_S390_KMC | 2,
53         KMC_TDEA_128_DECRYPT = CRYPT_S390_KMC | 2 | 0x80,
54         KMC_TDEA_192_ENCRYPT = CRYPT_S390_KMC | 3,
55         KMC_TDEA_192_DECRYPT = CRYPT_S390_KMC | 3 | 0x80,
56 };
57
58 /* function codes for KIMD (COMPUTE INTERMEDIATE MESSAGE DIGEST)
59  * instruction
60  */
61 enum crypt_s390_kimd_func {
62         KIMD_QUERY   = CRYPT_S390_KIMD | 0,
63         KIMD_SHA_1   = CRYPT_S390_KIMD | 1,
64         KIMD_SHA_256 = CRYPT_S390_KIMD | 2,
65 };
66
67 /* function codes for KLMD (COMPUTE LAST MESSAGE DIGEST)
68  * instruction
69  */
70 enum crypt_s390_klmd_func {
71         KLMD_QUERY   = CRYPT_S390_KLMD | 0,
72         KLMD_SHA_1   = CRYPT_S390_KLMD | 1,
73         KLMD_SHA_256 = CRYPT_S390_KLMD | 2,
74 };
75
76 /* function codes for KMAC (COMPUTE MESSAGE AUTHENTICATION CODE)
77  * instruction
78  */
79 enum crypt_s390_kmac_func {
80         KMAC_QUERY    = CRYPT_S390_KMAC | 0,
81         KMAC_DEA      = CRYPT_S390_KMAC | 1,
82         KMAC_TDEA_128 = CRYPT_S390_KMAC | 2,
83         KMAC_TDEA_192 = CRYPT_S390_KMAC | 3
84 };
85
86 /* status word for s390 crypto instructions' QUERY functions */
87 struct crypt_s390_query_status {
88         u64 high;
89         u64 low;
90 };
91
92 /*
93  * Standard fixup and ex_table sections for crypt_s390 inline functions.
94  * label 0: the s390 crypto operation
95  * label 1: just after 1 to catch illegal operation exception
96  *          (unsupported model)
97  * label 6: the return point after fixup
98  * label 7: set error value if exception _in_ crypto operation
99  * label 8: set error value if illegal operation exception
100  * [ret] is the variable to receive the error code
101  * [ERR] is the error code value
102  */
103 #ifndef __s390x__
104 #define __crypt_s390_fixup \
105         ".section .fixup,\"ax\" \n"     \
106         "7:     lhi     %0,%h[e1] \n"   \
107         "       bras    1,9f \n"        \
108         "       .long   6b \n"          \
109         "8:     lhi     %0,%h[e2] \n"   \
110         "       bras    1,9f \n"        \
111         "       .long   6b \n"          \
112         "9:     l       1,0(1) \n"      \
113         "       br      1 \n"           \
114         ".previous \n"                  \
115         ".section __ex_table,\"a\" \n"  \
116         "       .align  4 \n"           \
117         "       .long   0b,7b \n"       \
118         "       .long   1b,8b \n"       \
119         ".previous"
120 #else /* __s390x__ */
121 #define __crypt_s390_fixup \
122         ".section .fixup,\"ax\" \n"     \
123         "7:     lhi     %0,%h[e1] \n"   \
124         "       jg      6b \n"          \
125         "8:     lhi     %0,%h[e2] \n"   \
126         "       jg      6b \n"          \
127         ".previous\n"                   \
128         ".section __ex_table,\"a\" \n"  \
129         "       .align  8 \n"           \
130         "       .quad   0b,7b \n"       \
131         "       .quad   1b,8b \n"       \
132         ".previous"
133 #endif /* __s390x__ */
134
135 /*
136  * Standard code for setting the result of s390 crypto instructions.
137  * %0: the register which will receive the result
138  * [result]: the register containing the result (e.g. second operand length
139  * to compute number of processed bytes].
140  */
141 #ifndef __s390x__
142 #define __crypt_s390_set_result \
143         "       lr      %0,%[result] \n"
144 #else /* __s390x__ */
145 #define __crypt_s390_set_result \
146         "       lgr     %0,%[result] \n"
147 #endif
148
149 /*
150  * Executes the KM (CIPHER MESSAGE) operation of the CPU.
151  * @param func: the function code passed to KM; see crypt_s390_km_func
152  * @param param: address of parameter block; see POP for details on each func
153  * @param dest: address of destination memory area
154  * @param src: address of source memory area
155  * @param src_len: length of src operand in bytes
156  * @returns < zero for failure, 0 for the query func, number of processed bytes
157  *      for encryption/decryption funcs
158  */
159 static inline int
160 crypt_s390_km(long func, void* param, u8* dest, const u8* src, long src_len)
161 {
162         register long __func asm("0") = func & CRYPT_S390_FUNC_MASK;
163         register void* __param asm("1") = param;
164         register u8* __dest asm("4") = dest;
165         register const u8* __src asm("2") = src;
166         register long __src_len asm("3") = src_len;
167         int ret;
168
169         ret = 0;
170         __asm__ __volatile__ (
171                 "0:     .insn   rre,0xB92E0000,%1,%2 \n" /* KM opcode */
172                 "1:     brc     1,0b \n" /* handle partial completion */
173                 __crypt_s390_set_result
174                 "6:     \n"
175                 __crypt_s390_fixup
176                 : "+d" (ret), "+a" (__dest), "+a" (__src),
177                   [result] "+d" (__src_len)
178                 : [e1] "K" (-EFAULT), [e2] "K" (-ENOSYS), "d" (__func),
179                   "a" (__param)
180                 : "cc", "memory"
181         );
182         if (ret >= 0 && func & CRYPT_S390_FUNC_MASK){
183                 ret = src_len - ret;
184         }
185         return ret;
186 }
187
188 /*
189  * Executes the KMC (CIPHER MESSAGE WITH CHAINING) operation of the CPU.
190  * @param func: the function code passed to KM; see crypt_s390_kmc_func
191  * @param param: address of parameter block; see POP for details on each func
192  * @param dest: address of destination memory area
193  * @param src: address of source memory area
194  * @param src_len: length of src operand in bytes
195  * @returns < zero for failure, 0 for the query func, number of processed bytes
196  *      for encryption/decryption funcs
197  */
198 static inline int
199 crypt_s390_kmc(long func, void* param, u8* dest, const u8* src, long src_len)
200 {
201         register long __func asm("0") = func & CRYPT_S390_FUNC_MASK;
202         register void* __param asm("1") = param;
203         register u8* __dest asm("4") = dest;
204         register const u8* __src asm("2") = src;
205         register long __src_len asm("3") = src_len;
206         int ret;
207
208         ret = 0;
209         __asm__ __volatile__ (
210                 "0:     .insn   rre,0xB92F0000,%1,%2 \n" /* KMC opcode */
211                 "1:     brc     1,0b \n" /* handle partial completion */
212                 __crypt_s390_set_result
213                 "6:     \n"
214                 __crypt_s390_fixup
215                 : "+d" (ret), "+a" (__dest), "+a" (__src),
216                   [result] "+d" (__src_len)
217                 : [e1] "K" (-EFAULT), [e2] "K" (-ENOSYS), "d" (__func),
218                   "a" (__param)
219                 : "cc", "memory"
220         );
221         if (ret >= 0 && func & CRYPT_S390_FUNC_MASK){
222                 ret = src_len - ret;
223         }
224         return ret;
225 }
226
227 /*
228  * Executes the KIMD (COMPUTE INTERMEDIATE MESSAGE DIGEST) operation
229  * of the CPU.
230  * @param func: the function code passed to KM; see crypt_s390_kimd_func
231  * @param param: address of parameter block; see POP for details on each func
232  * @param src: address of source memory area
233  * @param src_len: length of src operand in bytes
234  * @returns < zero for failure, 0 for the query func, number of processed bytes
235  *      for digest funcs
236  */
237 static inline int
238 crypt_s390_kimd(long func, void* param, const u8* src, long src_len)
239 {
240         register long __func asm("0") = func & CRYPT_S390_FUNC_MASK;
241         register void* __param asm("1") = param;
242         register const u8* __src asm("2") = src;
243         register long __src_len asm("3") = src_len;
244         int ret;
245
246         ret = 0;
247         __asm__ __volatile__ (
248                 "0:     .insn   rre,0xB93E0000,%1,%1 \n" /* KIMD opcode */
249                 "1:     brc     1,0b \n" /* handle partical completion */
250                 __crypt_s390_set_result
251                 "6:     \n"
252                 __crypt_s390_fixup
253                 : "+d" (ret), "+a" (__src), [result] "+d" (__src_len)
254                 : [e1] "K" (-EFAULT), [e2] "K" (-ENOSYS), "d" (__func),
255                   "a" (__param)
256                 : "cc", "memory"
257         );
258         if (ret >= 0 && (func & CRYPT_S390_FUNC_MASK)){
259                 ret = src_len - ret;
260         }
261         return ret;
262 }
263
264 /*
265  * Executes the KLMD (COMPUTE LAST MESSAGE DIGEST) operation of the CPU.
266  * @param func: the function code passed to KM; see crypt_s390_klmd_func
267  * @param param: address of parameter block; see POP for details on each func
268  * @param src: address of source memory area
269  * @param src_len: length of src operand in bytes
270  * @returns < zero for failure, 0 for the query func, number of processed bytes
271  *      for digest funcs
272  */
273 static inline int
274 crypt_s390_klmd(long func, void* param, const u8* src, long src_len)
275 {
276         register long __func asm("0") = func & CRYPT_S390_FUNC_MASK;
277         register void* __param asm("1") = param;
278         register const u8* __src asm("2") = src;
279         register long __src_len asm("3") = src_len;
280         int ret;
281
282         ret = 0;
283         __asm__ __volatile__ (
284                 "0:     .insn   rre,0xB93F0000,%1,%1 \n" /* KLMD opcode */
285                 "1:     brc     1,0b \n" /* handle partical completion */
286                 __crypt_s390_set_result
287                 "6:     \n"
288                 __crypt_s390_fixup
289                 : "+d" (ret), "+a" (__src), [result] "+d" (__src_len)
290                 : [e1] "K" (-EFAULT), [e2] "K" (-ENOSYS), "d" (__func),
291                   "a" (__param)
292                 : "cc", "memory"
293         );
294         if (ret >= 0 && func & CRYPT_S390_FUNC_MASK){
295                 ret = src_len - ret;
296         }
297         return ret;
298 }
299
300 /*
301  * Executes the KMAC (COMPUTE MESSAGE AUTHENTICATION CODE) operation
302  * of the CPU.
303  * @param func: the function code passed to KM; see crypt_s390_klmd_func
304  * @param param: address of parameter block; see POP for details on each func
305  * @param src: address of source memory area
306  * @param src_len: length of src operand in bytes
307  * @returns < zero for failure, 0 for the query func, number of processed bytes
308  *      for digest funcs
309  */
310 static inline int
311 crypt_s390_kmac(long func, void* param, const u8* src, long src_len)
312 {
313         register long __func asm("0") = func & CRYPT_S390_FUNC_MASK;
314         register void* __param asm("1") = param;
315         register const u8* __src asm("2") = src;
316         register long __src_len asm("3") = src_len;
317         int ret;
318
319         ret = 0;
320         __asm__ __volatile__ (
321                 "0:     .insn   rre,0xB91E0000,%5,%5 \n" /* KMAC opcode */
322                 "1:     brc     1,0b \n" /* handle partical completion */
323                 __crypt_s390_set_result
324                 "6:     \n"
325                 __crypt_s390_fixup
326                 : "+d" (ret), "+a" (__src), [result] "+d" (__src_len)
327                 : [e1] "K" (-EFAULT), [e2] "K" (-ENOSYS), "d" (__func),
328                   "a" (__param)
329                 : "cc", "memory"
330         );
331         if (ret >= 0 && func & CRYPT_S390_FUNC_MASK){
332                 ret = src_len - ret;
333         }
334         return ret;
335 }
336
337 /**
338  * Tests if a specific crypto function is implemented on the machine.
339  * @param func: the function code of the specific function; 0 if op in general
340  * @return      1 if func available; 0 if func or op in general not available
341  */
342 static inline int
343 crypt_s390_func_available(int func)
344 {
345         int ret;
346
347         struct crypt_s390_query_status status = {
348                 .high = 0,
349                 .low = 0
350         };
351         switch (func & CRYPT_S390_OP_MASK){
352                 case CRYPT_S390_KM:
353                         ret = crypt_s390_km(KM_QUERY, &status, NULL, NULL, 0);
354                         break;
355                 case CRYPT_S390_KMC:
356                         ret = crypt_s390_kmc(KMC_QUERY, &status, NULL, NULL, 0);
357                         break;
358                 case CRYPT_S390_KIMD:
359                         ret = crypt_s390_kimd(KIMD_QUERY, &status, NULL, 0);
360                         break;
361                 case CRYPT_S390_KLMD:
362                         ret = crypt_s390_klmd(KLMD_QUERY, &status, NULL, 0);
363                         break;
364                 case CRYPT_S390_KMAC:
365                         ret = crypt_s390_kmac(KMAC_QUERY, &status, NULL, 0);
366                         break;
367                 default:
368                         ret = 0;
369                         return ret;
370         }
371         if (ret >= 0){
372                 func &= CRYPT_S390_FUNC_MASK;
373                 func &= 0x7f; //mask modifier bit
374                 if (func < 64){
375                         ret = (status.high >> (64 - func - 1)) & 0x1;
376                 } else {
377                         ret = (status.low >> (128 - func - 1)) & 0x1;
378                 }
379         } else {
380                 ret = 0;
381         }
382         return ret;
383 }
384
385 #endif // _CRYPTO_ARCH_S390_CRYPT_S390_H