LXR linux/arch/s390/crypto/crypt

   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#include <asm/facility.h>
  21
  22#define CRYPT_S390_OP_MASK 0xFF00
  23#define CRYPT_S390_FUNC_MASK 0x00FF
  24
  25#define CRYPT_S390_PRIORITY 300
  26#define CRYPT_S390_COMPOSITE_PRIORITY 400
  27
  28#define CRYPT_S390_MSA  0x1
  29#define CRYPT_S390_MSA3 0x2
  30#define CRYPT_S390_MSA4 0x4
  31
  32/* s390 cryptographic operations */
  33enum crypt_s390_operations {
  34        CRYPT_S390_KM   = 0x0100,
  35        CRYPT_S390_KMC  = 0x0200,
  36        CRYPT_S390_KIMD = 0x0300,
  37        CRYPT_S390_KLMD = 0x0400,
  38        CRYPT_S390_KMAC = 0x0500,
  39        CRYPT_S390_KMCTR = 0x0600
  40};
  41
  42/*
  43 * function codes for KM (CIPHER MESSAGE) instruction
  44 * 0x80 is the decipher modifier bit
  45 */
  46enum crypt_s390_km_func {
  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,
  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,
  64};
  65
  66/*
  67 * function codes for KMC (CIPHER MESSAGE WITH CHAINING)
  68 * instruction
  69 */
  70enum crypt_s390_kmc_func {
  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,
  84        KMC_PRNG             = CRYPT_S390_KMC | 0x43,
  85};
  86
  87/*
  88 * function codes for KMCTR (CIPHER MESSAGE WITH COUNTER)
  89 * instruction
  90 */
  91enum 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
 107/*
 108 * function codes for KIMD (COMPUTE INTERMEDIATE MESSAGE DIGEST)
 109 * instruction
 110 */
 111enum crypt_s390_kimd_func {
 112        KIMD_QUERY   = CRYPT_S390_KIMD | 0,
 113        KIMD_SHA_1   = CRYPT_S390_KIMD | 1,
 114        KIMD_SHA_256 = CRYPT_S390_KIMD | 2,
 115        KIMD_SHA_512 = CRYPT_S390_KIMD | 3,
 116        KIMD_GHASH   = CRYPT_S390_KIMD | 65,
 117};
 118
 119/*
 120 * function codes for KLMD (COMPUTE LAST MESSAGE DIGEST)
 121 * instruction
 122 */
 123enum crypt_s390_klmd_func {
 124        KLMD_QUERY   = CRYPT_S390_KLMD | 0,
 125        KLMD_SHA_1   = CRYPT_S390_KLMD | 1,
 126        KLMD_SHA_256 = CRYPT_S390_KLMD | 2,
 127        KLMD_SHA_512 = CRYPT_S390_KLMD | 3,
 128};
 129
 130/*
 131 * function codes for KMAC (COMPUTE MESSAGE AUTHENTICATION CODE)
 132 * instruction
 133 */
 134enum 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
 139};
 140
 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 *
 149 * Executes the KM (CIPHER MESSAGE) operation of the CPU.
 150 *
 151 * Returns -1 for failure, 0 for the query func, number of processed
 152 * bytes for encryption/decryption funcs
 153 */
 154static inline int crypt_s390_km(long func, void *param,
 155                                u8 *dest, const u8 *src, long src_len)
 156{
 157        register long __func asm("0") = func & CRYPT_S390_FUNC_MASK;
 158        register void *__param asm("1") = param;
 159        register const u8 *__src asm("2") = src;
 160        register long __src_len asm("3") = src_len;
 161        register u8 *__dest asm("4") = dest;
 162        int ret;
 163
 164        asm volatile(
 165                "0:     .insn   rre,0xb92e0000,%3,%1 \n" /* KM opcode */
 166                "1:     brc     1,0b \n" /* handle partial completion */
 167                "       la      %0,0\n"
 168                "2:\n"
 169                EX_TABLE(0b,2b) EX_TABLE(1b,2b)
 170                : "=d" (ret), "+a" (__src), "+d" (__src_len), "+a" (__dest)
 171                : "d" (__func), "a" (__param), "0" (-1) : "cc", "memory");
 172        if (ret < 0)
 173                return ret;
 174        return (func & CRYPT_S390_FUNC_MASK) ? src_len - __src_len : __src_len;
 175}
 176
 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 *
 185 * Executes the KMC (CIPHER MESSAGE WITH CHAINING) operation of the CPU.
 186 *
 187 * Returns -1 for failure, 0 for the query func, number of processed
 188 * bytes for encryption/decryption funcs
 189 */
 190static inline int crypt_s390_kmc(long func, void *param,
 191                                 u8 *dest, const u8 *src, long src_len)
 192{
 193        register long __func asm("0") = func & CRYPT_S390_FUNC_MASK;
 194        register void *__param asm("1") = param;
 195        register const u8 *__src asm("2") = src;
 196        register long __src_len asm("3") = src_len;
 197        register u8 *__dest asm("4") = dest;
 198        int ret;
 199
 200        asm volatile(
 201                "0:     .insn   rre,0xb92f0000,%3,%1 \n" /* KMC opcode */
 202                "1:     brc     1,0b \n" /* handle partial completion */
 203                "       la      %0,0\n"
 204                "2:\n"
 205                EX_TABLE(0b,2b) EX_TABLE(1b,2b)
 206                : "=d" (ret), "+a" (__src), "+d" (__src_len), "+a" (__dest)
 207                : "d" (__func), "a" (__param), "0" (-1) : "cc", "memory");
 208        if (ret < 0)
 209                return ret;
 210        return (func & CRYPT_S390_FUNC_MASK) ? src_len - __src_len : __src_len;
 211}
 212
 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 *
 220 * Executes the KIMD (COMPUTE INTERMEDIATE MESSAGE DIGEST) operation
 221 * of the CPU.
 222 *
 223 * Returns -1 for failure, 0 for the query func, number of processed
 224 * bytes for digest funcs
 225 */
 226static inline int crypt_s390_kimd(long func, void *param,
 227                                  const u8 *src, long src_len)
 228{
 229        register long __func asm("0") = func & CRYPT_S390_FUNC_MASK;
 230        register void *__param asm("1") = param;
 231        register const u8 *__src asm("2") = src;
 232        register long __src_len asm("3") = src_len;
 233        int ret;
 234
 235        asm volatile(
 236                "0:     .insn   rre,0xb93e0000,%1,%1 \n" /* KIMD opcode */
 237                "1:     brc     1,0b \n" /* handle partial completion */
 238                "       la      %0,0\n"
 239                "2:\n"
 240                EX_TABLE(0b,2b) EX_TABLE(1b,2b)
 241                : "=d" (ret), "+a" (__src), "+d" (__src_len)
 242                : "d" (__func), "a" (__param), "0" (-1) : "cc", "memory");
 243        if (ret < 0)
 244                return ret;
 245        return (func & CRYPT_S390_FUNC_MASK) ? src_len - __src_len : __src_len;
 246}
 247
 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 *
 255 * Executes the KLMD (COMPUTE LAST MESSAGE DIGEST) operation of the CPU.
 256 *
 257 * Returns -1 for failure, 0 for the query func, number of processed
 258 * bytes for digest funcs
 259 */
 260static inline int crypt_s390_klmd(long func, void *param,
 261                                  const u8 *src, long src_len)
 262{
 263        register long __func asm("0") = func & CRYPT_S390_FUNC_MASK;
 264        register void *__param asm("1") = param;
 265        register const u8 *__src asm("2") = src;
 266        register long __src_len asm("3") = src_len;
 267        int ret;
 268
 269        asm volatile(
 270                "0:     .insn   rre,0xb93f0000,%1,%1 \n" /* KLMD opcode */
 271                "1:     brc     1,0b \n" /* handle partial completion */
 272                "       la      %0,0\n"
 273                "2:\n"
 274                EX_TABLE(0b,2b) EX_TABLE(1b,2b)
 275                : "=d" (ret), "+a" (__src), "+d" (__src_len)
 276                : "d" (__func), "a" (__param), "0" (-1) : "cc", "memory");
 277        if (ret < 0)
 278                return ret;
 279        return (func & CRYPT_S390_FUNC_MASK) ? src_len - __src_len : __src_len;
 280}
 281
 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 *
 289 * Executes the KMAC (COMPUTE MESSAGE AUTHENTICATION CODE) operation
 290 * of the CPU.
 291 *
 292 * Returns -1 for failure, 0 for the query func, number of processed
 293 * bytes for digest funcs
 294 */
 295static inline int crypt_s390_kmac(long func, void *param,
 296                                  const u8 *src, long src_len)
 297{
 298        register long __func asm("0") = func & CRYPT_S390_FUNC_MASK;
 299        register void *__param asm("1") = param;
 300        register const u8 *__src asm("2") = src;
 301        register long __src_len asm("3") = src_len;
 302        int ret;
 303
 304        asm volatile(
 305                "0:     .insn   rre,0xb91e0000,%1,%1 \n" /* KLAC opcode */
 306                "1:     brc     1,0b \n" /* handle partial completion */
 307                "       la      %0,0\n"
 308                "2:\n"
 309                EX_TABLE(0b,2b) EX_TABLE(1b,2b)
 310                : "=d" (ret), "+a" (__src), "+d" (__src_len)
 311                : "d" (__func), "a" (__param), "0" (-1) : "cc", "memory");
 312        if (ret < 0)
 313                return ret;
 314        return (func & CRYPT_S390_FUNC_MASK) ? src_len - __src_len : __src_len;
 315}
 316
 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 */
 331static 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
 356/**
 357 * crypt_s390_func_available:
 358 * @func: the function code of the specific function; 0 if op in general
 359 *
 360 * Tests if a specific crypto function is implemented on the machine.
 361 *
 362 * Returns 1 if func available; 0 if func or op in general not available
 363 */
 364static inline int crypt_s390_func_available(int func,
 365                                            unsigned int facility_mask)
 366{
 367        unsigned char status[16];
 368        int ret;
 369
 370        if (facility_mask & CRYPT_S390_MSA && !test_facility(17))
 371                return 0;
 372
 373        if (facility_mask & CRYPT_S390_MSA3 &&
 374            (!test_facility(2) || !test_facility(76)))
 375                return 0;
 376        if (facility_mask & CRYPT_S390_MSA4 &&
 377            (!test_facility(2) || !test_facility(77)))
 378                return 0;
 379
 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;
 396        case CRYPT_S390_KMCTR:
 397                ret = crypt_s390_kmctr(KMCTR_QUERY, &status, NULL, NULL, 0,
 398                                       NULL);
 399                break;
 400        default:
 401                return 0;
 402        }
 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;
 408}
 409
 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 */
 419static 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
 437#endif  /* _CRYPTO_ARCH_S390_CRYPT_S390_H */
 438