drivers/common/dpaax/caamflib/rta.h

   1 /* SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0)
   2  *
   3  * Copyright 2008-2016 Freescale Semiconductor Inc.
   4  * Copyright 2016,2021 NXP
   5  *
   6  */
   7
   8 #ifndef __RTA_RTA_H__
   9 #define __RTA_RTA_H__
  10
  11 #include "rta/sec_run_time_asm.h"
  12 #include "rta/fifo_load_store_cmd.h"
  13 #include "rta/header_cmd.h"
  14 #include "rta/jump_cmd.h"
  15 #include "rta/key_cmd.h"
  16 #include "rta/load_cmd.h"
  17 #include "rta/math_cmd.h"
  18 #include "rta/move_cmd.h"
  19 #include "rta/nfifo_cmd.h"
  20 #include "rta/operation_cmd.h"
  21 #include "rta/protocol_cmd.h"
  22 #include "rta/seq_in_out_ptr_cmd.h"
  23 #include "rta/signature_cmd.h"
  24 #include "rta/store_cmd.h"
  25
  26 /**
  27  * DOC: About
  28  *
  29  * RTA (Runtime Assembler) Library is an easy and flexible runtime method for
  30  * writing SEC descriptors. It implements a thin abstraction layer above
  31  * SEC commands set; the resulting code is compact and similar to a
  32  * descriptor sequence.
  33  *
  34  * RTA library improves comprehension of the SEC code, adds flexibility for
  35  * writing complex descriptors and keeps the code lightweight. Should be used
  36  * by whom needs to encode descriptors at runtime, with comprehensible flow
  37  * control in descriptor.
  38  */
  39
  40 /**
  41  * DOC: Usage
  42  *
  43  * RTA is used in kernel space by the SEC / CAAM (Cryptographic Acceleration and
  44  * Assurance Module) kernel module (drivers/crypto/caam) and SEC / CAAM QI
  45  * kernel module (Freescale QorIQ SDK).
  46  *
  47  * RTA is used in user space by USDPAA - User Space DataPath Acceleration
  48  * Architecture (Freescale QorIQ SDK).
  49  */
  50
  51 /**
  52  * DOC: Descriptor Buffer Management Routines
  53  *
  54  * Contains details of RTA descriptor buffer management and SEC Era
  55  * management routines.
  56  */
  57
  58 /**
  59  * PROGRAM_CNTXT_INIT - must be called before any descriptor run-time assembly
  60  *                      call type field carry info i.e. whether descriptor is
  61  *                      shared or job descriptor.
  62  * @program: pointer to struct program
  63  * @buffer: input buffer where the descriptor will be placed (uint32_t *)
  64  * @offset: offset in input buffer from where the data will be written
  65  *          (unsigned int)
  66  */
  67 #define PROGRAM_CNTXT_INIT(program, buffer, offset) \
  68         rta_program_cntxt_init(program, buffer, offset)
  69
  70 /**
  71  * PROGRAM_FINALIZE - must be called to mark completion of RTA call.
  72  * @program: pointer to struct program
  73  *
  74  * Return: total size of the descriptor in words or negative number on error.
  75  */
  76 #define PROGRAM_FINALIZE(program) rta_program_finalize(program)
  77
  78 /**
  79  * PROGRAM_SET_36BIT_ADDR - must be called to set pointer size to 36 bits
  80  * @program: pointer to struct program
  81  *
  82  * Return: current size of the descriptor in words (unsigned int).
  83  */
  84 #define PROGRAM_SET_36BIT_ADDR(program) rta_program_set_36bit_addr(program)
  85
  86 /**
  87  * PROGRAM_SET_BSWAP - must be called to enable byte swapping
  88  * @program: pointer to struct program
  89  *
  90  * Byte swapping on a 4-byte boundary will be performed at the end - when
  91  * calling PROGRAM_FINALIZE().
  92  *
  93  * Return: current size of the descriptor in words (unsigned int).
  94  */
  95 #define PROGRAM_SET_BSWAP(program) rta_program_set_bswap(program)
  96
  97 /**
  98  * WORD - must be called to insert in descriptor buffer a 32bit value
  99  * @program: pointer to struct program
 100  * @val: input value to be written in descriptor buffer (uint32_t)
 101  *
 102  * Return: the descriptor buffer offset where this command is inserted
 103  * (unsigned int).
 104  */
 105 #define WORD(program, val) rta_word(program, val)
 106
 107 /**
 108  * DWORD - must be called to insert in descriptor buffer a 64bit value
 109  * @program: pointer to struct program
 110  * @val: input value to be written in descriptor buffer (uint64_t)
 111  *
 112  * Return: the descriptor buffer offset where this command is inserted
 113  * (unsigned int).
 114  */
 115 #define DWORD(program, val) rta_dword(program, val)
 116
 117 /**
 118  * COPY_DATA - must be called to insert in descriptor buffer data larger than
 119  *             64bits.
 120  * @program: pointer to struct program
 121  * @data: input data to be written in descriptor buffer (uint8_t *)
 122  * @len: length of input data (unsigned int)
 123  *
 124  * Return: the descriptor buffer offset where this command is inserted
 125  * (unsigned int).
 126  */
 127 #define COPY_DATA(program, data, len) rta_copy_data(program, (data), (len))
 128
 129 /**
 130  * DESC_LEN -  determines job / shared descriptor buffer length (in words)
 131  * @buffer: descriptor buffer (uint32_t *)
 132  *
 133  * Return: descriptor buffer length in words (unsigned int).
 134  */
 135 #define DESC_LEN(buffer) rta_desc_len(buffer)
 136
 137 /**
 138  * DESC_BYTES - determines job / shared descriptor buffer length (in bytes)
 139  * @buffer: descriptor buffer (uint32_t *)
 140  *
 141  * Return: descriptor buffer length in bytes (unsigned int).
 142  */
 143 #define DESC_BYTES(buffer) rta_desc_bytes(buffer)
 144
 145 /*
 146  * SEC HW block revision.
 147  *
 148  * This *must not be confused with SEC version*:
 149  * - SEC HW block revision format is "v"
 150  * - SEC revision format is "x.y"
 151  */
 152 extern enum rta_sec_era rta_sec_era;
 153
 154 /**
 155  * rta_set_sec_era - Set SEC Era HW block revision for which the RTA library
 156  *                   will generate the descriptors.
 157  * @era: SEC Era (enum rta_sec_era)
 158  *
 159  * Return: 0 if the ERA was set successfully, -1 otherwise (int)
 160  *
 161  * Warning 1: Must be called *only once*, *before* using any other RTA API
 162  * routine.
 163  *
 164  * Warning 2: *Not thread safe*.
 165  */
 166 static inline int
 167 rta_set_sec_era(enum rta_sec_era era)
 168 {
 169         if (era > MAX_SEC_ERA) {
 170                 rta_sec_era = DEFAULT_SEC_ERA;
 171                 pr_err("Unsupported SEC ERA. Defaulting to ERA %d\n",
 172                        DEFAULT_SEC_ERA + 1);
 173                 return -1;
 174         }
 175
 176         rta_sec_era = era;
 177         return 0;
 178 }
 179
 180 /**
 181  * rta_get_sec_era - Get SEC Era HW block revision for which the RTA library
 182  *                   will generate the descriptors.
 183  *
 184  * Return: SEC Era (unsigned int).
 185  */
 186 static inline unsigned int
 187 rta_get_sec_era(void)
 188 {
 189         return rta_sec_era;
 190 }
 191
 192 /**
 193  * DOC: SEC Commands Routines
 194  *
 195  * Contains details of RTA wrapper routines over SEC engine commands.
 196  */
 197
 198 /**
 199  * SHR_HDR - Configures Shared Descriptor HEADER command
 200  * @program: pointer to struct program
 201  * @share: descriptor share state (enum rta_share_type)
 202  * @start_idx: index in descriptor buffer where the execution of the shared
 203  *             descriptor should start (@c unsigned int).
 204  * @flags: operational flags: RIF, DNR, CIF, SC, PD
 205  *
 206  * Return: On success, descriptor buffer offset where this command is inserted.
 207  *         On error, a negative error code; first error program counter will
 208  *         point to offset in descriptor buffer where the instruction should
 209  *         have been written.
 210  */
 211 #define SHR_HDR(program, share, start_idx, flags) \
 212         rta_shr_header(program, share, start_idx, flags)
 213
 214 /**
 215  * JOB_HDR - Configures JOB Descriptor HEADER command
 216  * @program: pointer to struct program
 217  * @share: descriptor share state (enum rta_share_type)
 218  * @start_idx: index in descriptor buffer where the execution of the job
 219  *            descriptor should start (unsigned int). In case SHR bit is present
 220  *            in flags, this will be the shared descriptor length.
 221  * @share_desc: pointer to shared descriptor, in case SHR bit is set (uint64_t)
 222  * @flags: operational flags: RSMS, DNR, TD, MTD, REO, SHR
 223  *
 224  * Return: On success, descriptor buffer offset where this command is inserted.
 225  *         On error, a negative error code; first error program counter will
 226  *         point to offset in descriptor buffer where the instruction should
 227  *         have been written.
 228  */
 229 #define JOB_HDR(program, share, start_idx, share_desc, flags) \
 230         rta_job_header(program, share, start_idx, share_desc, flags, 0)
 231
 232 /**
 233  * JOB_HDR_EXT - Configures JOB Descriptor HEADER command
 234  * @program: pointer to struct program
 235  * @share: descriptor share state (enum rta_share_type)
 236  * @start_idx: index in descriptor buffer where the execution of the job
 237  *            descriptor should start (unsigned int). In case SHR bit is present
 238  *            in flags, this will be the shared descriptor length.
 239  * @share_desc: pointer to shared descriptor, in case SHR bit is set (uint64_t)
 240  * @flags: operational flags: RSMS, DNR, TD, MTD, REO, SHR
 241  * @ext_flags: extended header flags: DSV (DECO Select Valid), DECO Id (limited
 242  *             by DSEL_MASK).
 243  *
 244  * Return: On success, descriptor buffer offset where this command is inserted.
 245  *         On error, a negative error code; first error program counter will
 246  *         point to offset in descriptor buffer where the instruction should
 247  *         have been written.
 248  */
 249 #define JOB_HDR_EXT(program, share, start_idx, share_desc, flags, ext_flags) \
 250         rta_job_header(program, share, start_idx, share_desc, flags | EXT, \
 251                        ext_flags)
 252
 253 /**
 254  * MOVE - Configures MOVE and MOVE_LEN commands
 255  * @program: pointer to struct program
 256  * @src: internal source of data that will be moved: CONTEXT1, CONTEXT2, OFIFO,
 257  *       DESCBUF, MATH0-MATH3, IFIFOABD, IFIFOAB1, IFIFOAB2, AB1, AB2, ABD.
 258  * @src_offset: offset in source data (uint16_t)
 259  * @dst: internal destination of data that will be moved: CONTEXT1, CONTEXT2,
 260  *       OFIFO, DESCBUF, MATH0-MATH3, IFIFOAB1, IFIFOAB2, IFIFO, PKA, KEY1,
 261  *       KEY2, ALTSOURCE.
 262  * @dst_offset: offset in destination data (uint16_t)
 263  * @length: size of data to be moved: for MOVE must be specified as immediate
 264  *          value and IMMED flag must be set; for MOVE_LEN must be specified
 265  *          using MATH0-MATH3.
 266  * @opt: operational flags: WAITCOMP, FLUSH1, FLUSH2, LAST1, LAST2, SIZE_WORD,
 267  *       SIZE_BYTE, SIZE_DWORD, IMMED (not valid for MOVE_LEN).
 268  *
 269  * Return: On success, descriptor buffer offset where this command is inserted.
 270  *         On error, a negative error code; first error program counter will
 271  *         point to offset in descriptor buffer where the instruction should
 272  *         have been written.
 273  */
 274 #define MOVE(program, src, src_offset, dst, dst_offset, length, opt) \
 275         rta_move(program, __MOVE, src, src_offset, dst, dst_offset, length, opt)
 276
 277 /**
 278  * MOVEB - Configures MOVEB command
 279  * @program: pointer to struct program
 280  * @src: internal source of data that will be moved: CONTEXT1, CONTEXT2, OFIFO,
 281  *       DESCBUF, MATH0-MATH3, IFIFOABD, IFIFOAB1, IFIFOAB2, AB1, AB2, ABD.
 282  * @src_offset: offset in source data (uint16_t)
 283  * @dst: internal destination of data that will be moved: CONTEXT1, CONTEXT2,
 284  *       OFIFO, DESCBUF, MATH0-MATH3, IFIFOAB1, IFIFOAB2, IFIFO, PKA, KEY1,
 285  *       KEY2, ALTSOURCE.
 286  * @dst_offset: offset in destination data (uint16_t)
 287  * @length: size of data to be moved: for MOVE must be specified as immediate
 288  *          value and IMMED flag must be set; for MOVE_LEN must be specified
 289  *          using MATH0-MATH3.
 290  * @opt: operational flags: WAITCOMP, FLUSH1, FLUSH2, LAST1, LAST2, SIZE_WORD,
 291  *       SIZE_BYTE, SIZE_DWORD, IMMED (not valid for MOVE_LEN).
 292  *
 293  * Identical with MOVE command if byte swapping not enabled; else - when src/dst
 294  * is descriptor buffer or MATH registers, data type is byte array when MOVE
 295  * data type is 4-byte array and vice versa.
 296  *
 297  * Return: On success, descriptor buffer offset where this command is inserted.
 298  *         On error, a negative error code; first error program counter will
 299  *         point to offset in descriptor buffer where the instruction should
 300  *         have been written.
 301  */
 302 #define MOVEB(program, src, src_offset, dst, dst_offset, length, opt) \
 303         rta_move(program, __MOVEB, src, src_offset, dst, dst_offset, length, \
 304                  opt)
 305
 306 /**
 307  * MOVEDW - Configures MOVEDW command
 308  * @program: pointer to struct program
 309  * @src: internal source of data that will be moved: CONTEXT1, CONTEXT2, OFIFO,
 310  *       DESCBUF, MATH0-MATH3, IFIFOABD, IFIFOAB1, IFIFOAB2, AB1, AB2, ABD.
 311  * @src_offset: offset in source data (uint16_t)
 312  * @dst: internal destination of data that will be moved: CONTEXT1, CONTEXT2,
 313  *       OFIFO, DESCBUF, MATH0-MATH3, IFIFOAB1, IFIFOAB2, IFIFO, PKA, KEY1,
 314  *       KEY2, ALTSOURCE.
 315  * @dst_offset: offset in destination data (uint16_t)
 316  * @length: size of data to be moved: for MOVE must be specified as immediate
 317  *          value and IMMED flag must be set; for MOVE_LEN must be specified
 318  *          using MATH0-MATH3.
 319  * @opt: operational flags: WAITCOMP, FLUSH1, FLUSH2, LAST1, LAST2, SIZE_WORD,
 320  *       SIZE_BYTE, SIZE_DWORD, IMMED (not valid for MOVE_LEN).
 321  *
 322  * Identical with MOVE command, with the following differences: data type is
 323  * 8-byte array; word swapping is performed when SEC is programmed in little
 324  * endian mode.
 325  *
 326  * Return: On success, descriptor buffer offset where this command is inserted.
 327  *         On error, a negative error code; first error program counter will
 328  *         point to offset in descriptor buffer where the instruction should
 329  *         have been written.
 330  */
 331 #define MOVEDW(program, src, src_offset, dst, dst_offset, length, opt) \
 332         rta_move(program, __MOVEDW, src, src_offset, dst, dst_offset, length, \
 333                  opt)
 334
 335 /**
 336  * FIFOLOAD - Configures FIFOLOAD command to load message data, PKHA data, IV,
 337  *            ICV, AAD and bit length message data into Input Data FIFO.
 338  * @program: pointer to struct program
 339  * @data: input data type to store: PKHA registers, IFIFO, MSG1, MSG2,
 340  *        MSGOUTSNOOP, MSGINSNOOP, IV1, IV2, AAD1, ICV1, ICV2, BIT_DATA, SKIP.
 341  * @src: pointer or actual data in case of immediate load; IMMED, COPY and DCOPY
 342  *       flags indicate action taken (inline imm data, inline ptr, inline from
 343  *       ptr).
 344  * @length: number of bytes to load (uint32_t)
 345  * @flags: operational flags: SGF, IMMED, EXT, CLASS1, CLASS2, BOTH, FLUSH1,
 346  *         LAST1, LAST2, COPY, DCOPY.
 347  *
 348  * Return: On success, descriptor buffer offset where this command is inserted.
 349  *         On error, a negative error code; first error program counter will
 350  *         point to offset in descriptor buffer where the instruction should
 351  *         have been written.
 352  */
 353 #define FIFOLOAD(program, data, src, length, flags) \
 354         rta_fifo_load(program, data, src, length, flags)
 355
 356 /**
 357  * SEQFIFOLOAD - Configures SEQ FIFOLOAD command to load message data, PKHA
 358  *               data, IV, ICV, AAD and bit length message data into Input Data
 359  *               FIFO.
 360  * @program: pointer to struct program
 361  * @data: input data type to store: PKHA registers, IFIFO, MSG1, MSG2,
 362  *        MSGOUTSNOOP, MSGINSNOOP, IV1, IV2, AAD1, ICV1, ICV2, BIT_DATA, SKIP.
 363  * @length: number of bytes to load; can be set to 0 for SEQ command w/ VLF set
 364  *          (uint32_t).
 365  * @flags: operational flags: VLF, CLASS1, CLASS2, BOTH, FLUSH1, LAST1, LAST2,
 366  *         AIDF.
 367  *
 368  * Return: On success, descriptor buffer offset where this command is inserted.
 369  *         On error, a negative error code; first error program counter will
 370  *         point to offset in descriptor buffer where the instruction should
 371  *         have been written.
 372  */
 373 #define SEQFIFOLOAD(program, data, length, flags) \
 374         rta_fifo_load(program, data, NONE, length, flags|SEQ)
 375
 376 /**
 377  * FIFOSTORE - Configures FIFOSTORE command, to move data from Output Data FIFO
 378  *             to external memory via DMA.
 379  * @program: pointer to struct program
 380  * @data: output data type to store: PKHA registers, IFIFO, OFIFO, RNG,
 381  *        RNGOFIFO, AFHA_SBOX, MDHA_SPLIT_KEY, MSG, KEY1, KEY2, SKIP.
 382  * @encrypt_flags: store data encryption mode: EKT, TK
 383  * @dst: pointer to store location (uint64_t)
 384  * @length: number of bytes to load (uint32_t)
 385  * @flags: operational flags: SGF, CONT, EXT, CLASS1, CLASS2, BOTH
 386  *
 387  * Return: On success, descriptor buffer offset where this command is inserted.
 388  *         On error, a negative error code; first error program counter will
 389  *         point to offset in descriptor buffer where the instruction should
 390  *         have been written.
 391  */
 392 #define FIFOSTORE(program, data, encrypt_flags, dst, length, flags) \
 393         rta_fifo_store(program, data, encrypt_flags, dst, length, flags)
 394
 395 /**
 396  * SEQFIFOSTORE - Configures SEQ FIFOSTORE command, to move data from Output
 397  *                Data FIFO to external memory via DMA.
 398  * @program: pointer to struct program
 399  * @data: output data type to store: PKHA registers, IFIFO, OFIFO, RNG,
 400  *        RNGOFIFO, AFHA_SBOX, MDHA_SPLIT_KEY, MSG, KEY1, KEY2, METADATA, SKIP.
 401  * @encrypt_flags: store data encryption mode: EKT, TK
 402  * @length: number of bytes to load; can be set to 0 for SEQ command w/ VLF set
 403  *          (uint32_t).
 404  * @flags: operational flags: VLF, CONT, EXT, CLASS1, CLASS2, BOTH
 405  *
 406  * Return: On success, descriptor buffer offset where this command is inserted.
 407  *         On error, a negative error code; first error program counter will
 408  *         point to offset in descriptor buffer where the instruction should
 409  *         have been written.
 410  */
 411 #define SEQFIFOSTORE(program, data, encrypt_flags, length, flags) \
 412         rta_fifo_store(program, data, encrypt_flags, 0, length, flags|SEQ)
 413
 414 /**
 415  * KEY - Configures KEY and SEQ KEY commands
 416  * @program: pointer to struct program
 417  * @key_dst: key store location: KEY1, KEY2, PKE, AFHA_SBOX, MDHA_SPLIT_KEY
 418  * @encrypt_flags: key encryption mode: ENC, EKT, TK, NWB, PTS
 419  * @src: pointer or actual data in case of immediate load (uint64_t); IMMED,
 420  *       COPY and DCOPY flags indicate action taken (inline imm data,
 421  *       inline ptr, inline from ptr).
 422  * @length: number of bytes to load; can be set to 0 for SEQ command w/ VLF set
 423  *          (uint32_t).
 424  * @flags: operational flags: for KEY: SGF, IMMED, COPY, DCOPY; for SEQKEY: SEQ,
 425  *         VLF, AIDF.
 426  *
 427  * Return: On success, descriptor buffer offset where this command is inserted.
 428  *         On error, a negative error code; first error program counter will
 429  *         point to offset in descriptor buffer where the instruction should
 430  *         have been written.
 431  */
 432 #define KEY(program, key_dst, encrypt_flags, src, length, flags) \
 433         rta_key(program, key_dst, encrypt_flags, src, length, flags)
 434
 435 /**
 436  * SEQINPTR - Configures SEQ IN PTR command
 437  * @program: pointer to struct program
 438  * @src: starting address for Input Sequence (uint64_t)
 439  * @length: number of bytes in (or to be added to) Input Sequence (uint32_t)
 440  * @flags: operational flags: RBS, INL, SGF, PRE, EXT, RTO, RJD, SOP (when PRE,
 441  *         RTO or SOP are set, @src parameter must be 0).
 442  *
 443  * Return: On success, descriptor buffer offset where this command is inserted.
 444  *         On error, a negative error code; first error program counter will
 445  *         point to offset in descriptor buffer where the instruction should
 446  *         have been written.
 447  */
 448 #define SEQINPTR(program, src, length, flags) \
 449         rta_seq_in_ptr(program, src, length, flags)
 450
 451 /**
 452  * SEQOUTPTR - Configures SEQ OUT PTR command
 453  * @program: pointer to struct program
 454  * @dst: starting address for Output Sequence (uint64_t)
 455  * @length: number of bytes in (or to be added to) Output Sequence (uint32_t)
 456  * @flags: operational flags: SGF, PRE, EXT, RTO, RST, EWS (when PRE or RTO are
 457  *         set, @dst parameter must be 0).
 458  *
 459  * Return: On success, descriptor buffer offset where this command is inserted.
 460  *         On error, a negative error code; first error program counter will
 461  *         point to offset in descriptor buffer where the instruction should
 462  *         have been written.
 463  */
 464 #define SEQOUTPTR(program, dst, length, flags) \
 465         rta_seq_out_ptr(program, dst, length, flags)
 466
 467 /**
 468  * ALG_OPERATION - Configures ALGORITHM OPERATION command
 469  * @program: pointer to struct program
 470  * @cipher_alg: algorithm to be used
 471  * @aai: Additional Algorithm Information; contains mode information that is
 472  *       associated with the algorithm (check desc.h for specific values).
 473  * @algo_state: algorithm state; defines the state of the algorithm that is
 474  *              being executed (check desc.h file for specific values).
 475  * @icv_check: ICV checking; selects whether the algorithm should check
 476  *             calculated ICV with known ICV: ICV_CHECK_ENABLE,
 477  *             ICV_CHECK_DISABLE.
 478  * @enc: selects between encryption and decryption: DIR_ENC, DIR_DEC
 479  *
 480  * Return: On success, descriptor buffer offset where this command is inserted.
 481  *         On error, a negative error code; first error program counter will
 482  *         point to offset in descriptor buffer where the instruction should
 483  *         have been written.
 484  */
 485 #define ALG_OPERATION(program, cipher_alg, aai, algo_state, icv_check, enc) \
 486         rta_operation(program, cipher_alg, aai, algo_state, icv_check, enc)
 487
 488 #define ALG_OPERATION_NP(program, cipher_alg, aai, algo_state, icv_check, enc) \
 489         rta_operation2(program, cipher_alg, aai, algo_state, icv_check, enc)
 490
 491 /**
 492  * PROTOCOL - Configures PROTOCOL OPERATION command
 493  * @program: pointer to struct program
 494  * @optype: operation type: OP_TYPE_UNI_PROTOCOL / OP_TYPE_DECAP_PROTOCOL /
 495  *          OP_TYPE_ENCAP_PROTOCOL.
 496  * @protid: protocol identifier value (check desc.h file for specific values)
 497  * @protoinfo: protocol dependent value (check desc.h file for specific values)
 498  *
 499  * Return: On success, descriptor buffer offset where this command is inserted.
 500  *         On error, a negative error code; first error program counter will
 501  *         point to offset in descriptor buffer where the instruction should
 502  *         have been written.
 503  */
 504 #define PROTOCOL(program, optype, protid, protoinfo) \
 505         rta_proto_operation(program, optype, protid, protoinfo)
 506
 507 /**
 508  * DKP_PROTOCOL - Configures DKP (Derived Key Protocol) PROTOCOL command
 509  * @program: pointer to struct program
 510  * @protid: protocol identifier value - one of the following:
 511  *          OP_PCLID_DKP_{MD5 | SHA1 | SHA224 | SHA256 | SHA384 | SHA512}
 512  * @key_src: How the initial ("negotiated") key is provided to the DKP protocol.
 513  *           Valid values - one of OP_PCL_DKP_SRC_{IMM, SEQ, PTR, SGF}. Not all
 514  *           (key_src,key_dst) combinations are allowed.
 515  * @key_dst: How the derived ("split") key is returned by the DKP protocol.
 516  *           Valid values - one of OP_PCL_DKP_DST_{IMM, SEQ, PTR, SGF}. Not all
 517  *           (key_src,key_dst) combinations are allowed.
 518  * @keylen: length of the initial key, in bytes (uint16_t)
 519  * @key: address where algorithm key resides; virtual address if key_type is
 520  *       RTA_DATA_IMM, physical (bus) address if key_type is RTA_DATA_PTR or
 521  *       RTA_DATA_IMM_DMA.
 522  * @key_type: enum rta_data_type
 523  * Return: On success, descriptor buffer offset where this command is inserted.
 524  *         On error, a negative error code; first error program counter will
 525  *         point to offset in descriptor buffer where the instruction should
 526  *         have been written.
 527  */
 528 #define DKP_PROTOCOL(program, protid, key_src, key_dst, keylen, key, key_type) \
 529         rta_dkp_proto(program, protid, key_src, key_dst, keylen, key, key_type)
 530
 531 /**
 532  * PKHA_OPERATION - Configures PKHA OPERATION command
 533  * @program: pointer to struct program
 534  * @op_pkha: PKHA operation; indicates the modular arithmetic function to
 535  *           execute (check desc.h file for specific values).
 536  *
 537  * Return: On success, descriptor buffer offset where this command is inserted.
 538  *         On error, a negative error code; first error program counter will
 539  *         point to offset in descriptor buffer where the instruction should
 540  *         have been written.
 541  */
 542 #define PKHA_OPERATION(program, op_pkha)   rta_pkha_operation(program, op_pkha)
 543
 544 /**
 545  * JUMP - Configures JUMP command
 546  * @program: pointer to struct program
 547  * @addr: local offset for local jumps or address pointer for non-local jumps;
 548  *        IMM or PTR macros must be used to indicate type.
 549  * @jump_type: type of action taken by jump (enum rta_jump_type)
 550  * @test_type: defines how jump conditions are evaluated (enum rta_jump_cond)
 551  * @cond: jump conditions: operational flags - DONE1, DONE2, BOTH; various
 552  *        sharing and wait conditions (JSL = 1) - NIFP, NIP, NOP, NCP, CALM,
 553  *        SELF, SHARED, JQP; Math and PKHA status conditions (JSL = 0) - Z, N,
 554  *        NV, C, PK0, PK1, PKP.
 555  *
 556  * Return: On success, descriptor buffer offset where this command is inserted.
 557  *         On error, a negative error code; first error program counter will
 558  *         point to offset in descriptor buffer where the instruction should
 559  *         have been written.
 560  */
 561 #define JUMP(program, addr, jump_type, test_type, cond) \
 562         rta_jump(program, addr, jump_type, test_type, cond, NONE)
 563
 564 /**
 565  * JUMP_INC - Configures JUMP_INC command
 566  * @program: pointer to struct program
 567  * @addr: local offset; IMM or PTR macros must be used to indicate type
 568  * @test_type: defines how jump conditions are evaluated (enum rta_jump_cond)
 569  * @cond: jump conditions: Math status conditions (JSL = 0): Z, N, NV, C
 570  * @src_dst: register to increment / decrement: MATH0-MATH3, DPOVRD, SEQINSZ,
 571  *           SEQOUTSZ, VSEQINSZ, VSEQOUTSZ.
 572  *
 573  * Return: On success, descriptor buffer offset where this command is inserted.
 574  *         On error, a negative error code; first error program counter will
 575  *         point to offset in descriptor buffer where the instruction should
 576  *         have been written.
 577  */
 578 #define JUMP_INC(program, addr, test_type, cond, src_dst) \
 579         rta_jump(program, addr, LOCAL_JUMP_INC, test_type, cond, src_dst)
 580
 581 /**
 582  * JUMP_DEC - Configures JUMP_DEC command
 583  * @program: pointer to struct program
 584  * @addr: local offset; IMM or PTR macros must be used to indicate type
 585  * @test_type: defines how jump conditions are evaluated (enum rta_jump_cond)
 586  * @cond: jump conditions: Math status conditions (JSL = 0): Z, N, NV, C
 587  * @src_dst: register to increment / decrement: MATH0-MATH3, DPOVRD, SEQINSZ,
 588  *           SEQOUTSZ, VSEQINSZ, VSEQOUTSZ.
 589  *
 590  * Return: On success, descriptor buffer offset where this command is inserted.
 591  *         On error, a negative error code; first error program counter will
 592  *         point to offset in descriptor buffer where the instruction should
 593  *         have been written.
 594  */
 595 #define JUMP_DEC(program, addr, test_type, cond, src_dst) \
 596         rta_jump(program, addr, LOCAL_JUMP_DEC, test_type, cond, src_dst)
 597
 598 /**
 599  * LOAD - Configures LOAD command to load data registers from descriptor or from
 600  *        a memory location.
 601  * @program: pointer to struct program
 602  * @addr: immediate value or pointer to the data to be loaded; IMMED, COPY and
 603  *        DCOPY flags indicate action taken (inline imm data, inline ptr, inline
 604  *        from ptr).
 605  * @dst: destination register (uint64_t)
 606  * @offset: start point to write data in destination register (uint32_t)
 607  * @length: number of bytes to load (uint32_t)
 608  * @flags: operational flags: VLF, IMMED, COPY, DCOPY
 609  *
 610  * Return: On success, descriptor buffer offset where this command is inserted.
 611  *         On error, a negative error code; first error program counter will
 612  *         point to offset in descriptor buffer where the instruction should
 613  *         have been written.
 614  */
 615 #define LOAD(program, addr, dst, offset, length, flags) \
 616         rta_load(program, addr, dst, offset, length, flags)
 617
 618 /**
 619  * SEQLOAD - Configures SEQ LOAD command to load data registers from descriptor
 620  *           or from a memory location.
 621  * @program: pointer to struct program
 622  * @dst: destination register (uint64_t)
 623  * @offset: start point to write data in destination register (uint32_t)
 624  * @length: number of bytes to load (uint32_t)
 625  * @flags: operational flags: SGF
 626  *
 627  * Return: On success, descriptor buffer offset where this command is inserted.
 628  *         On error, a negative error code; first error program counter will
 629  *         point to offset in descriptor buffer where the instruction should
 630  *         have been written.
 631  */
 632 #define SEQLOAD(program, dst, offset, length, flags) \
 633         rta_load(program, NONE, dst, offset, length, flags|SEQ)
 634
 635 /**
 636  * STORE - Configures STORE command to read data from registers and write them
 637  *         to a memory location.
 638  * @program: pointer to struct program
 639  * @src: immediate value or source register for data to be stored: KEY1SZ,
 640  *       KEY2SZ, DJQDA, MODE1, MODE2, DJQCTRL, DATA1SZ, DATA2SZ, DSTAT, ICV1SZ,
 641  *       ICV2SZ, DPID, CCTRL, ICTRL, CLRW, CSTAT, MATH0-MATH3, PKHA registers,
 642  *       CONTEXT1, CONTEXT2, DESCBUF, JOBDESCBUF, SHAREDESCBUF. In case of
 643  *       immediate value, IMMED, COPY and DCOPY flags indicate action taken
 644  *       (inline imm data, inline ptr, inline from ptr).
 645  * @offset: start point for reading from source register (uint16_t)
 646  * @dst: pointer to store location (uint64_t)
 647  * @length: number of bytes to store (uint32_t)
 648  * @flags: operational flags: VLF, IMMED, COPY, DCOPY
 649  *
 650  * Return: On success, descriptor buffer offset where this command is inserted.
 651  *         On error, a negative error code; first error program counter will
 652  *         point to offset in descriptor buffer where the instruction should
 653  *         have been written.
 654  */
 655 #define STORE(program, src, offset, dst, length, flags) \
 656         rta_store(program, src, offset, dst, length, flags)
 657
 658 /**
 659  * SEQSTORE - Configures SEQ STORE command to read data from registers and write
 660  *            them to a memory location.
 661  * @program: pointer to struct program
 662  * @src: immediate value or source register for data to be stored: KEY1SZ,
 663  *       KEY2SZ, DJQDA, MODE1, MODE2, DJQCTRL, DATA1SZ, DATA2SZ, DSTAT, ICV1SZ,
 664  *       ICV2SZ, DPID, CCTRL, ICTRL, CLRW, CSTAT, MATH0-MATH3, PKHA registers,
 665  *       CONTEXT1, CONTEXT2, DESCBUF, JOBDESCBUF, SHAREDESCBUF. In case of
 666  *       immediate value, IMMED, COPY and DCOPY flags indicate action taken
 667  *       (inline imm data, inline ptr, inline from ptr).
 668  * @offset: start point for reading from source register (uint16_t)
 669  * @length: number of bytes to store (uint32_t)
 670  * @flags: operational flags: SGF, IMMED, COPY, DCOPY
 671  *
 672  * Return: On success, descriptor buffer offset where this command is inserted.
 673  *         On error, a negative error code; first error program counter will
 674  *         point to offset in descriptor buffer where the instruction should
 675  *         have been written.
 676  */
 677 #define SEQSTORE(program, src, offset, length, flags) \
 678         rta_store(program, src, offset, NONE, length, flags|SEQ)
 679
 680 /**
 681  * MATHB - Configures MATHB command to perform binary operations
 682  * @program: pointer to struct program
 683  * @operand1: first operand: MATH0-MATH3, DPOVRD, SEQINSZ, SEQOUTSZ, VSEQINSZ,
 684  *            VSEQOUTSZ, ZERO, ONE, NONE, Immediate value. IMMED must be used to
 685  *            indicate immediate value.
 686  * @operator: function to be performed: ADD, ADDC, SUB, SUBB, OR, AND, XOR,
 687  *            LSHIFT, RSHIFT, SHLD.
 688  * @operand2: second operand: MATH0-MATH3, DPOVRD, VSEQINSZ, VSEQOUTSZ, ABD,
 689  *            OFIFO, JOBSRC, ZERO, ONE, Immediate value. IMMED2 must be used to
 690  *            indicate immediate value.
 691  * @result: destination for the result: MATH0-MATH3, DPOVRD, SEQINSZ, SEQOUTSZ,
 692  *          NONE, VSEQINSZ, VSEQOUTSZ.
 693  * @length: length in bytes of the operation and the immediate value, if there
 694  *          is one (int).
 695  * @opt: operational flags: IFB, NFU, STL, SWP, IMMED, IMMED2
 696  *
 697  * Return: On success, descriptor buffer offset where this command is inserted.
 698  *         On error, a negative error code; first error program counter will
 699  *         point to offset in descriptor buffer where the instruction should
 700  *         have been written.
 701  */
 702 #define MATHB(program, operand1, operator, operand2, result, length, opt) \
 703         rta_math(program, operand1, MATH_FUN_##operator, operand2, result, \
 704                  length, opt)
 705
 706 /**
 707  * MATHI - Configures MATHI command to perform binary operations
 708  * @program: pointer to struct program
 709  * @operand: if !SSEL: MATH0-MATH3, DPOVRD, SEQINSZ, SEQOUTSZ, VSEQINSZ,
 710  *           VSEQOUTSZ, ZERO, ONE.
 711  *           if SSEL: MATH0-MATH3, DPOVRD, VSEQINSZ, VSEQOUTSZ, ABD, OFIFO,
 712  *           JOBSRC, ZERO, ONE.
 713  * @operator: function to be performed: ADD, ADDC, SUB, SUBB, OR, AND, XOR,
 714  *            LSHIFT, RSHIFT, FBYT (for !SSEL only).
 715  * @imm: Immediate value (uint8_t). IMMED must be used to indicate immediate
 716  *       value.
 717  * @result: destination for the result: MATH0-MATH3, DPOVRD, SEQINSZ, SEQOUTSZ,
 718  *          NONE, VSEQINSZ, VSEQOUTSZ.
 719  * @length: length in bytes of the operation and the immediate value, if there
 720  *          is one (int). @imm is left-extended with zeros if needed.
 721  * @opt: operational flags: NFU, SSEL, SWP, IMMED
 722  *
 723  * If !SSEL, @operand <@operator> @imm -> @result
 724  * If SSEL, @imm <@operator> @operand -> @result
 725  *
 726  * Return: On success, descriptor buffer offset where this command is inserted.
 727  *         On error, a negative error code; first error program counter will
 728  *         point to offset in descriptor buffer where the instruction should
 729  *         have been written.
 730  */
 731 #define MATHI(program, operand, operator, imm, result, length, opt) \
 732         rta_mathi(program, operand, MATH_FUN_##operator, imm, result, length, \
 733                   opt)
 734
 735 /**
 736  * MATHU - Configures MATHU command to perform unary operations
 737  * @program: pointer to struct program
 738  * @operand1: operand: MATH0-MATH3, DPOVRD, SEQINSZ, SEQOUTSZ, VSEQINSZ,
 739  *            VSEQOUTSZ, ZERO, ONE, NONE, Immediate value. IMMED must be used to
 740  *            indicate immediate value.
 741  * @operator: function to be performed: ZBYT, BSWAP
 742  * @result: destination for the result: MATH0-MATH3, DPOVRD, SEQINSZ, SEQOUTSZ,
 743  *          NONE, VSEQINSZ, VSEQOUTSZ.
 744  * @length: length in bytes of the operation and the immediate value, if there
 745  *          is one (int).
 746  * @opt: operational flags: NFU, STL, SWP, IMMED
 747  *
 748  * Return: On success, descriptor buffer offset where this command is inserted.
 749  *         On error, a negative error code; first error program counter will
 750  *         point to offset in descriptor buffer where the instruction should
 751  *         have been written.
 752  */
 753 #define MATHU(program, operand1, operator, result, length, opt) \
 754         rta_math(program, operand1, MATH_FUN_##operator, NONE, result, length, \
 755                  opt)
 756
 757 /**
 758  * SIGNATURE - Configures SIGNATURE command
 759  * @program: pointer to struct program
 760  * @sign_type: signature type: SIGN_TYPE_FINAL, SIGN_TYPE_FINAL_RESTORE,
 761  *             SIGN_TYPE_FINAL_NONZERO, SIGN_TYPE_IMM_2, SIGN_TYPE_IMM_3,
 762  *             SIGN_TYPE_IMM_4.
 763  *
 764  * After SIGNATURE command, DWORD or WORD must be used to insert signature in
 765  * descriptor buffer.
 766  *
 767  * Return: On success, descriptor buffer offset where this command is inserted.
 768  *         On error, a negative error code; first error program counter will
 769  *         point to offset in descriptor buffer where the instruction should
 770  *         have been written.
 771  */
 772 #define SIGNATURE(program, sign_type)   rta_signature(program, sign_type)
 773
 774 /**
 775  * NFIFOADD - Configures NFIFO command, a shortcut of RTA Load command to write
 776  *            to iNfo FIFO.
 777  * @program: pointer to struct program
 778  * @src: source for the input data in Alignment Block:IFIFO, OFIFO, PAD,
 779  *       MSGOUTSNOOP, ALTSOURCE, OFIFO_SYNC, MSGOUTSNOOP_ALT.
 780  * @data: type of data that is going through the Input Data FIFO: MSG, MSG1,
 781  *        MSG2, IV1, IV2, ICV1, ICV2, SAD1, AAD1, AAD2, AFHA_SBOX, SKIP,
 782  *        PKHA registers, AB1, AB2, ABD.
 783  * @length: length of the data copied in FIFO registers (uint32_t)
 784  * @flags: select options between:
 785  *         -operational flags: LAST1, LAST2, FLUSH1, FLUSH2, OC, BP
 786  *         -when PAD is selected as source: BM, PR, PS
 787  *         -padding type: <em>PAD_ZERO, PAD_NONZERO, PAD_INCREMENT, PAD_RANDOM,
 788  *          PAD_ZERO_N1, PAD_NONZERO_0, PAD_N1, PAD_NONZERO_N
 789  *
 790  * Return: On success, descriptor buffer offset where this command is inserted.
 791  *         On error, a negative error code; first error program counter will
 792  *         point to offset in descriptor buffer where the instruction should
 793  *         have been written.
 794  */
 795 #define NFIFOADD(program, src, data, length, flags) \
 796         rta_nfifo_load(program, src, data, length, flags)
 797
 798 /**
 799  * DOC: Self Referential Code Management Routines
 800  *
 801  * Contains details of RTA self referential code routines.
 802  */
 803
 804 /**
 805  * REFERENCE - initialize a variable used for storing an index inside a
 806  *             descriptor buffer.
 807  * @ref: reference to a descriptor buffer's index where an update is required
 808  *       with a value that will be known latter in the program flow.
 809  */
 810 #define REFERENCE(ref)    int ref = -1
 811
 812 /**
 813  * LABEL - initialize a variable used for storing an index inside a descriptor
 814  *         buffer.
 815  * @label: label stores the value with what should be updated the REFERENCE line
 816  *         in the descriptor buffer.
 817  */
 818 #define LABEL(label)      unsigned int label = 0
 819
 820 /**
 821  * SET_LABEL - set a LABEL value
 822  * @program: pointer to struct program
 823  * @label: value that will be inserted in a line previously written in the
 824  *         descriptor buffer.
 825  */
 826 #define SET_LABEL(program, label)  (label = rta_set_label(program))
 827
 828 /**
 829  * PATCH_JUMP - Auxiliary command to resolve self referential code
 830  * @program: buffer to be updated (struct program *)
 831  * @line: position in descriptor buffer where the update will be done; this
 832  *        value is previously retained in program flow using a reference near
 833  *        the sequence to be modified.
 834  * @new_ref: updated value that will be inserted in descriptor buffer at the
 835  *          specified line; this value is previously obtained using SET_LABEL
 836  *          macro near the line that will be used as reference (unsigned int).
 837  *          For JUMP command, the value represents the offset field (in words).
 838  *
 839  * Return: 0 in case of success, a negative error code if it fails
 840  */
 841 #define PATCH_JUMP(program, line, new_ref) rta_patch_jmp(program, line, new_ref)
 842
 843 /**
 844  * PATCH_MOVE - Auxiliary command to resolve self referential code
 845  * @program: buffer to be updated (struct program *)
 846  * @line: position in descriptor buffer where the update will be done; this
 847  *        value is previously retained in program flow using a reference near
 848  *        the sequence to be modified.
 849  * @new_ref: updated value that will be inserted in descriptor buffer at the
 850  *          specified line; this value is previously obtained using SET_LABEL
 851  *          macro near the line that will be used as reference (unsigned int).
 852  *          For MOVE command, the value represents the offset field (in words).
 853  *
 854  * Return: 0 in case of success, a negative error code if it fails
 855  */
 856 #define PATCH_MOVE(program, line, new_ref) \
 857         rta_patch_move(program, line, new_ref)
 858
 859 /**
 860  * PATCH_LOAD - Auxiliary command to resolve self referential code
 861  * @program: buffer to be updated (struct program *)
 862  * @line: position in descriptor buffer where the update will be done; this
 863  *        value is previously retained in program flow using a reference near
 864  *        the sequence to be modified.
 865  * @new_ref: updated value that will be inserted in descriptor buffer at the
 866  *          specified line; this value is previously obtained using SET_LABEL
 867  *          macro near the line that will be used as reference (unsigned int).
 868  *          For LOAD command, the value represents the offset field (in words).
 869  *
 870  * Return: 0 in case of success, a negative error code if it fails
 871  */
 872 #define PATCH_LOAD(program, line, new_ref) \
 873         rta_patch_load(program, line, new_ref)
 874
 875 /**
 876  * PATCH_STORE - Auxiliary command to resolve self referential code
 877  * @program: buffer to be updated (struct program *)
 878  * @line: position in descriptor buffer where the update will be done; this
 879  *        value is previously retained in program flow using a reference near
 880  *        the sequence to be modified.
 881  * @new_ref: updated value that will be inserted in descriptor buffer at the
 882  *          specified line; this value is previously obtained using SET_LABEL
 883  *          macro near the line that will be used as reference (unsigned int).
 884  *          For STORE command, the value represents the offset field (in words).
 885  *
 886  * Return: 0 in case of success, a negative error code if it fails
 887  */
 888 #define PATCH_STORE(program, line, new_ref) \
 889         rta_patch_store(program, line, new_ref)
 890
 891 /**
 892  * PATCH_HDR - Auxiliary command to resolve self referential code
 893  * @program: buffer to be updated (struct program *)
 894  * @line: position in descriptor buffer where the update will be done; this
 895  *        value is previously retained in program flow using a reference near
 896  *        the sequence to be modified.
 897  * @new_ref: updated value that will be inserted in descriptor buffer at the
 898  *          specified line; this value is previously obtained using SET_LABEL
 899  *          macro near the line that will be used as reference (unsigned int).
 900  *          For HEADER command, the value represents the start index field.
 901  *
 902  * Return: 0 in case of success, a negative error code if it fails
 903  */
 904 #define PATCH_HDR(program, line, new_ref) \
 905         rta_patch_header(program, line, new_ref)
 906
 907 /**
 908  * PATCH_RAW - Auxiliary command to resolve self referential code
 909  * @program: buffer to be updated (struct program *)
 910  * @line: position in descriptor buffer where the update will be done; this
 911  *        value is previously retained in program flow using a reference near
 912  *        the sequence to be modified.
 913  * @mask: mask to be used for applying the new value (unsigned int). The mask
 914  *        selects which bits from the provided @new_val are taken into
 915  *        consideration when overwriting the existing value.
 916  * @new_val: updated value that will be masked using the provided mask value
 917  *           and inserted in descriptor buffer at the specified line.
 918  *
 919  * Return: 0 in case of success, a negative error code if it fails
 920  */
 921 #define PATCH_RAW(program, line, mask, new_val) \
 922         rta_patch_raw(program, line, mask, new_val)
 923
 924 #endif /* __RTA_RTA_H__ */