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