drivers/crypto/dpaa2_sec/hw/rta/operation_cmd.h

   1 /*
   2  * Copyright 2008-2016 Freescale Semiconductor, Inc.
   3  *
   4  * SPDX-License-Identifier: BSD-3-Clause or GPL-2.0+
   5  */
   6
   7 #ifndef __RTA_OPERATION_CMD_H__
   8 #define __RTA_OPERATION_CMD_H__
   9
  10 extern enum rta_sec_era rta_sec_era;
  11
  12 static inline int
  13 __rta_alg_aai_aes(uint16_t aai)
  14 {
  15         uint16_t aes_mode = aai & OP_ALG_AESA_MODE_MASK;
  16
  17         if (aai & OP_ALG_AAI_C2K) {
  18                 if (rta_sec_era < RTA_SEC_ERA_5)
  19                         return -1;
  20                 if ((aes_mode != OP_ALG_AAI_CCM) &&
  21                     (aes_mode != OP_ALG_AAI_GCM))
  22                         return -EINVAL;
  23         }
  24
  25         switch (aes_mode) {
  26         case OP_ALG_AAI_CBC_CMAC:
  27         case OP_ALG_AAI_CTR_CMAC_LTE:
  28         case OP_ALG_AAI_CTR_CMAC:
  29                 if (rta_sec_era < RTA_SEC_ERA_2)
  30                         return -EINVAL;
  31                 /* no break */
  32         case OP_ALG_AAI_CTR:
  33         case OP_ALG_AAI_CBC:
  34         case OP_ALG_AAI_ECB:
  35         case OP_ALG_AAI_OFB:
  36         case OP_ALG_AAI_CFB:
  37         case OP_ALG_AAI_XTS:
  38         case OP_ALG_AAI_CMAC:
  39         case OP_ALG_AAI_XCBC_MAC:
  40         case OP_ALG_AAI_CCM:
  41         case OP_ALG_AAI_GCM:
  42         case OP_ALG_AAI_CBC_XCBCMAC:
  43         case OP_ALG_AAI_CTR_XCBCMAC:
  44                 return 0;
  45         }
  46
  47         return -EINVAL;
  48 }
  49
  50 static inline int
  51 __rta_alg_aai_des(uint16_t aai)
  52 {
  53         uint16_t aai_code = (uint16_t)(aai & ~OP_ALG_AAI_CHECKODD);
  54
  55         switch (aai_code) {
  56         case OP_ALG_AAI_CBC:
  57         case OP_ALG_AAI_ECB:
  58         case OP_ALG_AAI_CFB:
  59         case OP_ALG_AAI_OFB:
  60                 return 0;
  61         }
  62
  63         return -EINVAL;
  64 }
  65
  66 static inline int
  67 __rta_alg_aai_md5(uint16_t aai)
  68 {
  69         switch (aai) {
  70         case OP_ALG_AAI_HMAC:
  71                 if (rta_sec_era < RTA_SEC_ERA_2)
  72                         return -EINVAL;
  73                 /* no break */
  74         case OP_ALG_AAI_SMAC:
  75         case OP_ALG_AAI_HASH:
  76         case OP_ALG_AAI_HMAC_PRECOMP:
  77                 return 0;
  78         }
  79
  80         return -EINVAL;
  81 }
  82
  83 static inline int
  84 __rta_alg_aai_sha(uint16_t aai)
  85 {
  86         switch (aai) {
  87         case OP_ALG_AAI_HMAC:
  88                 if (rta_sec_era < RTA_SEC_ERA_2)
  89                         return -EINVAL;
  90                 /* no break */
  91         case OP_ALG_AAI_HASH:
  92         case OP_ALG_AAI_HMAC_PRECOMP:
  93                 return 0;
  94         }
  95
  96         return -EINVAL;
  97 }
  98
  99 static inline int
 100 __rta_alg_aai_rng(uint16_t aai)
 101 {
 102         uint16_t rng_mode = aai & OP_ALG_RNG_MODE_MASK;
 103         uint16_t rng_sh = aai & OP_ALG_AAI_RNG4_SH_MASK;
 104
 105         switch (rng_mode) {
 106         case OP_ALG_AAI_RNG:
 107         case OP_ALG_AAI_RNG_NZB:
 108         case OP_ALG_AAI_RNG_OBP:
 109                 break;
 110         default:
 111                 return -EINVAL;
 112         }
 113
 114         /* State Handle bits are valid only for SEC Era >= 5 */
 115         if ((rta_sec_era < RTA_SEC_ERA_5) && rng_sh)
 116                 return -EINVAL;
 117
 118         /* PS, AI, SK bits are also valid only for SEC Era >= 5 */
 119         if ((rta_sec_era < RTA_SEC_ERA_5) && (aai &
 120              (OP_ALG_AAI_RNG4_PS | OP_ALG_AAI_RNG4_AI | OP_ALG_AAI_RNG4_SK)))
 121                 return -EINVAL;
 122
 123         switch (rng_sh) {
 124         case OP_ALG_AAI_RNG4_SH_0:
 125         case OP_ALG_AAI_RNG4_SH_1:
 126                 return 0;
 127         }
 128
 129         return -EINVAL;
 130 }
 131
 132 static inline int
 133 __rta_alg_aai_crc(uint16_t aai)
 134 {
 135         uint16_t aai_code = aai & OP_ALG_CRC_POLY_MASK;
 136
 137         switch (aai_code) {
 138         case OP_ALG_AAI_802:
 139         case OP_ALG_AAI_3385:
 140         case OP_ALG_AAI_CUST_POLY:
 141                 return 0;
 142         }
 143
 144         return -EINVAL;
 145 }
 146
 147 static inline int
 148 __rta_alg_aai_kasumi(uint16_t aai)
 149 {
 150         switch (aai) {
 151         case OP_ALG_AAI_GSM:
 152         case OP_ALG_AAI_EDGE:
 153         case OP_ALG_AAI_F8:
 154         case OP_ALG_AAI_F9:
 155                 return 0;
 156         }
 157
 158         return -EINVAL;
 159 }
 160
 161 static inline int
 162 __rta_alg_aai_snow_f9(uint16_t aai)
 163 {
 164         if (aai == OP_ALG_AAI_F9)
 165                 return 0;
 166
 167         return -EINVAL;
 168 }
 169
 170 static inline int
 171 __rta_alg_aai_snow_f8(uint16_t aai)
 172 {
 173         if (aai == OP_ALG_AAI_F8)
 174                 return 0;
 175
 176         return -EINVAL;
 177 }
 178
 179 static inline int
 180 __rta_alg_aai_zuce(uint16_t aai)
 181 {
 182         if (aai == OP_ALG_AAI_F8)
 183                 return 0;
 184
 185         return -EINVAL;
 186 }
 187
 188 static inline int
 189 __rta_alg_aai_zuca(uint16_t aai)
 190 {
 191         if (aai == OP_ALG_AAI_F9)
 192                 return 0;
 193
 194         return -EINVAL;
 195 }
 196
 197 struct alg_aai_map {
 198         uint32_t chipher_algo;
 199         int (*aai_func)(uint16_t);
 200         uint32_t class;
 201 };
 202
 203 static const struct alg_aai_map alg_table[] = {
 204 /*1*/   { OP_ALG_ALGSEL_AES,      __rta_alg_aai_aes,    OP_TYPE_CLASS1_ALG },
 205         { OP_ALG_ALGSEL_DES,      __rta_alg_aai_des,    OP_TYPE_CLASS1_ALG },
 206         { OP_ALG_ALGSEL_3DES,     __rta_alg_aai_des,    OP_TYPE_CLASS1_ALG },
 207         { OP_ALG_ALGSEL_MD5,      __rta_alg_aai_md5,    OP_TYPE_CLASS2_ALG },
 208         { OP_ALG_ALGSEL_SHA1,     __rta_alg_aai_md5,    OP_TYPE_CLASS2_ALG },
 209         { OP_ALG_ALGSEL_SHA224,   __rta_alg_aai_sha,    OP_TYPE_CLASS2_ALG },
 210         { OP_ALG_ALGSEL_SHA256,   __rta_alg_aai_sha,    OP_TYPE_CLASS2_ALG },
 211         { OP_ALG_ALGSEL_SHA384,   __rta_alg_aai_sha,    OP_TYPE_CLASS2_ALG },
 212         { OP_ALG_ALGSEL_SHA512,   __rta_alg_aai_sha,    OP_TYPE_CLASS2_ALG },
 213         { OP_ALG_ALGSEL_RNG,      __rta_alg_aai_rng,    OP_TYPE_CLASS1_ALG },
 214 /*11*/  { OP_ALG_ALGSEL_CRC,      __rta_alg_aai_crc,    OP_TYPE_CLASS2_ALG },
 215         { OP_ALG_ALGSEL_ARC4,     NULL,                 OP_TYPE_CLASS1_ALG },
 216         { OP_ALG_ALGSEL_SNOW_F8,  __rta_alg_aai_snow_f8, OP_TYPE_CLASS1_ALG },
 217 /*14*/  { OP_ALG_ALGSEL_KASUMI,   __rta_alg_aai_kasumi, OP_TYPE_CLASS1_ALG },
 218         { OP_ALG_ALGSEL_SNOW_F9,  __rta_alg_aai_snow_f9, OP_TYPE_CLASS2_ALG },
 219         { OP_ALG_ALGSEL_ZUCE,     __rta_alg_aai_zuce,   OP_TYPE_CLASS1_ALG },
 220 /*17*/  { OP_ALG_ALGSEL_ZUCA,     __rta_alg_aai_zuca,   OP_TYPE_CLASS2_ALG }
 221 };
 222
 223 /*
 224  * Allowed OPERATION algorithms for each SEC Era.
 225  * Values represent the number of entries from alg_table[] that are supported.
 226  */
 227 static const unsigned int alg_table_sz[] = {14, 15, 15, 15, 17, 17, 11, 17};
 228
 229 static inline int
 230 rta_operation(struct program *program, uint32_t cipher_algo,
 231               uint16_t aai, uint8_t algo_state,
 232               int icv_checking, int enc)
 233 {
 234         uint32_t opcode = CMD_OPERATION;
 235         unsigned int i, found = 0;
 236         unsigned int start_pc = program->current_pc;
 237         int ret;
 238
 239         for (i = 0; i < alg_table_sz[rta_sec_era]; i++) {
 240                 if (alg_table[i].chipher_algo == cipher_algo) {
 241                         opcode |= cipher_algo | alg_table[i].class;
 242                         /* nothing else to verify */
 243                         if (alg_table[i].aai_func == NULL) {
 244                                 found = 1;
 245                                 break;
 246                         }
 247
 248                         aai &= OP_ALG_AAI_MASK;
 249
 250                         ret = (*alg_table[i].aai_func)(aai);
 251                         if (ret < 0) {
 252                                 pr_err("OPERATION: Bad AAI Type. SEC Program Line: %d\n",
 253                                        program->current_pc);
 254                                 goto err;
 255                         }
 256                         opcode |= aai;
 257                         found = 1;
 258                         break;
 259                 }
 260         }
 261         if (!found) {
 262                 pr_err("OPERATION: Invalid Command. SEC Program Line: %d\n",
 263                        program->current_pc);
 264                 ret = -EINVAL;
 265                 goto err;
 266         }
 267
 268         switch (algo_state) {
 269         case OP_ALG_AS_UPDATE:
 270         case OP_ALG_AS_INIT:
 271         case OP_ALG_AS_FINALIZE:
 272         case OP_ALG_AS_INITFINAL:
 273                 opcode |= algo_state;
 274                 break;
 275         default:
 276                 pr_err("Invalid Operation Command\n");
 277                 ret = -EINVAL;
 278                 goto err;
 279         }
 280
 281         switch (icv_checking) {
 282         case ICV_CHECK_DISABLE:
 283                 /*
 284                  * opcode |= OP_ALG_ICV_OFF;
 285                  * OP_ALG_ICV_OFF is 0
 286                  */
 287                 break;
 288         case ICV_CHECK_ENABLE:
 289                 opcode |= OP_ALG_ICV_ON;
 290                 break;
 291         default:
 292                 pr_err("Invalid Operation Command\n");
 293                 ret = -EINVAL;
 294                 goto err;
 295         }
 296
 297         switch (enc) {
 298         case DIR_DEC:
 299                 /*
 300                  * opcode |= OP_ALG_DECRYPT;
 301                  * OP_ALG_DECRYPT is 0
 302                  */
 303                 break;
 304         case DIR_ENC:
 305                 opcode |= OP_ALG_ENCRYPT;
 306                 break;
 307         default:
 308                 pr_err("Invalid Operation Command\n");
 309                 ret = -EINVAL;
 310                 goto err;
 311         }
 312
 313         __rta_out32(program, opcode);
 314         program->current_instruction++;
 315         return (int)start_pc;
 316
 317  err:
 318         program->first_error_pc = start_pc;
 319         return ret;
 320 }
 321
 322 /*
 323  * OPERATION PKHA routines
 324  */
 325 static inline int
 326 __rta_pkha_clearmem(uint32_t pkha_op)
 327 {
 328         switch (pkha_op) {
 329         case (OP_ALG_PKMODE_CLEARMEM_ALL):
 330         case (OP_ALG_PKMODE_CLEARMEM_ABE):
 331         case (OP_ALG_PKMODE_CLEARMEM_ABN):
 332         case (OP_ALG_PKMODE_CLEARMEM_AB):
 333         case (OP_ALG_PKMODE_CLEARMEM_AEN):
 334         case (OP_ALG_PKMODE_CLEARMEM_AE):
 335         case (OP_ALG_PKMODE_CLEARMEM_AN):
 336         case (OP_ALG_PKMODE_CLEARMEM_A):
 337         case (OP_ALG_PKMODE_CLEARMEM_BEN):
 338         case (OP_ALG_PKMODE_CLEARMEM_BE):
 339         case (OP_ALG_PKMODE_CLEARMEM_BN):
 340         case (OP_ALG_PKMODE_CLEARMEM_B):
 341         case (OP_ALG_PKMODE_CLEARMEM_EN):
 342         case (OP_ALG_PKMODE_CLEARMEM_N):
 343         case (OP_ALG_PKMODE_CLEARMEM_E):
 344                 return 0;
 345         }
 346
 347         return -EINVAL;
 348 }
 349
 350 static inline int
 351 __rta_pkha_mod_arithmetic(uint32_t pkha_op)
 352 {
 353         pkha_op &= (uint32_t)~OP_ALG_PKMODE_OUT_A;
 354
 355         switch (pkha_op) {
 356         case (OP_ALG_PKMODE_MOD_ADD):
 357         case (OP_ALG_PKMODE_MOD_SUB_AB):
 358         case (OP_ALG_PKMODE_MOD_SUB_BA):
 359         case (OP_ALG_PKMODE_MOD_MULT):
 360         case (OP_ALG_PKMODE_MOD_MULT_IM):
 361         case (OP_ALG_PKMODE_MOD_MULT_IM_OM):
 362         case (OP_ALG_PKMODE_MOD_EXPO):
 363         case (OP_ALG_PKMODE_MOD_EXPO_TEQ):
 364         case (OP_ALG_PKMODE_MOD_EXPO_IM):
 365         case (OP_ALG_PKMODE_MOD_EXPO_IM_TEQ):
 366         case (OP_ALG_PKMODE_MOD_REDUCT):
 367         case (OP_ALG_PKMODE_MOD_INV):
 368         case (OP_ALG_PKMODE_MOD_MONT_CNST):
 369         case (OP_ALG_PKMODE_MOD_CRT_CNST):
 370         case (OP_ALG_PKMODE_MOD_GCD):
 371         case (OP_ALG_PKMODE_MOD_PRIMALITY):
 372         case (OP_ALG_PKMODE_MOD_SML_EXP):
 373         case (OP_ALG_PKMODE_F2M_ADD):
 374         case (OP_ALG_PKMODE_F2M_MUL):
 375         case (OP_ALG_PKMODE_F2M_MUL_IM):
 376         case (OP_ALG_PKMODE_F2M_MUL_IM_OM):
 377         case (OP_ALG_PKMODE_F2M_EXP):
 378         case (OP_ALG_PKMODE_F2M_EXP_TEQ):
 379         case (OP_ALG_PKMODE_F2M_AMODN):
 380         case (OP_ALG_PKMODE_F2M_INV):
 381         case (OP_ALG_PKMODE_F2M_R2):
 382         case (OP_ALG_PKMODE_F2M_GCD):
 383         case (OP_ALG_PKMODE_F2M_SML_EXP):
 384         case (OP_ALG_PKMODE_ECC_F2M_ADD):
 385         case (OP_ALG_PKMODE_ECC_F2M_ADD_IM_OM_PROJ):
 386         case (OP_ALG_PKMODE_ECC_F2M_DBL):
 387         case (OP_ALG_PKMODE_ECC_F2M_DBL_IM_OM_PROJ):
 388         case (OP_ALG_PKMODE_ECC_F2M_MUL):
 389         case (OP_ALG_PKMODE_ECC_F2M_MUL_TEQ):
 390         case (OP_ALG_PKMODE_ECC_F2M_MUL_R2):
 391         case (OP_ALG_PKMODE_ECC_F2M_MUL_R2_TEQ):
 392         case (OP_ALG_PKMODE_ECC_F2M_MUL_R2_PROJ):
 393         case (OP_ALG_PKMODE_ECC_F2M_MUL_R2_PROJ_TEQ):
 394         case (OP_ALG_PKMODE_ECC_MOD_ADD):
 395         case (OP_ALG_PKMODE_ECC_MOD_ADD_IM_OM_PROJ):
 396         case (OP_ALG_PKMODE_ECC_MOD_DBL):
 397         case (OP_ALG_PKMODE_ECC_MOD_DBL_IM_OM_PROJ):
 398         case (OP_ALG_PKMODE_ECC_MOD_MUL):
 399         case (OP_ALG_PKMODE_ECC_MOD_MUL_TEQ):
 400         case (OP_ALG_PKMODE_ECC_MOD_MUL_R2):
 401         case (OP_ALG_PKMODE_ECC_MOD_MUL_R2_TEQ):
 402         case (OP_ALG_PKMODE_ECC_MOD_MUL_R2_PROJ):
 403         case (OP_ALG_PKMODE_ECC_MOD_MUL_R2_PROJ_TEQ):
 404                 return 0;
 405         }
 406
 407         return -EINVAL;
 408 }
 409
 410 static inline int
 411 __rta_pkha_copymem(uint32_t pkha_op)
 412 {
 413         switch (pkha_op) {
 414         case (OP_ALG_PKMODE_COPY_NSZ_A0_B0):
 415         case (OP_ALG_PKMODE_COPY_NSZ_A0_B1):
 416         case (OP_ALG_PKMODE_COPY_NSZ_A0_B2):
 417         case (OP_ALG_PKMODE_COPY_NSZ_A0_B3):
 418         case (OP_ALG_PKMODE_COPY_NSZ_A1_B0):
 419         case (OP_ALG_PKMODE_COPY_NSZ_A1_B1):
 420         case (OP_ALG_PKMODE_COPY_NSZ_A1_B2):
 421         case (OP_ALG_PKMODE_COPY_NSZ_A1_B3):
 422         case (OP_ALG_PKMODE_COPY_NSZ_A2_B0):
 423         case (OP_ALG_PKMODE_COPY_NSZ_A2_B1):
 424         case (OP_ALG_PKMODE_COPY_NSZ_A2_B2):
 425         case (OP_ALG_PKMODE_COPY_NSZ_A2_B3):
 426         case (OP_ALG_PKMODE_COPY_NSZ_A3_B0):
 427         case (OP_ALG_PKMODE_COPY_NSZ_A3_B1):
 428         case (OP_ALG_PKMODE_COPY_NSZ_A3_B2):
 429         case (OP_ALG_PKMODE_COPY_NSZ_A3_B3):
 430         case (OP_ALG_PKMODE_COPY_NSZ_B0_A0):
 431         case (OP_ALG_PKMODE_COPY_NSZ_B0_A1):
 432         case (OP_ALG_PKMODE_COPY_NSZ_B0_A2):
 433         case (OP_ALG_PKMODE_COPY_NSZ_B0_A3):
 434         case (OP_ALG_PKMODE_COPY_NSZ_B1_A0):
 435         case (OP_ALG_PKMODE_COPY_NSZ_B1_A1):
 436         case (OP_ALG_PKMODE_COPY_NSZ_B1_A2):
 437         case (OP_ALG_PKMODE_COPY_NSZ_B1_A3):
 438         case (OP_ALG_PKMODE_COPY_NSZ_B2_A0):
 439         case (OP_ALG_PKMODE_COPY_NSZ_B2_A1):
 440         case (OP_ALG_PKMODE_COPY_NSZ_B2_A2):
 441         case (OP_ALG_PKMODE_COPY_NSZ_B2_A3):
 442         case (OP_ALG_PKMODE_COPY_NSZ_B3_A0):
 443         case (OP_ALG_PKMODE_COPY_NSZ_B3_A1):
 444         case (OP_ALG_PKMODE_COPY_NSZ_B3_A2):
 445         case (OP_ALG_PKMODE_COPY_NSZ_B3_A3):
 446         case (OP_ALG_PKMODE_COPY_NSZ_A_E):
 447         case (OP_ALG_PKMODE_COPY_NSZ_A_N):
 448         case (OP_ALG_PKMODE_COPY_NSZ_B_E):
 449         case (OP_ALG_PKMODE_COPY_NSZ_B_N):
 450         case (OP_ALG_PKMODE_COPY_NSZ_N_A):
 451         case (OP_ALG_PKMODE_COPY_NSZ_N_B):
 452         case (OP_ALG_PKMODE_COPY_NSZ_N_E):
 453         case (OP_ALG_PKMODE_COPY_SSZ_A0_B0):
 454         case (OP_ALG_PKMODE_COPY_SSZ_A0_B1):
 455         case (OP_ALG_PKMODE_COPY_SSZ_A0_B2):
 456         case (OP_ALG_PKMODE_COPY_SSZ_A0_B3):
 457         case (OP_ALG_PKMODE_COPY_SSZ_A1_B0):
 458         case (OP_ALG_PKMODE_COPY_SSZ_A1_B1):
 459         case (OP_ALG_PKMODE_COPY_SSZ_A1_B2):
 460         case (OP_ALG_PKMODE_COPY_SSZ_A1_B3):
 461         case (OP_ALG_PKMODE_COPY_SSZ_A2_B0):
 462         case (OP_ALG_PKMODE_COPY_SSZ_A2_B1):
 463         case (OP_ALG_PKMODE_COPY_SSZ_A2_B2):
 464         case (OP_ALG_PKMODE_COPY_SSZ_A2_B3):
 465         case (OP_ALG_PKMODE_COPY_SSZ_A3_B0):
 466         case (OP_ALG_PKMODE_COPY_SSZ_A3_B1):
 467         case (OP_ALG_PKMODE_COPY_SSZ_A3_B2):
 468         case (OP_ALG_PKMODE_COPY_SSZ_A3_B3):
 469         case (OP_ALG_PKMODE_COPY_SSZ_B0_A0):
 470         case (OP_ALG_PKMODE_COPY_SSZ_B0_A1):
 471         case (OP_ALG_PKMODE_COPY_SSZ_B0_A2):
 472         case (OP_ALG_PKMODE_COPY_SSZ_B0_A3):
 473         case (OP_ALG_PKMODE_COPY_SSZ_B1_A0):
 474         case (OP_ALG_PKMODE_COPY_SSZ_B1_A1):
 475         case (OP_ALG_PKMODE_COPY_SSZ_B1_A2):
 476         case (OP_ALG_PKMODE_COPY_SSZ_B1_A3):
 477         case (OP_ALG_PKMODE_COPY_SSZ_B2_A0):
 478         case (OP_ALG_PKMODE_COPY_SSZ_B2_A1):
 479         case (OP_ALG_PKMODE_COPY_SSZ_B2_A2):
 480         case (OP_ALG_PKMODE_COPY_SSZ_B2_A3):
 481         case (OP_ALG_PKMODE_COPY_SSZ_B3_A0):
 482         case (OP_ALG_PKMODE_COPY_SSZ_B3_A1):
 483         case (OP_ALG_PKMODE_COPY_SSZ_B3_A2):
 484         case (OP_ALG_PKMODE_COPY_SSZ_B3_A3):
 485         case (OP_ALG_PKMODE_COPY_SSZ_A_E):
 486         case (OP_ALG_PKMODE_COPY_SSZ_A_N):
 487         case (OP_ALG_PKMODE_COPY_SSZ_B_E):
 488         case (OP_ALG_PKMODE_COPY_SSZ_B_N):
 489         case (OP_ALG_PKMODE_COPY_SSZ_N_A):
 490         case (OP_ALG_PKMODE_COPY_SSZ_N_B):
 491         case (OP_ALG_PKMODE_COPY_SSZ_N_E):
 492                 return 0;
 493         }
 494
 495         return -EINVAL;
 496 }
 497
 498 static inline int
 499 rta_pkha_operation(struct program *program, uint32_t op_pkha)
 500 {
 501         uint32_t opcode = CMD_OPERATION | OP_TYPE_PK | OP_ALG_PK;
 502         uint32_t pkha_func;
 503         unsigned int start_pc = program->current_pc;
 504         int ret = -EINVAL;
 505
 506         pkha_func = op_pkha & OP_ALG_PK_FUN_MASK;
 507
 508         switch (pkha_func) {
 509         case (OP_ALG_PKMODE_CLEARMEM):
 510                 ret = __rta_pkha_clearmem(op_pkha);
 511                 if (ret < 0) {
 512                         pr_err("OPERATION PKHA: Type not supported. SEC Program Line: %d\n",
 513                                program->current_pc);
 514                         goto err;
 515                 }
 516                 break;
 517         case (OP_ALG_PKMODE_MOD_ADD):
 518         case (OP_ALG_PKMODE_MOD_SUB_AB):
 519         case (OP_ALG_PKMODE_MOD_SUB_BA):
 520         case (OP_ALG_PKMODE_MOD_MULT):
 521         case (OP_ALG_PKMODE_MOD_EXPO):
 522         case (OP_ALG_PKMODE_MOD_REDUCT):
 523         case (OP_ALG_PKMODE_MOD_INV):
 524         case (OP_ALG_PKMODE_MOD_MONT_CNST):
 525         case (OP_ALG_PKMODE_MOD_CRT_CNST):
 526         case (OP_ALG_PKMODE_MOD_GCD):
 527         case (OP_ALG_PKMODE_MOD_PRIMALITY):
 528         case (OP_ALG_PKMODE_MOD_SML_EXP):
 529         case (OP_ALG_PKMODE_ECC_MOD_ADD):
 530         case (OP_ALG_PKMODE_ECC_MOD_DBL):
 531         case (OP_ALG_PKMODE_ECC_MOD_MUL):
 532                 ret = __rta_pkha_mod_arithmetic(op_pkha);
 533                 if (ret < 0) {
 534                         pr_err("OPERATION PKHA: Type not supported. SEC Program Line: %d\n",
 535                                program->current_pc);
 536                         goto err;
 537                 }
 538                 break;
 539         case (OP_ALG_PKMODE_COPY_NSZ):
 540         case (OP_ALG_PKMODE_COPY_SSZ):
 541                 ret = __rta_pkha_copymem(op_pkha);
 542                 if (ret < 0) {
 543                         pr_err("OPERATION PKHA: Type not supported. SEC Program Line: %d\n",
 544                                program->current_pc);
 545                         goto err;
 546                 }
 547                 break;
 548         default:
 549                 pr_err("Invalid Operation Command\n");
 550                 goto err;
 551         }
 552
 553         opcode |= op_pkha;
 554
 555         __rta_out32(program, opcode);
 556         program->current_instruction++;
 557         return (int)start_pc;
 558
 559  err:
 560         program->first_error_pc = start_pc;
 561         program->current_instruction++;
 562         return ret;
 563 }
 564
 565 #endif /* __RTA_OPERATION_CMD_H__ */