release/src-rt-6.x.4708/linux/linux-2.6.36/arch/s390/crypto/crypt_s390.h

   1 /*
   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         KIMD_SHA_512 = CRYPT_S390_KIMD | 3,
  86 };
  87
  88 /*
  89  * function codes for KLMD (COMPUTE LAST MESSAGE DIGEST)
  90  * instruction
  91  */
  92 enum crypt_s390_klmd_func {
  93         KLMD_QUERY   = CRYPT_S390_KLMD | 0,
  94         KLMD_SHA_1   = CRYPT_S390_KLMD | 1,
  95         KLMD_SHA_256 = CRYPT_S390_KLMD | 2,
  96         KLMD_SHA_512 = CRYPT_S390_KLMD | 3,
  97 };
  98
  99 /*
 100  * function codes for KMAC (COMPUTE MESSAGE AUTHENTICATION CODE)
 101  * instruction
 102  */
 103 enum crypt_s390_kmac_func {
 104         KMAC_QUERY    = CRYPT_S390_KMAC | 0,
 105         KMAC_DEA      = CRYPT_S390_KMAC | 1,
 106         KMAC_TDEA_128 = CRYPT_S390_KMAC | 2,
 107         KMAC_TDEA_192 = CRYPT_S390_KMAC | 3
 108 };
 109
 110 /**
 111  * crypt_s390_km:
 112  * @func: the function code passed to KM; see crypt_s390_km_func
 113  * @param: address of parameter block; see POP for details on each func
 114  * @dest: address of destination memory area
 115  * @src: address of source memory area
 116  * @src_len: length of src operand in bytes
 117  *
 118  * Executes the KM (CIPHER MESSAGE) operation of the CPU.
 119  *
 120  * Returns -1 for failure, 0 for the query func, number of processed
 121  * bytes for encryption/decryption funcs
 122  */
 123 static inline int crypt_s390_km(long func, void *param,
 124                                 u8 *dest, const u8 *src, long src_len)
 125 {
 126         register long __func asm("0") = func & CRYPT_S390_FUNC_MASK;
 127         register void *__param asm("1") = param;
 128         register const u8 *__src asm("2") = src;
 129         register long __src_len asm("3") = src_len;
 130         register u8 *__dest asm("4") = dest;
 131         int ret;
 132
 133         asm volatile(
 134                 "0:     .insn   rre,0xb92e0000,%3,%1 \n" /* KM opcode */
 135                 "1:     brc     1,0b \n" /* handle partial completion */
 136                 "       la      %0,0\n"
 137                 "2:\n"
 138                 EX_TABLE(0b,2b) EX_TABLE(1b,2b)
 139                 : "=d" (ret), "+a" (__src), "+d" (__src_len), "+a" (__dest)
 140                 : "d" (__func), "a" (__param), "0" (-1) : "cc", "memory");
 141         if (ret < 0)
 142                 return ret;
 143         return (func & CRYPT_S390_FUNC_MASK) ? src_len - __src_len : __src_len;
 144 }
 145
 146 /**
 147  * crypt_s390_kmc:
 148  * @func: the function code passed to KM; see crypt_s390_kmc_func
 149  * @param: address of parameter block; see POP for details on each func
 150  * @dest: address of destination memory area
 151  * @src: address of source memory area
 152  * @src_len: length of src operand in bytes
 153  *
 154  * Executes the KMC (CIPHER MESSAGE WITH CHAINING) operation of the CPU.
 155  *
 156  * Returns -1 for failure, 0 for the query func, number of processed
 157  * bytes for encryption/decryption funcs
 158  */
 159 static inline int crypt_s390_kmc(long func, void *param,
 160                                  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 const u8 *__src asm("2") = src;
 165         register long __src_len asm("3") = src_len;
 166         register u8 *__dest asm("4") = dest;
 167         int ret;
 168
 169         asm volatile(
 170                 "0:     .insn   rre,0xb92f0000,%3,%1 \n" /* KMC opcode */
 171                 "1:     brc     1,0b \n" /* handle partial completion */
 172                 "       la      %0,0\n"
 173                 "2:\n"
 174                 EX_TABLE(0b,2b) EX_TABLE(1b,2b)
 175                 : "=d" (ret), "+a" (__src), "+d" (__src_len), "+a" (__dest)
 176                 : "d" (__func), "a" (__param), "0" (-1) : "cc", "memory");
 177         if (ret < 0)
 178                 return ret;
 179         return (func & CRYPT_S390_FUNC_MASK) ? src_len - __src_len : __src_len;
 180 }
 181
 182 /**
 183  * crypt_s390_kimd:
 184  * @func: the function code passed to KM; see crypt_s390_kimd_func
 185  * @param: address of parameter block; see POP for details on each func
 186  * @src: address of source memory area
 187  * @src_len: length of src operand in bytes
 188  *
 189  * Executes the KIMD (COMPUTE INTERMEDIATE MESSAGE DIGEST) operation
 190  * of the CPU.
 191  *
 192  * Returns -1 for failure, 0 for the query func, number of processed
 193  * bytes for digest funcs
 194  */
 195 static inline int crypt_s390_kimd(long func, void *param,
 196                                   const u8 *src, long src_len)
 197 {
 198         register long __func asm("0") = func & CRYPT_S390_FUNC_MASK;
 199         register void *__param asm("1") = param;
 200         register const u8 *__src asm("2") = src;
 201         register long __src_len asm("3") = src_len;
 202         int ret;
 203
 204         asm volatile(
 205                 "0:     .insn   rre,0xb93e0000,%1,%1 \n" /* KIMD opcode */
 206                 "1:     brc     1,0b \n" /* handle partial completion */
 207                 "       la      %0,0\n"
 208                 "2:\n"
 209                 EX_TABLE(0b,2b) EX_TABLE(1b,2b)
 210                 : "=d" (ret), "+a" (__src), "+d" (__src_len)
 211                 : "d" (__func), "a" (__param), "0" (-1) : "cc", "memory");
 212         if (ret < 0)
 213                 return ret;
 214         return (func & CRYPT_S390_FUNC_MASK) ? src_len - __src_len : __src_len;
 215 }
 216
 217 /**
 218  * crypt_s390_klmd:
 219  * @func: the function code passed to KM; see crypt_s390_klmd_func
 220  * @param: address of parameter block; see POP for details on each func
 221  * @src: address of source memory area
 222  * @src_len: length of src operand in bytes
 223  *
 224  * Executes the KLMD (COMPUTE LAST MESSAGE DIGEST) operation of the CPU.
 225  *
 226  * Returns -1 for failure, 0 for the query func, number of processed
 227  * bytes for digest funcs
 228  */
 229 static inline int crypt_s390_klmd(long func, void *param,
 230                                   const u8 *src, long src_len)
 231 {
 232         register long __func asm("0") = func & CRYPT_S390_FUNC_MASK;
 233         register void *__param asm("1") = param;
 234         register const u8 *__src asm("2") = src;
 235         register long __src_len asm("3") = src_len;
 236         int ret;
 237
 238         asm volatile(
 239                 "0:     .insn   rre,0xb93f0000,%1,%1 \n" /* KLMD opcode */
 240                 "1:     brc     1,0b \n" /* handle partial completion */
 241                 "       la      %0,0\n"
 242                 "2:\n"
 243                 EX_TABLE(0b,2b) EX_TABLE(1b,2b)
 244                 : "=d" (ret), "+a" (__src), "+d" (__src_len)
 245                 : "d" (__func), "a" (__param), "0" (-1) : "cc", "memory");
 246         if (ret < 0)
 247                 return ret;
 248         return (func & CRYPT_S390_FUNC_MASK) ? src_len - __src_len : __src_len;
 249 }
 250
 251 /**
 252  * crypt_s390_kmac:
 253  * @func: the function code passed to KM; see crypt_s390_klmd_func
 254  * @param: address of parameter block; see POP for details on each func
 255  * @src: address of source memory area
 256  * @src_len: length of src operand in bytes
 257  *
 258  * Executes the KMAC (COMPUTE MESSAGE AUTHENTICATION CODE) operation
 259  * of the CPU.
 260  *
 261  * Returns -1 for failure, 0 for the query func, number of processed
 262  * bytes for digest funcs
 263  */
 264 static inline int crypt_s390_kmac(long func, void *param,
 265                                   const u8 *src, long src_len)
 266 {
 267         register long __func asm("0") = func & CRYPT_S390_FUNC_MASK;
 268         register void *__param asm("1") = param;
 269         register const u8 *__src asm("2") = src;
 270         register long __src_len asm("3") = src_len;
 271         int ret;
 272
 273         asm volatile(
 274                 "0:     .insn   rre,0xb91e0000,%1,%1 \n" /* KLAC opcode */
 275                 "1:     brc     1,0b \n" /* handle partial completion */
 276                 "       la      %0,0\n"
 277                 "2:\n"
 278                 EX_TABLE(0b,2b) EX_TABLE(1b,2b)
 279                 : "=d" (ret), "+a" (__src), "+d" (__src_len)
 280                 : "d" (__func), "a" (__param), "0" (-1) : "cc", "memory");
 281         if (ret < 0)
 282                 return ret;
 283         return (func & CRYPT_S390_FUNC_MASK) ? src_len - __src_len : __src_len;
 284 }
 285
 286 /**
 287  * crypt_s390_func_available:
 288  * @func: the function code of the specific function; 0 if op in general
 289  *
 290  * Tests if a specific crypto function is implemented on the machine.
 291  *
 292  * Returns 1 if func available; 0 if func or op in general not available
 293  */
 294 static inline int crypt_s390_func_available(int func)
 295 {
 296         unsigned char status[16];
 297         int ret;
 298
 299         /* check if CPACF facility (bit 17) is available */
 300         if (!(stfl() & 1ULL << (31 - 17)))
 301                 return 0;
 302
 303         switch (func & CRYPT_S390_OP_MASK) {
 304         case CRYPT_S390_KM:
 305                 ret = crypt_s390_km(KM_QUERY, &status, NULL, NULL, 0);
 306                 break;
 307         case CRYPT_S390_KMC:
 308                 ret = crypt_s390_kmc(KMC_QUERY, &status, NULL, NULL, 0);
 309                 break;
 310         case CRYPT_S390_KIMD:
 311                 ret = crypt_s390_kimd(KIMD_QUERY, &status, NULL, 0);
 312                 break;
 313         case CRYPT_S390_KLMD:
 314                 ret = crypt_s390_klmd(KLMD_QUERY, &status, NULL, 0);
 315                 break;
 316         case CRYPT_S390_KMAC:
 317                 ret = crypt_s390_kmac(KMAC_QUERY, &status, NULL, 0);
 318                 break;
 319         default:
 320                 return 0;
 321         }
 322         if (ret < 0)
 323                 return 0;
 324         func &= CRYPT_S390_FUNC_MASK;
 325         func &= 0x7f;           /* mask modifier bit */
 326         return (status[func >> 3] & (0x80 >> (func & 7))) != 0;
 327 }
 328
 329 #endif  /* _CRYPTO_ARCH_S390_CRYPT_S390_H */