--- /dev/null
+/* SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0)
+ *
+ * Copyright 2013-2016 Freescale Semiconductor Inc.
+ * Copyright 2016 NXP
+ *
+ */
+
+#ifndef __RTA_COMPAT_H__
+#define __RTA_COMPAT_H__
+
+#include <stdint.h>
+#include <errno.h>
+
+#ifdef __GLIBC__
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdbool.h>
+
+#include <rte_byteorder.h>
+#include <rte_common.h>
+
+#ifndef __BYTE_ORDER__
+#error "Undefined endianness"
+#endif
+
+#else
+#error Environment not supported!
+#endif
+
+#ifndef __always_inline
+#define __always_inline __rte_always_inline
+#endif
+
+#ifndef __always_unused
+#define __always_unused __attribute__((unused))
+#endif
+
+#ifndef __maybe_unused
+#define __maybe_unused __attribute__((unused))
+#endif
+
+#if defined(__GLIBC__) && !defined(pr_debug)
+#if !defined(SUPPRESS_PRINTS) && defined(RTA_DEBUG)
+#define pr_debug(fmt, ...) \
+ RTE_LOG(DEBUG, PMD, "%s(): " fmt "\n", __func__, ##__VA_ARGS__)
+#else
+#define pr_debug(fmt, ...) do { } while (0)
+#endif
+#endif /* pr_debug */
+
+#if defined(__GLIBC__) && !defined(pr_err)
+#if !defined(SUPPRESS_PRINTS)
+#define pr_err(fmt, ...) \
+ RTE_LOG(ERR, PMD, "%s(): " fmt "\n", __func__, ##__VA_ARGS__)
+#else
+#define pr_err(fmt, ...) do { } while (0)
+#endif
+#endif /* pr_err */
+
+#if defined(__GLIBC__) && !defined(pr_warn)
+#if !defined(SUPPRESS_PRINTS)
+#define pr_warn(fmt, ...) \
+ RTE_LOG(WARNING, PMD, "%s(): " fmt "\n", __func__, ##__VA_ARGS__)
+#else
+#define pr_warn(fmt, ...) do { } while (0)
+#endif
+#endif /* pr_warn */
+
+/**
+ * ARRAY_SIZE - returns the number of elements in an array
+ * @x: array
+ */
+#ifndef ARRAY_SIZE
+#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
+#endif
+
+#ifndef ALIGN
+#define ALIGN(x, a) (((x) + ((__typeof__(x))(a) - 1)) & \
+ ~((__typeof__(x))(a) - 1))
+#endif
+
+#ifndef BIT
+#define BIT(nr) (1UL << (nr))
+#endif
+
+#ifndef upper_32_bits
+/**
+ * upper_32_bits - return bits 32-63 of a number
+ * @n: the number we're accessing
+ */
+#define upper_32_bits(n) ((uint32_t)(((n) >> 16) >> 16))
+#endif
+
+#ifndef lower_32_bits
+/**
+ * lower_32_bits - return bits 0-31 of a number
+ * @n: the number we're accessing
+ */
+#define lower_32_bits(n) ((uint32_t)(n))
+#endif
+
+/* Use Linux naming convention */
+#ifdef __GLIBC__
+ #define swab16(x) rte_bswap16(x)
+ #define swab32(x) rte_bswap32(x)
+ #define swab64(x) rte_bswap64(x)
+ /* Define cpu_to_be32 macro if not defined in the build environment */
+ #if !defined(cpu_to_be32)
+ #if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+ #define cpu_to_be32(x) (x)
+ #else
+ #define cpu_to_be32(x) swab32(x)
+ #endif
+ #endif
+ /* Define cpu_to_le32 macro if not defined in the build environment */
+ #if !defined(cpu_to_le32)
+ #if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+ #define cpu_to_le32(x) swab32(x)
+ #else
+ #define cpu_to_le32(x) (x)
+ #endif
+ #endif
+#endif
+
+#endif /* __RTA_COMPAT_H__ */
--- /dev/null
+/* SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0)
+ *
+ * Copyright 2008-2016 Freescale Semiconductor Inc.
+ * Copyright 2016, 2019 NXP
+ *
+ */
+
+/*
+ * SEC descriptor composition header.
+ * Definitions to support SEC descriptor instruction generation
+ */
+
+#ifndef __RTA_DESC_H__
+#define __RTA_DESC_H__
+
+/* compat.h is not delivered in kernel */
+#ifndef __KERNEL__
+#include "compat.h"
+#endif
+
+extern enum rta_sec_era rta_sec_era;
+
+/* Max size of any SEC descriptor in 32-bit words, inclusive of header */
+#define MAX_CAAM_DESCSIZE 64
+
+#define CAAM_CMD_SZ sizeof(uint32_t)
+#define CAAM_PTR_SZ sizeof(dma_addr_t)
+#define CAAM_DESC_BYTES_MAX (CAAM_CMD_SZ * MAX_CAAM_DESCSIZE)
+#define DESC_JOB_IO_LEN (CAAM_CMD_SZ * 5 + CAAM_PTR_SZ * 3)
+
+/* Block size of any entity covered/uncovered with a KEK/TKEK */
+#define KEK_BLOCKSIZE 16
+
+/*
+ * Supported descriptor command types as they show up
+ * inside a descriptor command word.
+ */
+#define CMD_SHIFT 27
+#define CMD_MASK (0x1f << CMD_SHIFT)
+
+#define CMD_KEY (0x00 << CMD_SHIFT)
+#define CMD_SEQ_KEY (0x01 << CMD_SHIFT)
+#define CMD_LOAD (0x02 << CMD_SHIFT)
+#define CMD_SEQ_LOAD (0x03 << CMD_SHIFT)
+#define CMD_FIFO_LOAD (0x04 << CMD_SHIFT)
+#define CMD_SEQ_FIFO_LOAD (0x05 << CMD_SHIFT)
+#define CMD_MOVEDW (0x06 << CMD_SHIFT)
+#define CMD_MOVEB (0x07 << CMD_SHIFT)
+#define CMD_STORE (0x0a << CMD_SHIFT)
+#define CMD_SEQ_STORE (0x0b << CMD_SHIFT)
+#define CMD_FIFO_STORE (0x0c << CMD_SHIFT)
+#define CMD_SEQ_FIFO_STORE (0x0d << CMD_SHIFT)
+#define CMD_MOVE_LEN (0x0e << CMD_SHIFT)
+#define CMD_MOVE (0x0f << CMD_SHIFT)
+#define CMD_OPERATION ((uint32_t)(0x10 << CMD_SHIFT))
+#define CMD_SIGNATURE ((uint32_t)(0x12 << CMD_SHIFT))
+#define CMD_JUMP ((uint32_t)(0x14 << CMD_SHIFT))
+#define CMD_MATH ((uint32_t)(0x15 << CMD_SHIFT))
+#define CMD_DESC_HDR ((uint32_t)(0x16 << CMD_SHIFT))
+#define CMD_SHARED_DESC_HDR ((uint32_t)(0x17 << CMD_SHIFT))
+#define CMD_MATHI ((uint32_t)(0x1d << CMD_SHIFT))
+#define CMD_SEQ_IN_PTR ((uint32_t)(0x1e << CMD_SHIFT))
+#define CMD_SEQ_OUT_PTR ((uint32_t)(0x1f << CMD_SHIFT))
+
+/* General-purpose class selector for all commands */
+#define CLASS_SHIFT 25
+#define CLASS_MASK (0x03 << CLASS_SHIFT)
+
+#define CLASS_NONE (0x00 << CLASS_SHIFT)
+#define CLASS_1 (0x01 << CLASS_SHIFT)
+#define CLASS_2 (0x02 << CLASS_SHIFT)
+#define CLASS_BOTH (0x03 << CLASS_SHIFT)
+
+/* ICV Check bits for Algo Operation command */
+#define ICV_CHECK_DISABLE 0
+#define ICV_CHECK_ENABLE 1
+
+/* Encap Mode check bits for Algo Operation command */
+#define DIR_ENC 1
+#define DIR_DEC 0
+
+/*
+ * Descriptor header command constructs
+ * Covers shared, job, and trusted descriptor headers
+ */
+
+/*
+ * Extended Job Descriptor Header
+ */
+#define HDR_EXT BIT(24)
+
+/*
+ * Read input frame as soon as possible (SHR HDR)
+ */
+#define HDR_RIF BIT(25)
+
+/*
+ * Require SEQ LIODN to be the Same (JOB HDR)
+ */
+#define HDR_RSLS BIT(25)
+
+/*
+ * Do Not Run - marks a descriptor not executable if there was
+ * a preceding error somewhere
+ */
+#define HDR_DNR BIT(24)
+
+/*
+ * ONE - should always be set. Combination of ONE (always
+ * set) and ZRO (always clear) forms an endianness sanity check
+ */
+#define HDR_ONE BIT(23)
+#define HDR_ZRO BIT(15)
+
+/* Start Index or SharedDesc Length */
+#define HDR_START_IDX_SHIFT 16
+#define HDR_START_IDX_MASK (0x3f << HDR_START_IDX_SHIFT)
+#define HDR_START_IDX_MASK_ERA10 (0x7f << HDR_START_IDX_SHIFT)
+
+/* If shared descriptor header, 6-bit length */
+#define HDR_DESCLEN_SHR_MASK 0x3f
+/* If shared descriptor header, 7-bit length era10 onwards*/
+#define HDR_DESCLEN_SHR_MASK_ERA10 0x7f
+
+/* If non-shared header, 7-bit length */
+#define HDR_DESCLEN_MASK 0x7f
+
+/* This is a TrustedDesc (if not SharedDesc) */
+#define HDR_TRUSTED BIT(14)
+
+/* Make into TrustedDesc (if not SharedDesc) */
+#define HDR_MAKE_TRUSTED BIT(13)
+
+/* Clear Input FiFO (if SharedDesc) */
+#define HDR_CLEAR_IFIFO BIT(13)
+
+/* Save context if self-shared (if SharedDesc) */
+#define HDR_SAVECTX BIT(12)
+
+/* Next item points to SharedDesc */
+#define HDR_SHARED BIT(12)
+
+/*
+ * Reverse Execution Order - execute JobDesc first, then
+ * execute SharedDesc (normally SharedDesc goes first).
+ */
+#define HDR_REVERSE BIT(11)
+
+/* Propagate DNR property to SharedDesc */
+#define HDR_PROP_DNR BIT(11)
+
+/* DECO Select Valid */
+#define HDR_EXT_DSEL_VALID BIT(7)
+
+/* Fake trusted descriptor */
+#define HDR_EXT_FTD BIT(8)
+
+/* JobDesc/SharedDesc share property */
+#define HDR_SD_SHARE_SHIFT 8
+#define HDR_SD_SHARE_MASK (0x03 << HDR_SD_SHARE_SHIFT)
+#define HDR_JD_SHARE_SHIFT 8
+#define HDR_JD_SHARE_MASK (0x07 << HDR_JD_SHARE_SHIFT)
+
+#define HDR_SHARE_NEVER (0x00 << HDR_SD_SHARE_SHIFT)
+#define HDR_SHARE_WAIT (0x01 << HDR_SD_SHARE_SHIFT)
+#define HDR_SHARE_SERIAL (0x02 << HDR_SD_SHARE_SHIFT)
+#define HDR_SHARE_ALWAYS (0x03 << HDR_SD_SHARE_SHIFT)
+#define HDR_SHARE_DEFER (0x04 << HDR_SD_SHARE_SHIFT)
+
+/* JobDesc/SharedDesc descriptor length */
+#define HDR_JD_LENGTH_MASK 0x7f
+#define HDR_SD_LENGTH_MASK 0x3f
+
+/*
+ * KEY/SEQ_KEY Command Constructs
+ */
+
+/* Key Destination Class: 01 = Class 1, 02 - Class 2 */
+#define KEY_DEST_CLASS_SHIFT 25
+#define KEY_DEST_CLASS_MASK (0x03 << KEY_DEST_CLASS_SHIFT)
+#define KEY_DEST_CLASS1 (1 << KEY_DEST_CLASS_SHIFT)
+#define KEY_DEST_CLASS2 (2 << KEY_DEST_CLASS_SHIFT)
+
+/* Scatter-Gather Table/Variable Length Field */
+#define KEY_SGF BIT(24)
+#define KEY_VLF BIT(24)
+
+/* Immediate - Key follows command in the descriptor */
+#define KEY_IMM BIT(23)
+
+/*
+ * Already in Input Data FIFO - the Input Data Sequence is not read, since it is
+ * already in the Input Data FIFO.
+ */
+#define KEY_AIDF BIT(23)
+
+/*
+ * Encrypted - Key is encrypted either with the KEK, or
+ * with the TDKEK if this descriptor is trusted
+ */
+#define KEY_ENC BIT(22)
+
+/*
+ * No Write Back - Do not allow key to be FIFO STOREd
+ */
+#define KEY_NWB BIT(21)
+
+/*
+ * Enhanced Encryption of Key
+ */
+#define KEY_EKT BIT(20)
+
+/*
+ * Encrypted with Trusted Key
+ */
+#define KEY_TK BIT(15)
+
+/*
+ * Plaintext Store
+ */
+#define KEY_PTS BIT(14)
+
+/*
+ * KDEST - Key Destination: 0 - class key register,
+ * 1 - PKHA 'e', 2 - AFHA Sbox, 3 - MDHA split key
+ */
+#define KEY_DEST_SHIFT 16
+#define KEY_DEST_MASK (0x03 << KEY_DEST_SHIFT)
+
+#define KEY_DEST_CLASS_REG (0x00 << KEY_DEST_SHIFT)
+#define KEY_DEST_PKHA_E (0x01 << KEY_DEST_SHIFT)
+#define KEY_DEST_AFHA_SBOX (0x02 << KEY_DEST_SHIFT)
+#define KEY_DEST_MDHA_SPLIT (0x03 << KEY_DEST_SHIFT)
+
+/* Length in bytes */
+#define KEY_LENGTH_MASK 0x000003ff
+
+/*
+ * LOAD/SEQ_LOAD/STORE/SEQ_STORE Command Constructs
+ */
+
+/*
+ * Load/Store Destination: 0 = class independent CCB,
+ * 1 = class 1 CCB, 2 = class 2 CCB, 3 = DECO
+ */
+#define LDST_CLASS_SHIFT 25
+#define LDST_CLASS_MASK (0x03 << LDST_CLASS_SHIFT)
+#define LDST_CLASS_IND_CCB (0x00 << LDST_CLASS_SHIFT)
+#define LDST_CLASS_1_CCB (0x01 << LDST_CLASS_SHIFT)
+#define LDST_CLASS_2_CCB (0x02 << LDST_CLASS_SHIFT)
+#define LDST_CLASS_DECO (0x03 << LDST_CLASS_SHIFT)
+
+/* Scatter-Gather Table/Variable Length Field */
+#define LDST_SGF BIT(24)
+#define LDST_VLF BIT(24)
+
+/* Immediate - Key follows this command in descriptor */
+#define LDST_IMM_MASK 1
+#define LDST_IMM_SHIFT 23
+#define LDST_IMM BIT(23)
+
+/* SRC/DST - Destination for LOAD, Source for STORE */
+#define LDST_SRCDST_SHIFT 16
+#define LDST_SRCDST_MASK (0x7f << LDST_SRCDST_SHIFT)
+
+#define LDST_SRCDST_BYTE_CONTEXT (0x20 << LDST_SRCDST_SHIFT)
+#define LDST_SRCDST_BYTE_KEY (0x40 << LDST_SRCDST_SHIFT)
+#define LDST_SRCDST_BYTE_INFIFO (0x7c << LDST_SRCDST_SHIFT)
+#define LDST_SRCDST_BYTE_OUTFIFO (0x7e << LDST_SRCDST_SHIFT)
+
+#define LDST_SRCDST_WORD_MODE_REG (0x00 << LDST_SRCDST_SHIFT)
+#define LDST_SRCDST_WORD_DECO_JQCTRL (0x00 << LDST_SRCDST_SHIFT)
+#define LDST_SRCDST_WORD_KEYSZ_REG (0x01 << LDST_SRCDST_SHIFT)
+#define LDST_SRCDST_WORD_DECO_JQDAR (0x01 << LDST_SRCDST_SHIFT)
+#define LDST_SRCDST_WORD_DATASZ_REG (0x02 << LDST_SRCDST_SHIFT)
+#define LDST_SRCDST_WORD_DECO_STAT (0x02 << LDST_SRCDST_SHIFT)
+#define LDST_SRCDST_WORD_ICVSZ_REG (0x03 << LDST_SRCDST_SHIFT)
+#define LDST_SRCDST_BYTE_DCHKSM (0x03 << LDST_SRCDST_SHIFT)
+#define LDST_SRCDST_WORD_PID (0x04 << LDST_SRCDST_SHIFT)
+#define LDST_SRCDST_WORD_CHACTRL (0x06 << LDST_SRCDST_SHIFT)
+#define LDST_SRCDST_WORD_DECOCTRL (0x06 << LDST_SRCDST_SHIFT)
+#define LDST_SRCDST_WORD_IRQCTRL (0x07 << LDST_SRCDST_SHIFT)
+#define LDST_SRCDST_WORD_DECO_PCLOVRD (0x07 << LDST_SRCDST_SHIFT)
+#define LDST_SRCDST_WORD_CLRW (0x08 << LDST_SRCDST_SHIFT)
+#define LDST_SRCDST_WORD_DECO_MATH0 (0x08 << LDST_SRCDST_SHIFT)
+#define LDST_SRCDST_WORD_STAT (0x09 << LDST_SRCDST_SHIFT)
+#define LDST_SRCDST_WORD_DECO_MATH1 (0x09 << LDST_SRCDST_SHIFT)
+#define LDST_SRCDST_WORD_DECO_MATH2 (0x0a << LDST_SRCDST_SHIFT)
+#define LDST_SRCDST_WORD_DECO_AAD_SZ (0x0b << LDST_SRCDST_SHIFT)
+#define LDST_SRCDST_WORD_DECO_MATH3 (0x0b << LDST_SRCDST_SHIFT)
+#define LDST_SRCDST_WORD_CLASS1_IV_SZ (0x0c << LDST_SRCDST_SHIFT)
+#define LDST_SRCDST_WORD_ALTDS_CLASS1 (0x0f << LDST_SRCDST_SHIFT)
+#define LDST_SRCDST_WORD_PKHA_A_SZ (0x10 << LDST_SRCDST_SHIFT)
+#define LDST_SRCDST_WORD_GTR (0x10 << LDST_SRCDST_SHIFT)
+#define LDST_SRCDST_WORD_PKHA_B_SZ (0x11 << LDST_SRCDST_SHIFT)
+#define LDST_SRCDST_WORD_PKHA_N_SZ (0x12 << LDST_SRCDST_SHIFT)
+#define LDST_SRCDST_WORD_PKHA_E_SZ (0x13 << LDST_SRCDST_SHIFT)
+#define LDST_SRCDST_WORD_CLASS_CTX (0x20 << LDST_SRCDST_SHIFT)
+#define LDST_SRCDST_WORD_STR (0x20 << LDST_SRCDST_SHIFT)
+#define LDST_SRCDST_WORD_DESCBUF (0x40 << LDST_SRCDST_SHIFT)
+#define LDST_SRCDST_WORD_DESCBUF_JOB (0x41 << LDST_SRCDST_SHIFT)
+#define LDST_SRCDST_WORD_DESCBUF_SHARED (0x42 << LDST_SRCDST_SHIFT)
+#define LDST_SRCDST_WORD_DESCBUF_JOB_WE (0x45 << LDST_SRCDST_SHIFT)
+#define LDST_SRCDST_WORD_DESCBUF_SHARED_WE (0x46 << LDST_SRCDST_SHIFT)
+#define LDST_SRCDST_WORD_INFO_FIFO_SZL (0x70 << LDST_SRCDST_SHIFT)
+#define LDST_SRCDST_WORD_INFO_FIFO_SZM (0x71 << LDST_SRCDST_SHIFT)
+#define LDST_SRCDST_WORD_INFO_FIFO_L (0x72 << LDST_SRCDST_SHIFT)
+#define LDST_SRCDST_WORD_INFO_FIFO_M (0x73 << LDST_SRCDST_SHIFT)
+#define LDST_SRCDST_WORD_SZL (0x74 << LDST_SRCDST_SHIFT)
+#define LDST_SRCDST_WORD_SZM (0x75 << LDST_SRCDST_SHIFT)
+#define LDST_SRCDST_WORD_IFNSR (0x76 << LDST_SRCDST_SHIFT)
+#define LDST_SRCDST_WORD_OFNSR (0x77 << LDST_SRCDST_SHIFT)
+#define LDST_SRCDST_BYTE_ALTSOURCE (0x78 << LDST_SRCDST_SHIFT)
+#define LDST_SRCDST_WORD_INFO_FIFO (0x7a << LDST_SRCDST_SHIFT)
+
+/* Offset in source/destination */
+#define LDST_OFFSET_SHIFT 8
+#define LDST_OFFSET_MASK (0xff << LDST_OFFSET_SHIFT)
+
+/* LDOFF definitions used when DST = LDST_SRCDST_WORD_DECOCTRL */
+/* These could also be shifted by LDST_OFFSET_SHIFT - this reads better */
+#define LDOFF_CHG_SHARE_SHIFT 0
+#define LDOFF_CHG_SHARE_MASK (0x3 << LDOFF_CHG_SHARE_SHIFT)
+#define LDOFF_CHG_SHARE_NEVER (0x1 << LDOFF_CHG_SHARE_SHIFT)
+#define LDOFF_CHG_SHARE_OK_PROP (0x2 << LDOFF_CHG_SHARE_SHIFT)
+#define LDOFF_CHG_SHARE_OK_NO_PROP (0x3 << LDOFF_CHG_SHARE_SHIFT)
+
+#define LDOFF_ENABLE_AUTO_NFIFO BIT(2)
+#define LDOFF_DISABLE_AUTO_NFIFO BIT(3)
+
+#define LDOFF_CHG_NONSEQLIODN_SHIFT 4
+#define LDOFF_CHG_NONSEQLIODN_MASK (0x3 << LDOFF_CHG_NONSEQLIODN_SHIFT)
+#define LDOFF_CHG_NONSEQLIODN_SEQ (0x1 << LDOFF_CHG_NONSEQLIODN_SHIFT)
+#define LDOFF_CHG_NONSEQLIODN_NON_SEQ (0x2 << LDOFF_CHG_NONSEQLIODN_SHIFT)
+#define LDOFF_CHG_NONSEQLIODN_TRUSTED (0x3 << LDOFF_CHG_NONSEQLIODN_SHIFT)
+
+#define LDOFF_CHG_SEQLIODN_SHIFT 6
+#define LDOFF_CHG_SEQLIODN_MASK (0x3 << LDOFF_CHG_SEQLIODN_SHIFT)
+#define LDOFF_CHG_SEQLIODN_SEQ (0x1 << LDOFF_CHG_SEQLIODN_SHIFT)
+#define LDOFF_CHG_SEQLIODN_NON_SEQ (0x2 << LDOFF_CHG_SEQLIODN_SHIFT)
+#define LDOFF_CHG_SEQLIODN_TRUSTED (0x3 << LDOFF_CHG_SEQLIODN_SHIFT)
+
+/* Data length in bytes */
+#define LDST_LEN_SHIFT 0
+#define LDST_LEN_MASK (0xff << LDST_LEN_SHIFT)
+
+/* Special Length definitions when dst=deco-ctrl */
+#define LDLEN_ENABLE_OSL_COUNT BIT(7)
+#define LDLEN_RST_CHA_OFIFO_PTR BIT(6)
+#define LDLEN_RST_OFIFO BIT(5)
+#define LDLEN_SET_OFIFO_OFF_VALID BIT(4)
+#define LDLEN_SET_OFIFO_OFF_RSVD BIT(3)
+#define LDLEN_SET_OFIFO_OFFSET_SHIFT 0
+#define LDLEN_SET_OFIFO_OFFSET_MASK (3 << LDLEN_SET_OFIFO_OFFSET_SHIFT)
+
+/* CCB Clear Written Register bits */
+#define CLRW_CLR_C1MODE BIT(0)
+#define CLRW_CLR_C1DATAS BIT(2)
+#define CLRW_CLR_C1ICV BIT(3)
+#define CLRW_CLR_C1CTX BIT(5)
+#define CLRW_CLR_C1KEY BIT(6)
+#define CLRW_CLR_PK_A BIT(12)
+#define CLRW_CLR_PK_B BIT(13)
+#define CLRW_CLR_PK_N BIT(14)
+#define CLRW_CLR_PK_E BIT(15)
+#define CLRW_CLR_C2MODE BIT(16)
+#define CLRW_CLR_C2KEYS BIT(17)
+#define CLRW_CLR_C2DATAS BIT(18)
+#define CLRW_CLR_C2CTX BIT(21)
+#define CLRW_CLR_C2KEY BIT(22)
+#define CLRW_RESET_CLS2_DONE BIT(26) /* era 4 */
+#define CLRW_RESET_CLS1_DONE BIT(27) /* era 4 */
+#define CLRW_RESET_CLS2_CHA BIT(28) /* era 4 */
+#define CLRW_RESET_CLS1_CHA BIT(29) /* era 4 */
+#define CLRW_RESET_OFIFO BIT(30) /* era 3 */
+#define CLRW_RESET_IFIFO_DFIFO BIT(31) /* era 3 */
+
+/* CHA Control Register bits */
+#define CCTRL_RESET_CHA_ALL BIT(0)
+#define CCTRL_RESET_CHA_AESA BIT(1)
+#define CCTRL_RESET_CHA_DESA BIT(2)
+#define CCTRL_RESET_CHA_AFHA BIT(3)
+#define CCTRL_RESET_CHA_KFHA BIT(4)
+#define CCTRL_RESET_CHA_SF8A BIT(5)
+#define CCTRL_RESET_CHA_PKHA BIT(6)
+#define CCTRL_RESET_CHA_MDHA BIT(7)
+#define CCTRL_RESET_CHA_CRCA BIT(8)
+#define CCTRL_RESET_CHA_RNG BIT(9)
+#define CCTRL_RESET_CHA_SF9A BIT(10)
+#define CCTRL_RESET_CHA_ZUCE BIT(11)
+#define CCTRL_RESET_CHA_ZUCA BIT(12)
+#define CCTRL_UNLOAD_PK_A0 BIT(16)
+#define CCTRL_UNLOAD_PK_A1 BIT(17)
+#define CCTRL_UNLOAD_PK_A2 BIT(18)
+#define CCTRL_UNLOAD_PK_A3 BIT(19)
+#define CCTRL_UNLOAD_PK_B0 BIT(20)
+#define CCTRL_UNLOAD_PK_B1 BIT(21)
+#define CCTRL_UNLOAD_PK_B2 BIT(22)
+#define CCTRL_UNLOAD_PK_B3 BIT(23)
+#define CCTRL_UNLOAD_PK_N BIT(24)
+#define CCTRL_UNLOAD_PK_A BIT(26)
+#define CCTRL_UNLOAD_PK_B BIT(27)
+#define CCTRL_UNLOAD_SBOX BIT(28)
+
+/* IRQ Control Register (CxCIRQ) bits */
+#define CIRQ_ADI BIT(1)
+#define CIRQ_DDI BIT(2)
+#define CIRQ_RCDI BIT(3)
+#define CIRQ_KDI BIT(4)
+#define CIRQ_S8DI BIT(5)
+#define CIRQ_PDI BIT(6)
+#define CIRQ_MDI BIT(7)
+#define CIRQ_CDI BIT(8)
+#define CIRQ_RNDI BIT(9)
+#define CIRQ_S9DI BIT(10)
+#define CIRQ_ZEDI BIT(11) /* valid for Era 5 or higher */
+#define CIRQ_ZADI BIT(12) /* valid for Era 5 or higher */
+#define CIRQ_AEI BIT(17)
+#define CIRQ_DEI BIT(18)
+#define CIRQ_RCEI BIT(19)
+#define CIRQ_KEI BIT(20)
+#define CIRQ_S8EI BIT(21)
+#define CIRQ_PEI BIT(22)
+#define CIRQ_MEI BIT(23)
+#define CIRQ_CEI BIT(24)
+#define CIRQ_RNEI BIT(25)
+#define CIRQ_S9EI BIT(26)
+#define CIRQ_ZEEI BIT(27) /* valid for Era 5 or higher */
+#define CIRQ_ZAEI BIT(28) /* valid for Era 5 or higher */
+
+/*
+ * FIFO_LOAD/FIFO_STORE/SEQ_FIFO_LOAD/SEQ_FIFO_STORE
+ * Command Constructs
+ */
+
+/*
+ * Load Destination: 0 = skip (SEQ_FIFO_LOAD only),
+ * 1 = Load for Class1, 2 = Load for Class2, 3 = Load both
+ * Store Source: 0 = normal, 1 = Class1key, 2 = Class2key
+ */
+#define FIFOLD_CLASS_SHIFT 25
+#define FIFOLD_CLASS_MASK (0x03 << FIFOLD_CLASS_SHIFT)
+#define FIFOLD_CLASS_SKIP (0x00 << FIFOLD_CLASS_SHIFT)
+#define FIFOLD_CLASS_CLASS1 (0x01 << FIFOLD_CLASS_SHIFT)
+#define FIFOLD_CLASS_CLASS2 (0x02 << FIFOLD_CLASS_SHIFT)
+#define FIFOLD_CLASS_BOTH (0x03 << FIFOLD_CLASS_SHIFT)
+
+#define FIFOST_CLASS_SHIFT 25
+#define FIFOST_CLASS_MASK (0x03 << FIFOST_CLASS_SHIFT)
+#define FIFOST_CLASS_NORMAL (0x00 << FIFOST_CLASS_SHIFT)
+#define FIFOST_CLASS_CLASS1KEY (0x01 << FIFOST_CLASS_SHIFT)
+#define FIFOST_CLASS_CLASS2KEY (0x02 << FIFOST_CLASS_SHIFT)
+#define FIFOST_CLASS_BOTH (0x03 << FIFOST_CLASS_SHIFT)
+
+/*
+ * Scatter-Gather Table/Variable Length Field
+ * If set for FIFO_LOAD, refers to a SG table. Within
+ * SEQ_FIFO_LOAD, is variable input sequence
+ */
+#define FIFOLDST_SGF_SHIFT 24
+#define FIFOLDST_SGF_MASK (1 << FIFOLDST_SGF_SHIFT)
+#define FIFOLDST_VLF_MASK (1 << FIFOLDST_SGF_SHIFT)
+#define FIFOLDST_SGF BIT(24)
+#define FIFOLDST_VLF BIT(24)
+
+/*
+ * Immediate - Data follows command in descriptor
+ * AIDF - Already in Input Data FIFO
+ */
+#define FIFOLD_IMM_SHIFT 23
+#define FIFOLD_IMM_MASK (1 << FIFOLD_IMM_SHIFT)
+#define FIFOLD_AIDF_MASK (1 << FIFOLD_IMM_SHIFT)
+#define FIFOLD_IMM BIT(23)
+#define FIFOLD_AIDF BIT(23)
+
+#define FIFOST_IMM_SHIFT 23
+#define FIFOST_IMM_MASK (1 << FIFOST_IMM_SHIFT)
+#define FIFOST_IMM BIT(23)
+
+/* Continue - Not the last FIFO store to come */
+#define FIFOST_CONT_SHIFT 23
+#define FIFOST_CONT_MASK (1 << FIFOST_CONT_SHIFT)
+#define FIFOST_CONT BIT(23)
+
+/*
+ * Extended Length - use 32-bit extended length that
+ * follows the pointer field. Illegal with IMM set
+ */
+#define FIFOLDST_EXT_SHIFT 22
+#define FIFOLDST_EXT_MASK (1 << FIFOLDST_EXT_SHIFT)
+#define FIFOLDST_EXT BIT(22)
+
+/* Input data type.*/
+#define FIFOLD_TYPE_SHIFT 16
+#define FIFOLD_CONT_TYPE_SHIFT 19 /* shift past last-flush bits */
+#define FIFOLD_TYPE_MASK (0x3f << FIFOLD_TYPE_SHIFT)
+
+/* PK types */
+#define FIFOLD_TYPE_PK (0x00 << FIFOLD_TYPE_SHIFT)
+#define FIFOLD_TYPE_PK_MASK (0x30 << FIFOLD_TYPE_SHIFT)
+#define FIFOLD_TYPE_PK_TYPEMASK (0x0f << FIFOLD_TYPE_SHIFT)
+#define FIFOLD_TYPE_PK_A0 (0x00 << FIFOLD_TYPE_SHIFT)
+#define FIFOLD_TYPE_PK_A1 (0x01 << FIFOLD_TYPE_SHIFT)
+#define FIFOLD_TYPE_PK_A2 (0x02 << FIFOLD_TYPE_SHIFT)
+#define FIFOLD_TYPE_PK_A3 (0x03 << FIFOLD_TYPE_SHIFT)
+#define FIFOLD_TYPE_PK_B0 (0x04 << FIFOLD_TYPE_SHIFT)
+#define FIFOLD_TYPE_PK_B1 (0x05 << FIFOLD_TYPE_SHIFT)
+#define FIFOLD_TYPE_PK_B2 (0x06 << FIFOLD_TYPE_SHIFT)
+#define FIFOLD_TYPE_PK_B3 (0x07 << FIFOLD_TYPE_SHIFT)
+#define FIFOLD_TYPE_PK_N (0x08 << FIFOLD_TYPE_SHIFT)
+#define FIFOLD_TYPE_PK_A (0x0c << FIFOLD_TYPE_SHIFT)
+#define FIFOLD_TYPE_PK_B (0x0d << FIFOLD_TYPE_SHIFT)
+
+/* Other types. Need to OR in last/flush bits as desired */
+#define FIFOLD_TYPE_MSG_MASK (0x38 << FIFOLD_TYPE_SHIFT)
+#define FIFOLD_TYPE_MSG (0x10 << FIFOLD_TYPE_SHIFT)
+#define FIFOLD_TYPE_MSG1OUT2 (0x18 << FIFOLD_TYPE_SHIFT)
+#define FIFOLD_TYPE_IV (0x20 << FIFOLD_TYPE_SHIFT)
+#define FIFOLD_TYPE_BITDATA (0x28 << FIFOLD_TYPE_SHIFT)
+#define FIFOLD_TYPE_AAD (0x30 << FIFOLD_TYPE_SHIFT)
+#define FIFOLD_TYPE_ICV (0x38 << FIFOLD_TYPE_SHIFT)
+
+/* Last/Flush bits for use with "other" types above */
+#define FIFOLD_TYPE_ACT_MASK (0x07 << FIFOLD_TYPE_SHIFT)
+#define FIFOLD_TYPE_NOACTION (0x00 << FIFOLD_TYPE_SHIFT)
+#define FIFOLD_TYPE_FLUSH1 (0x01 << FIFOLD_TYPE_SHIFT)
+#define FIFOLD_TYPE_LAST1 (0x02 << FIFOLD_TYPE_SHIFT)
+#define FIFOLD_TYPE_LAST2FLUSH (0x03 << FIFOLD_TYPE_SHIFT)
+#define FIFOLD_TYPE_LAST2 (0x04 << FIFOLD_TYPE_SHIFT)
+#define FIFOLD_TYPE_LAST2FLUSH1 (0x05 << FIFOLD_TYPE_SHIFT)
+#define FIFOLD_TYPE_LASTBOTH (0x06 << FIFOLD_TYPE_SHIFT)
+#define FIFOLD_TYPE_LASTBOTHFL (0x07 << FIFOLD_TYPE_SHIFT)
+#define FIFOLD_TYPE_NOINFOFIFO (0x0f << FIFOLD_TYPE_SHIFT)
+
+#define FIFOLDST_LEN_MASK 0xffff
+#define FIFOLDST_EXT_LEN_MASK 0xffffffff
+
+/* Output data types */
+#define FIFOST_TYPE_SHIFT 16
+#define FIFOST_TYPE_MASK (0x3f << FIFOST_TYPE_SHIFT)
+
+#define FIFOST_TYPE_PKHA_A0 (0x00 << FIFOST_TYPE_SHIFT)
+#define FIFOST_TYPE_PKHA_A1 (0x01 << FIFOST_TYPE_SHIFT)
+#define FIFOST_TYPE_PKHA_A2 (0x02 << FIFOST_TYPE_SHIFT)
+#define FIFOST_TYPE_PKHA_A3 (0x03 << FIFOST_TYPE_SHIFT)
+#define FIFOST_TYPE_PKHA_B0 (0x04 << FIFOST_TYPE_SHIFT)
+#define FIFOST_TYPE_PKHA_B1 (0x05 << FIFOST_TYPE_SHIFT)
+#define FIFOST_TYPE_PKHA_B2 (0x06 << FIFOST_TYPE_SHIFT)
+#define FIFOST_TYPE_PKHA_B3 (0x07 << FIFOST_TYPE_SHIFT)
+#define FIFOST_TYPE_PKHA_N (0x08 << FIFOST_TYPE_SHIFT)
+#define FIFOST_TYPE_PKHA_A (0x0c << FIFOST_TYPE_SHIFT)
+#define FIFOST_TYPE_PKHA_B (0x0d << FIFOST_TYPE_SHIFT)
+#define FIFOST_TYPE_AF_SBOX_JKEK (0x20 << FIFOST_TYPE_SHIFT)
+#define FIFOST_TYPE_AF_SBOX_TKEK (0x21 << FIFOST_TYPE_SHIFT)
+#define FIFOST_TYPE_PKHA_E_JKEK (0x22 << FIFOST_TYPE_SHIFT)
+#define FIFOST_TYPE_PKHA_E_TKEK (0x23 << FIFOST_TYPE_SHIFT)
+#define FIFOST_TYPE_KEY_KEK (0x24 << FIFOST_TYPE_SHIFT)
+#define FIFOST_TYPE_KEY_TKEK (0x25 << FIFOST_TYPE_SHIFT)
+#define FIFOST_TYPE_SPLIT_KEK (0x26 << FIFOST_TYPE_SHIFT)
+#define FIFOST_TYPE_SPLIT_TKEK (0x27 << FIFOST_TYPE_SHIFT)
+#define FIFOST_TYPE_OUTFIFO_KEK (0x28 << FIFOST_TYPE_SHIFT)
+#define FIFOST_TYPE_OUTFIFO_TKEK (0x29 << FIFOST_TYPE_SHIFT)
+#define FIFOST_TYPE_MESSAGE_DATA (0x30 << FIFOST_TYPE_SHIFT)
+#define FIFOST_TYPE_MESSAGE_DATA2 (0x31 << FIFOST_TYPE_SHIFT)
+#define FIFOST_TYPE_RNGSTORE (0x34 << FIFOST_TYPE_SHIFT)
+#define FIFOST_TYPE_RNGFIFO (0x35 << FIFOST_TYPE_SHIFT)
+#define FIFOST_TYPE_METADATA (0x3e << FIFOST_TYPE_SHIFT)
+#define FIFOST_TYPE_SKIP (0x3f << FIFOST_TYPE_SHIFT)
+
+/*
+ * OPERATION Command Constructs
+ */
+
+/* Operation type selectors - OP TYPE */
+#define OP_TYPE_SHIFT 24
+#define OP_TYPE_MASK (0x07 << OP_TYPE_SHIFT)
+
+#define OP_TYPE_UNI_PROTOCOL (0x00 << OP_TYPE_SHIFT)
+#define OP_TYPE_PK (0x01 << OP_TYPE_SHIFT)
+#define OP_TYPE_CLASS1_ALG (0x02 << OP_TYPE_SHIFT)
+#define OP_TYPE_CLASS2_ALG (0x04 << OP_TYPE_SHIFT)
+#define OP_TYPE_DECAP_PROTOCOL (0x06 << OP_TYPE_SHIFT)
+#define OP_TYPE_ENCAP_PROTOCOL (0x07 << OP_TYPE_SHIFT)
+
+/* ProtocolID selectors - PROTID */
+#define OP_PCLID_SHIFT 16
+#define OP_PCLID_MASK (0xff << OP_PCLID_SHIFT)
+
+/* Assuming OP_TYPE = OP_TYPE_UNI_PROTOCOL */
+#define OP_PCLID_IKEV1_PRF (0x01 << OP_PCLID_SHIFT)
+#define OP_PCLID_IKEV2_PRF (0x02 << OP_PCLID_SHIFT)
+#define OP_PCLID_SSL30_PRF (0x08 << OP_PCLID_SHIFT)
+#define OP_PCLID_TLS10_PRF (0x09 << OP_PCLID_SHIFT)
+#define OP_PCLID_TLS11_PRF (0x0a << OP_PCLID_SHIFT)
+#define OP_PCLID_TLS12_PRF (0x0b << OP_PCLID_SHIFT)
+#define OP_PCLID_DTLS_PRF (0x0c << OP_PCLID_SHIFT)
+#define OP_PCLID_PUBLICKEYPAIR (0x14 << OP_PCLID_SHIFT)
+#define OP_PCLID_DSASIGN (0x15 << OP_PCLID_SHIFT)
+#define OP_PCLID_DSAVERIFY (0x16 << OP_PCLID_SHIFT)
+#define OP_PCLID_DIFFIEHELLMAN (0x17 << OP_PCLID_SHIFT)
+#define OP_PCLID_RSAENCRYPT (0x18 << OP_PCLID_SHIFT)
+#define OP_PCLID_RSADECRYPT (0x19 << OP_PCLID_SHIFT)
+#define OP_PCLID_DKP_MD5 (0x20 << OP_PCLID_SHIFT)
+#define OP_PCLID_DKP_SHA1 (0x21 << OP_PCLID_SHIFT)
+#define OP_PCLID_DKP_SHA224 (0x22 << OP_PCLID_SHIFT)
+#define OP_PCLID_DKP_SHA256 (0x23 << OP_PCLID_SHIFT)
+#define OP_PCLID_DKP_SHA384 (0x24 << OP_PCLID_SHIFT)
+#define OP_PCLID_DKP_SHA512 (0x25 << OP_PCLID_SHIFT)
+
+/* Assuming OP_TYPE = OP_TYPE_DECAP_PROTOCOL/ENCAP_PROTOCOL */
+#define OP_PCLID_IPSEC (0x01 << OP_PCLID_SHIFT)
+#define OP_PCLID_SRTP (0x02 << OP_PCLID_SHIFT)
+#define OP_PCLID_MACSEC (0x03 << OP_PCLID_SHIFT)
+#define OP_PCLID_WIFI (0x04 << OP_PCLID_SHIFT)
+#define OP_PCLID_WIMAX (0x05 << OP_PCLID_SHIFT)
+#define OP_PCLID_SSL30 (0x08 << OP_PCLID_SHIFT)
+#define OP_PCLID_TLS10 (0x09 << OP_PCLID_SHIFT)
+#define OP_PCLID_TLS11 (0x0a << OP_PCLID_SHIFT)
+#define OP_PCLID_TLS12 (0x0b << OP_PCLID_SHIFT)
+#define OP_PCLID_DTLS (0x0c << OP_PCLID_SHIFT)
+#define OP_PCLID_BLOB (0x0d << OP_PCLID_SHIFT)
+#define OP_PCLID_IPSEC_NEW (0x11 << OP_PCLID_SHIFT)
+#define OP_PCLID_3G_DCRC (0x31 << OP_PCLID_SHIFT)
+#define OP_PCLID_3G_RLC_PDU (0x32 << OP_PCLID_SHIFT)
+#define OP_PCLID_3G_RLC_SDU (0x33 << OP_PCLID_SHIFT)
+#define OP_PCLID_LTE_PDCP_USER (0x42 << OP_PCLID_SHIFT)
+#define OP_PCLID_LTE_PDCP_CTRL (0x43 << OP_PCLID_SHIFT)
+#define OP_PCLID_LTE_PDCP_CTRL_MIXED (0x44 << OP_PCLID_SHIFT)
+#define OP_PCLID_LTE_PDCP_USER_RN (0x45 << OP_PCLID_SHIFT)
+
+/*
+ * ProtocolInfo selectors
+ */
+#define OP_PCLINFO_MASK 0xffff
+
+/* for OP_PCLID_IPSEC */
+#define OP_PCL_IPSEC_CIPHER_MASK 0xff00
+#define OP_PCL_IPSEC_AUTH_MASK 0x00ff
+
+#define OP_PCL_IPSEC_DES_IV64 0x0100
+#define OP_PCL_IPSEC_DES 0x0200
+#define OP_PCL_IPSEC_3DES 0x0300
+#define OP_PCL_IPSEC_NULL 0x0B00
+#define OP_PCL_IPSEC_AES_CBC 0x0c00
+#define OP_PCL_IPSEC_AES_CTR 0x0d00
+#define OP_PCL_IPSEC_AES_XTS 0x1600
+#define OP_PCL_IPSEC_AES_CCM8 0x0e00
+#define OP_PCL_IPSEC_AES_CCM12 0x0f00
+#define OP_PCL_IPSEC_AES_CCM16 0x1000
+#define OP_PCL_IPSEC_AES_GCM8 0x1200
+#define OP_PCL_IPSEC_AES_GCM12 0x1300
+#define OP_PCL_IPSEC_AES_GCM16 0x1400
+#define OP_PCL_IPSEC_AES_NULL_WITH_GMAC 0x1500
+
+#define OP_PCL_IPSEC_HMAC_NULL 0x0000
+#define OP_PCL_IPSEC_HMAC_MD5_96 0x0001
+#define OP_PCL_IPSEC_HMAC_SHA1_96 0x0002
+#define OP_PCL_IPSEC_AES_XCBC_MAC_96 0x0005
+#define OP_PCL_IPSEC_HMAC_MD5_128 0x0006
+#define OP_PCL_IPSEC_HMAC_SHA1_160 0x0007
+#define OP_PCL_IPSEC_AES_CMAC_96 0x0008
+#define OP_PCL_IPSEC_HMAC_SHA2_256_128 0x000c
+#define OP_PCL_IPSEC_HMAC_SHA2_384_192 0x000d
+#define OP_PCL_IPSEC_HMAC_SHA2_512_256 0x000e
+
+/* For SRTP - OP_PCLID_SRTP */
+#define OP_PCL_SRTP_CIPHER_MASK 0xff00
+#define OP_PCL_SRTP_AUTH_MASK 0x00ff
+
+#define OP_PCL_SRTP_AES_CTR 0x0d00
+
+#define OP_PCL_SRTP_HMAC_SHA1_160 0x0007
+
+/*
+ * For SSL/TLS/DTLS - OP_PCL_TLS
+ * For more details see IANA TLS Cipher Suite registry:
+ * https://www.iana.org/assignments/tls-parameters/tls-parameters.xhtml
+ * Note: for private/internal use (reserved by IANA) - OP_PCL_PVT_TLS
+ */
+#define OP_PCL_TLS_RSA_EXPORT_WITH_RC4_40_MD5 0x0003
+#define OP_PCL_TLS_RSA_WITH_RC4_128_MD5 0x0004
+#define OP_PCL_TLS_RSA_WITH_RC4_128_SHA 0x0005
+#define OP_PCL_TLS_RSA_EXPORT_WITH_DES40_CBC_SHA 0x0008
+#define OP_PCL_TLS_RSA_WITH_DES_CBC_SHA 0x0009
+#define OP_PCL_TLS_RSA_WITH_3DES_EDE_CBC_SHA 0x000a
+#define OP_PCL_TLS_DH_DSS_EXPORT_WITH_DES40_CBC_SHA 0x000b
+#define OP_PCL_TLS_DH_DSS_WITH_DES_CBC_SHA 0x000c
+#define OP_PCL_TLS_DH_DSS_WITH_3DES_EDE_CBC_SHA 0x000d
+#define OP_PCL_TLS_DH_RSA_EXPORT_WITH_DES40_CBC_SHA 0x000e
+#define OP_PCL_TLS_DH_RSA_WITH_DES_CBC_SHA 0x000f
+#define OP_PCL_TLS_DH_RSA_WITH_3DES_EDE_CBC_SHA 0x0010
+#define OP_PCL_TLS_DHE_DSS_EXPORT_WITH_DES40_CBC_SHA 0x0011
+#define OP_PCL_TLS_DHE_DSS_WITH_DES_CBC_SHA 0x0012
+#define OP_PCL_TLS_DHE_DSS_WITH_3DES_EDE_CBC_SHA 0x0013
+#define OP_PCL_TLS_DHE_RSA_EXPORT_WITH_DES40_CBC_SHA 0x0014
+#define OP_PCL_TLS_DHE_RSA_WITH_DES_CBC_SHA 0x0015
+#define OP_PCL_TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA 0x0016
+#define OP_PCL_TLS_DH_anon_EXPORT_WITH_RC4_40_MD5 0x0017
+#define OP_PCL_TLS_DH_anon_WITH_RC4_128_MD5 0x0018
+#define OP_PCL_TLS_DH_anon_EXPORT_WITH_DES40_CBC_SHA 0x0019
+#define OP_PCL_TLS_DH_anon_WITH_DES_CBC_SHA 0x001a
+#define OP_PCL_TLS_DH_anon_WITH_3DES_EDE_CBC_SHA 0x001b
+#define OP_PCL_TLS_KRB5_WITH_DES_CBC_SHA 0x001e
+#define OP_PCL_TLS_KRB5_WITH_3DES_EDE_CBC_SHA 0x001f
+#define OP_PCL_TLS_KRB5_WITH_RC4_128_SHA 0x0020
+#define OP_PCL_TLS_KRB5_WITH_3DES_EDE_CBC_MD5 0x0023
+#define OP_PCL_TLS_KRB5_WITH_DES_CBC_MD5 0x0022
+#define OP_PCL_TLS_KRB5_WITH_RC4_128_MD5 0x0024
+#define OP_PCL_TLS_KRB5_EXPORT_WITH_DES_CBC_40_SHA 0x0026
+#define OP_PCL_TLS_KRB5_EXPORT_WITH_RC4_40_SHA 0x0028
+#define OP_PCL_TLS_KRB5_EXPORT_WITH_DES_CBC_40_MD5 0x0029
+#define OP_PCL_TLS_KRB5_EXPORT_WITH_RC4_40_MD5 0x002b
+#define OP_PCL_TLS_RSA_WITH_AES_128_CBC_SHA 0x002f
+#define OP_PCL_TLS_DH_DSS_WITH_AES_128_CBC_SHA 0x0030
+#define OP_PCL_TLS_DH_RSA_WITH_AES_128_CBC_SHA 0x0031
+#define OP_PCL_TLS_DHE_DSS_WITH_AES_128_CBC_SHA 0x0032
+#define OP_PCL_TLS_DHE_RSA_WITH_AES_128_CBC_SHA 0x0033
+#define OP_PCL_TLS_DH_anon_WITH_AES_128_CBC_SHA 0x0034
+#define OP_PCL_TLS_RSA_WITH_AES_256_CBC_SHA 0x0035
+#define OP_PCL_TLS_DH_DSS_WITH_AES_256_CBC_SHA 0x0036
+#define OP_PCL_TLS_DH_RSA_WITH_AES_256_CBC_SHA 0x0037
+#define OP_PCL_TLS_DHE_DSS_WITH_AES_256_CBC_SHA 0x0038
+#define OP_PCL_TLS_DHE_RSA_WITH_AES_256_CBC_SHA 0x0039
+#define OP_PCL_TLS_DH_anon_WITH_AES_256_CBC_SHA 0x003a
+#define OP_PCL_TLS_RSA_WITH_AES_128_CBC_SHA256 0x003c
+#define OP_PCL_TLS_RSA_WITH_AES_256_CBC_SHA256 0x003d
+#define OP_PCL_TLS_DH_DSS_WITH_AES_128_CBC_SHA256 0x003e
+#define OP_PCL_TLS_DH_RSA_WITH_AES_128_CBC_SHA256 0x003f
+#define OP_PCL_TLS_DHE_DSS_WITH_AES_128_CBC_SHA256 0x0040
+#define OP_PCL_TLS_DHE_RSA_WITH_AES_128_CBC_SHA256 0x0067
+#define OP_PCL_TLS_DH_DSS_WITH_AES_256_CBC_SHA256 0x0068
+#define OP_PCL_TLS_DH_RSA_WITH_AES_256_CBC_SHA256 0x0069
+#define OP_PCL_TLS_DHE_DSS_WITH_AES_256_CBC_SHA256 0x006a
+#define OP_PCL_TLS_DHE_RSA_WITH_AES_256_CBC_SHA256 0x006b
+#define OP_PCL_TLS_DH_anon_WITH_AES_128_CBC_SHA256 0x006c
+#define OP_PCL_TLS_DH_anon_WITH_AES_256_CBC_SHA256 0x006d
+#define OP_PCL_TLS_PSK_WITH_RC4_128_SHA 0x008a
+#define OP_PCL_TLS_PSK_WITH_3DES_EDE_CBC_SHA 0x008b
+#define OP_PCL_TLS_PSK_WITH_AES_128_CBC_SHA 0x008c
+#define OP_PCL_TLS_PSK_WITH_AES_256_CBC_SHA 0x008d
+#define OP_PCL_TLS_DHE_PSK_WITH_RC4_128_SHA 0x008e
+#define OP_PCL_TLS_DHE_PSK_WITH_3DES_EDE_CBC_SHA 0x008f
+#define OP_PCL_TLS_DHE_PSK_WITH_AES_128_CBC_SHA 0x0090
+#define OP_PCL_TLS_DHE_PSK_WITH_AES_256_CBC_SHA 0x0091
+#define OP_PCL_TLS_RSA_PSK_WITH_RC4_128_SHA 0x0092
+#define OP_PCL_TLS_RSA_PSK_WITH_3DES_EDE_CBC_SHA 0x0093
+#define OP_PCL_TLS_RSA_PSK_WITH_AES_128_CBC_SHA 0x0094
+#define OP_PCL_TLS_RSA_PSK_WITH_AES_256_CBC_SHA 0x0095
+#define OP_PCL_TLS_RSA_WITH_AES_128_GCM_SHA256 0x009c
+#define OP_PCL_TLS_RSA_WITH_AES_256_GCM_SHA384 0x009d
+#define OP_PCL_TLS_DHE_RSA_WITH_AES_128_GCM_SHA256 0x009e
+#define OP_PCL_TLS_DHE_RSA_WITH_AES_256_GCM_SHA384 0x009f
+#define OP_PCL_TLS_DH_RSA_WITH_AES_128_GCM_SHA256 0x00a0
+#define OP_PCL_TLS_DH_RSA_WITH_AES_256_GCM_SHA384 0x00a1
+#define OP_PCL_TLS_DHE_DSS_WITH_AES_128_GCM_SHA256 0x00a2
+#define OP_PCL_TLS_DHE_DSS_WITH_AES_256_GCM_SHA384 0x00a3
+#define OP_PCL_TLS_DH_DSS_WITH_AES_128_GCM_SHA256 0x00a4
+#define OP_PCL_TLS_DH_DSS_WITH_AES_256_GCM_SHA384 0x00a5
+#define OP_PCL_TLS_DH_anon_WITH_AES_128_GCM_SHA256 0x00a6
+#define OP_PCL_TLS_DH_anon_WITH_AES_256_GCM_SHA384 0x00a7
+#define OP_PCL_TLS_PSK_WITH_AES_128_GCM_SHA256 0x00a8
+#define OP_PCL_TLS_PSK_WITH_AES_256_GCM_SHA384 0x00a9
+#define OP_PCL_TLS_DHE_PSK_WITH_AES_128_GCM_SHA256 0x00aa
+#define OP_PCL_TLS_DHE_PSK_WITH_AES_256_GCM_SHA384 0x00ab
+#define OP_PCL_TLS_RSA_PSK_WITH_AES_128_GCM_SHA256 0x00ac
+#define OP_PCL_TLS_RSA_PSK_WITH_AES_256_GCM_SHA384 0x00ad
+#define OP_PCL_TLS_PSK_WITH_AES_128_CBC_SHA256 0x00ae
+#define OP_PCL_TLS_PSK_WITH_AES_256_CBC_SHA384 0x00af
+#define OP_PCL_TLS_DHE_PSK_WITH_AES_128_CBC_SHA256 0x00b2
+#define OP_PCL_TLS_DHE_PSK_WITH_AES_256_CBC_SHA384 0x00b3
+#define OP_PCL_TLS_RSA_PSK_WITH_AES_128_CBC_SHA256 0x00b6
+#define OP_PCL_TLS_RSA_PSK_WITH_AES_256_CBC_SHA384 0x00b7
+#define OP_PCL_TLS_ECDH_ECDSA_WITH_RC4_128_SHA 0xc002
+#define OP_PCL_TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA 0xc003
+#define OP_PCL_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA 0xc004
+#define OP_PCL_TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA 0xc005
+#define OP_PCL_TLS_ECDHE_ECDSA_WITH_RC4_128_SHA 0xc007
+#define OP_PCL_TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA 0xc008
+#define OP_PCL_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA 0xc009
+#define OP_PCL_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA 0xc00a
+#define OP_PCL_TLS_ECDH_RSA_WITH_RC4_128_SHA 0xc00c
+#define OP_PCL_TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA 0xc00d
+#define OP_PCL_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA 0xc00e
+#define OP_PCL_TLS_ECDH_RSA_WITH_AES_256_CBC_SHA 0xc00f
+#define OP_PCL_TLS_ECDHE_RSA_WITH_RC4_128_SHA 0xc011
+#define OP_PCL_TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA 0xc012
+#define OP_PCL_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA 0xc013
+#define OP_PCL_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA 0xc014
+#define OP_PCL_TLS_ECDH_anon_WITH_RC4_128_SHA 0xc016
+#define OP_PCL_TLS_ECDH_anon_WITH_3DES_EDE_CBC_SHA 0xc017
+#define OP_PCL_TLS_ECDH_anon_WITH_AES_128_CBC_SHA 0xc018
+#define OP_PCL_TLS_ECDH_anon_WITH_AES_256_CBC_SHA 0xc019
+#define OP_PCL_TLS_SRP_SHA_WITH_3DES_EDE_CBC_SHA 0xc01a
+#define OP_PCL_TLS_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA 0xc01b
+#define OP_PCL_TLS_SRP_SHA_DSS_WITH_3DES_EDE_CBC_SHA 0xc01c
+#define OP_PCL_TLS_SRP_SHA_WITH_AES_128_CBC_SHA 0xc01d
+#define OP_PCL_TLS_SRP_SHA_RSA_WITH_AES_128_CBC_SHA 0xc01e
+#define OP_PCL_TLS_SRP_SHA_DSS_WITH_AES_128_CBC_SHA 0xc01f
+#define OP_PCL_TLS_SRP_SHA_WITH_AES_256_CBC_SHA 0xc020
+#define OP_PCL_TLS_SRP_SHA_RSA_WITH_AES_256_CBC_SHA 0xc021
+#define OP_PCL_TLS_SRP_SHA_DSS_WITH_AES_256_CBC_SHA 0xc022
+#define OP_PCL_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256 0xc023
+#define OP_PCL_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384 0xc024
+#define OP_PCL_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256 0xc025
+#define OP_PCL_TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384 0xc026
+#define OP_PCL_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256 0xc027
+#define OP_PCL_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384 0xc028
+#define OP_PCL_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256 0xc029
+#define OP_PCL_TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384 0xc02a
+#define OP_PCL_TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 0xc02b
+#define OP_PCL_TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384 0xc02c
+#define OP_PCL_TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256 0xc02d
+#define OP_PCL_TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384 0xc02e
+#define OP_PCL_TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 0xc02f
+#define OP_PCL_TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 0xc030
+#define OP_PCL_TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256 0xc031
+#define OP_PCL_TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384 0xc032
+#define OP_PCL_TLS_ECDHE_PSK_WITH_RC4_128_SHA 0xc033
+#define OP_PCL_TLS_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA 0xc034
+#define OP_PCL_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA 0xc035
+#define OP_PCL_TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA 0xc036
+#define OP_PCL_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256 0xc037
+#define OP_PCL_TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA384 0xc038
+#define OP_PCL_PVT_TLS_3DES_EDE_CBC_MD5 0xff23
+#define OP_PCL_PVT_TLS_3DES_EDE_CBC_SHA160 0xff30
+#define OP_PCL_PVT_TLS_3DES_EDE_CBC_SHA384 0xff33
+#define OP_PCL_PVT_TLS_3DES_EDE_CBC_SHA224 0xff34
+#define OP_PCL_PVT_TLS_3DES_EDE_CBC_SHA512 0xff35
+#define OP_PCL_PVT_TLS_3DES_EDE_CBC_SHA256 0xff36
+#define OP_PCL_PVT_TLS_AES_256_CBC_SHA160 0xff60
+#define OP_PCL_PVT_TLS_AES_256_CBC_SHA384 0xff63
+#define OP_PCL_PVT_TLS_AES_256_CBC_SHA224 0xff64
+#define OP_PCL_PVT_TLS_AES_256_CBC_SHA512 0xff65
+#define OP_PCL_PVT_TLS_AES_256_CBC_SHA256 0xff66
+#define OP_PCL_PVT_TLS_AES_128_CBC_SHA160 0xff80
+#define OP_PCL_PVT_TLS_AES_128_CBC_SHA384 0xff83
+#define OP_PCL_PVT_TLS_AES_128_CBC_SHA224 0xff84
+#define OP_PCL_PVT_TLS_AES_128_CBC_SHA512 0xff85
+#define OP_PCL_PVT_TLS_AES_128_CBC_SHA256 0xff86
+#define OP_PCL_PVT_TLS_AES_192_CBC_SHA160 0xff90
+#define OP_PCL_PVT_TLS_AES_192_CBC_SHA384 0xff93
+#define OP_PCL_PVT_TLS_AES_192_CBC_SHA224 0xff94
+#define OP_PCL_PVT_TLS_AES_192_CBC_SHA512 0xff95
+#define OP_PCL_PVT_TLS_AES_192_CBC_SHA256 0xff96
+#define OP_PCL_PVT_TLS_MASTER_SECRET_PRF_FE 0xfffe
+#define OP_PCL_PVT_TLS_MASTER_SECRET_PRF_FF 0xffff
+
+/* 802.16 WiMAX protinfos */
+#define OP_PCL_WIMAX_OFDM 0x0201
+#define OP_PCL_WIMAX_OFDMA 0x0231
+
+/* 802.11 WiFi protinfos */
+#define OP_PCL_WIFI 0xac04
+
+/* MacSec protinfos */
+#define OP_PCL_MACSEC 0x0001
+
+/* 3G DCRC protinfos */
+#define OP_PCL_3G_DCRC_CRC7 0x0710
+#define OP_PCL_3G_DCRC_CRC11 0x0B10
+
+/* 3G RLC protinfos */
+#define OP_PCL_3G_RLC_NULL 0x0000
+#define OP_PCL_3G_RLC_KASUMI 0x0001
+#define OP_PCL_3G_RLC_SNOW 0x0002
+
+/* LTE protinfos */
+#define OP_PCL_LTE_NULL 0x0000
+#define OP_PCL_LTE_SNOW 0x0001
+#define OP_PCL_LTE_AES 0x0002
+#define OP_PCL_LTE_ZUC 0x0003
+
+/* LTE mixed protinfos */
+#define OP_PCL_LTE_MIXED_AUTH_SHIFT 0
+#define OP_PCL_LTE_MIXED_AUTH_MASK (3 << OP_PCL_LTE_MIXED_AUTH_SHIFT)
+#define OP_PCL_LTE_MIXED_ENC_SHIFT 8
+#define OP_PCL_LTE_MIXED_ENC_MASK (3 << OP_PCL_LTE_MIXED_ENC_SHIFT)
+#define OP_PCL_LTE_MIXED_AUTH_NULL (OP_PCL_LTE_NULL << \
+ OP_PCL_LTE_MIXED_AUTH_SHIFT)
+#define OP_PCL_LTE_MIXED_AUTH_SNOW (OP_PCL_LTE_SNOW << \
+ OP_PCL_LTE_MIXED_AUTH_SHIFT)
+#define OP_PCL_LTE_MIXED_AUTH_AES (OP_PCL_LTE_AES << \
+ OP_PCL_LTE_MIXED_AUTH_SHIFT)
+#define OP_PCL_LTE_MIXED_AUTH_ZUC (OP_PCL_LTE_ZUC << \
+ OP_PCL_LTE_MIXED_AUTH_SHIFT)
+#define OP_PCL_LTE_MIXED_ENC_NULL (OP_PCL_LTE_NULL << \
+ OP_PCL_LTE_MIXED_ENC_SHIFT)
+#define OP_PCL_LTE_MIXED_ENC_SNOW (OP_PCL_LTE_SNOW << \
+ OP_PCL_LTE_MIXED_ENC_SHIFT)
+#define OP_PCL_LTE_MIXED_ENC_AES (OP_PCL_LTE_AES << \
+ OP_PCL_LTE_MIXED_ENC_SHIFT)
+#define OP_PCL_LTE_MIXED_ENC_ZUC (OP_PCL_LTE_ZUC << \
+ OP_PCL_LTE_MIXED_ENC_SHIFT)
+
+/* PKI unidirectional protocol protinfo bits */
+#define OP_PCL_PKPROT_DSA_MSG BIT(10)
+#define OP_PCL_PKPROT_HASH_SHIFT 7
+#define OP_PCL_PKPROT_HASH_MASK (7 << OP_PCL_PKPROT_HASH_SHIFT)
+#define OP_PCL_PKPROT_HASH_MD5 (0 << OP_PCL_PKPROT_HASH_SHIFT)
+#define OP_PCL_PKPROT_HASH_SHA1 (1 << OP_PCL_PKPROT_HASH_SHIFT)
+#define OP_PCL_PKPROT_HASH_SHA224 (2 << OP_PCL_PKPROT_HASH_SHIFT)
+#define OP_PCL_PKPROT_HASH_SHA256 (3 << OP_PCL_PKPROT_HASH_SHIFT)
+#define OP_PCL_PKPROT_HASH_SHA384 (4 << OP_PCL_PKPROT_HASH_SHIFT)
+#define OP_PCL_PKPROT_HASH_SHA512 (5 << OP_PCL_PKPROT_HASH_SHIFT)
+#define OP_PCL_PKPROT_EKT_Z BIT(6)
+#define OP_PCL_PKPROT_DECRYPT_Z BIT(5)
+#define OP_PCL_PKPROT_EKT_PRI BIT(4)
+#define OP_PCL_PKPROT_TEST BIT(3)
+#define OP_PCL_PKPROT_DECRYPT_PRI BIT(2)
+#define OP_PCL_PKPROT_ECC BIT(1)
+#define OP_PCL_PKPROT_F2M BIT(0)
+
+/* Blob protinfos */
+#define OP_PCL_BLOB_TKEK_SHIFT 9
+#define OP_PCL_BLOB_TKEK BIT(9)
+#define OP_PCL_BLOB_EKT_SHIFT 8
+#define OP_PCL_BLOB_EKT BIT(8)
+#define OP_PCL_BLOB_REG_SHIFT 4
+#define OP_PCL_BLOB_REG_MASK (0xF << OP_PCL_BLOB_REG_SHIFT)
+#define OP_PCL_BLOB_REG_MEMORY (0x0 << OP_PCL_BLOB_REG_SHIFT)
+#define OP_PCL_BLOB_REG_KEY1 (0x1 << OP_PCL_BLOB_REG_SHIFT)
+#define OP_PCL_BLOB_REG_KEY2 (0x3 << OP_PCL_BLOB_REG_SHIFT)
+#define OP_PCL_BLOB_AFHA_SBOX (0x5 << OP_PCL_BLOB_REG_SHIFT)
+#define OP_PCL_BLOB_REG_SPLIT (0x7 << OP_PCL_BLOB_REG_SHIFT)
+#define OP_PCL_BLOB_REG_PKE (0x9 << OP_PCL_BLOB_REG_SHIFT)
+#define OP_PCL_BLOB_SEC_MEM_SHIFT 3
+#define OP_PCL_BLOB_SEC_MEM BIT(3)
+#define OP_PCL_BLOB_BLACK BIT(2)
+#define OP_PCL_BLOB_FORMAT_SHIFT 0
+#define OP_PCL_BLOB_FORMAT_MASK 0x3
+#define OP_PCL_BLOB_FORMAT_NORMAL 0
+#define OP_PCL_BLOB_FORMAT_MASTER_VER 2
+#define OP_PCL_BLOB_FORMAT_TEST 3
+
+/* IKE / IKEv2 protinfos */
+#define OP_PCL_IKE_HMAC_MD5 0x0100
+#define OP_PCL_IKE_HMAC_SHA1 0x0200
+#define OP_PCL_IKE_HMAC_AES128_CBC 0x0400
+#define OP_PCL_IKE_HMAC_SHA256 0x0500
+#define OP_PCL_IKE_HMAC_SHA384 0x0600
+#define OP_PCL_IKE_HMAC_SHA512 0x0700
+#define OP_PCL_IKE_HMAC_AES128_CMAC 0x0800
+
+/* PKI unidirectional protocol protinfo bits */
+#define OP_PCL_PKPROT_TEST BIT(3)
+#define OP_PCL_PKPROT_DECRYPT BIT(2)
+#define OP_PCL_PKPROT_ECC BIT(1)
+#define OP_PCL_PKPROT_F2M BIT(0)
+
+/* RSA Protinfo */
+#define OP_PCL_RSAPROT_OP_MASK 3
+#define OP_PCL_RSAPROT_OP_ENC_F_IN 0
+#define OP_PCL_RSAPROT_OP_ENC_F_OUT 1
+#define OP_PCL_RSAPROT_OP_DEC_ND 0
+#define OP_PCL_RSAPROT_OP_DEC_PQD 1
+#define OP_PCL_RSAPROT_OP_DEC_PQDPDQC 2
+#define OP_PCL_RSAPROT_FFF_SHIFT 4
+#define OP_PCL_RSAPROT_FFF_MASK (7 << OP_PCL_RSAPROT_FFF_SHIFT)
+#define OP_PCL_RSAPROT_FFF_RED (0 << OP_PCL_RSAPROT_FFF_SHIFT)
+#define OP_PCL_RSAPROT_FFF_ENC (1 << OP_PCL_RSAPROT_FFF_SHIFT)
+#define OP_PCL_RSAPROT_FFF_TK_ENC (5 << OP_PCL_RSAPROT_FFF_SHIFT)
+#define OP_PCL_RSAPROT_FFF_EKT (3 << OP_PCL_RSAPROT_FFF_SHIFT)
+#define OP_PCL_RSAPROT_FFF_TK_EKT (7 << OP_PCL_RSAPROT_FFF_SHIFT)
+#define OP_PCL_RSAPROT_PPP_SHIFT 8
+#define OP_PCL_RSAPROT_PPP_MASK (7 << OP_PCL_RSAPROT_PPP_SHIFT)
+#define OP_PCL_RSAPROT_PPP_RED (0 << OP_PCL_RSAPROT_PPP_SHIFT)
+#define OP_PCL_RSAPROT_PPP_ENC (1 << OP_PCL_RSAPROT_PPP_SHIFT)
+#define OP_PCL_RSAPROT_PPP_TK_ENC (5 << OP_PCL_RSAPROT_PPP_SHIFT)
+#define OP_PCL_RSAPROT_PPP_EKT (3 << OP_PCL_RSAPROT_PPP_SHIFT)
+#define OP_PCL_RSAPROT_PPP_TK_EKT (7 << OP_PCL_RSAPROT_PPP_SHIFT)
+#define OP_PCL_RSAPROT_FMT_PKCSV15 BIT(12)
+
+/* Derived Key Protocol (DKP) Protinfo */
+#define OP_PCL_DKP_SRC_SHIFT 14
+#define OP_PCL_DKP_SRC_MASK (3 << OP_PCL_DKP_SRC_SHIFT)
+#define OP_PCL_DKP_SRC_IMM (0 << OP_PCL_DKP_SRC_SHIFT)
+#define OP_PCL_DKP_SRC_SEQ (1 << OP_PCL_DKP_SRC_SHIFT)
+#define OP_PCL_DKP_SRC_PTR (2 << OP_PCL_DKP_SRC_SHIFT)
+#define OP_PCL_DKP_SRC_SGF (3 << OP_PCL_DKP_SRC_SHIFT)
+#define OP_PCL_DKP_DST_SHIFT 12
+#define OP_PCL_DKP_DST_MASK (3 << OP_PCL_DKP_DST_SHIFT)
+#define OP_PCL_DKP_DST_IMM (0 << OP_PCL_DKP_DST_SHIFT)
+#define OP_PCL_DKP_DST_SEQ (1 << OP_PCL_DKP_DST_SHIFT)
+#define OP_PCL_DKP_DST_PTR (2 << OP_PCL_DKP_DST_SHIFT)
+#define OP_PCL_DKP_DST_SGF (3 << OP_PCL_DKP_DST_SHIFT)
+#define OP_PCL_DKP_KEY_SHIFT 0
+#define OP_PCL_DKP_KEY_MASK (0xfff << OP_PCL_DKP_KEY_SHIFT)
+
+/* For non-protocol/alg-only op commands */
+#define OP_ALG_TYPE_SHIFT 24
+#define OP_ALG_TYPE_MASK (0x7 << OP_ALG_TYPE_SHIFT)
+#define OP_ALG_TYPE_CLASS1 (0x2 << OP_ALG_TYPE_SHIFT)
+#define OP_ALG_TYPE_CLASS2 (0x4 << OP_ALG_TYPE_SHIFT)
+
+#define OP_ALG_ALGSEL_SHIFT 16
+#define OP_ALG_ALGSEL_MASK (0xff << OP_ALG_ALGSEL_SHIFT)
+#define OP_ALG_ALGSEL_SUBMASK (0x0f << OP_ALG_ALGSEL_SHIFT)
+#define OP_ALG_ALGSEL_AES (0x10 << OP_ALG_ALGSEL_SHIFT)
+#define OP_ALG_ALGSEL_DES (0x20 << OP_ALG_ALGSEL_SHIFT)
+#define OP_ALG_ALGSEL_3DES (0x21 << OP_ALG_ALGSEL_SHIFT)
+#define OP_ALG_ALGSEL_ARC4 (0x30 << OP_ALG_ALGSEL_SHIFT)
+#define OP_ALG_ALGSEL_MD5 (0x40 << OP_ALG_ALGSEL_SHIFT)
+#define OP_ALG_ALGSEL_SHA1 (0x41 << OP_ALG_ALGSEL_SHIFT)
+#define OP_ALG_ALGSEL_SHA224 (0x42 << OP_ALG_ALGSEL_SHIFT)
+#define OP_ALG_ALGSEL_SHA256 (0x43 << OP_ALG_ALGSEL_SHIFT)
+#define OP_ALG_ALGSEL_SHA384 (0x44 << OP_ALG_ALGSEL_SHIFT)
+#define OP_ALG_ALGSEL_SHA512 (0x45 << OP_ALG_ALGSEL_SHIFT)
+#define OP_ALG_ALGSEL_RNG (0x50 << OP_ALG_ALGSEL_SHIFT)
+#define OP_ALG_ALGSEL_SNOW_F8 (0x60 << OP_ALG_ALGSEL_SHIFT)
+#define OP_ALG_ALGSEL_KASUMI (0x70 << OP_ALG_ALGSEL_SHIFT)
+#define OP_ALG_ALGSEL_CRC (0x90 << OP_ALG_ALGSEL_SHIFT)
+#define OP_ALG_ALGSEL_SNOW_F9 (0xA0 << OP_ALG_ALGSEL_SHIFT)
+#define OP_ALG_ALGSEL_ZUCE (0xB0 << OP_ALG_ALGSEL_SHIFT)
+#define OP_ALG_ALGSEL_ZUCA (0xC0 << OP_ALG_ALGSEL_SHIFT)
+
+#define OP_ALG_AAI_SHIFT 4
+#define OP_ALG_AAI_MASK (0x3ff << OP_ALG_AAI_SHIFT)
+
+/* block cipher AAI set */
+#define OP_ALG_AESA_MODE_MASK (0xF0 << OP_ALG_AAI_SHIFT)
+#define OP_ALG_AAI_CTR (0x00 << OP_ALG_AAI_SHIFT)
+#define OP_ALG_AAI_CTR_MOD128 (0x00 << OP_ALG_AAI_SHIFT)
+#define OP_ALG_AAI_CTR_MOD8 (0x01 << OP_ALG_AAI_SHIFT)
+#define OP_ALG_AAI_CTR_MOD16 (0x02 << OP_ALG_AAI_SHIFT)
+#define OP_ALG_AAI_CTR_MOD24 (0x03 << OP_ALG_AAI_SHIFT)
+#define OP_ALG_AAI_CTR_MOD32 (0x04 << OP_ALG_AAI_SHIFT)
+#define OP_ALG_AAI_CTR_MOD40 (0x05 << OP_ALG_AAI_SHIFT)
+#define OP_ALG_AAI_CTR_MOD48 (0x06 << OP_ALG_AAI_SHIFT)
+#define OP_ALG_AAI_CTR_MOD56 (0x07 << OP_ALG_AAI_SHIFT)
+#define OP_ALG_AAI_CTR_MOD64 (0x08 << OP_ALG_AAI_SHIFT)
+#define OP_ALG_AAI_CTR_MOD72 (0x09 << OP_ALG_AAI_SHIFT)
+#define OP_ALG_AAI_CTR_MOD80 (0x0a << OP_ALG_AAI_SHIFT)
+#define OP_ALG_AAI_CTR_MOD88 (0x0b << OP_ALG_AAI_SHIFT)
+#define OP_ALG_AAI_CTR_MOD96 (0x0c << OP_ALG_AAI_SHIFT)
+#define OP_ALG_AAI_CTR_MOD104 (0x0d << OP_ALG_AAI_SHIFT)
+#define OP_ALG_AAI_CTR_MOD112 (0x0e << OP_ALG_AAI_SHIFT)
+#define OP_ALG_AAI_CTR_MOD120 (0x0f << OP_ALG_AAI_SHIFT)
+#define OP_ALG_AAI_CBC (0x10 << OP_ALG_AAI_SHIFT)
+#define OP_ALG_AAI_ECB (0x20 << OP_ALG_AAI_SHIFT)
+#define OP_ALG_AAI_CFB (0x30 << OP_ALG_AAI_SHIFT)
+#define OP_ALG_AAI_OFB (0x40 << OP_ALG_AAI_SHIFT)
+#define OP_ALG_AAI_XTS (0x50 << OP_ALG_AAI_SHIFT)
+#define OP_ALG_AAI_CMAC (0x60 << OP_ALG_AAI_SHIFT)
+#define OP_ALG_AAI_XCBC_MAC (0x70 << OP_ALG_AAI_SHIFT)
+#define OP_ALG_AAI_CCM (0x80 << OP_ALG_AAI_SHIFT)
+#define OP_ALG_AAI_GCM (0x90 << OP_ALG_AAI_SHIFT)
+#define OP_ALG_AAI_CBC_XCBCMAC (0xa0 << OP_ALG_AAI_SHIFT)
+#define OP_ALG_AAI_CTR_XCBCMAC (0xb0 << OP_ALG_AAI_SHIFT)
+#define OP_ALG_AAI_CBC_CMAC (0xc0 << OP_ALG_AAI_SHIFT)
+#define OP_ALG_AAI_CTR_CMAC_LTE (0xd0 << OP_ALG_AAI_SHIFT)
+#define OP_ALG_AAI_CTR_CMAC (0xe0 << OP_ALG_AAI_SHIFT)
+#define OP_ALG_AAI_CHECKODD (0x80 << OP_ALG_AAI_SHIFT)
+#define OP_ALG_AAI_DK (0x100 << OP_ALG_AAI_SHIFT)
+#define OP_ALG_AAI_C2K (0x200 << OP_ALG_AAI_SHIFT)
+
+/* randomizer AAI set */
+#define OP_ALG_RNG_MODE_MASK (0x30 << OP_ALG_AAI_SHIFT)
+#define OP_ALG_AAI_RNG (0x00 << OP_ALG_AAI_SHIFT)
+#define OP_ALG_AAI_RNG_NZB (0x10 << OP_ALG_AAI_SHIFT)
+#define OP_ALG_AAI_RNG_OBP (0x20 << OP_ALG_AAI_SHIFT)
+
+/* RNG4 AAI set */
+#define OP_ALG_AAI_RNG4_SH_SHIFT OP_ALG_AAI_SHIFT
+#define OP_ALG_AAI_RNG4_SH_MASK (0x03 << OP_ALG_AAI_RNG4_SH_SHIFT)
+#define OP_ALG_AAI_RNG4_SH_0 (0x00 << OP_ALG_AAI_RNG4_SH_SHIFT)
+#define OP_ALG_AAI_RNG4_SH_1 (0x01 << OP_ALG_AAI_RNG4_SH_SHIFT)
+#define OP_ALG_AAI_RNG4_PS (0x40 << OP_ALG_AAI_SHIFT)
+#define OP_ALG_AAI_RNG4_AI (0x80 << OP_ALG_AAI_SHIFT)
+#define OP_ALG_AAI_RNG4_SK (0x100 << OP_ALG_AAI_SHIFT)
+
+/* hmac/smac AAI set */
+#define OP_ALG_AAI_HASH (0x00 << OP_ALG_AAI_SHIFT)
+#define OP_ALG_AAI_HMAC (0x01 << OP_ALG_AAI_SHIFT)
+#define OP_ALG_AAI_SMAC (0x02 << OP_ALG_AAI_SHIFT)
+#define OP_ALG_AAI_HMAC_PRECOMP (0x04 << OP_ALG_AAI_SHIFT)
+
+/* CRC AAI set*/
+#define OP_ALG_CRC_POLY_MASK (0x07 << OP_ALG_AAI_SHIFT)
+#define OP_ALG_AAI_802 (0x01 << OP_ALG_AAI_SHIFT)
+#define OP_ALG_AAI_3385 (0x02 << OP_ALG_AAI_SHIFT)
+#define OP_ALG_AAI_CUST_POLY (0x04 << OP_ALG_AAI_SHIFT)
+#define OP_ALG_AAI_DIS (0x10 << OP_ALG_AAI_SHIFT)
+#define OP_ALG_AAI_DOS (0x20 << OP_ALG_AAI_SHIFT)
+#define OP_ALG_AAI_DOC (0x40 << OP_ALG_AAI_SHIFT)
+#define OP_ALG_AAI_IVZ (0x80 << OP_ALG_AAI_SHIFT)
+
+/* Kasumi/SNOW/ZUC AAI set */
+#define OP_ALG_AAI_F8 (0xc0 << OP_ALG_AAI_SHIFT)
+#define OP_ALG_AAI_F9 (0xc8 << OP_ALG_AAI_SHIFT)
+#define OP_ALG_AAI_GSM (0x10 << OP_ALG_AAI_SHIFT)
+#define OP_ALG_AAI_EDGE (0x20 << OP_ALG_AAI_SHIFT)
+
+#define OP_ALG_AS_SHIFT 2
+#define OP_ALG_AS_MASK (0x3 << OP_ALG_AS_SHIFT)
+#define OP_ALG_AS_UPDATE (0 << OP_ALG_AS_SHIFT)
+#define OP_ALG_AS_INIT (1 << OP_ALG_AS_SHIFT)
+#define OP_ALG_AS_FINALIZE (2 << OP_ALG_AS_SHIFT)
+#define OP_ALG_AS_INITFINAL (3 << OP_ALG_AS_SHIFT)
+
+#define OP_ALG_ICV_SHIFT 1
+#define OP_ALG_ICV_MASK (1 << OP_ALG_ICV_SHIFT)
+#define OP_ALG_ICV_OFF 0
+#define OP_ALG_ICV_ON BIT(1)
+
+#define OP_ALG_DIR_SHIFT 0
+#define OP_ALG_DIR_MASK 1
+#define OP_ALG_DECRYPT 0
+#define OP_ALG_ENCRYPT BIT(0)
+
+/* PKHA algorithm type set */
+#define OP_ALG_PK 0x00800000
+#define OP_ALG_PK_FUN_MASK 0x3f /* clrmem, modmath, or cpymem */
+
+/* PKHA mode clear memory functions */
+#define OP_ALG_PKMODE_A_RAM BIT(19)
+#define OP_ALG_PKMODE_B_RAM BIT(18)
+#define OP_ALG_PKMODE_E_RAM BIT(17)
+#define OP_ALG_PKMODE_N_RAM BIT(16)
+#define OP_ALG_PKMODE_CLEARMEM BIT(0)
+
+/* PKHA mode clear memory functions */
+#define OP_ALG_PKMODE_CLEARMEM_ALL (OP_ALG_PKMODE_CLEARMEM | \
+ OP_ALG_PKMODE_A_RAM | \
+ OP_ALG_PKMODE_B_RAM | \
+ OP_ALG_PKMODE_N_RAM | \
+ OP_ALG_PKMODE_E_RAM)
+#define OP_ALG_PKMODE_CLEARMEM_ABE (OP_ALG_PKMODE_CLEARMEM | \
+ OP_ALG_PKMODE_A_RAM | \
+ OP_ALG_PKMODE_B_RAM | \
+ OP_ALG_PKMODE_E_RAM)
+#define OP_ALG_PKMODE_CLEARMEM_ABN (OP_ALG_PKMODE_CLEARMEM | \
+ OP_ALG_PKMODE_A_RAM | \
+ OP_ALG_PKMODE_B_RAM | \
+ OP_ALG_PKMODE_N_RAM)
+#define OP_ALG_PKMODE_CLEARMEM_AB (OP_ALG_PKMODE_CLEARMEM | \
+ OP_ALG_PKMODE_A_RAM | \
+ OP_ALG_PKMODE_B_RAM)
+#define OP_ALG_PKMODE_CLEARMEM_AEN (OP_ALG_PKMODE_CLEARMEM | \
+ OP_ALG_PKMODE_A_RAM | \
+ OP_ALG_PKMODE_E_RAM | \
+ OP_ALG_PKMODE_N_RAM)
+#define OP_ALG_PKMODE_CLEARMEM_AE (OP_ALG_PKMODE_CLEARMEM | \
+ OP_ALG_PKMODE_A_RAM | \
+ OP_ALG_PKMODE_E_RAM)
+#define OP_ALG_PKMODE_CLEARMEM_AN (OP_ALG_PKMODE_CLEARMEM | \
+ OP_ALG_PKMODE_A_RAM | \
+ OP_ALG_PKMODE_N_RAM)
+#define OP_ALG_PKMODE_CLEARMEM_A (OP_ALG_PKMODE_CLEARMEM | \
+ OP_ALG_PKMODE_A_RAM)
+#define OP_ALG_PKMODE_CLEARMEM_BEN (OP_ALG_PKMODE_CLEARMEM | \
+ OP_ALG_PKMODE_B_RAM | \
+ OP_ALG_PKMODE_E_RAM | \
+ OP_ALG_PKMODE_N_RAM)
+#define OP_ALG_PKMODE_CLEARMEM_BE (OP_ALG_PKMODE_CLEARMEM | \
+ OP_ALG_PKMODE_B_RAM | \
+ OP_ALG_PKMODE_E_RAM)
+#define OP_ALG_PKMODE_CLEARMEM_BN (OP_ALG_PKMODE_CLEARMEM | \
+ OP_ALG_PKMODE_B_RAM | \
+ OP_ALG_PKMODE_N_RAM)
+#define OP_ALG_PKMODE_CLEARMEM_B (OP_ALG_PKMODE_CLEARMEM | \
+ OP_ALG_PKMODE_B_RAM)
+#define OP_ALG_PKMODE_CLEARMEM_EN (OP_ALG_PKMODE_CLEARMEM | \
+ OP_ALG_PKMODE_E_RAM | \
+ OP_ALG_PKMODE_N_RAM)
+#define OP_ALG_PKMODE_CLEARMEM_E (OP_ALG_PKMODE_CLEARMEM | \
+ OP_ALG_PKMODE_E_RAM)
+#define OP_ALG_PKMODE_CLEARMEM_N (OP_ALG_PKMODE_CLEARMEM | \
+ OP_ALG_PKMODE_N_RAM)
+
+/* PKHA mode modular-arithmetic functions */
+#define OP_ALG_PKMODE_MOD_IN_MONTY BIT(19)
+#define OP_ALG_PKMODE_MOD_OUT_MONTY BIT(18)
+#define OP_ALG_PKMODE_MOD_F2M BIT(17)
+#define OP_ALG_PKMODE_MOD_R2_IN BIT(16)
+#define OP_ALG_PKMODE_PRJECTV BIT(11)
+#define OP_ALG_PKMODE_TIME_EQ BIT(10)
+
+#define OP_ALG_PKMODE_OUT_B 0x000
+#define OP_ALG_PKMODE_OUT_A 0x100
+
+/*
+ * PKHA mode modular-arithmetic integer functions
+ * Can be ORed with OP_ALG_PKMODE_OUT_A to change destination from B
+ */
+#define OP_ALG_PKMODE_MOD_ADD 0x002
+#define OP_ALG_PKMODE_MOD_SUB_AB 0x003
+#define OP_ALG_PKMODE_MOD_SUB_BA 0x004
+#define OP_ALG_PKMODE_MOD_MULT 0x005
+#define OP_ALG_PKMODE_MOD_MULT_IM (0x005 | OP_ALG_PKMODE_MOD_IN_MONTY)
+#define OP_ALG_PKMODE_MOD_MULT_IM_OM (0x005 | OP_ALG_PKMODE_MOD_IN_MONTY \
+ | OP_ALG_PKMODE_MOD_OUT_MONTY)
+#define OP_ALG_PKMODE_MOD_EXPO 0x006
+#define OP_ALG_PKMODE_MOD_EXPO_TEQ (0x006 | OP_ALG_PKMODE_TIME_EQ)
+#define OP_ALG_PKMODE_MOD_EXPO_IM (0x006 | OP_ALG_PKMODE_MOD_IN_MONTY)
+#define OP_ALG_PKMODE_MOD_EXPO_IM_TEQ (0x006 | OP_ALG_PKMODE_MOD_IN_MONTY \
+ | OP_ALG_PKMODE_TIME_EQ)
+#define OP_ALG_PKMODE_MOD_REDUCT 0x007
+#define OP_ALG_PKMODE_MOD_INV 0x008
+#define OP_ALG_PKMODE_MOD_ECC_ADD 0x009
+#define OP_ALG_PKMODE_MOD_ECC_DBL 0x00a
+#define OP_ALG_PKMODE_MOD_ECC_MULT 0x00b
+#define OP_ALG_PKMODE_MOD_MONT_CNST 0x00c
+#define OP_ALG_PKMODE_MOD_CRT_CNST 0x00d
+#define OP_ALG_PKMODE_MOD_GCD 0x00e
+#define OP_ALG_PKMODE_MOD_PRIMALITY 0x00f
+#define OP_ALG_PKMODE_MOD_SML_EXP 0x016
+
+/*
+ * PKHA mode modular-arithmetic F2m functions
+ * Can be ORed with OP_ALG_PKMODE_OUT_A to change destination from B
+ */
+#define OP_ALG_PKMODE_F2M_ADD (0x002 | OP_ALG_PKMODE_MOD_F2M)
+#define OP_ALG_PKMODE_F2M_MUL (0x005 | OP_ALG_PKMODE_MOD_F2M)
+#define OP_ALG_PKMODE_F2M_MUL_IM (0x005 | OP_ALG_PKMODE_MOD_F2M \
+ | OP_ALG_PKMODE_MOD_IN_MONTY)
+#define OP_ALG_PKMODE_F2M_MUL_IM_OM (0x005 | OP_ALG_PKMODE_MOD_F2M \
+ | OP_ALG_PKMODE_MOD_IN_MONTY \
+ | OP_ALG_PKMODE_MOD_OUT_MONTY)
+#define OP_ALG_PKMODE_F2M_EXP (0x006 | OP_ALG_PKMODE_MOD_F2M)
+#define OP_ALG_PKMODE_F2M_EXP_TEQ (0x006 | OP_ALG_PKMODE_MOD_F2M \
+ | OP_ALG_PKMODE_TIME_EQ)
+#define OP_ALG_PKMODE_F2M_AMODN (0x007 | OP_ALG_PKMODE_MOD_F2M)
+#define OP_ALG_PKMODE_F2M_INV (0x008 | OP_ALG_PKMODE_MOD_F2M)
+#define OP_ALG_PKMODE_F2M_R2 (0x00c | OP_ALG_PKMODE_MOD_F2M)
+#define OP_ALG_PKMODE_F2M_GCD (0x00e | OP_ALG_PKMODE_MOD_F2M)
+#define OP_ALG_PKMODE_F2M_SML_EXP (0x016 | OP_ALG_PKMODE_MOD_F2M)
+
+/*
+ * PKHA mode ECC Integer arithmetic functions
+ * Can be ORed with OP_ALG_PKMODE_OUT_A to change destination from B
+ */
+#define OP_ALG_PKMODE_ECC_MOD_ADD 0x009
+#define OP_ALG_PKMODE_ECC_MOD_ADD_IM_OM_PROJ \
+ (0x009 | OP_ALG_PKMODE_MOD_IN_MONTY \
+ | OP_ALG_PKMODE_MOD_OUT_MONTY \
+ | OP_ALG_PKMODE_PRJECTV)
+#define OP_ALG_PKMODE_ECC_MOD_DBL 0x00a
+#define OP_ALG_PKMODE_ECC_MOD_DBL_IM_OM_PROJ \
+ (0x00a | OP_ALG_PKMODE_MOD_IN_MONTY \
+ | OP_ALG_PKMODE_MOD_OUT_MONTY \
+ | OP_ALG_PKMODE_PRJECTV)
+#define OP_ALG_PKMODE_ECC_MOD_MUL 0x00b
+#define OP_ALG_PKMODE_ECC_MOD_MUL_TEQ (0x00b | OP_ALG_PKMODE_TIME_EQ)
+#define OP_ALG_PKMODE_ECC_MOD_MUL_R2 (0x00b | OP_ALG_PKMODE_MOD_R2_IN)
+#define OP_ALG_PKMODE_ECC_MOD_MUL_R2_TEQ \
+ (0x00b | OP_ALG_PKMODE_MOD_R2_IN \
+ | OP_ALG_PKMODE_TIME_EQ)
+#define OP_ALG_PKMODE_ECC_MOD_MUL_R2_PROJ \
+ (0x00b | OP_ALG_PKMODE_MOD_R2_IN \
+ | OP_ALG_PKMODE_PRJECTV)
+#define OP_ALG_PKMODE_ECC_MOD_MUL_R2_PROJ_TEQ \
+ (0x00b | OP_ALG_PKMODE_MOD_R2_IN \
+ | OP_ALG_PKMODE_PRJECTV \
+ | OP_ALG_PKMODE_TIME_EQ)
+
+/*
+ * PKHA mode ECC F2m arithmetic functions
+ * Can be ORed with OP_ALG_PKMODE_OUT_A to change destination from B
+ */
+#define OP_ALG_PKMODE_ECC_F2M_ADD (0x009 | OP_ALG_PKMODE_MOD_F2M)
+#define OP_ALG_PKMODE_ECC_F2M_ADD_IM_OM_PROJ \
+ (0x009 | OP_ALG_PKMODE_MOD_F2M \
+ | OP_ALG_PKMODE_MOD_IN_MONTY \
+ | OP_ALG_PKMODE_MOD_OUT_MONTY \
+ | OP_ALG_PKMODE_PRJECTV)
+#define OP_ALG_PKMODE_ECC_F2M_DBL (0x00a | OP_ALG_PKMODE_MOD_F2M)
+#define OP_ALG_PKMODE_ECC_F2M_DBL_IM_OM_PROJ \
+ (0x00a | OP_ALG_PKMODE_MOD_F2M \
+ | OP_ALG_PKMODE_MOD_IN_MONTY \
+ | OP_ALG_PKMODE_MOD_OUT_MONTY \
+ | OP_ALG_PKMODE_PRJECTV)
+#define OP_ALG_PKMODE_ECC_F2M_MUL (0x00b | OP_ALG_PKMODE_MOD_F2M)
+#define OP_ALG_PKMODE_ECC_F2M_MUL_TEQ \
+ (0x00b | OP_ALG_PKMODE_MOD_F2M \
+ | OP_ALG_PKMODE_TIME_EQ)
+#define OP_ALG_PKMODE_ECC_F2M_MUL_R2 \
+ (0x00b | OP_ALG_PKMODE_MOD_F2M \
+ | OP_ALG_PKMODE_MOD_R2_IN)
+#define OP_ALG_PKMODE_ECC_F2M_MUL_R2_TEQ \
+ (0x00b | OP_ALG_PKMODE_MOD_F2M \
+ | OP_ALG_PKMODE_MOD_R2_IN \
+ | OP_ALG_PKMODE_TIME_EQ)
+#define OP_ALG_PKMODE_ECC_F2M_MUL_R2_PROJ \
+ (0x00b | OP_ALG_PKMODE_MOD_F2M \
+ | OP_ALG_PKMODE_MOD_R2_IN \
+ | OP_ALG_PKMODE_PRJECTV)
+#define OP_ALG_PKMODE_ECC_F2M_MUL_R2_PROJ_TEQ \
+ (0x00b | OP_ALG_PKMODE_MOD_F2M \
+ | OP_ALG_PKMODE_MOD_R2_IN \
+ | OP_ALG_PKMODE_PRJECTV \
+ | OP_ALG_PKMODE_TIME_EQ)
+
+/* PKHA mode copy-memory functions */
+#define OP_ALG_PKMODE_SRC_REG_SHIFT 17
+#define OP_ALG_PKMODE_SRC_REG_MASK (7 << OP_ALG_PKMODE_SRC_REG_SHIFT)
+#define OP_ALG_PKMODE_DST_REG_SHIFT 10
+#define OP_ALG_PKMODE_DST_REG_MASK (7 << OP_ALG_PKMODE_DST_REG_SHIFT)
+#define OP_ALG_PKMODE_SRC_SEG_SHIFT 8
+#define OP_ALG_PKMODE_SRC_SEG_MASK (3 << OP_ALG_PKMODE_SRC_SEG_SHIFT)
+#define OP_ALG_PKMODE_DST_SEG_SHIFT 6
+#define OP_ALG_PKMODE_DST_SEG_MASK (3 << OP_ALG_PKMODE_DST_SEG_SHIFT)
+
+#define OP_ALG_PKMODE_SRC_REG_A (0 << OP_ALG_PKMODE_SRC_REG_SHIFT)
+#define OP_ALG_PKMODE_SRC_REG_B (1 << OP_ALG_PKMODE_SRC_REG_SHIFT)
+#define OP_ALG_PKMODE_SRC_REG_N (3 << OP_ALG_PKMODE_SRC_REG_SHIFT)
+#define OP_ALG_PKMODE_DST_REG_A (0 << OP_ALG_PKMODE_DST_REG_SHIFT)
+#define OP_ALG_PKMODE_DST_REG_B (1 << OP_ALG_PKMODE_DST_REG_SHIFT)
+#define OP_ALG_PKMODE_DST_REG_E (2 << OP_ALG_PKMODE_DST_REG_SHIFT)
+#define OP_ALG_PKMODE_DST_REG_N (3 << OP_ALG_PKMODE_DST_REG_SHIFT)
+#define OP_ALG_PKMODE_SRC_SEG_0 (0 << OP_ALG_PKMODE_SRC_SEG_SHIFT)
+#define OP_ALG_PKMODE_SRC_SEG_1 (1 << OP_ALG_PKMODE_SRC_SEG_SHIFT)
+#define OP_ALG_PKMODE_SRC_SEG_2 (2 << OP_ALG_PKMODE_SRC_SEG_SHIFT)
+#define OP_ALG_PKMODE_SRC_SEG_3 (3 << OP_ALG_PKMODE_SRC_SEG_SHIFT)
+#define OP_ALG_PKMODE_DST_SEG_0 (0 << OP_ALG_PKMODE_DST_SEG_SHIFT)
+#define OP_ALG_PKMODE_DST_SEG_1 (1 << OP_ALG_PKMODE_DST_SEG_SHIFT)
+#define OP_ALG_PKMODE_DST_SEG_2 (2 << OP_ALG_PKMODE_DST_SEG_SHIFT)
+#define OP_ALG_PKMODE_DST_SEG_3 (3 << OP_ALG_PKMODE_DST_SEG_SHIFT)
+
+/* PKHA mode copy-memory functions - amount based on N SIZE */
+#define OP_ALG_PKMODE_COPY_NSZ 0x10
+#define OP_ALG_PKMODE_COPY_NSZ_A0_B0 (OP_ALG_PKMODE_COPY_NSZ | \
+ OP_ALG_PKMODE_SRC_REG_A | \
+ OP_ALG_PKMODE_DST_REG_B)
+#define OP_ALG_PKMODE_COPY_NSZ_A0_B1 (OP_ALG_PKMODE_COPY_NSZ | \
+ OP_ALG_PKMODE_SRC_REG_A | \
+ OP_ALG_PKMODE_DST_REG_B | \
+ OP_ALG_PKMODE_DST_SEG_1)
+#define OP_ALG_PKMODE_COPY_NSZ_A0_B2 (OP_ALG_PKMODE_COPY_NSZ | \
+ OP_ALG_PKMODE_SRC_REG_A | \
+ OP_ALG_PKMODE_DST_REG_B | \
+ OP_ALG_PKMODE_DST_SEG_2)
+#define OP_ALG_PKMODE_COPY_NSZ_A0_B3 (OP_ALG_PKMODE_COPY_NSZ | \
+ OP_ALG_PKMODE_SRC_REG_A | \
+ OP_ALG_PKMODE_DST_REG_B | \
+ OP_ALG_PKMODE_DST_SEG_3)
+
+#define OP_ALG_PKMODE_COPY_NSZ_A1_B0 (OP_ALG_PKMODE_COPY_NSZ | \
+ OP_ALG_PKMODE_SRC_REG_A | \
+ OP_ALG_PKMODE_SRC_SEG_1 | \
+ OP_ALG_PKMODE_DST_REG_B)
+#define OP_ALG_PKMODE_COPY_NSZ_A1_B1 (OP_ALG_PKMODE_COPY_NSZ | \
+ OP_ALG_PKMODE_SRC_REG_A | \
+ OP_ALG_PKMODE_SRC_SEG_1 | \
+ OP_ALG_PKMODE_DST_REG_B | \
+ OP_ALG_PKMODE_DST_SEG_1)
+#define OP_ALG_PKMODE_COPY_NSZ_A1_B2 (OP_ALG_PKMODE_COPY_NSZ | \
+ OP_ALG_PKMODE_SRC_REG_A | \
+ OP_ALG_PKMODE_SRC_SEG_1 | \
+ OP_ALG_PKMODE_DST_REG_B | \
+ OP_ALG_PKMODE_DST_SEG_2)
+#define OP_ALG_PKMODE_COPY_NSZ_A1_B3 (OP_ALG_PKMODE_COPY_NSZ | \
+ OP_ALG_PKMODE_SRC_REG_A | \
+ OP_ALG_PKMODE_SRC_SEG_1 | \
+ OP_ALG_PKMODE_DST_REG_B | \
+ OP_ALG_PKMODE_DST_SEG_3)
+
+#define OP_ALG_PKMODE_COPY_NSZ_A2_B0 (OP_ALG_PKMODE_COPY_NSZ | \
+ OP_ALG_PKMODE_SRC_REG_A | \
+ OP_ALG_PKMODE_SRC_SEG_2 | \
+ OP_ALG_PKMODE_DST_REG_B)
+#define OP_ALG_PKMODE_COPY_NSZ_A2_B1 (OP_ALG_PKMODE_COPY_NSZ | \
+ OP_ALG_PKMODE_SRC_REG_A | \
+ OP_ALG_PKMODE_SRC_SEG_2 | \
+ OP_ALG_PKMODE_DST_REG_B | \
+ OP_ALG_PKMODE_DST_SEG_1)
+#define OP_ALG_PKMODE_COPY_NSZ_A2_B2 (OP_ALG_PKMODE_COPY_NSZ | \
+ OP_ALG_PKMODE_SRC_REG_A | \
+ OP_ALG_PKMODE_SRC_SEG_2 | \
+ OP_ALG_PKMODE_DST_REG_B | \
+ OP_ALG_PKMODE_DST_SEG_2)
+#define OP_ALG_PKMODE_COPY_NSZ_A2_B3 (OP_ALG_PKMODE_COPY_NSZ | \
+ OP_ALG_PKMODE_SRC_REG_A | \
+ OP_ALG_PKMODE_SRC_SEG_2 | \
+ OP_ALG_PKMODE_DST_REG_B | \
+ OP_ALG_PKMODE_DST_SEG_3)
+
+#define OP_ALG_PKMODE_COPY_NSZ_A3_B0 (OP_ALG_PKMODE_COPY_NSZ | \
+ OP_ALG_PKMODE_SRC_REG_A | \
+ OP_ALG_PKMODE_SRC_SEG_3 | \
+ OP_ALG_PKMODE_DST_REG_B)
+#define OP_ALG_PKMODE_COPY_NSZ_A3_B1 (OP_ALG_PKMODE_COPY_NSZ | \
+ OP_ALG_PKMODE_SRC_REG_A | \
+ OP_ALG_PKMODE_SRC_SEG_3 | \
+ OP_ALG_PKMODE_DST_REG_B | \
+ OP_ALG_PKMODE_DST_SEG_1)
+#define OP_ALG_PKMODE_COPY_NSZ_A3_B2 (OP_ALG_PKMODE_COPY_NSZ | \
+ OP_ALG_PKMODE_SRC_REG_A | \
+ OP_ALG_PKMODE_SRC_SEG_3 | \
+ OP_ALG_PKMODE_DST_REG_B | \
+ OP_ALG_PKMODE_DST_SEG_2)
+#define OP_ALG_PKMODE_COPY_NSZ_A3_B3 (OP_ALG_PKMODE_COPY_NSZ | \
+ OP_ALG_PKMODE_SRC_REG_A | \
+ OP_ALG_PKMODE_SRC_SEG_3 | \
+ OP_ALG_PKMODE_DST_REG_B | \
+ OP_ALG_PKMODE_DST_SEG_3)
+
+#define OP_ALG_PKMODE_COPY_NSZ_B0_A0 (OP_ALG_PKMODE_COPY_NSZ | \
+ OP_ALG_PKMODE_SRC_REG_B | \
+ OP_ALG_PKMODE_DST_REG_A)
+#define OP_ALG_PKMODE_COPY_NSZ_B0_A1 (OP_ALG_PKMODE_COPY_NSZ | \
+ OP_ALG_PKMODE_SRC_REG_B | \
+ OP_ALG_PKMODE_DST_REG_A | \
+ OP_ALG_PKMODE_DST_SEG_1)
+#define OP_ALG_PKMODE_COPY_NSZ_B0_A2 (OP_ALG_PKMODE_COPY_NSZ | \
+ OP_ALG_PKMODE_SRC_REG_B | \
+ OP_ALG_PKMODE_DST_REG_A | \
+ OP_ALG_PKMODE_DST_SEG_2)
+#define OP_ALG_PKMODE_COPY_NSZ_B0_A3 (OP_ALG_PKMODE_COPY_NSZ | \
+ OP_ALG_PKMODE_SRC_REG_B | \
+ OP_ALG_PKMODE_DST_REG_A | \
+ OP_ALG_PKMODE_DST_SEG_3)
+
+#define OP_ALG_PKMODE_COPY_NSZ_B1_A0 (OP_ALG_PKMODE_COPY_NSZ | \
+ OP_ALG_PKMODE_SRC_REG_B | \
+ OP_ALG_PKMODE_SRC_SEG_1 | \
+ OP_ALG_PKMODE_DST_REG_A)
+#define OP_ALG_PKMODE_COPY_NSZ_B1_A1 (OP_ALG_PKMODE_COPY_NSZ | \
+ OP_ALG_PKMODE_SRC_REG_B | \
+ OP_ALG_PKMODE_SRC_SEG_1 | \
+ OP_ALG_PKMODE_DST_REG_A | \
+ OP_ALG_PKMODE_DST_SEG_1)
+#define OP_ALG_PKMODE_COPY_NSZ_B1_A2 (OP_ALG_PKMODE_COPY_NSZ | \
+ OP_ALG_PKMODE_SRC_REG_B | \
+ OP_ALG_PKMODE_SRC_SEG_1 | \
+ OP_ALG_PKMODE_DST_REG_A | \
+ OP_ALG_PKMODE_DST_SEG_2)
+#define OP_ALG_PKMODE_COPY_NSZ_B1_A3 (OP_ALG_PKMODE_COPY_NSZ | \
+ OP_ALG_PKMODE_SRC_REG_B | \
+ OP_ALG_PKMODE_SRC_SEG_1 | \
+ OP_ALG_PKMODE_DST_REG_A | \
+ OP_ALG_PKMODE_DST_SEG_3)
+
+#define OP_ALG_PKMODE_COPY_NSZ_B2_A0 (OP_ALG_PKMODE_COPY_NSZ | \
+ OP_ALG_PKMODE_SRC_REG_B | \
+ OP_ALG_PKMODE_SRC_SEG_2 | \
+ OP_ALG_PKMODE_DST_REG_A)
+#define OP_ALG_PKMODE_COPY_NSZ_B2_A1 (OP_ALG_PKMODE_COPY_NSZ | \
+ OP_ALG_PKMODE_SRC_REG_B | \
+ OP_ALG_PKMODE_SRC_SEG_2 | \
+ OP_ALG_PKMODE_DST_REG_A | \
+ OP_ALG_PKMODE_DST_SEG_1)
+#define OP_ALG_PKMODE_COPY_NSZ_B2_A2 (OP_ALG_PKMODE_COPY_NSZ | \
+ OP_ALG_PKMODE_SRC_REG_B | \
+ OP_ALG_PKMODE_SRC_SEG_2 | \
+ OP_ALG_PKMODE_DST_REG_A | \
+ OP_ALG_PKMODE_DST_SEG_2)
+#define OP_ALG_PKMODE_COPY_NSZ_B2_A3 (OP_ALG_PKMODE_COPY_NSZ | \
+ OP_ALG_PKMODE_SRC_REG_B | \
+ OP_ALG_PKMODE_SRC_SEG_2 | \
+ OP_ALG_PKMODE_DST_REG_A | \
+ OP_ALG_PKMODE_DST_SEG_3)
+
+#define OP_ALG_PKMODE_COPY_NSZ_B3_A0 (OP_ALG_PKMODE_COPY_NSZ | \
+ OP_ALG_PKMODE_SRC_REG_B | \
+ OP_ALG_PKMODE_SRC_SEG_3 | \
+ OP_ALG_PKMODE_DST_REG_A)
+#define OP_ALG_PKMODE_COPY_NSZ_B3_A1 (OP_ALG_PKMODE_COPY_NSZ | \
+ OP_ALG_PKMODE_SRC_REG_B | \
+ OP_ALG_PKMODE_SRC_SEG_3 | \
+ OP_ALG_PKMODE_DST_REG_A | \
+ OP_ALG_PKMODE_DST_SEG_1)
+#define OP_ALG_PKMODE_COPY_NSZ_B3_A2 (OP_ALG_PKMODE_COPY_NSZ | \
+ OP_ALG_PKMODE_SRC_REG_B | \
+ OP_ALG_PKMODE_SRC_SEG_3 | \
+ OP_ALG_PKMODE_DST_REG_A | \
+ OP_ALG_PKMODE_DST_SEG_2)
+#define OP_ALG_PKMODE_COPY_NSZ_B3_A3 (OP_ALG_PKMODE_COPY_NSZ | \
+ OP_ALG_PKMODE_SRC_REG_B | \
+ OP_ALG_PKMODE_SRC_SEG_3 | \
+ OP_ALG_PKMODE_DST_REG_A | \
+ OP_ALG_PKMODE_DST_SEG_3)
+
+#define OP_ALG_PKMODE_COPY_NSZ_A_B (OP_ALG_PKMODE_COPY_NSZ | \
+ OP_ALG_PKMODE_SRC_REG_A | \
+ OP_ALG_PKMODE_DST_REG_B)
+#define OP_ALG_PKMODE_COPY_NSZ_A_E (OP_ALG_PKMODE_COPY_NSZ | \
+ OP_ALG_PKMODE_SRC_REG_A | \
+ OP_ALG_PKMODE_DST_REG_E)
+#define OP_ALG_PKMODE_COPY_NSZ_A_N (OP_ALG_PKMODE_COPY_NSZ | \
+ OP_ALG_PKMODE_SRC_REG_A | \
+ OP_ALG_PKMODE_DST_REG_N)
+#define OP_ALG_PKMODE_COPY_NSZ_B_A (OP_ALG_PKMODE_COPY_NSZ | \
+ OP_ALG_PKMODE_SRC_REG_B | \
+ OP_ALG_PKMODE_DST_REG_A)
+#define OP_ALG_PKMODE_COPY_NSZ_B_E (OP_ALG_PKMODE_COPY_NSZ | \
+ OP_ALG_PKMODE_SRC_REG_B | \
+ OP_ALG_PKMODE_DST_REG_E)
+#define OP_ALG_PKMODE_COPY_NSZ_B_N (OP_ALG_PKMODE_COPY_NSZ | \
+ OP_ALG_PKMODE_SRC_REG_B | \
+ OP_ALG_PKMODE_DST_REG_N)
+#define OP_ALG_PKMODE_COPY_NSZ_N_A (OP_ALG_PKMODE_COPY_NSZ | \
+ OP_ALG_PKMODE_SRC_REG_N | \
+ OP_ALG_PKMODE_DST_REG_A)
+#define OP_ALG_PKMODE_COPY_NSZ_N_B (OP_ALG_PKMODE_COPY_NSZ | \
+ OP_ALG_PKMODE_SRC_REG_N | \
+ OP_ALG_PKMODE_DST_REG_B)
+#define OP_ALG_PKMODE_COPY_NSZ_N_E (OP_ALG_PKMODE_COPY_NSZ | \
+ OP_ALG_PKMODE_SRC_REG_N | \
+ OP_ALG_PKMODE_DST_REG_E)
+
+/* PKHA mode copy-memory functions - amount based on SRC SIZE */
+#define OP_ALG_PKMODE_COPY_SSZ 0x11
+#define OP_ALG_PKMODE_COPY_SSZ_A0_B0 (OP_ALG_PKMODE_COPY_SSZ | \
+ OP_ALG_PKMODE_SRC_REG_A | \
+ OP_ALG_PKMODE_DST_REG_B)
+#define OP_ALG_PKMODE_COPY_SSZ_A0_B1 (OP_ALG_PKMODE_COPY_SSZ | \
+ OP_ALG_PKMODE_SRC_REG_A | \
+ OP_ALG_PKMODE_DST_REG_B | \
+ OP_ALG_PKMODE_DST_SEG_1)
+#define OP_ALG_PKMODE_COPY_SSZ_A0_B2 (OP_ALG_PKMODE_COPY_SSZ | \
+ OP_ALG_PKMODE_SRC_REG_A | \
+ OP_ALG_PKMODE_DST_REG_B | \
+ OP_ALG_PKMODE_DST_SEG_2)
+#define OP_ALG_PKMODE_COPY_SSZ_A0_B3 (OP_ALG_PKMODE_COPY_SSZ | \
+ OP_ALG_PKMODE_SRC_REG_A | \
+ OP_ALG_PKMODE_DST_REG_B | \
+ OP_ALG_PKMODE_DST_SEG_3)
+
+#define OP_ALG_PKMODE_COPY_SSZ_A1_B0 (OP_ALG_PKMODE_COPY_SSZ | \
+ OP_ALG_PKMODE_SRC_REG_A | \
+ OP_ALG_PKMODE_SRC_SEG_1 | \
+ OP_ALG_PKMODE_DST_REG_B)
+#define OP_ALG_PKMODE_COPY_SSZ_A1_B1 (OP_ALG_PKMODE_COPY_SSZ | \
+ OP_ALG_PKMODE_SRC_REG_A | \
+ OP_ALG_PKMODE_SRC_SEG_1 | \
+ OP_ALG_PKMODE_DST_REG_B | \
+ OP_ALG_PKMODE_DST_SEG_1)
+#define OP_ALG_PKMODE_COPY_SSZ_A1_B2 (OP_ALG_PKMODE_COPY_SSZ | \
+ OP_ALG_PKMODE_SRC_REG_A | \
+ OP_ALG_PKMODE_SRC_SEG_1 | \
+ OP_ALG_PKMODE_DST_REG_B | \
+ OP_ALG_PKMODE_DST_SEG_2)
+#define OP_ALG_PKMODE_COPY_SSZ_A1_B3 (OP_ALG_PKMODE_COPY_SSZ | \
+ OP_ALG_PKMODE_SRC_REG_A | \
+ OP_ALG_PKMODE_SRC_SEG_1 | \
+ OP_ALG_PKMODE_DST_REG_B | \
+ OP_ALG_PKMODE_DST_SEG_3)
+
+#define OP_ALG_PKMODE_COPY_SSZ_A2_B0 (OP_ALG_PKMODE_COPY_SSZ | \
+ OP_ALG_PKMODE_SRC_REG_A | \
+ OP_ALG_PKMODE_SRC_SEG_2 | \
+ OP_ALG_PKMODE_DST_REG_B)
+#define OP_ALG_PKMODE_COPY_SSZ_A2_B1 (OP_ALG_PKMODE_COPY_SSZ | \
+ OP_ALG_PKMODE_SRC_REG_A | \
+ OP_ALG_PKMODE_SRC_SEG_2 | \
+ OP_ALG_PKMODE_DST_REG_B | \
+ OP_ALG_PKMODE_DST_SEG_1)
+#define OP_ALG_PKMODE_COPY_SSZ_A2_B2 (OP_ALG_PKMODE_COPY_SSZ | \
+ OP_ALG_PKMODE_SRC_REG_A | \
+ OP_ALG_PKMODE_SRC_SEG_2 | \
+ OP_ALG_PKMODE_DST_REG_B | \
+ OP_ALG_PKMODE_DST_SEG_2)
+#define OP_ALG_PKMODE_COPY_SSZ_A2_B3 (OP_ALG_PKMODE_COPY_SSZ | \
+ OP_ALG_PKMODE_SRC_REG_A | \
+ OP_ALG_PKMODE_SRC_SEG_2 | \
+ OP_ALG_PKMODE_DST_REG_B | \
+ OP_ALG_PKMODE_DST_SEG_3)
+
+#define OP_ALG_PKMODE_COPY_SSZ_A3_B0 (OP_ALG_PKMODE_COPY_SSZ | \
+ OP_ALG_PKMODE_SRC_REG_A | \
+ OP_ALG_PKMODE_SRC_SEG_3 | \
+ OP_ALG_PKMODE_DST_REG_B)
+#define OP_ALG_PKMODE_COPY_SSZ_A3_B1 (OP_ALG_PKMODE_COPY_SSZ | \
+ OP_ALG_PKMODE_SRC_REG_A | \
+ OP_ALG_PKMODE_SRC_SEG_3 | \
+ OP_ALG_PKMODE_DST_REG_B | \
+ OP_ALG_PKMODE_DST_SEG_1)
+#define OP_ALG_PKMODE_COPY_SSZ_A3_B2 (OP_ALG_PKMODE_COPY_SSZ | \
+ OP_ALG_PKMODE_SRC_REG_A | \
+ OP_ALG_PKMODE_SRC_SEG_3 | \
+ OP_ALG_PKMODE_DST_REG_B | \
+ OP_ALG_PKMODE_DST_SEG_2)
+#define OP_ALG_PKMODE_COPY_SSZ_A3_B3 (OP_ALG_PKMODE_COPY_SSZ | \
+ OP_ALG_PKMODE_SRC_REG_A | \
+ OP_ALG_PKMODE_SRC_SEG_3 | \
+ OP_ALG_PKMODE_DST_REG_B | \
+ OP_ALG_PKMODE_DST_SEG_3)
+
+#define OP_ALG_PKMODE_COPY_SSZ_B0_A0 (OP_ALG_PKMODE_COPY_SSZ | \
+ OP_ALG_PKMODE_SRC_REG_B | \
+ OP_ALG_PKMODE_DST_REG_A)
+#define OP_ALG_PKMODE_COPY_SSZ_B0_A1 (OP_ALG_PKMODE_COPY_SSZ | \
+ OP_ALG_PKMODE_SRC_REG_B | \
+ OP_ALG_PKMODE_DST_REG_A | \
+ OP_ALG_PKMODE_DST_SEG_1)
+#define OP_ALG_PKMODE_COPY_SSZ_B0_A2 (OP_ALG_PKMODE_COPY_SSZ | \
+ OP_ALG_PKMODE_SRC_REG_B | \
+ OP_ALG_PKMODE_DST_REG_A | \
+ OP_ALG_PKMODE_DST_SEG_2)
+#define OP_ALG_PKMODE_COPY_SSZ_B0_A3 (OP_ALG_PKMODE_COPY_SSZ | \
+ OP_ALG_PKMODE_SRC_REG_B | \
+ OP_ALG_PKMODE_DST_REG_A | \
+ OP_ALG_PKMODE_DST_SEG_3)
+
+#define OP_ALG_PKMODE_COPY_SSZ_B1_A0 (OP_ALG_PKMODE_COPY_SSZ | \
+ OP_ALG_PKMODE_SRC_REG_B | \
+ OP_ALG_PKMODE_SRC_SEG_1 | \
+ OP_ALG_PKMODE_DST_REG_A)
+#define OP_ALG_PKMODE_COPY_SSZ_B1_A1 (OP_ALG_PKMODE_COPY_SSZ | \
+ OP_ALG_PKMODE_SRC_REG_B | \
+ OP_ALG_PKMODE_SRC_SEG_1 | \
+ OP_ALG_PKMODE_DST_REG_A | \
+ OP_ALG_PKMODE_DST_SEG_1)
+#define OP_ALG_PKMODE_COPY_SSZ_B1_A2 (OP_ALG_PKMODE_COPY_SSZ | \
+ OP_ALG_PKMODE_SRC_REG_B | \
+ OP_ALG_PKMODE_SRC_SEG_1 | \
+ OP_ALG_PKMODE_DST_REG_A | \
+ OP_ALG_PKMODE_DST_SEG_2)
+#define OP_ALG_PKMODE_COPY_SSZ_B1_A3 (OP_ALG_PKMODE_COPY_SSZ | \
+ OP_ALG_PKMODE_SRC_REG_B | \
+ OP_ALG_PKMODE_SRC_SEG_1 | \
+ OP_ALG_PKMODE_DST_REG_A | \
+ OP_ALG_PKMODE_DST_SEG_3)
+
+#define OP_ALG_PKMODE_COPY_SSZ_B2_A0 (OP_ALG_PKMODE_COPY_SSZ | \
+ OP_ALG_PKMODE_SRC_REG_B | \
+ OP_ALG_PKMODE_SRC_SEG_2 | \
+ OP_ALG_PKMODE_DST_REG_A)
+#define OP_ALG_PKMODE_COPY_SSZ_B2_A1 (OP_ALG_PKMODE_COPY_SSZ | \
+ OP_ALG_PKMODE_SRC_REG_B | \
+ OP_ALG_PKMODE_SRC_SEG_2 | \
+ OP_ALG_PKMODE_DST_REG_A | \
+ OP_ALG_PKMODE_DST_SEG_1)
+#define OP_ALG_PKMODE_COPY_SSZ_B2_A2 (OP_ALG_PKMODE_COPY_SSZ | \
+ OP_ALG_PKMODE_SRC_REG_B | \
+ OP_ALG_PKMODE_SRC_SEG_2 | \
+ OP_ALG_PKMODE_DST_REG_A | \
+ OP_ALG_PKMODE_DST_SEG_2)
+#define OP_ALG_PKMODE_COPY_SSZ_B2_A3 (OP_ALG_PKMODE_COPY_SSZ | \
+ OP_ALG_PKMODE_SRC_REG_B | \
+ OP_ALG_PKMODE_SRC_SEG_2 | \
+ OP_ALG_PKMODE_DST_REG_A | \
+ OP_ALG_PKMODE_DST_SEG_3)
+
+#define OP_ALG_PKMODE_COPY_SSZ_B3_A0 (OP_ALG_PKMODE_COPY_SSZ | \
+ OP_ALG_PKMODE_SRC_REG_B | \
+ OP_ALG_PKMODE_SRC_SEG_3 | \
+ OP_ALG_PKMODE_DST_REG_A)
+#define OP_ALG_PKMODE_COPY_SSZ_B3_A1 (OP_ALG_PKMODE_COPY_SSZ | \
+ OP_ALG_PKMODE_SRC_REG_B | \
+ OP_ALG_PKMODE_SRC_SEG_3 | \
+ OP_ALG_PKMODE_DST_REG_A | \
+ OP_ALG_PKMODE_DST_SEG_1)
+#define OP_ALG_PKMODE_COPY_SSZ_B3_A2 (OP_ALG_PKMODE_COPY_SSZ | \
+ OP_ALG_PKMODE_SRC_REG_B | \
+ OP_ALG_PKMODE_SRC_SEG_3 | \
+ OP_ALG_PKMODE_DST_REG_A | \
+ OP_ALG_PKMODE_DST_SEG_2)
+#define OP_ALG_PKMODE_COPY_SSZ_B3_A3 (OP_ALG_PKMODE_COPY_SSZ | \
+ OP_ALG_PKMODE_SRC_REG_B | \
+ OP_ALG_PKMODE_SRC_SEG_3 | \
+ OP_ALG_PKMODE_DST_REG_A | \
+ OP_ALG_PKMODE_DST_SEG_3)
+
+#define OP_ALG_PKMODE_COPY_SSZ_A_B (OP_ALG_PKMODE_COPY_SSZ | \
+ OP_ALG_PKMODE_SRC_REG_A | \
+ OP_ALG_PKMODE_DST_REG_B)
+#define OP_ALG_PKMODE_COPY_SSZ_A_E (OP_ALG_PKMODE_COPY_SSZ | \
+ OP_ALG_PKMODE_SRC_REG_A | \
+ OP_ALG_PKMODE_DST_REG_E)
+#define OP_ALG_PKMODE_COPY_SSZ_A_N (OP_ALG_PKMODE_COPY_SSZ | \
+ OP_ALG_PKMODE_SRC_REG_A | \
+ OP_ALG_PKMODE_DST_REG_N)
+#define OP_ALG_PKMODE_COPY_SSZ_B_A (OP_ALG_PKMODE_COPY_SSZ | \
+ OP_ALG_PKMODE_SRC_REG_B | \
+ OP_ALG_PKMODE_DST_REG_A)
+#define OP_ALG_PKMODE_COPY_SSZ_B_E (OP_ALG_PKMODE_COPY_SSZ | \
+ OP_ALG_PKMODE_SRC_REG_B | \
+ OP_ALG_PKMODE_DST_REG_E)
+#define OP_ALG_PKMODE_COPY_SSZ_B_N (OP_ALG_PKMODE_COPY_SSZ | \
+ OP_ALG_PKMODE_SRC_REG_B | \
+ OP_ALG_PKMODE_DST_REG_N)
+#define OP_ALG_PKMODE_COPY_SSZ_N_A (OP_ALG_PKMODE_COPY_SSZ | \
+ OP_ALG_PKMODE_SRC_REG_N | \
+ OP_ALG_PKMODE_DST_REG_A)
+#define OP_ALG_PKMODE_COPY_SSZ_N_B (OP_ALG_PKMODE_COPY_SSZ | \
+ OP_ALG_PKMODE_SRC_REG_N | \
+ OP_ALG_PKMODE_DST_REG_B)
+#define OP_ALG_PKMODE_COPY_SSZ_N_E (OP_ALG_PKMODE_COPY_SSZ | \
+ OP_ALG_PKMODE_SRC_REG_N | \
+ OP_ALG_PKMODE_DST_REG_E)
+
+/*
+ * SEQ_IN_PTR Command Constructs
+ */
+
+/* Release Buffers */
+#define SQIN_RBS BIT(26)
+
+/* Sequence pointer is really a descriptor */
+#define SQIN_INL BIT(25)
+
+/* Sequence pointer is a scatter-gather table */
+#define SQIN_SGF BIT(24)
+
+/* Appends to a previous pointer */
+#define SQIN_PRE BIT(23)
+
+/* Use extended length following pointer */
+#define SQIN_EXT BIT(22)
+
+/* Restore sequence with pointer/length */
+#define SQIN_RTO BIT(21)
+
+/* Replace job descriptor */
+#define SQIN_RJD BIT(20)
+
+/* Sequence Out Pointer - start a new input sequence using output sequence */
+#define SQIN_SOP BIT(19)
+
+#define SQIN_LEN_SHIFT 0
+#define SQIN_LEN_MASK (0xffff << SQIN_LEN_SHIFT)
+
+/*
+ * SEQ_OUT_PTR Command Constructs
+ */
+
+/* Sequence pointer is a scatter-gather table */
+#define SQOUT_SGF BIT(24)
+
+/* Appends to a previous pointer */
+#define SQOUT_PRE BIT(23)
+
+/* Restore sequence with pointer/length */
+#define SQOUT_RTO BIT(21)
+
+/*
+ * Ignore length field, add current output frame length back to SOL register.
+ * Reset tracking length of bytes written to output frame.
+ * Must be used together with SQOUT_RTO.
+ */
+#define SQOUT_RST BIT(20)
+
+/* Allow "write safe" transactions for this Output Sequence */
+#define SQOUT_EWS BIT(19)
+
+/* Use extended length following pointer */
+#define SQOUT_EXT BIT(22)
+
+#define SQOUT_LEN_SHIFT 0
+#define SQOUT_LEN_MASK (0xffff << SQOUT_LEN_SHIFT)
+
+/*
+ * SIGNATURE Command Constructs
+ */
+
+/* TYPE field is all that's relevant */
+#define SIGN_TYPE_SHIFT 16
+#define SIGN_TYPE_MASK (0x0f << SIGN_TYPE_SHIFT)
+
+#define SIGN_TYPE_FINAL (0x00 << SIGN_TYPE_SHIFT)
+#define SIGN_TYPE_FINAL_RESTORE (0x01 << SIGN_TYPE_SHIFT)
+#define SIGN_TYPE_FINAL_NONZERO (0x02 << SIGN_TYPE_SHIFT)
+#define SIGN_TYPE_IMM_2 (0x0a << SIGN_TYPE_SHIFT)
+#define SIGN_TYPE_IMM_3 (0x0b << SIGN_TYPE_SHIFT)
+#define SIGN_TYPE_IMM_4 (0x0c << SIGN_TYPE_SHIFT)
+
+/*
+ * MOVE Command Constructs
+ */
+
+#define MOVE_AUX_SHIFT 25
+#define MOVE_AUX_MASK (3 << MOVE_AUX_SHIFT)
+#define MOVE_AUX_MS (2 << MOVE_AUX_SHIFT)
+#define MOVE_AUX_LS (1 << MOVE_AUX_SHIFT)
+
+#define MOVE_WAITCOMP_SHIFT 24
+#define MOVE_WAITCOMP_MASK (1 << MOVE_WAITCOMP_SHIFT)
+#define MOVE_WAITCOMP BIT(24)
+
+#define MOVE_SRC_SHIFT 20
+#define MOVE_SRC_MASK (0x0f << MOVE_SRC_SHIFT)
+#define MOVE_SRC_CLASS1CTX (0x00 << MOVE_SRC_SHIFT)
+#define MOVE_SRC_CLASS2CTX (0x01 << MOVE_SRC_SHIFT)
+#define MOVE_SRC_OUTFIFO (0x02 << MOVE_SRC_SHIFT)
+#define MOVE_SRC_DESCBUF (0x03 << MOVE_SRC_SHIFT)
+#define MOVE_SRC_MATH0 (0x04 << MOVE_SRC_SHIFT)
+#define MOVE_SRC_MATH1 (0x05 << MOVE_SRC_SHIFT)
+#define MOVE_SRC_MATH2 (0x06 << MOVE_SRC_SHIFT)
+#define MOVE_SRC_MATH3 (0x07 << MOVE_SRC_SHIFT)
+#define MOVE_SRC_INFIFO (0x08 << MOVE_SRC_SHIFT)
+#define MOVE_SRC_INFIFO_CL (0x09 << MOVE_SRC_SHIFT)
+#define MOVE_SRC_INFIFO_NO_NFIFO (0x0a << MOVE_SRC_SHIFT)
+
+#define MOVE_DEST_SHIFT 16
+#define MOVE_DEST_MASK (0x0f << MOVE_DEST_SHIFT)
+#define MOVE_DEST_CLASS1CTX (0x00 << MOVE_DEST_SHIFT)
+#define MOVE_DEST_CLASS2CTX (0x01 << MOVE_DEST_SHIFT)
+#define MOVE_DEST_OUTFIFO (0x02 << MOVE_DEST_SHIFT)
+#define MOVE_DEST_DESCBUF (0x03 << MOVE_DEST_SHIFT)
+#define MOVE_DEST_MATH0 (0x04 << MOVE_DEST_SHIFT)
+#define MOVE_DEST_MATH1 (0x05 << MOVE_DEST_SHIFT)
+#define MOVE_DEST_MATH2 (0x06 << MOVE_DEST_SHIFT)
+#define MOVE_DEST_MATH3 (0x07 << MOVE_DEST_SHIFT)
+#define MOVE_DEST_CLASS1INFIFO (0x08 << MOVE_DEST_SHIFT)
+#define MOVE_DEST_CLASS2INFIFO (0x09 << MOVE_DEST_SHIFT)
+#define MOVE_DEST_INFIFO (0x0a << MOVE_DEST_SHIFT)
+#define MOVE_DEST_PK_A (0x0c << MOVE_DEST_SHIFT)
+#define MOVE_DEST_CLASS1KEY (0x0d << MOVE_DEST_SHIFT)
+#define MOVE_DEST_CLASS2KEY (0x0e << MOVE_DEST_SHIFT)
+#define MOVE_DEST_ALTSOURCE (0x0f << MOVE_DEST_SHIFT)
+
+#define MOVE_OFFSET_SHIFT 8
+#define MOVE_OFFSET_MASK (0xff << MOVE_OFFSET_SHIFT)
+
+#define MOVE_LEN_SHIFT 0
+#define MOVE_LEN_MASK (0xff << MOVE_LEN_SHIFT)
+
+#define MOVELEN_MRSEL_SHIFT 0
+#define MOVELEN_MRSEL_MASK (0x3 << MOVE_LEN_SHIFT)
+#define MOVELEN_MRSEL_MATH0 (0 << MOVELEN_MRSEL_SHIFT)
+#define MOVELEN_MRSEL_MATH1 (1 << MOVELEN_MRSEL_SHIFT)
+#define MOVELEN_MRSEL_MATH2 (2 << MOVELEN_MRSEL_SHIFT)
+#define MOVELEN_MRSEL_MATH3 (3 << MOVELEN_MRSEL_SHIFT)
+
+#define MOVELEN_SIZE_SHIFT 6
+#define MOVELEN_SIZE_MASK (0x3 << MOVELEN_SIZE_SHIFT)
+#define MOVELEN_SIZE_WORD (0x01 << MOVELEN_SIZE_SHIFT)
+#define MOVELEN_SIZE_BYTE (0x02 << MOVELEN_SIZE_SHIFT)
+#define MOVELEN_SIZE_DWORD (0x03 << MOVELEN_SIZE_SHIFT)
+
+/*
+ * MATH Command Constructs
+ */
+
+#define MATH_IFB_SHIFT 26
+#define MATH_IFB_MASK (1 << MATH_IFB_SHIFT)
+#define MATH_IFB BIT(26)
+
+#define MATH_NFU_SHIFT 25
+#define MATH_NFU_MASK (1 << MATH_NFU_SHIFT)
+#define MATH_NFU BIT(25)
+
+/* STL for MATH, SSEL for MATHI */
+#define MATH_STL_SHIFT 24
+#define MATH_STL_MASK (1 << MATH_STL_SHIFT)
+#define MATH_STL BIT(24)
+
+#define MATH_SSEL_SHIFT 24
+#define MATH_SSEL_MASK (1 << MATH_SSEL_SHIFT)
+#define MATH_SSEL BIT(24)
+
+#define MATH_SWP_SHIFT 0
+#define MATH_SWP_MASK (1 << MATH_SWP_SHIFT)
+#define MATH_SWP BIT(0)
+
+/* Function selectors */
+#define MATH_FUN_SHIFT 20
+#define MATH_FUN_MASK (0x0f << MATH_FUN_SHIFT)
+#define MATH_FUN_ADD (0x00 << MATH_FUN_SHIFT)
+#define MATH_FUN_ADDC (0x01 << MATH_FUN_SHIFT)
+#define MATH_FUN_SUB (0x02 << MATH_FUN_SHIFT)
+#define MATH_FUN_SUBB (0x03 << MATH_FUN_SHIFT)
+#define MATH_FUN_OR (0x04 << MATH_FUN_SHIFT)
+#define MATH_FUN_AND (0x05 << MATH_FUN_SHIFT)
+#define MATH_FUN_XOR (0x06 << MATH_FUN_SHIFT)
+#define MATH_FUN_LSHIFT (0x07 << MATH_FUN_SHIFT)
+#define MATH_FUN_RSHIFT (0x08 << MATH_FUN_SHIFT)
+#define MATH_FUN_SHLD (0x09 << MATH_FUN_SHIFT)
+#define MATH_FUN_ZBYT (0x0a << MATH_FUN_SHIFT) /* ZBYT is for MATH */
+#define MATH_FUN_FBYT (0x0a << MATH_FUN_SHIFT) /* FBYT is for MATHI */
+#define MATH_FUN_BSWAP (0x0b << MATH_FUN_SHIFT)
+
+/* Source 0 selectors */
+#define MATH_SRC0_SHIFT 16
+#define MATH_SRC0_MASK (0x0f << MATH_SRC0_SHIFT)
+#define MATH_SRC0_REG0 (0x00 << MATH_SRC0_SHIFT)
+#define MATH_SRC0_REG1 (0x01 << MATH_SRC0_SHIFT)
+#define MATH_SRC0_REG2 (0x02 << MATH_SRC0_SHIFT)
+#define MATH_SRC0_REG3 (0x03 << MATH_SRC0_SHIFT)
+#define MATH_SRC0_IMM (0x04 << MATH_SRC0_SHIFT)
+#define MATH_SRC0_DPOVRD (0x07 << MATH_SRC0_SHIFT)
+#define MATH_SRC0_SEQINLEN (0x08 << MATH_SRC0_SHIFT)
+#define MATH_SRC0_SEQOUTLEN (0x09 << MATH_SRC0_SHIFT)
+#define MATH_SRC0_VARSEQINLEN (0x0a << MATH_SRC0_SHIFT)
+#define MATH_SRC0_VARSEQOUTLEN (0x0b << MATH_SRC0_SHIFT)
+#define MATH_SRC0_ZERO (0x0c << MATH_SRC0_SHIFT)
+#define MATH_SRC0_ONE (0x0f << MATH_SRC0_SHIFT)
+
+/* Source 1 selectors */
+#define MATH_SRC1_SHIFT 12
+#define MATHI_SRC1_SHIFT 16
+#define MATH_SRC1_MASK (0x0f << MATH_SRC1_SHIFT)
+#define MATH_SRC1_REG0 (0x00 << MATH_SRC1_SHIFT)
+#define MATH_SRC1_REG1 (0x01 << MATH_SRC1_SHIFT)
+#define MATH_SRC1_REG2 (0x02 << MATH_SRC1_SHIFT)
+#define MATH_SRC1_REG3 (0x03 << MATH_SRC1_SHIFT)
+#define MATH_SRC1_IMM (0x04 << MATH_SRC1_SHIFT)
+#define MATH_SRC1_DPOVRD (0x07 << MATH_SRC1_SHIFT)
+#define MATH_SRC1_VARSEQINLEN (0x08 << MATH_SRC1_SHIFT)
+#define MATH_SRC1_VARSEQOUTLEN (0x09 << MATH_SRC1_SHIFT)
+#define MATH_SRC1_INFIFO (0x0a << MATH_SRC1_SHIFT)
+#define MATH_SRC1_OUTFIFO (0x0b << MATH_SRC1_SHIFT)
+#define MATH_SRC1_ONE (0x0c << MATH_SRC1_SHIFT)
+#define MATH_SRC1_JOBSOURCE (0x0d << MATH_SRC1_SHIFT)
+#define MATH_SRC1_ZERO (0x0f << MATH_SRC1_SHIFT)
+
+/* Destination selectors */
+#define MATH_DEST_SHIFT 8
+#define MATHI_DEST_SHIFT 12
+#define MATH_DEST_MASK (0x0f << MATH_DEST_SHIFT)
+#define MATH_DEST_REG0 (0x00 << MATH_DEST_SHIFT)
+#define MATH_DEST_REG1 (0x01 << MATH_DEST_SHIFT)
+#define MATH_DEST_REG2 (0x02 << MATH_DEST_SHIFT)
+#define MATH_DEST_REG3 (0x03 << MATH_DEST_SHIFT)
+#define MATH_DEST_DPOVRD (0x07 << MATH_DEST_SHIFT)
+#define MATH_DEST_SEQINLEN (0x08 << MATH_DEST_SHIFT)
+#define MATH_DEST_SEQOUTLEN (0x09 << MATH_DEST_SHIFT)
+#define MATH_DEST_VARSEQINLEN (0x0a << MATH_DEST_SHIFT)
+#define MATH_DEST_VARSEQOUTLEN (0x0b << MATH_DEST_SHIFT)
+#define MATH_DEST_NONE (0x0f << MATH_DEST_SHIFT)
+
+/* MATHI Immediate value */
+#define MATHI_IMM_SHIFT 4
+#define MATHI_IMM_MASK (0xff << MATHI_IMM_SHIFT)
+
+/* Length selectors */
+#define MATH_LEN_SHIFT 0
+#define MATH_LEN_MASK (0x0f << MATH_LEN_SHIFT)
+#define MATH_LEN_1BYTE 0x01
+#define MATH_LEN_2BYTE 0x02
+#define MATH_LEN_4BYTE 0x04
+#define MATH_LEN_8BYTE 0x08
+
+/*
+ * JUMP Command Constructs
+ */
+
+#define JUMP_CLASS_SHIFT 25
+#define JUMP_CLASS_MASK (3 << JUMP_CLASS_SHIFT)
+#define JUMP_CLASS_NONE 0
+#define JUMP_CLASS_CLASS1 (1 << JUMP_CLASS_SHIFT)
+#define JUMP_CLASS_CLASS2 (2 << JUMP_CLASS_SHIFT)
+#define JUMP_CLASS_BOTH (3 << JUMP_CLASS_SHIFT)
+
+#define JUMP_JSL_SHIFT 24
+#define JUMP_JSL_MASK (1 << JUMP_JSL_SHIFT)
+#define JUMP_JSL BIT(24)
+
+#define JUMP_TYPE_SHIFT 20
+#define JUMP_TYPE_MASK (0x0f << JUMP_TYPE_SHIFT)
+#define JUMP_TYPE_LOCAL (0x00 << JUMP_TYPE_SHIFT)
+#define JUMP_TYPE_LOCAL_INC (0x01 << JUMP_TYPE_SHIFT)
+#define JUMP_TYPE_GOSUB (0x02 << JUMP_TYPE_SHIFT)
+#define JUMP_TYPE_LOCAL_DEC (0x03 << JUMP_TYPE_SHIFT)
+#define JUMP_TYPE_NONLOCAL (0x04 << JUMP_TYPE_SHIFT)
+#define JUMP_TYPE_RETURN (0x06 << JUMP_TYPE_SHIFT)
+#define JUMP_TYPE_HALT (0x08 << JUMP_TYPE_SHIFT)
+#define JUMP_TYPE_HALT_USER (0x0c << JUMP_TYPE_SHIFT)
+
+#define JUMP_TEST_SHIFT 16
+#define JUMP_TEST_MASK (0x03 << JUMP_TEST_SHIFT)
+#define JUMP_TEST_ALL (0x00 << JUMP_TEST_SHIFT)
+#define JUMP_TEST_INVALL (0x01 << JUMP_TEST_SHIFT)
+#define JUMP_TEST_ANY (0x02 << JUMP_TEST_SHIFT)
+#define JUMP_TEST_INVANY (0x03 << JUMP_TEST_SHIFT)
+
+/* Condition codes. JSL bit is factored in */
+#define JUMP_COND_SHIFT 8
+#define JUMP_COND_MASK ((0xff << JUMP_COND_SHIFT) | JUMP_JSL)
+#define JUMP_COND_PK_0 BIT(15)
+#define JUMP_COND_PK_GCD_1 BIT(14)
+#define JUMP_COND_PK_PRIME BIT(13)
+#define JUMP_COND_MATH_N BIT(11)
+#define JUMP_COND_MATH_Z BIT(10)
+#define JUMP_COND_MATH_C BIT(9)
+#define JUMP_COND_MATH_NV BIT(8)
+
+#define JUMP_COND_JQP (BIT(15) | JUMP_JSL)
+#define JUMP_COND_SHRD (BIT(14) | JUMP_JSL)
+#define JUMP_COND_SELF (BIT(13) | JUMP_JSL)
+#define JUMP_COND_CALM (BIT(12) | JUMP_JSL)
+#define JUMP_COND_NIP (BIT(11) | JUMP_JSL)
+#define JUMP_COND_NIFP (BIT(10) | JUMP_JSL)
+#define JUMP_COND_NOP (BIT(9) | JUMP_JSL)
+#define JUMP_COND_NCP (BIT(8) | JUMP_JSL)
+
+/* Source / destination selectors */
+#define JUMP_SRC_DST_SHIFT 12
+#define JUMP_SRC_DST_MASK (0x0f << JUMP_SRC_DST_SHIFT)
+#define JUMP_SRC_DST_MATH0 (0x00 << JUMP_SRC_DST_SHIFT)
+#define JUMP_SRC_DST_MATH1 (0x01 << JUMP_SRC_DST_SHIFT)
+#define JUMP_SRC_DST_MATH2 (0x02 << JUMP_SRC_DST_SHIFT)
+#define JUMP_SRC_DST_MATH3 (0x03 << JUMP_SRC_DST_SHIFT)
+#define JUMP_SRC_DST_DPOVRD (0x07 << JUMP_SRC_DST_SHIFT)
+#define JUMP_SRC_DST_SEQINLEN (0x08 << JUMP_SRC_DST_SHIFT)
+#define JUMP_SRC_DST_SEQOUTLEN (0x09 << JUMP_SRC_DST_SHIFT)
+#define JUMP_SRC_DST_VARSEQINLEN (0x0a << JUMP_SRC_DST_SHIFT)
+#define JUMP_SRC_DST_VARSEQOUTLEN (0x0b << JUMP_SRC_DST_SHIFT)
+
+#define JUMP_OFFSET_SHIFT 0
+#define JUMP_OFFSET_MASK (0xff << JUMP_OFFSET_SHIFT)
+
+/*
+ * NFIFO ENTRY
+ * Data Constructs
+ *
+ */
+#define NFIFOENTRY_DEST_SHIFT 30
+#define NFIFOENTRY_DEST_MASK ((uint32_t)(3 << NFIFOENTRY_DEST_SHIFT))
+#define NFIFOENTRY_DEST_DECO (0 << NFIFOENTRY_DEST_SHIFT)
+#define NFIFOENTRY_DEST_CLASS1 (1 << NFIFOENTRY_DEST_SHIFT)
+#define NFIFOENTRY_DEST_CLASS2 ((uint32_t)(2 << NFIFOENTRY_DEST_SHIFT))
+#define NFIFOENTRY_DEST_BOTH ((uint32_t)(3 << NFIFOENTRY_DEST_SHIFT))
+
+#define NFIFOENTRY_LC2_SHIFT 29
+#define NFIFOENTRY_LC2_MASK (1 << NFIFOENTRY_LC2_SHIFT)
+#define NFIFOENTRY_LC2 BIT(29)
+
+#define NFIFOENTRY_LC1_SHIFT 28
+#define NFIFOENTRY_LC1_MASK (1 << NFIFOENTRY_LC1_SHIFT)
+#define NFIFOENTRY_LC1 BIT(28)
+
+#define NFIFOENTRY_FC2_SHIFT 27
+#define NFIFOENTRY_FC2_MASK (1 << NFIFOENTRY_FC2_SHIFT)
+#define NFIFOENTRY_FC2 BIT(27)
+
+#define NFIFOENTRY_FC1_SHIFT 26
+#define NFIFOENTRY_FC1_MASK (1 << NFIFOENTRY_FC1_SHIFT)
+#define NFIFOENTRY_FC1 BIT(26)
+
+#define NFIFOENTRY_STYPE_SHIFT 24
+#define NFIFOENTRY_STYPE_MASK (3 << NFIFOENTRY_STYPE_SHIFT)
+#define NFIFOENTRY_STYPE_DFIFO (0 << NFIFOENTRY_STYPE_SHIFT)
+#define NFIFOENTRY_STYPE_OFIFO (1 << NFIFOENTRY_STYPE_SHIFT)
+#define NFIFOENTRY_STYPE_PAD (2 << NFIFOENTRY_STYPE_SHIFT)
+#define NFIFOENTRY_STYPE_SNOOP (3 << NFIFOENTRY_STYPE_SHIFT)
+#define NFIFOENTRY_STYPE_ALTSOURCE ((0 << NFIFOENTRY_STYPE_SHIFT) \
+ | NFIFOENTRY_AST)
+#define NFIFOENTRY_STYPE_OFIFO_SYNC ((1 << NFIFOENTRY_STYPE_SHIFT) \
+ | NFIFOENTRY_AST)
+#define NFIFOENTRY_STYPE_SNOOP_ALT ((3 << NFIFOENTRY_STYPE_SHIFT) \
+ | NFIFOENTRY_AST)
+
+#define NFIFOENTRY_DTYPE_SHIFT 20
+#define NFIFOENTRY_DTYPE_MASK (0xF << NFIFOENTRY_DTYPE_SHIFT)
+
+#define NFIFOENTRY_DTYPE_SBOX (0x0 << NFIFOENTRY_DTYPE_SHIFT)
+#define NFIFOENTRY_DTYPE_AAD (0x1 << NFIFOENTRY_DTYPE_SHIFT)
+#define NFIFOENTRY_DTYPE_IV (0x2 << NFIFOENTRY_DTYPE_SHIFT)
+#define NFIFOENTRY_DTYPE_SAD (0x3 << NFIFOENTRY_DTYPE_SHIFT)
+#define NFIFOENTRY_DTYPE_ICV (0xA << NFIFOENTRY_DTYPE_SHIFT)
+#define NFIFOENTRY_DTYPE_SKIP (0xE << NFIFOENTRY_DTYPE_SHIFT)
+#define NFIFOENTRY_DTYPE_MSG (0xF << NFIFOENTRY_DTYPE_SHIFT)
+
+#define NFIFOENTRY_DTYPE_PK_A0 (0x0 << NFIFOENTRY_DTYPE_SHIFT)
+#define NFIFOENTRY_DTYPE_PK_A1 (0x1 << NFIFOENTRY_DTYPE_SHIFT)
+#define NFIFOENTRY_DTYPE_PK_A2 (0x2 << NFIFOENTRY_DTYPE_SHIFT)
+#define NFIFOENTRY_DTYPE_PK_A3 (0x3 << NFIFOENTRY_DTYPE_SHIFT)
+#define NFIFOENTRY_DTYPE_PK_B0 (0x4 << NFIFOENTRY_DTYPE_SHIFT)
+#define NFIFOENTRY_DTYPE_PK_B1 (0x5 << NFIFOENTRY_DTYPE_SHIFT)
+#define NFIFOENTRY_DTYPE_PK_B2 (0x6 << NFIFOENTRY_DTYPE_SHIFT)
+#define NFIFOENTRY_DTYPE_PK_B3 (0x7 << NFIFOENTRY_DTYPE_SHIFT)
+#define NFIFOENTRY_DTYPE_PK_N (0x8 << NFIFOENTRY_DTYPE_SHIFT)
+#define NFIFOENTRY_DTYPE_PK_E (0x9 << NFIFOENTRY_DTYPE_SHIFT)
+#define NFIFOENTRY_DTYPE_PK_A (0xC << NFIFOENTRY_DTYPE_SHIFT)
+#define NFIFOENTRY_DTYPE_PK_B (0xD << NFIFOENTRY_DTYPE_SHIFT)
+
+#define NFIFOENTRY_BND_SHIFT 19
+#define NFIFOENTRY_BND_MASK (1 << NFIFOENTRY_BND_SHIFT)
+#define NFIFOENTRY_BND BIT(19)
+
+#define NFIFOENTRY_PTYPE_SHIFT 16
+#define NFIFOENTRY_PTYPE_MASK (0x7 << NFIFOENTRY_PTYPE_SHIFT)
+
+#define NFIFOENTRY_PTYPE_ZEROS (0x0 << NFIFOENTRY_PTYPE_SHIFT)
+#define NFIFOENTRY_PTYPE_RND_NOZEROS (0x1 << NFIFOENTRY_PTYPE_SHIFT)
+#define NFIFOENTRY_PTYPE_INCREMENT (0x2 << NFIFOENTRY_PTYPE_SHIFT)
+#define NFIFOENTRY_PTYPE_RND (0x3 << NFIFOENTRY_PTYPE_SHIFT)
+#define NFIFOENTRY_PTYPE_ZEROS_NZ (0x4 << NFIFOENTRY_PTYPE_SHIFT)
+#define NFIFOENTRY_PTYPE_RND_NZ_LZ (0x5 << NFIFOENTRY_PTYPE_SHIFT)
+#define NFIFOENTRY_PTYPE_N (0x6 << NFIFOENTRY_PTYPE_SHIFT)
+#define NFIFOENTRY_PTYPE_RND_NZ_N (0x7 << NFIFOENTRY_PTYPE_SHIFT)
+
+#define NFIFOENTRY_OC_SHIFT 15
+#define NFIFOENTRY_OC_MASK (1 << NFIFOENTRY_OC_SHIFT)
+#define NFIFOENTRY_OC BIT(15)
+
+#define NFIFOENTRY_PR_SHIFT 15
+#define NFIFOENTRY_PR_MASK (1 << NFIFOENTRY_PR_SHIFT)
+#define NFIFOENTRY_PR BIT(15)
+
+#define NFIFOENTRY_AST_SHIFT 14
+#define NFIFOENTRY_AST_MASK (1 << NFIFOENTRY_AST_SHIFT)
+#define NFIFOENTRY_AST BIT(14)
+
+#define NFIFOENTRY_BM_SHIFT 11
+#define NFIFOENTRY_BM_MASK (1 << NFIFOENTRY_BM_SHIFT)
+#define NFIFOENTRY_BM BIT(11)
+
+#define NFIFOENTRY_PS_SHIFT 10
+#define NFIFOENTRY_PS_MASK (1 << NFIFOENTRY_PS_SHIFT)
+#define NFIFOENTRY_PS BIT(10)
+
+#define NFIFOENTRY_DLEN_SHIFT 0
+#define NFIFOENTRY_DLEN_MASK (0xFFF << NFIFOENTRY_DLEN_SHIFT)
+
+#define NFIFOENTRY_PLEN_SHIFT 0
+#define NFIFOENTRY_PLEN_MASK (0xFF << NFIFOENTRY_PLEN_SHIFT)
+
+/* Append Load Immediate Command */
+#define FD_CMD_APPEND_LOAD_IMMEDIATE BIT(31)
+
+/* Set SEQ LIODN equal to the Non-SEQ LIODN for the job */
+#define FD_CMD_SET_SEQ_LIODN_EQUAL_NONSEQ_LIODN BIT(30)
+
+/* Frame Descriptor Command for Replacement Job Descriptor */
+#define FD_CMD_REPLACE_JOB_DESC BIT(29)
+
+#endif /* __RTA_DESC_H__ */
--- /dev/null
+/* SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0)
+ *
+ * Copyright 2008-2016 Freescale Semiconductor Inc.
+ * Copyright 2016,2019 NXP
+ *
+ */
+
+#ifndef __DESC_ALGO_H__
+#define __DESC_ALGO_H__
+
+#include "rta.h"
+#include "common.h"
+
+/**
+ * DOC: Algorithms - Shared Descriptor Constructors
+ *
+ * Shared descriptors for algorithms (i.e. not for protocols).
+ */
+
+/**
+ * cnstr_shdsc_zuce - ZUC Enc (EEA2) as a shared descriptor
+ * @descbuf: pointer to descriptor-under-construction buffer
+ * @ps: if 36/40bit addressing is desired, this parameter must be true
+ * @swap: must be true when core endianness doesn't match SEC endianness
+ * @cipherdata: pointer to block cipher transform definitions
+ * @dir: Cipher direction (DIR_ENC/DIR_DEC)
+ *
+ * Return: size of descriptor written in words or negative number on error
+ */
+static inline int
+cnstr_shdsc_zuce(uint32_t *descbuf, bool ps, bool swap,
+ struct alginfo *cipherdata, uint8_t dir)
+{
+ struct program prg;
+ struct program *p = &prg;
+
+ PROGRAM_CNTXT_INIT(p, descbuf, 0);
+ if (swap)
+ PROGRAM_SET_BSWAP(p);
+
+ if (ps)
+ PROGRAM_SET_36BIT_ADDR(p);
+ SHR_HDR(p, SHR_ALWAYS, 1, 0);
+
+ KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
+ cipherdata->keylen, INLINE_KEY(cipherdata));
+
+ SEQLOAD(p, CONTEXT1, 0, 16, 0);
+
+ MATHB(p, SEQINSZ, SUB, MATH2, VSEQINSZ, 4, 0);
+ MATHB(p, SEQINSZ, SUB, MATH2, VSEQOUTSZ, 4, 0);
+ ALG_OPERATION(p, OP_ALG_ALGSEL_ZUCE, OP_ALG_AAI_F8,
+ OP_ALG_AS_INITFINAL, 0, dir);
+ SEQFIFOLOAD(p, MSG1, 0, VLF | LAST1);
+ SEQFIFOSTORE(p, MSG, 0, 0, VLF);
+
+ return PROGRAM_FINALIZE(p);
+}
+
+/**
+ * cnstr_shdsc_zuca - ZUC Auth (EIA2) as a shared descriptor
+ * @descbuf: pointer to descriptor-under-construction buffer
+ * @ps: if 36/40bit addressing is desired, this parameter must be true
+ * @swap: must be true when core endianness doesn't match SEC endianness
+ * @authdata: pointer to authentication transform definitions
+ * @chk_icv: Whether to compare and verify ICV (true/false)
+ * @authlen: size of digest
+ *
+ * The IV prepended before hmac payload must be 8 bytes consisting
+ * of COUNT||BEAERER||DIR. The COUNT is of 32-bits, bearer is of 5 bits and
+ * direction is of 1 bit - totalling to 38 bits.
+ *
+ * Return: size of descriptor written in words or negative number on error
+ */
+static inline int
+cnstr_shdsc_zuca(uint32_t *descbuf, bool ps, bool swap,
+ struct alginfo *authdata, uint8_t chk_icv,
+ uint32_t authlen)
+{
+ struct program prg;
+ struct program *p = &prg;
+ int dir = chk_icv ? DIR_DEC : DIR_ENC;
+
+ PROGRAM_CNTXT_INIT(p, descbuf, 0);
+ if (swap)
+ PROGRAM_SET_BSWAP(p);
+
+ if (ps)
+ PROGRAM_SET_36BIT_ADDR(p);
+ SHR_HDR(p, SHR_ALWAYS, 1, 0);
+
+ KEY(p, KEY2, authdata->key_enc_flags, authdata->key,
+ authdata->keylen, INLINE_KEY(authdata));
+
+ SEQLOAD(p, CONTEXT2, 0, 8, 0);
+
+ if (chk_icv == ICV_CHECK_ENABLE)
+ MATHB(p, SEQINSZ, SUB, authlen, VSEQINSZ, 4, IMMED2);
+ else
+ MATHB(p, SEQINSZ, SUB, ZERO, VSEQINSZ, 4, 0);
+
+ ALG_OPERATION(p, OP_ALG_ALGSEL_ZUCA, OP_ALG_AAI_F9,
+ OP_ALG_AS_INITFINAL, chk_icv, dir);
+
+ SEQFIFOLOAD(p, MSG2, 0, VLF | CLASS2 | LAST2);
+
+ if (chk_icv == ICV_CHECK_ENABLE)
+ SEQFIFOLOAD(p, ICV2, authlen, LAST2);
+ else
+ /* Save lower half of MAC out into a 32-bit sequence */
+ SEQSTORE(p, CONTEXT2, 0, authlen, 0);
+
+ return PROGRAM_FINALIZE(p);
+}
+
+
+/**
+ * cnstr_shdsc_snow_f8 - SNOW/f8 (UEA2) as a shared descriptor
+ * @descbuf: pointer to descriptor-under-construction buffer
+ * @ps: if 36/40bit addressing is desired, this parameter must be true
+ * @swap: must be true when core endianness doesn't match SEC endianness
+ * @cipherdata: pointer to block cipher transform definitions
+ * @dir: Cipher direction (DIR_ENC/DIR_DEC)
+ *
+ * Return: size of descriptor written in words or negative number on error
+ */
+static inline int
+cnstr_shdsc_snow_f8(uint32_t *descbuf, bool ps, bool swap,
+ struct alginfo *cipherdata, uint8_t dir)
+{
+ struct program prg;
+ struct program *p = &prg;
+
+ PROGRAM_CNTXT_INIT(p, descbuf, 0);
+ if (swap)
+ PROGRAM_SET_BSWAP(p);
+
+ if (ps)
+ PROGRAM_SET_36BIT_ADDR(p);
+ SHR_HDR(p, SHR_ALWAYS, 1, 0);
+
+ KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
+ cipherdata->keylen, INLINE_KEY(cipherdata));
+
+ SEQLOAD(p, CONTEXT1, 0, 16, 0);
+
+ MATHB(p, SEQINSZ, SUB, MATH2, VSEQINSZ, 4, 0);
+ MATHB(p, SEQINSZ, SUB, MATH2, VSEQOUTSZ, 4, 0);
+ ALG_OPERATION(p, OP_ALG_ALGSEL_SNOW_F8, OP_ALG_AAI_F8,
+ OP_ALG_AS_INITFINAL, 0, dir);
+ SEQFIFOLOAD(p, MSG1, 0, VLF | LAST1);
+ SEQFIFOSTORE(p, MSG, 0, 0, VLF);
+
+ return PROGRAM_FINALIZE(p);
+}
+
+/**
+ * conv_to_zuc_eia_iv - ZUCA IV 16-byte to 8-byte convert
+ * function for 3G.
+ * @iv: 16 bytes of original IV data.
+ *
+ * From the original IV, we extract 32-bits of COUNT,
+ * 5-bits of bearer and 1-bit of direction.
+ * Refer to CAAM refman for ZUCA IV format. Then these values are
+ * appended as COUNT||BEARER||DIR continuously to make a 38-bit block.
+ * This 38-bit block is copied left justified into 8-byte array used as
+ * converted IV.
+ *
+ * Return: 8-bytes of IV data as understood by SEC HW
+ */
+
+static inline uint8_t *conv_to_zuc_eia_iv(uint8_t *iv)
+{
+ uint8_t dir = (iv[14] & 0x80) ? 4 : 0;
+
+ iv[12] = iv[4] | dir;
+ iv[13] = 0;
+ iv[14] = 0;
+ iv[15] = 0;
+
+ iv[8] = iv[0];
+ iv[9] = iv[1];
+ iv[10] = iv[2];
+ iv[11] = iv[3];
+
+ return (iv + 8);
+}
+
+/**
+ * conv_to_snow_f9_iv - SNOW/f9 (UIA2) IV 16 byte to 12 byte convert
+ * function for 3G.
+ * @iv: 16 byte original IV data
+ *
+ * Return: 12 byte IV data as understood by SEC HW
+ */
+
+static inline uint8_t *conv_to_snow_f9_iv(uint8_t *iv)
+{
+ uint8_t temp = (iv[8] == iv[0]) ? 0 : 4;
+
+ iv[12] = iv[4];
+ iv[13] = iv[5];
+ iv[14] = iv[6];
+ iv[15] = iv[7];
+
+ iv[8] = temp;
+ iv[9] = 0x00;
+ iv[10] = 0x00;
+ iv[11] = 0x00;
+
+ iv[4] = iv[0];
+ iv[5] = iv[1];
+ iv[6] = iv[2];
+ iv[7] = iv[3];
+
+ return (iv + 4);
+}
+
+/**
+ * cnstr_shdsc_snow_f9 - SNOW/f9 (UIA2) as a shared descriptor
+ * @descbuf: pointer to descriptor-under-construction buffer
+ * @ps: if 36/40bit addressing is desired, this parameter must be true
+ * @swap: must be true when core endianness doesn't match SEC endianness
+ * @authdata: pointer to authentication transform definitions
+ * @chk_icv: check or generate ICV value
+ * @authlen: size of digest
+ *
+ * Return: size of descriptor written in words or negative number on error
+ */
+static inline int
+cnstr_shdsc_snow_f9(uint32_t *descbuf, bool ps, bool swap,
+ struct alginfo *authdata, uint8_t chk_icv,
+ uint32_t authlen)
+{
+ struct program prg;
+ struct program *p = &prg;
+ int dir = chk_icv ? DIR_DEC : DIR_ENC;
+
+ PROGRAM_CNTXT_INIT(p, descbuf, 0);
+ if (swap)
+ PROGRAM_SET_BSWAP(p);
+
+ if (ps)
+ PROGRAM_SET_36BIT_ADDR(p);
+
+ SHR_HDR(p, SHR_ALWAYS, 1, 0);
+
+ KEY(p, KEY2, authdata->key_enc_flags, authdata->key,
+ authdata->keylen, INLINE_KEY(authdata));
+
+ SEQLOAD(p, CONTEXT2, 0, 12, 0);
+
+ if (chk_icv == ICV_CHECK_ENABLE)
+ MATHB(p, SEQINSZ, SUB, authlen, VSEQINSZ, 4, IMMED2);
+ else
+ MATHB(p, SEQINSZ, SUB, ZERO, VSEQINSZ, 4, 0);
+
+ ALG_OPERATION(p, OP_ALG_ALGSEL_SNOW_F9, OP_ALG_AAI_F9,
+ OP_ALG_AS_INITFINAL, chk_icv, dir);
+
+ SEQFIFOLOAD(p, MSG2, 0, VLF | CLASS2 | LAST2);
+
+ if (chk_icv == ICV_CHECK_ENABLE)
+ SEQFIFOLOAD(p, ICV2, authlen, LAST2);
+ else
+ /* Save lower half of MAC out into a 32-bit sequence */
+ SEQSTORE(p, CONTEXT2, 0, authlen, 0);
+
+ return PROGRAM_FINALIZE(p);
+}
+
+/**
+ * cnstr_shdsc_blkcipher - block cipher transformation
+ * @descbuf: pointer to descriptor-under-construction buffer
+ * @ps: if 36/40bit addressing is desired, this parameter must be true
+ * @swap: must be true when core endianness doesn't match SEC endianness
+ * @share: sharing type of shared descriptor
+ * @cipherdata: pointer to block cipher transform definitions
+ * Valid algorithm values one of OP_ALG_ALGSEL_* {DES, 3DES, AES}
+ * Valid modes for:
+ * AES: OP_ALG_AAI_* {CBC, CTR}
+ * DES, 3DES: OP_ALG_AAI_CBC
+ * @iv: IV data; if NULL, "ivlen" bytes from the input frame will be read as IV
+ * @ivlen: IV length
+ * @dir: DIR_ENC/DIR_DEC
+ *
+ * Return: size of descriptor written in words or negative number on error
+ */
+static inline int
+cnstr_shdsc_blkcipher(uint32_t *descbuf, bool ps, bool swap,
+ enum rta_share_type share,
+ struct alginfo *cipherdata, uint8_t *iv,
+ uint32_t ivlen, uint8_t dir)
+{
+ struct program prg;
+ struct program *p = &prg;
+ uint32_t iv_off = 0;
+ const bool need_dk = (dir == DIR_DEC) &&
+ (cipherdata->algtype == OP_ALG_ALGSEL_AES) &&
+ (cipherdata->algmode == OP_ALG_AAI_CBC);
+ LABEL(keyjmp);
+ LABEL(skipdk);
+ REFERENCE(pkeyjmp);
+ REFERENCE(pskipdk);
+
+ PROGRAM_CNTXT_INIT(p, descbuf, 0);
+ if (swap)
+ PROGRAM_SET_BSWAP(p);
+ if (ps)
+ PROGRAM_SET_36BIT_ADDR(p);
+ SHR_HDR(p, share, 1, SC);
+
+ pkeyjmp = JUMP(p, keyjmp, LOCAL_JUMP, ALL_TRUE, SHRD);
+ /* Insert Key */
+ KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
+ cipherdata->keylen, INLINE_KEY(cipherdata));
+
+ if (need_dk) {
+ ALG_OPERATION(p, cipherdata->algtype, cipherdata->algmode,
+ OP_ALG_AS_INITFINAL, ICV_CHECK_DISABLE, dir);
+
+ pskipdk = JUMP(p, skipdk, LOCAL_JUMP, ALL_TRUE, 0);
+ }
+ SET_LABEL(p, keyjmp);
+
+ if (need_dk) {
+ ALG_OPERATION(p, OP_ALG_ALGSEL_AES, cipherdata->algmode |
+ OP_ALG_AAI_DK, OP_ALG_AS_INITFINAL,
+ ICV_CHECK_DISABLE, dir);
+ SET_LABEL(p, skipdk);
+ } else {
+ ALG_OPERATION(p, cipherdata->algtype, cipherdata->algmode,
+ OP_ALG_AS_INITFINAL, ICV_CHECK_DISABLE, dir);
+ }
+
+ if (cipherdata->algmode == OP_ALG_AAI_CTR)
+ iv_off = 16;
+
+ if (iv)
+ /* IV load, convert size */
+ LOAD(p, (uintptr_t)iv, CONTEXT1, iv_off, ivlen, IMMED | COPY);
+ else
+ /* IV is present first before the actual message */
+ SEQLOAD(p, CONTEXT1, iv_off, ivlen, 0);
+
+ MATHB(p, SEQINSZ, SUB, MATH2, VSEQINSZ, 4, 0);
+ MATHB(p, SEQINSZ, SUB, MATH2, VSEQOUTSZ, 4, 0);
+
+ /* Insert sequence load/store with VLF */
+ SEQFIFOLOAD(p, MSG1, 0, VLF | LAST1);
+ SEQFIFOSTORE(p, MSG, 0, 0, VLF);
+
+ PATCH_JUMP(p, pkeyjmp, keyjmp);
+ if (need_dk)
+ PATCH_JUMP(p, pskipdk, skipdk);
+
+ return PROGRAM_FINALIZE(p);
+}
+
+/**
+ * cnstr_shdsc_hmac - HMAC shared
+ * @descbuf: pointer to descriptor-under-construction buffer
+ * @ps: if 36/40bit addressing is desired, this parameter must be true
+ * @swap: must be true when core endianness doesn't match SEC endianness
+ * @share: sharing type of shared descriptor
+ * @authdata: pointer to authentication transform definitions;
+ * message digest algorithm: OP_ALG_ALGSEL_MD5/ SHA1-512.
+ * @do_icv: 0 if ICV checking is not desired, any other value if ICV checking
+ * is needed for all the packets processed by this shared descriptor
+ * @trunc_len: Length of the truncated ICV to be written in the output buffer, 0
+ * if no truncation is needed
+ *
+ * Note: There's no support for keys longer than the block size of the
+ * underlying hash function, according to the selected algorithm.
+ *
+ * Return: size of descriptor written in words or negative number on error
+ */
+static inline int
+cnstr_shdsc_hmac(uint32_t *descbuf, bool ps, bool swap,
+ enum rta_share_type share,
+ struct alginfo *authdata, uint8_t do_icv,
+ uint8_t trunc_len)
+{
+ struct program prg;
+ struct program *p = &prg;
+ uint8_t storelen, opicv, dir;
+ LABEL(keyjmp);
+ LABEL(jmpprecomp);
+ REFERENCE(pkeyjmp);
+ REFERENCE(pjmpprecomp);
+
+ /* Compute fixed-size store based on alg selection */
+ switch (authdata->algtype) {
+ case OP_ALG_ALGSEL_MD5:
+ storelen = 16;
+ break;
+ case OP_ALG_ALGSEL_SHA1:
+ storelen = 20;
+ break;
+ case OP_ALG_ALGSEL_SHA224:
+ storelen = 28;
+ break;
+ case OP_ALG_ALGSEL_SHA256:
+ storelen = 32;
+ break;
+ case OP_ALG_ALGSEL_SHA384:
+ storelen = 48;
+ break;
+ case OP_ALG_ALGSEL_SHA512:
+ storelen = 64;
+ break;
+ default:
+ return -EINVAL;
+ }
+
+ trunc_len = trunc_len && (trunc_len < storelen) ? trunc_len : storelen;
+
+ opicv = do_icv ? ICV_CHECK_ENABLE : ICV_CHECK_DISABLE;
+ dir = do_icv ? DIR_DEC : DIR_ENC;
+
+ PROGRAM_CNTXT_INIT(p, descbuf, 0);
+ if (swap)
+ PROGRAM_SET_BSWAP(p);
+ if (ps)
+ PROGRAM_SET_36BIT_ADDR(p);
+ SHR_HDR(p, share, 1, SC);
+
+ pkeyjmp = JUMP(p, keyjmp, LOCAL_JUMP, ALL_TRUE, SHRD);
+ KEY(p, KEY2, authdata->key_enc_flags, authdata->key, authdata->keylen,
+ INLINE_KEY(authdata));
+
+ /* Do operation */
+ ALG_OPERATION(p, authdata->algtype, OP_ALG_AAI_HMAC,
+ OP_ALG_AS_INITFINAL, opicv, dir);
+
+ pjmpprecomp = JUMP(p, jmpprecomp, LOCAL_JUMP, ALL_TRUE, 0);
+ SET_LABEL(p, keyjmp);
+
+ ALG_OPERATION(p, authdata->algtype, OP_ALG_AAI_HMAC_PRECOMP,
+ OP_ALG_AS_INITFINAL, opicv, dir);
+
+ SET_LABEL(p, jmpprecomp);
+
+ /* compute sequences */
+ if (opicv == ICV_CHECK_ENABLE)
+ MATHB(p, SEQINSZ, SUB, trunc_len, VSEQINSZ, 4, IMMED2);
+ else
+ MATHB(p, SEQINSZ, SUB, MATH2, VSEQINSZ, 4, 0);
+
+ /* Do load (variable length) */
+ SEQFIFOLOAD(p, MSG2, 0, VLF | LAST2);
+
+ if (opicv == ICV_CHECK_ENABLE)
+ SEQFIFOLOAD(p, ICV2, trunc_len, LAST2);
+ else
+ SEQSTORE(p, CONTEXT2, 0, trunc_len, 0);
+
+ PATCH_JUMP(p, pkeyjmp, keyjmp);
+ PATCH_JUMP(p, pjmpprecomp, jmpprecomp);
+
+ return PROGRAM_FINALIZE(p);
+}
+
+/**
+ * cnstr_shdsc_kasumi_f8 - KASUMI F8 (Confidentiality) as a shared descriptor
+ * (ETSI "Document 1: f8 and f9 specification")
+ * @descbuf: pointer to descriptor-under-construction buffer
+ * @ps: if 36/40bit addressing is desired, this parameter must be true
+ * @swap: must be true when core endianness doesn't match SEC endianness
+ * @cipherdata: pointer to block cipher transform definitions
+ * @dir: cipher direction (DIR_ENC/DIR_DEC)
+ * @count: count value (32 bits)
+ * @bearer: bearer ID (5 bits)
+ * @direction: direction (1 bit)
+ *
+ * Return: size of descriptor written in words or negative number on error
+ */
+static inline int
+cnstr_shdsc_kasumi_f8(uint32_t *descbuf, bool ps, bool swap,
+ struct alginfo *cipherdata, uint8_t dir)
+{
+ struct program prg;
+ struct program *p = &prg;
+
+ PROGRAM_CNTXT_INIT(p, descbuf, 0);
+ if (swap)
+ PROGRAM_SET_BSWAP(p);
+ if (ps)
+ PROGRAM_SET_36BIT_ADDR(p);
+ SHR_HDR(p, SHR_ALWAYS, 1, 0);
+
+ KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
+ cipherdata->keylen, INLINE_KEY(cipherdata));
+ SEQLOAD(p, CONTEXT1, 0, 8, 0);
+ MATHB(p, SEQINSZ, SUB, MATH2, VSEQINSZ, 4, 0);
+ MATHB(p, SEQINSZ, SUB, MATH2, VSEQOUTSZ, 4, 0);
+ ALG_OPERATION(p, OP_ALG_ALGSEL_KASUMI, OP_ALG_AAI_F8,
+ OP_ALG_AS_INITFINAL, 0, dir);
+ SEQFIFOLOAD(p, MSG1, 0, VLF | LAST1);
+ SEQFIFOSTORE(p, MSG, 0, 0, VLF);
+
+ return PROGRAM_FINALIZE(p);
+}
+
+/**
+ * cnstr_shdsc_kasumi_f9 - KASUMI F9 (Integrity) as a shared descriptor
+ * (ETSI "Document 1: f8 and f9 specification")
+ * @descbuf: pointer to descriptor-under-construction buffer
+ * @ps: if 36/40bit addressing is desired, this parameter must be true
+ * @swap: must be true when core endianness doesn't match SEC endianness
+ * @authdata: pointer to authentication transform definitions
+ * @chk_icv: check or generate ICV value
+ * @authlen: size of digest
+ *
+ * Return: size of descriptor written in words or negative number on error
+ */
+static inline int
+cnstr_shdsc_kasumi_f9(uint32_t *descbuf, bool ps, bool swap,
+ struct alginfo *authdata, uint8_t chk_icv,
+ uint32_t authlen)
+{
+ struct program prg;
+ struct program *p = &prg;
+ int dir = chk_icv ? DIR_DEC : DIR_ENC;
+
+ PROGRAM_CNTXT_INIT(p, descbuf, 0);
+ if (swap)
+ PROGRAM_SET_BSWAP(p);
+
+ if (ps)
+ PROGRAM_SET_36BIT_ADDR(p);
+
+ SHR_HDR(p, SHR_ALWAYS, 1, 0);
+
+ KEY(p, KEY2, authdata->key_enc_flags, authdata->key,
+ authdata->keylen, INLINE_KEY(authdata));
+
+ SEQLOAD(p, CONTEXT2, 0, 12, 0);
+
+ if (chk_icv == ICV_CHECK_ENABLE)
+ MATHB(p, SEQINSZ, SUB, authlen, VSEQINSZ, 4, IMMED2);
+ else
+ MATHB(p, SEQINSZ, SUB, ZERO, VSEQINSZ, 4, 0);
+
+ ALG_OPERATION(p, OP_ALG_ALGSEL_KASUMI, OP_ALG_AAI_F9,
+ OP_ALG_AS_INITFINAL, chk_icv, dir);
+
+ SEQFIFOLOAD(p, MSG2, 0, VLF | CLASS2 | LAST2);
+
+ if (chk_icv == ICV_CHECK_ENABLE)
+ SEQFIFOLOAD(p, ICV2, authlen, LAST2);
+ else
+ /* Save lower half of MAC out into a 32-bit sequence */
+ SEQSTORE(p, CONTEXT2, 0, authlen, 0);
+
+ return PROGRAM_FINALIZE(p);
+}
+
+/**
+ * cnstr_shdsc_crc - CRC32 Accelerator (IEEE 802 CRC32 protocol mode)
+ * @descbuf: pointer to descriptor-under-construction buffer
+ * @swap: must be true when core endianness doesn't match SEC endianness
+ *
+ * Return: size of descriptor written in words or negative number on error
+ */
+static inline int
+cnstr_shdsc_crc(uint32_t *descbuf, bool swap)
+{
+ struct program prg;
+ struct program *p = &prg;
+
+ PROGRAM_CNTXT_INIT(p, descbuf, 0);
+ if (swap)
+ PROGRAM_SET_BSWAP(p);
+
+ SHR_HDR(p, SHR_ALWAYS, 1, 0);
+
+ MATHB(p, SEQINSZ, SUB, MATH2, VSEQINSZ, 4, 0);
+ ALG_OPERATION(p, OP_ALG_ALGSEL_CRC,
+ OP_ALG_AAI_802 | OP_ALG_AAI_DOC,
+ OP_ALG_AS_FINALIZE, 0, DIR_ENC);
+ SEQFIFOLOAD(p, MSG2, 0, VLF | LAST2);
+ SEQSTORE(p, CONTEXT2, 0, 4, 0);
+
+ return PROGRAM_FINALIZE(p);
+}
+
+/**
+ * cnstr_shdsc_gcm_encap - AES-GCM encap as a shared descriptor
+ * @descbuf: pointer to descriptor-under-construction buffer
+ * @ps: if 36/40bit addressing is desired, this parameter must be true
+ * @swap: must be true when core endianness doesn't match SEC endianness
+ * @share: sharing type of shared descriptor
+ * @cipherdata: pointer to block cipher transform definitions
+ * Valid algorithm values - OP_ALG_ALGSEL_AES ANDed with
+ * OP_ALG_AAI_GCM.
+ * @ivlen: Initialization vector length
+ * @icvsize: integrity check value (ICV) size (truncated or full)
+ *
+ * Return: size of descriptor written in words or negative number on error
+ */
+static inline int
+cnstr_shdsc_gcm_encap(uint32_t *descbuf, bool ps, bool swap,
+ enum rta_share_type share,
+ struct alginfo *cipherdata,
+ uint32_t ivlen, uint32_t icvsize)
+{
+ struct program prg;
+ struct program *p = &prg;
+
+ LABEL(keyjmp);
+ LABEL(zeroassocjump2);
+ LABEL(zeroassocjump1);
+ LABEL(zeropayloadjump);
+ REFERENCE(pkeyjmp);
+ REFERENCE(pzeroassocjump2);
+ REFERENCE(pzeroassocjump1);
+ REFERENCE(pzeropayloadjump);
+
+ PROGRAM_CNTXT_INIT(p, descbuf, 0);
+
+ if (swap)
+ PROGRAM_SET_BSWAP(p);
+ if (ps)
+ PROGRAM_SET_36BIT_ADDR(p);
+
+ SHR_HDR(p, share, 1, SC);
+
+ pkeyjmp = JUMP(p, keyjmp, LOCAL_JUMP, ALL_TRUE, SELF | SHRD);
+ /* Insert Key */
+ KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
+ cipherdata->keylen, INLINE_KEY(cipherdata));
+
+ SET_LABEL(p, keyjmp);
+
+ /* class 1 operation */
+ ALG_OPERATION(p, cipherdata->algtype, cipherdata->algmode,
+ OP_ALG_AS_INITFINAL, ICV_CHECK_DISABLE, DIR_ENC);
+
+ MATHB(p, DPOVRD, AND, 0x7fffffff, MATH3, 4, IMMED2);
+
+ /* if assoclen + cryptlen is ZERO, skip to ICV write */
+ MATHB(p, SEQINSZ, SUB, ivlen, VSEQOUTSZ, 4, IMMED2);
+ pzeroassocjump2 = JUMP(p, zeroassocjump2, LOCAL_JUMP, ALL_TRUE, MATH_Z);
+
+ SEQFIFOLOAD(p, IV1, ivlen, FLUSH1);
+
+ /* if assoclen is ZERO, skip reading the assoc data */
+ MATHB(p, ZERO, ADD, MATH3, VSEQINSZ, 4, 0);
+ pzeroassocjump1 = JUMP(p, zeroassocjump1, LOCAL_JUMP, ALL_TRUE, MATH_Z);
+
+ /* cryptlen = seqinlen - assoclen */
+ MATHB(p, SEQINSZ, SUB, MATH3, VSEQOUTSZ, 4, 0);
+
+ /* if cryptlen is ZERO jump to zero-payload commands */
+ pzeropayloadjump = JUMP(p, zeropayloadjump, LOCAL_JUMP, ALL_TRUE,
+ MATH_Z);
+
+ /* read assoc data */
+ SEQFIFOLOAD(p, AAD1, 0, CLASS1 | VLF | FLUSH1);
+ SET_LABEL(p, zeroassocjump1);
+
+ MATHB(p, SEQINSZ, SUB, MATH0, VSEQINSZ, 4, 0);
+
+ /* write encrypted data */
+ SEQFIFOSTORE(p, MSG, 0, 0, VLF);
+
+ /* read payload data */
+ SEQFIFOLOAD(p, MSG1, 0, CLASS1 | VLF | LAST1);
+
+ /* jump the zero-payload commands */
+ JUMP(p, 4, LOCAL_JUMP, ALL_TRUE, 0);
+
+ /* zero-payload commands */
+ SET_LABEL(p, zeropayloadjump);
+
+ /* read assoc data */
+ SEQFIFOLOAD(p, AAD1, 0, CLASS1 | VLF | LAST1);
+
+ JUMP(p, 2, LOCAL_JUMP, ALL_TRUE, 0);
+
+ /* There is no input data */
+ SET_LABEL(p, zeroassocjump2);
+
+ SEQFIFOLOAD(p, IV1, ivlen, FLUSH1 | LAST1);
+
+ /* write ICV */
+ SEQSTORE(p, CONTEXT1, 0, icvsize, 0);
+
+ PATCH_JUMP(p, pkeyjmp, keyjmp);
+ PATCH_JUMP(p, pzeroassocjump2, zeroassocjump2);
+ PATCH_JUMP(p, pzeroassocjump1, zeroassocjump1);
+ PATCH_JUMP(p, pzeropayloadjump, zeropayloadjump);
+
+ return PROGRAM_FINALIZE(p);
+}
+
+/**
+ * cnstr_shdsc_gcm_decap - AES-GCM decap as a shared descriptor
+ * @descbuf: pointer to descriptor-under-construction buffer
+ * @ps: if 36/40bit addressing is desired, this parameter must be true
+ * @swap: must be true when core endianness doesn't match SEC endianness
+ * @share: sharing type of shared descriptor
+ * @cipherdata: pointer to block cipher transform definitions
+ * Valid algorithm values - OP_ALG_ALGSEL_AES ANDed with
+ * OP_ALG_AAI_GCM.
+ * @icvsize: integrity check value (ICV) size (truncated or full)
+ *
+ * Return: size of descriptor written in words or negative number on error
+ */
+static inline int
+cnstr_shdsc_gcm_decap(uint32_t *descbuf, bool ps, bool swap,
+ enum rta_share_type share,
+ struct alginfo *cipherdata,
+ uint32_t ivlen, uint32_t icvsize)
+{
+ struct program prg;
+ struct program *p = &prg;
+
+ LABEL(keyjmp);
+ LABEL(zeroassocjump1);
+ LABEL(zeropayloadjump);
+ REFERENCE(pkeyjmp);
+ REFERENCE(pzeroassocjump1);
+ REFERENCE(pzeropayloadjump);
+
+ PROGRAM_CNTXT_INIT(p, descbuf, 0);
+
+ if (swap)
+ PROGRAM_SET_BSWAP(p);
+ if (ps)
+ PROGRAM_SET_36BIT_ADDR(p);
+
+ SHR_HDR(p, share, 1, SC);
+
+ pkeyjmp = JUMP(p, keyjmp, LOCAL_JUMP, ALL_TRUE, SELF | SHRD);
+ /* Insert Key */
+ KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
+ cipherdata->keylen, INLINE_KEY(cipherdata));
+
+ SET_LABEL(p, keyjmp);
+
+ /* class 1 operation */
+ ALG_OPERATION(p, cipherdata->algtype, cipherdata->algmode,
+ OP_ALG_AS_INITFINAL, ICV_CHECK_ENABLE, DIR_DEC);
+
+ MATHB(p, DPOVRD, AND, 0x7fffffff, MATH3, 4, IMMED2);
+ SEQFIFOLOAD(p, IV1, ivlen, FLUSH1);
+
+ /* if assoclen is ZERO, skip reading the assoc data */
+ MATHB(p, ZERO, ADD, MATH3, VSEQINSZ, 4, 0);
+ pzeroassocjump1 = JUMP(p, zeroassocjump1, LOCAL_JUMP, ALL_TRUE, MATH_Z);
+
+ /* read assoc data */
+ SEQFIFOLOAD(p, AAD1, 0, CLASS1 | VLF | FLUSH1);
+
+ SET_LABEL(p, zeroassocjump1);
+
+ /* cryptlen = seqoutlen - assoclen */
+ MATHB(p, SEQOUTSZ, SUB, MATH0, VSEQINSZ, 4, 0);
+
+ /* jump to zero-payload command if cryptlen is zero */
+ pzeropayloadjump = JUMP(p, zeropayloadjump, LOCAL_JUMP, ALL_TRUE,
+ MATH_Z);
+
+ MATHB(p, SEQOUTSZ, SUB, MATH0, VSEQOUTSZ, 4, 0);
+
+ /* store encrypted data */
+ SEQFIFOSTORE(p, MSG, 0, 0, VLF);
+
+ /* read payload data */
+ SEQFIFOLOAD(p, MSG1, 0, CLASS1 | VLF | FLUSH1);
+
+ /* zero-payload command */
+ SET_LABEL(p, zeropayloadjump);
+
+ /* read ICV */
+ SEQFIFOLOAD(p, ICV1, icvsize, CLASS1 | LAST1);
+
+ PATCH_JUMP(p, pkeyjmp, keyjmp);
+ PATCH_JUMP(p, pzeroassocjump1, zeroassocjump1);
+ PATCH_JUMP(p, pzeropayloadjump, zeropayloadjump);
+
+ return PROGRAM_FINALIZE(p);
+}
+
+#endif /* __DESC_ALGO_H__ */
--- /dev/null
+/* SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0)
+ *
+ * Copyright 2008-2016 Freescale Semiconductor Inc.
+ * Copyright 2016 NXP
+ *
+ */
+
+#ifndef __DESC_COMMON_H__
+#define __DESC_COMMON_H__
+
+#include "rta.h"
+
+/**
+ * DOC: Shared Descriptor Constructors - shared structures
+ *
+ * Data structures shared between algorithm, protocol implementations.
+ */
+
+/**
+ * struct alginfo - Container for algorithm details
+ * @algtype: algorithm selector; for valid values, see documentation of the
+ * functions where it is used.
+ * @keylen: length of the provided algorithm key, in bytes
+ * @key: address where algorithm key resides; virtual address if key_type is
+ * RTA_DATA_IMM, physical (bus) address if key_type is RTA_DATA_PTR or
+ * RTA_DATA_IMM_DMA.
+ * @key_enc_flags: key encryption flags; see encrypt_flags parameter of KEY
+ * command for valid values.
+ * @key_type: enum rta_data_type
+ * @algmode: algorithm mode selector; for valid values, see documentation of the
+ * functions where it is used.
+ */
+struct alginfo {
+ uint32_t algtype;
+ uint32_t keylen;
+ uint64_t key;
+ uint32_t key_enc_flags;
+ enum rta_data_type key_type;
+ uint16_t algmode;
+};
+
+#define INLINE_KEY(alginfo) inline_flags(alginfo->key_type)
+
+/**
+ * rta_inline_query() - Provide indications on which data items can be inlined
+ * and which shall be referenced in a shared descriptor.
+ * @sd_base_len: Shared descriptor base length - bytes consumed by the commands,
+ * excluding the data items to be inlined (or corresponding
+ * pointer if an item is not inlined). Each cnstr_* function that
+ * generates descriptors should have a define mentioning
+ * corresponding length.
+ * @jd_len: Maximum length of the job descriptor(s) that will be used
+ * together with the shared descriptor.
+ * @data_len: Array of lengths of the data items trying to be inlined
+ * @inl_mask: 32bit mask with bit x = 1 if data item x can be inlined, 0
+ * otherwise.
+ * @count: Number of data items (size of @data_len array); must be <= 32
+ *
+ * Return: 0 if data can be inlined / referenced, negative value if not. If 0,
+ * check @inl_mask for details.
+ */
+static inline int
+rta_inline_query(unsigned int sd_base_len,
+ unsigned int jd_len,
+ unsigned int *data_len,
+ uint32_t *inl_mask,
+ unsigned int count)
+{
+ int rem_bytes = (int)(CAAM_DESC_BYTES_MAX - sd_base_len - jd_len);
+ unsigned int i;
+
+ *inl_mask = 0;
+ for (i = 0; (i < count) && (rem_bytes > 0); i++) {
+ if (rem_bytes - (int)(data_len[i] +
+ (count - i - 1) * CAAM_PTR_SZ) >= 0) {
+ rem_bytes -= data_len[i];
+ *inl_mask |= (1 << i);
+ } else {
+ rem_bytes -= CAAM_PTR_SZ;
+ }
+ }
+
+ return (rem_bytes >= 0) ? 0 : -1;
+}
+
+/**
+ * struct protcmd - Container for Protocol Operation Command fields
+ * @optype: command type
+ * @protid: protocol Identifier
+ * @protinfo: protocol Information
+ */
+struct protcmd {
+ uint32_t optype;
+ uint32_t protid;
+ uint16_t protinfo;
+};
+
+#endif /* __DESC_COMMON_H__ */
--- /dev/null
+/* SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0)
+ *
+ * Copyright 2008-2016 Freescale Semiconductor Inc.
+ * Copyright 2016,2019 NXP
+ *
+ */
+
+#ifndef __DESC_IPSEC_H__
+#define __DESC_IPSEC_H__
+
+#include "rta.h"
+#include "common.h"
+
+/**
+ * DOC: IPsec Shared Descriptor Constructors
+ *
+ * Shared descriptors for IPsec protocol.
+ */
+
+/* General IPSec ESP encap / decap PDB options */
+
+/**
+ * PDBOPTS_ESP_ESN - Extended sequence included
+ */
+#define PDBOPTS_ESP_ESN 0x10
+
+/**
+ * PDBOPTS_ESP_IPVSN - Process IPv6 header
+ *
+ * Valid only for IPsec legacy mode.
+ */
+#define PDBOPTS_ESP_IPVSN 0x02
+
+/**
+ * PDBOPTS_ESP_TUNNEL - Tunnel mode next-header byte
+ *
+ * Valid only for IPsec legacy mode.
+ */
+#define PDBOPTS_ESP_TUNNEL 0x01
+
+/* IPSec ESP Encap PDB options */
+
+/**
+ * PDBOPTS_ESP_UPDATE_CSUM - Update ip header checksum
+ *
+ * Valid only for IPsec legacy mode.
+ */
+#define PDBOPTS_ESP_UPDATE_CSUM 0x80
+
+/**
+ * PDBOPTS_ESP_DIFFSERV - Copy TOS/TC from inner iphdr
+ *
+ * Valid only for IPsec legacy mode.
+ */
+#define PDBOPTS_ESP_DIFFSERV 0x40
+
+/**
+ * PDBOPTS_ESP_IVSRC - IV comes from internal random gen
+ */
+#define PDBOPTS_ESP_IVSRC 0x20
+
+/**
+ * PDBOPTS_ESP_IPHDRSRC - IP header comes from PDB
+ *
+ * Valid only for IPsec legacy mode.
+ */
+#define PDBOPTS_ESP_IPHDRSRC 0x08
+
+/**
+ * PDBOPTS_ESP_INCIPHDR - Prepend IP header to output frame
+ *
+ * Valid only for IPsec legacy mode.
+ */
+#define PDBOPTS_ESP_INCIPHDR 0x04
+
+/**
+ * PDBOPTS_ESP_OIHI_MASK - Mask for Outer IP Header Included
+ *
+ * Valid only for IPsec new mode.
+ */
+#define PDBOPTS_ESP_OIHI_MASK 0x0c
+
+/**
+ * PDBOPTS_ESP_OIHI_PDB_INL - Prepend IP header to output frame from PDB (where
+ * it is inlined).
+ *
+ * Valid only for IPsec new mode.
+ */
+#define PDBOPTS_ESP_OIHI_PDB_INL 0x0c
+
+/**
+ * PDBOPTS_ESP_OIHI_PDB_REF - Prepend IP header to output frame from PDB
+ * (referenced by pointer).
+ *
+ * Vlid only for IPsec new mode.
+ */
+#define PDBOPTS_ESP_OIHI_PDB_REF 0x08
+
+/**
+ * PDBOPTS_ESP_OIHI_IF - Prepend IP header to output frame from input frame
+ *
+ * Valid only for IPsec new mode.
+ */
+#define PDBOPTS_ESP_OIHI_IF 0x04
+
+/**
+ * PDBOPTS_ESP_NAT - Enable RFC 3948 UDP-encapsulated-ESP
+ *
+ * Valid only for IPsec new mode.
+ */
+#define PDBOPTS_ESP_NAT 0x02
+
+/**
+ * PDBOPTS_ESP_NUC - Enable NAT UDP Checksum
+ *
+ * Valid only for IPsec new mode.
+ */
+#define PDBOPTS_ESP_NUC 0x01
+
+/* IPSec ESP Decap PDB options */
+
+/**
+ * PDBOPTS_ESP_ARS_MASK - antireplay window mask
+ */
+#define PDBOPTS_ESP_ARS_MASK 0xc0
+
+/**
+ * PDBOPTS_ESP_ARSNONE - No antireplay window
+ */
+#define PDBOPTS_ESP_ARSNONE 0x00
+
+/**
+ * PDBOPTS_ESP_ARS64 - 64-entry antireplay window
+ */
+#define PDBOPTS_ESP_ARS64 0xc0
+
+/**
+ * PDBOPTS_ESP_ARS128 - 128-entry antireplay window
+ *
+ * Valid only for IPsec new mode.
+ */
+#define PDBOPTS_ESP_ARS128 0x80
+
+/**
+ * PDBOPTS_ESP_ARS32 - 32-entry antireplay window
+ */
+#define PDBOPTS_ESP_ARS32 0x40
+
+/**
+ * PDBOPTS_ESP_VERIFY_CSUM - Validate ip header checksum
+ *
+ * Valid only for IPsec legacy mode.
+ */
+#define PDBOPTS_ESP_VERIFY_CSUM 0x20
+
+/**
+ * PDBOPTS_ESP_TECN - Implement RRFC6040 ECN tunneling from outer header to
+ * inner header.
+ *
+ * Valid only for IPsec new mode.
+ */
+#define PDBOPTS_ESP_TECN 0x20
+
+/**
+ * PDBOPTS_ESP_OUTFMT - Output only decapsulation
+ *
+ * Valid only for IPsec legacy mode.
+ */
+#define PDBOPTS_ESP_OUTFMT 0x08
+
+/**
+ * PDBOPTS_ESP_AOFL - Adjust out frame len
+ *
+ * Valid only for IPsec legacy mode and for SEC >= 5.3.
+ */
+#define PDBOPTS_ESP_AOFL 0x04
+
+/**
+ * PDBOPTS_ESP_ETU - EtherType Update
+ *
+ * Add corresponding ethertype (0x0800 for IPv4, 0x86dd for IPv6) in the output
+ * frame.
+ * Valid only for IPsec new mode.
+ */
+#define PDBOPTS_ESP_ETU 0x01
+
+#define PDBHMO_ESP_DECAP_SHIFT 28
+#define PDBHMO_ESP_ENCAP_SHIFT 28
+#define PDBNH_ESP_ENCAP_SHIFT 16
+#define PDBNH_ESP_ENCAP_MASK (0xff << PDBNH_ESP_ENCAP_SHIFT)
+#define PDBHDRLEN_ESP_DECAP_SHIFT 16
+#define PDBHDRLEN_MASK (0x0fff << PDBHDRLEN_ESP_DECAP_SHIFT)
+#define PDB_NH_OFFSET_SHIFT 8
+#define PDB_NH_OFFSET_MASK (0xff << PDB_NH_OFFSET_SHIFT)
+
+/**
+ * PDBHMO_ESP_DECAP_DTTL - IPsec ESP decrement TTL (IPv4) / Hop limit (IPv6)
+ * HMO option.
+ */
+#define PDBHMO_ESP_DECAP_DTTL (0x02 << PDBHMO_ESP_DECAP_SHIFT)
+
+/**
+ * PDBHMO_ESP_ENCAP_DTTL - IPsec ESP increment TTL (IPv4) / Hop limit (IPv6)
+ * HMO option.
+ */
+#define PDBHMO_ESP_ENCAP_DTTL (0x02 << PDBHMO_ESP_ENCAP_SHIFT)
+
+/**
+ * PDBHMO_ESP_DIFFSERV - (Decap) DiffServ Copy - Copy the IPv4 TOS or IPv6
+ * Traffic Class byte from the outer IP header to the
+ * inner IP header.
+ */
+#define PDBHMO_ESP_DIFFSERV (0x01 << PDBHMO_ESP_DECAP_SHIFT)
+
+/**
+ * PDBHMO_ESP_SNR - (Encap) - Sequence Number Rollover control
+ *
+ * Configures behaviour in case of SN / ESN rollover:
+ * error if SNR = 1, rollover allowed if SNR = 0.
+ * Valid only for IPsec new mode.
+ */
+#define PDBHMO_ESP_SNR (0x01 << PDBHMO_ESP_ENCAP_SHIFT)
+
+/**
+ * PDBHMO_ESP_DFBIT - (Encap) Copy DF bit - if an IPv4 tunnel mode outer IP
+ * header is coming from the PDB, copy the DF bit from the
+ * inner IP header to the outer IP header.
+ */
+#define PDBHMO_ESP_DFBIT (0x04 << PDBHMO_ESP_ENCAP_SHIFT)
+
+/**
+ * PDBHMO_ESP_DFV - (Decap) - DF bit value
+ *
+ * If ODF = 1, DF bit in output frame is replaced by DFV.
+ * Valid only from SEC Era 5 onwards.
+ */
+#define PDBHMO_ESP_DFV (0x04 << PDBHMO_ESP_DECAP_SHIFT)
+
+/**
+ * PDBHMO_ESP_ODF - (Decap) Override DF bit in IPv4 header of decapsulated
+ * output frame.
+ *
+ * If ODF = 1, DF is replaced with the value of DFV bit.
+ * Valid only from SEC Era 5 onwards.
+ */
+#define PDBHMO_ESP_ODF (0x08 << PDBHMO_ESP_DECAP_SHIFT)
+
+/**
+ * struct ipsec_encap_cbc - PDB part for IPsec CBC encapsulation
+ * @iv: 16-byte array initialization vector
+ */
+struct ipsec_encap_cbc {
+ uint8_t iv[16];
+};
+
+
+/**
+ * struct ipsec_encap_ctr - PDB part for IPsec CTR encapsulation
+ * @ctr_nonce: 4-byte array nonce
+ * @ctr_initial: initial count constant
+ * @iv: initialization vector
+ */
+struct ipsec_encap_ctr {
+ uint8_t ctr_nonce[4];
+ uint32_t ctr_initial;
+ uint64_t iv;
+};
+
+/**
+ * struct ipsec_encap_ccm - PDB part for IPsec CCM encapsulation
+ * @salt: 3-byte array salt (lower 24 bits)
+ * @ccm_opt: CCM algorithm options - MSB-LSB description:
+ * b0_flags (8b) - CCM B0; use 0x5B for 8-byte ICV, 0x6B for 12-byte ICV,
+ * 0x7B for 16-byte ICV (cf. RFC4309, RFC3610)
+ * ctr_flags (8b) - counter flags; constant equal to 0x3
+ * ctr_initial (16b) - initial count constant
+ * @iv: initialization vector
+ */
+struct ipsec_encap_ccm {
+ uint8_t salt[4];
+ uint32_t ccm_opt;
+ uint64_t iv;
+};
+
+/**
+ * struct ipsec_encap_gcm - PDB part for IPsec GCM encapsulation
+ * @salt: 3-byte array salt (lower 24 bits)
+ * @rsvd: reserved, do not use
+ * @iv: initialization vector
+ */
+struct ipsec_encap_gcm {
+ uint8_t salt[4];
+ uint32_t rsvd;
+ uint64_t iv;
+};
+
+/**
+ * struct ipsec_encap_pdb - PDB for IPsec encapsulation
+ * @options: MSB-LSB description (both for legacy and new modes)
+ * hmo (header manipulation options) - 4b
+ * reserved - 4b
+ * next header (legacy) / reserved (new) - 8b
+ * next header offset (legacy) / AOIPHO (actual outer IP header offset) - 8b
+ * option flags (depend on selected algorithm) - 8b
+ * @seq_num_ext_hi: (optional) IPsec Extended Sequence Number (ESN)
+ * @seq_num: IPsec sequence number
+ * @spi: IPsec SPI (Security Parameters Index)
+ * @ip_hdr_len: optional IP Header length (in bytes)
+ * reserved - 16b
+ * Opt. IP Hdr Len - 16b
+ * @ip_hdr: optional IP Header content (only for IPsec legacy mode)
+ */
+struct ipsec_encap_pdb {
+ uint32_t options;
+ uint32_t seq_num_ext_hi;
+ uint32_t seq_num;
+ union {
+ struct ipsec_encap_cbc cbc;
+ struct ipsec_encap_ctr ctr;
+ struct ipsec_encap_ccm ccm;
+ struct ipsec_encap_gcm gcm;
+ };
+ uint32_t spi;
+ uint32_t ip_hdr_len;
+ uint8_t ip_hdr[0];
+};
+
+static inline unsigned int
+__rta_copy_ipsec_encap_pdb(struct program *program,
+ struct ipsec_encap_pdb *pdb,
+ uint32_t algtype)
+{
+ unsigned int start_pc = program->current_pc;
+
+ __rta_out32(program, pdb->options);
+ __rta_out32(program, pdb->seq_num_ext_hi);
+ __rta_out32(program, pdb->seq_num);
+
+ switch (algtype & OP_PCL_IPSEC_CIPHER_MASK) {
+ case OP_PCL_IPSEC_DES_IV64:
+ case OP_PCL_IPSEC_DES:
+ case OP_PCL_IPSEC_3DES:
+ case OP_PCL_IPSEC_AES_CBC:
+ case OP_PCL_IPSEC_NULL:
+ rta_copy_data(program, pdb->cbc.iv, sizeof(pdb->cbc.iv));
+ break;
+
+ case OP_PCL_IPSEC_AES_CTR:
+ rta_copy_data(program, pdb->ctr.ctr_nonce,
+ sizeof(pdb->ctr.ctr_nonce));
+ __rta_out32(program, pdb->ctr.ctr_initial);
+ __rta_out64(program, true, pdb->ctr.iv);
+ break;
+
+ case OP_PCL_IPSEC_AES_CCM8:
+ case OP_PCL_IPSEC_AES_CCM12:
+ case OP_PCL_IPSEC_AES_CCM16:
+ rta_copy_data(program, pdb->ccm.salt, sizeof(pdb->ccm.salt));
+ __rta_out32(program, pdb->ccm.ccm_opt);
+ __rta_out64(program, true, pdb->ccm.iv);
+ break;
+
+ case OP_PCL_IPSEC_AES_GCM8:
+ case OP_PCL_IPSEC_AES_GCM12:
+ case OP_PCL_IPSEC_AES_GCM16:
+ case OP_PCL_IPSEC_AES_NULL_WITH_GMAC:
+ rta_copy_data(program, pdb->gcm.salt, sizeof(pdb->gcm.salt));
+ __rta_out32(program, pdb->gcm.rsvd);
+ __rta_out64(program, true, pdb->gcm.iv);
+ break;
+ }
+
+ __rta_out32(program, pdb->spi);
+ __rta_out32(program, pdb->ip_hdr_len);
+
+ return start_pc;
+}
+
+/**
+ * struct ipsec_decap_cbc - PDB part for IPsec CBC decapsulation
+ * @rsvd: reserved, do not use
+ */
+struct ipsec_decap_cbc {
+ uint32_t rsvd[2];
+};
+
+/**
+ * struct ipsec_decap_ctr - PDB part for IPsec CTR decapsulation
+ * @ctr_nonce: 4-byte array nonce
+ * @ctr_initial: initial count constant
+ */
+struct ipsec_decap_ctr {
+ uint8_t ctr_nonce[4];
+ uint32_t ctr_initial;
+};
+
+/**
+ * struct ipsec_decap_ccm - PDB part for IPsec CCM decapsulation
+ * @salt: 3-byte salt (lower 24 bits)
+ * @ccm_opt: CCM algorithm options - MSB-LSB description:
+ * b0_flags (8b) - CCM B0; use 0x5B for 8-byte ICV, 0x6B for 12-byte ICV,
+ * 0x7B for 16-byte ICV (cf. RFC4309, RFC3610)
+ * ctr_flags (8b) - counter flags; constant equal to 0x3
+ * ctr_initial (16b) - initial count constant
+ */
+struct ipsec_decap_ccm {
+ uint8_t salt[4];
+ uint32_t ccm_opt;
+};
+
+/**
+ * struct ipsec_decap_gcm - PDB part for IPsec GCN decapsulation
+ * @salt: 4-byte salt
+ * @rsvd: reserved, do not use
+ */
+struct ipsec_decap_gcm {
+ uint8_t salt[4];
+ uint32_t rsvd;
+};
+
+/**
+ * struct ipsec_decap_pdb - PDB for IPsec decapsulation
+ * @options: MSB-LSB description (both for legacy and new modes)
+ * hmo (header manipulation options) - 4b
+ * IP header length - 12b
+ * next header offset (legacy) / AOIPHO (actual outer IP header offset) - 8b
+ * option flags (depend on selected algorithm) - 8b
+ * @seq_num_ext_hi: (optional) IPsec Extended Sequence Number (ESN)
+ * @seq_num: IPsec sequence number
+ * @anti_replay: Anti-replay window; size depends on ARS (option flags);
+ * format must be Big Endian, irrespective of platform
+ */
+struct ipsec_decap_pdb {
+ uint32_t options;
+ union {
+ struct ipsec_decap_cbc cbc;
+ struct ipsec_decap_ctr ctr;
+ struct ipsec_decap_ccm ccm;
+ struct ipsec_decap_gcm gcm;
+ };
+ uint32_t seq_num_ext_hi;
+ uint32_t seq_num;
+ uint32_t anti_replay[4];
+};
+
+static inline unsigned int
+__rta_copy_ipsec_decap_pdb(struct program *program,
+ struct ipsec_decap_pdb *pdb,
+ uint32_t algtype)
+{
+ unsigned int start_pc = program->current_pc;
+ unsigned int i, ars;
+
+ __rta_out32(program, pdb->options);
+
+ switch (algtype & OP_PCL_IPSEC_CIPHER_MASK) {
+ case OP_PCL_IPSEC_DES_IV64:
+ case OP_PCL_IPSEC_DES:
+ case OP_PCL_IPSEC_3DES:
+ case OP_PCL_IPSEC_AES_CBC:
+ case OP_PCL_IPSEC_NULL:
+ __rta_out32(program, pdb->cbc.rsvd[0]);
+ __rta_out32(program, pdb->cbc.rsvd[1]);
+ break;
+
+ case OP_PCL_IPSEC_AES_CTR:
+ rta_copy_data(program, pdb->ctr.ctr_nonce,
+ sizeof(pdb->ctr.ctr_nonce));
+ __rta_out32(program, pdb->ctr.ctr_initial);
+ break;
+
+ case OP_PCL_IPSEC_AES_CCM8:
+ case OP_PCL_IPSEC_AES_CCM12:
+ case OP_PCL_IPSEC_AES_CCM16:
+ rta_copy_data(program, pdb->ccm.salt, sizeof(pdb->ccm.salt));
+ __rta_out32(program, pdb->ccm.ccm_opt);
+ break;
+
+ case OP_PCL_IPSEC_AES_GCM8:
+ case OP_PCL_IPSEC_AES_GCM12:
+ case OP_PCL_IPSEC_AES_GCM16:
+ case OP_PCL_IPSEC_AES_NULL_WITH_GMAC:
+ rta_copy_data(program, pdb->gcm.salt, sizeof(pdb->gcm.salt));
+ __rta_out32(program, pdb->gcm.rsvd);
+ break;
+ }
+
+ __rta_out32(program, pdb->seq_num_ext_hi);
+ __rta_out32(program, pdb->seq_num);
+
+ switch (pdb->options & PDBOPTS_ESP_ARS_MASK) {
+ case PDBOPTS_ESP_ARS128:
+ ars = 4;
+ break;
+ case PDBOPTS_ESP_ARS64:
+ ars = 2;
+ break;
+ case PDBOPTS_ESP_ARS32:
+ ars = 1;
+ break;
+ case PDBOPTS_ESP_ARSNONE:
+ default:
+ ars = 0;
+ break;
+ }
+
+ for (i = 0; i < ars; i++)
+ __rta_out_be32(program, pdb->anti_replay[i]);
+
+ return start_pc;
+}
+
+/**
+ * enum ipsec_icv_size - Type selectors for icv size in IPsec protocol
+ * @IPSEC_ICV_MD5_SIZE: full-length MD5 ICV
+ * @IPSEC_ICV_MD5_TRUNC_SIZE: truncated MD5 ICV
+ */
+enum ipsec_icv_size {
+ IPSEC_ICV_MD5_SIZE = 16,
+ IPSEC_ICV_MD5_TRUNC_SIZE = 12
+};
+
+/*
+ * IPSec ESP Datapath Protocol Override Register (DPOVRD)
+ * IPSEC_N_* defines are for IPsec new mode.
+ */
+
+/**
+ * IPSEC_DPOVRD_USE - DPOVRD will override values specified in the PDB
+ */
+#define IPSEC_DPOVRD_USE BIT(31)
+
+/**
+ * IPSEC_DPOVRD_ECN_SHIFT - Explicit Congestion Notification
+ *
+ * If set, MSB of the 4 bits indicates that the 2 LSBs will replace the ECN bits
+ * in the IP header.
+ */
+#define IPSEC_DPOVRD_ECN_SHIFT 24
+
+/**
+ * IPSEC_DPOVRD_ECN_MASK - See IPSEC_DPOVRD_ECN_SHIFT
+ */
+#define IPSEC_DPOVRD_ECN_MASK (0xf << IPSEC_ENCAP_DPOVRD_ECN_SHIFT)
+
+/**
+ * IPSEC_DPOVRD_IP_HDR_LEN_SHIFT - The length (in bytes) of the portion of the
+ * IP header that is not encrypted
+ */
+#define IPSEC_DPOVRD_IP_HDR_LEN_SHIFT 16
+
+/**
+ * IPSEC_DPOVRD_IP_HDR_LEN_MASK - See IPSEC_DPOVRD_IP_HDR_LEN_SHIFT
+ */
+#define IPSEC_DPOVRD_IP_HDR_LEN_MASK (0xff << IPSEC_DPOVRD_IP_HDR_LEN_SHIFT)
+
+/**
+ * IPSEC_DPOVRD_NH_OFFSET_SHIFT - The location of the next header field within
+ * the IP header of the transport mode packet
+ *
+ * Encap:
+ * ESP_Trailer_NH <-- IP_Hdr[DPOVRD[NH_OFFSET]]
+ * IP_Hdr[DPOVRD[NH_OFFSET]] <-- DPOVRD[NH]
+ *Decap:
+ * IP_Hdr[DPOVRD[NH_OFFSET]] <-- ESP_Trailer_NH
+ */
+#define IPSEC_DPOVRD_NH_OFFSET_SHIFT 8
+
+/**
+ * IPSEC_DPOVRD_NH_OFFSET_MASK - See IPSEC_DPOVRD_NH_OFFSET_SHIFT
+ */
+#define IPSEC_DPOVRD_NH_OFFSET_MASK (0xff << IPSEC_DPOVRD_NH_OFFSET_SHIFT)
+
+/**
+ * IPSEC_DPOVRD_NH_MASK - See IPSEC_DPOVRD_NH_OFFSET_SHIFT
+ * Valid only for encapsulation.
+ */
+#define IPSEC_DPOVRD_NH_MASK 0xff
+
+/**
+ * IPSEC_N_ENCAP_DPOVRD_OIM_LEN_SHIFT - Outer IP header Material length (encap)
+ * Valid only if L2_COPY is not set.
+ */
+#define IPSEC_N_ENCAP_DPOVRD_OIM_LEN_SHIFT 16
+
+/**
+ * IPSEC_N_ENCAP_DPOVRD_OIM_LEN_MASK - See IPSEC_N_ENCAP_DPOVRD_OIM_LEN_SHIFT
+ */
+#define IPSEC_N_ENCAP_DPOVRD_OIM_LEN_MASK \
+ (0xfff << IPSEC_N_ENCAP_DPOVRD_OIM_LEN_SHIFT)
+
+/**
+ * IPSEC_N_ENCAP_DPOVRD_L2_LEN_SHIFT - L2 header length
+ * Valid only if L2_COPY is set.
+ */
+#define IPSEC_N_ENCAP_DPOVRD_L2_LEN_SHIFT 16
+
+/**
+ * IPSEC_N_ENCAP_DPOVRD_L2_LEN_MASK - See IPSEC_N_ENCAP_DPOVRD_L2_LEN_SHIFT
+ */
+#define IPSEC_N_ENCAP_DPOVRD_L2_LEN_MASK \
+ (0xff << IPSEC_N_ENCAP_DPOVRD_L2_LEN_SHIFT)
+
+/**
+ * IPSEC_N_ENCAP_DPOVRD_OIMIF - Outer IP header Material in Input Frame
+ */
+#define IPSEC_N_ENCAP_DPOVRD_OIMIF BIT(15)
+
+/**
+ * IPSEC_N_ENCAP_DPOVRD_L2_COPY - L2 header present in input frame
+ *
+ * Note: For Era <= 8, this bit is reserved (not used) by HW.
+ */
+#define IPSEC_N_ENCAP_DPOVRD_L2_COPY BIT(14)
+
+/**
+ * IPSEC_N_ENCAP_DPOVRD_AOIPHO_SHIFT - Actual Outer IP Header Offset (encap)
+ */
+#define IPSEC_N_ENCAP_DPOVRD_AOIPHO_SHIFT 8
+
+/**
+ * IPSEC_N_ENCAP_DPOVRD_AOIPHO_MASK - See IPSEC_N_ENCAP_DPOVRD_AOIPHO_SHIFT
+ */
+#define IPSEC_N_ENCAP_DPOVRD_AOIPHO_MASK \
+ (0x3c << IPSEC_N_ENCAP_DPOVRD_AOIPHO_SHIFT)
+
+/**
+ * IPSEC_N_ENCAP_DPOVRD_NH_MASK - Next Header
+ *
+ * Used in the Next Header field of the encapsulated payload.
+ */
+#define IPSEC_N_ENCAP_DPOVRD_NH_MASK 0xff
+
+/**
+ * IPSEC_N_DECAP_DPOVRD_AOIPHO_SHIFT - Actual Outer IP Header Offset (decap)
+ */
+#define IPSEC_N_DECAP_DPOVRD_AOIPHO_SHIFT 12
+
+/**
+ * IPSEC_N_DECAP_DPOVRD_AOIPHO_MASK - See IPSEC_N_DECAP_DPOVRD_AOIPHO_SHIFT
+ */
+#define IPSEC_N_DECAP_DPOVRD_AOIPHO_MASK \
+ (0xff << IPSEC_N_DECAP_DPOVRD_AOIPHO_SHIFT)
+
+/**
+ * IPSEC_N_DECAP_DPOVRD_OIM_LEN_MASK - Outer IP header Material length (decap)
+ */
+#define IPSEC_N_DECAP_DPOVRD_OIM_LEN_MASK 0xfff
+
+static inline void __gen_auth_key(struct program *program,
+ struct alginfo *authdata)
+{
+ uint32_t dkp_protid;
+
+ switch (authdata->algtype & OP_PCL_IPSEC_AUTH_MASK) {
+ case OP_PCL_IPSEC_HMAC_MD5_96:
+ case OP_PCL_IPSEC_HMAC_MD5_128:
+ dkp_protid = OP_PCLID_DKP_MD5;
+ break;
+ case OP_PCL_IPSEC_HMAC_SHA1_96:
+ case OP_PCL_IPSEC_HMAC_SHA1_160:
+ dkp_protid = OP_PCLID_DKP_SHA1;
+ break;
+ case OP_PCL_IPSEC_HMAC_SHA2_256_128:
+ dkp_protid = OP_PCLID_DKP_SHA256;
+ break;
+ case OP_PCL_IPSEC_HMAC_SHA2_384_192:
+ dkp_protid = OP_PCLID_DKP_SHA384;
+ break;
+ case OP_PCL_IPSEC_HMAC_SHA2_512_256:
+ dkp_protid = OP_PCLID_DKP_SHA512;
+ break;
+ default:
+ KEY(program, KEY2, authdata->key_enc_flags, authdata->key,
+ authdata->keylen, INLINE_KEY(authdata));
+ return;
+ }
+
+ if (authdata->key_type == RTA_DATA_PTR)
+ DKP_PROTOCOL(program, dkp_protid, OP_PCL_DKP_SRC_PTR,
+ OP_PCL_DKP_DST_PTR, (uint16_t)authdata->keylen,
+ authdata->key, authdata->key_type);
+ else
+ DKP_PROTOCOL(program, dkp_protid, OP_PCL_DKP_SRC_IMM,
+ OP_PCL_DKP_DST_IMM, (uint16_t)authdata->keylen,
+ authdata->key, authdata->key_type);
+}
+
+/**
+ * cnstr_shdsc_ipsec_encap - IPSec ESP encapsulation protocol-level shared
+ * descriptor.
+ * @descbuf: pointer to buffer used for descriptor construction
+ * @ps: if 36/40bit addressing is desired, this parameter must be true
+ * @swap: if true, perform descriptor byte swapping on a 4-byte boundary
+ * @share: sharing type of shared descriptor
+ * @pdb: pointer to the PDB to be used with this descriptor
+ * This structure will be copied inline to the descriptor under
+ * construction. No error checking will be made. Refer to the
+ * block guide for a details of the encapsulation PDB.
+ * @cipherdata: pointer to block cipher transform definitions
+ * Valid algorithm values - one of OP_PCL_IPSEC_*
+ * @authdata: pointer to authentication transform definitions
+ * If an authentication key is required by the protocol:
+ * -For SEC Eras 1-5, an MDHA split key must be provided;
+ * Note that the size of the split key itself must be specified.
+ * -For SEC Eras 6+, a "normal" key must be provided; DKP (Derived
+ * Key Protocol) will be used to compute MDHA on the fly in HW.
+ * Valid algorithm values - one of OP_PCL_IPSEC_*
+ *
+ * Return: size of descriptor written in words or negative number on error
+ */
+static inline int
+cnstr_shdsc_ipsec_encap(uint32_t *descbuf, bool ps, bool swap,
+ enum rta_share_type share,
+ struct ipsec_encap_pdb *pdb,
+ struct alginfo *cipherdata,
+ struct alginfo *authdata)
+{
+ struct program prg;
+ struct program *p = &prg;
+
+ LABEL(keyjmp);
+ REFERENCE(pkeyjmp);
+ LABEL(hdr);
+ REFERENCE(phdr);
+
+ PROGRAM_CNTXT_INIT(p, descbuf, 0);
+ if (swap)
+ PROGRAM_SET_BSWAP(p);
+ if (ps)
+ PROGRAM_SET_36BIT_ADDR(p);
+ phdr = SHR_HDR(p, share, hdr, 0);
+ __rta_copy_ipsec_encap_pdb(p, pdb, cipherdata->algtype);
+ COPY_DATA(p, pdb->ip_hdr, pdb->ip_hdr_len);
+ SET_LABEL(p, hdr);
+ pkeyjmp = JUMP(p, keyjmp, LOCAL_JUMP, ALL_TRUE, BOTH|SHRD);
+ if (authdata->keylen) {
+ if (rta_sec_era < RTA_SEC_ERA_6)
+ KEY(p, MDHA_SPLIT_KEY, authdata->key_enc_flags,
+ authdata->key, authdata->keylen,
+ INLINE_KEY(authdata));
+ else
+ __gen_auth_key(p, authdata);
+ }
+ if (cipherdata->keylen)
+ KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
+ cipherdata->keylen, INLINE_KEY(cipherdata));
+ SET_LABEL(p, keyjmp);
+ PROTOCOL(p, OP_TYPE_ENCAP_PROTOCOL,
+ OP_PCLID_IPSEC,
+ (uint16_t)(cipherdata->algtype | authdata->algtype));
+ PATCH_JUMP(p, pkeyjmp, keyjmp);
+ PATCH_HDR(p, phdr, hdr);
+ return PROGRAM_FINALIZE(p);
+}
+
+/**
+ * cnstr_shdsc_ipsec_decap - IPSec ESP decapsulation protocol-level shared
+ * descriptor.
+ * @descbuf: pointer to buffer used for descriptor construction
+ * @ps: if 36/40bit addressing is desired, this parameter must be true
+ * @swap: if true, perform descriptor byte swapping on a 4-byte boundary
+ * @share: sharing type of shared descriptor
+ * @pdb: pointer to the PDB to be used with this descriptor
+ * This structure will be copied inline to the descriptor under
+ * construction. No error checking will be made. Refer to the
+ * block guide for details about the decapsulation PDB.
+ * @cipherdata: pointer to block cipher transform definitions.
+ * Valid algorithm values - one of OP_PCL_IPSEC_*
+ * @authdata: pointer to authentication transform definitions
+ * If an authentication key is required by the protocol:
+ * -For SEC Eras 1-5, an MDHA split key must be provided;
+ * Note that the size of the split key itself must be specified.
+ * -For SEC Eras 6+, a "normal" key must be provided; DKP (Derived
+ * Key Protocol) will be used to compute MDHA on the fly in HW.
+ * Valid algorithm values - one of OP_PCL_IPSEC_*
+ *
+ * Return: size of descriptor written in words or negative number on error
+ */
+static inline int
+cnstr_shdsc_ipsec_decap(uint32_t *descbuf, bool ps, bool swap,
+ enum rta_share_type share,
+ struct ipsec_decap_pdb *pdb,
+ struct alginfo *cipherdata,
+ struct alginfo *authdata)
+{
+ struct program prg;
+ struct program *p = &prg;
+
+ LABEL(keyjmp);
+ REFERENCE(pkeyjmp);
+ LABEL(hdr);
+ REFERENCE(phdr);
+
+ PROGRAM_CNTXT_INIT(p, descbuf, 0);
+ if (swap)
+ PROGRAM_SET_BSWAP(p);
+ if (ps)
+ PROGRAM_SET_36BIT_ADDR(p);
+ phdr = SHR_HDR(p, share, hdr, 0);
+ __rta_copy_ipsec_decap_pdb(p, pdb, cipherdata->algtype);
+ SET_LABEL(p, hdr);
+ pkeyjmp = JUMP(p, keyjmp, LOCAL_JUMP, ALL_TRUE, BOTH|SHRD);
+ if (authdata->keylen) {
+ if (rta_sec_era < RTA_SEC_ERA_6)
+ KEY(p, MDHA_SPLIT_KEY, authdata->key_enc_flags,
+ authdata->key, authdata->keylen,
+ INLINE_KEY(authdata));
+ else
+ __gen_auth_key(p, authdata);
+ }
+ if (cipherdata->keylen)
+ KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
+ cipherdata->keylen, INLINE_KEY(cipherdata));
+ SET_LABEL(p, keyjmp);
+ PROTOCOL(p, OP_TYPE_DECAP_PROTOCOL,
+ OP_PCLID_IPSEC,
+ (uint16_t)(cipherdata->algtype | authdata->algtype));
+ PATCH_JUMP(p, pkeyjmp, keyjmp);
+ PATCH_HDR(p, phdr, hdr);
+ return PROGRAM_FINALIZE(p);
+}
+
+/**
+ * cnstr_shdsc_ipsec_encap_des_aes_xcbc - IPSec DES-CBC/3DES-CBC and
+ * AES-XCBC-MAC-96 ESP encapsulation shared descriptor.
+ * @descbuf: pointer to buffer used for descriptor construction
+ * @pdb: pointer to the PDB to be used with this descriptor
+ * This structure will be copied inline to the descriptor under
+ * construction. No error checking will be made. Refer to the
+ * block guide for a details of the encapsulation PDB.
+ * @cipherdata: pointer to block cipher transform definitions
+ * Valid algorithm values - OP_PCL_IPSEC_DES, OP_PCL_IPSEC_3DES.
+ * @authdata: pointer to authentication transform definitions
+ * Valid algorithm value: OP_PCL_IPSEC_AES_XCBC_MAC_96.
+ *
+ * Supported only for platforms with 32-bit address pointers and SEC ERA 4 or
+ * higher. The tunnel/transport mode of the IPsec ESP is supported only if the
+ * Outer/Transport IP Header is present in the encapsulation output packet.
+ * The descriptor performs DES-CBC/3DES-CBC & HMAC-MD5-96 and then rereads
+ * the input packet to do the AES-XCBC-MAC-96 calculation and to overwrite
+ * the MD5 ICV.
+ * The descriptor uses all the benefits of the built-in protocol by computing
+ * the IPsec ESP with a hardware supported algorithms combination
+ * (DES-CBC/3DES-CBC & HMAC-MD5-96). The HMAC-MD5 authentication algorithm
+ * was chosen in order to speed up the computational time for this intermediate
+ * step.
+ * Warning: The user must allocate at least 32 bytes for the authentication key
+ * (in order to use it also with HMAC-MD5-96),even when using a shorter key
+ * for the AES-XCBC-MAC-96.
+ *
+ * Return: size of descriptor written in words or negative number on error
+ */
+static inline int
+cnstr_shdsc_ipsec_encap_des_aes_xcbc(uint32_t *descbuf,
+ struct ipsec_encap_pdb *pdb,
+ struct alginfo *cipherdata,
+ struct alginfo *authdata)
+{
+ struct program prg;
+ struct program *p = &prg;
+
+ LABEL(hdr);
+ LABEL(shd_ptr);
+ LABEL(keyjump);
+ LABEL(outptr);
+ LABEL(swapped_seqin_fields);
+ LABEL(swapped_seqin_ptr);
+ REFERENCE(phdr);
+ REFERENCE(pkeyjump);
+ REFERENCE(move_outlen);
+ REFERENCE(move_seqout_ptr);
+ REFERENCE(swapped_seqin_ptr_jump);
+ REFERENCE(write_swapped_seqin_ptr);
+
+ PROGRAM_CNTXT_INIT(p, descbuf, 0);
+ phdr = SHR_HDR(p, SHR_SERIAL, hdr, 0);
+ __rta_copy_ipsec_encap_pdb(p, pdb, cipherdata->algtype);
+ COPY_DATA(p, pdb->ip_hdr, pdb->ip_hdr_len);
+ SET_LABEL(p, hdr);
+ pkeyjump = JUMP(p, keyjump, LOCAL_JUMP, ALL_TRUE, SHRD | SELF);
+ /*
+ * Hard-coded KEY arguments. The descriptor uses all the benefits of
+ * the built-in protocol by computing the IPsec ESP with a hardware
+ * supported algorithms combination (DES-CBC/3DES-CBC & HMAC-MD5-96).
+ * The HMAC-MD5 authentication algorithm was chosen with
+ * the keys options from below in order to speed up the computational
+ * time for this intermediate step.
+ * Warning: The user must allocate at least 32 bytes for
+ * the authentication key (in order to use it also with HMAC-MD5-96),
+ * even when using a shorter key for the AES-XCBC-MAC-96.
+ */
+ KEY(p, MDHA_SPLIT_KEY, 0, authdata->key, 32, INLINE_KEY(authdata));
+ SET_LABEL(p, keyjump);
+ LOAD(p, LDST_SRCDST_WORD_CLRW | CLRW_CLR_C1MODE | CLRW_CLR_C1DATAS |
+ CLRW_CLR_C1CTX | CLRW_CLR_C1KEY | CLRW_RESET_CLS1_CHA, CLRW, 0, 4,
+ IMMED);
+ KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
+ cipherdata->keylen, INLINE_KEY(cipherdata));
+ PROTOCOL(p, OP_TYPE_ENCAP_PROTOCOL, OP_PCLID_IPSEC,
+ (uint16_t)(cipherdata->algtype | OP_PCL_IPSEC_HMAC_MD5_96));
+ /* Swap SEQINPTR to SEQOUTPTR. */
+ move_seqout_ptr = MOVE(p, DESCBUF, 0, MATH1, 0, 16, WAITCOMP | IMMED);
+ MATHB(p, MATH1, AND, ~(CMD_SEQ_IN_PTR ^ CMD_SEQ_OUT_PTR), MATH1,
+ 8, IFB | IMMED2);
+/*
+ * TODO: RTA currently doesn't support creating a LOAD command
+ * with another command as IMM.
+ * To be changed when proper support is added in RTA.
+ */
+ LOAD(p, 0xa00000e5, MATH3, 4, 4, IMMED);
+ MATHB(p, MATH3, SHLD, MATH3, MATH3, 8, 0);
+ write_swapped_seqin_ptr = MOVE(p, MATH1, 0, DESCBUF, 0, 20, WAITCOMP |
+ IMMED);
+ swapped_seqin_ptr_jump = JUMP(p, swapped_seqin_ptr, LOCAL_JUMP,
+ ALL_TRUE, 0);
+ LOAD(p, LDST_SRCDST_WORD_CLRW | CLRW_CLR_C1MODE | CLRW_CLR_C1DATAS |
+ CLRW_CLR_C1CTX | CLRW_CLR_C1KEY | CLRW_RESET_CLS1_CHA, CLRW, 0, 4,
+ 0);
+ SEQOUTPTR(p, 0, 65535, RTO);
+ move_outlen = MOVE(p, DESCBUF, 0, MATH0, 4, 8, WAITCOMP | IMMED);
+ MATHB(p, MATH0, SUB,
+ (uint64_t)(pdb->ip_hdr_len + IPSEC_ICV_MD5_TRUNC_SIZE),
+ VSEQINSZ, 4, IMMED2);
+ MATHB(p, MATH0, SUB, IPSEC_ICV_MD5_TRUNC_SIZE, VSEQOUTSZ, 4, IMMED2);
+ KEY(p, KEY1, authdata->key_enc_flags, authdata->key, authdata->keylen,
+ 0);
+ ALG_OPERATION(p, OP_ALG_ALGSEL_AES, OP_ALG_AAI_XCBC_MAC,
+ OP_ALG_AS_INITFINAL, ICV_CHECK_DISABLE, DIR_ENC);
+ SEQFIFOLOAD(p, SKIP, pdb->ip_hdr_len, 0);
+ SEQFIFOLOAD(p, MSG1, 0, VLF | FLUSH1 | LAST1);
+ SEQFIFOSTORE(p, SKIP, 0, 0, VLF);
+ SEQSTORE(p, CONTEXT1, 0, IPSEC_ICV_MD5_TRUNC_SIZE, 0);
+/*
+ * TODO: RTA currently doesn't support adding labels in or after Job Descriptor.
+ * To be changed when proper support is added in RTA.
+ */
+ /* Label the Shared Descriptor Pointer */
+ SET_LABEL(p, shd_ptr);
+ shd_ptr += 1;
+ /* Label the Output Pointer */
+ SET_LABEL(p, outptr);
+ outptr += 3;
+ /* Label the first word after JD */
+ SET_LABEL(p, swapped_seqin_fields);
+ swapped_seqin_fields += 8;
+ /* Label the second word after JD */
+ SET_LABEL(p, swapped_seqin_ptr);
+ swapped_seqin_ptr += 9;
+
+ PATCH_HDR(p, phdr, hdr);
+ PATCH_JUMP(p, pkeyjump, keyjump);
+ PATCH_JUMP(p, swapped_seqin_ptr_jump, swapped_seqin_ptr);
+ PATCH_MOVE(p, move_outlen, outptr);
+ PATCH_MOVE(p, move_seqout_ptr, shd_ptr);
+ PATCH_MOVE(p, write_swapped_seqin_ptr, swapped_seqin_fields);
+ return PROGRAM_FINALIZE(p);
+}
+
+/**
+ * cnstr_shdsc_ipsec_decap_des_aes_xcbc - IPSec DES-CBC/3DES-CBC and
+ * AES-XCBC-MAC-96 ESP decapsulation shared descriptor.
+ * @descbuf: pointer to buffer used for descriptor construction
+ * @pdb: pointer to the PDB to be used with this descriptor
+ * This structure will be copied inline to the descriptor under
+ * construction. No error checking will be made. Refer to the
+ * block guide for a details of the encapsulation PDB.
+ * @cipherdata: pointer to block cipher transform definitions
+ * Valid algorithm values - OP_PCL_IPSEC_DES, OP_PCL_IPSEC_3DES.
+ * @authdata: pointer to authentication transform definitions
+ * Valid algorithm value: OP_PCL_IPSEC_AES_XCBC_MAC_96.
+ *
+ * Supported only for platforms with 32-bit address pointers and SEC ERA 4 or
+ * higher. The tunnel/transport mode of the IPsec ESP is supported only if the
+ * Outer/Transport IP Header is present in the decapsulation input packet.
+ * The descriptor computes the AES-XCBC-MAC-96 to check if the received ICV
+ * is correct, rereads the input packet to compute the MD5 ICV, overwrites
+ * the XCBC ICV, and then sends the modified input packet to the
+ * DES-CBC/3DES-CBC & HMAC-MD5-96 IPsec.
+ * The descriptor uses all the benefits of the built-in protocol by computing
+ * the IPsec ESP with a hardware supported algorithms combination
+ * (DES-CBC/3DES-CBC & HMAC-MD5-96). The HMAC-MD5 authentication algorithm
+ * was chosen in order to speed up the computational time for this intermediate
+ * step.
+ * Warning: The user must allocate at least 32 bytes for the authentication key
+ * (in order to use it also with HMAC-MD5-96),even when using a shorter key
+ * for the AES-XCBC-MAC-96.
+ *
+ * Return: size of descriptor written in words or negative number on error
+ */
+static inline int
+cnstr_shdsc_ipsec_decap_des_aes_xcbc(uint32_t *descbuf,
+ struct ipsec_decap_pdb *pdb,
+ struct alginfo *cipherdata,
+ struct alginfo *authdata)
+{
+ struct program prg;
+ struct program *p = &prg;
+ uint32_t ip_hdr_len = (pdb->options & PDBHDRLEN_MASK) >>
+ PDBHDRLEN_ESP_DECAP_SHIFT;
+
+ LABEL(hdr);
+ LABEL(jump_cmd);
+ LABEL(keyjump);
+ LABEL(outlen);
+ LABEL(seqin_ptr);
+ LABEL(seqout_ptr);
+ LABEL(swapped_seqout_fields);
+ LABEL(swapped_seqout_ptr);
+ REFERENCE(seqout_ptr_jump);
+ REFERENCE(phdr);
+ REFERENCE(pkeyjump);
+ REFERENCE(move_jump);
+ REFERENCE(move_jump_back);
+ REFERENCE(move_seqin_ptr);
+ REFERENCE(swapped_seqout_ptr_jump);
+ REFERENCE(write_swapped_seqout_ptr);
+
+ PROGRAM_CNTXT_INIT(p, descbuf, 0);
+ phdr = SHR_HDR(p, SHR_SERIAL, hdr, 0);
+ __rta_copy_ipsec_decap_pdb(p, pdb, cipherdata->algtype);
+ SET_LABEL(p, hdr);
+ pkeyjump = JUMP(p, keyjump, LOCAL_JUMP, ALL_TRUE, SHRD | SELF);
+ /*
+ * Hard-coded KEY arguments. The descriptor uses all the benefits of
+ * the built-in protocol by computing the IPsec ESP with a hardware
+ * supported algorithms combination (DES-CBC/3DES-CBC & HMAC-MD5-96).
+ * The HMAC-MD5 authentication algorithm was chosen with
+ * the keys options from bellow in order to speed up the computational
+ * time for this intermediate step.
+ * Warning: The user must allocate at least 32 bytes for
+ * the authentication key (in order to use it also with HMAC-MD5-96),
+ * even when using a shorter key for the AES-XCBC-MAC-96.
+ */
+ KEY(p, MDHA_SPLIT_KEY, 0, authdata->key, 32, INLINE_KEY(authdata));
+ SET_LABEL(p, keyjump);
+ LOAD(p, LDST_SRCDST_WORD_CLRW | CLRW_CLR_C1MODE | CLRW_CLR_C1DATAS |
+ CLRW_CLR_C1CTX | CLRW_CLR_C1KEY | CLRW_RESET_CLS1_CHA, CLRW, 0, 4,
+ 0);
+ KEY(p, KEY1, authdata->key_enc_flags, authdata->key, authdata->keylen,
+ INLINE_KEY(authdata));
+ MATHB(p, SEQINSZ, SUB,
+ (uint64_t)(ip_hdr_len + IPSEC_ICV_MD5_TRUNC_SIZE), MATH0, 4,
+ IMMED2);
+ MATHB(p, MATH0, SUB, ZERO, VSEQINSZ, 4, 0);
+ ALG_OPERATION(p, OP_ALG_ALGSEL_MD5, OP_ALG_AAI_HMAC_PRECOMP,
+ OP_ALG_AS_INITFINAL, ICV_CHECK_DISABLE, DIR_ENC);
+ ALG_OPERATION(p, OP_ALG_ALGSEL_AES, OP_ALG_AAI_XCBC_MAC,
+ OP_ALG_AS_INITFINAL, ICV_CHECK_ENABLE, DIR_DEC);
+ SEQFIFOLOAD(p, SKIP, ip_hdr_len, 0);
+ SEQFIFOLOAD(p, MSG1, 0, VLF | FLUSH1);
+ SEQFIFOLOAD(p, ICV1, IPSEC_ICV_MD5_TRUNC_SIZE, FLUSH1 | LAST1);
+ /* Swap SEQOUTPTR to SEQINPTR. */
+ move_seqin_ptr = MOVE(p, DESCBUF, 0, MATH1, 0, 16, WAITCOMP | IMMED);
+ MATHB(p, MATH1, OR, CMD_SEQ_IN_PTR ^ CMD_SEQ_OUT_PTR, MATH1, 8,
+ IFB | IMMED2);
+/*
+ * TODO: RTA currently doesn't support creating a LOAD command
+ * with another command as IMM.
+ * To be changed when proper support is added in RTA.
+ */
+ LOAD(p, 0xA00000e1, MATH3, 4, 4, IMMED);
+ MATHB(p, MATH3, SHLD, MATH3, MATH3, 8, 0);
+ write_swapped_seqout_ptr = MOVE(p, MATH1, 0, DESCBUF, 0, 20, WAITCOMP |
+ IMMED);
+ swapped_seqout_ptr_jump = JUMP(p, swapped_seqout_ptr, LOCAL_JUMP,
+ ALL_TRUE, 0);
+/*
+ * TODO: To be changed when proper support is added in RTA (can't load
+ * a command that is also written by RTA).
+ * Change when proper RTA support is added.
+ */
+ SET_LABEL(p, jump_cmd);
+ WORD(p, 0xA00000f3);
+ SEQINPTR(p, 0, 65535, RTO);
+ MATHB(p, MATH0, SUB, ZERO, VSEQINSZ, 4, 0);
+ MATHB(p, MATH0, ADD, ip_hdr_len, VSEQOUTSZ, 4, IMMED2);
+ move_jump = MOVE(p, DESCBUF, 0, OFIFO, 0, 8, WAITCOMP | IMMED);
+ move_jump_back = MOVE(p, OFIFO, 0, DESCBUF, 0, 8, IMMED);
+ SEQFIFOLOAD(p, SKIP, ip_hdr_len, 0);
+ SEQFIFOLOAD(p, MSG2, 0, VLF | LAST2);
+ SEQFIFOSTORE(p, SKIP, 0, 0, VLF);
+ SEQSTORE(p, CONTEXT2, 0, IPSEC_ICV_MD5_TRUNC_SIZE, 0);
+ seqout_ptr_jump = JUMP(p, seqout_ptr, LOCAL_JUMP, ALL_TRUE, CALM);
+
+ LOAD(p, LDST_SRCDST_WORD_CLRW | CLRW_CLR_C1MODE | CLRW_CLR_C1DATAS |
+ CLRW_CLR_C1CTX | CLRW_CLR_C1KEY | CLRW_CLR_C2MODE |
+ CLRW_CLR_C2DATAS | CLRW_CLR_C2CTX | CLRW_RESET_CLS1_CHA, CLRW, 0,
+ 4, 0);
+ SEQINPTR(p, 0, 65535, RTO);
+ MATHB(p, MATH0, ADD,
+ (uint64_t)(ip_hdr_len + IPSEC_ICV_MD5_TRUNC_SIZE), SEQINSZ, 4,
+ IMMED2);
+ KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
+ cipherdata->keylen, INLINE_KEY(cipherdata));
+ PROTOCOL(p, OP_TYPE_DECAP_PROTOCOL, OP_PCLID_IPSEC,
+ (uint16_t)(cipherdata->algtype | OP_PCL_IPSEC_HMAC_MD5_96));
+/*
+ * TODO: RTA currently doesn't support adding labels in or after Job Descriptor.
+ * To be changed when proper support is added in RTA.
+ */
+ /* Label the SEQ OUT PTR */
+ SET_LABEL(p, seqout_ptr);
+ seqout_ptr += 2;
+ /* Label the Output Length */
+ SET_LABEL(p, outlen);
+ outlen += 4;
+ /* Label the SEQ IN PTR */
+ SET_LABEL(p, seqin_ptr);
+ seqin_ptr += 5;
+ /* Label the first word after JD */
+ SET_LABEL(p, swapped_seqout_fields);
+ swapped_seqout_fields += 8;
+ /* Label the second word after JD */
+ SET_LABEL(p, swapped_seqout_ptr);
+ swapped_seqout_ptr += 9;
+
+ PATCH_HDR(p, phdr, hdr);
+ PATCH_JUMP(p, pkeyjump, keyjump);
+ PATCH_JUMP(p, seqout_ptr_jump, seqout_ptr);
+ PATCH_JUMP(p, swapped_seqout_ptr_jump, swapped_seqout_ptr);
+ PATCH_MOVE(p, move_jump, jump_cmd);
+ PATCH_MOVE(p, move_jump_back, seqin_ptr);
+ PATCH_MOVE(p, move_seqin_ptr, outlen);
+ PATCH_MOVE(p, write_swapped_seqout_ptr, swapped_seqout_fields);
+ return PROGRAM_FINALIZE(p);
+}
+
+/**
+ * IPSEC_NEW_ENC_BASE_DESC_LEN - IPsec new mode encap shared descriptor length
+ *
+ * Accounts only for the "base" commands and is intended to be used by upper
+ * layers to determine whether Outer IP Header and/or keys can be inlined or
+ * not. To be used as first parameter of rta_inline_query().
+ */
+#define IPSEC_NEW_ENC_BASE_DESC_LEN (12 * CAAM_CMD_SZ + \
+ sizeof(struct ipsec_encap_pdb))
+
+/**
+ * IPSEC_NEW_NULL_ENC_BASE_DESC_LEN - IPsec new mode encap shared descriptor
+ * length for the case of
+ * NULL encryption / authentication
+ *
+ * Accounts only for the "base" commands and is intended to be used by upper
+ * layers to determine whether Outer IP Header and/or key can be inlined or
+ * not. To be used as first parameter of rta_inline_query().
+ */
+#define IPSEC_NEW_NULL_ENC_BASE_DESC_LEN (11 * CAAM_CMD_SZ + \
+ sizeof(struct ipsec_encap_pdb))
+
+/**
+ * cnstr_shdsc_ipsec_new_encap - IPSec new mode ESP encapsulation
+ * protocol-level shared descriptor.
+ * @descbuf: pointer to buffer used for descriptor construction
+ * @ps: if 36/40bit addressing is desired, this parameter must be true
+ * @swap: must be true when core endianness doesn't match SEC endianness
+ * @share: sharing type of shared descriptor
+ * @pdb: pointer to the PDB to be used with this descriptor
+ * This structure will be copied inline to the descriptor under
+ * construction. No error checking will be made. Refer to the
+ * block guide for details about the encapsulation PDB.
+ * @opt_ip_hdr: pointer to Optional IP Header
+ * -if OIHI = PDBOPTS_ESP_OIHI_PDB_INL, opt_ip_hdr points to the buffer to
+ * be inlined in the PDB. Number of bytes (buffer size) copied is provided
+ * in pdb->ip_hdr_len.
+ * -if OIHI = PDBOPTS_ESP_OIHI_PDB_REF, opt_ip_hdr points to the address of
+ * the Optional IP Header. The address will be inlined in the PDB verbatim.
+ * -for other values of OIHI options field, opt_ip_hdr is not used.
+ * @cipherdata: pointer to block cipher transform definitions
+ * Valid algorithm values - one of OP_PCL_IPSEC_*
+ * @authdata: pointer to authentication transform definitions.
+ * If an authentication key is required by the protocol, a "normal"
+ * key must be provided; DKP (Derived Key Protocol) will be used to
+ * compute MDHA on the fly in HW.
+ * Valid algorithm values - one of OP_PCL_IPSEC_*
+ *
+ * Note: L2 header copy functionality is implemented assuming that bits 14
+ * (currently reserved) and 16-23 (part of Outer IP Header Material Length)
+ * in DPOVRD register are not used (which is usually the case when L3 header
+ * is provided in PDB).
+ * When DPOVRD[14] is set, frame starts with an L2 header; in this case, the
+ * L2 header length is found at DPOVRD[23:16]. SEC uses this length to copy
+ * the header and then it deletes DPOVRD[23:16] (so there is no side effect
+ * when later running IPsec protocol).
+ *
+ * Return: size of descriptor written in words or negative number on error
+ */
+static inline int
+cnstr_shdsc_ipsec_new_encap(uint32_t *descbuf, bool ps,
+ bool swap,
+ enum rta_share_type share,
+ struct ipsec_encap_pdb *pdb,
+ uint8_t *opt_ip_hdr,
+ struct alginfo *cipherdata,
+ struct alginfo *authdata)
+{
+ struct program prg;
+ struct program *p = &prg;
+
+ LABEL(keyjmp);
+ REFERENCE(pkeyjmp);
+ LABEL(hdr);
+ REFERENCE(phdr);
+ LABEL(l2copy);
+ REFERENCE(pl2copy);
+
+ if (rta_sec_era < RTA_SEC_ERA_8) {
+ pr_err("IPsec new mode encap: available only for Era %d or above\n",
+ USER_SEC_ERA(RTA_SEC_ERA_8));
+ return -ENOTSUP;
+ }
+
+ PROGRAM_CNTXT_INIT(p, descbuf, 0);
+ if (swap)
+ PROGRAM_SET_BSWAP(p);
+ if (ps)
+ PROGRAM_SET_36BIT_ADDR(p);
+ phdr = SHR_HDR(p, share, hdr, 0);
+
+ __rta_copy_ipsec_encap_pdb(p, pdb, cipherdata->algtype);
+
+ switch (pdb->options & PDBOPTS_ESP_OIHI_MASK) {
+ case PDBOPTS_ESP_OIHI_PDB_INL:
+ COPY_DATA(p, opt_ip_hdr, pdb->ip_hdr_len);
+ break;
+ case PDBOPTS_ESP_OIHI_PDB_REF:
+ if (ps)
+ COPY_DATA(p, opt_ip_hdr, 8);
+ else
+ COPY_DATA(p, opt_ip_hdr, 4);
+ break;
+ default:
+ break;
+ }
+ SET_LABEL(p, hdr);
+
+ MATHB(p, DPOVRD, AND, IPSEC_N_ENCAP_DPOVRD_L2_COPY, NONE, 4, IMMED2);
+ pl2copy = JUMP(p, l2copy, LOCAL_JUMP, ALL_TRUE, MATH_Z);
+ MATHI(p, DPOVRD, RSHIFT, IPSEC_N_ENCAP_DPOVRD_L2_LEN_SHIFT, VSEQOUTSZ,
+ 1, 0);
+ MATHB(p, DPOVRD, AND, ~IPSEC_N_ENCAP_DPOVRD_L2_LEN_MASK, DPOVRD, 4,
+ IMMED2);
+ /* TODO: CLASS2 corresponds to AUX=2'b10; add more intuitive defines */
+ SEQFIFOSTORE(p, METADATA, 0, 0, CLASS2 | VLF);
+ SET_LABEL(p, l2copy);
+
+ pkeyjmp = JUMP(p, keyjmp, LOCAL_JUMP, ALL_TRUE, SHRD);
+ if (authdata->keylen)
+ __gen_auth_key(p, authdata);
+ if (cipherdata->keylen)
+ KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
+ cipherdata->keylen, INLINE_KEY(cipherdata));
+ SET_LABEL(p, keyjmp);
+ PROTOCOL(p, OP_TYPE_ENCAP_PROTOCOL,
+ OP_PCLID_IPSEC_NEW,
+ (uint16_t)(cipherdata->algtype | authdata->algtype));
+ PATCH_JUMP(p, pl2copy, l2copy);
+ PATCH_JUMP(p, pkeyjmp, keyjmp);
+ PATCH_HDR(p, phdr, hdr);
+ return PROGRAM_FINALIZE(p);
+}
+
+/**
+ * IPSEC_NEW_DEC_BASE_DESC_LEN - IPsec new mode decap shared descriptor length
+ *
+ * Accounts only for the "base" commands and is intended to be used by upper
+ * layers to determine whether keys can be inlined or not. To be used as first
+ * parameter of rta_inline_query().
+ */
+#define IPSEC_NEW_DEC_BASE_DESC_LEN (5 * CAAM_CMD_SZ + \
+ sizeof(struct ipsec_decap_pdb))
+
+/**
+ * IPSEC_NEW_NULL_DEC_BASE_DESC_LEN - IPsec new mode decap shared descriptor
+ * length for the case of
+ * NULL decryption / authentication
+ *
+ * Accounts only for the "base" commands and is intended to be used by upper
+ * layers to determine whether key can be inlined or not. To be used as first
+ * parameter of rta_inline_query().
+ */
+#define IPSEC_NEW_NULL_DEC_BASE_DESC_LEN (4 * CAAM_CMD_SZ + \
+ sizeof(struct ipsec_decap_pdb))
+
+/**
+ * cnstr_shdsc_ipsec_new_decap - IPSec new mode ESP decapsulation protocol-level
+ * shared descriptor.
+ * @descbuf: pointer to buffer used for descriptor construction
+ * @ps: if 36/40bit addressing is desired, this parameter must be true
+ * @swap: must be true when core endianness doesn't match SEC endianness
+ * @share: sharing type of shared descriptor
+ * @pdb: pointer to the PDB to be used with this descriptor
+ * This structure will be copied inline to the descriptor under
+ * construction. No error checking will be made. Refer to the
+ * block guide for details about the decapsulation PDB.
+ * @cipherdata: pointer to block cipher transform definitions
+ * Valid algorithm values 0 one of OP_PCL_IPSEC_*
+ * @authdata: pointer to authentication transform definitions.
+ * If an authentication key is required by the protocol, a "normal"
+ * key must be provided; DKP (Derived Key Protocol) will be used to
+ * compute MDHA on the fly in HW.
+ * Valid algorithm values - one of OP_PCL_IPSEC_*
+ *
+ * Return: size of descriptor written in words or negative number on error
+ */
+static inline int
+cnstr_shdsc_ipsec_new_decap(uint32_t *descbuf, bool ps,
+ bool swap,
+ enum rta_share_type share,
+ struct ipsec_decap_pdb *pdb,
+ struct alginfo *cipherdata,
+ struct alginfo *authdata)
+{
+ struct program prg;
+ struct program *p = &prg;
+
+ LABEL(keyjmp);
+ REFERENCE(pkeyjmp);
+ LABEL(hdr);
+ REFERENCE(phdr);
+
+ if (rta_sec_era < RTA_SEC_ERA_8) {
+ pr_err("IPsec new mode decap: available only for Era %d or above\n",
+ USER_SEC_ERA(RTA_SEC_ERA_8));
+ return -ENOTSUP;
+ }
+
+ PROGRAM_CNTXT_INIT(p, descbuf, 0);
+ if (swap)
+ PROGRAM_SET_BSWAP(p);
+ if (ps)
+ PROGRAM_SET_36BIT_ADDR(p);
+ phdr = SHR_HDR(p, share, hdr, 0);
+ __rta_copy_ipsec_decap_pdb(p, pdb, cipherdata->algtype);
+ SET_LABEL(p, hdr);
+ pkeyjmp = JUMP(p, keyjmp, LOCAL_JUMP, ALL_TRUE, SHRD);
+ if (authdata->keylen)
+ __gen_auth_key(p, authdata);
+ if (cipherdata->keylen)
+ KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
+ cipherdata->keylen, INLINE_KEY(cipherdata));
+ SET_LABEL(p, keyjmp);
+ PROTOCOL(p, OP_TYPE_DECAP_PROTOCOL,
+ OP_PCLID_IPSEC_NEW,
+ (uint16_t)(cipherdata->algtype | authdata->algtype));
+ PATCH_JUMP(p, pkeyjmp, keyjmp);
+ PATCH_HDR(p, phdr, hdr);
+ return PROGRAM_FINALIZE(p);
+}
+
+/**
+ * IPSEC_AUTH_VAR_BASE_DESC_LEN - IPsec encap/decap shared descriptor length
+ * for the case of variable-length authentication
+ * only data.
+ * Note: Only for SoCs with SEC_ERA >= 3.
+ *
+ * Accounts only for the "base" commands and is intended to be used by upper
+ * layers to determine whether keys can be inlined or not. To be used as first
+ * parameter of rta_inline_query().
+ */
+#define IPSEC_AUTH_VAR_BASE_DESC_LEN (27 * CAAM_CMD_SZ)
+
+/**
+ * IPSEC_AUTH_VAR_AES_DEC_BASE_DESC_LEN - IPsec AES decap shared descriptor
+ * length for variable-length authentication only
+ * data.
+ * Note: Only for SoCs with SEC_ERA >= 3.
+ *
+ * Accounts only for the "base" commands and is intended to be used by upper
+ * layers to determine whether key can be inlined or not. To be used as first
+ * parameter of rta_inline_query().
+ */
+#define IPSEC_AUTH_VAR_AES_DEC_BASE_DESC_LEN \
+ (IPSEC_AUTH_VAR_BASE_DESC_LEN + CAAM_CMD_SZ)
+
+/**
+ * IPSEC_AUTH_BASE_DESC_LEN - IPsec encap/decap shared descriptor length
+ *
+ * Accounts only for the "base" commands and is intended to be used by upper
+ * layers to determine whether key can be inlined or not. To be used as first
+ * parameter of rta_inline_query().
+ */
+#define IPSEC_AUTH_BASE_DESC_LEN (19 * CAAM_CMD_SZ)
+
+/**
+ * IPSEC_AUTH_AES_DEC_BASE_DESC_LEN - IPsec AES decap shared descriptor length
+ *
+ * Accounts only for the "base" commands and is intended to be used by upper
+ * layers to determine whether key can be inlined or not. To be used as first
+ * parameter of rta_inline_query().
+ */
+#define IPSEC_AUTH_AES_DEC_BASE_DESC_LEN (IPSEC_AUTH_BASE_DESC_LEN + \
+ CAAM_CMD_SZ)
+
+/**
+ * cnstr_shdsc_authenc - authenc-like descriptor
+ * @descbuf: pointer to buffer used for descriptor construction
+ * @ps: if 36/40bit addressing is desired, this parameter must be true
+ * @swap: if true, perform descriptor byte swapping on a 4-byte boundary
+ * @share: sharing type of shared descriptor
+ * @cipherdata: pointer to block cipher transform definitions.
+ * Valid algorithm values one of OP_ALG_ALGSEL_* {DES, 3DES, AES}
+ * Valid modes for:
+ * AES: OP_ALG_AAI_* {CBC, CTR}
+ * DES, 3DES: OP_ALG_AAI_CBC
+ * @authdata: pointer to authentication transform definitions.
+ * Valid algorithm values - one of OP_ALG_ALGSEL_* {MD5, SHA1,
+ * SHA224, SHA256, SHA384, SHA512}
+ * Note: The key for authentication is supposed to be given as plain text.
+ * Note: There's no support for keys longer than the block size of the
+ * underlying hash function, according to the selected algorithm.
+ *
+ * @ivlen: length of the IV to be read from the input frame, before any data
+ * to be processed
+ *
+ * @trunc_len: the length of the ICV to be written to the output frame. If 0,
+ * then the corresponding length of the digest, according to the
+ * selected algorithm shall be used.
+ * @dir: Protocol direction, encapsulation or decapsulation (DIR_ENC/DIR_DEC)
+ *
+ * Note: Here's how the input frame needs to be formatted so that the processing
+ * will be done correctly:
+ * For encapsulation:
+ * Input:
+ * +----+----------------+-----------------------------------------------+
+ * | IV | Auth-only head | Padded data to be auth & Enc | Auth-only tail |
+ * +----+----------------+-----------------------------------------------+
+ * Output:
+ * +--------------------------------------+
+ * | Authenticated & Encrypted data | ICV |
+ * +--------------------------------+-----+
+ *
+ * For decapsulation:
+ * Input:
+ * +----+----------------+-----------------+----------------------+
+ * | IV | Auth-only head | Auth & Enc data | Auth-only tail | ICV |
+ * +----+----------------+-----------------+----------------------+
+ * Output:
+ * +----+---------------------------+
+ * | Decrypted & authenticated data |
+ * +----+---------------------------+
+ *
+ * Note: This descriptor can use per-packet commands, encoded as below in the
+ * DPOVRD register:
+ * 32 28 16 1
+ * +------+------------------------------+
+ * | 0x8 | auth_tail_len | auth_hdr_len |
+ * +------+------------------------------+
+ *
+ * This mechanism is available only for SoCs having SEC ERA >= 3. In other
+ * words, this will not work for P4080TO2
+ *
+ * Note: The descriptor does not add any kind of padding to the input data,
+ * so the upper layer needs to ensure that the data is padded properly,
+ * according to the selected cipher. Failure to do so will result in
+ * the descriptor failing with a data-size error.
+ *
+ * Return: size of descriptor written in words or negative number on error
+ */
+static inline int
+cnstr_shdsc_authenc(uint32_t *descbuf, bool ps, bool swap,
+ enum rta_share_type share,
+ struct alginfo *cipherdata,
+ struct alginfo *authdata,
+ uint16_t ivlen,
+ uint8_t trunc_len, uint8_t dir)
+{
+ struct program prg;
+ struct program *p = &prg;
+ const bool need_dk = (dir == DIR_DEC) &&
+ (cipherdata->algtype == OP_ALG_ALGSEL_AES) &&
+ (cipherdata->algmode == OP_ALG_AAI_CBC);
+ int data_type;
+
+ LABEL(keyjmp);
+ LABEL(skipkeys);
+ LABEL(proc_icv);
+ LABEL(no_auth_tail);
+ REFERENCE(pkeyjmp);
+ REFERENCE(pskipkeys);
+ REFERENCE(p_proc_icv);
+ REFERENCE(p_no_auth_tail);
+
+ PROGRAM_CNTXT_INIT(p, descbuf, 0);
+
+ if (swap)
+ PROGRAM_SET_BSWAP(p);
+ if (ps)
+ PROGRAM_SET_36BIT_ADDR(p);
+
+ /*
+ * Since we currently assume that key length is equal to hash digest
+ * size, it's ok to truncate keylen value.
+ */
+ trunc_len = trunc_len && (trunc_len < authdata->keylen) ?
+ trunc_len : (uint8_t)authdata->keylen;
+
+ SHR_HDR(p, share, 1, SC);
+
+ /* Collect the (auth_tail || auth_hdr) len from DPOVRD */
+ MATHB(p, DPOVRD, ADD, 0x80000000, MATH2, 4, IMMED2);
+
+ /* Get auth_hdr len in MATH0 */
+ MATHB(p, MATH2, AND, 0xFFFF, MATH0, 4, IMMED2);
+
+ /* Get auth_tail len in MATH2 */
+ MATHB(p, MATH2, AND, 0xFFF0000, MATH2, 4, IMMED2);
+ MATHI(p, MATH2, RSHIFT, 16, MATH2, 4, IMMED2);
+
+ pkeyjmp = JUMP(p, keyjmp, LOCAL_JUMP, ALL_TRUE, SHRD);
+
+ KEY(p, KEY2, authdata->key_enc_flags, authdata->key, authdata->keylen,
+ INLINE_KEY(authdata));
+
+ /* Insert Key */
+ KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
+ cipherdata->keylen, INLINE_KEY(cipherdata));
+
+ /* Do operation */
+ ALG_OPERATION(p, authdata->algtype, OP_ALG_AAI_HMAC,
+ OP_ALG_AS_INITFINAL,
+ dir == DIR_ENC ? ICV_CHECK_DISABLE : ICV_CHECK_ENABLE,
+ dir);
+
+ if (need_dk)
+ ALG_OPERATION(p, OP_ALG_ALGSEL_AES, cipherdata->algmode,
+ OP_ALG_AS_INITFINAL, ICV_CHECK_DISABLE, dir);
+ pskipkeys = JUMP(p, skipkeys, LOCAL_JUMP, ALL_TRUE, 0);
+
+ SET_LABEL(p, keyjmp);
+
+ ALG_OPERATION(p, authdata->algtype, OP_ALG_AAI_HMAC_PRECOMP,
+ OP_ALG_AS_INITFINAL,
+ dir == DIR_ENC ? ICV_CHECK_DISABLE : ICV_CHECK_ENABLE,
+ dir);
+
+ if (need_dk) {
+ ALG_OPERATION(p, OP_ALG_ALGSEL_AES, cipherdata->algmode |
+ OP_ALG_AAI_DK, OP_ALG_AS_INITFINAL,
+ ICV_CHECK_DISABLE, dir);
+ SET_LABEL(p, skipkeys);
+ } else {
+ SET_LABEL(p, skipkeys);
+ ALG_OPERATION(p, cipherdata->algtype, cipherdata->algmode,
+ OP_ALG_AS_INITFINAL, ICV_CHECK_DISABLE, dir);
+ }
+
+ /* Read IV */
+ if (cipherdata->algmode == OP_ALG_AAI_CTR)
+ SEQLOAD(p, CONTEXT1, 16, ivlen, 0);
+ else
+ SEQLOAD(p, CONTEXT1, 0, ivlen, 0);
+
+ /*
+ * authenticate auth_hdr data
+ */
+ MATHB(p, MATH0, ADD, ZERO, VSEQINSZ, 4, 0);
+ SEQFIFOLOAD(p, MSG2, 0, VLF);
+
+ /*
+ * Prepare the length of the data to be both encrypted/decrypted
+ * and authenticated/checked
+ */
+ MATHB(p, SEQINSZ, SUB, MATH2, VSEQINSZ, 4, 0);
+ if (dir == DIR_DEC) {
+ MATHB(p, VSEQINSZ, SUB, trunc_len, VSEQINSZ, 4, IMMED2);
+ data_type = MSGINSNOOP;
+ } else {
+ data_type = MSGOUTSNOOP;
+ }
+
+ MATHB(p, VSEQINSZ, ADD, ZERO, VSEQOUTSZ, 4, 0);
+
+ /* Prepare for writing the output frame */
+ SEQFIFOSTORE(p, MSG, 0, 0, VLF);
+
+
+ /* Check if there is no auth-tail */
+ MATHB(p, MATH2, ADD, ZERO, MATH2, 4, 0);
+ p_no_auth_tail = JUMP(p, no_auth_tail, LOCAL_JUMP, ALL_TRUE, MATH_Z);
+
+ /*
+ * Read input plain/cipher text, encrypt/decrypt & auth & write
+ * to output
+ */
+ SEQFIFOLOAD(p, data_type, 0, VLF | LAST1 | FLUSH1);
+
+ /* Authenticate auth tail */
+ MATHB(p, MATH2, ADD, ZERO, VSEQINSZ, 4, 0);
+ SEQFIFOLOAD(p, MSG2, 0, VLF | LAST2);
+
+ /* Jump to process icv */
+ p_proc_icv = JUMP(p, proc_icv, LOCAL_JUMP, ALL_FALSE, MATH_Z);
+
+ SET_LABEL(p, no_auth_tail);
+
+ SEQFIFOLOAD(p, data_type, 0, VLF | LAST1 | LAST2 | FLUSH1);
+
+ SET_LABEL(p, proc_icv);
+
+ if (dir == DIR_ENC)
+ /* Finally, write the ICV */
+ SEQSTORE(p, CONTEXT2, 0, trunc_len, 0);
+ else
+ /* Read the ICV to check */
+ SEQFIFOLOAD(p, ICV2, trunc_len, LAST2);
+
+ PATCH_JUMP(p, pkeyjmp, keyjmp);
+ PATCH_JUMP(p, pskipkeys, skipkeys);
+ PATCH_JUMP(p, p_no_auth_tail, no_auth_tail);
+ PATCH_JUMP(p, p_proc_icv, proc_icv);
+ return PROGRAM_FINALIZE(p);
+}
+
+#endif /* __DESC_IPSEC_H__ */
--- /dev/null
+/* SPDX-License-Identifier: BSD-3-Clause or GPL-2.0+
+ * Copyright 2008-2013 Freescale Semiconductor, Inc.
+ * Copyright 2019 NXP
+ */
+
+#ifndef __DESC_PDCP_H__
+#define __DESC_PDCP_H__
+
+#include "rta.h"
+#include "common.h"
+
+/**
+ * DOC: PDCP Shared Descriptor Constructors
+ *
+ * Shared descriptors for PDCP protocol.
+ */
+
+/**
+ * PDCP_NULL_MAX_FRAME_LEN - The maximum frame frame length that is supported by
+ * PDCP NULL protocol.
+ */
+#define PDCP_NULL_MAX_FRAME_LEN 0x00002FFF
+
+/**
+ * PDCP_MAC_I_LEN - The length of the MAC-I for PDCP protocol operation
+ */
+#define PDCP_MAC_I_LEN 0x00000004
+
+/**
+ * PDCP_MAX_FRAME_LEN_STATUS - The status returned in FD status/command field in
+ * case the input frame is larger than
+ * PDCP_NULL_MAX_FRAME_LEN.
+ */
+#define PDCP_MAX_FRAME_LEN_STATUS 0xF1
+
+/**
+ * PDCP_C_PLANE_SN_MASK - This mask is used in the PDCP descriptors for
+ * extracting the sequence number (SN) from the PDCP
+ * Control Plane header. For PDCP Control Plane, the SN
+ * is constant (5 bits) as opposed to PDCP Data Plane
+ * (7/12/15 bits).
+ */
+#define PDCP_C_PLANE_SN_MASK 0x1F000000
+#define PDCP_C_PLANE_SN_MASK_BE 0x0000001F
+
+/**
+ * PDCP_12BIT_SN_MASK - This mask is used in the PDCP descriptors for
+ * extracting the sequence number (SN) from the
+ * PDCP User Plane header.
+ */
+#define PDCP_12BIT_SN_MASK 0xFF0F0000
+#define PDCP_12BIT_SN_MASK_BE 0x00000FFF
+
+/**
+ * PDCP_U_PLANE_15BIT_SN_MASK - This mask is used in the PDCP descriptors for
+ * extracting the sequence number (SN) from the
+ * PDCP User Plane header. For PDCP Control Plane,
+ * the SN is constant (5 bits) as opposed to PDCP
+ * Data Plane (7/12/15 bits).
+ */
+#define PDCP_U_PLANE_15BIT_SN_MASK 0xFF7F0000
+#define PDCP_U_PLANE_15BIT_SN_MASK_BE 0x00007FFF
+
+/**
+ * PDCP_U_PLANE_18BIT_SN_MASK - This mask is used in the PDCP descriptors for
+ * extracting the sequence number (SN) from the
+ * PDCP User Plane header.
+ */
+#define PDCP_U_PLANE_18BIT_SN_MASK 0xFFFF0300
+#define PDCP_U_PLANE_18BIT_SN_MASK_BE 0x0003FFFF
+
+/**
+ * PDCP_BEARER_MASK - This mask is used masking out the bearer for PDCP
+ * processing with SNOW f9 in LTE.
+ *
+ * The value on which this mask is applied is formatted as below:
+ * Count-C (32 bit) | Bearer (5 bit) | Direction (1 bit) | 0 (26 bits)
+ *
+ * Applying this mask is done for creating the upper 64 bits of the IV needed
+ * for SNOW f9.
+ *
+ * The lower 32 bits of the mask are used for masking the direction for AES
+ * CMAC IV.
+ */
+#define PDCP_BEARER_MASK 0x00000004FFFFFFFFull
+#define PDCP_BEARER_MASK_BE 0xFFFFFFFF04000000ull
+
+/**
+ * PDCP_DIR_MASK - This mask is used masking out the direction for PDCP
+ * processing with SNOW f9 in LTE.
+ *
+ * The value on which this mask is applied is formatted as below:
+ * Bearer (5 bit) | Direction (1 bit) | 0 (26 bits)
+ *
+ * Applying this mask is done for creating the lower 32 bits of the IV needed
+ * for SNOW f9.
+ *
+ * The upper 32 bits of the mask are used for masking the direction for AES
+ * CMAC IV.
+ */
+#define PDCP_DIR_MASK 0x00000000000000F8ull
+#define PDCP_DIR_MASK_BE 0xF800000000000000ull
+
+/**
+ * PDCP_NULL_INT_MAC_I_VAL - The value of the PDCP PDU MAC-I in case NULL
+ * integrity is used.
+ */
+
+#define PDCP_NULL_INT_MAC_I_VAL 0x00000000
+
+/**
+ * PDCP_NULL_INT_ICV_CHECK_FAILED_STATUS - The status used to report ICV check
+ * failed in case of NULL integrity
+ * Control Plane processing.
+ */
+#define PDCP_NULL_INT_ICV_CHECK_FAILED_STATUS 0x0A
+/**
+ * PDCP_DPOVRD_HFN_OV_EN - Value to be used in the FD status/cmd field to
+ * indicate the HFN override mechanism is active for the
+ * frame.
+ */
+#define PDCP_DPOVRD_HFN_OV_EN 0x80000000
+
+/**
+ * PDCP_P4080REV2_HFN_OV_BUFLEN - The length in bytes of the supplementary space
+ * that must be provided by the user at the
+ * beginning of the input frame buffer for
+ * P4080 REV 2.
+ *
+ * The format of the frame buffer is the following:
+ *
+ * |<---PDCP_P4080REV2_HFN_OV_BUFLEN-->|
+ * //===================================||============||==============\\
+ * || PDCP_DPOVRD_HFN_OV_EN | HFN value || PDCP Header|| PDCP Payload ||
+ * \\===================================||============||==============//
+ *
+ * If HFN override mechanism is not desired, then the MSB of the first 4 bytes
+ * must be set to 0b.
+ */
+#define PDCP_P4080REV2_HFN_OV_BUFLEN 4
+
+/**
+ * enum cipher_type_pdcp - Type selectors for cipher types in PDCP protocol OP
+ * instructions.
+ * @PDCP_CIPHER_TYPE_NULL: NULL
+ * @PDCP_CIPHER_TYPE_SNOW: SNOW F8
+ * @PDCP_CIPHER_TYPE_AES: AES
+ * @PDCP_CIPHER_TYPE_ZUC: ZUCE
+ * @PDCP_CIPHER_TYPE_INVALID: invalid option
+ */
+enum cipher_type_pdcp {
+ PDCP_CIPHER_TYPE_NULL,
+ PDCP_CIPHER_TYPE_SNOW,
+ PDCP_CIPHER_TYPE_AES,
+ PDCP_CIPHER_TYPE_ZUC,
+ PDCP_CIPHER_TYPE_INVALID
+};
+
+/**
+ * enum auth_type_pdcp - Type selectors for integrity types in PDCP protocol OP
+ * instructions.
+ * @PDCP_AUTH_TYPE_NULL: NULL
+ * @PDCP_AUTH_TYPE_SNOW: SNOW F9
+ * @PDCP_AUTH_TYPE_AES: AES CMAC
+ * @PDCP_AUTH_TYPE_ZUC: ZUCA
+ * @PDCP_AUTH_TYPE_INVALID: invalid option
+ */
+enum auth_type_pdcp {
+ PDCP_AUTH_TYPE_NULL,
+ PDCP_AUTH_TYPE_SNOW,
+ PDCP_AUTH_TYPE_AES,
+ PDCP_AUTH_TYPE_ZUC,
+ PDCP_AUTH_TYPE_INVALID
+};
+
+/**
+ * enum pdcp_dir - Type selectors for direction for PDCP protocol
+ * @PDCP_DIR_UPLINK: uplink direction
+ * @PDCP_DIR_DOWNLINK: downlink direction
+ * @PDCP_DIR_INVALID: invalid option
+ */
+enum pdcp_dir {
+ PDCP_DIR_UPLINK = 0,
+ PDCP_DIR_DOWNLINK = 1,
+ PDCP_DIR_INVALID
+};
+
+/**
+ * enum pdcp_plane - PDCP domain selectors
+ * @PDCP_CONTROL_PLANE: Control Plane
+ * @PDCP_DATA_PLANE: Data Plane
+ * @PDCP_SHORT_MAC: Short MAC
+ */
+enum pdcp_plane {
+ PDCP_CONTROL_PLANE,
+ PDCP_DATA_PLANE,
+ PDCP_SHORT_MAC
+};
+
+/**
+ * enum pdcp_sn_size - Sequence Number Size selectors for PDCP protocol
+ * @PDCP_SN_SIZE_5: 5bit sequence number
+ * @PDCP_SN_SIZE_7: 7bit sequence number
+ * @PDCP_SN_SIZE_12: 12bit sequence number
+ * @PDCP_SN_SIZE_15: 15bit sequence number
+ * @PDCP_SN_SIZE_18: 18bit sequence number
+ */
+enum pdcp_sn_size {
+ PDCP_SN_SIZE_5 = 5,
+ PDCP_SN_SIZE_7 = 7,
+ PDCP_SN_SIZE_12 = 12,
+ PDCP_SN_SIZE_15 = 15,
+ PDCP_SN_SIZE_18 = 18
+};
+
+/*
+ * PDCP Control Plane Protocol Data Blocks
+ */
+#define PDCP_C_PLANE_PDB_HFN_SHIFT 5
+#define PDCP_C_PLANE_PDB_BEARER_SHIFT 27
+#define PDCP_C_PLANE_PDB_DIR_SHIFT 26
+#define PDCP_C_PLANE_PDB_HFN_THR_SHIFT 5
+
+#define PDCP_U_PLANE_PDB_OPT_SHORT_SN 0x2
+#define PDCP_U_PLANE_PDB_OPT_15B_SN 0x4
+#define PDCP_U_PLANE_PDB_OPT_18B_SN 0x6
+#define PDCP_U_PLANE_PDB_SHORT_SN_HFN_SHIFT 7
+#define PDCP_U_PLANE_PDB_LONG_SN_HFN_SHIFT 12
+#define PDCP_U_PLANE_PDB_15BIT_SN_HFN_SHIFT 15
+#define PDCP_U_PLANE_PDB_18BIT_SN_HFN_SHIFT 18
+#define PDCP_U_PLANE_PDB_BEARER_SHIFT 27
+#define PDCP_U_PLANE_PDB_DIR_SHIFT 26
+#define PDCP_U_PLANE_PDB_SHORT_SN_HFN_THR_SHIFT 7
+#define PDCP_U_PLANE_PDB_LONG_SN_HFN_THR_SHIFT 12
+#define PDCP_U_PLANE_PDB_15BIT_SN_HFN_THR_SHIFT 15
+#define PDCP_U_PLANE_PDB_18BIT_SN_HFN_THR_SHIFT 18
+
+struct pdcp_pdb {
+ union {
+ uint32_t opt;
+ uint32_t rsvd;
+ } opt_res;
+ uint32_t hfn_res; /* HyperFrame number,(27, 25 or 21 bits),
+ * left aligned & right-padded with zeros.
+ */
+ uint32_t bearer_dir_res;/* Bearer(5 bits), packet direction (1 bit),
+ * left aligned & right-padded with zeros.
+ */
+ uint32_t hfn_thr_res; /* HyperFrame number threshold (27, 25 or 21
+ * bits), left aligned & right-padded with
+ * zeros.
+ */
+};
+
+/*
+ * PDCP internal PDB types
+ */
+enum pdb_type_e {
+ PDCP_PDB_TYPE_NO_PDB,
+ PDCP_PDB_TYPE_FULL_PDB,
+ PDCP_PDB_TYPE_REDUCED_PDB,
+ PDCP_PDB_TYPE_INVALID
+};
+
+/*
+ * Function for appending the portion of a PDCP Control Plane shared descriptor
+ * which performs NULL encryption and integrity (i.e. copies the input frame
+ * to the output frame, appending 32 bits of zeros at the end (MAC-I for
+ * NULL integrity).
+ */
+static inline int
+pdcp_insert_cplane_null_op(struct program *p,
+ bool swap __maybe_unused,
+ struct alginfo *cipherdata __maybe_unused,
+ struct alginfo *authdata __maybe_unused,
+ unsigned int dir,
+ enum pdcp_sn_size sn_size __maybe_unused,
+ unsigned char era_2_sw_hfn_ovrd __maybe_unused)
+{
+ LABEL(local_offset);
+ REFERENCE(move_cmd_read_descbuf);
+ REFERENCE(move_cmd_write_descbuf);
+
+ if (rta_sec_era > RTA_SEC_ERA_2) {
+ MATHB(p, SEQINSZ, ADD, ZERO, VSEQINSZ, 4, 0);
+ if (dir == OP_TYPE_ENCAP_PROTOCOL)
+ MATHB(p, SEQINSZ, ADD, PDCP_MAC_I_LEN, VSEQOUTSZ, 4,
+ IMMED2);
+ else
+ MATHB(p, SEQINSZ, SUB, PDCP_MAC_I_LEN, VSEQOUTSZ, 4,
+ IMMED2);
+ } else {
+ MATHB(p, SEQINSZ, ADD, ONE, VSEQINSZ, 4, 0);
+ MATHB(p, VSEQINSZ, SUB, ONE, VSEQINSZ, 4, 0);
+
+ if (dir == OP_TYPE_ENCAP_PROTOCOL) {
+ MATHB(p, SEQINSZ, ADD, PDCP_MAC_I_LEN, VSEQOUTSZ, 4,
+ IMMED2);
+ MATHB(p, VSEQINSZ, SUB, ONE, MATH0, 4, 0);
+ } else {
+ MATHB(p, VSEQINSZ, SUB, PDCP_MAC_I_LEN, VSEQINSZ, 4,
+ IMMED2);
+ MATHB(p, SEQINSZ, SUB, PDCP_MAC_I_LEN, VSEQOUTSZ, 4,
+ IMMED2);
+ MATHB(p, VSEQOUTSZ, SUB, ONE, MATH0, 4, 0);
+ }
+
+ MATHB(p, MATH0, ADD, ONE, MATH0, 4, 0);
+
+ /*
+ * Since MOVELEN is available only starting with
+ * SEC ERA 3, use poor man's MOVELEN: create a MOVE
+ * command dynamically by writing the length from M1 by
+ * OR-ing the command in the M1 register and MOVE the
+ * result into the descriptor buffer. Care must be taken
+ * wrt. the location of the command because of SEC
+ * pipelining. The actual MOVEs are written at the end
+ * of the descriptor due to calculations needed on the
+ * offset in the descriptor for the MOVE command.
+ */
+ move_cmd_read_descbuf = MOVE(p, DESCBUF, 0, MATH0, 0, 6,
+ IMMED);
+ move_cmd_write_descbuf = MOVE(p, MATH0, 0, DESCBUF, 0, 8,
+ WAITCOMP | IMMED);
+ }
+ MATHB(p, VSEQINSZ, SUB, PDCP_NULL_MAX_FRAME_LEN, NONE, 4,
+ IMMED2);
+ JUMP(p, PDCP_MAX_FRAME_LEN_STATUS, HALT_STATUS, ALL_FALSE, MATH_N);
+
+ if (rta_sec_era > RTA_SEC_ERA_2) {
+ if (dir == OP_TYPE_ENCAP_PROTOCOL)
+ MATHB(p, VSEQINSZ, ADD, ZERO, MATH0, 4, 0);
+ else
+ MATHB(p, VSEQOUTSZ, ADD, ZERO, MATH0, 4, 0);
+ }
+ SEQFIFOSTORE(p, MSG, 0, 0, VLF);
+ SEQFIFOLOAD(p, MSG1, 0, VLF | LAST1 | FLUSH1);
+
+ if (rta_sec_era > RTA_SEC_ERA_2) {
+ MOVE(p, AB1, 0, OFIFO, 0, MATH0, 0);
+ } else {
+ SET_LABEL(p, local_offset);
+
+ /* Shut off automatic Info FIFO entries */
+ LOAD(p, 0, DCTRL, LDOFF_DISABLE_AUTO_NFIFO, 0, IMMED);
+ /* Placeholder for MOVE command with length from M1 register */
+ MOVE(p, IFIFOAB1, 0, OFIFO, 0, 0, IMMED);
+ /* Enable automatic Info FIFO entries */
+ LOAD(p, 0, DCTRL, LDOFF_ENABLE_AUTO_NFIFO, 0, IMMED);
+ }
+
+ if (dir == OP_TYPE_ENCAP_PROTOCOL) {
+ MATHB(p, MATH1, XOR, MATH1, MATH0, 8, 0);
+ MOVE(p, MATH0, 0, OFIFO, 0, 4, IMMED);
+ }
+
+ if (rta_sec_era < RTA_SEC_ERA_3) {
+ PATCH_MOVE(p, move_cmd_read_descbuf, local_offset);
+ PATCH_MOVE(p, move_cmd_write_descbuf, local_offset);
+ }
+
+ return 0;
+}
+
+static inline int
+insert_copy_frame_op(struct program *p,
+ struct alginfo *cipherdata __maybe_unused,
+ unsigned int dir __maybe_unused)
+{
+ LABEL(local_offset);
+ REFERENCE(move_cmd_read_descbuf);
+ REFERENCE(move_cmd_write_descbuf);
+
+ if (rta_sec_era > RTA_SEC_ERA_2) {
+ MATHB(p, SEQINSZ, ADD, ZERO, VSEQINSZ, 4, 0);
+ MATHB(p, SEQINSZ, ADD, ZERO, VSEQOUTSZ, 4, 0);
+ } else {
+ MATHB(p, SEQINSZ, ADD, ONE, VSEQINSZ, 4, 0);
+ MATHB(p, VSEQINSZ, SUB, ONE, VSEQINSZ, 4, 0);
+ MATHB(p, SEQINSZ, ADD, ONE, VSEQOUTSZ, 4, 0);
+ MATHB(p, VSEQOUTSZ, SUB, ONE, VSEQOUTSZ, 4, 0);
+ MATHB(p, VSEQINSZ, SUB, ONE, MATH0, 4, 0);
+ MATHB(p, MATH0, ADD, ONE, MATH0, 4, 0);
+
+ /*
+ * Since MOVELEN is available only starting with
+ * SEC ERA 3, use poor man's MOVELEN: create a MOVE
+ * command dynamically by writing the length from M1 by
+ * OR-ing the command in the M1 register and MOVE the
+ * result into the descriptor buffer. Care must be taken
+ * wrt. the location of the command because of SEC
+ * pipelining. The actual MOVEs are written at the end
+ * of the descriptor due to calculations needed on the
+ * offset in the descriptor for the MOVE command.
+ */
+ move_cmd_read_descbuf = MOVE(p, DESCBUF, 0, MATH0, 0, 6,
+ IMMED);
+ move_cmd_write_descbuf = MOVE(p, MATH0, 0, DESCBUF, 0, 8,
+ WAITCOMP | IMMED);
+ }
+ MATHB(p, SEQINSZ, SUB, PDCP_NULL_MAX_FRAME_LEN, NONE, 4,
+ IFB | IMMED2);
+ JUMP(p, PDCP_MAX_FRAME_LEN_STATUS, HALT_STATUS, ALL_FALSE, MATH_N);
+
+ if (rta_sec_era > RTA_SEC_ERA_2)
+ MATHB(p, VSEQINSZ, ADD, ZERO, MATH0, 4, 0);
+
+ SEQFIFOLOAD(p, MSG1, 0, VLF | LAST1 | FLUSH1);
+ if (rta_sec_era > RTA_SEC_ERA_2) {
+ MOVE(p, AB1, 0, OFIFO, 0, MATH0, 0);
+ } else {
+ SET_LABEL(p, local_offset);
+
+ /* Shut off automatic Info FIFO entries */
+ LOAD(p, 0, DCTRL, LDOFF_DISABLE_AUTO_NFIFO, 0, IMMED);
+
+ /* Placeholder for MOVE command with length from M0 register */
+ MOVE(p, IFIFOAB1, 0, OFIFO, 0, 0, IMMED);
+
+ /* Enable automatic Info FIFO entries */
+ LOAD(p, 0, DCTRL, LDOFF_ENABLE_AUTO_NFIFO, 0, IMMED);
+ }
+
+ SEQFIFOSTORE(p, MSG, 0, 0, VLF);
+
+ if (rta_sec_era < RTA_SEC_ERA_3) {
+ PATCH_MOVE(p, move_cmd_read_descbuf, local_offset);
+ PATCH_MOVE(p, move_cmd_write_descbuf, local_offset);
+ }
+ return 0;
+}
+
+static inline int
+pdcp_insert_cplane_int_only_op(struct program *p,
+ bool swap __maybe_unused,
+ struct alginfo *cipherdata __maybe_unused,
+ struct alginfo *authdata, unsigned int dir,
+ enum pdcp_sn_size sn_size,
+ unsigned char era_2_sw_hfn_ovrd)
+{
+ uint32_t offset = 0, length = 0, sn_mask = 0;
+
+ /* 12 bit SN is only supported for protocol offload case */
+ if (rta_sec_era >= RTA_SEC_ERA_8 && sn_size == PDCP_SN_SIZE_12) {
+ KEY(p, KEY2, authdata->key_enc_flags, authdata->key,
+ authdata->keylen, INLINE_KEY(authdata));
+
+ PROTOCOL(p, dir, OP_PCLID_LTE_PDCP_USER_RN,
+ (uint16_t)authdata->algtype);
+ return 0;
+ }
+
+ /* Non-proto is supported only for 5bit cplane and 18bit uplane */
+ switch (sn_size) {
+ case PDCP_SN_SIZE_5:
+ offset = 7;
+ length = 1;
+ sn_mask = (swap == false) ? PDCP_C_PLANE_SN_MASK :
+ PDCP_C_PLANE_SN_MASK_BE;
+ break;
+ case PDCP_SN_SIZE_18:
+ offset = 5;
+ length = 3;
+ sn_mask = (swap == false) ? PDCP_U_PLANE_18BIT_SN_MASK :
+ PDCP_U_PLANE_18BIT_SN_MASK_BE;
+ break;
+ case PDCP_SN_SIZE_7:
+ case PDCP_SN_SIZE_12:
+ case PDCP_SN_SIZE_15:
+ pr_err("Invalid sn_size for %s\n", __func__);
+ return -ENOTSUP;
+
+ }
+ LABEL(local_offset);
+ REFERENCE(move_cmd_read_descbuf);
+ REFERENCE(move_cmd_write_descbuf);
+
+ switch (authdata->algtype) {
+ case PDCP_AUTH_TYPE_SNOW:
+ /* Insert Auth Key */
+ KEY(p, KEY2, authdata->key_enc_flags, authdata->key,
+ authdata->keylen, INLINE_KEY(authdata));
+ SEQLOAD(p, MATH0, offset, length, 0);
+ JUMP(p, 1, LOCAL_JUMP, ALL_TRUE, CALM);
+
+ if (rta_sec_era > RTA_SEC_ERA_2 ||
+ (rta_sec_era == RTA_SEC_ERA_2 &&
+ era_2_sw_hfn_ovrd == 0)) {
+ SEQINPTR(p, 0, length, RTO);
+ } else {
+ SEQINPTR(p, 0, 5, RTO);
+ SEQFIFOLOAD(p, SKIP, 4, 0);
+ }
+
+ if (swap == false) {
+ MATHB(p, MATH0, AND, sn_mask, MATH1, 8,
+ IFB | IMMED2);
+ MATHB(p, MATH1, SHLD, MATH1, MATH1, 8, 0);
+
+ MOVEB(p, DESCBUF, 8, MATH2, 0, 8, WAITCOMP | IMMED);
+
+ MATHB(p, MATH2, AND, PDCP_BEARER_MASK, MATH2, 8,
+ IMMED2);
+ MOVEB(p, DESCBUF, 0x0C, MATH3, 0, 4, WAITCOMP | IMMED);
+ MATHB(p, MATH3, AND, PDCP_DIR_MASK, MATH3, 8, IMMED2);
+ MATHB(p, MATH1, OR, MATH2, MATH2, 8, 0);
+ MOVEB(p, MATH2, 0, CONTEXT2, 0, 0x0C, WAITCOMP | IMMED);
+ } else {
+ MATHB(p, MATH0, AND, sn_mask, MATH1, 8,
+ IFB | IMMED2);
+ MATHB(p, MATH1, SHLD, MATH1, MATH1, 8, 0);
+
+ MOVE(p, DESCBUF, 8, MATH2, 0, 8, WAITCOMP | IMMED);
+ MATHB(p, MATH2, AND, PDCP_BEARER_MASK_BE, MATH2, 8,
+ IMMED2);
+
+ MOVE(p, DESCBUF, 0x0C, MATH3, 0, 4, WAITCOMP | IMMED);
+ MATHB(p, MATH3, AND, PDCP_DIR_MASK_BE, MATH3, 8,
+ IMMED2);
+ MATHB(p, MATH1, OR, MATH2, MATH2, 8, 0);
+ MOVE(p, MATH2, 0, CONTEXT2, 0, 0x0C, WAITCOMP | IMMED);
+ }
+
+ if (dir == OP_TYPE_DECAP_PROTOCOL) {
+ MATHB(p, SEQINSZ, SUB, PDCP_MAC_I_LEN, MATH1, 4,
+ IMMED2);
+ } else {
+ if (rta_sec_era > RTA_SEC_ERA_2) {
+ MATHB(p, SEQINSZ, SUB, ZERO, MATH1, 4,
+ 0);
+ } else {
+ MATHB(p, SEQINSZ, ADD, ONE, MATH1, 4,
+ 0);
+ MATHB(p, MATH1, SUB, ONE, MATH1, 4,
+ 0);
+ }
+ }
+
+ if (rta_sec_era > RTA_SEC_ERA_2) {
+ MATHB(p, MATH1, SUB, ZERO, VSEQINSZ, 4, 0);
+ MATHB(p, MATH1, SUB, ZERO, VSEQOUTSZ, 4, 0);
+ } else {
+ MATHB(p, ZERO, ADD, MATH1, VSEQINSZ, 4, 0);
+ MATHB(p, ZERO, ADD, MATH1, VSEQOUTSZ, 4, 0);
+
+ /*
+ * Since MOVELEN is available only starting with
+ * SEC ERA 3, use poor man's MOVELEN: create a MOVE
+ * command dynamically by writing the length from M1 by
+ * OR-ing the command in the M1 register and MOVE the
+ * result into the descriptor buffer. Care must be taken
+ * wrt. the location of the command because of SEC
+ * pipelining. The actual MOVEs are written at the end
+ * of the descriptor due to calculations needed on the
+ * offset in the descriptor for the MOVE command.
+ */
+ move_cmd_read_descbuf = MOVE(p, DESCBUF, 0, MATH1, 0, 6,
+ IMMED);
+ move_cmd_write_descbuf = MOVE(p, MATH1, 0, DESCBUF, 0,
+ 8, WAITCOMP | IMMED);
+ }
+
+ SEQFIFOSTORE(p, MSG, 0, 0, VLF);
+ ALG_OPERATION(p, OP_ALG_ALGSEL_SNOW_F9, OP_ALG_AAI_F9,
+ OP_ALG_AS_INITFINAL,
+ dir == OP_TYPE_ENCAP_PROTOCOL ?
+ ICV_CHECK_DISABLE : ICV_CHECK_ENABLE,
+ DIR_ENC);
+
+ if (rta_sec_era > RTA_SEC_ERA_2) {
+ SEQFIFOLOAD(p, MSGINSNOOP, 0,
+ VLF | LAST1 | LAST2 | FLUSH1);
+ MOVE(p, AB1, 0, OFIFO, 0, MATH1, 0);
+ } else {
+ SEQFIFOLOAD(p, MSGINSNOOP, 0,
+ VLF | LAST1 | LAST2 | FLUSH1);
+ SET_LABEL(p, local_offset);
+
+ /* Shut off automatic Info FIFO entries */
+ LOAD(p, 0, DCTRL, LDOFF_DISABLE_AUTO_NFIFO, 0, IMMED);
+ /*
+ * Placeholder for MOVE command with length from M1
+ * register
+ */
+ MOVE(p, IFIFOAB1, 0, OFIFO, 0, 0, IMMED);
+ /* Enable automatic Info FIFO entries */
+ LOAD(p, 0, DCTRL, LDOFF_ENABLE_AUTO_NFIFO, 0, IMMED);
+ }
+
+ if (dir == OP_TYPE_DECAP_PROTOCOL)
+ SEQFIFOLOAD(p, ICV2, 4, LAST2);
+ else
+ SEQSTORE(p, CONTEXT2, 0, 4, 0);
+
+ break;
+
+ case PDCP_AUTH_TYPE_AES:
+ /* Insert Auth Key */
+ KEY(p, KEY1, authdata->key_enc_flags, authdata->key,
+ authdata->keylen, INLINE_KEY(authdata));
+ SEQLOAD(p, MATH0, offset, length, 0);
+ JUMP(p, 1, LOCAL_JUMP, ALL_TRUE, CALM);
+ if (rta_sec_era > RTA_SEC_ERA_2 ||
+ (rta_sec_era == RTA_SEC_ERA_2 &&
+ era_2_sw_hfn_ovrd == 0)) {
+ SEQINPTR(p, 0, length, RTO);
+ } else {
+ SEQINPTR(p, 0, 5, RTO);
+ SEQFIFOLOAD(p, SKIP, 4, 0);
+ }
+
+ if (swap == false) {
+ MATHB(p, MATH0, AND, sn_mask, MATH1, 8,
+ IFB | IMMED2);
+ MATHB(p, MATH1, SHLD, MATH1, MATH1, 8, 0);
+
+ MOVEB(p, DESCBUF, 8, MATH2, 0, 8, WAITCOMP | IMMED);
+ MATHB(p, MATH1, OR, MATH2, MATH2, 8, 0);
+ MOVEB(p, MATH2, 0, IFIFOAB1, 0, 8, IMMED);
+ } else {
+ MATHB(p, MATH0, AND, sn_mask, MATH1, 8,
+ IFB | IMMED2);
+ MATHB(p, MATH1, SHLD, MATH1, MATH1, 8, 0);
+
+ MOVE(p, DESCBUF, 8, MATH2, 0, 8, WAITCOMP | IMMED);
+ MATHB(p, MATH1, OR, MATH2, MATH2, 8, 0);
+ MOVE(p, MATH2, 0, IFIFOAB1, 0, 8, IMMED);
+ }
+
+ if (dir == OP_TYPE_DECAP_PROTOCOL) {
+ MATHB(p, SEQINSZ, SUB, PDCP_MAC_I_LEN, MATH1, 4,
+ IMMED2);
+ } else {
+ if (rta_sec_era > RTA_SEC_ERA_2) {
+ MATHB(p, SEQINSZ, SUB, ZERO, MATH1, 4,
+ 0);
+ } else {
+ MATHB(p, SEQINSZ, ADD, ONE, MATH1, 4,
+ 0);
+ MATHB(p, MATH1, SUB, ONE, MATH1, 4,
+ 0);
+ }
+ }
+
+ if (rta_sec_era > RTA_SEC_ERA_2) {
+ MATHB(p, MATH1, SUB, ZERO, VSEQINSZ, 4, 0);
+ MATHB(p, MATH1, SUB, ZERO, VSEQOUTSZ, 4, 0);
+ } else {
+ MATHB(p, ZERO, ADD, MATH1, VSEQINSZ, 4, 0);
+ MATHB(p, ZERO, ADD, MATH1, VSEQOUTSZ, 4, 0);
+
+ /*
+ * Since MOVELEN is available only starting with
+ * SEC ERA 3, use poor man's MOVELEN: create a MOVE
+ * command dynamically by writing the length from M1 by
+ * OR-ing the command in the M1 register and MOVE the
+ * result into the descriptor buffer. Care must be taken
+ * wrt. the location of the command because of SEC
+ * pipelining. The actual MOVEs are written at the end
+ * of the descriptor due to calculations needed on the
+ * offset in the descriptor for the MOVE command.
+ */
+ move_cmd_read_descbuf = MOVE(p, DESCBUF, 0, MATH1, 0, 6,
+ IMMED);
+ move_cmd_write_descbuf = MOVE(p, MATH1, 0, DESCBUF, 0,
+ 8, WAITCOMP | IMMED);
+ }
+ SEQFIFOSTORE(p, MSG, 0, 0, VLF);
+ ALG_OPERATION(p, OP_ALG_ALGSEL_AES,
+ OP_ALG_AAI_CMAC,
+ OP_ALG_AS_INITFINAL,
+ dir == OP_TYPE_ENCAP_PROTOCOL ?
+ ICV_CHECK_DISABLE : ICV_CHECK_ENABLE,
+ DIR_ENC);
+
+ if (rta_sec_era > RTA_SEC_ERA_2) {
+ MOVE(p, AB2, 0, OFIFO, 0, MATH1, 0);
+ SEQFIFOLOAD(p, MSGINSNOOP, 0,
+ VLF | LAST1 | LAST2 | FLUSH1);
+ } else {
+ SEQFIFOLOAD(p, MSGINSNOOP, 0,
+ VLF | LAST1 | LAST2 | FLUSH1);
+ SET_LABEL(p, local_offset);
+
+ /* Shut off automatic Info FIFO entries */
+ LOAD(p, 0, DCTRL, LDOFF_DISABLE_AUTO_NFIFO, 0, IMMED);
+
+ /*
+ * Placeholder for MOVE command with length from
+ * M1 register
+ */
+ MOVE(p, IFIFOAB2, 0, OFIFO, 0, 0, IMMED);
+
+ /* Enable automatic Info FIFO entries */
+ LOAD(p, 0, DCTRL, LDOFF_ENABLE_AUTO_NFIFO, 0, IMMED);
+ }
+
+ if (dir == OP_TYPE_DECAP_PROTOCOL)
+ SEQFIFOLOAD(p, ICV1, 4, LAST1 | FLUSH1);
+ else
+ SEQSTORE(p, CONTEXT1, 0, 4, 0);
+
+ break;
+
+ case PDCP_AUTH_TYPE_ZUC:
+ if (rta_sec_era < RTA_SEC_ERA_5) {
+ pr_err("Invalid era for selected algorithm\n");
+ return -ENOTSUP;
+ }
+ /* Insert Auth Key */
+ KEY(p, KEY2, authdata->key_enc_flags, authdata->key,
+ authdata->keylen, INLINE_KEY(authdata));
+ SEQLOAD(p, MATH0, offset, length, 0);
+ JUMP(p, 1, LOCAL_JUMP, ALL_TRUE, CALM);
+ SEQINPTR(p, 0, length, RTO);
+ if (swap == false) {
+ MATHB(p, MATH0, AND, sn_mask, MATH1, 8,
+ IFB | IMMED2);
+ MATHB(p, MATH1, SHLD, MATH1, MATH1, 8, 0);
+
+ MOVEB(p, DESCBUF, 8, MATH2, 0, 8, WAITCOMP | IMMED);
+ MATHB(p, MATH1, OR, MATH2, MATH2, 8, 0);
+ MOVEB(p, MATH2, 0, CONTEXT2, 0, 8, IMMED);
+
+ } else {
+ MATHB(p, MATH0, AND, sn_mask, MATH1, 8,
+ IFB | IMMED2);
+ MATHB(p, MATH1, SHLD, MATH1, MATH1, 8, 0);
+
+ MOVE(p, DESCBUF, 8, MATH2, 0, 8, WAITCOMP | IMMED);
+ MATHB(p, MATH1, OR, MATH2, MATH2, 8, 0);
+ MOVE(p, MATH2, 0, CONTEXT2, 0, 8, IMMED);
+ }
+ if (dir == OP_TYPE_DECAP_PROTOCOL)
+ MATHB(p, SEQINSZ, SUB, PDCP_MAC_I_LEN, MATH1, 4,
+ IMMED2);
+ else
+ MATHB(p, SEQINSZ, SUB, ZERO, MATH1, 4, 0);
+
+ MATHB(p, MATH1, SUB, ZERO, VSEQINSZ, 4, 0);
+ MATHB(p, MATH1, SUB, ZERO, VSEQOUTSZ, 4, 0);
+ SEQFIFOSTORE(p, MSG, 0, 0, VLF);
+ ALG_OPERATION(p, OP_ALG_ALGSEL_ZUCA,
+ OP_ALG_AAI_F9,
+ OP_ALG_AS_INITFINAL,
+ dir == OP_TYPE_ENCAP_PROTOCOL ?
+ ICV_CHECK_DISABLE : ICV_CHECK_ENABLE,
+ DIR_ENC);
+ SEQFIFOLOAD(p, MSGINSNOOP, 0, VLF | LAST1 | LAST2 | FLUSH1);
+ MOVE(p, AB1, 0, OFIFO, 0, MATH1, 0);
+
+ if (dir == OP_TYPE_DECAP_PROTOCOL)
+ SEQFIFOLOAD(p, ICV2, 4, LAST2);
+ else
+ SEQSTORE(p, CONTEXT2, 0, 4, 0);
+
+ break;
+
+ default:
+ pr_err("%s: Invalid integrity algorithm selected: %d\n",
+ "pdcp_insert_cplane_int_only_op", authdata->algtype);
+ return -EINVAL;
+ }
+
+ if (rta_sec_era < RTA_SEC_ERA_3) {
+ PATCH_MOVE(p, move_cmd_read_descbuf, local_offset);
+ PATCH_MOVE(p, move_cmd_write_descbuf, local_offset);
+ }
+
+ return 0;
+}
+
+static inline int
+pdcp_insert_cplane_enc_only_op(struct program *p,
+ bool swap __maybe_unused,
+ struct alginfo *cipherdata,
+ struct alginfo *authdata __maybe_unused,
+ unsigned int dir,
+ enum pdcp_sn_size sn_size,
+ unsigned char era_2_sw_hfn_ovrd __maybe_unused)
+{
+ uint32_t offset = 0, length = 0, sn_mask = 0;
+ /* Insert Cipher Key */
+ KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
+ cipherdata->keylen, INLINE_KEY(cipherdata));
+
+ if ((rta_sec_era >= RTA_SEC_ERA_8 && sn_size != PDCP_SN_SIZE_18 &&
+ !(rta_sec_era == RTA_SEC_ERA_8 &&
+ authdata->algtype == 0))
+ || (rta_sec_era == RTA_SEC_ERA_10)) {
+ if (sn_size == PDCP_SN_SIZE_5)
+ PROTOCOL(p, dir, OP_PCLID_LTE_PDCP_CTRL_MIXED,
+ (uint16_t)cipherdata->algtype << 8);
+ else
+ PROTOCOL(p, dir, OP_PCLID_LTE_PDCP_USER_RN,
+ (uint16_t)cipherdata->algtype << 8);
+ return 0;
+ }
+ /* Non-proto is supported only for 5bit cplane and 18bit uplane */
+ switch (sn_size) {
+ case PDCP_SN_SIZE_5:
+ offset = 7;
+ length = 1;
+ sn_mask = (swap == false) ? PDCP_C_PLANE_SN_MASK :
+ PDCP_C_PLANE_SN_MASK_BE;
+ break;
+ case PDCP_SN_SIZE_18:
+ offset = 5;
+ length = 3;
+ sn_mask = (swap == false) ? PDCP_U_PLANE_18BIT_SN_MASK :
+ PDCP_U_PLANE_18BIT_SN_MASK_BE;
+ break;
+ case PDCP_SN_SIZE_12:
+ offset = 6;
+ length = 2;
+ sn_mask = (swap == false) ? PDCP_12BIT_SN_MASK :
+ PDCP_12BIT_SN_MASK_BE;
+ break;
+ case PDCP_SN_SIZE_7:
+ case PDCP_SN_SIZE_15:
+ pr_err("Invalid sn_size for %s\n", __func__);
+ return -ENOTSUP;
+ }
+
+ SEQLOAD(p, MATH0, offset, length, 0);
+ JUMP(p, 1, LOCAL_JUMP, ALL_TRUE, CALM);
+ MATHB(p, MATH0, AND, sn_mask, MATH1, 8, IFB | IMMED2);
+ SEQSTORE(p, MATH0, offset, length, 0);
+ MATHB(p, MATH1, SHLD, MATH1, MATH1, 8, 0);
+ MOVEB(p, DESCBUF, 8, MATH2, 0, 8, WAITCOMP | IMMED);
+ MATHB(p, MATH1, OR, MATH2, MATH2, 8, 0);
+
+ switch (cipherdata->algtype) {
+ case PDCP_CIPHER_TYPE_SNOW:
+ MOVEB(p, MATH2, 0, CONTEXT1, 0, 8, WAITCOMP | IMMED);
+
+ if (rta_sec_era > RTA_SEC_ERA_2) {
+ MATHB(p, SEQINSZ, SUB, ZERO, VSEQINSZ, 4, 0);
+ } else {
+ MATHB(p, SEQINSZ, SUB, ONE, MATH1, 4, 0);
+ MATHB(p, MATH1, ADD, ONE, VSEQINSZ, 4, 0);
+ }
+
+ if (dir == OP_TYPE_ENCAP_PROTOCOL)
+ MATHB(p, SEQINSZ, ADD, PDCP_MAC_I_LEN, VSEQOUTSZ, 4,
+ IMMED2);
+ else
+ MATHB(p, SEQINSZ, SUB, PDCP_MAC_I_LEN, VSEQOUTSZ, 4,
+ IMMED2);
+ SEQFIFOSTORE(p, MSG, 0, 0, VLF | CONT);
+ ALG_OPERATION(p, OP_ALG_ALGSEL_SNOW_F8,
+ OP_ALG_AAI_F8,
+ OP_ALG_AS_INITFINAL, ICV_CHECK_DISABLE,
+ dir == OP_TYPE_ENCAP_PROTOCOL ?
+ DIR_ENC : DIR_DEC);
+ break;
+
+ case PDCP_CIPHER_TYPE_AES:
+ MOVEB(p, MATH2, 0, CONTEXT1, 0x10, 0x10, WAITCOMP | IMMED);
+
+ if (rta_sec_era > RTA_SEC_ERA_2) {
+ MATHB(p, SEQINSZ, SUB, ZERO, VSEQINSZ, 4, 0);
+ } else {
+ MATHB(p, SEQINSZ, SUB, ONE, MATH1, 4, 0);
+ MATHB(p, MATH1, ADD, ONE, VSEQINSZ, 4, 0);
+ }
+
+ if (dir == OP_TYPE_ENCAP_PROTOCOL)
+ MATHB(p, SEQINSZ, ADD, PDCP_MAC_I_LEN, VSEQOUTSZ, 4,
+ IMMED2);
+ else
+ MATHB(p, SEQINSZ, SUB, PDCP_MAC_I_LEN, VSEQOUTSZ, 4,
+ IMMED2);
+
+ SEQFIFOSTORE(p, MSG, 0, 0, VLF | CONT);
+ ALG_OPERATION(p, OP_ALG_ALGSEL_AES,
+ OP_ALG_AAI_CTR,
+ OP_ALG_AS_INITFINAL,
+ ICV_CHECK_DISABLE,
+ dir == OP_TYPE_ENCAP_PROTOCOL ?
+ DIR_ENC : DIR_DEC);
+ break;
+
+ case PDCP_CIPHER_TYPE_ZUC:
+ if (rta_sec_era < RTA_SEC_ERA_5) {
+ pr_err("Invalid era for selected algorithm\n");
+ return -ENOTSUP;
+ }
+
+ MOVEB(p, MATH2, 0, CONTEXT1, 0, 0x08, IMMED);
+ MOVEB(p, MATH2, 0, CONTEXT1, 0x08, 0x08, WAITCOMP | IMMED);
+ MATHB(p, SEQINSZ, SUB, ZERO, VSEQINSZ, 4, 0);
+ if (dir == OP_TYPE_ENCAP_PROTOCOL)
+ MATHB(p, SEQINSZ, ADD, PDCP_MAC_I_LEN, VSEQOUTSZ, 4,
+ IMMED2);
+ else
+ MATHB(p, SEQINSZ, SUB, PDCP_MAC_I_LEN, VSEQOUTSZ, 4,
+ IMMED2);
+
+ SEQFIFOSTORE(p, MSG, 0, 0, VLF | CONT);
+ ALG_OPERATION(p, OP_ALG_ALGSEL_ZUCE,
+ OP_ALG_AAI_F8,
+ OP_ALG_AS_INITFINAL,
+ ICV_CHECK_DISABLE,
+ dir == OP_TYPE_ENCAP_PROTOCOL ?
+ DIR_ENC : DIR_DEC);
+ break;
+
+ default:
+ pr_err("%s: Invalid encrypt algorithm selected: %d\n",
+ "pdcp_insert_cplane_enc_only_op", cipherdata->algtype);
+ return -EINVAL;
+ }
+
+ if (dir == OP_TYPE_ENCAP_PROTOCOL) {
+ SEQFIFOLOAD(p, MSG1, 0, VLF);
+ FIFOLOAD(p, MSG1, PDCP_NULL_INT_MAC_I_VAL, 4,
+ LAST1 | FLUSH1 | IMMED);
+ } else {
+ SEQFIFOLOAD(p, MSG1, 0, VLF | LAST1 | FLUSH1);
+ MOVE(p, OFIFO, 0, MATH1, 4, PDCP_MAC_I_LEN, WAITCOMP | IMMED);
+ MATHB(p, MATH1, XOR, PDCP_NULL_INT_MAC_I_VAL, NONE, 4, IMMED2);
+ JUMP(p, PDCP_NULL_INT_ICV_CHECK_FAILED_STATUS,
+ HALT_STATUS, ALL_FALSE, MATH_Z);
+ }
+
+ return 0;
+}
+
+static inline int
+pdcp_insert_uplane_snow_snow_op(struct program *p,
+ bool swap __maybe_unused,
+ struct alginfo *cipherdata,
+ struct alginfo *authdata,
+ unsigned int dir,
+ enum pdcp_sn_size sn_size,
+ unsigned char era_2_sw_hfn_ovrd __maybe_unused)
+{
+ uint32_t offset = 0, length = 0, sn_mask = 0;
+
+ KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
+ cipherdata->keylen, INLINE_KEY(cipherdata));
+ KEY(p, KEY2, authdata->key_enc_flags, authdata->key, authdata->keylen,
+ INLINE_KEY(authdata));
+
+ if (rta_sec_era >= RTA_SEC_ERA_8 && sn_size != PDCP_SN_SIZE_18) {
+ int pclid;
+
+ if (sn_size == PDCP_SN_SIZE_5)
+ pclid = OP_PCLID_LTE_PDCP_CTRL_MIXED;
+ else
+ pclid = OP_PCLID_LTE_PDCP_USER_RN;
+
+ PROTOCOL(p, dir, pclid,
+ ((uint16_t)cipherdata->algtype << 8) |
+ (uint16_t)authdata->algtype);
+
+ return 0;
+ }
+ /* Non-proto is supported only for 5bit cplane and 18bit uplane */
+ switch (sn_size) {
+ case PDCP_SN_SIZE_5:
+ offset = 7;
+ length = 1;
+ sn_mask = (swap == false) ? PDCP_C_PLANE_SN_MASK :
+ PDCP_C_PLANE_SN_MASK_BE;
+ break;
+ case PDCP_SN_SIZE_18:
+ offset = 5;
+ length = 3;
+ sn_mask = (swap == false) ? PDCP_U_PLANE_18BIT_SN_MASK :
+ PDCP_U_PLANE_18BIT_SN_MASK_BE;
+ break;
+ case PDCP_SN_SIZE_7:
+ case PDCP_SN_SIZE_12:
+ case PDCP_SN_SIZE_15:
+ pr_err("Invalid sn_size for %s\n", __func__);
+ return -ENOTSUP;
+ }
+
+ if (dir == OP_TYPE_ENCAP_PROTOCOL)
+ MATHB(p, SEQINSZ, SUB, length, VSEQINSZ, 4, IMMED2);
+
+ SEQLOAD(p, MATH0, offset, length, 0);
+ JUMP(p, 1, LOCAL_JUMP, ALL_TRUE, CALM);
+ MOVEB(p, MATH0, offset, IFIFOAB2, 0, length, IMMED);
+ MATHB(p, MATH0, AND, sn_mask, MATH1, 8, IFB | IMMED2);
+
+ SEQSTORE(p, MATH0, offset, length, 0);
+ MATHB(p, MATH1, SHLD, MATH1, MATH1, 8, 0);
+ MOVEB(p, DESCBUF, 8, MATH2, 0, 8, WAITCOMP | IMMED);
+ MATHB(p, MATH1, OR, MATH2, MATH1, 8, 0);
+ MOVEB(p, MATH1, 0, CONTEXT1, 0, 8, IMMED);
+ MOVEB(p, MATH1, 0, CONTEXT2, 0, 4, WAITCOMP | IMMED);
+ if (swap == false) {
+ MATHB(p, MATH1, AND, upper_32_bits(PDCP_BEARER_MASK),
+ MATH2, 4, IMMED2);
+ MATHB(p, MATH1, AND, lower_32_bits(PDCP_DIR_MASK),
+ MATH3, 4, IMMED2);
+ } else {
+ MATHB(p, MATH1, AND, lower_32_bits(PDCP_BEARER_MASK_BE),
+ MATH2, 4, IMMED2);
+ MATHB(p, MATH1, AND, upper_32_bits(PDCP_DIR_MASK_BE),
+ MATH3, 4, IMMED2);
+ }
+ MATHB(p, MATH3, SHLD, MATH3, MATH3, 8, 0);
+
+ MOVEB(p, MATH2, 4, OFIFO, 0, 12, IMMED);
+ MOVE(p, OFIFO, 0, CONTEXT2, 4, 12, IMMED);
+ if (dir == OP_TYPE_ENCAP_PROTOCOL) {
+ MATHB(p, SEQINSZ, ADD, PDCP_MAC_I_LEN, VSEQOUTSZ, 4, IMMED2);
+ } else {
+ MATHI(p, SEQINSZ, SUB, PDCP_MAC_I_LEN, VSEQOUTSZ, 4, IMMED2);
+ MATHI(p, SEQINSZ, SUB, PDCP_MAC_I_LEN, VSEQINSZ, 4, IMMED2);
+ }
+
+ if (dir == OP_TYPE_ENCAP_PROTOCOL)
+ SEQFIFOSTORE(p, MSG, 0, 0, VLF);
+ else
+ SEQFIFOSTORE(p, MSG, 0, 0, VLF | CONT);
+
+ ALG_OPERATION(p, OP_ALG_ALGSEL_SNOW_F9,
+ OP_ALG_AAI_F9,
+ OP_ALG_AS_INITFINAL,
+ dir == OP_TYPE_ENCAP_PROTOCOL ?
+ ICV_CHECK_DISABLE : ICV_CHECK_ENABLE,
+ DIR_DEC);
+ ALG_OPERATION(p, OP_ALG_ALGSEL_SNOW_F8,
+ OP_ALG_AAI_F8,
+ OP_ALG_AS_INITFINAL,
+ ICV_CHECK_DISABLE,
+ dir == OP_TYPE_ENCAP_PROTOCOL ? DIR_ENC : DIR_DEC);
+
+ if (dir == OP_TYPE_ENCAP_PROTOCOL) {
+ SEQFIFOLOAD(p, MSGINSNOOP, 0, VLF | LAST2);
+ MOVE(p, CONTEXT2, 0, IFIFOAB1, 0, 4, LAST1 | FLUSH1 | IMMED);
+ } else {
+ SEQFIFOLOAD(p, MSGOUTSNOOP, 0, VLF | LAST2);
+ SEQFIFOLOAD(p, MSG1, 4, LAST1 | FLUSH1);
+ JUMP(p, 1, LOCAL_JUMP, ALL_TRUE, CLASS1 | NOP | NIFP);
+
+ if (rta_sec_era >= RTA_SEC_ERA_6)
+ LOAD(p, 0, DCTRL, 0, LDLEN_RST_CHA_OFIFO_PTR, IMMED);
+
+ MOVE(p, OFIFO, 0, MATH0, 0, 4, WAITCOMP | IMMED);
+
+ NFIFOADD(p, IFIFO, ICV2, 4, LAST2);
+
+ if (rta_sec_era <= RTA_SEC_ERA_2) {
+ /* Shut off automatic Info FIFO entries */
+ LOAD(p, 0, DCTRL, LDOFF_DISABLE_AUTO_NFIFO, 0, IMMED);
+ MOVE(p, MATH0, 0, IFIFOAB2, 0, 4, WAITCOMP | IMMED);
+ } else {
+ MOVE(p, MATH0, 0, IFIFO, 0, 4, WAITCOMP | IMMED);
+ }
+ }
+
+ return 0;
+}
+
+static inline int
+pdcp_insert_uplane_zuc_zuc_op(struct program *p,
+ bool swap __maybe_unused,
+ struct alginfo *cipherdata,
+ struct alginfo *authdata,
+ unsigned int dir,
+ enum pdcp_sn_size sn_size,
+ unsigned char era_2_sw_hfn_ovrd __maybe_unused)
+{
+ uint32_t offset = 0, length = 0, sn_mask = 0;
+
+ LABEL(keyjump);
+ REFERENCE(pkeyjump);
+
+ if (rta_sec_era < RTA_SEC_ERA_5) {
+ pr_err("Invalid era for selected algorithm\n");
+ return -ENOTSUP;
+ }
+
+ pkeyjump = JUMP(p, keyjump, LOCAL_JUMP, ALL_TRUE, SHRD | SELF | BOTH);
+ KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
+ cipherdata->keylen, INLINE_KEY(cipherdata));
+ KEY(p, KEY2, authdata->key_enc_flags, authdata->key, authdata->keylen,
+ INLINE_KEY(authdata));
+
+ SET_LABEL(p, keyjump);
+ PATCH_JUMP(p, pkeyjump, keyjump);
+
+ if (rta_sec_era >= RTA_SEC_ERA_8 && sn_size != PDCP_SN_SIZE_18) {
+ int pclid;
+
+ if (sn_size == PDCP_SN_SIZE_5)
+ pclid = OP_PCLID_LTE_PDCP_CTRL_MIXED;
+ else
+ pclid = OP_PCLID_LTE_PDCP_USER_RN;
+
+ PROTOCOL(p, dir, pclid,
+ ((uint16_t)cipherdata->algtype << 8) |
+ (uint16_t)authdata->algtype);
+
+ return 0;
+ }
+ /* Non-proto is supported only for 5bit cplane and 18bit uplane */
+ switch (sn_size) {
+ case PDCP_SN_SIZE_5:
+ offset = 7;
+ length = 1;
+ sn_mask = (swap == false) ? PDCP_C_PLANE_SN_MASK :
+ PDCP_C_PLANE_SN_MASK_BE;
+ break;
+ case PDCP_SN_SIZE_18:
+ offset = 5;
+ length = 3;
+ sn_mask = (swap == false) ? PDCP_U_PLANE_18BIT_SN_MASK :
+ PDCP_U_PLANE_18BIT_SN_MASK_BE;
+ break;
+ case PDCP_SN_SIZE_7:
+ case PDCP_SN_SIZE_12:
+ case PDCP_SN_SIZE_15:
+ pr_err("Invalid sn_size for %s\n", __func__);
+ return -ENOTSUP;
+ }
+
+ SEQLOAD(p, MATH0, offset, length, 0);
+ JUMP(p, 1, LOCAL_JUMP, ALL_TRUE, CALM);
+ MOVEB(p, MATH0, offset, IFIFOAB2, 0, length, IMMED);
+ MATHB(p, MATH0, AND, sn_mask, MATH1, 8, IFB | IMMED2);
+ MATHB(p, MATH1, SHLD, MATH1, MATH1, 8, 0);
+
+ MOVEB(p, DESCBUF, 8, MATH2, 0, 8, WAITCOMP | IMMED);
+ MATHB(p, MATH1, OR, MATH2, MATH2, 8, 0);
+ MOVEB(p, MATH2, 0, CONTEXT1, 0, 8, IMMED);
+
+ MOVEB(p, MATH2, 0, CONTEXT2, 0, 8, WAITCOMP | IMMED);
+
+ if (dir == OP_TYPE_ENCAP_PROTOCOL)
+ MATHB(p, SEQINSZ, ADD, PDCP_MAC_I_LEN, VSEQOUTSZ, 4, IMMED2);
+ else
+ MATHB(p, SEQINSZ, SUB, PDCP_MAC_I_LEN, VSEQOUTSZ, 4, IMMED2);
+
+ MATHB(p, SEQINSZ, SUB, ZERO, VSEQINSZ, 4, 0);
+ SEQSTORE(p, MATH0, offset, length, 0);
+
+ if (dir == OP_TYPE_ENCAP_PROTOCOL) {
+ SEQFIFOSTORE(p, MSG, 0, 0, VLF);
+ SEQFIFOLOAD(p, MSGINSNOOP, 0, VLF | LAST2);
+ } else {
+ SEQFIFOSTORE(p, MSG, 0, 0, VLF | CONT);
+ SEQFIFOLOAD(p, MSGOUTSNOOP, 0, VLF | LAST1 | FLUSH1);
+ }
+
+ ALG_OPERATION(p, OP_ALG_ALGSEL_ZUCA,
+ OP_ALG_AAI_F9,
+ OP_ALG_AS_INITFINAL,
+ dir == OP_TYPE_ENCAP_PROTOCOL ?
+ ICV_CHECK_DISABLE : ICV_CHECK_ENABLE,
+ DIR_ENC);
+
+ ALG_OPERATION(p, OP_ALG_ALGSEL_ZUCE,
+ OP_ALG_AAI_F8,
+ OP_ALG_AS_INITFINAL,
+ ICV_CHECK_DISABLE,
+ dir == OP_TYPE_ENCAP_PROTOCOL ? DIR_ENC : DIR_DEC);
+
+ if (dir == OP_TYPE_ENCAP_PROTOCOL) {
+ MOVE(p, CONTEXT2, 0, IFIFOAB1, 0, 4, LAST1 | FLUSH1 | IMMED);
+ } else {
+ /* Save ICV */
+ MOVEB(p, OFIFO, 0, MATH0, 0, 4, IMMED);
+
+ LOAD(p, NFIFOENTRY_STYPE_ALTSOURCE |
+ NFIFOENTRY_DEST_CLASS2 |
+ NFIFOENTRY_DTYPE_ICV |
+ NFIFOENTRY_LC2 | 4, NFIFO_SZL, 0, 4, IMMED);
+ MOVEB(p, MATH0, 0, ALTSOURCE, 0, 4, WAITCOMP | IMMED);
+ }
+
+ /* Reset ZUCA mode and done interrupt */
+ LOAD(p, CLRW_CLR_C2MODE, CLRW, 0, 4, IMMED);
+ LOAD(p, CIRQ_ZADI, ICTRL, 0, 4, IMMED);
+
+ return 0;
+}
+
+static inline int
+pdcp_insert_uplane_aes_aes_op(struct program *p,
+ bool swap __maybe_unused,
+ struct alginfo *cipherdata,
+ struct alginfo *authdata,
+ unsigned int dir,
+ enum pdcp_sn_size sn_size,
+ unsigned char era_2_sw_hfn_ovrd __maybe_unused)
+{
+ uint32_t offset = 0, length = 0, sn_mask = 0;
+
+ if ((rta_sec_era >= RTA_SEC_ERA_8 && sn_size != PDCP_SN_SIZE_18)) {
+ /* Insert Auth Key */
+ KEY(p, KEY2, authdata->key_enc_flags, authdata->key,
+ authdata->keylen, INLINE_KEY(authdata));
+
+ /* Insert Cipher Key */
+ KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
+ cipherdata->keylen, INLINE_KEY(cipherdata));
+
+ PROTOCOL(p, dir, OP_PCLID_LTE_PDCP_USER_RN,
+ ((uint16_t)cipherdata->algtype << 8) |
+ (uint16_t)authdata->algtype);
+ return 0;
+ }
+
+ /* Non-proto is supported only for 5bit cplane and 18bit uplane */
+ switch (sn_size) {
+ case PDCP_SN_SIZE_18:
+ offset = 5;
+ length = 3;
+ sn_mask = (swap == false) ? PDCP_U_PLANE_18BIT_SN_MASK :
+ PDCP_U_PLANE_18BIT_SN_MASK_BE;
+ break;
+
+ default:
+ pr_err("Invalid sn_size for %s\n", __func__);
+ return -ENOTSUP;
+ }
+
+ SEQLOAD(p, MATH0, offset, length, 0);
+ JUMP(p, 1, LOCAL_JUMP, ALL_TRUE, CALM);
+ MATHB(p, MATH0, AND, sn_mask, MATH1, 8, IFB | IMMED2);
+
+ MATHB(p, MATH1, SHLD, MATH1, MATH1, 8, 0);
+ MOVEB(p, DESCBUF, 8, MATH2, 0, 0x08, WAITCOMP | IMMED);
+ MATHB(p, MATH1, OR, MATH2, MATH2, 8, 0);
+ SEQSTORE(p, MATH0, offset, length, 0);
+
+ if (dir == OP_TYPE_ENCAP_PROTOCOL) {
+ KEY(p, KEY1, authdata->key_enc_flags, authdata->key,
+ authdata->keylen, INLINE_KEY(authdata));
+ MOVEB(p, MATH2, 0, IFIFOAB1, 0, 0x08, IMMED);
+ MOVEB(p, MATH0, offset, IFIFOAB1, 0, length, IMMED);
+
+ MATHB(p, SEQINSZ, SUB, ZERO, VSEQINSZ, 4, 0);
+ MATHB(p, VSEQINSZ, ADD, PDCP_MAC_I_LEN, VSEQOUTSZ, 4, IMMED2);
+
+ ALG_OPERATION(p, OP_ALG_ALGSEL_AES,
+ OP_ALG_AAI_CMAC,
+ OP_ALG_AS_INITFINAL,
+ ICV_CHECK_DISABLE,
+ DIR_DEC);
+ SEQFIFOLOAD(p, MSG1, 0, VLF | LAST1 | FLUSH1);
+ MOVEB(p, CONTEXT1, 0, MATH3, 0, 4, WAITCOMP | IMMED);
+
+ LOAD(p, CLRW_RESET_CLS1_CHA |
+ CLRW_CLR_C1KEY |
+ CLRW_CLR_C1CTX |
+ CLRW_CLR_C1ICV |
+ CLRW_CLR_C1DATAS |
+ CLRW_CLR_C1MODE,
+ CLRW, 0, 4, IMMED);
+
+ KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
+ cipherdata->keylen, INLINE_KEY(cipherdata));
+
+ MOVEB(p, MATH2, 0, CONTEXT1, 16, 8, IMMED);
+ SEQINPTR(p, 0, PDCP_NULL_MAX_FRAME_LEN, RTO);
+
+ ALG_OPERATION(p, OP_ALG_ALGSEL_AES,
+ OP_ALG_AAI_CTR,
+ OP_ALG_AS_INITFINAL,
+ ICV_CHECK_DISABLE,
+ DIR_ENC);
+
+ SEQFIFOSTORE(p, MSG, 0, 0, VLF);
+
+ SEQFIFOLOAD(p, SKIP, length, 0);
+
+ SEQFIFOLOAD(p, MSG1, 0, VLF);
+ MOVEB(p, MATH3, 0, IFIFOAB1, 0, 4, LAST1 | FLUSH1 | IMMED);
+ } else {
+ MOVEB(p, MATH2, 0, CONTEXT1, 16, 8, IMMED);
+ MOVEB(p, MATH2, 0, CONTEXT2, 0, 8, IMMED);
+
+ MATHB(p, SEQINSZ, SUB, ZERO, VSEQINSZ, 4, 0);
+ MATHB(p, SEQINSZ, SUB, PDCP_MAC_I_LEN, VSEQOUTSZ, 4, IMMED2);
+
+ KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
+ cipherdata->keylen, INLINE_KEY(cipherdata));
+
+ ALG_OPERATION(p, OP_ALG_ALGSEL_AES,
+ OP_ALG_AAI_CTR,
+ OP_ALG_AS_INITFINAL,
+ ICV_CHECK_DISABLE,
+ DIR_DEC);
+
+ SEQFIFOSTORE(p, MSG, 0, 0, VLF | CONT);
+ SEQFIFOLOAD(p, MSG1, 0, VLF | LAST1 | FLUSH1);
+
+ MOVEB(p, OFIFO, 0, MATH3, 0, 4, IMMED);
+
+ LOAD(p, CLRW_RESET_CLS1_CHA |
+ CLRW_CLR_C1KEY |
+ CLRW_CLR_C1CTX |
+ CLRW_CLR_C1ICV |
+ CLRW_CLR_C1DATAS |
+ CLRW_CLR_C1MODE,
+ CLRW, 0, 4, IMMED);
+
+ KEY(p, KEY1, authdata->key_enc_flags, authdata->key,
+ authdata->keylen, INLINE_KEY(authdata));
+
+ SEQINPTR(p, 0, 0, SOP);
+
+ ALG_OPERATION(p, OP_ALG_ALGSEL_AES,
+ OP_ALG_AAI_CMAC,
+ OP_ALG_AS_INITFINAL,
+ ICV_CHECK_ENABLE,
+ DIR_DEC);
+
+ MATHB(p, SEQINSZ, SUB, ZERO, VSEQINSZ, 4, 0);
+
+ MOVE(p, CONTEXT2, 0, IFIFOAB1, 0, 8, IMMED);
+
+ SEQFIFOLOAD(p, MSG1, 0, VLF | LAST1 | FLUSH1);
+
+ LOAD(p, NFIFOENTRY_STYPE_ALTSOURCE |
+ NFIFOENTRY_DEST_CLASS1 |
+ NFIFOENTRY_DTYPE_ICV |
+ NFIFOENTRY_LC1 |
+ NFIFOENTRY_FC1 | 4, NFIFO_SZL, 0, 4, IMMED);
+ MOVEB(p, MATH3, 0, ALTSOURCE, 0, 4, IMMED);
+ }
+
+ return 0;
+}
+
+static inline int
+pdcp_insert_cplane_acc_op(struct program *p,
+ bool swap __maybe_unused,
+ struct alginfo *cipherdata,
+ struct alginfo *authdata,
+ unsigned int dir,
+ enum pdcp_sn_size sn_size,
+ unsigned char era_2_hfn_ovrd __maybe_unused)
+{
+ /* Insert Auth Key */
+ KEY(p, KEY2, authdata->key_enc_flags, authdata->key, authdata->keylen,
+ INLINE_KEY(authdata));
+
+ /* Insert Cipher Key */
+ KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
+ cipherdata->keylen, INLINE_KEY(cipherdata));
+
+ if (sn_size == PDCP_SN_SIZE_5)
+ PROTOCOL(p, dir, OP_PCLID_LTE_PDCP_CTRL,
+ (uint16_t)cipherdata->algtype);
+ else
+ PROTOCOL(p, dir, OP_PCLID_LTE_PDCP_USER_RN,
+ ((uint16_t)cipherdata->algtype << 8) |
+ (uint16_t)authdata->algtype);
+
+ return 0;
+}
+
+static inline int
+pdcp_insert_cplane_snow_aes_op(struct program *p,
+ bool swap __maybe_unused,
+ struct alginfo *cipherdata,
+ struct alginfo *authdata,
+ unsigned int dir,
+ enum pdcp_sn_size sn_size,
+ unsigned char era_2_sw_hfn_ovrd)
+{
+ uint32_t offset = 0, length = 0, sn_mask = 0;
+
+ LABEL(back_to_sd_offset);
+ LABEL(end_desc);
+ LABEL(local_offset);
+ LABEL(jump_to_beginning);
+ LABEL(fifo_load_mac_i_offset);
+ REFERENCE(seqin_ptr_read);
+ REFERENCE(seqin_ptr_write);
+ REFERENCE(seq_out_read);
+ REFERENCE(jump_back_to_sd_cmd);
+ REFERENCE(move_mac_i_to_desc_buf);
+
+ if ((rta_sec_era >= RTA_SEC_ERA_8 && sn_size != PDCP_SN_SIZE_18) ||
+ (rta_sec_era == RTA_SEC_ERA_10)) {
+ KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
+ cipherdata->keylen, INLINE_KEY(cipherdata));
+ KEY(p, KEY2, authdata->key_enc_flags, authdata->key,
+ authdata->keylen, INLINE_KEY(authdata));
+
+ if (sn_size == PDCP_SN_SIZE_5)
+ PROTOCOL(p, dir, OP_PCLID_LTE_PDCP_CTRL_MIXED,
+ ((uint16_t)cipherdata->algtype << 8) |
+ (uint16_t)authdata->algtype);
+ else
+ PROTOCOL(p, dir, OP_PCLID_LTE_PDCP_USER_RN,
+ ((uint16_t)cipherdata->algtype << 8) |
+ (uint16_t)authdata->algtype);
+
+ return 0;
+ }
+ /* Non-proto is supported only for 5bit cplane and 18bit uplane */
+ switch (sn_size) {
+ case PDCP_SN_SIZE_5:
+ offset = 7;
+ length = 1;
+ sn_mask = (swap == false) ? PDCP_C_PLANE_SN_MASK :
+ PDCP_C_PLANE_SN_MASK_BE;
+ break;
+ case PDCP_SN_SIZE_18:
+ offset = 5;
+ length = 3;
+ sn_mask = (swap == false) ? PDCP_U_PLANE_18BIT_SN_MASK :
+ PDCP_U_PLANE_18BIT_SN_MASK_BE;
+ break;
+ case PDCP_SN_SIZE_7:
+ case PDCP_SN_SIZE_12:
+ case PDCP_SN_SIZE_15:
+ pr_err("Invalid sn_size for %s\n", __func__);
+ return -ENOTSUP;
+
+ }
+
+ SEQLOAD(p, MATH0, offset, length, 0);
+ JUMP(p, 1, LOCAL_JUMP, ALL_TRUE, CALM);
+ MATHB(p, MATH0, AND, sn_mask, MATH1, 8, IFB | IMMED2);
+ MATHB(p, MATH1, SHLD, MATH1, MATH1, 8, 0);
+ MOVEB(p, DESCBUF, 4, MATH2, 0, 0x08, WAITCOMP | IMMED);
+ MATHB(p, MATH1, OR, MATH2, MATH2, 8, 0);
+ SEQSTORE(p, MATH0, offset, length, 0);
+ if (dir == OP_TYPE_ENCAP_PROTOCOL) {
+ if (rta_sec_era > RTA_SEC_ERA_2 ||
+ (rta_sec_era == RTA_SEC_ERA_2 &&
+ era_2_sw_hfn_ovrd == 0)) {
+ SEQINPTR(p, 0, length, RTO);
+ } else {
+ SEQINPTR(p, 0, 5, RTO);
+ SEQFIFOLOAD(p, SKIP, 4, 0);
+ }
+ KEY(p, KEY1, authdata->key_enc_flags, authdata->key,
+ authdata->keylen, INLINE_KEY(authdata));
+ MOVEB(p, MATH2, 0, IFIFOAB1, 0, 0x08, IMMED);
+
+ if (rta_sec_era > RTA_SEC_ERA_2) {
+ MATHB(p, SEQINSZ, SUB, ZERO, VSEQINSZ, 4, 0);
+ MATHB(p, SEQINSZ, SUB, ZERO, MATH1, 4, 0);
+ MATHB(p, VSEQINSZ, ADD, PDCP_MAC_I_LEN - 1, VSEQOUTSZ,
+ 4, IMMED2);
+ } else {
+ MATHB(p, SEQINSZ, SUB, MATH3, VSEQINSZ, 4, 0);
+ MATHB(p, VSEQINSZ, ADD, PDCP_MAC_I_LEN - 1, VSEQOUTSZ,
+ 4, IMMED2);
+ /*
+ * Note: Although the calculations below might seem a
+ * little off, the logic is the following:
+ *
+ * - SEQ IN PTR RTO below needs the full length of the
+ * frame; in case of P4080_REV_2_HFN_OV_WORKAROUND,
+ * this means the length of the frame to be processed
+ * + 4 bytes (the HFN override flag and value).
+ * The length of the frame to be processed minus 1
+ * byte is in the VSIL register (because
+ * VSIL = SIL + 3, due to 1 byte, the header being
+ * already written by the SEQ STORE above). So for
+ * calculating the length to use in RTO, I add one
+ * to the VSIL value in order to obtain the total
+ * frame length. This helps in case of P4080 which
+ * can have the value 0 as an operand in a MATH
+ * command only as SRC1 When the HFN override
+ * workaround is not enabled, the length of the
+ * frame is given by the SIL register; the
+ * calculation is similar to the one in the SEC 4.2
+ * and SEC 5.3 cases.
+ */
+ if (era_2_sw_hfn_ovrd)
+ MATHB(p, VSEQOUTSZ, ADD, ONE, MATH1, 4,
+ 0);
+ else
+ MATHB(p, SEQINSZ, ADD, MATH3, MATH1, 4,
+ 0);
+ }
+ /*
+ * Placeholder for filling the length in
+ * SEQIN PTR RTO below
+ */
+ seqin_ptr_read = MOVE(p, DESCBUF, 0, MATH1, 0, 6, IMMED);
+ seqin_ptr_write = MOVE(p, MATH1, 0, DESCBUF, 0, 8,
+ WAITCOMP | IMMED);
+ ALG_OPERATION(p, OP_ALG_ALGSEL_AES,
+ OP_ALG_AAI_CMAC,
+ OP_ALG_AS_INITFINAL,
+ ICV_CHECK_DISABLE,
+ DIR_DEC);
+ SEQFIFOLOAD(p, MSG1, 0, VLF | LAST1 | FLUSH1);
+ MOVEB(p, CONTEXT1, 0, MATH3, 0, 4, WAITCOMP | IMMED);
+ if (rta_sec_era <= RTA_SEC_ERA_3)
+ LOAD(p, CLRW_CLR_C1KEY |
+ CLRW_CLR_C1CTX |
+ CLRW_CLR_C1ICV |
+ CLRW_CLR_C1DATAS |
+ CLRW_CLR_C1MODE,
+ CLRW, 0, 4, IMMED);
+ else
+ LOAD(p, CLRW_RESET_CLS1_CHA |
+ CLRW_CLR_C1KEY |
+ CLRW_CLR_C1CTX |
+ CLRW_CLR_C1ICV |
+ CLRW_CLR_C1DATAS |
+ CLRW_CLR_C1MODE,
+ CLRW, 0, 4, IMMED);
+
+ if (rta_sec_era <= RTA_SEC_ERA_3)
+ LOAD(p, CCTRL_RESET_CHA_ALL, CCTRL, 0, 4, IMMED);
+
+ KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
+ cipherdata->keylen, INLINE_KEY(cipherdata));
+ SET_LABEL(p, local_offset);
+ MOVEB(p, MATH2, 0, CONTEXT1, 0, 8, IMMED);
+ SEQINPTR(p, 0, 0, RTO);
+
+ if (rta_sec_era == RTA_SEC_ERA_2 && era_2_sw_hfn_ovrd) {
+ SEQFIFOLOAD(p, SKIP, 5, 0);
+ MATHB(p, SEQINSZ, ADD, ONE, SEQINSZ, 4, 0);
+ }
+
+ MATHB(p, SEQINSZ, SUB, length, VSEQINSZ, 4, IMMED2);
+ ALG_OPERATION(p, OP_ALG_ALGSEL_SNOW_F8,
+ OP_ALG_AAI_F8,
+ OP_ALG_AS_INITFINAL,
+ ICV_CHECK_DISABLE,
+ DIR_ENC);
+ SEQFIFOSTORE(p, MSG, 0, 0, VLF);
+
+ if (rta_sec_era > RTA_SEC_ERA_2 ||
+ (rta_sec_era == RTA_SEC_ERA_2 &&
+ era_2_sw_hfn_ovrd == 0))
+ SEQFIFOLOAD(p, SKIP, length, 0);
+
+ SEQFIFOLOAD(p, MSG1, 0, VLF);
+ MOVEB(p, MATH3, 0, IFIFOAB1, 0, 4, LAST1 | FLUSH1 | IMMED);
+ PATCH_MOVE(p, seqin_ptr_read, local_offset);
+ PATCH_MOVE(p, seqin_ptr_write, local_offset);
+ } else {
+ MOVEB(p, MATH2, 0, CONTEXT1, 0, 8, IMMED);
+
+ if (rta_sec_era >= RTA_SEC_ERA_5)
+ MOVE(p, CONTEXT1, 0, CONTEXT2, 0, 8, IMMED);
+
+ if (rta_sec_era > RTA_SEC_ERA_2)
+ MATHB(p, SEQINSZ, SUB, ZERO, VSEQINSZ, 4, 0);
+ else
+ MATHB(p, SEQINSZ, SUB, MATH3, VSEQINSZ, 4, 0);
+
+ MATHI(p, SEQINSZ, SUB, PDCP_MAC_I_LEN, VSEQOUTSZ, 4, IMMED2);
+/*
+ * TODO: To be changed when proper support is added in RTA (can't load a
+ * command that is also written by RTA (or patch it for that matter).
+ * Change when proper RTA support is added.
+ */
+ if (p->ps)
+ WORD(p, 0x168B0004);
+ else
+ WORD(p, 0x16880404);
+
+ jump_back_to_sd_cmd = JUMP(p, 0, LOCAL_JUMP, ALL_TRUE, 0);
+ /*
+ * Placeholder for command reading the SEQ OUT command in
+ * JD. Done for rereading the decrypted data and performing
+ * the integrity check
+ */
+/*
+ * TODO: RTA currently doesn't support patching of length of a MOVE command
+ * Thus, it is inserted as a raw word, as per PS setting.
+ */
+ if (p->ps)
+ seq_out_read = MOVE(p, DESCBUF, 0, MATH1, 0, 20,
+ WAITCOMP | IMMED);
+ else
+ seq_out_read = MOVE(p, DESCBUF, 0, MATH1, 0, 16,
+ WAITCOMP | IMMED);
+
+ MATHB(p, MATH1, XOR, CMD_SEQ_IN_PTR ^ CMD_SEQ_OUT_PTR, MATH1, 4,
+ IMMED2);
+ /* Placeholder for overwriting the SEQ IN with SEQ OUT */
+/*
+ * TODO: RTA currently doesn't support patching of length of a MOVE command
+ * Thus, it is inserted as a raw word, as per PS setting.
+ */
+ if (p->ps)
+ MOVE(p, MATH1, 0, DESCBUF, 0, 24, IMMED);
+ else
+ MOVE(p, MATH1, 0, DESCBUF, 0, 20, IMMED);
+
+ KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
+ cipherdata->keylen, INLINE_KEY(cipherdata));
+
+ if (rta_sec_era >= RTA_SEC_ERA_4)
+ MOVE(p, CONTEXT1, 0, CONTEXT2, 0, 8, IMMED);
+ else
+ MOVE(p, CONTEXT1, 0, MATH3, 0, 8, IMMED);
+
+ ALG_OPERATION(p, OP_ALG_ALGSEL_SNOW_F8,
+ OP_ALG_AAI_F8,
+ OP_ALG_AS_INITFINAL,
+ ICV_CHECK_DISABLE,
+ DIR_DEC);
+ SEQFIFOSTORE(p, MSG, 0, 0, VLF | CONT);
+ SEQFIFOLOAD(p, MSG1, 0, VLF | LAST1 | FLUSH1);
+
+ if (rta_sec_era <= RTA_SEC_ERA_3)
+ move_mac_i_to_desc_buf = MOVE(p, OFIFO, 0, DESCBUF, 0,
+ 4, WAITCOMP | IMMED);
+ else
+ MOVE(p, OFIFO, 0, MATH3, 0, 4, IMMED);
+
+ if (rta_sec_era <= RTA_SEC_ERA_3)
+ LOAD(p, CCTRL_RESET_CHA_ALL, CCTRL, 0, 4, IMMED);
+ else
+ LOAD(p, CLRW_RESET_CLS1_CHA |
+ CLRW_CLR_C1KEY |
+ CLRW_CLR_C1CTX |
+ CLRW_CLR_C1ICV |
+ CLRW_CLR_C1DATAS |
+ CLRW_CLR_C1MODE,
+ CLRW, 0, 4, IMMED);
+
+ KEY(p, KEY1, authdata->key_enc_flags, authdata->key,
+ authdata->keylen, INLINE_KEY(authdata));
+ /*
+ * Placeholder for jump in SD for executing the new SEQ IN PTR
+ * command (which is actually the old SEQ OUT PTR command
+ * copied over from JD.
+ */
+ SET_LABEL(p, jump_to_beginning);
+ JUMP(p, 1 - jump_to_beginning, LOCAL_JUMP, ALL_TRUE, 0);
+ SET_LABEL(p, back_to_sd_offset);
+ ALG_OPERATION(p, OP_ALG_ALGSEL_AES,
+ OP_ALG_AAI_CMAC,
+ OP_ALG_AS_INITFINAL,
+ ICV_CHECK_ENABLE,
+ DIR_DEC);
+
+ /* Read the # of bytes written in the output buffer + 1 (HDR) */
+ MATHI(p, VSEQOUTSZ, ADD, length, VSEQINSZ, 4, IMMED2);
+
+ if (rta_sec_era <= RTA_SEC_ERA_3)
+ MOVE(p, MATH3, 0, IFIFOAB1, 0, 8, IMMED);
+ else
+ MOVE(p, CONTEXT2, 0, IFIFOAB1, 0, 8, IMMED);
+
+ if (rta_sec_era == RTA_SEC_ERA_2 && era_2_sw_hfn_ovrd)
+ SEQFIFOLOAD(p, SKIP, 4, 0);
+
+ SEQFIFOLOAD(p, MSG1, 0, VLF | LAST1 | FLUSH1);
+
+ if (rta_sec_era >= RTA_SEC_ERA_4) {
+ LOAD(p, NFIFOENTRY_STYPE_ALTSOURCE |
+ NFIFOENTRY_DEST_CLASS1 |
+ NFIFOENTRY_DTYPE_ICV |
+ NFIFOENTRY_LC1 |
+ NFIFOENTRY_FC1 | 4, NFIFO_SZL, 0, 4, IMMED);
+ MOVE(p, MATH3, 0, ALTSOURCE, 0, 4, IMMED);
+ } else {
+ SET_LABEL(p, fifo_load_mac_i_offset);
+ FIFOLOAD(p, ICV1, fifo_load_mac_i_offset, 4,
+ LAST1 | FLUSH1 | IMMED);
+ }
+
+ SET_LABEL(p, end_desc);
+
+ if (!p->ps) {
+ PATCH_MOVE(p, seq_out_read, end_desc + 1);
+ PATCH_JUMP(p, jump_back_to_sd_cmd,
+ back_to_sd_offset + jump_back_to_sd_cmd - 5);
+
+ if (rta_sec_era <= RTA_SEC_ERA_3)
+ PATCH_MOVE(p, move_mac_i_to_desc_buf,
+ fifo_load_mac_i_offset + 1);
+ } else {
+ PATCH_MOVE(p, seq_out_read, end_desc + 2);
+ PATCH_JUMP(p, jump_back_to_sd_cmd,
+ back_to_sd_offset + jump_back_to_sd_cmd - 5);
+
+ if (rta_sec_era <= RTA_SEC_ERA_3)
+ PATCH_MOVE(p, move_mac_i_to_desc_buf,
+ fifo_load_mac_i_offset + 1);
+ }
+ }
+
+ return 0;
+}
+
+static inline int
+pdcp_insert_cplane_aes_snow_op(struct program *p,
+ bool swap __maybe_unused,
+ struct alginfo *cipherdata,
+ struct alginfo *authdata,
+ unsigned int dir,
+ enum pdcp_sn_size sn_size,
+ unsigned char era_2_sw_hfn_ovrd __maybe_unused)
+{
+ uint32_t offset = 0, length = 0, sn_mask = 0;
+
+ KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
+ cipherdata->keylen, INLINE_KEY(cipherdata));
+ KEY(p, KEY2, authdata->key_enc_flags, authdata->key, authdata->keylen,
+ INLINE_KEY(authdata));
+
+ if ((rta_sec_era >= RTA_SEC_ERA_8 && sn_size != PDCP_SN_SIZE_18) ||
+ (rta_sec_era == RTA_SEC_ERA_10)) {
+ int pclid;
+
+ if (sn_size == PDCP_SN_SIZE_5)
+ pclid = OP_PCLID_LTE_PDCP_CTRL_MIXED;
+ else
+ pclid = OP_PCLID_LTE_PDCP_USER_RN;
+
+ PROTOCOL(p, dir, pclid,
+ ((uint16_t)cipherdata->algtype << 8) |
+ (uint16_t)authdata->algtype);
+
+ return 0;
+ }
+ /* Non-proto is supported only for 5bit cplane and 18bit uplane */
+ switch (sn_size) {
+ case PDCP_SN_SIZE_5:
+ offset = 7;
+ length = 1;
+ sn_mask = (swap == false) ? PDCP_C_PLANE_SN_MASK :
+ PDCP_C_PLANE_SN_MASK_BE;
+ break;
+ case PDCP_SN_SIZE_18:
+ offset = 5;
+ length = 3;
+ sn_mask = (swap == false) ? PDCP_U_PLANE_18BIT_SN_MASK :
+ PDCP_U_PLANE_18BIT_SN_MASK_BE;
+ break;
+ case PDCP_SN_SIZE_7:
+ case PDCP_SN_SIZE_12:
+ case PDCP_SN_SIZE_15:
+ pr_err("Invalid sn_size for %s\n", __func__);
+ return -ENOTSUP;
+
+ }
+
+ if (dir == OP_TYPE_ENCAP_PROTOCOL)
+ MATHB(p, SEQINSZ, SUB, length, VSEQINSZ, 4, IMMED2);
+
+ SEQLOAD(p, MATH0, offset, length, 0);
+ JUMP(p, 1, LOCAL_JUMP, ALL_TRUE, CALM);
+ MOVEB(p, MATH0, offset, IFIFOAB2, 0, length, IMMED);
+ MATHB(p, MATH0, AND, sn_mask, MATH1, 8, IFB | IMMED2);
+
+ SEQSTORE(p, MATH0, offset, length, 0);
+ MATHB(p, MATH1, SHLD, MATH1, MATH1, 8, 0);
+ MOVEB(p, DESCBUF, 4, MATH2, 0, 8, WAITCOMP | IMMED);
+ MATHB(p, MATH1, OR, MATH2, MATH1, 8, 0);
+ MOVEB(p, MATH1, 0, CONTEXT1, 16, 8, IMMED);
+ MOVEB(p, MATH1, 0, CONTEXT2, 0, 4, IMMED);
+ if (swap == false) {
+ MATHB(p, MATH1, AND, upper_32_bits(PDCP_BEARER_MASK), MATH2, 4,
+ IMMED2);
+ MATHB(p, MATH1, AND, lower_32_bits(PDCP_DIR_MASK), MATH3, 4,
+ IMMED2);
+ } else {
+ MATHB(p, MATH1, AND, lower_32_bits(PDCP_BEARER_MASK_BE), MATH2,
+ 4, IMMED2);
+ MATHB(p, MATH1, AND, upper_32_bits(PDCP_DIR_MASK_BE), MATH3,
+ 4, IMMED2);
+ }
+ MATHB(p, MATH3, SHLD, MATH3, MATH3, 8, 0);
+ MOVEB(p, MATH2, 4, OFIFO, 0, 12, IMMED);
+ MOVE(p, OFIFO, 0, CONTEXT2, 4, 12, IMMED);
+ if (dir == OP_TYPE_ENCAP_PROTOCOL) {
+ MATHB(p, SEQINSZ, ADD, PDCP_MAC_I_LEN, VSEQOUTSZ, 4, IMMED2);
+ } else {
+ MATHB(p, SEQINSZ, SUB, PDCP_MAC_I_LEN, MATH1, 4, IMMED2);
+
+ MATHB(p, ZERO, ADD, MATH1, VSEQOUTSZ, 4, 0);
+ MATHB(p, ZERO, ADD, MATH1, VSEQINSZ, 4, 0);
+ }
+
+ if (dir == OP_TYPE_ENCAP_PROTOCOL)
+ SEQFIFOSTORE(p, MSG, 0, 0, VLF);
+ else
+ SEQFIFOSTORE(p, MSG, 0, 0, VLF | CONT);
+
+ ALG_OPERATION(p, OP_ALG_ALGSEL_SNOW_F9,
+ OP_ALG_AAI_F9,
+ OP_ALG_AS_INITFINAL,
+ dir == OP_TYPE_ENCAP_PROTOCOL ?
+ ICV_CHECK_DISABLE : ICV_CHECK_ENABLE,
+ DIR_DEC);
+ ALG_OPERATION(p, OP_ALG_ALGSEL_AES,
+ OP_ALG_AAI_CTR,
+ OP_ALG_AS_INITFINAL,
+ ICV_CHECK_DISABLE,
+ dir == OP_TYPE_ENCAP_PROTOCOL ? DIR_ENC : DIR_DEC);
+
+ if (dir == OP_TYPE_ENCAP_PROTOCOL) {
+ SEQFIFOLOAD(p, MSGINSNOOP, 0, VLF | LAST2);
+ MOVE(p, CONTEXT2, 0, IFIFOAB1, 0, 4, LAST1 | FLUSH1 | IMMED);
+ } else {
+ SEQFIFOLOAD(p, MSGOUTSNOOP, 0, VLF | LAST2);
+ SEQFIFOLOAD(p, MSG1, 4, LAST1 | FLUSH1);
+ JUMP(p, 1, LOCAL_JUMP, ALL_TRUE, CLASS1 | NOP | NIFP);
+
+ if (rta_sec_era >= RTA_SEC_ERA_6)
+ LOAD(p, 0, DCTRL, 0, LDLEN_RST_CHA_OFIFO_PTR, IMMED);
+
+ MOVE(p, OFIFO, 0, MATH0, 0, 4, WAITCOMP | IMMED);
+
+ NFIFOADD(p, IFIFO, ICV2, 4, LAST2);
+
+ if (rta_sec_era <= RTA_SEC_ERA_2) {
+ /* Shut off automatic Info FIFO entries */
+ LOAD(p, 0, DCTRL, LDOFF_DISABLE_AUTO_NFIFO, 0, IMMED);
+ MOVE(p, MATH0, 0, IFIFOAB2, 0, 4, WAITCOMP | IMMED);
+ } else {
+ MOVE(p, MATH0, 0, IFIFO, 0, 4, WAITCOMP | IMMED);
+ }
+ }
+
+ return 0;
+}
+
+static inline int
+pdcp_insert_cplane_snow_zuc_op(struct program *p,
+ bool swap __maybe_unused,
+ struct alginfo *cipherdata,
+ struct alginfo *authdata,
+ unsigned int dir,
+ enum pdcp_sn_size sn_size,
+ unsigned char era_2_sw_hfn_ovrd __maybe_unused)
+{
+ uint32_t offset = 0, length = 0, sn_mask = 0;
+
+ LABEL(keyjump);
+ REFERENCE(pkeyjump);
+
+ if (rta_sec_era < RTA_SEC_ERA_5) {
+ pr_err("Invalid era for selected algorithm\n");
+ return -ENOTSUP;
+ }
+
+ pkeyjump = JUMP(p, keyjump, LOCAL_JUMP, ALL_TRUE, SHRD | SELF | BOTH);
+ KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
+ cipherdata->keylen, INLINE_KEY(cipherdata));
+ KEY(p, KEY2, authdata->key_enc_flags, authdata->key, authdata->keylen,
+ INLINE_KEY(authdata));
+
+ SET_LABEL(p, keyjump);
+
+ if ((rta_sec_era >= RTA_SEC_ERA_8 && sn_size != PDCP_SN_SIZE_18) ||
+ (rta_sec_era == RTA_SEC_ERA_10)) {
+ int pclid;
+
+ if (sn_size == PDCP_SN_SIZE_5)
+ pclid = OP_PCLID_LTE_PDCP_CTRL_MIXED;
+ else
+ pclid = OP_PCLID_LTE_PDCP_USER_RN;
+
+ PROTOCOL(p, dir, pclid,
+ ((uint16_t)cipherdata->algtype << 8) |
+ (uint16_t)authdata->algtype);
+ return 0;
+ }
+ /* Non-proto is supported only for 5bit cplane and 18bit uplane */
+ switch (sn_size) {
+ case PDCP_SN_SIZE_5:
+ offset = 7;
+ length = 1;
+ sn_mask = (swap == false) ? PDCP_C_PLANE_SN_MASK :
+ PDCP_C_PLANE_SN_MASK_BE;
+ break;
+ case PDCP_SN_SIZE_18:
+ offset = 5;
+ length = 3;
+ sn_mask = (swap == false) ? PDCP_U_PLANE_18BIT_SN_MASK :
+ PDCP_U_PLANE_18BIT_SN_MASK_BE;
+ break;
+ case PDCP_SN_SIZE_7:
+ case PDCP_SN_SIZE_12:
+ case PDCP_SN_SIZE_15:
+ pr_err("Invalid sn_size for %s\n", __func__);
+ return -ENOTSUP;
+
+ }
+
+ SEQLOAD(p, MATH0, offset, length, 0);
+ JUMP(p, 1, LOCAL_JUMP, ALL_TRUE, CALM);
+ MOVEB(p, MATH0, offset, IFIFOAB2, 0, length, IMMED);
+ MATHB(p, MATH0, AND, sn_mask, MATH1, 8, IFB | IMMED2);
+
+ MATHB(p, MATH1, SHLD, MATH1, MATH1, 8, 0);
+ MOVEB(p, DESCBUF, 4, MATH2, 0, 8, WAITCOMP | IMMED);
+ MATHB(p, MATH1, OR, MATH2, MATH2, 8, 0);
+ MOVEB(p, MATH2, 0, CONTEXT1, 0, 8, IMMED);
+ MOVEB(p, MATH2, 0, CONTEXT2, 0, 8, WAITCOMP | IMMED);
+
+ if (dir == OP_TYPE_ENCAP_PROTOCOL)
+ MATHB(p, SEQINSZ, ADD, PDCP_MAC_I_LEN, VSEQOUTSZ, 4, IMMED2);
+ else
+ MATHB(p, SEQINSZ, SUB, PDCP_MAC_I_LEN, VSEQOUTSZ, 4, IMMED2);
+
+ MATHB(p, SEQINSZ, SUB, ZERO, VSEQINSZ, 4, 0);
+ SEQSTORE(p, MATH0, offset, length, 0);
+
+ if (dir == OP_TYPE_ENCAP_PROTOCOL) {
+ SEQFIFOSTORE(p, MSG, 0, 0, VLF);
+ SEQFIFOLOAD(p, MSGINSNOOP, 0, VLF | LAST2);
+ } else {
+ SEQFIFOSTORE(p, MSG, 0, 0, VLF | CONT);
+ SEQFIFOLOAD(p, MSGOUTSNOOP, 0, VLF | LAST1 | FLUSH1);
+ }
+
+ ALG_OPERATION(p, OP_ALG_ALGSEL_ZUCA,
+ OP_ALG_AAI_F9,
+ OP_ALG_AS_INITFINAL,
+ dir == OP_TYPE_ENCAP_PROTOCOL ?
+ ICV_CHECK_DISABLE : ICV_CHECK_ENABLE,
+ DIR_ENC);
+
+ ALG_OPERATION(p, OP_ALG_ALGSEL_SNOW_F8,
+ OP_ALG_AAI_F8,
+ OP_ALG_AS_INITFINAL,
+ ICV_CHECK_DISABLE,
+ dir == OP_TYPE_ENCAP_PROTOCOL ? DIR_ENC : DIR_DEC);
+ if (dir == OP_TYPE_ENCAP_PROTOCOL) {
+ MOVE(p, CONTEXT2, 0, IFIFOAB1, 0, 4, LAST1 | FLUSH1 | IMMED);
+ } else {
+ /* Save ICV */
+ MOVE(p, OFIFO, 0, MATH0, 0, 4, IMMED);
+ LOAD(p, NFIFOENTRY_STYPE_ALTSOURCE |
+ NFIFOENTRY_DEST_CLASS2 |
+ NFIFOENTRY_DTYPE_ICV |
+ NFIFOENTRY_LC2 | 4, NFIFO_SZL, 0, 4, IMMED);
+ MOVE(p, MATH0, 0, ALTSOURCE, 0, 4, WAITCOMP | IMMED);
+ }
+
+ /* Reset ZUCA mode and done interrupt */
+ LOAD(p, CLRW_CLR_C2MODE, CLRW, 0, 4, IMMED);
+ LOAD(p, CIRQ_ZADI, ICTRL, 0, 4, IMMED);
+
+ PATCH_JUMP(p, pkeyjump, keyjump);
+ return 0;
+}
+
+static inline int
+pdcp_insert_cplane_aes_zuc_op(struct program *p,
+ bool swap __maybe_unused,
+ struct alginfo *cipherdata,
+ struct alginfo *authdata,
+ unsigned int dir,
+ enum pdcp_sn_size sn_size,
+ unsigned char era_2_sw_hfn_ovrd __maybe_unused)
+{
+ uint32_t offset = 0, length = 0, sn_mask = 0;
+ LABEL(keyjump);
+ REFERENCE(pkeyjump);
+
+ if (rta_sec_era < RTA_SEC_ERA_5) {
+ pr_err("Invalid era for selected algorithm\n");
+ return -ENOTSUP;
+ }
+
+ pkeyjump = JUMP(p, keyjump, LOCAL_JUMP, ALL_TRUE, SHRD | SELF | BOTH);
+ KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
+ cipherdata->keylen, INLINE_KEY(cipherdata));
+ KEY(p, KEY2, authdata->key_enc_flags, authdata->key, authdata->keylen,
+ INLINE_KEY(authdata));
+
+ if ((rta_sec_era >= RTA_SEC_ERA_8 && sn_size != PDCP_SN_SIZE_18) ||
+ (rta_sec_era == RTA_SEC_ERA_10)) {
+ int pclid;
+
+ if (sn_size == PDCP_SN_SIZE_5)
+ pclid = OP_PCLID_LTE_PDCP_CTRL_MIXED;
+ else
+ pclid = OP_PCLID_LTE_PDCP_USER_RN;
+
+ PROTOCOL(p, dir, pclid,
+ ((uint16_t)cipherdata->algtype << 8) |
+ (uint16_t)authdata->algtype);
+
+ return 0;
+ }
+ /* Non-proto is supported only for 5bit cplane and 18bit uplane */
+ switch (sn_size) {
+ case PDCP_SN_SIZE_5:
+ offset = 7;
+ length = 1;
+ sn_mask = (swap == false) ? PDCP_C_PLANE_SN_MASK :
+ PDCP_C_PLANE_SN_MASK_BE;
+ break;
+ case PDCP_SN_SIZE_18:
+ offset = 5;
+ length = 3;
+ sn_mask = (swap == false) ? PDCP_U_PLANE_18BIT_SN_MASK :
+ PDCP_U_PLANE_18BIT_SN_MASK_BE;
+ break;
+ case PDCP_SN_SIZE_7:
+ case PDCP_SN_SIZE_12:
+ case PDCP_SN_SIZE_15:
+ pr_err("Invalid sn_size for %s\n", __func__);
+ return -ENOTSUP;
+
+ }
+
+ SET_LABEL(p, keyjump);
+ SEQLOAD(p, MATH0, offset, length, 0);
+ JUMP(p, 1, LOCAL_JUMP, ALL_TRUE, CALM);
+ MOVEB(p, MATH0, offset, IFIFOAB2, 0, length, IMMED);
+ MATHB(p, MATH0, AND, sn_mask, MATH1, 8, IFB | IMMED2);
+
+ MATHB(p, MATH1, SHLD, MATH1, MATH1, 8, 0);
+ MOVEB(p, DESCBUF, 4, MATH2, 0, 8, WAITCOMP | IMMED);
+ MATHB(p, MATH1, OR, MATH2, MATH2, 8, 0);
+ MOVEB(p, MATH2, 0, CONTEXT1, 16, 8, IMMED);
+ MOVEB(p, MATH2, 0, CONTEXT2, 0, 8, WAITCOMP | IMMED);
+
+ if (dir == OP_TYPE_ENCAP_PROTOCOL)
+ MATHB(p, SEQINSZ, ADD, PDCP_MAC_I_LEN, VSEQOUTSZ, 4, IMMED2);
+ else
+ MATHB(p, SEQINSZ, SUB, PDCP_MAC_I_LEN, VSEQOUTSZ, 4, IMMED2);
+
+ MATHB(p, SEQINSZ, SUB, ZERO, VSEQINSZ, 4, 0);
+ SEQSTORE(p, MATH0, offset, length, 0);
+
+ if (dir == OP_TYPE_ENCAP_PROTOCOL) {
+ SEQFIFOSTORE(p, MSG, 0, 0, VLF);
+ SEQFIFOLOAD(p, MSGINSNOOP, 0, VLF | LAST2);
+ } else {
+ SEQFIFOSTORE(p, MSG, 0, 0, VLF | CONT);
+ SEQFIFOLOAD(p, MSGOUTSNOOP, 0, VLF | LAST1 | FLUSH1);
+ }
+
+ ALG_OPERATION(p, OP_ALG_ALGSEL_ZUCA,
+ OP_ALG_AAI_F9,
+ OP_ALG_AS_INITFINAL,
+ dir == OP_TYPE_ENCAP_PROTOCOL ?
+ ICV_CHECK_DISABLE : ICV_CHECK_ENABLE,
+ DIR_ENC);
+
+ ALG_OPERATION(p, OP_ALG_ALGSEL_AES,
+ OP_ALG_AAI_CTR,
+ OP_ALG_AS_INITFINAL,
+ ICV_CHECK_DISABLE,
+ dir == OP_TYPE_ENCAP_PROTOCOL ? DIR_ENC : DIR_DEC);
+
+ if (dir == OP_TYPE_ENCAP_PROTOCOL) {
+ MOVE(p, CONTEXT2, 0, IFIFOAB1, 0, 4, LAST1 | FLUSH1 | IMMED);
+ } else {
+ /* Save ICV */
+ MOVE(p, OFIFO, 0, MATH0, 0, 4, IMMED);
+
+ LOAD(p, NFIFOENTRY_STYPE_ALTSOURCE |
+ NFIFOENTRY_DEST_CLASS2 |
+ NFIFOENTRY_DTYPE_ICV |
+ NFIFOENTRY_LC2 | 4, NFIFO_SZL, 0, 4, IMMED);
+ MOVE(p, MATH0, 0, ALTSOURCE, 0, 4, WAITCOMP | IMMED);
+ }
+
+ /* Reset ZUCA mode and done interrupt */
+ LOAD(p, CLRW_CLR_C2MODE, CLRW, 0, 4, IMMED);
+ LOAD(p, CIRQ_ZADI, ICTRL, 0, 4, IMMED);
+
+ PATCH_JUMP(p, pkeyjump, keyjump);
+
+ return 0;
+}
+
+static inline int
+pdcp_insert_cplane_zuc_snow_op(struct program *p,
+ bool swap __maybe_unused,
+ struct alginfo *cipherdata,
+ struct alginfo *authdata,
+ unsigned int dir,
+ enum pdcp_sn_size sn_size,
+ unsigned char era_2_sw_hfn_ovrd __maybe_unused)
+{
+ uint32_t offset = 0, length = 0, sn_mask = 0;
+ LABEL(keyjump);
+ REFERENCE(pkeyjump);
+
+ if (rta_sec_era < RTA_SEC_ERA_5) {
+ pr_err("Invalid era for selected algorithm\n");
+ return -ENOTSUP;
+ }
+
+ pkeyjump = JUMP(p, keyjump, LOCAL_JUMP, ALL_TRUE, SHRD | SELF | BOTH);
+ KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
+ cipherdata->keylen, INLINE_KEY(cipherdata));
+ KEY(p, KEY2, authdata->key_enc_flags, authdata->key, authdata->keylen,
+ INLINE_KEY(authdata));
+
+ if ((rta_sec_era >= RTA_SEC_ERA_8 && sn_size != PDCP_SN_SIZE_18) ||
+ (rta_sec_era == RTA_SEC_ERA_10)) {
+ int pclid;
+
+ if (sn_size == PDCP_SN_SIZE_5)
+ pclid = OP_PCLID_LTE_PDCP_CTRL_MIXED;
+ else
+ pclid = OP_PCLID_LTE_PDCP_USER_RN;
+
+ PROTOCOL(p, dir, pclid,
+ ((uint16_t)cipherdata->algtype << 8) |
+ (uint16_t)authdata->algtype);
+
+ return 0;
+ }
+ /* Non-proto is supported only for 5bit cplane and 18bit uplane */
+ switch (sn_size) {
+ case PDCP_SN_SIZE_5:
+ offset = 7;
+ length = 1;
+ sn_mask = (swap == false) ? PDCP_C_PLANE_SN_MASK :
+ PDCP_C_PLANE_SN_MASK_BE;
+ break;
+ case PDCP_SN_SIZE_18:
+ offset = 5;
+ length = 3;
+ sn_mask = (swap == false) ? PDCP_U_PLANE_18BIT_SN_MASK :
+ PDCP_U_PLANE_18BIT_SN_MASK_BE;
+ break;
+ case PDCP_SN_SIZE_7:
+ case PDCP_SN_SIZE_12:
+ case PDCP_SN_SIZE_15:
+ pr_err("Invalid sn_size for %s\n", __func__);
+ return -ENOTSUP;
+
+ }
+ SET_LABEL(p, keyjump);
+ SEQLOAD(p, MATH0, offset, length, 0);
+ JUMP(p, 1, LOCAL_JUMP, ALL_TRUE, CALM);
+ MOVEB(p, MATH0, offset, IFIFOAB2, 0, length, IMMED);
+ MATHB(p, MATH0, AND, sn_mask, MATH1, 8, IFB | IMMED2);
+
+ MATHB(p, MATH1, SHLD, MATH1, MATH1, 8, 0);
+ MOVEB(p, DESCBUF, 4, MATH2, 0, 8, WAITCOMP | IMMED);
+ MATHB(p, MATH1, OR, MATH2, MATH1, 8, 0);
+ MOVEB(p, MATH1, 0, CONTEXT1, 0, 8, IMMED);
+ MOVEB(p, MATH1, 0, CONTEXT2, 0, 4, IMMED);
+ if (swap == false) {
+ MATHB(p, MATH1, AND, upper_32_bits(PDCP_BEARER_MASK), MATH2,
+ 4, IMMED2);
+ MATHB(p, MATH1, AND, lower_32_bits(PDCP_DIR_MASK), MATH3,
+ 4, IMMED2);
+ } else {
+ MATHB(p, MATH1, AND, lower_32_bits(PDCP_BEARER_MASK_BE), MATH2,
+ 4, IMMED2);
+ MATHB(p, MATH1, AND, upper_32_bits(PDCP_DIR_MASK_BE), MATH3,
+ 4, IMMED2);
+ }
+ MATHB(p, MATH3, SHLD, MATH3, MATH3, 8, 0);
+ MOVEB(p, MATH2, 4, OFIFO, 0, 12, IMMED);
+ MOVE(p, OFIFO, 0, CONTEXT2, 4, 12, IMMED);
+
+ if (dir == OP_TYPE_ENCAP_PROTOCOL) {
+ MATHB(p, SEQINSZ, ADD, PDCP_MAC_I_LEN, VSEQOUTSZ, 4, IMMED2);
+ MATHB(p, SEQINSZ, SUB, ZERO, VSEQINSZ, 4, 0);
+ } else {
+ MATHB(p, SEQINSZ, SUB, PDCP_MAC_I_LEN, VSEQOUTSZ, 4, IMMED2);
+ MATHB(p, VSEQOUTSZ, SUB, ZERO, VSEQINSZ, 4, 0);
+ }
+
+ SEQSTORE(p, MATH0, offset, length, 0);
+
+ if (dir == OP_TYPE_ENCAP_PROTOCOL) {
+ SEQFIFOSTORE(p, MSG, 0, 0, VLF);
+ SEQFIFOLOAD(p, MSGINSNOOP, 0, VLF | LAST2);
+ } else {
+ SEQFIFOSTORE(p, MSG, 0, 0, VLF | CONT);
+ SEQFIFOLOAD(p, MSGOUTSNOOP, 0, VLF | LAST2);
+ }
+
+ ALG_OPERATION(p, OP_ALG_ALGSEL_SNOW_F9,
+ OP_ALG_AAI_F9,
+ OP_ALG_AS_INITFINAL,
+ dir == OP_TYPE_ENCAP_PROTOCOL ?
+ ICV_CHECK_DISABLE : ICV_CHECK_ENABLE,
+ DIR_DEC);
+
+ ALG_OPERATION(p, OP_ALG_ALGSEL_ZUCE,
+ OP_ALG_AAI_F8,
+ OP_ALG_AS_INITFINAL,
+ ICV_CHECK_DISABLE,
+ dir == OP_TYPE_ENCAP_PROTOCOL ? DIR_ENC : DIR_DEC);
+
+ if (dir == OP_TYPE_ENCAP_PROTOCOL) {
+ MOVE(p, CONTEXT2, 0, IFIFOAB1, 0, 4, LAST1 | FLUSH1 | IMMED);
+ } else {
+ SEQFIFOLOAD(p, MSG1, 4, LAST1 | FLUSH1);
+ JUMP(p, 1, LOCAL_JUMP, ALL_TRUE, CLASS1 | NOP | NIFP);
+
+ if (rta_sec_era >= RTA_SEC_ERA_6)
+ /*
+ * For SEC ERA 6, there's a problem with the OFIFO
+ * pointer, and thus it needs to be reset here before
+ * moving to M0.
+ */
+ LOAD(p, 0, DCTRL, 0, LDLEN_RST_CHA_OFIFO_PTR, IMMED);
+
+ /* Put ICV to M0 before sending it to C2 for comparison. */
+ MOVEB(p, OFIFO, 0, MATH0, 0, 4, WAITCOMP | IMMED);
+
+ LOAD(p, NFIFOENTRY_STYPE_ALTSOURCE |
+ NFIFOENTRY_DEST_CLASS2 |
+ NFIFOENTRY_DTYPE_ICV |
+ NFIFOENTRY_LC2 | 4, NFIFO_SZL, 0, 4, IMMED);
+ MOVEB(p, MATH0, 0, ALTSOURCE, 0, 4, IMMED);
+ }
+
+ PATCH_JUMP(p, pkeyjump, keyjump);
+ return 0;
+}
+
+static inline int
+pdcp_insert_cplane_zuc_aes_op(struct program *p,
+ bool swap __maybe_unused,
+ struct alginfo *cipherdata,
+ struct alginfo *authdata,
+ unsigned int dir,
+ enum pdcp_sn_size sn_size,
+ unsigned char era_2_sw_hfn_ovrd __maybe_unused)
+{
+ uint32_t offset = 0, length = 0, sn_mask = 0;
+ if (rta_sec_era < RTA_SEC_ERA_5) {
+ pr_err("Invalid era for selected algorithm\n");
+ return -ENOTSUP;
+ }
+
+ if ((rta_sec_era >= RTA_SEC_ERA_8 && sn_size != PDCP_SN_SIZE_18) ||
+ (rta_sec_era == RTA_SEC_ERA_10)) {
+ int pclid;
+
+ KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
+ cipherdata->keylen, INLINE_KEY(cipherdata));
+ KEY(p, KEY2, authdata->key_enc_flags, authdata->key,
+ authdata->keylen, INLINE_KEY(authdata));
+
+ if (sn_size == PDCP_SN_SIZE_5)
+ pclid = OP_PCLID_LTE_PDCP_CTRL_MIXED;
+ else
+ pclid = OP_PCLID_LTE_PDCP_USER_RN;
+
+ PROTOCOL(p, dir, pclid,
+ ((uint16_t)cipherdata->algtype << 8) |
+ (uint16_t)authdata->algtype);
+ return 0;
+ }
+ /* Non-proto is supported only for 5bit cplane and 18bit uplane */
+ switch (sn_size) {
+ case PDCP_SN_SIZE_5:
+ offset = 7;
+ length = 1;
+ sn_mask = (swap == false) ? PDCP_C_PLANE_SN_MASK :
+ PDCP_C_PLANE_SN_MASK_BE;
+ break;
+ case PDCP_SN_SIZE_18:
+ offset = 5;
+ length = 3;
+ sn_mask = (swap == false) ? PDCP_U_PLANE_18BIT_SN_MASK :
+ PDCP_U_PLANE_18BIT_SN_MASK_BE;
+ break;
+ case PDCP_SN_SIZE_7:
+ case PDCP_SN_SIZE_12:
+ case PDCP_SN_SIZE_15:
+ pr_err("Invalid sn_size for %s\n", __func__);
+ return -ENOTSUP;
+ }
+
+ SEQLOAD(p, MATH0, offset, length, 0);
+ JUMP(p, 1, LOCAL_JUMP, ALL_TRUE, CALM);
+ MATHB(p, MATH0, AND, sn_mask, MATH1, 8, IFB | IMMED2);
+
+ MATHB(p, MATH1, SHLD, MATH1, MATH1, 8, 0);
+ MOVEB(p, DESCBUF, 4, MATH2, 0, 0x08, WAITCOMP | IMMED);
+ MATHB(p, MATH1, OR, MATH2, MATH2, 8, 0);
+ SEQSTORE(p, MATH0, offset, length, 0);
+ if (dir == OP_TYPE_ENCAP_PROTOCOL) {
+ KEY(p, KEY1, authdata->key_enc_flags, authdata->key,
+ authdata->keylen, INLINE_KEY(authdata));
+ MOVEB(p, MATH2, 0, IFIFOAB1, 0, 0x08, IMMED);
+ MOVEB(p, MATH0, offset, IFIFOAB1, 0, length, IMMED);
+
+ MATHB(p, SEQINSZ, SUB, ZERO, VSEQINSZ, 4, 0);
+ MATHB(p, VSEQINSZ, ADD, PDCP_MAC_I_LEN, VSEQOUTSZ, 4, IMMED2);
+
+ ALG_OPERATION(p, OP_ALG_ALGSEL_AES,
+ OP_ALG_AAI_CMAC,
+ OP_ALG_AS_INITFINAL,
+ ICV_CHECK_DISABLE,
+ DIR_DEC);
+ SEQFIFOLOAD(p, MSG1, 0, VLF | LAST1 | FLUSH1);
+ MOVEB(p, CONTEXT1, 0, MATH3, 0, 4, WAITCOMP | IMMED);
+ LOAD(p, CLRW_RESET_CLS1_CHA |
+ CLRW_CLR_C1KEY |
+ CLRW_CLR_C1CTX |
+ CLRW_CLR_C1ICV |
+ CLRW_CLR_C1DATAS |
+ CLRW_CLR_C1MODE,
+ CLRW, 0, 4, IMMED);
+
+ KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
+ cipherdata->keylen, INLINE_KEY(cipherdata));
+
+ MOVEB(p, MATH2, 0, CONTEXT1, 0, 8, IMMED);
+ SEQINPTR(p, 0, PDCP_NULL_MAX_FRAME_LEN, RTO);
+
+ ALG_OPERATION(p, OP_ALG_ALGSEL_ZUCE,
+ OP_ALG_AAI_F8,
+ OP_ALG_AS_INITFINAL,
+ ICV_CHECK_DISABLE,
+ DIR_ENC);
+ SEQFIFOSTORE(p, MSG, 0, 0, VLF);
+
+ SEQFIFOLOAD(p, SKIP, length, 0);
+
+ SEQFIFOLOAD(p, MSG1, 0, VLF);
+ MOVEB(p, MATH3, 0, IFIFOAB1, 0, 4, LAST1 | FLUSH1 | IMMED);
+ } else {
+ MOVEB(p, MATH2, 0, CONTEXT1, 0, 8, IMMED);
+
+ MOVE(p, CONTEXT1, 0, CONTEXT2, 0, 8, IMMED);
+
+ MATHB(p, SEQINSZ, SUB, ZERO, VSEQINSZ, 4, 0);
+
+ MATHB(p, SEQINSZ, SUB, PDCP_MAC_I_LEN, VSEQOUTSZ, 4, IMMED2);
+
+ KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
+ cipherdata->keylen, INLINE_KEY(cipherdata));
+
+ MOVE(p, CONTEXT1, 0, CONTEXT2, 0, 8, IMMED);
+
+ ALG_OPERATION(p, OP_ALG_ALGSEL_ZUCE,
+ OP_ALG_AAI_F8,
+ OP_ALG_AS_INITFINAL,
+ ICV_CHECK_DISABLE,
+ DIR_DEC);
+ SEQFIFOSTORE(p, MSG, 0, 0, VLF | CONT);
+ SEQFIFOLOAD(p, MSG1, 0, VLF | LAST1 | FLUSH1);
+
+ MOVEB(p, OFIFO, 0, MATH3, 0, 4, IMMED);
+
+ LOAD(p, CLRW_RESET_CLS1_CHA |
+ CLRW_CLR_C1KEY |
+ CLRW_CLR_C1CTX |
+ CLRW_CLR_C1ICV |
+ CLRW_CLR_C1DATAS |
+ CLRW_CLR_C1MODE,
+ CLRW, 0, 4, IMMED);
+
+ KEY(p, KEY1, authdata->key_enc_flags, authdata->key,
+ authdata->keylen, INLINE_KEY(authdata));
+
+ SEQINPTR(p, 0, 0, SOP);
+
+ ALG_OPERATION(p, OP_ALG_ALGSEL_AES,
+ OP_ALG_AAI_CMAC,
+ OP_ALG_AS_INITFINAL,
+ ICV_CHECK_ENABLE,
+ DIR_DEC);
+
+ MATHB(p, SEQINSZ, SUB, ZERO, VSEQINSZ, 4, 0);
+
+ MOVE(p, CONTEXT2, 0, IFIFOAB1, 0, 8, IMMED);
+
+ SEQFIFOLOAD(p, MSG1, 0, VLF | LAST1 | FLUSH1);
+
+ LOAD(p, NFIFOENTRY_STYPE_ALTSOURCE |
+ NFIFOENTRY_DEST_CLASS1 |
+ NFIFOENTRY_DTYPE_ICV |
+ NFIFOENTRY_LC1 |
+ NFIFOENTRY_FC1 | 4, NFIFO_SZL, 0, 4, IMMED);
+ MOVEB(p, MATH3, 0, ALTSOURCE, 0, 4, IMMED);
+ }
+
+ return 0;
+}
+
+static inline int
+pdcp_insert_uplane_no_int_op(struct program *p,
+ bool swap __maybe_unused,
+ struct alginfo *cipherdata,
+ unsigned int dir,
+ enum pdcp_sn_size sn_size)
+{
+ int op;
+ uint32_t sn_mask;
+
+ /* Insert Cipher Key */
+ KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
+ cipherdata->keylen, INLINE_KEY(cipherdata));
+
+ if ((rta_sec_era >= RTA_SEC_ERA_8 && sn_size == PDCP_SN_SIZE_15) ||
+ (rta_sec_era >= RTA_SEC_ERA_10)) {
+ PROTOCOL(p, dir, OP_PCLID_LTE_PDCP_USER,
+ (uint16_t)cipherdata->algtype);
+ return 0;
+ }
+
+ if (sn_size == PDCP_SN_SIZE_15) {
+ SEQLOAD(p, MATH0, 6, 2, 0);
+ sn_mask = (swap == false) ? PDCP_U_PLANE_15BIT_SN_MASK :
+ PDCP_U_PLANE_15BIT_SN_MASK_BE;
+ } else { /* SN Size == PDCP_SN_SIZE_18 */
+ SEQLOAD(p, MATH0, 5, 3, 0);
+ sn_mask = (swap == false) ? PDCP_U_PLANE_18BIT_SN_MASK :
+ PDCP_U_PLANE_18BIT_SN_MASK_BE;
+ }
+ JUMP(p, 1, LOCAL_JUMP, ALL_TRUE, CALM);
+ MATHB(p, MATH0, AND, sn_mask, MATH1, 8, IFB | IMMED2);
+
+ if (sn_size == PDCP_SN_SIZE_15)
+ SEQSTORE(p, MATH0, 6, 2, 0);
+ else /* SN Size == PDCP_SN_SIZE_18 */
+ SEQSTORE(p, MATH0, 5, 3, 0);
+
+ MATHB(p, MATH1, SHLD, MATH1, MATH1, 8, 0);
+ MOVEB(p, DESCBUF, 8, MATH2, 0, 8, WAITCOMP | IMMED);
+ MATHB(p, MATH1, OR, MATH2, MATH2, 8, 0);
+
+ MATHB(p, SEQINSZ, SUB, MATH3, VSEQINSZ, 4, 0);
+ MATHB(p, SEQINSZ, SUB, MATH3, VSEQOUTSZ, 4, 0);
+
+ SEQFIFOSTORE(p, MSG, 0, 0, VLF);
+
+ op = dir == OP_TYPE_ENCAP_PROTOCOL ? DIR_ENC : DIR_DEC;
+ switch (cipherdata->algtype) {
+ case PDCP_CIPHER_TYPE_SNOW:
+ MOVEB(p, MATH2, 0, CONTEXT1, 0, 8, WAITCOMP | IMMED);
+ ALG_OPERATION(p, OP_ALG_ALGSEL_SNOW_F8,
+ OP_ALG_AAI_F8,
+ OP_ALG_AS_INITFINAL,
+ ICV_CHECK_DISABLE,
+ op);
+ break;
+
+ case PDCP_CIPHER_TYPE_AES:
+ MOVEB(p, MATH2, 0, CONTEXT1, 0x10, 0x10, WAITCOMP | IMMED);
+ ALG_OPERATION(p, OP_ALG_ALGSEL_AES,
+ OP_ALG_AAI_CTR,
+ OP_ALG_AS_INITFINAL,
+ ICV_CHECK_DISABLE,
+ op);
+ break;
+
+ case PDCP_CIPHER_TYPE_ZUC:
+ if (rta_sec_era < RTA_SEC_ERA_5) {
+ pr_err("Invalid era for selected algorithm\n");
+ return -ENOTSUP;
+ }
+ MOVEB(p, MATH2, 0, CONTEXT1, 0, 0x08, IMMED);
+ MOVEB(p, MATH2, 0, CONTEXT1, 0x08, 0x08, WAITCOMP | IMMED);
+
+ ALG_OPERATION(p, OP_ALG_ALGSEL_ZUCE,
+ OP_ALG_AAI_F8,
+ OP_ALG_AS_INITFINAL,
+ ICV_CHECK_DISABLE,
+ op);
+ break;
+
+ default:
+ pr_err("%s: Invalid encrypt algorithm selected: %d\n",
+ "pdcp_insert_uplane_15bit_op", cipherdata->algtype);
+ return -EINVAL;
+ }
+
+ SEQFIFOLOAD(p, MSG1, 0, VLF | LAST1 | FLUSH1);
+
+ return 0;
+}
+
+/*
+ * Function for inserting the snippet of code responsible for creating
+ * the HFN override code via either DPOVRD or via the input frame.
+ */
+static inline int
+insert_hfn_ov_op(struct program *p,
+ uint32_t shift,
+ enum pdb_type_e pdb_type,
+ unsigned char era_2_sw_hfn_ovrd)
+{
+ uint32_t imm = PDCP_DPOVRD_HFN_OV_EN;
+ uint16_t hfn_pdb_offset;
+ LABEL(keyjump);
+ REFERENCE(pkeyjump);
+
+ if (rta_sec_era == RTA_SEC_ERA_2 && !era_2_sw_hfn_ovrd)
+ return 0;
+
+ switch (pdb_type) {
+ case PDCP_PDB_TYPE_NO_PDB:
+ /*
+ * If there is no PDB, then HFN override mechanism does not
+ * make any sense, thus in this case the function will
+ * return the pointer to the current position in the
+ * descriptor buffer
+ */
+ return 0;
+
+ case PDCP_PDB_TYPE_REDUCED_PDB:
+ hfn_pdb_offset = 4;
+ break;
+
+ case PDCP_PDB_TYPE_FULL_PDB:
+ hfn_pdb_offset = 8;
+ break;
+
+ default:
+ return -EINVAL;
+ }
+
+ if (rta_sec_era > RTA_SEC_ERA_2) {
+ MATHB(p, DPOVRD, AND, imm, NONE, 8, IFB | IMMED2);
+ } else {
+ SEQLOAD(p, MATH0, 4, 4, 0);
+ JUMP(p, 1, LOCAL_JUMP, ALL_TRUE, CALM);
+ MATHB(p, MATH0, AND, imm, NONE, 8, IFB | IMMED2);
+ SEQSTORE(p, MATH0, 4, 4, 0);
+ }
+
+ pkeyjump = JUMP(p, keyjump, LOCAL_JUMP, ALL_TRUE, MATH_Z);
+
+ if (rta_sec_era > RTA_SEC_ERA_2)
+ MATHI(p, DPOVRD, LSHIFT, shift, MATH0, 4, IMMED2);
+ else
+ MATHB(p, MATH0, LSHIFT, shift, MATH0, 4, IMMED2);
+
+ MATHB(p, MATH0, SHLD, MATH0, MATH0, 8, 0);
+ MOVE(p, MATH0, 0, DESCBUF, hfn_pdb_offset, 4, IMMED);
+
+ if (rta_sec_era >= RTA_SEC_ERA_8)
+ /*
+ * For ERA8, DPOVRD could be handled by the PROTOCOL command
+ * itself. For now, this is not done. Thus, clear DPOVRD here
+ * to alleviate any side-effects.
+ */
+ MATHB(p, DPOVRD, AND, ZERO, DPOVRD, 4, STL);
+
+ SET_LABEL(p, keyjump);
+ PATCH_JUMP(p, pkeyjump, keyjump);
+ return 0;
+}
+
+/*
+ * PDCP Control PDB creation function
+ */
+static inline enum pdb_type_e
+cnstr_pdcp_c_plane_pdb(struct program *p,
+ uint32_t hfn,
+ enum pdcp_sn_size sn_size,
+ unsigned char bearer,
+ unsigned char direction,
+ uint32_t hfn_threshold,
+ struct alginfo *cipherdata,
+ struct alginfo *authdata)
+{
+ struct pdcp_pdb pdb;
+ enum pdb_type_e
+ pdb_mask[PDCP_CIPHER_TYPE_INVALID][PDCP_AUTH_TYPE_INVALID] = {
+ { /* NULL */
+ PDCP_PDB_TYPE_NO_PDB, /* NULL */
+ PDCP_PDB_TYPE_FULL_PDB, /* SNOW f9 */
+ PDCP_PDB_TYPE_FULL_PDB, /* AES CMAC */
+ PDCP_PDB_TYPE_FULL_PDB /* ZUC-I */
+ },
+ { /* SNOW f8 */
+ PDCP_PDB_TYPE_FULL_PDB, /* NULL */
+ PDCP_PDB_TYPE_FULL_PDB, /* SNOW f9 */
+ PDCP_PDB_TYPE_REDUCED_PDB, /* AES CMAC */
+ PDCP_PDB_TYPE_REDUCED_PDB /* ZUC-I */
+ },
+ { /* AES CTR */
+ PDCP_PDB_TYPE_FULL_PDB, /* NULL */
+ PDCP_PDB_TYPE_REDUCED_PDB, /* SNOW f9 */
+ PDCP_PDB_TYPE_FULL_PDB, /* AES CMAC */
+ PDCP_PDB_TYPE_REDUCED_PDB /* ZUC-I */
+ },
+ { /* ZUC-E */
+ PDCP_PDB_TYPE_FULL_PDB, /* NULL */
+ PDCP_PDB_TYPE_REDUCED_PDB, /* SNOW f9 */
+ PDCP_PDB_TYPE_REDUCED_PDB, /* AES CMAC */
+ PDCP_PDB_TYPE_FULL_PDB /* ZUC-I */
+ },
+ };
+
+ if (rta_sec_era >= RTA_SEC_ERA_8) {
+ memset(&pdb, 0x00, sizeof(struct pdcp_pdb));
+
+ /* To support 12-bit seq numbers, we use u-plane opt in pdb.
+ * SEC supports 5-bit only with c-plane opt in pdb.
+ */
+ if (sn_size == PDCP_SN_SIZE_12) {
+ pdb.hfn_res = hfn << PDCP_U_PLANE_PDB_LONG_SN_HFN_SHIFT;
+ pdb.bearer_dir_res = (uint32_t)
+ ((bearer << PDCP_U_PLANE_PDB_BEARER_SHIFT) |
+ (direction << PDCP_U_PLANE_PDB_DIR_SHIFT));
+
+ pdb.hfn_thr_res =
+ hfn_threshold << PDCP_U_PLANE_PDB_LONG_SN_HFN_THR_SHIFT;
+
+ } else {
+ /* This means 5-bit c-plane.
+ * Here we use c-plane opt in pdb
+ */
+
+ /* This is a HW issue. Bit 2 should be set to zero,
+ * but it does not work this way. Override here.
+ */
+ pdb.opt_res.rsvd = 0x00000002;
+
+ /* Copy relevant information from user to PDB */
+ pdb.hfn_res = hfn << PDCP_C_PLANE_PDB_HFN_SHIFT;
+ pdb.bearer_dir_res = (uint32_t)
+ ((bearer << PDCP_C_PLANE_PDB_BEARER_SHIFT) |
+ (direction << PDCP_C_PLANE_PDB_DIR_SHIFT));
+ pdb.hfn_thr_res =
+ hfn_threshold << PDCP_C_PLANE_PDB_HFN_THR_SHIFT;
+ }
+
+ /* copy PDB in descriptor*/
+ __rta_out32(p, pdb.opt_res.opt);
+ __rta_out32(p, pdb.hfn_res);
+ __rta_out32(p, pdb.bearer_dir_res);
+ __rta_out32(p, pdb.hfn_thr_res);
+
+ return PDCP_PDB_TYPE_FULL_PDB;
+ }
+
+ switch (pdb_mask[cipherdata->algtype][authdata->algtype]) {
+ case PDCP_PDB_TYPE_NO_PDB:
+ break;
+
+ case PDCP_PDB_TYPE_REDUCED_PDB:
+ __rta_out32(p, (hfn << PDCP_C_PLANE_PDB_HFN_SHIFT));
+ __rta_out32(p,
+ (uint32_t)((bearer <<
+ PDCP_C_PLANE_PDB_BEARER_SHIFT) |
+ (direction <<
+ PDCP_C_PLANE_PDB_DIR_SHIFT)));
+ break;
+
+ case PDCP_PDB_TYPE_FULL_PDB:
+ memset(&pdb, 0x00, sizeof(struct pdcp_pdb));
+
+ /* This is a HW issue. Bit 2 should be set to zero,
+ * but it does not work this way. Override here.
+ */
+ pdb.opt_res.rsvd = 0x00000002;
+
+ /* Copy relevant information from user to PDB */
+ pdb.hfn_res = hfn << PDCP_C_PLANE_PDB_HFN_SHIFT;
+ pdb.bearer_dir_res = (uint32_t)
+ ((bearer << PDCP_C_PLANE_PDB_BEARER_SHIFT) |
+ (direction << PDCP_C_PLANE_PDB_DIR_SHIFT));
+ pdb.hfn_thr_res =
+ hfn_threshold << PDCP_C_PLANE_PDB_HFN_THR_SHIFT;
+
+ /* copy PDB in descriptor*/
+ __rta_out32(p, pdb.opt_res.opt);
+ __rta_out32(p, pdb.hfn_res);
+ __rta_out32(p, pdb.bearer_dir_res);
+ __rta_out32(p, pdb.hfn_thr_res);
+
+ break;
+
+ default:
+ return PDCP_PDB_TYPE_INVALID;
+ }
+
+ return pdb_mask[cipherdata->algtype][authdata->algtype];
+}
+
+/*
+ * PDCP UPlane PDB creation function
+ */
+static inline enum pdb_type_e
+cnstr_pdcp_u_plane_pdb(struct program *p,
+ enum pdcp_sn_size sn_size,
+ uint32_t hfn, unsigned short bearer,
+ unsigned short direction,
+ uint32_t hfn_threshold,
+ struct alginfo *cipherdata,
+ struct alginfo *authdata)
+{
+ struct pdcp_pdb pdb;
+ enum pdb_type_e pdb_type = PDCP_PDB_TYPE_FULL_PDB;
+ enum pdb_type_e
+ pdb_mask[PDCP_CIPHER_TYPE_INVALID][PDCP_AUTH_TYPE_INVALID] = {
+ { /* NULL */
+ PDCP_PDB_TYPE_NO_PDB, /* NULL */
+ PDCP_PDB_TYPE_FULL_PDB, /* SNOW f9 */
+ PDCP_PDB_TYPE_FULL_PDB, /* AES CMAC */
+ PDCP_PDB_TYPE_FULL_PDB /* ZUC-I */
+ },
+ { /* SNOW f8 */
+ PDCP_PDB_TYPE_FULL_PDB, /* NULL */
+ PDCP_PDB_TYPE_FULL_PDB, /* SNOW f9 */
+ PDCP_PDB_TYPE_REDUCED_PDB, /* AES CMAC */
+ PDCP_PDB_TYPE_REDUCED_PDB /* ZUC-I */
+ },
+ { /* AES CTR */
+ PDCP_PDB_TYPE_FULL_PDB, /* NULL */
+ PDCP_PDB_TYPE_REDUCED_PDB, /* SNOW f9 */
+ PDCP_PDB_TYPE_FULL_PDB, /* AES CMAC */
+ PDCP_PDB_TYPE_REDUCED_PDB /* ZUC-I */
+ },
+ { /* ZUC-E */
+ PDCP_PDB_TYPE_FULL_PDB, /* NULL */
+ PDCP_PDB_TYPE_REDUCED_PDB, /* SNOW f9 */
+ PDCP_PDB_TYPE_REDUCED_PDB, /* AES CMAC */
+ PDCP_PDB_TYPE_FULL_PDB /* ZUC-I */
+ },
+ };
+
+ /* Read options from user */
+ /* Depending on sequence number length, the HFN and HFN threshold
+ * have different lengths.
+ */
+ memset(&pdb, 0x00, sizeof(struct pdcp_pdb));
+
+ switch (sn_size) {
+ case PDCP_SN_SIZE_7:
+ pdb.opt_res.opt |= PDCP_U_PLANE_PDB_OPT_SHORT_SN;
+ pdb.hfn_res = hfn << PDCP_U_PLANE_PDB_SHORT_SN_HFN_SHIFT;
+ pdb.hfn_thr_res =
+ hfn_threshold<<PDCP_U_PLANE_PDB_SHORT_SN_HFN_THR_SHIFT;
+ break;
+
+ case PDCP_SN_SIZE_12:
+ pdb.opt_res.opt &= (uint32_t)(~PDCP_U_PLANE_PDB_OPT_SHORT_SN);
+ pdb.hfn_res = hfn << PDCP_U_PLANE_PDB_LONG_SN_HFN_SHIFT;
+ pdb.hfn_thr_res =
+ hfn_threshold<<PDCP_U_PLANE_PDB_LONG_SN_HFN_THR_SHIFT;
+ break;
+
+ case PDCP_SN_SIZE_15:
+ pdb.opt_res.opt = (uint32_t)(PDCP_U_PLANE_PDB_OPT_15B_SN);
+ pdb.hfn_res = hfn << PDCP_U_PLANE_PDB_15BIT_SN_HFN_SHIFT;
+ pdb.hfn_thr_res =
+ hfn_threshold<<PDCP_U_PLANE_PDB_15BIT_SN_HFN_THR_SHIFT;
+ break;
+
+ case PDCP_SN_SIZE_18:
+ pdb.opt_res.opt = (uint32_t)(PDCP_U_PLANE_PDB_OPT_18B_SN);
+ pdb.hfn_res = hfn << PDCP_U_PLANE_PDB_18BIT_SN_HFN_SHIFT;
+ pdb.hfn_thr_res =
+ hfn_threshold<<PDCP_U_PLANE_PDB_18BIT_SN_HFN_THR_SHIFT;
+
+ if (rta_sec_era <= RTA_SEC_ERA_8) {
+ if (cipherdata && authdata)
+ pdb_type = pdb_mask[cipherdata->algtype]
+ [authdata->algtype];
+ }
+ break;
+
+ default:
+ pr_err("Invalid Sequence Number Size setting in PDB\n");
+ return -EINVAL;
+ }
+
+ pdb.bearer_dir_res = (uint32_t)
+ ((bearer << PDCP_U_PLANE_PDB_BEARER_SHIFT) |
+ (direction << PDCP_U_PLANE_PDB_DIR_SHIFT));
+
+ switch (pdb_type) {
+ case PDCP_PDB_TYPE_NO_PDB:
+ break;
+
+ case PDCP_PDB_TYPE_REDUCED_PDB:
+ __rta_out32(p, pdb.hfn_res);
+ __rta_out32(p, pdb.bearer_dir_res);
+ break;
+
+ case PDCP_PDB_TYPE_FULL_PDB:
+ /* copy PDB in descriptor*/
+ __rta_out32(p, pdb.opt_res.opt);
+ __rta_out32(p, pdb.hfn_res);
+ __rta_out32(p, pdb.bearer_dir_res);
+ __rta_out32(p, pdb.hfn_thr_res);
+
+ break;
+
+ default:
+ return PDCP_PDB_TYPE_INVALID;
+ }
+
+ return pdb_type;
+}
+/**
+ * cnstr_shdsc_pdcp_c_plane_encap - Function for creating a PDCP Control Plane
+ * encapsulation descriptor.
+ * @descbuf: pointer to buffer for descriptor construction
+ * @ps: if 36/40bit addressing is desired, this parameter must be true
+ * @swap: must be true when core endianness doesn't match SEC endianness
+ * @hfn: starting Hyper Frame Number to be used together with the SN from the
+ * PDCP frames.
+ * @sn_size: size of sequence numbers, only 5/12 bit sequence numbers are valid
+ * @bearer: radio bearer ID
+ * @direction: the direction of the PDCP frame (UL/DL)
+ * @hfn_threshold: HFN value that once reached triggers a warning from SEC that
+ * keys should be renegotiated at the earliest convenience.
+ * @cipherdata: pointer to block cipher transform definitions
+ * Valid algorithm values are those from cipher_type_pdcp enum.
+ * @authdata: pointer to authentication transform definitions
+ * Valid algorithm values are those from auth_type_pdcp enum.
+ * @era_2_sw_hfn_ovrd: if software HFN override mechanism is desired for
+ * this descriptor. Note: Can only be used for
+ * SEC ERA 2.
+ * Return: size of descriptor written in words or negative number on error.
+ * Once the function returns, the value of this parameter can be used
+ * for reclaiming the space that wasn't used for the descriptor.
+ *
+ * Note: descbuf must be large enough to contain a full 256 byte long
+ * descriptor; after the function returns, by subtracting the actual number of
+ * bytes used, the user can reuse the remaining buffer space for other purposes.
+ */
+static inline int
+cnstr_shdsc_pdcp_c_plane_encap(uint32_t *descbuf,
+ bool ps,
+ bool swap,
+ uint32_t hfn,
+ enum pdcp_sn_size sn_size,
+ unsigned char bearer,
+ unsigned char direction,
+ uint32_t hfn_threshold,
+ struct alginfo *cipherdata,
+ struct alginfo *authdata,
+ unsigned char era_2_sw_hfn_ovrd)
+{
+ static int
+ (*pdcp_cp_fp[PDCP_CIPHER_TYPE_INVALID][PDCP_AUTH_TYPE_INVALID])
+ (struct program*, bool swap, struct alginfo *,
+ struct alginfo *, unsigned int, enum pdcp_sn_size,
+ unsigned char __maybe_unused) = {
+ { /* NULL */
+ pdcp_insert_cplane_null_op, /* NULL */
+ pdcp_insert_cplane_int_only_op, /* SNOW f9 */
+ pdcp_insert_cplane_int_only_op, /* AES CMAC */
+ pdcp_insert_cplane_int_only_op /* ZUC-I */
+ },
+ { /* SNOW f8 */
+ pdcp_insert_cplane_enc_only_op, /* NULL */
+ pdcp_insert_cplane_acc_op, /* SNOW f9 */
+ pdcp_insert_cplane_snow_aes_op, /* AES CMAC */
+ pdcp_insert_cplane_snow_zuc_op /* ZUC-I */
+ },
+ { /* AES CTR */
+ pdcp_insert_cplane_enc_only_op, /* NULL */
+ pdcp_insert_cplane_aes_snow_op, /* SNOW f9 */
+ pdcp_insert_cplane_acc_op, /* AES CMAC */
+ pdcp_insert_cplane_aes_zuc_op /* ZUC-I */
+ },
+ { /* ZUC-E */
+ pdcp_insert_cplane_enc_only_op, /* NULL */
+ pdcp_insert_cplane_zuc_snow_op, /* SNOW f9 */
+ pdcp_insert_cplane_zuc_aes_op, /* AES CMAC */
+ pdcp_insert_cplane_acc_op /* ZUC-I */
+ },
+ };
+ static enum rta_share_type
+ desc_share[PDCP_CIPHER_TYPE_INVALID][PDCP_AUTH_TYPE_INVALID] = {
+ { /* NULL */
+ SHR_WAIT, /* NULL */
+ SHR_ALWAYS, /* SNOW f9 */
+ SHR_ALWAYS, /* AES CMAC */
+ SHR_ALWAYS /* ZUC-I */
+ },
+ { /* SNOW f8 */
+ SHR_ALWAYS, /* NULL */
+ SHR_ALWAYS, /* SNOW f9 */
+ SHR_WAIT, /* AES CMAC */
+ SHR_WAIT /* ZUC-I */
+ },
+ { /* AES CTR */
+ SHR_ALWAYS, /* NULL */
+ SHR_ALWAYS, /* SNOW f9 */
+ SHR_ALWAYS, /* AES CMAC */
+ SHR_WAIT /* ZUC-I */
+ },
+ { /* ZUC-E */
+ SHR_ALWAYS, /* NULL */
+ SHR_WAIT, /* SNOW f9 */
+ SHR_WAIT, /* AES CMAC */
+ SHR_ALWAYS /* ZUC-I */
+ },
+ };
+ enum pdb_type_e pdb_type;
+ struct program prg;
+ struct program *p = &prg;
+ int err;
+ LABEL(pdb_end);
+
+ if (rta_sec_era != RTA_SEC_ERA_2 && era_2_sw_hfn_ovrd) {
+ pr_err("Cannot select SW HFN override for other era than 2");
+ return -EINVAL;
+ }
+
+ if (sn_size != PDCP_SN_SIZE_12 && sn_size != PDCP_SN_SIZE_5) {
+ pr_err("C-plane supports only 5-bit and 12-bit sequence numbers\n");
+ return -EINVAL;
+ }
+
+ PROGRAM_CNTXT_INIT(p, descbuf, 0);
+ if (swap)
+ PROGRAM_SET_BSWAP(p);
+ if (ps)
+ PROGRAM_SET_36BIT_ADDR(p);
+
+ SHR_HDR(p, desc_share[cipherdata->algtype][authdata->algtype], 0, 0);
+
+ pdb_type = cnstr_pdcp_c_plane_pdb(p,
+ hfn,
+ sn_size,
+ bearer,
+ direction,
+ hfn_threshold,
+ cipherdata,
+ authdata);
+
+ SET_LABEL(p, pdb_end);
+
+ err = insert_hfn_ov_op(p, sn_size, pdb_type,
+ era_2_sw_hfn_ovrd);
+ if (err)
+ return err;
+
+ err = pdcp_cp_fp[cipherdata->algtype][authdata->algtype](p,
+ swap,
+ cipherdata,
+ authdata,
+ OP_TYPE_ENCAP_PROTOCOL,
+ sn_size,
+ era_2_sw_hfn_ovrd);
+ if (err)
+ return err;
+
+ PATCH_HDR(p, 0, pdb_end);
+
+ return PROGRAM_FINALIZE(p);
+}
+
+/**
+ * cnstr_shdsc_pdcp_c_plane_decap - Function for creating a PDCP Control Plane
+ * decapsulation descriptor.
+ * @descbuf: pointer to buffer for descriptor construction
+ * @ps: if 36/40bit addressing is desired, this parameter must be true
+ * @swap: must be true when core endianness doesn't match SEC endianness
+ * @hfn: starting Hyper Frame Number to be used together with the SN from the
+ * PDCP frames.
+ * @sn_size: size of sequence numbers, only 5/12 bit sequence numbers are valid
+ * @bearer: radio bearer ID
+ * @direction: the direction of the PDCP frame (UL/DL)
+ * @hfn_threshold: HFN value that once reached triggers a warning from SEC that
+ * keys should be renegotiated at the earliest convenience.
+ * @cipherdata: pointer to block cipher transform definitions
+ * Valid algorithm values are those from cipher_type_pdcp enum.
+ * @authdata: pointer to authentication transform definitions
+ * Valid algorithm values are those from auth_type_pdcp enum.
+ * @era_2_sw_hfn_ovrd: if software HFN override mechanism is desired for
+ * this descriptor. Note: Can only be used for
+ * SEC ERA 2.
+ *
+ * Return: size of descriptor written in words or negative number on error.
+ * Once the function returns, the value of this parameter can be used
+ * for reclaiming the space that wasn't used for the descriptor.
+ *
+ * Note: descbuf must be large enough to contain a full 256 byte long
+ * descriptor; after the function returns, by subtracting the actual number of
+ * bytes used, the user can reuse the remaining buffer space for other purposes.
+ */
+static inline int
+cnstr_shdsc_pdcp_c_plane_decap(uint32_t *descbuf,
+ bool ps,
+ bool swap,
+ uint32_t hfn,
+ enum pdcp_sn_size sn_size,
+ unsigned char bearer,
+ unsigned char direction,
+ uint32_t hfn_threshold,
+ struct alginfo *cipherdata,
+ struct alginfo *authdata,
+ unsigned char era_2_sw_hfn_ovrd)
+{
+ static int
+ (*pdcp_cp_fp[PDCP_CIPHER_TYPE_INVALID][PDCP_AUTH_TYPE_INVALID])
+ (struct program*, bool swap, struct alginfo *,
+ struct alginfo *, unsigned int, enum pdcp_sn_size,
+ unsigned char) = {
+ { /* NULL */
+ pdcp_insert_cplane_null_op, /* NULL */
+ pdcp_insert_cplane_int_only_op, /* SNOW f9 */
+ pdcp_insert_cplane_int_only_op, /* AES CMAC */
+ pdcp_insert_cplane_int_only_op /* ZUC-I */
+ },
+ { /* SNOW f8 */
+ pdcp_insert_cplane_enc_only_op, /* NULL */
+ pdcp_insert_cplane_acc_op, /* SNOW f9 */
+ pdcp_insert_cplane_snow_aes_op, /* AES CMAC */
+ pdcp_insert_cplane_snow_zuc_op /* ZUC-I */
+ },
+ { /* AES CTR */
+ pdcp_insert_cplane_enc_only_op, /* NULL */
+ pdcp_insert_cplane_aes_snow_op, /* SNOW f9 */
+ pdcp_insert_cplane_acc_op, /* AES CMAC */
+ pdcp_insert_cplane_aes_zuc_op /* ZUC-I */
+ },
+ { /* ZUC-E */
+ pdcp_insert_cplane_enc_only_op, /* NULL */
+ pdcp_insert_cplane_zuc_snow_op, /* SNOW f9 */
+ pdcp_insert_cplane_zuc_aes_op, /* AES CMAC */
+ pdcp_insert_cplane_acc_op /* ZUC-I */
+ },
+ };
+ static enum rta_share_type
+ desc_share[PDCP_CIPHER_TYPE_INVALID][PDCP_AUTH_TYPE_INVALID] = {
+ { /* NULL */
+ SHR_WAIT, /* NULL */
+ SHR_ALWAYS, /* SNOW f9 */
+ SHR_ALWAYS, /* AES CMAC */
+ SHR_ALWAYS /* ZUC-I */
+ },
+ { /* SNOW f8 */
+ SHR_ALWAYS, /* NULL */
+ SHR_ALWAYS, /* SNOW f9 */
+ SHR_WAIT, /* AES CMAC */
+ SHR_WAIT /* ZUC-I */
+ },
+ { /* AES CTR */
+ SHR_ALWAYS, /* NULL */
+ SHR_ALWAYS, /* SNOW f9 */
+ SHR_ALWAYS, /* AES CMAC */
+ SHR_WAIT /* ZUC-I */
+ },
+ { /* ZUC-E */
+ SHR_ALWAYS, /* NULL */
+ SHR_WAIT, /* SNOW f9 */
+ SHR_WAIT, /* AES CMAC */
+ SHR_ALWAYS /* ZUC-I */
+ },
+ };
+ enum pdb_type_e pdb_type;
+ struct program prg;
+ struct program *p = &prg;
+ int err;
+ LABEL(pdb_end);
+
+ if (rta_sec_era != RTA_SEC_ERA_2 && era_2_sw_hfn_ovrd) {
+ pr_err("Cannot select SW HFN override for other era than 2");
+ return -EINVAL;
+ }
+
+ if (sn_size != PDCP_SN_SIZE_12 && sn_size != PDCP_SN_SIZE_5) {
+ pr_err("C-plane supports only 5-bit and 12-bit sequence numbers\n");
+ return -EINVAL;
+ }
+
+ PROGRAM_CNTXT_INIT(p, descbuf, 0);
+ if (swap)
+ PROGRAM_SET_BSWAP(p);
+ if (ps)
+ PROGRAM_SET_36BIT_ADDR(p);
+
+ SHR_HDR(p, desc_share[cipherdata->algtype][authdata->algtype], 0, 0);
+
+ pdb_type = cnstr_pdcp_c_plane_pdb(p,
+ hfn,
+ sn_size,
+ bearer,
+ direction,
+ hfn_threshold,
+ cipherdata,
+ authdata);
+
+ SET_LABEL(p, pdb_end);
+
+ err = insert_hfn_ov_op(p, sn_size, pdb_type,
+ era_2_sw_hfn_ovrd);
+ if (err)
+ return err;
+
+ err = pdcp_cp_fp[cipherdata->algtype][authdata->algtype](p,
+ swap,
+ cipherdata,
+ authdata,
+ OP_TYPE_DECAP_PROTOCOL,
+ sn_size,
+ era_2_sw_hfn_ovrd);
+ if (err)
+ return err;
+
+ PATCH_HDR(p, 0, pdb_end);
+
+ return PROGRAM_FINALIZE(p);
+}
+
+static int
+pdcp_insert_uplane_with_int_op(struct program *p,
+ bool swap __maybe_unused,
+ struct alginfo *cipherdata,
+ struct alginfo *authdata,
+ enum pdcp_sn_size sn_size,
+ unsigned char era_2_sw_hfn_ovrd,
+ unsigned int dir)
+{
+ static int
+ (*pdcp_cp_fp[PDCP_CIPHER_TYPE_INVALID][PDCP_AUTH_TYPE_INVALID])
+ (struct program*, bool swap, struct alginfo *,
+ struct alginfo *, unsigned int, enum pdcp_sn_size,
+ unsigned char __maybe_unused) = {
+ { /* NULL */
+ pdcp_insert_cplane_null_op, /* NULL */
+ pdcp_insert_cplane_int_only_op, /* SNOW f9 */
+ pdcp_insert_cplane_int_only_op, /* AES CMAC */
+ pdcp_insert_cplane_int_only_op /* ZUC-I */
+ },
+ { /* SNOW f8 */
+ pdcp_insert_cplane_enc_only_op, /* NULL */
+ pdcp_insert_uplane_snow_snow_op, /* SNOW f9 */
+ pdcp_insert_cplane_snow_aes_op, /* AES CMAC */
+ pdcp_insert_cplane_snow_zuc_op /* ZUC-I */
+ },
+ { /* AES CTR */
+ pdcp_insert_cplane_enc_only_op, /* NULL */
+ pdcp_insert_cplane_aes_snow_op, /* SNOW f9 */
+ pdcp_insert_uplane_aes_aes_op, /* AES CMAC */
+ pdcp_insert_cplane_aes_zuc_op /* ZUC-I */
+ },
+ { /* ZUC-E */
+ pdcp_insert_cplane_enc_only_op, /* NULL */
+ pdcp_insert_cplane_zuc_snow_op, /* SNOW f9 */
+ pdcp_insert_cplane_zuc_aes_op, /* AES CMAC */
+ pdcp_insert_uplane_zuc_zuc_op /* ZUC-I */
+ },
+ };
+ int err;
+
+ err = pdcp_cp_fp[cipherdata->algtype][authdata->algtype](p,
+ swap,
+ cipherdata,
+ authdata,
+ dir,
+ sn_size,
+ era_2_sw_hfn_ovrd);
+ if (err)
+ return err;
+
+ return 0;
+}
+
+
+/**
+ * cnstr_shdsc_pdcp_u_plane_encap - Function for creating a PDCP User Plane
+ * encapsulation descriptor.
+ * @descbuf: pointer to buffer for descriptor construction
+ * @ps: if 36/40bit addressing is desired, this parameter must be true
+ * @swap: must be true when core endianness doesn't match SEC endianness
+ * @sn_size: selects Sequence Number Size: 7/12/15 bits
+ * @hfn: starting Hyper Frame Number to be used together with the SN from the
+ * PDCP frames.
+ * @bearer: radio bearer ID
+ * @direction: the direction of the PDCP frame (UL/DL)
+ * @hfn_threshold: HFN value that once reached triggers a warning from SEC that
+ * keys should be renegotiated at the earliest convenience.
+ * @cipherdata: pointer to block cipher transform definitions
+ * Valid algorithm values are those from cipher_type_pdcp enum.
+ * @era_2_sw_hfn_ovrd: if software HFN override mechanism is desired for
+ * this descriptor. Note: Can only be used for
+ * SEC ERA 2.
+ *
+ * Return: size of descriptor written in words or negative number on error.
+ * Once the function returns, the value of this parameter can be used
+ * for reclaiming the space that wasn't used for the descriptor.
+ *
+ * Note: descbuf must be large enough to contain a full 256 byte long
+ * descriptor; after the function returns, by subtracting the actual number of
+ * bytes used, the user can reuse the remaining buffer space for other purposes.
+ */
+static inline int
+cnstr_shdsc_pdcp_u_plane_encap(uint32_t *descbuf,
+ bool ps,
+ bool swap,
+ enum pdcp_sn_size sn_size,
+ uint32_t hfn,
+ unsigned short bearer,
+ unsigned short direction,
+ uint32_t hfn_threshold,
+ struct alginfo *cipherdata,
+ struct alginfo *authdata,
+ unsigned char era_2_sw_hfn_ovrd)
+{
+ struct program prg;
+ struct program *p = &prg;
+ int err;
+ enum pdb_type_e pdb_type;
+ static enum rta_share_type
+ desc_share[PDCP_CIPHER_TYPE_INVALID][PDCP_AUTH_TYPE_INVALID] = {
+ { /* NULL */
+ SHR_WAIT, /* NULL */
+ SHR_ALWAYS, /* SNOW f9 */
+ SHR_ALWAYS, /* AES CMAC */
+ SHR_ALWAYS /* ZUC-I */
+ },
+ { /* SNOW f8 */
+ SHR_ALWAYS, /* NULL */
+ SHR_ALWAYS, /* SNOW f9 */
+ SHR_WAIT, /* AES CMAC */
+ SHR_WAIT /* ZUC-I */
+ },
+ { /* AES CTR */
+ SHR_ALWAYS, /* NULL */
+ SHR_ALWAYS, /* SNOW f9 */
+ SHR_ALWAYS, /* AES CMAC */
+ SHR_WAIT /* ZUC-I */
+ },
+ { /* ZUC-E */
+ SHR_ALWAYS, /* NULL */
+ SHR_WAIT, /* SNOW f9 */
+ SHR_WAIT, /* AES CMAC */
+ SHR_ALWAYS /* ZUC-I */
+ },
+ };
+ LABEL(pdb_end);
+
+ if (rta_sec_era != RTA_SEC_ERA_2 && era_2_sw_hfn_ovrd) {
+ pr_err("Cannot select SW HFN ovrd for other era than 2");
+ return -EINVAL;
+ }
+
+ if (authdata && !authdata->algtype && rta_sec_era < RTA_SEC_ERA_8) {
+ pr_err("Cannot use u-plane auth with era < 8");
+ return -EINVAL;
+ }
+
+ PROGRAM_CNTXT_INIT(p, descbuf, 0);
+ if (swap)
+ PROGRAM_SET_BSWAP(p);
+ if (ps)
+ PROGRAM_SET_36BIT_ADDR(p);
+
+ if (authdata)
+ SHR_HDR(p, desc_share[cipherdata->algtype][authdata->algtype], 0, 0);
+ else
+ SHR_HDR(p, SHR_ALWAYS, 0, 0);
+ pdb_type = cnstr_pdcp_u_plane_pdb(p, sn_size, hfn,
+ bearer, direction, hfn_threshold,
+ cipherdata, authdata);
+ if (pdb_type == PDCP_PDB_TYPE_INVALID) {
+ pr_err("Error creating PDCP UPlane PDB\n");
+ return -EINVAL;
+ }
+ SET_LABEL(p, pdb_end);
+
+ err = insert_hfn_ov_op(p, sn_size, pdb_type, era_2_sw_hfn_ovrd);
+ if (err)
+ return err;
+
+ switch (sn_size) {
+ case PDCP_SN_SIZE_7:
+ case PDCP_SN_SIZE_12:
+ switch (cipherdata->algtype) {
+ case PDCP_CIPHER_TYPE_ZUC:
+ if (rta_sec_era < RTA_SEC_ERA_5) {
+ pr_err("Invalid era for selected algorithm\n");
+ return -ENOTSUP;
+ }
+ /* fallthrough */
+ case PDCP_CIPHER_TYPE_AES:
+ case PDCP_CIPHER_TYPE_SNOW:
+ case PDCP_CIPHER_TYPE_NULL:
+ if (rta_sec_era == RTA_SEC_ERA_8 &&
+ authdata && authdata->algtype == 0){
+ err = pdcp_insert_uplane_with_int_op(p, swap,
+ cipherdata, authdata,
+ sn_size, era_2_sw_hfn_ovrd,
+ OP_TYPE_ENCAP_PROTOCOL);
+ if (err)
+ return err;
+ break;
+ }
+
+ if (pdb_type != PDCP_PDB_TYPE_FULL_PDB) {
+ pr_err("PDB type must be FULL for PROTO desc\n");
+ return -EINVAL;
+ }
+
+ /* Insert auth key if requested */
+ if (authdata && authdata->algtype) {
+ KEY(p, KEY2, authdata->key_enc_flags,
+ (uint64_t)authdata->key, authdata->keylen,
+ INLINE_KEY(authdata));
+ }
+ /* Insert Cipher Key */
+ KEY(p, KEY1, cipherdata->key_enc_flags,
+ (uint64_t)cipherdata->key, cipherdata->keylen,
+ INLINE_KEY(cipherdata));
+
+ if (authdata)
+ PROTOCOL(p, OP_TYPE_ENCAP_PROTOCOL,
+ OP_PCLID_LTE_PDCP_USER_RN,
+ ((uint16_t)cipherdata->algtype << 8) |
+ (uint16_t)authdata->algtype);
+ else
+ PROTOCOL(p, OP_TYPE_ENCAP_PROTOCOL,
+ OP_PCLID_LTE_PDCP_USER,
+ (uint16_t)cipherdata->algtype);
+ break;
+ default:
+ pr_err("%s: Invalid encrypt algorithm selected: %d\n",
+ "cnstr_pcl_shdsc_pdcp_u_plane_decap",
+ cipherdata->algtype);
+ return -EINVAL;
+ }
+ break;
+
+ case PDCP_SN_SIZE_15:
+ case PDCP_SN_SIZE_18:
+ if (authdata) {
+ err = pdcp_insert_uplane_with_int_op(p, swap,
+ cipherdata, authdata,
+ sn_size, era_2_sw_hfn_ovrd,
+ OP_TYPE_ENCAP_PROTOCOL);
+ if (err)
+ return err;
+
+ break;
+ }
+
+ switch (cipherdata->algtype) {
+ case PDCP_CIPHER_TYPE_NULL:
+ insert_copy_frame_op(p,
+ cipherdata,
+ OP_TYPE_ENCAP_PROTOCOL);
+ break;
+
+ default:
+ err = pdcp_insert_uplane_no_int_op(p, swap, cipherdata,
+ OP_TYPE_ENCAP_PROTOCOL, sn_size);
+ if (err)
+ return err;
+ break;
+ }
+ break;
+
+ case PDCP_SN_SIZE_5:
+ default:
+ pr_err("Invalid SN size selected\n");
+ return -ENOTSUP;
+ }
+
+ PATCH_HDR(p, 0, pdb_end);
+ return PROGRAM_FINALIZE(p);
+}
+
+/**
+ * cnstr_shdsc_pdcp_u_plane_decap - Function for creating a PDCP User Plane
+ * decapsulation descriptor.
+ * @descbuf: pointer to buffer for descriptor construction
+ * @ps: if 36/40bit addressing is desired, this parameter must be true
+ * @swap: must be true when core endianness doesn't match SEC endianness
+ * @sn_size: selects Sequence Number Size: 7/12/15 bits
+ * @hfn: starting Hyper Frame Number to be used together with the SN from the
+ * PDCP frames.
+ * @bearer: radio bearer ID
+ * @direction: the direction of the PDCP frame (UL/DL)
+ * @hfn_threshold: HFN value that once reached triggers a warning from SEC that
+ * keys should be renegotiated at the earliest convenience.
+ * @cipherdata: pointer to block cipher transform definitions
+ * Valid algorithm values are those from cipher_type_pdcp enum.
+ * @era_2_sw_hfn_ovrd: if software HFN override mechanism is desired for
+ * this descriptor. Note: Can only be used for
+ * SEC ERA 2.
+ *
+ * Return: size of descriptor written in words or negative number on error.
+ * Once the function returns, the value of this parameter can be used
+ * for reclaiming the space that wasn't used for the descriptor.
+ *
+ * Note: descbuf must be large enough to contain a full 256 byte long
+ * descriptor; after the function returns, by subtracting the actual number of
+ * bytes used, the user can reuse the remaining buffer space for other purposes.
+ */
+static inline int
+cnstr_shdsc_pdcp_u_plane_decap(uint32_t *descbuf,
+ bool ps,
+ bool swap,
+ enum pdcp_sn_size sn_size,
+ uint32_t hfn,
+ unsigned short bearer,
+ unsigned short direction,
+ uint32_t hfn_threshold,
+ struct alginfo *cipherdata,
+ struct alginfo *authdata,
+ unsigned char era_2_sw_hfn_ovrd)
+{
+ struct program prg;
+ struct program *p = &prg;
+ int err;
+ enum pdb_type_e pdb_type;
+ static enum rta_share_type
+ desc_share[PDCP_CIPHER_TYPE_INVALID][PDCP_AUTH_TYPE_INVALID] = {
+ { /* NULL */
+ SHR_WAIT, /* NULL */
+ SHR_ALWAYS, /* SNOW f9 */
+ SHR_ALWAYS, /* AES CMAC */
+ SHR_ALWAYS /* ZUC-I */
+ },
+ { /* SNOW f8 */
+ SHR_ALWAYS, /* NULL */
+ SHR_ALWAYS, /* SNOW f9 */
+ SHR_WAIT, /* AES CMAC */
+ SHR_WAIT /* ZUC-I */
+ },
+ { /* AES CTR */
+ SHR_ALWAYS, /* NULL */
+ SHR_ALWAYS, /* SNOW f9 */
+ SHR_ALWAYS, /* AES CMAC */
+ SHR_WAIT /* ZUC-I */
+ },
+ { /* ZUC-E */
+ SHR_ALWAYS, /* NULL */
+ SHR_WAIT, /* SNOW f9 */
+ SHR_WAIT, /* AES CMAC */
+ SHR_ALWAYS /* ZUC-I */
+ },
+ };
+
+ LABEL(pdb_end);
+
+ if (rta_sec_era != RTA_SEC_ERA_2 && era_2_sw_hfn_ovrd) {
+ pr_err("Cannot select SW HFN override for other era than 2");
+ return -EINVAL;
+ }
+
+ if (authdata && !authdata->algtype && rta_sec_era < RTA_SEC_ERA_8) {
+ pr_err("Cannot use u-plane auth with era < 8");
+ return -EINVAL;
+ }
+
+ PROGRAM_CNTXT_INIT(p, descbuf, 0);
+ if (swap)
+ PROGRAM_SET_BSWAP(p);
+ if (ps)
+ PROGRAM_SET_36BIT_ADDR(p);
+ if (authdata)
+ SHR_HDR(p, desc_share[cipherdata->algtype][authdata->algtype], 0, 0);
+ else
+ SHR_HDR(p, SHR_ALWAYS, 0, 0);
+
+ pdb_type = cnstr_pdcp_u_plane_pdb(p, sn_size, hfn, bearer,
+ direction, hfn_threshold,
+ cipherdata, authdata);
+ if (pdb_type == PDCP_PDB_TYPE_INVALID) {
+ pr_err("Error creating PDCP UPlane PDB\n");
+ return -EINVAL;
+ }
+ SET_LABEL(p, pdb_end);
+
+ err = insert_hfn_ov_op(p, sn_size, pdb_type, era_2_sw_hfn_ovrd);
+ if (err)
+ return err;
+
+ switch (sn_size) {
+ case PDCP_SN_SIZE_7:
+ case PDCP_SN_SIZE_12:
+ switch (cipherdata->algtype) {
+ case PDCP_CIPHER_TYPE_ZUC:
+ if (rta_sec_era < RTA_SEC_ERA_5) {
+ pr_err("Invalid era for selected algorithm\n");
+ return -ENOTSUP;
+ }
+ /* fallthrough */
+ case PDCP_CIPHER_TYPE_AES:
+ case PDCP_CIPHER_TYPE_SNOW:
+ case PDCP_CIPHER_TYPE_NULL:
+ if (pdb_type != PDCP_PDB_TYPE_FULL_PDB) {
+ pr_err("PDB type must be FULL for PROTO desc\n");
+ return -EINVAL;
+ }
+
+ /* Insert auth key if requested */
+ if (authdata && authdata->algtype)
+ KEY(p, KEY2, authdata->key_enc_flags,
+ (uint64_t)authdata->key, authdata->keylen,
+ INLINE_KEY(authdata));
+
+ /* Insert Cipher Key */
+ KEY(p, KEY1, cipherdata->key_enc_flags,
+ cipherdata->key, cipherdata->keylen,
+ INLINE_KEY(cipherdata));
+ if (authdata)
+ PROTOCOL(p, OP_TYPE_DECAP_PROTOCOL,
+ OP_PCLID_LTE_PDCP_USER_RN,
+ ((uint16_t)cipherdata->algtype << 8) |
+ (uint16_t)authdata->algtype);
+ else
+ PROTOCOL(p, OP_TYPE_DECAP_PROTOCOL,
+ OP_PCLID_LTE_PDCP_USER,
+ (uint16_t)cipherdata->algtype);
+ break;
+ default:
+ pr_err("%s: Invalid encrypt algorithm selected: %d\n",
+ "cnstr_pcl_shdsc_pdcp_u_plane_decap",
+ cipherdata->algtype);
+ return -EINVAL;
+ }
+ break;
+
+ case PDCP_SN_SIZE_15:
+ case PDCP_SN_SIZE_18:
+ if (authdata) {
+ err = pdcp_insert_uplane_with_int_op(p, swap,
+ cipherdata, authdata,
+ sn_size, era_2_sw_hfn_ovrd,
+ OP_TYPE_DECAP_PROTOCOL);
+ if (err)
+ return err;
+
+ break;
+ }
+
+ switch (cipherdata->algtype) {
+ case PDCP_CIPHER_TYPE_NULL:
+ insert_copy_frame_op(p,
+ cipherdata,
+ OP_TYPE_DECAP_PROTOCOL);
+ break;
+
+ default:
+ err = pdcp_insert_uplane_no_int_op(p, swap, cipherdata,
+ OP_TYPE_DECAP_PROTOCOL, sn_size);
+ if (err)
+ return err;
+ break;
+ }
+ break;
+
+ case PDCP_SN_SIZE_5:
+ default:
+ pr_err("Invalid SN size selected\n");
+ return -ENOTSUP;
+ }
+
+ PATCH_HDR(p, 0, pdb_end);
+ return PROGRAM_FINALIZE(p);
+}
+
+/**
+ * cnstr_shdsc_pdcp_short_mac - Function for creating a PDCP Short MAC
+ * descriptor.
+ * @descbuf: pointer to buffer for descriptor construction
+ * @ps: if 36/40bit addressing is desired, this parameter must be true
+ * @swap: must be true when core endianness doesn't match SEC endianness
+ * @authdata: pointer to authentication transform definitions
+ * Valid algorithm values are those from auth_type_pdcp enum.
+ *
+ * Return: size of descriptor written in words or negative number on error.
+ * Once the function returns, the value of this parameter can be used
+ * for reclaiming the space that wasn't used for the descriptor.
+ *
+ * Note: descbuf must be large enough to contain a full 256 byte long
+ * descriptor; after the function returns, by subtracting the actual number of
+ * bytes used, the user can reuse the remaining buffer space for other purposes.
+ */
+static inline int
+cnstr_shdsc_pdcp_short_mac(uint32_t *descbuf,
+ bool ps,
+ bool swap,
+ struct alginfo *authdata)
+{
+ struct program prg;
+ struct program *p = &prg;
+ uint32_t iv[3] = {0, 0, 0};
+ LABEL(local_offset);
+ REFERENCE(move_cmd_read_descbuf);
+ REFERENCE(move_cmd_write_descbuf);
+
+ PROGRAM_CNTXT_INIT(p, descbuf, 0);
+ if (swap)
+ PROGRAM_SET_BSWAP(p);
+ if (ps)
+ PROGRAM_SET_36BIT_ADDR(p);
+
+ SHR_HDR(p, SHR_ALWAYS, 1, 0);
+
+ if (rta_sec_era > RTA_SEC_ERA_2) {
+ MATHB(p, SEQINSZ, SUB, ZERO, VSEQINSZ, 4, 0);
+ MATHB(p, SEQINSZ, SUB, ZERO, MATH1, 4, 0);
+ } else {
+ MATHB(p, SEQINSZ, ADD, ONE, MATH1, 4, 0);
+ MATHB(p, MATH1, SUB, ONE, MATH1, 4, 0);
+ MATHB(p, ZERO, ADD, MATH1, VSEQINSZ, 4, 0);
+ MOVE(p, MATH1, 0, MATH0, 0, 8, IMMED);
+
+ /*
+ * Since MOVELEN is available only starting with
+ * SEC ERA 3, use poor man's MOVELEN: create a MOVE
+ * command dynamically by writing the length from M1 by
+ * OR-ing the command in the M1 register and MOVE the
+ * result into the descriptor buffer. Care must be taken
+ * wrt. the location of the command because of SEC
+ * pipelining. The actual MOVEs are written at the end
+ * of the descriptor due to calculations needed on the
+ * offset in the descriptor for the MOVE command.
+ */
+ move_cmd_read_descbuf = MOVE(p, DESCBUF, 0, MATH0, 0, 6,
+ IMMED);
+ move_cmd_write_descbuf = MOVE(p, MATH0, 0, DESCBUF, 0, 8,
+ WAITCOMP | IMMED);
+ }
+ MATHB(p, ZERO, ADD, MATH1, VSEQOUTSZ, 4, 0);
+
+ switch (authdata->algtype) {
+ case PDCP_AUTH_TYPE_NULL:
+ SEQFIFOSTORE(p, MSG, 0, 0, VLF);
+ if (rta_sec_era > RTA_SEC_ERA_2) {
+ MOVE(p, AB1, 0, OFIFO, 0, MATH1, 0);
+ } else {
+ SET_LABEL(p, local_offset);
+
+ /* Shut off automatic Info FIFO entries */
+ LOAD(p, 0, DCTRL, LDOFF_DISABLE_AUTO_NFIFO, 0, IMMED);
+
+ /* Placeholder for MOVE command with length from M1
+ * register
+ */
+ MOVE(p, IFIFOAB1, 0, OFIFO, 0, 0, IMMED);
+
+ /* Enable automatic Info FIFO entries */
+ LOAD(p, 0, DCTRL, LDOFF_ENABLE_AUTO_NFIFO, 0, IMMED);
+ }
+
+ LOAD(p, (uintptr_t)iv, MATH0, 0, 8, IMMED | COPY);
+ SEQFIFOLOAD(p, MSG1, 0, VLF | LAST1 | LAST2 | FLUSH1);
+ SEQSTORE(p, MATH0, 0, 4, 0);
+
+ break;
+
+ case PDCP_AUTH_TYPE_SNOW:
+ iv[0] = 0xFFFFFFFF;
+ iv[1] = swap ? swab32(0x04000000) : 0x04000000;
+ iv[2] = swap ? swab32(0xF8000000) : 0xF8000000;
+
+ KEY(p, KEY2, authdata->key_enc_flags, authdata->key,
+ authdata->keylen, INLINE_KEY(authdata));
+ LOAD(p, (uintptr_t)&iv, CONTEXT2, 0, 12, IMMED | COPY);
+ ALG_OPERATION(p, OP_ALG_ALGSEL_SNOW_F9,
+ OP_ALG_AAI_F9,
+ OP_ALG_AS_INITFINAL,
+ ICV_CHECK_DISABLE,
+ DIR_ENC);
+ SEQFIFOSTORE(p, MSG, 0, 0, VLF);
+
+ if (rta_sec_era > RTA_SEC_ERA_2) {
+ MOVE(p, AB1, 0, OFIFO, 0, MATH1, 0);
+ } else {
+ SET_LABEL(p, local_offset);
+
+
+ /* Shut off automatic Info FIFO entries */
+ LOAD(p, 0, DCTRL, LDOFF_DISABLE_AUTO_NFIFO, 0, IMMED);
+
+ /* Placeholder for MOVE command with length from M1
+ * register
+ */
+ MOVE(p, IFIFOAB1, 0, OFIFO, 0, 0, IMMED);
+
+ /* Enable automatic Info FIFO entries */
+ LOAD(p, 0, DCTRL, LDOFF_ENABLE_AUTO_NFIFO, 0, IMMED);
+ }
+ SEQFIFOLOAD(p, MSGINSNOOP, 0, VLF | LAST1 | LAST2 | FLUSH1);
+ SEQSTORE(p, CONTEXT2, 0, 4, 0);
+
+ break;
+
+ case PDCP_AUTH_TYPE_AES:
+ iv[0] = 0xFFFFFFFF;
+ iv[1] = swap ? swab32(0xFC000000) : 0xFC000000;
+ iv[2] = 0x00000000; /* unused */
+
+ KEY(p, KEY1, authdata->key_enc_flags, authdata->key,
+ authdata->keylen, INLINE_KEY(authdata));
+ LOAD(p, (uintptr_t)&iv, MATH0, 0, 8, IMMED | COPY);
+ MOVE(p, MATH0, 0, IFIFOAB1, 0, 8, IMMED);
+ ALG_OPERATION(p, OP_ALG_ALGSEL_AES,
+ OP_ALG_AAI_CMAC,
+ OP_ALG_AS_INITFINAL,
+ ICV_CHECK_DISABLE,
+ DIR_ENC);
+ SEQFIFOSTORE(p, MSG, 0, 0, VLF);
+
+ if (rta_sec_era > RTA_SEC_ERA_2) {
+ MOVE(p, AB2, 0, OFIFO, 0, MATH1, 0);
+ } else {
+ SET_LABEL(p, local_offset);
+
+ /* Shut off automatic Info FIFO entries */
+ LOAD(p, 0, DCTRL, LDOFF_DISABLE_AUTO_NFIFO, 0, IMMED);
+
+ /* Placeholder for MOVE command with length from M1
+ * register
+ */
+ MOVE(p, IFIFOAB2, 0, OFIFO, 0, 0, IMMED);
+
+ /* Enable automatic Info FIFO entries */
+ LOAD(p, 0, DCTRL, LDOFF_ENABLE_AUTO_NFIFO, 0, IMMED);
+ }
+ SEQFIFOLOAD(p, MSGINSNOOP, 0, VLF | LAST1 | LAST2 | FLUSH1);
+ SEQSTORE(p, CONTEXT1, 0, 4, 0);
+
+ break;
+
+ case PDCP_AUTH_TYPE_ZUC:
+ if (rta_sec_era < RTA_SEC_ERA_5) {
+ pr_err("Invalid era for selected algorithm\n");
+ return -ENOTSUP;
+ }
+ iv[0] = 0xFFFFFFFF;
+ iv[1] = swap ? swab32(0xFC000000) : 0xFC000000;
+ iv[2] = 0x00000000; /* unused */
+
+ KEY(p, KEY2, authdata->key_enc_flags, authdata->key,
+ authdata->keylen, INLINE_KEY(authdata));
+ LOAD(p, (uintptr_t)&iv, CONTEXT2, 0, 12, IMMED | COPY);
+ ALG_OPERATION(p, OP_ALG_ALGSEL_ZUCA,
+ OP_ALG_AAI_F9,
+ OP_ALG_AS_INITFINAL,
+ ICV_CHECK_DISABLE,
+ DIR_ENC);
+ SEQFIFOSTORE(p, MSG, 0, 0, VLF);
+ MOVE(p, AB1, 0, OFIFO, 0, MATH1, 0);
+ SEQFIFOLOAD(p, MSGINSNOOP, 0, VLF | LAST1 | LAST2 | FLUSH1);
+ SEQSTORE(p, CONTEXT2, 0, 4, 0);
+
+ break;
+
+ default:
+ pr_err("%s: Invalid integrity algorithm selected: %d\n",
+ "cnstr_shdsc_pdcp_short_mac", authdata->algtype);
+ return -EINVAL;
+ }
+
+
+ if (rta_sec_era < RTA_SEC_ERA_3) {
+ PATCH_MOVE(p, move_cmd_read_descbuf, local_offset);
+ PATCH_MOVE(p, move_cmd_write_descbuf, local_offset);
+ }
+
+ return PROGRAM_FINALIZE(p);
+}
+
+#endif /* __DESC_PDCP_H__ */
--- /dev/null
+/* SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0)
+ *
+ * Copyright 2008-2016 Freescale Semiconductor Inc.
+ * Copyright 2016 NXP
+ *
+ */
+
+#ifndef __RTA_RTA_H__
+#define __RTA_RTA_H__
+
+#include "rta/sec_run_time_asm.h"
+#include "rta/fifo_load_store_cmd.h"
+#include "rta/header_cmd.h"
+#include "rta/jump_cmd.h"
+#include "rta/key_cmd.h"
+#include "rta/load_cmd.h"
+#include "rta/math_cmd.h"
+#include "rta/move_cmd.h"
+#include "rta/nfifo_cmd.h"
+#include "rta/operation_cmd.h"
+#include "rta/protocol_cmd.h"
+#include "rta/seq_in_out_ptr_cmd.h"
+#include "rta/signature_cmd.h"
+#include "rta/store_cmd.h"
+
+/**
+ * DOC: About
+ *
+ * RTA (Runtime Assembler) Library is an easy and flexible runtime method for
+ * writing SEC descriptors. It implements a thin abstraction layer above
+ * SEC commands set; the resulting code is compact and similar to a
+ * descriptor sequence.
+ *
+ * RTA library improves comprehension of the SEC code, adds flexibility for
+ * writing complex descriptors and keeps the code lightweight. Should be used
+ * by whom needs to encode descriptors at runtime, with comprehensible flow
+ * control in descriptor.
+ */
+
+/**
+ * DOC: Usage
+ *
+ * RTA is used in kernel space by the SEC / CAAM (Cryptographic Acceleration and
+ * Assurance Module) kernel module (drivers/crypto/caam) and SEC / CAAM QI
+ * kernel module (Freescale QorIQ SDK).
+ *
+ * RTA is used in user space by USDPAA - User Space DataPath Acceleration
+ * Architecture (Freescale QorIQ SDK).
+ */
+
+/**
+ * DOC: Descriptor Buffer Management Routines
+ *
+ * Contains details of RTA descriptor buffer management and SEC Era
+ * management routines.
+ */
+
+/**
+ * PROGRAM_CNTXT_INIT - must be called before any descriptor run-time assembly
+ * call type field carry info i.e. whether descriptor is
+ * shared or job descriptor.
+ * @program: pointer to struct program
+ * @buffer: input buffer where the descriptor will be placed (uint32_t *)
+ * @offset: offset in input buffer from where the data will be written
+ * (unsigned int)
+ */
+#define PROGRAM_CNTXT_INIT(program, buffer, offset) \
+ rta_program_cntxt_init(program, buffer, offset)
+
+/**
+ * PROGRAM_FINALIZE - must be called to mark completion of RTA call.
+ * @program: pointer to struct program
+ *
+ * Return: total size of the descriptor in words or negative number on error.
+ */
+#define PROGRAM_FINALIZE(program) rta_program_finalize(program)
+
+/**
+ * PROGRAM_SET_36BIT_ADDR - must be called to set pointer size to 36 bits
+ * @program: pointer to struct program
+ *
+ * Return: current size of the descriptor in words (unsigned int).
+ */
+#define PROGRAM_SET_36BIT_ADDR(program) rta_program_set_36bit_addr(program)
+
+/**
+ * PROGRAM_SET_BSWAP - must be called to enable byte swapping
+ * @program: pointer to struct program
+ *
+ * Byte swapping on a 4-byte boundary will be performed at the end - when
+ * calling PROGRAM_FINALIZE().
+ *
+ * Return: current size of the descriptor in words (unsigned int).
+ */
+#define PROGRAM_SET_BSWAP(program) rta_program_set_bswap(program)
+
+/**
+ * WORD - must be called to insert in descriptor buffer a 32bit value
+ * @program: pointer to struct program
+ * @val: input value to be written in descriptor buffer (uint32_t)
+ *
+ * Return: the descriptor buffer offset where this command is inserted
+ * (unsigned int).
+ */
+#define WORD(program, val) rta_word(program, val)
+
+/**
+ * DWORD - must be called to insert in descriptor buffer a 64bit value
+ * @program: pointer to struct program
+ * @val: input value to be written in descriptor buffer (uint64_t)
+ *
+ * Return: the descriptor buffer offset where this command is inserted
+ * (unsigned int).
+ */
+#define DWORD(program, val) rta_dword(program, val)
+
+/**
+ * COPY_DATA - must be called to insert in descriptor buffer data larger than
+ * 64bits.
+ * @program: pointer to struct program
+ * @data: input data to be written in descriptor buffer (uint8_t *)
+ * @len: length of input data (unsigned int)
+ *
+ * Return: the descriptor buffer offset where this command is inserted
+ * (unsigned int).
+ */
+#define COPY_DATA(program, data, len) rta_copy_data(program, (data), (len))
+
+/**
+ * DESC_LEN - determines job / shared descriptor buffer length (in words)
+ * @buffer: descriptor buffer (uint32_t *)
+ *
+ * Return: descriptor buffer length in words (unsigned int).
+ */
+#define DESC_LEN(buffer) rta_desc_len(buffer)
+
+/**
+ * DESC_BYTES - determines job / shared descriptor buffer length (in bytes)
+ * @buffer: descriptor buffer (uint32_t *)
+ *
+ * Return: descriptor buffer length in bytes (unsigned int).
+ */
+#define DESC_BYTES(buffer) rta_desc_bytes(buffer)
+
+/*
+ * SEC HW block revision.
+ *
+ * This *must not be confused with SEC version*:
+ * - SEC HW block revision format is "v"
+ * - SEC revision format is "x.y"
+ */
+extern enum rta_sec_era rta_sec_era;
+
+/**
+ * rta_set_sec_era - Set SEC Era HW block revision for which the RTA library
+ * will generate the descriptors.
+ * @era: SEC Era (enum rta_sec_era)
+ *
+ * Return: 0 if the ERA was set successfully, -1 otherwise (int)
+ *
+ * Warning 1: Must be called *only once*, *before* using any other RTA API
+ * routine.
+ *
+ * Warning 2: *Not thread safe*.
+ */
+static inline int
+rta_set_sec_era(enum rta_sec_era era)
+{
+ if (era > MAX_SEC_ERA) {
+ rta_sec_era = DEFAULT_SEC_ERA;
+ pr_err("Unsupported SEC ERA. Defaulting to ERA %d\n",
+ DEFAULT_SEC_ERA + 1);
+ return -1;
+ }
+
+ rta_sec_era = era;
+ return 0;
+}
+
+/**
+ * rta_get_sec_era - Get SEC Era HW block revision for which the RTA library
+ * will generate the descriptors.
+ *
+ * Return: SEC Era (unsigned int).
+ */
+static inline unsigned int
+rta_get_sec_era(void)
+{
+ return rta_sec_era;
+}
+
+/**
+ * DOC: SEC Commands Routines
+ *
+ * Contains details of RTA wrapper routines over SEC engine commands.
+ */
+
+/**
+ * SHR_HDR - Configures Shared Descriptor HEADER command
+ * @program: pointer to struct program
+ * @share: descriptor share state (enum rta_share_type)
+ * @start_idx: index in descriptor buffer where the execution of the shared
+ * descriptor should start (@c unsigned int).
+ * @flags: operational flags: RIF, DNR, CIF, SC, PD
+ *
+ * Return: On success, descriptor buffer offset where this command is inserted.
+ * On error, a negative error code; first error program counter will
+ * point to offset in descriptor buffer where the instruction should
+ * have been written.
+ */
+#define SHR_HDR(program, share, start_idx, flags) \
+ rta_shr_header(program, share, start_idx, flags)
+
+/**
+ * JOB_HDR - Configures JOB Descriptor HEADER command
+ * @program: pointer to struct program
+ * @share: descriptor share state (enum rta_share_type)
+ * @start_idx: index in descriptor buffer where the execution of the job
+ * descriptor should start (unsigned int). In case SHR bit is present
+ * in flags, this will be the shared descriptor length.
+ * @share_desc: pointer to shared descriptor, in case SHR bit is set (uint64_t)
+ * @flags: operational flags: RSMS, DNR, TD, MTD, REO, SHR
+ *
+ * Return: On success, descriptor buffer offset where this command is inserted.
+ * On error, a negative error code; first error program counter will
+ * point to offset in descriptor buffer where the instruction should
+ * have been written.
+ */
+#define JOB_HDR(program, share, start_idx, share_desc, flags) \
+ rta_job_header(program, share, start_idx, share_desc, flags, 0)
+
+/**
+ * JOB_HDR_EXT - Configures JOB Descriptor HEADER command
+ * @program: pointer to struct program
+ * @share: descriptor share state (enum rta_share_type)
+ * @start_idx: index in descriptor buffer where the execution of the job
+ * descriptor should start (unsigned int). In case SHR bit is present
+ * in flags, this will be the shared descriptor length.
+ * @share_desc: pointer to shared descriptor, in case SHR bit is set (uint64_t)
+ * @flags: operational flags: RSMS, DNR, TD, MTD, REO, SHR
+ * @ext_flags: extended header flags: DSV (DECO Select Valid), DECO Id (limited
+ * by DSEL_MASK).
+ *
+ * Return: On success, descriptor buffer offset where this command is inserted.
+ * On error, a negative error code; first error program counter will
+ * point to offset in descriptor buffer where the instruction should
+ * have been written.
+ */
+#define JOB_HDR_EXT(program, share, start_idx, share_desc, flags, ext_flags) \
+ rta_job_header(program, share, start_idx, share_desc, flags | EXT, \
+ ext_flags)
+
+/**
+ * MOVE - Configures MOVE and MOVE_LEN commands
+ * @program: pointer to struct program
+ * @src: internal source of data that will be moved: CONTEXT1, CONTEXT2, OFIFO,
+ * DESCBUF, MATH0-MATH3, IFIFOABD, IFIFOAB1, IFIFOAB2, AB1, AB2, ABD.
+ * @src_offset: offset in source data (uint16_t)
+ * @dst: internal destination of data that will be moved: CONTEXT1, CONTEXT2,
+ * OFIFO, DESCBUF, MATH0-MATH3, IFIFOAB1, IFIFOAB2, IFIFO, PKA, KEY1,
+ * KEY2, ALTSOURCE.
+ * @dst_offset: offset in destination data (uint16_t)
+ * @length: size of data to be moved: for MOVE must be specified as immediate
+ * value and IMMED flag must be set; for MOVE_LEN must be specified
+ * using MATH0-MATH3.
+ * @opt: operational flags: WAITCOMP, FLUSH1, FLUSH2, LAST1, LAST2, SIZE_WORD,
+ * SIZE_BYTE, SIZE_DWORD, IMMED (not valid for MOVE_LEN).
+ *
+ * Return: On success, descriptor buffer offset where this command is inserted.
+ * On error, a negative error code; first error program counter will
+ * point to offset in descriptor buffer where the instruction should
+ * have been written.
+ */
+#define MOVE(program, src, src_offset, dst, dst_offset, length, opt) \
+ rta_move(program, __MOVE, src, src_offset, dst, dst_offset, length, opt)
+
+/**
+ * MOVEB - Configures MOVEB command
+ * @program: pointer to struct program
+ * @src: internal source of data that will be moved: CONTEXT1, CONTEXT2, OFIFO,
+ * DESCBUF, MATH0-MATH3, IFIFOABD, IFIFOAB1, IFIFOAB2, AB1, AB2, ABD.
+ * @src_offset: offset in source data (uint16_t)
+ * @dst: internal destination of data that will be moved: CONTEXT1, CONTEXT2,
+ * OFIFO, DESCBUF, MATH0-MATH3, IFIFOAB1, IFIFOAB2, IFIFO, PKA, KEY1,
+ * KEY2, ALTSOURCE.
+ * @dst_offset: offset in destination data (uint16_t)
+ * @length: size of data to be moved: for MOVE must be specified as immediate
+ * value and IMMED flag must be set; for MOVE_LEN must be specified
+ * using MATH0-MATH3.
+ * @opt: operational flags: WAITCOMP, FLUSH1, FLUSH2, LAST1, LAST2, SIZE_WORD,
+ * SIZE_BYTE, SIZE_DWORD, IMMED (not valid for MOVE_LEN).
+ *
+ * Identical with MOVE command if byte swapping not enabled; else - when src/dst
+ * is descriptor buffer or MATH registers, data type is byte array when MOVE
+ * data type is 4-byte array and vice versa.
+ *
+ * Return: On success, descriptor buffer offset where this command is inserted.
+ * On error, a negative error code; first error program counter will
+ * point to offset in descriptor buffer where the instruction should
+ * have been written.
+ */
+#define MOVEB(program, src, src_offset, dst, dst_offset, length, opt) \
+ rta_move(program, __MOVEB, src, src_offset, dst, dst_offset, length, \
+ opt)
+
+/**
+ * MOVEDW - Configures MOVEDW command
+ * @program: pointer to struct program
+ * @src: internal source of data that will be moved: CONTEXT1, CONTEXT2, OFIFO,
+ * DESCBUF, MATH0-MATH3, IFIFOABD, IFIFOAB1, IFIFOAB2, AB1, AB2, ABD.
+ * @src_offset: offset in source data (uint16_t)
+ * @dst: internal destination of data that will be moved: CONTEXT1, CONTEXT2,
+ * OFIFO, DESCBUF, MATH0-MATH3, IFIFOAB1, IFIFOAB2, IFIFO, PKA, KEY1,
+ * KEY2, ALTSOURCE.
+ * @dst_offset: offset in destination data (uint16_t)
+ * @length: size of data to be moved: for MOVE must be specified as immediate
+ * value and IMMED flag must be set; for MOVE_LEN must be specified
+ * using MATH0-MATH3.
+ * @opt: operational flags: WAITCOMP, FLUSH1, FLUSH2, LAST1, LAST2, SIZE_WORD,
+ * SIZE_BYTE, SIZE_DWORD, IMMED (not valid for MOVE_LEN).
+ *
+ * Identical with MOVE command, with the following differences: data type is
+ * 8-byte array; word swapping is performed when SEC is programmed in little
+ * endian mode.
+ *
+ * Return: On success, descriptor buffer offset where this command is inserted.
+ * On error, a negative error code; first error program counter will
+ * point to offset in descriptor buffer where the instruction should
+ * have been written.
+ */
+#define MOVEDW(program, src, src_offset, dst, dst_offset, length, opt) \
+ rta_move(program, __MOVEDW, src, src_offset, dst, dst_offset, length, \
+ opt)
+
+/**
+ * FIFOLOAD - Configures FIFOLOAD command to load message data, PKHA data, IV,
+ * ICV, AAD and bit length message data into Input Data FIFO.
+ * @program: pointer to struct program
+ * @data: input data type to store: PKHA registers, IFIFO, MSG1, MSG2,
+ * MSGOUTSNOOP, MSGINSNOOP, IV1, IV2, AAD1, ICV1, ICV2, BIT_DATA, SKIP.
+ * @src: pointer or actual data in case of immediate load; IMMED, COPY and DCOPY
+ * flags indicate action taken (inline imm data, inline ptr, inline from
+ * ptr).
+ * @length: number of bytes to load (uint32_t)
+ * @flags: operational flags: SGF, IMMED, EXT, CLASS1, CLASS2, BOTH, FLUSH1,
+ * LAST1, LAST2, COPY, DCOPY.
+ *
+ * Return: On success, descriptor buffer offset where this command is inserted.
+ * On error, a negative error code; first error program counter will
+ * point to offset in descriptor buffer where the instruction should
+ * have been written.
+ */
+#define FIFOLOAD(program, data, src, length, flags) \
+ rta_fifo_load(program, data, src, length, flags)
+
+/**
+ * SEQFIFOLOAD - Configures SEQ FIFOLOAD command to load message data, PKHA
+ * data, IV, ICV, AAD and bit length message data into Input Data
+ * FIFO.
+ * @program: pointer to struct program
+ * @data: input data type to store: PKHA registers, IFIFO, MSG1, MSG2,
+ * MSGOUTSNOOP, MSGINSNOOP, IV1, IV2, AAD1, ICV1, ICV2, BIT_DATA, SKIP.
+ * @length: number of bytes to load; can be set to 0 for SEQ command w/ VLF set
+ * (uint32_t).
+ * @flags: operational flags: VLF, CLASS1, CLASS2, BOTH, FLUSH1, LAST1, LAST2,
+ * AIDF.
+ *
+ * Return: On success, descriptor buffer offset where this command is inserted.
+ * On error, a negative error code; first error program counter will
+ * point to offset in descriptor buffer where the instruction should
+ * have been written.
+ */
+#define SEQFIFOLOAD(program, data, length, flags) \
+ rta_fifo_load(program, data, NONE, length, flags|SEQ)
+
+/**
+ * FIFOSTORE - Configures FIFOSTORE command, to move data from Output Data FIFO
+ * to external memory via DMA.
+ * @program: pointer to struct program
+ * @data: output data type to store: PKHA registers, IFIFO, OFIFO, RNG,
+ * RNGOFIFO, AFHA_SBOX, MDHA_SPLIT_KEY, MSG, KEY1, KEY2, SKIP.
+ * @encrypt_flags: store data encryption mode: EKT, TK
+ * @dst: pointer to store location (uint64_t)
+ * @length: number of bytes to load (uint32_t)
+ * @flags: operational flags: SGF, CONT, EXT, CLASS1, CLASS2, BOTH
+ *
+ * Return: On success, descriptor buffer offset where this command is inserted.
+ * On error, a negative error code; first error program counter will
+ * point to offset in descriptor buffer where the instruction should
+ * have been written.
+ */
+#define FIFOSTORE(program, data, encrypt_flags, dst, length, flags) \
+ rta_fifo_store(program, data, encrypt_flags, dst, length, flags)
+
+/**
+ * SEQFIFOSTORE - Configures SEQ FIFOSTORE command, to move data from Output
+ * Data FIFO to external memory via DMA.
+ * @program: pointer to struct program
+ * @data: output data type to store: PKHA registers, IFIFO, OFIFO, RNG,
+ * RNGOFIFO, AFHA_SBOX, MDHA_SPLIT_KEY, MSG, KEY1, KEY2, METADATA, SKIP.
+ * @encrypt_flags: store data encryption mode: EKT, TK
+ * @length: number of bytes to load; can be set to 0 for SEQ command w/ VLF set
+ * (uint32_t).
+ * @flags: operational flags: VLF, CONT, EXT, CLASS1, CLASS2, BOTH
+ *
+ * Return: On success, descriptor buffer offset where this command is inserted.
+ * On error, a negative error code; first error program counter will
+ * point to offset in descriptor buffer where the instruction should
+ * have been written.
+ */
+#define SEQFIFOSTORE(program, data, encrypt_flags, length, flags) \
+ rta_fifo_store(program, data, encrypt_flags, 0, length, flags|SEQ)
+
+/**
+ * KEY - Configures KEY and SEQ KEY commands
+ * @program: pointer to struct program
+ * @key_dst: key store location: KEY1, KEY2, PKE, AFHA_SBOX, MDHA_SPLIT_KEY
+ * @encrypt_flags: key encryption mode: ENC, EKT, TK, NWB, PTS
+ * @src: pointer or actual data in case of immediate load (uint64_t); IMMED,
+ * COPY and DCOPY flags indicate action taken (inline imm data,
+ * inline ptr, inline from ptr).
+ * @length: number of bytes to load; can be set to 0 for SEQ command w/ VLF set
+ * (uint32_t).
+ * @flags: operational flags: for KEY: SGF, IMMED, COPY, DCOPY; for SEQKEY: SEQ,
+ * VLF, AIDF.
+ *
+ * Return: On success, descriptor buffer offset where this command is inserted.
+ * On error, a negative error code; first error program counter will
+ * point to offset in descriptor buffer where the instruction should
+ * have been written.
+ */
+#define KEY(program, key_dst, encrypt_flags, src, length, flags) \
+ rta_key(program, key_dst, encrypt_flags, src, length, flags)
+
+/**
+ * SEQINPTR - Configures SEQ IN PTR command
+ * @program: pointer to struct program
+ * @src: starting address for Input Sequence (uint64_t)
+ * @length: number of bytes in (or to be added to) Input Sequence (uint32_t)
+ * @flags: operational flags: RBS, INL, SGF, PRE, EXT, RTO, RJD, SOP (when PRE,
+ * RTO or SOP are set, @src parameter must be 0).
+ *
+ * Return: On success, descriptor buffer offset where this command is inserted.
+ * On error, a negative error code; first error program counter will
+ * point to offset in descriptor buffer where the instruction should
+ * have been written.
+ */
+#define SEQINPTR(program, src, length, flags) \
+ rta_seq_in_ptr(program, src, length, flags)
+
+/**
+ * SEQOUTPTR - Configures SEQ OUT PTR command
+ * @program: pointer to struct program
+ * @dst: starting address for Output Sequence (uint64_t)
+ * @length: number of bytes in (or to be added to) Output Sequence (uint32_t)
+ * @flags: operational flags: SGF, PRE, EXT, RTO, RST, EWS (when PRE or RTO are
+ * set, @dst parameter must be 0).
+ *
+ * Return: On success, descriptor buffer offset where this command is inserted.
+ * On error, a negative error code; first error program counter will
+ * point to offset in descriptor buffer where the instruction should
+ * have been written.
+ */
+#define SEQOUTPTR(program, dst, length, flags) \
+ rta_seq_out_ptr(program, dst, length, flags)
+
+/**
+ * ALG_OPERATION - Configures ALGORITHM OPERATION command
+ * @program: pointer to struct program
+ * @cipher_alg: algorithm to be used
+ * @aai: Additional Algorithm Information; contains mode information that is
+ * associated with the algorithm (check desc.h for specific values).
+ * @algo_state: algorithm state; defines the state of the algorithm that is
+ * being executed (check desc.h file for specific values).
+ * @icv_check: ICV checking; selects whether the algorithm should check
+ * calculated ICV with known ICV: ICV_CHECK_ENABLE,
+ * ICV_CHECK_DISABLE.
+ * @enc: selects between encryption and decryption: DIR_ENC, DIR_DEC
+ *
+ * Return: On success, descriptor buffer offset where this command is inserted.
+ * On error, a negative error code; first error program counter will
+ * point to offset in descriptor buffer where the instruction should
+ * have been written.
+ */
+#define ALG_OPERATION(program, cipher_alg, aai, algo_state, icv_check, enc) \
+ rta_operation(program, cipher_alg, aai, algo_state, icv_check, enc)
+
+/**
+ * PROTOCOL - Configures PROTOCOL OPERATION command
+ * @program: pointer to struct program
+ * @optype: operation type: OP_TYPE_UNI_PROTOCOL / OP_TYPE_DECAP_PROTOCOL /
+ * OP_TYPE_ENCAP_PROTOCOL.
+ * @protid: protocol identifier value (check desc.h file for specific values)
+ * @protoinfo: protocol dependent value (check desc.h file for specific values)
+ *
+ * Return: On success, descriptor buffer offset where this command is inserted.
+ * On error, a negative error code; first error program counter will
+ * point to offset in descriptor buffer where the instruction should
+ * have been written.
+ */
+#define PROTOCOL(program, optype, protid, protoinfo) \
+ rta_proto_operation(program, optype, protid, protoinfo)
+
+/**
+ * DKP_PROTOCOL - Configures DKP (Derived Key Protocol) PROTOCOL command
+ * @program: pointer to struct program
+ * @protid: protocol identifier value - one of the following:
+ * OP_PCLID_DKP_{MD5 | SHA1 | SHA224 | SHA256 | SHA384 | SHA512}
+ * @key_src: How the initial ("negotiated") key is provided to the DKP protocol.
+ * Valid values - one of OP_PCL_DKP_SRC_{IMM, SEQ, PTR, SGF}. Not all
+ * (key_src,key_dst) combinations are allowed.
+ * @key_dst: How the derived ("split") key is returned by the DKP protocol.
+ * Valid values - one of OP_PCL_DKP_DST_{IMM, SEQ, PTR, SGF}. Not all
+ * (key_src,key_dst) combinations are allowed.
+ * @keylen: length of the initial key, in bytes (uint16_t)
+ * @key: address where algorithm key resides; virtual address if key_type is
+ * RTA_DATA_IMM, physical (bus) address if key_type is RTA_DATA_PTR or
+ * RTA_DATA_IMM_DMA.
+ * @key_type: enum rta_data_type
+ * Return: On success, descriptor buffer offset where this command is inserted.
+ * On error, a negative error code; first error program counter will
+ * point to offset in descriptor buffer where the instruction should
+ * have been written.
+ */
+#define DKP_PROTOCOL(program, protid, key_src, key_dst, keylen, key, key_type) \
+ rta_dkp_proto(program, protid, key_src, key_dst, keylen, key, key_type)
+
+/**
+ * PKHA_OPERATION - Configures PKHA OPERATION command
+ * @program: pointer to struct program
+ * @op_pkha: PKHA operation; indicates the modular arithmetic function to
+ * execute (check desc.h file for specific values).
+ *
+ * Return: On success, descriptor buffer offset where this command is inserted.
+ * On error, a negative error code; first error program counter will
+ * point to offset in descriptor buffer where the instruction should
+ * have been written.
+ */
+#define PKHA_OPERATION(program, op_pkha) rta_pkha_operation(program, op_pkha)
+
+/**
+ * JUMP - Configures JUMP command
+ * @program: pointer to struct program
+ * @addr: local offset for local jumps or address pointer for non-local jumps;
+ * IMM or PTR macros must be used to indicate type.
+ * @jump_type: type of action taken by jump (enum rta_jump_type)
+ * @test_type: defines how jump conditions are evaluated (enum rta_jump_cond)
+ * @cond: jump conditions: operational flags - DONE1, DONE2, BOTH; various
+ * sharing and wait conditions (JSL = 1) - NIFP, NIP, NOP, NCP, CALM,
+ * SELF, SHARED, JQP; Math and PKHA status conditions (JSL = 0) - Z, N,
+ * NV, C, PK0, PK1, PKP.
+ *
+ * Return: On success, descriptor buffer offset where this command is inserted.
+ * On error, a negative error code; first error program counter will
+ * point to offset in descriptor buffer where the instruction should
+ * have been written.
+ */
+#define JUMP(program, addr, jump_type, test_type, cond) \
+ rta_jump(program, addr, jump_type, test_type, cond, NONE)
+
+/**
+ * JUMP_INC - Configures JUMP_INC command
+ * @program: pointer to struct program
+ * @addr: local offset; IMM or PTR macros must be used to indicate type
+ * @test_type: defines how jump conditions are evaluated (enum rta_jump_cond)
+ * @cond: jump conditions: Math status conditions (JSL = 0): Z, N, NV, C
+ * @src_dst: register to increment / decrement: MATH0-MATH3, DPOVRD, SEQINSZ,
+ * SEQOUTSZ, VSEQINSZ, VSEQOUTSZ.
+ *
+ * Return: On success, descriptor buffer offset where this command is inserted.
+ * On error, a negative error code; first error program counter will
+ * point to offset in descriptor buffer where the instruction should
+ * have been written.
+ */
+#define JUMP_INC(program, addr, test_type, cond, src_dst) \
+ rta_jump(program, addr, LOCAL_JUMP_INC, test_type, cond, src_dst)
+
+/**
+ * JUMP_DEC - Configures JUMP_DEC command
+ * @program: pointer to struct program
+ * @addr: local offset; IMM or PTR macros must be used to indicate type
+ * @test_type: defines how jump conditions are evaluated (enum rta_jump_cond)
+ * @cond: jump conditions: Math status conditions (JSL = 0): Z, N, NV, C
+ * @src_dst: register to increment / decrement: MATH0-MATH3, DPOVRD, SEQINSZ,
+ * SEQOUTSZ, VSEQINSZ, VSEQOUTSZ.
+ *
+ * Return: On success, descriptor buffer offset where this command is inserted.
+ * On error, a negative error code; first error program counter will
+ * point to offset in descriptor buffer where the instruction should
+ * have been written.
+ */
+#define JUMP_DEC(program, addr, test_type, cond, src_dst) \
+ rta_jump(program, addr, LOCAL_JUMP_DEC, test_type, cond, src_dst)
+
+/**
+ * LOAD - Configures LOAD command to load data registers from descriptor or from
+ * a memory location.
+ * @program: pointer to struct program
+ * @addr: immediate value or pointer to the data to be loaded; IMMED, COPY and
+ * DCOPY flags indicate action taken (inline imm data, inline ptr, inline
+ * from ptr).
+ * @dst: destination register (uint64_t)
+ * @offset: start point to write data in destination register (uint32_t)
+ * @length: number of bytes to load (uint32_t)
+ * @flags: operational flags: VLF, IMMED, COPY, DCOPY
+ *
+ * Return: On success, descriptor buffer offset where this command is inserted.
+ * On error, a negative error code; first error program counter will
+ * point to offset in descriptor buffer where the instruction should
+ * have been written.
+ */
+#define LOAD(program, addr, dst, offset, length, flags) \
+ rta_load(program, addr, dst, offset, length, flags)
+
+/**
+ * SEQLOAD - Configures SEQ LOAD command to load data registers from descriptor
+ * or from a memory location.
+ * @program: pointer to struct program
+ * @dst: destination register (uint64_t)
+ * @offset: start point to write data in destination register (uint32_t)
+ * @length: number of bytes to load (uint32_t)
+ * @flags: operational flags: SGF
+ *
+ * Return: On success, descriptor buffer offset where this command is inserted.
+ * On error, a negative error code; first error program counter will
+ * point to offset in descriptor buffer where the instruction should
+ * have been written.
+ */
+#define SEQLOAD(program, dst, offset, length, flags) \
+ rta_load(program, NONE, dst, offset, length, flags|SEQ)
+
+/**
+ * STORE - Configures STORE command to read data from registers and write them
+ * to a memory location.
+ * @program: pointer to struct program
+ * @src: immediate value or source register for data to be stored: KEY1SZ,
+ * KEY2SZ, DJQDA, MODE1, MODE2, DJQCTRL, DATA1SZ, DATA2SZ, DSTAT, ICV1SZ,
+ * ICV2SZ, DPID, CCTRL, ICTRL, CLRW, CSTAT, MATH0-MATH3, PKHA registers,
+ * CONTEXT1, CONTEXT2, DESCBUF, JOBDESCBUF, SHAREDESCBUF. In case of
+ * immediate value, IMMED, COPY and DCOPY flags indicate action taken
+ * (inline imm data, inline ptr, inline from ptr).
+ * @offset: start point for reading from source register (uint16_t)
+ * @dst: pointer to store location (uint64_t)
+ * @length: number of bytes to store (uint32_t)
+ * @flags: operational flags: VLF, IMMED, COPY, DCOPY
+ *
+ * Return: On success, descriptor buffer offset where this command is inserted.
+ * On error, a negative error code; first error program counter will
+ * point to offset in descriptor buffer where the instruction should
+ * have been written.
+ */
+#define STORE(program, src, offset, dst, length, flags) \
+ rta_store(program, src, offset, dst, length, flags)
+
+/**
+ * SEQSTORE - Configures SEQ STORE command to read data from registers and write
+ * them to a memory location.
+ * @program: pointer to struct program
+ * @src: immediate value or source register for data to be stored: KEY1SZ,
+ * KEY2SZ, DJQDA, MODE1, MODE2, DJQCTRL, DATA1SZ, DATA2SZ, DSTAT, ICV1SZ,
+ * ICV2SZ, DPID, CCTRL, ICTRL, CLRW, CSTAT, MATH0-MATH3, PKHA registers,
+ * CONTEXT1, CONTEXT2, DESCBUF, JOBDESCBUF, SHAREDESCBUF. In case of
+ * immediate value, IMMED, COPY and DCOPY flags indicate action taken
+ * (inline imm data, inline ptr, inline from ptr).
+ * @offset: start point for reading from source register (uint16_t)
+ * @length: number of bytes to store (uint32_t)
+ * @flags: operational flags: SGF, IMMED, COPY, DCOPY
+ *
+ * Return: On success, descriptor buffer offset where this command is inserted.
+ * On error, a negative error code; first error program counter will
+ * point to offset in descriptor buffer where the instruction should
+ * have been written.
+ */
+#define SEQSTORE(program, src, offset, length, flags) \
+ rta_store(program, src, offset, NONE, length, flags|SEQ)
+
+/**
+ * MATHB - Configures MATHB command to perform binary operations
+ * @program: pointer to struct program
+ * @operand1: first operand: MATH0-MATH3, DPOVRD, SEQINSZ, SEQOUTSZ, VSEQINSZ,
+ * VSEQOUTSZ, ZERO, ONE, NONE, Immediate value. IMMED must be used to
+ * indicate immediate value.
+ * @operator: function to be performed: ADD, ADDC, SUB, SUBB, OR, AND, XOR,
+ * LSHIFT, RSHIFT, SHLD.
+ * @operand2: second operand: MATH0-MATH3, DPOVRD, VSEQINSZ, VSEQOUTSZ, ABD,
+ * OFIFO, JOBSRC, ZERO, ONE, Immediate value. IMMED2 must be used to
+ * indicate immediate value.
+ * @result: destination for the result: MATH0-MATH3, DPOVRD, SEQINSZ, SEQOUTSZ,
+ * NONE, VSEQINSZ, VSEQOUTSZ.
+ * @length: length in bytes of the operation and the immediate value, if there
+ * is one (int).
+ * @opt: operational flags: IFB, NFU, STL, SWP, IMMED, IMMED2
+ *
+ * Return: On success, descriptor buffer offset where this command is inserted.
+ * On error, a negative error code; first error program counter will
+ * point to offset in descriptor buffer where the instruction should
+ * have been written.
+ */
+#define MATHB(program, operand1, operator, operand2, result, length, opt) \
+ rta_math(program, operand1, MATH_FUN_##operator, operand2, result, \
+ length, opt)
+
+/**
+ * MATHI - Configures MATHI command to perform binary operations
+ * @program: pointer to struct program
+ * @operand: if !SSEL: MATH0-MATH3, DPOVRD, SEQINSZ, SEQOUTSZ, VSEQINSZ,
+ * VSEQOUTSZ, ZERO, ONE.
+ * if SSEL: MATH0-MATH3, DPOVRD, VSEQINSZ, VSEQOUTSZ, ABD, OFIFO,
+ * JOBSRC, ZERO, ONE.
+ * @operator: function to be performed: ADD, ADDC, SUB, SUBB, OR, AND, XOR,
+ * LSHIFT, RSHIFT, FBYT (for !SSEL only).
+ * @imm: Immediate value (uint8_t). IMMED must be used to indicate immediate
+ * value.
+ * @result: destination for the result: MATH0-MATH3, DPOVRD, SEQINSZ, SEQOUTSZ,
+ * NONE, VSEQINSZ, VSEQOUTSZ.
+ * @length: length in bytes of the operation and the immediate value, if there
+ * is one (int). @imm is left-extended with zeros if needed.
+ * @opt: operational flags: NFU, SSEL, SWP, IMMED
+ *
+ * If !SSEL, @operand <@operator> @imm -> @result
+ * If SSEL, @imm <@operator> @operand -> @result
+ *
+ * Return: On success, descriptor buffer offset where this command is inserted.
+ * On error, a negative error code; first error program counter will
+ * point to offset in descriptor buffer where the instruction should
+ * have been written.
+ */
+#define MATHI(program, operand, operator, imm, result, length, opt) \
+ rta_mathi(program, operand, MATH_FUN_##operator, imm, result, length, \
+ opt)
+
+/**
+ * MATHU - Configures MATHU command to perform unary operations
+ * @program: pointer to struct program
+ * @operand1: operand: MATH0-MATH3, DPOVRD, SEQINSZ, SEQOUTSZ, VSEQINSZ,
+ * VSEQOUTSZ, ZERO, ONE, NONE, Immediate value. IMMED must be used to
+ * indicate immediate value.
+ * @operator: function to be performed: ZBYT, BSWAP
+ * @result: destination for the result: MATH0-MATH3, DPOVRD, SEQINSZ, SEQOUTSZ,
+ * NONE, VSEQINSZ, VSEQOUTSZ.
+ * @length: length in bytes of the operation and the immediate value, if there
+ * is one (int).
+ * @opt: operational flags: NFU, STL, SWP, IMMED
+ *
+ * Return: On success, descriptor buffer offset where this command is inserted.
+ * On error, a negative error code; first error program counter will
+ * point to offset in descriptor buffer where the instruction should
+ * have been written.
+ */
+#define MATHU(program, operand1, operator, result, length, opt) \
+ rta_math(program, operand1, MATH_FUN_##operator, NONE, result, length, \
+ opt)
+
+/**
+ * SIGNATURE - Configures SIGNATURE command
+ * @program: pointer to struct program
+ * @sign_type: signature type: SIGN_TYPE_FINAL, SIGN_TYPE_FINAL_RESTORE,
+ * SIGN_TYPE_FINAL_NONZERO, SIGN_TYPE_IMM_2, SIGN_TYPE_IMM_3,
+ * SIGN_TYPE_IMM_4.
+ *
+ * After SIGNATURE command, DWORD or WORD must be used to insert signature in
+ * descriptor buffer.
+ *
+ * Return: On success, descriptor buffer offset where this command is inserted.
+ * On error, a negative error code; first error program counter will
+ * point to offset in descriptor buffer where the instruction should
+ * have been written.
+ */
+#define SIGNATURE(program, sign_type) rta_signature(program, sign_type)
+
+/**
+ * NFIFOADD - Configures NFIFO command, a shortcut of RTA Load command to write
+ * to iNfo FIFO.
+ * @program: pointer to struct program
+ * @src: source for the input data in Alignment Block:IFIFO, OFIFO, PAD,
+ * MSGOUTSNOOP, ALTSOURCE, OFIFO_SYNC, MSGOUTSNOOP_ALT.
+ * @data: type of data that is going through the Input Data FIFO: MSG, MSG1,
+ * MSG2, IV1, IV2, ICV1, ICV2, SAD1, AAD1, AAD2, AFHA_SBOX, SKIP,
+ * PKHA registers, AB1, AB2, ABD.
+ * @length: length of the data copied in FIFO registers (uint32_t)
+ * @flags: select options between:
+ * -operational flags: LAST1, LAST2, FLUSH1, FLUSH2, OC, BP
+ * -when PAD is selected as source: BM, PR, PS
+ * -padding type: <em>PAD_ZERO, PAD_NONZERO, PAD_INCREMENT, PAD_RANDOM,
+ * PAD_ZERO_N1, PAD_NONZERO_0, PAD_N1, PAD_NONZERO_N
+ *
+ * Return: On success, descriptor buffer offset where this command is inserted.
+ * On error, a negative error code; first error program counter will
+ * point to offset in descriptor buffer where the instruction should
+ * have been written.
+ */
+#define NFIFOADD(program, src, data, length, flags) \
+ rta_nfifo_load(program, src, data, length, flags)
+
+/**
+ * DOC: Self Referential Code Management Routines
+ *
+ * Contains details of RTA self referential code routines.
+ */
+
+/**
+ * REFERENCE - initialize a variable used for storing an index inside a
+ * descriptor buffer.
+ * @ref: reference to a descriptor buffer's index where an update is required
+ * with a value that will be known latter in the program flow.
+ */
+#define REFERENCE(ref) int ref = -1
+
+/**
+ * LABEL - initialize a variable used for storing an index inside a descriptor
+ * buffer.
+ * @label: label stores the value with what should be updated the REFERENCE line
+ * in the descriptor buffer.
+ */
+#define LABEL(label) unsigned int label = 0
+
+/**
+ * SET_LABEL - set a LABEL value
+ * @program: pointer to struct program
+ * @label: value that will be inserted in a line previously written in the
+ * descriptor buffer.
+ */
+#define SET_LABEL(program, label) (label = rta_set_label(program))
+
+/**
+ * PATCH_JUMP - Auxiliary command to resolve self referential code
+ * @program: buffer to be updated (struct program *)
+ * @line: position in descriptor buffer where the update will be done; this
+ * value is previously retained in program flow using a reference near
+ * the sequence to be modified.
+ * @new_ref: updated value that will be inserted in descriptor buffer at the
+ * specified line; this value is previously obtained using SET_LABEL
+ * macro near the line that will be used as reference (unsigned int).
+ * For JUMP command, the value represents the offset field (in words).
+ *
+ * Return: 0 in case of success, a negative error code if it fails
+ */
+#define PATCH_JUMP(program, line, new_ref) rta_patch_jmp(program, line, new_ref)
+
+/**
+ * PATCH_MOVE - Auxiliary command to resolve self referential code
+ * @program: buffer to be updated (struct program *)
+ * @line: position in descriptor buffer where the update will be done; this
+ * value is previously retained in program flow using a reference near
+ * the sequence to be modified.
+ * @new_ref: updated value that will be inserted in descriptor buffer at the
+ * specified line; this value is previously obtained using SET_LABEL
+ * macro near the line that will be used as reference (unsigned int).
+ * For MOVE command, the value represents the offset field (in words).
+ *
+ * Return: 0 in case of success, a negative error code if it fails
+ */
+#define PATCH_MOVE(program, line, new_ref) \
+ rta_patch_move(program, line, new_ref)
+
+/**
+ * PATCH_LOAD - Auxiliary command to resolve self referential code
+ * @program: buffer to be updated (struct program *)
+ * @line: position in descriptor buffer where the update will be done; this
+ * value is previously retained in program flow using a reference near
+ * the sequence to be modified.
+ * @new_ref: updated value that will be inserted in descriptor buffer at the
+ * specified line; this value is previously obtained using SET_LABEL
+ * macro near the line that will be used as reference (unsigned int).
+ * For LOAD command, the value represents the offset field (in words).
+ *
+ * Return: 0 in case of success, a negative error code if it fails
+ */
+#define PATCH_LOAD(program, line, new_ref) \
+ rta_patch_load(program, line, new_ref)
+
+/**
+ * PATCH_STORE - Auxiliary command to resolve self referential code
+ * @program: buffer to be updated (struct program *)
+ * @line: position in descriptor buffer where the update will be done; this
+ * value is previously retained in program flow using a reference near
+ * the sequence to be modified.
+ * @new_ref: updated value that will be inserted in descriptor buffer at the
+ * specified line; this value is previously obtained using SET_LABEL
+ * macro near the line that will be used as reference (unsigned int).
+ * For STORE command, the value represents the offset field (in words).
+ *
+ * Return: 0 in case of success, a negative error code if it fails
+ */
+#define PATCH_STORE(program, line, new_ref) \
+ rta_patch_store(program, line, new_ref)
+
+/**
+ * PATCH_HDR - Auxiliary command to resolve self referential code
+ * @program: buffer to be updated (struct program *)
+ * @line: position in descriptor buffer where the update will be done; this
+ * value is previously retained in program flow using a reference near
+ * the sequence to be modified.
+ * @new_ref: updated value that will be inserted in descriptor buffer at the
+ * specified line; this value is previously obtained using SET_LABEL
+ * macro near the line that will be used as reference (unsigned int).
+ * For HEADER command, the value represents the start index field.
+ *
+ * Return: 0 in case of success, a negative error code if it fails
+ */
+#define PATCH_HDR(program, line, new_ref) \
+ rta_patch_header(program, line, new_ref)
+
+/**
+ * PATCH_RAW - Auxiliary command to resolve self referential code
+ * @program: buffer to be updated (struct program *)
+ * @line: position in descriptor buffer where the update will be done; this
+ * value is previously retained in program flow using a reference near
+ * the sequence to be modified.
+ * @mask: mask to be used for applying the new value (unsigned int). The mask
+ * selects which bits from the provided @new_val are taken into
+ * consideration when overwriting the existing value.
+ * @new_val: updated value that will be masked using the provided mask value
+ * and inserted in descriptor buffer at the specified line.
+ *
+ * Return: 0 in case of success, a negative error code if it fails
+ */
+#define PATCH_RAW(program, line, mask, new_val) \
+ rta_patch_raw(program, line, mask, new_val)
+
+#endif /* __RTA_RTA_H__ */
--- /dev/null
+/* SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0)
+ *
+ * Copyright 2008-2016 Freescale Semiconductor Inc.
+ * Copyright 2016,2019 NXP
+ */
+
+#ifndef __RTA_FIFO_LOAD_STORE_CMD_H__
+#define __RTA_FIFO_LOAD_STORE_CMD_H__
+
+extern enum rta_sec_era rta_sec_era;
+
+static const uint32_t fifo_load_table[][2] = {
+/*1*/ { PKA0, FIFOLD_CLASS_CLASS1 | FIFOLD_TYPE_PK_A0 },
+ { PKA1, FIFOLD_CLASS_CLASS1 | FIFOLD_TYPE_PK_A1 },
+ { PKA2, FIFOLD_CLASS_CLASS1 | FIFOLD_TYPE_PK_A2 },
+ { PKA3, FIFOLD_CLASS_CLASS1 | FIFOLD_TYPE_PK_A3 },
+ { PKB0, FIFOLD_CLASS_CLASS1 | FIFOLD_TYPE_PK_B0 },
+ { PKB1, FIFOLD_CLASS_CLASS1 | FIFOLD_TYPE_PK_B1 },
+ { PKB2, FIFOLD_CLASS_CLASS1 | FIFOLD_TYPE_PK_B2 },
+ { PKB3, FIFOLD_CLASS_CLASS1 | FIFOLD_TYPE_PK_B3 },
+ { PKA, FIFOLD_CLASS_CLASS1 | FIFOLD_TYPE_PK_A },
+ { PKB, FIFOLD_CLASS_CLASS1 | FIFOLD_TYPE_PK_B },
+ { PKN, FIFOLD_CLASS_CLASS1 | FIFOLD_TYPE_PK_N },
+ { SKIP, FIFOLD_CLASS_SKIP },
+ { MSG1, FIFOLD_CLASS_CLASS1 | FIFOLD_TYPE_MSG },
+ { MSG2, FIFOLD_CLASS_CLASS2 | FIFOLD_TYPE_MSG },
+ { MSGOUTSNOOP, FIFOLD_CLASS_BOTH | FIFOLD_TYPE_MSG1OUT2 },
+ { MSGINSNOOP, FIFOLD_CLASS_BOTH | FIFOLD_TYPE_MSG },
+ { IV1, FIFOLD_CLASS_CLASS1 | FIFOLD_TYPE_IV },
+ { IV2, FIFOLD_CLASS_CLASS2 | FIFOLD_TYPE_IV },
+ { AAD1, FIFOLD_CLASS_CLASS1 | FIFOLD_TYPE_AAD },
+ { ICV1, FIFOLD_CLASS_CLASS1 | FIFOLD_TYPE_ICV },
+ { ICV2, FIFOLD_CLASS_CLASS2 | FIFOLD_TYPE_ICV },
+ { BIT_DATA, FIFOLD_TYPE_BITDATA },
+/*23*/ { IFIFO, FIFOLD_CLASS_CLASS1 | FIFOLD_TYPE_NOINFOFIFO }
+};
+
+/*
+ * Allowed FIFO_LOAD input data types for each SEC Era.
+ * Values represent the number of entries from fifo_load_table[] that are
+ * supported.
+ */
+static const unsigned int fifo_load_table_sz[] = {22, 22, 23, 23,
+ 23, 23, 23, 23,
+ 23, 23};
+
+static inline int
+rta_fifo_load(struct program *program, uint32_t src,
+ uint64_t loc, uint32_t length, uint32_t flags)
+{
+ uint32_t opcode = 0;
+ uint32_t ext_length = 0, val = 0;
+ int ret = -EINVAL;
+ bool is_seq_cmd = false;
+ unsigned int start_pc = program->current_pc;
+
+ /* write command type field */
+ if (flags & SEQ) {
+ opcode = CMD_SEQ_FIFO_LOAD;
+ is_seq_cmd = true;
+ } else {
+ opcode = CMD_FIFO_LOAD;
+ }
+
+ /* Parameters checking */
+ if (is_seq_cmd) {
+ if ((flags & IMMED) || (flags & SGF)) {
+ pr_err("SEQ FIFO LOAD: Invalid command\n");
+ goto err;
+ }
+ if ((rta_sec_era <= RTA_SEC_ERA_5) && (flags & AIDF)) {
+ pr_err("SEQ FIFO LOAD: Flag(s) not supported by SEC Era %d\n",
+ USER_SEC_ERA(rta_sec_era));
+ goto err;
+ }
+ if ((flags & VLF) && ((flags & EXT) || (length >> 16))) {
+ pr_err("SEQ FIFO LOAD: Invalid usage of VLF\n");
+ goto err;
+ }
+ } else {
+ if (src == SKIP) {
+ pr_err("FIFO LOAD: Invalid src\n");
+ goto err;
+ }
+ if ((flags & AIDF) || (flags & VLF)) {
+ pr_err("FIFO LOAD: Invalid command\n");
+ goto err;
+ }
+ if ((flags & IMMED) && (flags & SGF)) {
+ pr_err("FIFO LOAD: Invalid usage of SGF and IMM\n");
+ goto err;
+ }
+ if ((flags & IMMED) && ((flags & EXT) || (length >> 16))) {
+ pr_err("FIFO LOAD: Invalid usage of EXT and IMM\n");
+ goto err;
+ }
+ }
+
+ /* write input data type field */
+ ret = __rta_map_opcode(src, fifo_load_table,
+ fifo_load_table_sz[rta_sec_era], &val);
+ if (ret < 0) {
+ pr_err("FIFO LOAD: Source value is not supported. SEC Program Line: %d\n",
+ program->current_pc);
+ goto err;
+ }
+ opcode |= val;
+
+ if (flags & CLASS1)
+ opcode |= FIFOLD_CLASS_CLASS1;
+ if (flags & CLASS2)
+ opcode |= FIFOLD_CLASS_CLASS2;
+ if (flags & BOTH)
+ opcode |= FIFOLD_CLASS_BOTH;
+
+ /* write fields: SGF|VLF, IMM, [LC1, LC2, F1] */
+ if (flags & FLUSH1)
+ opcode |= FIFOLD_TYPE_FLUSH1;
+ if (flags & LAST1)
+ opcode |= FIFOLD_TYPE_LAST1;
+ if (flags & LAST2)
+ opcode |= FIFOLD_TYPE_LAST2;
+ if (!is_seq_cmd) {
+ if (flags & SGF)
+ opcode |= FIFOLDST_SGF;
+ if (flags & IMMED)
+ opcode |= FIFOLD_IMM;
+ } else {
+ if (flags & VLF)
+ opcode |= FIFOLDST_VLF;
+ if (flags & AIDF)
+ opcode |= FIFOLD_AIDF;
+ }
+
+ /*
+ * Verify if extended length is required. In case of BITDATA, calculate
+ * number of full bytes and additional valid bits.
+ */
+ if ((flags & EXT) || (length >> 16)) {
+ opcode |= FIFOLDST_EXT;
+ if (src == BIT_DATA) {
+ ext_length = (length / 8);
+ length = (length % 8);
+ } else {
+ ext_length = length;
+ length = 0;
+ }
+ }
+ opcode |= (uint16_t) length;
+
+ __rta_out32(program, opcode);
+ program->current_instruction++;
+
+ /* write pointer or immediate data field */
+ if (flags & IMMED)
+ __rta_inline_data(program, loc, flags & __COPY_MASK, length);
+ else if (!is_seq_cmd)
+ __rta_out64(program, program->ps, loc);
+
+ /* write extended length field */
+ if (opcode & FIFOLDST_EXT)
+ __rta_out32(program, ext_length);
+
+ return (int)start_pc;
+
+ err:
+ program->first_error_pc = start_pc;
+ program->current_instruction++;
+ return ret;
+}
+
+static const uint32_t fifo_store_table[][2] = {
+/*1*/ { PKA0, FIFOST_TYPE_PKHA_A0 },
+ { PKA1, FIFOST_TYPE_PKHA_A1 },
+ { PKA2, FIFOST_TYPE_PKHA_A2 },
+ { PKA3, FIFOST_TYPE_PKHA_A3 },
+ { PKB0, FIFOST_TYPE_PKHA_B0 },
+ { PKB1, FIFOST_TYPE_PKHA_B1 },
+ { PKB2, FIFOST_TYPE_PKHA_B2 },
+ { PKB3, FIFOST_TYPE_PKHA_B3 },
+ { PKA, FIFOST_TYPE_PKHA_A },
+ { PKB, FIFOST_TYPE_PKHA_B },
+ { PKN, FIFOST_TYPE_PKHA_N },
+ { PKE, FIFOST_TYPE_PKHA_E_JKEK },
+ { RNG, FIFOST_TYPE_RNGSTORE },
+ { RNGOFIFO, FIFOST_TYPE_RNGFIFO },
+ { AFHA_SBOX, FIFOST_TYPE_AF_SBOX_JKEK },
+ { MDHA_SPLIT_KEY, FIFOST_CLASS_CLASS2KEY | FIFOST_TYPE_SPLIT_KEK },
+ { MSG, FIFOST_TYPE_MESSAGE_DATA },
+ { KEY1, FIFOST_CLASS_CLASS1KEY | FIFOST_TYPE_KEY_KEK },
+ { KEY2, FIFOST_CLASS_CLASS2KEY | FIFOST_TYPE_KEY_KEK },
+ { OFIFO, FIFOST_TYPE_OUTFIFO_KEK},
+ { SKIP, FIFOST_TYPE_SKIP },
+/*22*/ { METADATA, FIFOST_TYPE_METADATA},
+ { MSG_CKSUM, FIFOST_TYPE_MESSAGE_DATA2 }
+};
+
+/*
+ * Allowed FIFO_STORE output data types for each SEC Era.
+ * Values represent the number of entries from fifo_store_table[] that are
+ * supported.
+ */
+static const unsigned int fifo_store_table_sz[] = {21, 21, 21, 21,
+ 22, 22, 22, 23,
+ 23, 23};
+
+static inline int
+rta_fifo_store(struct program *program, uint32_t src,
+ uint32_t encrypt_flags, uint64_t dst,
+ uint32_t length, uint32_t flags)
+{
+ uint32_t opcode = 0;
+ uint32_t val = 0;
+ int ret = -EINVAL;
+ bool is_seq_cmd = false;
+ unsigned int start_pc = program->current_pc;
+
+ /* write command type field */
+ if (flags & SEQ) {
+ opcode = CMD_SEQ_FIFO_STORE;
+ is_seq_cmd = true;
+ } else {
+ opcode = CMD_FIFO_STORE;
+ }
+
+ /* Parameter checking */
+ if (is_seq_cmd) {
+ if ((flags & VLF) && ((length >> 16) || (flags & EXT))) {
+ pr_err("SEQ FIFO STORE: Invalid usage of VLF\n");
+ goto err;
+ }
+ if (dst) {
+ pr_err("SEQ FIFO STORE: Invalid command\n");
+ goto err;
+ }
+ if ((src == METADATA) && (flags & (CONT | EXT))) {
+ pr_err("SEQ FIFO STORE: Invalid flags\n");
+ goto err;
+ }
+ } else {
+ if (((src == RNGOFIFO) && ((dst) || (flags & EXT))) ||
+ (src == METADATA)) {
+ pr_err("FIFO STORE: Invalid destination\n");
+ goto err;
+ }
+ }
+ if ((rta_sec_era == RTA_SEC_ERA_7) && (src == AFHA_SBOX)) {
+ pr_err("FIFO STORE: AFHA S-box not supported by SEC Era %d\n",
+ USER_SEC_ERA(rta_sec_era));
+ goto err;
+ }
+
+ /* write output data type field */
+ ret = __rta_map_opcode(src, fifo_store_table,
+ fifo_store_table_sz[rta_sec_era], &val);
+ if (ret < 0) {
+ pr_err("FIFO STORE: Source type not supported. SEC Program Line: %d\n",
+ program->current_pc);
+ goto err;
+ }
+ opcode |= val;
+
+ if (encrypt_flags & TK)
+ opcode |= (0x1 << FIFOST_TYPE_SHIFT);
+ if (encrypt_flags & EKT) {
+ if (rta_sec_era == RTA_SEC_ERA_1) {
+ pr_err("FIFO STORE: AES-CCM source types not supported\n");
+ ret = -EINVAL;
+ goto err;
+ }
+ opcode |= (0x10 << FIFOST_TYPE_SHIFT);
+ opcode &= (uint32_t)~(0x20 << FIFOST_TYPE_SHIFT);
+ }
+
+ /* write flags fields */
+ if (flags & CONT)
+ opcode |= FIFOST_CONT;
+ if ((flags & VLF) && (is_seq_cmd))
+ opcode |= FIFOLDST_VLF;
+ if ((flags & SGF) && (!is_seq_cmd))
+ opcode |= FIFOLDST_SGF;
+ if (flags & CLASS1)
+ opcode |= FIFOST_CLASS_CLASS1KEY;
+ if (flags & CLASS2)
+ opcode |= FIFOST_CLASS_CLASS2KEY;
+ if (flags & BOTH)
+ opcode |= FIFOST_CLASS_BOTH;
+
+ /* Verify if extended length is required */
+ if ((length >> 16) || (flags & EXT))
+ opcode |= FIFOLDST_EXT;
+ else
+ opcode |= (uint16_t) length;
+
+ __rta_out32(program, opcode);
+ program->current_instruction++;
+
+ /* write pointer field */
+ if ((!is_seq_cmd) && (dst))
+ __rta_out64(program, program->ps, dst);
+
+ /* write extended length field */
+ if (opcode & FIFOLDST_EXT)
+ __rta_out32(program, length);
+
+ return (int)start_pc;
+
+ err:
+ program->first_error_pc = start_pc;
+ program->current_instruction++;
+ return ret;
+}
+
+#endif /* __RTA_FIFO_LOAD_STORE_CMD_H__ */
--- /dev/null
+/* SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0)
+ *
+ * Copyright 2008-2016 Freescale Semiconductor Inc.
+ * Copyright 2016,2019 NXP
+ */
+
+#ifndef __RTA_HEADER_CMD_H__
+#define __RTA_HEADER_CMD_H__
+
+extern enum rta_sec_era rta_sec_era;
+
+/* Allowed job header flags for each SEC Era. */
+static const uint32_t job_header_flags[] = {
+ DNR | TD | MTD | SHR | REO,
+ DNR | TD | MTD | SHR | REO | RSMS,
+ DNR | TD | MTD | SHR | REO | RSMS,
+ DNR | TD | MTD | SHR | REO | RSMS,
+ DNR | TD | MTD | SHR | REO | RSMS | EXT,
+ DNR | TD | MTD | SHR | REO | RSMS | EXT,
+ DNR | TD | MTD | SHR | REO | RSMS | EXT,
+ DNR | TD | MTD | SHR | REO | EXT,
+ DNR | TD | MTD | SHR | REO | EXT,
+ DNR | TD | MTD | SHR | REO | EXT
+};
+
+/* Allowed shared header flags for each SEC Era. */
+static const uint32_t shr_header_flags[] = {
+ DNR | SC | PD,
+ DNR | SC | PD | CIF,
+ DNR | SC | PD | CIF,
+ DNR | SC | PD | CIF | RIF,
+ DNR | SC | PD | CIF | RIF,
+ DNR | SC | PD | CIF | RIF,
+ DNR | SC | PD | CIF | RIF,
+ DNR | SC | PD | CIF | RIF,
+ DNR | SC | PD | CIF | RIF,
+ DNR | SC | PD | CIF | RIF
+};
+
+static inline int
+rta_shr_header(struct program *program,
+ enum rta_share_type share,
+ unsigned int start_idx,
+ uint32_t flags)
+{
+ uint32_t opcode = CMD_SHARED_DESC_HDR;
+ unsigned int start_pc = program->current_pc;
+
+ if (flags & ~shr_header_flags[rta_sec_era]) {
+ pr_err("SHR_DESC: Flag(s) not supported by SEC Era %d\n",
+ USER_SEC_ERA(rta_sec_era));
+ goto err;
+ }
+
+ switch (share) {
+ case SHR_ALWAYS:
+ opcode |= HDR_SHARE_ALWAYS;
+ break;
+ case SHR_SERIAL:
+ opcode |= HDR_SHARE_SERIAL;
+ break;
+ case SHR_NEVER:
+ /*
+ * opcode |= HDR_SHARE_NEVER;
+ * HDR_SHARE_NEVER is 0
+ */
+ break;
+ case SHR_WAIT:
+ opcode |= HDR_SHARE_WAIT;
+ break;
+ default:
+ pr_err("SHR_DESC: SHARE VALUE is not supported. SEC Program Line: %d\n",
+ program->current_pc);
+ goto err;
+ }
+
+ opcode |= HDR_ONE;
+ if (rta_sec_era >= RTA_SEC_ERA_10)
+ opcode |= (start_idx << HDR_START_IDX_SHIFT) &
+ HDR_START_IDX_MASK_ERA10;
+ else
+ opcode |= (start_idx << HDR_START_IDX_SHIFT) &
+ HDR_START_IDX_MASK;
+
+ if (flags & DNR)
+ opcode |= HDR_DNR;
+ if (flags & CIF)
+ opcode |= HDR_CLEAR_IFIFO;
+ if (flags & SC)
+ opcode |= HDR_SAVECTX;
+ if (flags & PD)
+ opcode |= HDR_PROP_DNR;
+ if (flags & RIF)
+ opcode |= HDR_RIF;
+
+ __rta_out32(program, opcode);
+ program->current_instruction++;
+
+ if (program->current_instruction == 1)
+ program->shrhdr = program->buffer;
+
+ return (int)start_pc;
+
+ err:
+ program->first_error_pc = start_pc;
+ program->current_instruction++;
+ return -EINVAL;
+}
+
+static inline int
+rta_job_header(struct program *program,
+ enum rta_share_type share,
+ unsigned int start_idx,
+ uint64_t shr_desc, uint32_t flags,
+ uint32_t ext_flags)
+{
+ uint32_t opcode = CMD_DESC_HDR;
+ uint32_t hdr_ext = 0;
+ unsigned int start_pc = program->current_pc;
+
+ if (flags & ~job_header_flags[rta_sec_era]) {
+ pr_err("JOB_DESC: Flag(s) not supported by SEC Era %d\n",
+ USER_SEC_ERA(rta_sec_era));
+ goto err;
+ }
+
+ switch (share) {
+ case SHR_ALWAYS:
+ opcode |= HDR_SHARE_ALWAYS;
+ break;
+ case SHR_SERIAL:
+ opcode |= HDR_SHARE_SERIAL;
+ break;
+ case SHR_NEVER:
+ /*
+ * opcode |= HDR_SHARE_NEVER;
+ * HDR_SHARE_NEVER is 0
+ */
+ break;
+ case SHR_WAIT:
+ opcode |= HDR_SHARE_WAIT;
+ break;
+ case SHR_DEFER:
+ opcode |= HDR_SHARE_DEFER;
+ break;
+ default:
+ pr_err("JOB_DESC: SHARE VALUE is not supported. SEC Program Line: %d\n",
+ program->current_pc);
+ goto err;
+ }
+
+ if ((flags & TD) && (flags & REO)) {
+ pr_err("JOB_DESC: REO flag not supported for trusted descriptors. SEC Program Line: %d\n",
+ program->current_pc);
+ goto err;
+ }
+
+ if ((rta_sec_era < RTA_SEC_ERA_7) && (flags & MTD) && !(flags & TD)) {
+ pr_err("JOB_DESC: Trying to MTD a descriptor that is not a TD. SEC Program Line: %d\n",
+ program->current_pc);
+ goto err;
+ }
+
+ if ((flags & EXT) && !(flags & SHR) && (start_idx < 2)) {
+ pr_err("JOB_DESC: Start index must be >= 2 in case of no SHR and EXT. SEC Program Line: %d\n",
+ program->current_pc);
+ goto err;
+ }
+
+ opcode |= HDR_ONE;
+ if (rta_sec_era >= RTA_SEC_ERA_10)
+ opcode |= (start_idx << HDR_START_IDX_SHIFT) &
+ HDR_START_IDX_MASK_ERA10;
+ else
+ opcode |= (start_idx << HDR_START_IDX_SHIFT) &
+ HDR_START_IDX_MASK;
+
+ if (flags & EXT) {
+ opcode |= HDR_EXT;
+
+ if (ext_flags & DSV) {
+ hdr_ext |= HDR_EXT_DSEL_VALID;
+ hdr_ext |= ext_flags & DSEL_MASK;
+ }
+
+ if (ext_flags & FTD) {
+ if (rta_sec_era <= RTA_SEC_ERA_5) {
+ pr_err("JOB_DESC: Fake trusted descriptor not supported by SEC Era %d\n",
+ USER_SEC_ERA(rta_sec_era));
+ goto err;
+ }
+
+ hdr_ext |= HDR_EXT_FTD;
+ }
+ }
+ if (flags & RSMS)
+ opcode |= HDR_RSLS;
+ if (flags & DNR)
+ opcode |= HDR_DNR;
+ if (flags & TD)
+ opcode |= HDR_TRUSTED;
+ if (flags & MTD)
+ opcode |= HDR_MAKE_TRUSTED;
+ if (flags & REO)
+ opcode |= HDR_REVERSE;
+ if (flags & SHR)
+ opcode |= HDR_SHARED;
+
+ __rta_out32(program, opcode);
+ program->current_instruction++;
+
+ if (program->current_instruction == 1) {
+ program->jobhdr = program->buffer;
+
+ if (opcode & HDR_SHARED)
+ __rta_out64(program, program->ps, shr_desc);
+ }
+
+ if (flags & EXT)
+ __rta_out32(program, hdr_ext);
+
+ /* Note: descriptor length is set in program_finalize routine */
+ return (int)start_pc;
+
+ err:
+ program->first_error_pc = start_pc;
+ program->current_instruction++;
+ return -EINVAL;
+}
+
+#endif /* __RTA_HEADER_CMD_H__ */
--- /dev/null
+/* SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0)
+ *
+ * Copyright 2008-2016 Freescale Semiconductor Inc.
+ * Copyright 2016,2019 NXP
+ */
+
+#ifndef __RTA_JUMP_CMD_H__
+#define __RTA_JUMP_CMD_H__
+
+extern enum rta_sec_era rta_sec_era;
+
+static const uint32_t jump_test_cond[][2] = {
+ { NIFP, JUMP_COND_NIFP },
+ { NIP, JUMP_COND_NIP },
+ { NOP, JUMP_COND_NOP },
+ { NCP, JUMP_COND_NCP },
+ { CALM, JUMP_COND_CALM },
+ { SELF, JUMP_COND_SELF },
+ { SHRD, JUMP_COND_SHRD },
+ { JQP, JUMP_COND_JQP },
+ { MATH_Z, JUMP_COND_MATH_Z },
+ { MATH_N, JUMP_COND_MATH_N },
+ { MATH_NV, JUMP_COND_MATH_NV },
+ { MATH_C, JUMP_COND_MATH_C },
+ { PK_0, JUMP_COND_PK_0 },
+ { PK_GCD_1, JUMP_COND_PK_GCD_1 },
+ { PK_PRIME, JUMP_COND_PK_PRIME },
+ { CLASS1, JUMP_CLASS_CLASS1 },
+ { CLASS2, JUMP_CLASS_CLASS2 },
+ { BOTH, JUMP_CLASS_BOTH }
+};
+
+static const uint32_t jump_test_math_cond[][2] = {
+ { MATH_Z, JUMP_COND_MATH_Z },
+ { MATH_N, JUMP_COND_MATH_N },
+ { MATH_NV, JUMP_COND_MATH_NV },
+ { MATH_C, JUMP_COND_MATH_C }
+};
+
+static const uint32_t jump_src_dst[][2] = {
+ { MATH0, JUMP_SRC_DST_MATH0 },
+ { MATH1, JUMP_SRC_DST_MATH1 },
+ { MATH2, JUMP_SRC_DST_MATH2 },
+ { MATH3, JUMP_SRC_DST_MATH3 },
+ { DPOVRD, JUMP_SRC_DST_DPOVRD },
+ { SEQINSZ, JUMP_SRC_DST_SEQINLEN },
+ { SEQOUTSZ, JUMP_SRC_DST_SEQOUTLEN },
+ { VSEQINSZ, JUMP_SRC_DST_VARSEQINLEN },
+ { VSEQOUTSZ, JUMP_SRC_DST_VARSEQOUTLEN }
+};
+
+static inline int
+rta_jump(struct program *program, uint64_t address,
+ enum rta_jump_type jump_type,
+ enum rta_jump_cond test_type,
+ uint32_t test_condition, uint32_t src_dst)
+{
+ uint32_t opcode = CMD_JUMP;
+ unsigned int start_pc = program->current_pc;
+ int ret = -EINVAL;
+
+ if (((jump_type == GOSUB) || (jump_type == RETURN)) &&
+ (rta_sec_era < RTA_SEC_ERA_4)) {
+ pr_err("JUMP: Jump type not supported by SEC Era %d\n",
+ USER_SEC_ERA(rta_sec_era));
+ goto err;
+ }
+
+ if (((jump_type == LOCAL_JUMP_INC) || (jump_type == LOCAL_JUMP_DEC)) &&
+ (rta_sec_era <= RTA_SEC_ERA_5)) {
+ pr_err("JUMP_INCDEC: Jump type not supported by SEC Era %d\n",
+ USER_SEC_ERA(rta_sec_era));
+ goto err;
+ }
+
+ switch (jump_type) {
+ case (LOCAL_JUMP):
+ /*
+ * opcode |= JUMP_TYPE_LOCAL;
+ * JUMP_TYPE_LOCAL is 0
+ */
+ break;
+ case (HALT):
+ opcode |= JUMP_TYPE_HALT;
+ break;
+ case (HALT_STATUS):
+ opcode |= JUMP_TYPE_HALT_USER;
+ break;
+ case (FAR_JUMP):
+ opcode |= JUMP_TYPE_NONLOCAL;
+ break;
+ case (GOSUB):
+ opcode |= JUMP_TYPE_GOSUB;
+ break;
+ case (RETURN):
+ opcode |= JUMP_TYPE_RETURN;
+ break;
+ case (LOCAL_JUMP_INC):
+ opcode |= JUMP_TYPE_LOCAL_INC;
+ break;
+ case (LOCAL_JUMP_DEC):
+ opcode |= JUMP_TYPE_LOCAL_DEC;
+ break;
+ default:
+ pr_err("JUMP: Invalid jump type. SEC Program Line: %d\n",
+ program->current_pc);
+ goto err;
+ }
+
+ switch (test_type) {
+ case (ALL_TRUE):
+ /*
+ * opcode |= JUMP_TEST_ALL;
+ * JUMP_TEST_ALL is 0
+ */
+ break;
+ case (ALL_FALSE):
+ opcode |= JUMP_TEST_INVALL;
+ break;
+ case (ANY_TRUE):
+ opcode |= JUMP_TEST_ANY;
+ break;
+ case (ANY_FALSE):
+ opcode |= JUMP_TEST_INVANY;
+ break;
+ default:
+ pr_err("JUMP: test type not supported. SEC Program Line: %d\n",
+ program->current_pc);
+ goto err;
+ }
+
+ /* write test condition field */
+ if ((jump_type != LOCAL_JUMP_INC) && (jump_type != LOCAL_JUMP_DEC)) {
+ __rta_map_flags(test_condition, jump_test_cond,
+ ARRAY_SIZE(jump_test_cond), &opcode);
+ } else {
+ uint32_t val = 0;
+
+ ret = __rta_map_opcode(src_dst, jump_src_dst,
+ ARRAY_SIZE(jump_src_dst), &val);
+ if (ret < 0) {
+ pr_err("JUMP_INCDEC: SRC_DST not supported. SEC PC: %d; Instr: %d\n",
+ program->current_pc,
+ program->current_instruction);
+ goto err;
+ }
+ opcode |= val;
+
+ __rta_map_flags(test_condition, jump_test_math_cond,
+ ARRAY_SIZE(jump_test_math_cond), &opcode);
+ }
+
+ /* write local offset field for local jumps and user-defined halt */
+ if ((jump_type == LOCAL_JUMP) || (jump_type == LOCAL_JUMP_INC) ||
+ (jump_type == LOCAL_JUMP_DEC) || (jump_type == GOSUB) ||
+ (jump_type == HALT_STATUS))
+ opcode |= (uint32_t)(address & JUMP_OFFSET_MASK);
+
+ __rta_out32(program, opcode);
+ program->current_instruction++;
+
+ if (jump_type == FAR_JUMP)
+ __rta_out64(program, program->ps, address);
+
+ return (int)start_pc;
+
+ err:
+ program->first_error_pc = start_pc;
+ program->current_instruction++;
+ return ret;
+}
+
+#endif /* __RTA_JUMP_CMD_H__ */
--- /dev/null
+/* SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0)
+ *
+ * Copyright 2008-2016 Freescale Semiconductor Inc.
+ * Copyright 2016,2019 NXP
+ */
+
+#ifndef __RTA_KEY_CMD_H__
+#define __RTA_KEY_CMD_H__
+
+extern enum rta_sec_era rta_sec_era;
+
+/* Allowed encryption flags for each SEC Era */
+static const uint32_t key_enc_flags[] = {
+ ENC,
+ ENC | NWB | EKT | TK,
+ ENC | NWB | EKT | TK,
+ ENC | NWB | EKT | TK,
+ ENC | NWB | EKT | TK,
+ ENC | NWB | EKT | TK,
+ ENC | NWB | EKT | TK | PTS,
+ ENC | NWB | EKT | TK | PTS,
+ ENC | NWB | EKT | TK | PTS,
+ ENC | NWB | EKT | TK | PTS
+};
+
+static inline int
+rta_key(struct program *program, uint32_t key_dst,
+ uint32_t encrypt_flags, uint64_t src, uint32_t length,
+ uint32_t flags)
+{
+ uint32_t opcode = 0;
+ bool is_seq_cmd = false;
+ unsigned int start_pc = program->current_pc;
+
+ if (encrypt_flags & ~key_enc_flags[rta_sec_era]) {
+ pr_err("KEY: Flag(s) not supported by SEC Era %d\n",
+ USER_SEC_ERA(rta_sec_era));
+ goto err;
+ }
+
+ /* write cmd type */
+ if (flags & SEQ) {
+ opcode = CMD_SEQ_KEY;
+ is_seq_cmd = true;
+ } else {
+ opcode = CMD_KEY;
+ }
+
+ /* check parameters */
+ if (is_seq_cmd) {
+ if ((flags & IMMED) || (flags & SGF)) {
+ pr_err("SEQKEY: Invalid flag. SEC PC: %d; Instr: %d\n",
+ program->current_pc,
+ program->current_instruction);
+ goto err;
+ }
+ if ((rta_sec_era <= RTA_SEC_ERA_5) &&
+ ((flags & VLF) || (flags & AIDF))) {
+ pr_err("SEQKEY: Flag(s) not supported by SEC Era %d\n",
+ USER_SEC_ERA(rta_sec_era));
+ goto err;
+ }
+ } else {
+ if ((flags & AIDF) || (flags & VLF)) {
+ pr_err("KEY: Invalid flag. SEC PC: %d; Instr: %d\n",
+ program->current_pc,
+ program->current_instruction);
+ goto err;
+ }
+ if ((flags & SGF) && (flags & IMMED)) {
+ pr_err("KEY: Invalid flag. SEC PC: %d; Instr: %d\n",
+ program->current_pc,
+ program->current_instruction);
+ goto err;
+ }
+ }
+
+ if ((encrypt_flags & PTS) &&
+ ((encrypt_flags & ENC) || (encrypt_flags & NWB) ||
+ (key_dst == PKE))) {
+ pr_err("KEY: Invalid flag / destination. SEC PC: %d; Instr: %d\n",
+ program->current_pc, program->current_instruction);
+ goto err;
+ }
+
+ if (key_dst == AFHA_SBOX) {
+ if (rta_sec_era == RTA_SEC_ERA_7) {
+ pr_err("KEY: AFHA S-box not supported by SEC Era %d\n",
+ USER_SEC_ERA(rta_sec_era));
+ goto err;
+ }
+
+ if (flags & IMMED) {
+ pr_err("KEY: Invalid flag. SEC PC: %d; Instr: %d\n",
+ program->current_pc,
+ program->current_instruction);
+ goto err;
+ }
+
+ /*
+ * Sbox data loaded into the ARC-4 processor must be exactly
+ * 258 bytes long, or else a data sequence error is generated.
+ */
+ if (length != 258) {
+ pr_err("KEY: Invalid length. SEC PC: %d; Instr: %d\n",
+ program->current_pc,
+ program->current_instruction);
+ goto err;
+ }
+ }
+
+ /* write key destination and class fields */
+ switch (key_dst) {
+ case (KEY1):
+ opcode |= KEY_DEST_CLASS1;
+ break;
+ case (KEY2):
+ opcode |= KEY_DEST_CLASS2;
+ break;
+ case (PKE):
+ opcode |= KEY_DEST_CLASS1 | KEY_DEST_PKHA_E;
+ break;
+ case (AFHA_SBOX):
+ opcode |= KEY_DEST_CLASS1 | KEY_DEST_AFHA_SBOX;
+ break;
+ case (MDHA_SPLIT_KEY):
+ opcode |= KEY_DEST_CLASS2 | KEY_DEST_MDHA_SPLIT;
+ break;
+ default:
+ pr_err("KEY: Invalid destination. SEC PC: %d; Instr: %d\n",
+ program->current_pc, program->current_instruction);
+ goto err;
+ }
+
+ /* write key length */
+ length &= KEY_LENGTH_MASK;
+ opcode |= length;
+
+ /* write key command specific flags */
+ if (encrypt_flags & ENC) {
+ /* Encrypted (black) keys must be padded to 8 bytes (CCM) or
+ * 16 bytes (ECB) depending on EKT bit. AES-CCM encrypted keys
+ * (EKT = 1) have 6-byte nonce and 6-byte MAC after padding.
+ */
+ opcode |= KEY_ENC;
+ if (encrypt_flags & EKT) {
+ opcode |= KEY_EKT;
+ length = ALIGN(length, 8);
+ length += 12;
+ } else {
+ length = ALIGN(length, 16);
+ }
+ if (encrypt_flags & TK)
+ opcode |= KEY_TK;
+ }
+ if (encrypt_flags & NWB)
+ opcode |= KEY_NWB;
+ if (encrypt_flags & PTS)
+ opcode |= KEY_PTS;
+
+ /* write general command flags */
+ if (!is_seq_cmd) {
+ if (flags & IMMED)
+ opcode |= KEY_IMM;
+ if (flags & SGF)
+ opcode |= KEY_SGF;
+ } else {
+ if (flags & AIDF)
+ opcode |= KEY_AIDF;
+ if (flags & VLF)
+ opcode |= KEY_VLF;
+ }
+
+ __rta_out32(program, opcode);
+ program->current_instruction++;
+
+ if (flags & IMMED)
+ __rta_inline_data(program, src, flags & __COPY_MASK, length);
+ else
+ __rta_out64(program, program->ps, src);
+
+ return (int)start_pc;
+
+ err:
+ program->first_error_pc = start_pc;
+ program->current_instruction++;
+ return -EINVAL;
+}
+
+#endif /* __RTA_KEY_CMD_H__ */
--- /dev/null
+/* SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0)
+ *
+ * Copyright 2008-2016 Freescale Semiconductor Inc.
+ * Copyright 2016,2019 NXP
+ */
+
+#ifndef __RTA_LOAD_CMD_H__
+#define __RTA_LOAD_CMD_H__
+
+extern enum rta_sec_era rta_sec_era;
+
+/* Allowed length and offset masks for each SEC Era in case DST = DCTRL */
+static const uint32_t load_len_mask_allowed[] = {
+ 0x000000ee,
+ 0x000000fe,
+ 0x000000fe,
+ 0x000000fe,
+ 0x000000fe,
+ 0x000000fe,
+ 0x000000fe,
+ 0x000000fe,
+ 0x000000fe,
+ 0x000000fe
+};
+
+static const uint32_t load_off_mask_allowed[] = {
+ 0x0000000f,
+ 0x000000ff,
+ 0x000000ff,
+ 0x000000ff,
+ 0x000000ff,
+ 0x000000ff,
+ 0x000000ff,
+ 0x000000ff,
+ 0x000000ff,
+ 0x000000ff
+};
+
+#define IMM_MUST 0
+#define IMM_CAN 1
+#define IMM_NO 2
+#define IMM_DSNM 3 /* it doesn't matter the src type */
+
+enum e_lenoff {
+ LENOF_03,
+ LENOF_4,
+ LENOF_48,
+ LENOF_448,
+ LENOF_18,
+ LENOF_32,
+ LENOF_24,
+ LENOF_16,
+ LENOF_8,
+ LENOF_128,
+ LENOF_256,
+ DSNM /* it doesn't matter the length/offset values */
+};
+
+struct load_map {
+ uint32_t dst;
+ uint32_t dst_opcode;
+ enum e_lenoff len_off;
+ uint8_t imm_src;
+
+};
+
+static const struct load_map load_dst[] = {
+/*1*/ { KEY1SZ, LDST_CLASS_1_CCB | LDST_SRCDST_WORD_KEYSZ_REG,
+ LENOF_4, IMM_MUST },
+ { KEY2SZ, LDST_CLASS_2_CCB | LDST_SRCDST_WORD_KEYSZ_REG,
+ LENOF_4, IMM_MUST },
+ { DATA1SZ, LDST_CLASS_1_CCB | LDST_SRCDST_WORD_DATASZ_REG,
+ LENOF_448, IMM_MUST },
+ { DATA2SZ, LDST_CLASS_2_CCB | LDST_SRCDST_WORD_DATASZ_REG,
+ LENOF_448, IMM_MUST },
+ { ICV1SZ, LDST_CLASS_1_CCB | LDST_SRCDST_WORD_ICVSZ_REG,
+ LENOF_4, IMM_MUST },
+ { ICV2SZ, LDST_CLASS_2_CCB | LDST_SRCDST_WORD_ICVSZ_REG,
+ LENOF_4, IMM_MUST },
+ { CCTRL, LDST_CLASS_IND_CCB | LDST_SRCDST_WORD_CHACTRL,
+ LENOF_4, IMM_MUST },
+ { DCTRL, LDST_CLASS_DECO | LDST_IMM | LDST_SRCDST_WORD_DECOCTRL,
+ DSNM, IMM_DSNM },
+ { ICTRL, LDST_CLASS_IND_CCB | LDST_SRCDST_WORD_IRQCTRL,
+ LENOF_4, IMM_MUST },
+ { DPOVRD, LDST_CLASS_DECO | LDST_SRCDST_WORD_DECO_PCLOVRD,
+ LENOF_4, IMM_MUST },
+ { CLRW, LDST_CLASS_IND_CCB | LDST_SRCDST_WORD_CLRW,
+ LENOF_4, IMM_MUST },
+ { AAD1SZ, LDST_CLASS_1_CCB | LDST_SRCDST_WORD_DECO_AAD_SZ,
+ LENOF_4, IMM_MUST },
+ { IV1SZ, LDST_CLASS_1_CCB | LDST_SRCDST_WORD_CLASS1_IV_SZ,
+ LENOF_4, IMM_MUST },
+ { ALTDS1, LDST_CLASS_1_CCB | LDST_SRCDST_WORD_ALTDS_CLASS1,
+ LENOF_448, IMM_MUST },
+ { PKASZ, LDST_CLASS_1_CCB | LDST_SRCDST_WORD_PKHA_A_SZ,
+ LENOF_4, IMM_MUST, },
+ { PKBSZ, LDST_CLASS_1_CCB | LDST_SRCDST_WORD_PKHA_B_SZ,
+ LENOF_4, IMM_MUST },
+ { PKNSZ, LDST_CLASS_1_CCB | LDST_SRCDST_WORD_PKHA_N_SZ,
+ LENOF_4, IMM_MUST },
+ { PKESZ, LDST_CLASS_1_CCB | LDST_SRCDST_WORD_PKHA_E_SZ,
+ LENOF_4, IMM_MUST },
+ { NFIFO, LDST_CLASS_IND_CCB | LDST_SRCDST_WORD_INFO_FIFO,
+ LENOF_48, IMM_MUST },
+ { IFIFO, LDST_SRCDST_BYTE_INFIFO, LENOF_18, IMM_MUST },
+ { OFIFO, LDST_SRCDST_BYTE_OUTFIFO, LENOF_18, IMM_MUST },
+ { MATH0, LDST_CLASS_DECO | LDST_SRCDST_WORD_DECO_MATH0,
+ LENOF_32, IMM_CAN },
+ { MATH1, LDST_CLASS_DECO | LDST_SRCDST_WORD_DECO_MATH1,
+ LENOF_24, IMM_CAN },
+ { MATH2, LDST_CLASS_DECO | LDST_SRCDST_WORD_DECO_MATH2,
+ LENOF_16, IMM_CAN },
+ { MATH3, LDST_CLASS_DECO | LDST_SRCDST_WORD_DECO_MATH3,
+ LENOF_8, IMM_CAN },
+ { CONTEXT1, LDST_CLASS_1_CCB | LDST_SRCDST_BYTE_CONTEXT,
+ LENOF_128, IMM_CAN },
+ { CONTEXT2, LDST_CLASS_2_CCB | LDST_SRCDST_BYTE_CONTEXT,
+ LENOF_128, IMM_CAN },
+ { KEY1, LDST_CLASS_1_CCB | LDST_SRCDST_BYTE_KEY,
+ LENOF_32, IMM_CAN },
+ { KEY2, LDST_CLASS_2_CCB | LDST_SRCDST_BYTE_KEY,
+ LENOF_32, IMM_CAN },
+ { DESCBUF, LDST_CLASS_DECO | LDST_SRCDST_WORD_DESCBUF,
+ LENOF_256, IMM_NO },
+ { DPID, LDST_CLASS_DECO | LDST_SRCDST_WORD_PID,
+ LENOF_448, IMM_MUST },
+/*32*/ { IDFNS, LDST_SRCDST_WORD_IFNSR, LENOF_18, IMM_MUST },
+ { ODFNS, LDST_SRCDST_WORD_OFNSR, LENOF_18, IMM_MUST },
+ { ALTSOURCE, LDST_SRCDST_BYTE_ALTSOURCE, LENOF_18, IMM_MUST },
+/*35*/ { NFIFO_SZL, LDST_SRCDST_WORD_INFO_FIFO_SZL, LENOF_48, IMM_MUST },
+ { NFIFO_SZM, LDST_SRCDST_WORD_INFO_FIFO_SZM, LENOF_03, IMM_MUST },
+ { NFIFO_L, LDST_SRCDST_WORD_INFO_FIFO_L, LENOF_48, IMM_MUST },
+ { NFIFO_M, LDST_SRCDST_WORD_INFO_FIFO_M, LENOF_03, IMM_MUST },
+ { SZL, LDST_SRCDST_WORD_SZL, LENOF_48, IMM_MUST },
+/*40*/ { SZM, LDST_SRCDST_WORD_SZM, LENOF_03, IMM_MUST }
+};
+
+/*
+ * Allowed LOAD destinations for each SEC Era.
+ * Values represent the number of entries from load_dst[] that are supported.
+ */
+static const unsigned int load_dst_sz[] = { 31, 34, 34, 40, 40,
+ 40, 40, 40, 40, 40};
+
+static inline int
+load_check_len_offset(int pos, uint32_t length, uint32_t offset)
+{
+ if ((load_dst[pos].dst == DCTRL) &&
+ ((length & ~load_len_mask_allowed[rta_sec_era]) ||
+ (offset & ~load_off_mask_allowed[rta_sec_era])))
+ goto err;
+
+ switch (load_dst[pos].len_off) {
+ case (LENOF_03):
+ if ((length > 3) || (offset))
+ goto err;
+ break;
+ case (LENOF_4):
+ if ((length != 4) || (offset != 0))
+ goto err;
+ break;
+ case (LENOF_48):
+ if (!(((length == 4) && (offset == 0)) ||
+ ((length == 8) && (offset == 0))))
+ goto err;
+ break;
+ case (LENOF_448):
+ if (!(((length == 4) && (offset == 0)) ||
+ ((length == 4) && (offset == 4)) ||
+ ((length == 8) && (offset == 0))))
+ goto err;
+ break;
+ case (LENOF_18):
+ if ((length < 1) || (length > 8) || (offset != 0))
+ goto err;
+ break;
+ case (LENOF_32):
+ if ((length > 32) || (offset > 32) || ((offset + length) > 32))
+ goto err;
+ break;
+ case (LENOF_24):
+ if ((length > 24) || (offset > 24) || ((offset + length) > 24))
+ goto err;
+ break;
+ case (LENOF_16):
+ if ((length > 16) || (offset > 16) || ((offset + length) > 16))
+ goto err;
+ break;
+ case (LENOF_8):
+ if ((length > 8) || (offset > 8) || ((offset + length) > 8))
+ goto err;
+ break;
+ case (LENOF_128):
+ if ((length > 128) || (offset > 128) ||
+ ((offset + length) > 128))
+ goto err;
+ break;
+ case (LENOF_256):
+ if ((length < 1) || (length > 256) || ((length + offset) > 256))
+ goto err;
+ break;
+ case (DSNM):
+ break;
+ default:
+ goto err;
+ }
+
+ return 0;
+err:
+ return -EINVAL;
+}
+
+static inline int
+rta_load(struct program *program, uint64_t src, uint64_t dst,
+ uint32_t offset, uint32_t length, uint32_t flags)
+{
+ uint32_t opcode = 0;
+ int pos = -1, ret = -EINVAL;
+ unsigned int start_pc = program->current_pc, i;
+
+ if (flags & SEQ)
+ opcode = CMD_SEQ_LOAD;
+ else
+ opcode = CMD_LOAD;
+
+ if ((length & 0xffffff00) || (offset & 0xffffff00)) {
+ pr_err("LOAD: Bad length/offset passed. Should be 8 bits\n");
+ goto err;
+ }
+
+ if (flags & SGF)
+ opcode |= LDST_SGF;
+ if (flags & VLF)
+ opcode |= LDST_VLF;
+
+ /* check load destination, length and offset and source type */
+ for (i = 0; i < load_dst_sz[rta_sec_era]; i++)
+ if (dst == load_dst[i].dst) {
+ pos = (int)i;
+ break;
+ }
+ if (-1 == pos) {
+ pr_err("LOAD: Invalid dst. SEC Program Line: %d\n",
+ program->current_pc);
+ goto err;
+ }
+
+ if (flags & IMMED) {
+ if (load_dst[pos].imm_src == IMM_NO) {
+ pr_err("LOAD: Invalid source type. SEC Program Line: %d\n",
+ program->current_pc);
+ goto err;
+ }
+ opcode |= LDST_IMM;
+ } else if (load_dst[pos].imm_src == IMM_MUST) {
+ pr_err("LOAD IMM: Invalid source type. SEC Program Line: %d\n",
+ program->current_pc);
+ goto err;
+ }
+
+ ret = load_check_len_offset(pos, length, offset);
+ if (ret < 0) {
+ pr_err("LOAD: Invalid length/offset. SEC Program Line: %d\n",
+ program->current_pc);
+ goto err;
+ }
+
+ opcode |= load_dst[pos].dst_opcode;
+
+ /* DESC BUFFER: length / offset values are specified in 4-byte words */
+ if (dst == DESCBUF) {
+ opcode |= (length >> 2);
+ opcode |= ((offset >> 2) << LDST_OFFSET_SHIFT);
+ } else {
+ opcode |= length;
+ opcode |= (offset << LDST_OFFSET_SHIFT);
+ }
+
+ __rta_out32(program, opcode);
+ program->current_instruction++;
+
+ /* DECO CONTROL: skip writing pointer of imm data */
+ if (dst == DCTRL)
+ return (int)start_pc;
+
+ /*
+ * For data copy, 3 possible ways to specify how to copy data:
+ * - IMMED & !COPY: copy data directly from src( max 8 bytes)
+ * - IMMED & COPY: copy data imm from the location specified by user
+ * - !IMMED and is not SEQ cmd: copy the address
+ */
+ if (flags & IMMED)
+ __rta_inline_data(program, src, flags & __COPY_MASK, length);
+ else if (!(flags & SEQ))
+ __rta_out64(program, program->ps, src);
+
+ return (int)start_pc;
+
+ err:
+ program->first_error_pc = start_pc;
+ program->current_instruction++;
+ return ret;
+}
+
+#endif /* __RTA_LOAD_CMD_H__*/
--- /dev/null
+/* SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0)
+ *
+ * Copyright 2008-2016 Freescale Semiconductor Inc.
+ * Copyright 2016,2019 NXP
+ */
+
+#ifndef __RTA_MATH_CMD_H__
+#define __RTA_MATH_CMD_H__
+
+extern enum rta_sec_era rta_sec_era;
+
+static const uint32_t math_op1[][2] = {
+/*1*/ { MATH0, MATH_SRC0_REG0 },
+ { MATH1, MATH_SRC0_REG1 },
+ { MATH2, MATH_SRC0_REG2 },
+ { MATH3, MATH_SRC0_REG3 },
+ { SEQINSZ, MATH_SRC0_SEQINLEN },
+ { SEQOUTSZ, MATH_SRC0_SEQOUTLEN },
+ { VSEQINSZ, MATH_SRC0_VARSEQINLEN },
+ { VSEQOUTSZ, MATH_SRC0_VARSEQOUTLEN },
+ { ZERO, MATH_SRC0_ZERO },
+/*10*/ { NONE, 0 }, /* dummy value */
+ { DPOVRD, MATH_SRC0_DPOVRD },
+ { ONE, MATH_SRC0_ONE }
+};
+
+/*
+ * Allowed MATH op1 sources for each SEC Era.
+ * Values represent the number of entries from math_op1[] that are supported.
+ */
+static const unsigned int math_op1_sz[] = {10, 10, 12, 12, 12, 12,
+ 12, 12, 12, 12};
+
+static const uint32_t math_op2[][2] = {
+/*1*/ { MATH0, MATH_SRC1_REG0 },
+ { MATH1, MATH_SRC1_REG1 },
+ { MATH2, MATH_SRC1_REG2 },
+ { MATH3, MATH_SRC1_REG3 },
+ { ABD, MATH_SRC1_INFIFO },
+ { OFIFO, MATH_SRC1_OUTFIFO },
+ { ONE, MATH_SRC1_ONE },
+/*8*/ { NONE, 0 }, /* dummy value */
+ { JOBSRC, MATH_SRC1_JOBSOURCE },
+ { DPOVRD, MATH_SRC1_DPOVRD },
+ { VSEQINSZ, MATH_SRC1_VARSEQINLEN },
+ { VSEQOUTSZ, MATH_SRC1_VARSEQOUTLEN },
+/*13*/ { ZERO, MATH_SRC1_ZERO }
+};
+
+/*
+ * Allowed MATH op2 sources for each SEC Era.
+ * Values represent the number of entries from math_op2[] that are supported.
+ */
+static const unsigned int math_op2_sz[] = {8, 9, 13, 13, 13, 13, 13, 13,
+ 13, 13};
+
+static const uint32_t math_result[][2] = {
+/*1*/ { MATH0, MATH_DEST_REG0 },
+ { MATH1, MATH_DEST_REG1 },
+ { MATH2, MATH_DEST_REG2 },
+ { MATH3, MATH_DEST_REG3 },
+ { SEQINSZ, MATH_DEST_SEQINLEN },
+ { SEQOUTSZ, MATH_DEST_SEQOUTLEN },
+ { VSEQINSZ, MATH_DEST_VARSEQINLEN },
+ { VSEQOUTSZ, MATH_DEST_VARSEQOUTLEN },
+/*9*/ { NONE, MATH_DEST_NONE },
+ { DPOVRD, MATH_DEST_DPOVRD }
+};
+
+/*
+ * Allowed MATH result destinations for each SEC Era.
+ * Values represent the number of entries from math_result[] that are
+ * supported.
+ */
+static const unsigned int math_result_sz[] = {9, 9, 10, 10, 10, 10, 10, 10,
+ 10, 10};
+
+static inline int
+rta_math(struct program *program, uint64_t operand1,
+ uint32_t op, uint64_t operand2, uint32_t result,
+ int length, uint32_t options)
+{
+ uint32_t opcode = CMD_MATH;
+ uint32_t val = 0;
+ int ret = -EINVAL;
+ unsigned int start_pc = program->current_pc;
+
+ if (((op == MATH_FUN_BSWAP) && (rta_sec_era < RTA_SEC_ERA_4)) ||
+ ((op == MATH_FUN_ZBYT) && (rta_sec_era < RTA_SEC_ERA_2))) {
+ pr_err("MATH: operation not supported by SEC Era %d. SEC PC: %d; Instr: %d\n",
+ USER_SEC_ERA(rta_sec_era), program->current_pc,
+ program->current_instruction);
+ goto err;
+ }
+
+ if (options & SWP) {
+ if (rta_sec_era < RTA_SEC_ERA_7) {
+ pr_err("MATH: operation not supported by SEC Era %d. SEC PC: %d; Instr: %d\n",
+ USER_SEC_ERA(rta_sec_era), program->current_pc,
+ program->current_instruction);
+ goto err;
+ }
+
+ if ((options & IFB) ||
+ (!(options & IMMED) && !(options & IMMED2)) ||
+ ((options & IMMED) && (options & IMMED2))) {
+ pr_err("MATH: SWP - invalid configuration. SEC PC: %d; Instr: %d\n",
+ program->current_pc,
+ program->current_instruction);
+ goto err;
+ }
+ }
+
+ /*
+ * SHLD operation is different from others and we
+ * assume that we can have _NONE as first operand
+ * or _SEQINSZ as second operand
+ */
+ if ((op != MATH_FUN_SHLD) && ((operand1 == NONE) ||
+ (operand2 == SEQINSZ))) {
+ pr_err("MATH: Invalid operand. SEC PC: %d; Instr: %d\n",
+ program->current_pc, program->current_instruction);
+ goto err;
+ }
+
+ /*
+ * We first check if it is unary operation. In that
+ * case second operand must be _NONE
+ */
+ if (((op == MATH_FUN_ZBYT) || (op == MATH_FUN_BSWAP)) &&
+ (operand2 != NONE)) {
+ pr_err("MATH: Invalid operand2. SEC PC: %d; Instr: %d\n",
+ program->current_pc, program->current_instruction);
+ goto err;
+ }
+
+ /* Write first operand field */
+ if (options & IMMED) {
+ opcode |= MATH_SRC0_IMM;
+ } else {
+ ret = __rta_map_opcode((uint32_t)operand1, math_op1,
+ math_op1_sz[rta_sec_era], &val);
+ if (ret < 0) {
+ pr_err("MATH: operand1 not supported. SEC PC: %d; Instr: %d\n",
+ program->current_pc,
+ program->current_instruction);
+ goto err;
+ }
+ opcode |= val;
+ }
+
+ /* Write second operand field */
+ if (options & IMMED2) {
+ opcode |= MATH_SRC1_IMM;
+ } else {
+ ret = __rta_map_opcode((uint32_t)operand2, math_op2,
+ math_op2_sz[rta_sec_era], &val);
+ if (ret < 0) {
+ pr_err("MATH: operand2 not supported. SEC PC: %d; Instr: %d\n",
+ program->current_pc,
+ program->current_instruction);
+ goto err;
+ }
+ opcode |= val;
+ }
+
+ /* Write result field */
+ ret = __rta_map_opcode(result, math_result, math_result_sz[rta_sec_era],
+ &val);
+ if (ret < 0) {
+ pr_err("MATH: result not supported. SEC PC: %d; Instr: %d\n",
+ program->current_pc, program->current_instruction);
+ goto err;
+ }
+ opcode |= val;
+
+ /*
+ * as we encode operations with their "real" values, we do not
+ * to translate but we do need to validate the value
+ */
+ switch (op) {
+ /*Binary operators */
+ case (MATH_FUN_ADD):
+ case (MATH_FUN_ADDC):
+ case (MATH_FUN_SUB):
+ case (MATH_FUN_SUBB):
+ case (MATH_FUN_OR):
+ case (MATH_FUN_AND):
+ case (MATH_FUN_XOR):
+ case (MATH_FUN_LSHIFT):
+ case (MATH_FUN_RSHIFT):
+ case (MATH_FUN_SHLD):
+ /* Unary operators */
+ case (MATH_FUN_ZBYT):
+ case (MATH_FUN_BSWAP):
+ opcode |= op;
+ break;
+ default:
+ pr_err("MATH: operator is not supported. SEC PC: %d; Instr: %d\n",
+ program->current_pc, program->current_instruction);
+ ret = -EINVAL;
+ goto err;
+ }
+
+ opcode |= (options & ~(IMMED | IMMED2));
+
+ /* Verify length */
+ switch (length) {
+ case (1):
+ opcode |= MATH_LEN_1BYTE;
+ break;
+ case (2):
+ opcode |= MATH_LEN_2BYTE;
+ break;
+ case (4):
+ opcode |= MATH_LEN_4BYTE;
+ break;
+ case (8):
+ opcode |= MATH_LEN_8BYTE;
+ break;
+ default:
+ pr_err("MATH: length is not supported. SEC PC: %d; Instr: %d\n",
+ program->current_pc, program->current_instruction);
+ ret = -EINVAL;
+ goto err;
+ }
+
+ __rta_out32(program, opcode);
+ program->current_instruction++;
+
+ /* Write immediate value */
+ if ((options & IMMED) && !(options & IMMED2)) {
+ __rta_out64(program, (length > 4) && !(options & IFB),
+ operand1);
+ } else if ((options & IMMED2) && !(options & IMMED)) {
+ __rta_out64(program, (length > 4) && !(options & IFB),
+ operand2);
+ } else if ((options & IMMED) && (options & IMMED2)) {
+ __rta_out32(program, lower_32_bits(operand1));
+ __rta_out32(program, lower_32_bits(operand2));
+ }
+
+ return (int)start_pc;
+
+ err:
+ program->first_error_pc = start_pc;
+ program->current_instruction++;
+ return ret;
+}
+
+static inline int
+rta_mathi(struct program *program, uint64_t operand,
+ uint32_t op, uint8_t imm, uint32_t result,
+ int length, uint32_t options)
+{
+ uint32_t opcode = CMD_MATHI;
+ uint32_t val = 0;
+ int ret = -EINVAL;
+ unsigned int start_pc = program->current_pc;
+
+ if (rta_sec_era < RTA_SEC_ERA_6) {
+ pr_err("MATHI: Command not supported by SEC Era %d. SEC PC: %d; Instr: %d\n",
+ USER_SEC_ERA(rta_sec_era), program->current_pc,
+ program->current_instruction);
+ goto err;
+ }
+
+ if (((op == MATH_FUN_FBYT) && (options & SSEL))) {
+ pr_err("MATHI: Illegal combination - FBYT and SSEL. SEC PC: %d; Instr: %d\n",
+ program->current_pc, program->current_instruction);
+ goto err;
+ }
+
+ if ((options & SWP) && (rta_sec_era < RTA_SEC_ERA_7)) {
+ pr_err("MATHI: SWP not supported by SEC Era %d. SEC PC: %d; Instr: %d\n",
+ USER_SEC_ERA(rta_sec_era), program->current_pc,
+ program->current_instruction);
+ goto err;
+ }
+
+ /* Write first operand field */
+ if (!(options & SSEL))
+ ret = __rta_map_opcode((uint32_t)operand, math_op1,
+ math_op1_sz[rta_sec_era], &val);
+ else
+ ret = __rta_map_opcode((uint32_t)operand, math_op2,
+ math_op2_sz[rta_sec_era], &val);
+ if (ret < 0) {
+ pr_err("MATHI: operand not supported. SEC PC: %d; Instr: %d\n",
+ program->current_pc, program->current_instruction);
+ goto err;
+ }
+
+ if (!(options & SSEL))
+ opcode |= val;
+ else
+ opcode |= (val << (MATHI_SRC1_SHIFT - MATH_SRC1_SHIFT));
+
+ /* Write second operand field */
+ opcode |= (imm << MATHI_IMM_SHIFT);
+
+ /* Write result field */
+ ret = __rta_map_opcode(result, math_result, math_result_sz[rta_sec_era],
+ &val);
+ if (ret < 0) {
+ pr_err("MATHI: result not supported. SEC PC: %d; Instr: %d\n",
+ program->current_pc, program->current_instruction);
+ goto err;
+ }
+ opcode |= (val << (MATHI_DEST_SHIFT - MATH_DEST_SHIFT));
+
+ /*
+ * as we encode operations with their "real" values, we do not have to
+ * translate but we do need to validate the value
+ */
+ switch (op) {
+ case (MATH_FUN_ADD):
+ case (MATH_FUN_ADDC):
+ case (MATH_FUN_SUB):
+ case (MATH_FUN_SUBB):
+ case (MATH_FUN_OR):
+ case (MATH_FUN_AND):
+ case (MATH_FUN_XOR):
+ case (MATH_FUN_LSHIFT):
+ case (MATH_FUN_RSHIFT):
+ case (MATH_FUN_FBYT):
+ opcode |= op;
+ break;
+ default:
+ pr_err("MATHI: operator not supported. SEC PC: %d; Instr: %d\n",
+ program->current_pc, program->current_instruction);
+ ret = -EINVAL;
+ goto err;
+ }
+
+ opcode |= options;
+
+ /* Verify length */
+ switch (length) {
+ case (1):
+ opcode |= MATH_LEN_1BYTE;
+ break;
+ case (2):
+ opcode |= MATH_LEN_2BYTE;
+ break;
+ case (4):
+ opcode |= MATH_LEN_4BYTE;
+ break;
+ case (8):
+ opcode |= MATH_LEN_8BYTE;
+ break;
+ default:
+ pr_err("MATHI: length %d not supported. SEC PC: %d; Instr: %d\n",
+ length, program->current_pc,
+ program->current_instruction);
+ ret = -EINVAL;
+ goto err;
+ }
+
+ __rta_out32(program, opcode);
+ program->current_instruction++;
+
+ return (int)start_pc;
+
+ err:
+ program->first_error_pc = start_pc;
+ program->current_instruction++;
+ return ret;
+}
+
+#endif /* __RTA_MATH_CMD_H__ */
--- /dev/null
+/* SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0)
+ *
+ * Copyright 2008-2016 Freescale Semiconductor Inc.
+ * Copyright 2016,2019 NXP
+ */
+
+#ifndef __RTA_MOVE_CMD_H__
+#define __RTA_MOVE_CMD_H__
+
+#define MOVE_SET_AUX_SRC 0x01
+#define MOVE_SET_AUX_DST 0x02
+#define MOVE_SET_AUX_LS 0x03
+#define MOVE_SET_LEN_16b 0x04
+
+#define MOVE_SET_AUX_MATH 0x10
+#define MOVE_SET_AUX_MATH_SRC (MOVE_SET_AUX_SRC | MOVE_SET_AUX_MATH)
+#define MOVE_SET_AUX_MATH_DST (MOVE_SET_AUX_DST | MOVE_SET_AUX_MATH)
+
+#define MASK_16b 0xFF
+
+/* MOVE command type */
+#define __MOVE 1
+#define __MOVEB 2
+#define __MOVEDW 3
+
+extern enum rta_sec_era rta_sec_era;
+
+static const uint32_t move_src_table[][2] = {
+/*1*/ { CONTEXT1, MOVE_SRC_CLASS1CTX },
+ { CONTEXT2, MOVE_SRC_CLASS2CTX },
+ { OFIFO, MOVE_SRC_OUTFIFO },
+ { DESCBUF, MOVE_SRC_DESCBUF },
+ { MATH0, MOVE_SRC_MATH0 },
+ { MATH1, MOVE_SRC_MATH1 },
+ { MATH2, MOVE_SRC_MATH2 },
+ { MATH3, MOVE_SRC_MATH3 },
+/*9*/ { IFIFOABD, MOVE_SRC_INFIFO },
+ { IFIFOAB1, MOVE_SRC_INFIFO_CL | MOVE_AUX_LS },
+ { IFIFOAB2, MOVE_SRC_INFIFO_CL },
+/*12*/ { ABD, MOVE_SRC_INFIFO_NO_NFIFO },
+ { AB1, MOVE_SRC_INFIFO_NO_NFIFO | MOVE_AUX_LS },
+ { AB2, MOVE_SRC_INFIFO_NO_NFIFO | MOVE_AUX_MS }
+};
+
+/* Allowed MOVE / MOVE_LEN sources for each SEC Era.
+ * Values represent the number of entries from move_src_table[] that are
+ * supported.
+ */
+static const unsigned int move_src_table_sz[] = {9, 11, 14, 14, 14, 14, 14, 14,
+ 14, 14};
+
+static const uint32_t move_dst_table[][2] = {
+/*1*/ { CONTEXT1, MOVE_DEST_CLASS1CTX },
+ { CONTEXT2, MOVE_DEST_CLASS2CTX },
+ { OFIFO, MOVE_DEST_OUTFIFO },
+ { DESCBUF, MOVE_DEST_DESCBUF },
+ { MATH0, MOVE_DEST_MATH0 },
+ { MATH1, MOVE_DEST_MATH1 },
+ { MATH2, MOVE_DEST_MATH2 },
+ { MATH3, MOVE_DEST_MATH3 },
+ { IFIFOAB1, MOVE_DEST_CLASS1INFIFO },
+ { IFIFOAB2, MOVE_DEST_CLASS2INFIFO },
+ { PKA, MOVE_DEST_PK_A },
+ { KEY1, MOVE_DEST_CLASS1KEY },
+ { KEY2, MOVE_DEST_CLASS2KEY },
+/*14*/ { IFIFO, MOVE_DEST_INFIFO },
+/*15*/ { ALTSOURCE, MOVE_DEST_ALTSOURCE}
+};
+
+/* Allowed MOVE / MOVE_LEN destinations for each SEC Era.
+ * Values represent the number of entries from move_dst_table[] that are
+ * supported.
+ */
+static const
+unsigned int move_dst_table_sz[] = {13, 14, 14, 15, 15, 15, 15, 15, 15, 15};
+
+static inline int
+set_move_offset(struct program *program __maybe_unused,
+ uint64_t src, uint16_t src_offset,
+ uint64_t dst, uint16_t dst_offset,
+ uint16_t *offset, uint16_t *opt);
+
+static inline int
+math_offset(uint16_t offset);
+
+static inline int
+rta_move(struct program *program, int cmd_type, uint64_t src,
+ uint16_t src_offset, uint64_t dst,
+ uint16_t dst_offset, uint32_t length, uint32_t flags)
+{
+ uint32_t opcode = 0;
+ uint16_t offset = 0, opt = 0;
+ uint32_t val = 0;
+ int ret = -EINVAL;
+ bool is_move_len_cmd = false;
+ unsigned int start_pc = program->current_pc;
+
+ if ((rta_sec_era < RTA_SEC_ERA_7) && (cmd_type != __MOVE)) {
+ pr_err("MOVE: MOVEB / MOVEDW not supported by SEC Era %d. SEC PC: %d; Instr: %d\n",
+ USER_SEC_ERA(rta_sec_era), program->current_pc,
+ program->current_instruction);
+ goto err;
+ }
+
+ /* write command type */
+ if (cmd_type == __MOVEB) {
+ opcode = CMD_MOVEB;
+ } else if (cmd_type == __MOVEDW) {
+ opcode = CMD_MOVEDW;
+ } else if (!(flags & IMMED)) {
+ if (rta_sec_era < RTA_SEC_ERA_3) {
+ pr_err("MOVE: MOVE_LEN not supported by SEC Era %d. SEC PC: %d; Instr: %d\n",
+ USER_SEC_ERA(rta_sec_era), program->current_pc,
+ program->current_instruction);
+ goto err;
+ }
+
+ if ((length != MATH0) && (length != MATH1) &&
+ (length != MATH2) && (length != MATH3)) {
+ pr_err("MOVE: MOVE_LEN length must be MATH[0-3]. SEC PC: %d; Instr: %d\n",
+ program->current_pc,
+ program->current_instruction);
+ goto err;
+ }
+
+ opcode = CMD_MOVE_LEN;
+ is_move_len_cmd = true;
+ } else {
+ opcode = CMD_MOVE;
+ }
+
+ /* write offset first, to check for invalid combinations or incorrect
+ * offset values sooner; decide which offset should be here
+ * (src or dst)
+ */
+ ret = set_move_offset(program, src, src_offset, dst, dst_offset,
+ &offset, &opt);
+ if (ret < 0)
+ goto err;
+
+ opcode |= (offset << MOVE_OFFSET_SHIFT) & MOVE_OFFSET_MASK;
+
+ /* set AUX field if required */
+ if (opt == MOVE_SET_AUX_SRC) {
+ opcode |= ((src_offset / 16) << MOVE_AUX_SHIFT) & MOVE_AUX_MASK;
+ } else if (opt == MOVE_SET_AUX_DST) {
+ opcode |= ((dst_offset / 16) << MOVE_AUX_SHIFT) & MOVE_AUX_MASK;
+ } else if (opt == MOVE_SET_AUX_LS) {
+ opcode |= MOVE_AUX_LS;
+ } else if (opt & MOVE_SET_AUX_MATH) {
+ if (opt & MOVE_SET_AUX_SRC)
+ offset = src_offset;
+ else
+ offset = dst_offset;
+
+ if (rta_sec_era < RTA_SEC_ERA_6) {
+ if (offset)
+ pr_debug("MOVE: Offset not supported by SEC Era %d. SEC PC: %d; Instr: %d\n",
+ USER_SEC_ERA(rta_sec_era),
+ program->current_pc,
+ program->current_instruction);
+ /* nothing to do for offset = 0 */
+ } else {
+ ret = math_offset(offset);
+ if (ret < 0) {
+ pr_err("MOVE: Invalid offset in MATH register. SEC PC: %d; Instr: %d\n",
+ program->current_pc,
+ program->current_instruction);
+ goto err;
+ }
+
+ opcode |= (uint32_t)ret;
+ }
+ }
+
+ /* write source field */
+ ret = __rta_map_opcode((uint32_t)src, move_src_table,
+ move_src_table_sz[rta_sec_era], &val);
+ if (ret < 0) {
+ pr_err("MOVE: Invalid SRC. SEC PC: %d; Instr: %d\n",
+ program->current_pc, program->current_instruction);
+ goto err;
+ }
+ opcode |= val;
+
+ /* write destination field */
+ ret = __rta_map_opcode((uint32_t)dst, move_dst_table,
+ move_dst_table_sz[rta_sec_era], &val);
+ if (ret < 0) {
+ pr_err("MOVE: Invalid DST. SEC PC: %d; Instr: %d\n",
+ program->current_pc, program->current_instruction);
+ goto err;
+ }
+ opcode |= val;
+
+ /* write flags */
+ if (flags & (FLUSH1 | FLUSH2))
+ opcode |= MOVE_AUX_MS;
+ if (flags & (LAST2 | LAST1))
+ opcode |= MOVE_AUX_LS;
+ if (flags & WAITCOMP)
+ opcode |= MOVE_WAITCOMP;
+
+ if (!is_move_len_cmd) {
+ /* write length */
+ if (opt == MOVE_SET_LEN_16b)
+ opcode |= (length & (MOVE_OFFSET_MASK | MOVE_LEN_MASK));
+ else
+ opcode |= (length & MOVE_LEN_MASK);
+ } else {
+ /* write mrsel */
+ switch (length) {
+ case (MATH0):
+ /*
+ * opcode |= MOVELEN_MRSEL_MATH0;
+ * MOVELEN_MRSEL_MATH0 is 0
+ */
+ break;
+ case (MATH1):
+ opcode |= MOVELEN_MRSEL_MATH1;
+ break;
+ case (MATH2):
+ opcode |= MOVELEN_MRSEL_MATH2;
+ break;
+ case (MATH3):
+ opcode |= MOVELEN_MRSEL_MATH3;
+ break;
+ }
+
+ /* write size */
+ if (rta_sec_era >= RTA_SEC_ERA_7) {
+ if (flags & SIZE_WORD)
+ opcode |= MOVELEN_SIZE_WORD;
+ else if (flags & SIZE_BYTE)
+ opcode |= MOVELEN_SIZE_BYTE;
+ else if (flags & SIZE_DWORD)
+ opcode |= MOVELEN_SIZE_DWORD;
+ }
+ }
+
+ __rta_out32(program, opcode);
+ program->current_instruction++;
+
+ return (int)start_pc;
+
+ err:
+ program->first_error_pc = start_pc;
+ program->current_instruction++;
+ return ret;
+}
+
+static inline int
+set_move_offset(struct program *program __maybe_unused,
+ uint64_t src, uint16_t src_offset,
+ uint64_t dst, uint16_t dst_offset,
+ uint16_t *offset, uint16_t *opt)
+{
+ switch (src) {
+ case (CONTEXT1):
+ case (CONTEXT2):
+ if (dst == DESCBUF) {
+ *opt = MOVE_SET_AUX_SRC;
+ *offset = dst_offset;
+ } else if ((dst == KEY1) || (dst == KEY2)) {
+ if ((src_offset) && (dst_offset)) {
+ pr_err("MOVE: Bad offset. SEC PC: %d; Instr: %d\n",
+ program->current_pc,
+ program->current_instruction);
+ goto err;
+ }
+ if (dst_offset) {
+ *opt = MOVE_SET_AUX_LS;
+ *offset = dst_offset;
+ } else {
+ *offset = src_offset;
+ }
+ } else {
+ if ((dst == MATH0) || (dst == MATH1) ||
+ (dst == MATH2) || (dst == MATH3)) {
+ *opt = MOVE_SET_AUX_MATH_DST;
+ } else if (((dst == OFIFO) || (dst == ALTSOURCE)) &&
+ (src_offset % 4)) {
+ pr_err("MOVE: Bad offset alignment. SEC PC: %d; Instr: %d\n",
+ program->current_pc,
+ program->current_instruction);
+ goto err;
+ }
+
+ *offset = src_offset;
+ }
+ break;
+
+ case (OFIFO):
+ if (dst == OFIFO) {
+ pr_err("MOVE: Invalid DST. SEC PC: %d; Instr: %d\n",
+ program->current_pc,
+ program->current_instruction);
+ goto err;
+ }
+ if (((dst == IFIFOAB1) || (dst == IFIFOAB2) ||
+ (dst == IFIFO) || (dst == PKA)) &&
+ (src_offset || dst_offset)) {
+ pr_err("MOVE: Offset should be zero. SEC PC: %d; Instr: %d\n",
+ program->current_pc,
+ program->current_instruction);
+ goto err;
+ }
+ *offset = dst_offset;
+ break;
+
+ case (DESCBUF):
+ if ((dst == CONTEXT1) || (dst == CONTEXT2)) {
+ *opt = MOVE_SET_AUX_DST;
+ } else if ((dst == MATH0) || (dst == MATH1) ||
+ (dst == MATH2) || (dst == MATH3)) {
+ *opt = MOVE_SET_AUX_MATH_DST;
+ } else if (dst == DESCBUF) {
+ pr_err("MOVE: Invalid DST. SEC PC: %d; Instr: %d\n",
+ program->current_pc,
+ program->current_instruction);
+ goto err;
+ } else if (((dst == OFIFO) || (dst == ALTSOURCE)) &&
+ (src_offset % 4)) {
+ pr_err("MOVE: Invalid offset alignment. SEC PC: %d; Instr %d\n",
+ program->current_pc,
+ program->current_instruction);
+ goto err;
+ }
+
+ *offset = src_offset;
+ break;
+
+ case (MATH0):
+ case (MATH1):
+ case (MATH2):
+ case (MATH3):
+ if ((dst == OFIFO) || (dst == ALTSOURCE)) {
+ if (src_offset % 4) {
+ pr_err("MOVE: Bad offset alignment. SEC PC: %d; Instr: %d\n",
+ program->current_pc,
+ program->current_instruction);
+ goto err;
+ }
+ *offset = src_offset;
+ } else if ((dst == IFIFOAB1) || (dst == IFIFOAB2) ||
+ (dst == IFIFO) || (dst == PKA)) {
+ *offset = src_offset;
+ } else {
+ *offset = dst_offset;
+
+ /*
+ * This condition is basically the negation of:
+ * dst in { CONTEXT[1-2], MATH[0-3] }
+ */
+ if ((dst != KEY1) && (dst != KEY2))
+ *opt = MOVE_SET_AUX_MATH_SRC;
+ }
+ break;
+
+ case (IFIFOABD):
+ case (IFIFOAB1):
+ case (IFIFOAB2):
+ case (ABD):
+ case (AB1):
+ case (AB2):
+ if ((dst == IFIFOAB1) || (dst == IFIFOAB2) ||
+ (dst == IFIFO) || (dst == PKA) || (dst == ALTSOURCE)) {
+ pr_err("MOVE: Bad DST. SEC PC: %d; Instr: %d\n",
+ program->current_pc,
+ program->current_instruction);
+ goto err;
+ } else {
+ if (dst == OFIFO) {
+ *opt = MOVE_SET_LEN_16b;
+ } else {
+ if (dst_offset % 4) {
+ pr_err("MOVE: Bad offset alignment. SEC PC: %d; Instr: %d\n",
+ program->current_pc,
+ program->current_instruction);
+ goto err;
+ }
+ *offset = dst_offset;
+ }
+ }
+ break;
+ default:
+ break;
+ }
+
+ return 0;
+ err:
+ return -EINVAL;
+}
+
+static inline int
+math_offset(uint16_t offset)
+{
+ switch (offset) {
+ case 0:
+ return 0;
+ case 4:
+ return MOVE_AUX_LS;
+ case 6:
+ return MOVE_AUX_MS;
+ case 7:
+ return MOVE_AUX_LS | MOVE_AUX_MS;
+ }
+
+ return -EINVAL;
+}
+
+#endif /* __RTA_MOVE_CMD_H__ */
--- /dev/null
+/* SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0)
+ *
+ * Copyright 2008-2016 Freescale Semiconductor Inc.
+ * Copyright 2016,2019 NXP
+ */
+
+#ifndef __RTA_NFIFO_CMD_H__
+#define __RTA_NFIFO_CMD_H__
+
+extern enum rta_sec_era rta_sec_era;
+
+static const uint32_t nfifo_src[][2] = {
+/*1*/ { IFIFO, NFIFOENTRY_STYPE_DFIFO },
+ { OFIFO, NFIFOENTRY_STYPE_OFIFO },
+ { PAD, NFIFOENTRY_STYPE_PAD },
+/*4*/ { MSGOUTSNOOP, NFIFOENTRY_STYPE_SNOOP | NFIFOENTRY_DEST_BOTH },
+/*5*/ { ALTSOURCE, NFIFOENTRY_STYPE_ALTSOURCE },
+ { OFIFO_SYNC, NFIFOENTRY_STYPE_OFIFO_SYNC },
+/*7*/ { MSGOUTSNOOP_ALT, NFIFOENTRY_STYPE_SNOOP_ALT | NFIFOENTRY_DEST_BOTH }
+};
+
+/*
+ * Allowed NFIFO LOAD sources for each SEC Era.
+ * Values represent the number of entries from nfifo_src[] that are supported.
+ */
+static const unsigned int nfifo_src_sz[] = {4, 5, 5, 5, 5, 5, 5, 7, 7, 7};
+
+static const uint32_t nfifo_data[][2] = {
+ { MSG, NFIFOENTRY_DTYPE_MSG },
+ { MSG1, NFIFOENTRY_DEST_CLASS1 | NFIFOENTRY_DTYPE_MSG },
+ { MSG2, NFIFOENTRY_DEST_CLASS2 | NFIFOENTRY_DTYPE_MSG },
+ { IV1, NFIFOENTRY_DEST_CLASS1 | NFIFOENTRY_DTYPE_IV },
+ { IV2, NFIFOENTRY_DEST_CLASS2 | NFIFOENTRY_DTYPE_IV },
+ { ICV1, NFIFOENTRY_DEST_CLASS1 | NFIFOENTRY_DTYPE_ICV },
+ { ICV2, NFIFOENTRY_DEST_CLASS2 | NFIFOENTRY_DTYPE_ICV },
+ { SAD1, NFIFOENTRY_DEST_CLASS1 | NFIFOENTRY_DTYPE_SAD },
+ { AAD1, NFIFOENTRY_DEST_CLASS1 | NFIFOENTRY_DTYPE_AAD },
+ { AAD2, NFIFOENTRY_DEST_CLASS2 | NFIFOENTRY_DTYPE_AAD },
+ { AFHA_SBOX, NFIFOENTRY_DEST_CLASS1 | NFIFOENTRY_DTYPE_SBOX },
+ { SKIP, NFIFOENTRY_DTYPE_SKIP },
+ { PKE, NFIFOENTRY_DEST_CLASS1 | NFIFOENTRY_DTYPE_PK_E },
+ { PKN, NFIFOENTRY_DEST_CLASS1 | NFIFOENTRY_DTYPE_PK_N },
+ { PKA, NFIFOENTRY_DEST_CLASS1 | NFIFOENTRY_DTYPE_PK_A },
+ { PKA0, NFIFOENTRY_DEST_CLASS1 | NFIFOENTRY_DTYPE_PK_A0 },
+ { PKA1, NFIFOENTRY_DEST_CLASS1 | NFIFOENTRY_DTYPE_PK_A1 },
+ { PKA2, NFIFOENTRY_DEST_CLASS1 | NFIFOENTRY_DTYPE_PK_A2 },
+ { PKA3, NFIFOENTRY_DEST_CLASS1 | NFIFOENTRY_DTYPE_PK_A3 },
+ { PKB, NFIFOENTRY_DEST_CLASS1 | NFIFOENTRY_DTYPE_PK_B },
+ { PKB0, NFIFOENTRY_DEST_CLASS1 | NFIFOENTRY_DTYPE_PK_B0 },
+ { PKB1, NFIFOENTRY_DEST_CLASS1 | NFIFOENTRY_DTYPE_PK_B1 },
+ { PKB2, NFIFOENTRY_DEST_CLASS1 | NFIFOENTRY_DTYPE_PK_B2 },
+ { PKB3, NFIFOENTRY_DEST_CLASS1 | NFIFOENTRY_DTYPE_PK_B3 },
+ { AB1, NFIFOENTRY_DEST_CLASS1 },
+ { AB2, NFIFOENTRY_DEST_CLASS2 },
+ { ABD, NFIFOENTRY_DEST_DECO }
+};
+
+static const uint32_t nfifo_flags[][2] = {
+/*1*/ { LAST1, NFIFOENTRY_LC1 },
+ { LAST2, NFIFOENTRY_LC2 },
+ { FLUSH1, NFIFOENTRY_FC1 },
+ { BP, NFIFOENTRY_BND },
+ { PAD_ZERO, NFIFOENTRY_PTYPE_ZEROS },
+ { PAD_NONZERO, NFIFOENTRY_PTYPE_RND_NOZEROS },
+ { PAD_INCREMENT, NFIFOENTRY_PTYPE_INCREMENT },
+ { PAD_RANDOM, NFIFOENTRY_PTYPE_RND },
+ { PAD_ZERO_N1, NFIFOENTRY_PTYPE_ZEROS_NZ },
+ { PAD_NONZERO_0, NFIFOENTRY_PTYPE_RND_NZ_LZ },
+ { PAD_N1, NFIFOENTRY_PTYPE_N },
+/*12*/ { PAD_NONZERO_N, NFIFOENTRY_PTYPE_RND_NZ_N },
+ { FLUSH2, NFIFOENTRY_FC2 },
+ { OC, NFIFOENTRY_OC }
+};
+
+/*
+ * Allowed NFIFO LOAD flags for each SEC Era.
+ * Values represent the number of entries from nfifo_flags[] that are supported.
+ */
+static const unsigned int nfifo_flags_sz[] = {12, 14, 14, 14, 14, 14,
+ 14, 14, 14, 14};
+
+static const uint32_t nfifo_pad_flags[][2] = {
+ { BM, NFIFOENTRY_BM },
+ { PS, NFIFOENTRY_PS },
+ { PR, NFIFOENTRY_PR }
+};
+
+/*
+ * Allowed NFIFO LOAD pad flags for each SEC Era.
+ * Values represent the number of entries from nfifo_pad_flags[] that are
+ * supported.
+ */
+static const unsigned int nfifo_pad_flags_sz[] = {2, 2, 2, 2, 3, 3, 3, 3, 3, 3};
+
+static inline int
+rta_nfifo_load(struct program *program, uint32_t src,
+ uint32_t data, uint32_t length, uint32_t flags)
+{
+ uint32_t opcode = 0, val;
+ int ret = -EINVAL;
+ uint32_t load_cmd = CMD_LOAD | LDST_IMM | LDST_CLASS_IND_CCB |
+ LDST_SRCDST_WORD_INFO_FIFO;
+ unsigned int start_pc = program->current_pc;
+
+ if ((data == AFHA_SBOX) && (rta_sec_era == RTA_SEC_ERA_7)) {
+ pr_err("NFIFO: AFHA S-box not supported by SEC Era %d\n",
+ USER_SEC_ERA(rta_sec_era));
+ goto err;
+ }
+
+ /* write source field */
+ ret = __rta_map_opcode(src, nfifo_src, nfifo_src_sz[rta_sec_era], &val);
+ if (ret < 0) {
+ pr_err("NFIFO: Invalid SRC. SEC PC: %d; Instr: %d\n",
+ program->current_pc, program->current_instruction);
+ goto err;
+ }
+ opcode |= val;
+
+ /* write type field */
+ ret = __rta_map_opcode(data, nfifo_data, ARRAY_SIZE(nfifo_data), &val);
+ if (ret < 0) {
+ pr_err("NFIFO: Invalid data. SEC PC: %d; Instr: %d\n",
+ program->current_pc, program->current_instruction);
+ goto err;
+ }
+ opcode |= val;
+
+ /* write DL field */
+ if (!(flags & EXT)) {
+ opcode |= length & NFIFOENTRY_DLEN_MASK;
+ load_cmd |= 4;
+ } else {
+ load_cmd |= 8;
+ }
+
+ /* write flags */
+ __rta_map_flags(flags, nfifo_flags, nfifo_flags_sz[rta_sec_era],
+ &opcode);
+
+ /* in case of padding, check the destination */
+ if (src == PAD)
+ __rta_map_flags(flags, nfifo_pad_flags,
+ nfifo_pad_flags_sz[rta_sec_era], &opcode);
+
+ /* write LOAD command first */
+ __rta_out32(program, load_cmd);
+ __rta_out32(program, opcode);
+
+ if (flags & EXT)
+ __rta_out32(program, length & NFIFOENTRY_DLEN_MASK);
+
+ program->current_instruction++;
+
+ return (int)start_pc;
+
+ err:
+ program->first_error_pc = start_pc;
+ program->current_instruction++;
+ return ret;
+}
+
+#endif /* __RTA_NFIFO_CMD_H__ */
--- /dev/null
+/* SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0)
+ *
+ * Copyright 2008-2016 Freescale Semiconductor Inc.
+ * Copyright 2016,2019 NXP
+ */
+
+#ifndef __RTA_OPERATION_CMD_H__
+#define __RTA_OPERATION_CMD_H__
+
+#if defined(RTE_TOOLCHAIN_GCC) && (GCC_VERSION >= 70000)
+#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
+#endif
+
+extern enum rta_sec_era rta_sec_era;
+
+static inline int
+__rta_alg_aai_aes(uint16_t aai)
+{
+ uint16_t aes_mode = aai & OP_ALG_AESA_MODE_MASK;
+
+ if (aai & OP_ALG_AAI_C2K) {
+ if (rta_sec_era < RTA_SEC_ERA_5)
+ return -1;
+ if ((aes_mode != OP_ALG_AAI_CCM) &&
+ (aes_mode != OP_ALG_AAI_GCM))
+ return -EINVAL;
+ }
+
+ switch (aes_mode) {
+ case OP_ALG_AAI_CBC_CMAC:
+ case OP_ALG_AAI_CTR_CMAC_LTE:
+ case OP_ALG_AAI_CTR_CMAC:
+ if (rta_sec_era < RTA_SEC_ERA_2)
+ return -EINVAL;
+ /* no break */
+ case OP_ALG_AAI_CTR:
+ case OP_ALG_AAI_CBC:
+ case OP_ALG_AAI_ECB:
+ case OP_ALG_AAI_OFB:
+ case OP_ALG_AAI_CFB:
+ case OP_ALG_AAI_XTS:
+ case OP_ALG_AAI_CMAC:
+ case OP_ALG_AAI_XCBC_MAC:
+ case OP_ALG_AAI_CCM:
+ case OP_ALG_AAI_GCM:
+ case OP_ALG_AAI_CBC_XCBCMAC:
+ case OP_ALG_AAI_CTR_XCBCMAC:
+ return 0;
+ }
+
+ return -EINVAL;
+}
+
+static inline int
+__rta_alg_aai_des(uint16_t aai)
+{
+ uint16_t aai_code = (uint16_t)(aai & ~OP_ALG_AAI_CHECKODD);
+
+ switch (aai_code) {
+ case OP_ALG_AAI_CBC:
+ case OP_ALG_AAI_ECB:
+ case OP_ALG_AAI_CFB:
+ case OP_ALG_AAI_OFB:
+ return 0;
+ }
+
+ return -EINVAL;
+}
+
+static inline int
+__rta_alg_aai_md5(uint16_t aai)
+{
+ switch (aai) {
+ case OP_ALG_AAI_HMAC:
+ if (rta_sec_era < RTA_SEC_ERA_2)
+ return -EINVAL;
+ /* no break */
+ case OP_ALG_AAI_SMAC:
+ case OP_ALG_AAI_HASH:
+ case OP_ALG_AAI_HMAC_PRECOMP:
+ return 0;
+ }
+
+ return -EINVAL;
+}
+
+static inline int
+__rta_alg_aai_sha(uint16_t aai)
+{
+ switch (aai) {
+ case OP_ALG_AAI_HMAC:
+ if (rta_sec_era < RTA_SEC_ERA_2)
+ return -EINVAL;
+ /* no break */
+ case OP_ALG_AAI_HASH:
+ case OP_ALG_AAI_HMAC_PRECOMP:
+ return 0;
+ }
+
+ return -EINVAL;
+}
+
+static inline int
+__rta_alg_aai_rng(uint16_t aai)
+{
+ uint16_t rng_mode = aai & OP_ALG_RNG_MODE_MASK;
+ uint16_t rng_sh = aai & OP_ALG_AAI_RNG4_SH_MASK;
+
+ switch (rng_mode) {
+ case OP_ALG_AAI_RNG:
+ case OP_ALG_AAI_RNG_NZB:
+ case OP_ALG_AAI_RNG_OBP:
+ break;
+ default:
+ return -EINVAL;
+ }
+
+ /* State Handle bits are valid only for SEC Era >= 5 */
+ if ((rta_sec_era < RTA_SEC_ERA_5) && rng_sh)
+ return -EINVAL;
+
+ /* PS, AI, SK bits are also valid only for SEC Era >= 5 */
+ if ((rta_sec_era < RTA_SEC_ERA_5) && (aai &
+ (OP_ALG_AAI_RNG4_PS | OP_ALG_AAI_RNG4_AI | OP_ALG_AAI_RNG4_SK)))
+ return -EINVAL;
+
+ switch (rng_sh) {
+ case OP_ALG_AAI_RNG4_SH_0:
+ case OP_ALG_AAI_RNG4_SH_1:
+ return 0;
+ }
+
+ return -EINVAL;
+}
+
+static inline int
+__rta_alg_aai_crc(uint16_t aai)
+{
+ uint16_t aai_code = aai & OP_ALG_CRC_POLY_MASK;
+
+ switch (aai_code) {
+ case OP_ALG_AAI_802:
+ case OP_ALG_AAI_3385:
+ case OP_ALG_AAI_CUST_POLY:
+ return 0;
+ }
+
+ return -EINVAL;
+}
+
+static inline int
+__rta_alg_aai_kasumi(uint16_t aai)
+{
+ switch (aai) {
+ case OP_ALG_AAI_GSM:
+ case OP_ALG_AAI_EDGE:
+ case OP_ALG_AAI_F8:
+ case OP_ALG_AAI_F9:
+ return 0;
+ }
+
+ return -EINVAL;
+}
+
+static inline int
+__rta_alg_aai_snow_f9(uint16_t aai)
+{
+ if (aai == OP_ALG_AAI_F9)
+ return 0;
+
+ return -EINVAL;
+}
+
+static inline int
+__rta_alg_aai_snow_f8(uint16_t aai)
+{
+ if (aai == OP_ALG_AAI_F8)
+ return 0;
+
+ return -EINVAL;
+}
+
+static inline int
+__rta_alg_aai_zuce(uint16_t aai)
+{
+ if (aai == OP_ALG_AAI_F8)
+ return 0;
+
+ return -EINVAL;
+}
+
+static inline int
+__rta_alg_aai_zuca(uint16_t aai)
+{
+ if (aai == OP_ALG_AAI_F9)
+ return 0;
+
+ return -EINVAL;
+}
+
+struct alg_aai_map {
+ uint32_t chipher_algo;
+ int (*aai_func)(uint16_t);
+ uint32_t class;
+};
+
+static const struct alg_aai_map alg_table[] = {
+/*1*/ { OP_ALG_ALGSEL_AES, __rta_alg_aai_aes, OP_TYPE_CLASS1_ALG },
+ { OP_ALG_ALGSEL_DES, __rta_alg_aai_des, OP_TYPE_CLASS1_ALG },
+ { OP_ALG_ALGSEL_3DES, __rta_alg_aai_des, OP_TYPE_CLASS1_ALG },
+ { OP_ALG_ALGSEL_MD5, __rta_alg_aai_md5, OP_TYPE_CLASS2_ALG },
+ { OP_ALG_ALGSEL_SHA1, __rta_alg_aai_md5, OP_TYPE_CLASS2_ALG },
+ { OP_ALG_ALGSEL_SHA224, __rta_alg_aai_sha, OP_TYPE_CLASS2_ALG },
+ { OP_ALG_ALGSEL_SHA256, __rta_alg_aai_sha, OP_TYPE_CLASS2_ALG },
+ { OP_ALG_ALGSEL_SHA384, __rta_alg_aai_sha, OP_TYPE_CLASS2_ALG },
+ { OP_ALG_ALGSEL_SHA512, __rta_alg_aai_sha, OP_TYPE_CLASS2_ALG },
+ { OP_ALG_ALGSEL_RNG, __rta_alg_aai_rng, OP_TYPE_CLASS1_ALG },
+/*11*/ { OP_ALG_ALGSEL_CRC, __rta_alg_aai_crc, OP_TYPE_CLASS2_ALG },
+ { OP_ALG_ALGSEL_ARC4, NULL, OP_TYPE_CLASS1_ALG },
+ { OP_ALG_ALGSEL_SNOW_F8, __rta_alg_aai_snow_f8, OP_TYPE_CLASS1_ALG },
+/*14*/ { OP_ALG_ALGSEL_KASUMI, __rta_alg_aai_kasumi, OP_TYPE_CLASS1_ALG },
+ { OP_ALG_ALGSEL_SNOW_F9, __rta_alg_aai_snow_f9, OP_TYPE_CLASS2_ALG },
+ { OP_ALG_ALGSEL_ZUCE, __rta_alg_aai_zuce, OP_TYPE_CLASS1_ALG },
+/*17*/ { OP_ALG_ALGSEL_ZUCA, __rta_alg_aai_zuca, OP_TYPE_CLASS2_ALG }
+};
+
+/*
+ * Allowed OPERATION algorithms for each SEC Era.
+ * Values represent the number of entries from alg_table[] that are supported.
+ */
+static const unsigned int alg_table_sz[] = {14, 15, 15, 15, 17, 17,
+ 11, 17, 17, 17};
+
+static inline int
+rta_operation(struct program *program, uint32_t cipher_algo,
+ uint16_t aai, uint8_t algo_state,
+ int icv_checking, int enc)
+{
+ uint32_t opcode = CMD_OPERATION;
+ unsigned int i, found = 0;
+ unsigned int start_pc = program->current_pc;
+ int ret;
+
+ for (i = 0; i < alg_table_sz[rta_sec_era]; i++) {
+ if (alg_table[i].chipher_algo == cipher_algo) {
+ opcode |= cipher_algo | alg_table[i].class;
+ /* nothing else to verify */
+ if (alg_table[i].aai_func == NULL) {
+ found = 1;
+ break;
+ }
+
+ aai &= OP_ALG_AAI_MASK;
+
+ ret = (*alg_table[i].aai_func)(aai);
+ if (ret < 0) {
+ pr_err("OPERATION: Bad AAI Type. SEC Program Line: %d\n",
+ program->current_pc);
+ goto err;
+ }
+ opcode |= aai;
+ found = 1;
+ break;
+ }
+ }
+ if (!found) {
+ pr_err("OPERATION: Invalid Command. SEC Program Line: %d\n",
+ program->current_pc);
+ ret = -EINVAL;
+ goto err;
+ }
+
+ switch (algo_state) {
+ case OP_ALG_AS_UPDATE:
+ case OP_ALG_AS_INIT:
+ case OP_ALG_AS_FINALIZE:
+ case OP_ALG_AS_INITFINAL:
+ opcode |= algo_state;
+ break;
+ default:
+ pr_err("Invalid Operation Command\n");
+ ret = -EINVAL;
+ goto err;
+ }
+
+ switch (icv_checking) {
+ case ICV_CHECK_DISABLE:
+ /*
+ * opcode |= OP_ALG_ICV_OFF;
+ * OP_ALG_ICV_OFF is 0
+ */
+ break;
+ case ICV_CHECK_ENABLE:
+ opcode |= OP_ALG_ICV_ON;
+ break;
+ default:
+ pr_err("Invalid Operation Command\n");
+ ret = -EINVAL;
+ goto err;
+ }
+
+ switch (enc) {
+ case DIR_DEC:
+ /*
+ * opcode |= OP_ALG_DECRYPT;
+ * OP_ALG_DECRYPT is 0
+ */
+ break;
+ case DIR_ENC:
+ opcode |= OP_ALG_ENCRYPT;
+ break;
+ default:
+ pr_err("Invalid Operation Command\n");
+ ret = -EINVAL;
+ goto err;
+ }
+
+ __rta_out32(program, opcode);
+ program->current_instruction++;
+ return (int)start_pc;
+
+ err:
+ program->first_error_pc = start_pc;
+ return ret;
+}
+
+/*
+ * OPERATION PKHA routines
+ */
+static inline int
+__rta_pkha_clearmem(uint32_t pkha_op)
+{
+ switch (pkha_op) {
+ case (OP_ALG_PKMODE_CLEARMEM_ALL):
+ case (OP_ALG_PKMODE_CLEARMEM_ABE):
+ case (OP_ALG_PKMODE_CLEARMEM_ABN):
+ case (OP_ALG_PKMODE_CLEARMEM_AB):
+ case (OP_ALG_PKMODE_CLEARMEM_AEN):
+ case (OP_ALG_PKMODE_CLEARMEM_AE):
+ case (OP_ALG_PKMODE_CLEARMEM_AN):
+ case (OP_ALG_PKMODE_CLEARMEM_A):
+ case (OP_ALG_PKMODE_CLEARMEM_BEN):
+ case (OP_ALG_PKMODE_CLEARMEM_BE):
+ case (OP_ALG_PKMODE_CLEARMEM_BN):
+ case (OP_ALG_PKMODE_CLEARMEM_B):
+ case (OP_ALG_PKMODE_CLEARMEM_EN):
+ case (OP_ALG_PKMODE_CLEARMEM_N):
+ case (OP_ALG_PKMODE_CLEARMEM_E):
+ return 0;
+ }
+
+ return -EINVAL;
+}
+
+static inline int
+__rta_pkha_mod_arithmetic(uint32_t pkha_op)
+{
+ pkha_op &= (uint32_t)~OP_ALG_PKMODE_OUT_A;
+
+ switch (pkha_op) {
+ case (OP_ALG_PKMODE_MOD_ADD):
+ case (OP_ALG_PKMODE_MOD_SUB_AB):
+ case (OP_ALG_PKMODE_MOD_SUB_BA):
+ case (OP_ALG_PKMODE_MOD_MULT):
+ case (OP_ALG_PKMODE_MOD_MULT_IM):
+ case (OP_ALG_PKMODE_MOD_MULT_IM_OM):
+ case (OP_ALG_PKMODE_MOD_EXPO):
+ case (OP_ALG_PKMODE_MOD_EXPO_TEQ):
+ case (OP_ALG_PKMODE_MOD_EXPO_IM):
+ case (OP_ALG_PKMODE_MOD_EXPO_IM_TEQ):
+ case (OP_ALG_PKMODE_MOD_REDUCT):
+ case (OP_ALG_PKMODE_MOD_INV):
+ case (OP_ALG_PKMODE_MOD_MONT_CNST):
+ case (OP_ALG_PKMODE_MOD_CRT_CNST):
+ case (OP_ALG_PKMODE_MOD_GCD):
+ case (OP_ALG_PKMODE_MOD_PRIMALITY):
+ case (OP_ALG_PKMODE_MOD_SML_EXP):
+ case (OP_ALG_PKMODE_F2M_ADD):
+ case (OP_ALG_PKMODE_F2M_MUL):
+ case (OP_ALG_PKMODE_F2M_MUL_IM):
+ case (OP_ALG_PKMODE_F2M_MUL_IM_OM):
+ case (OP_ALG_PKMODE_F2M_EXP):
+ case (OP_ALG_PKMODE_F2M_EXP_TEQ):
+ case (OP_ALG_PKMODE_F2M_AMODN):
+ case (OP_ALG_PKMODE_F2M_INV):
+ case (OP_ALG_PKMODE_F2M_R2):
+ case (OP_ALG_PKMODE_F2M_GCD):
+ case (OP_ALG_PKMODE_F2M_SML_EXP):
+ case (OP_ALG_PKMODE_ECC_F2M_ADD):
+ case (OP_ALG_PKMODE_ECC_F2M_ADD_IM_OM_PROJ):
+ case (OP_ALG_PKMODE_ECC_F2M_DBL):
+ case (OP_ALG_PKMODE_ECC_F2M_DBL_IM_OM_PROJ):
+ case (OP_ALG_PKMODE_ECC_F2M_MUL):
+ case (OP_ALG_PKMODE_ECC_F2M_MUL_TEQ):
+ case (OP_ALG_PKMODE_ECC_F2M_MUL_R2):
+ case (OP_ALG_PKMODE_ECC_F2M_MUL_R2_TEQ):
+ case (OP_ALG_PKMODE_ECC_F2M_MUL_R2_PROJ):
+ case (OP_ALG_PKMODE_ECC_F2M_MUL_R2_PROJ_TEQ):
+ case (OP_ALG_PKMODE_ECC_MOD_ADD):
+ case (OP_ALG_PKMODE_ECC_MOD_ADD_IM_OM_PROJ):
+ case (OP_ALG_PKMODE_ECC_MOD_DBL):
+ case (OP_ALG_PKMODE_ECC_MOD_DBL_IM_OM_PROJ):
+ case (OP_ALG_PKMODE_ECC_MOD_MUL):
+ case (OP_ALG_PKMODE_ECC_MOD_MUL_TEQ):
+ case (OP_ALG_PKMODE_ECC_MOD_MUL_R2):
+ case (OP_ALG_PKMODE_ECC_MOD_MUL_R2_TEQ):
+ case (OP_ALG_PKMODE_ECC_MOD_MUL_R2_PROJ):
+ case (OP_ALG_PKMODE_ECC_MOD_MUL_R2_PROJ_TEQ):
+ return 0;
+ }
+
+ return -EINVAL;
+}
+
+static inline int
+__rta_pkha_copymem(uint32_t pkha_op)
+{
+ switch (pkha_op) {
+ case (OP_ALG_PKMODE_COPY_NSZ_A0_B0):
+ case (OP_ALG_PKMODE_COPY_NSZ_A0_B1):
+ case (OP_ALG_PKMODE_COPY_NSZ_A0_B2):
+ case (OP_ALG_PKMODE_COPY_NSZ_A0_B3):
+ case (OP_ALG_PKMODE_COPY_NSZ_A1_B0):
+ case (OP_ALG_PKMODE_COPY_NSZ_A1_B1):
+ case (OP_ALG_PKMODE_COPY_NSZ_A1_B2):
+ case (OP_ALG_PKMODE_COPY_NSZ_A1_B3):
+ case (OP_ALG_PKMODE_COPY_NSZ_A2_B0):
+ case (OP_ALG_PKMODE_COPY_NSZ_A2_B1):
+ case (OP_ALG_PKMODE_COPY_NSZ_A2_B2):
+ case (OP_ALG_PKMODE_COPY_NSZ_A2_B3):
+ case (OP_ALG_PKMODE_COPY_NSZ_A3_B0):
+ case (OP_ALG_PKMODE_COPY_NSZ_A3_B1):
+ case (OP_ALG_PKMODE_COPY_NSZ_A3_B2):
+ case (OP_ALG_PKMODE_COPY_NSZ_A3_B3):
+ case (OP_ALG_PKMODE_COPY_NSZ_B0_A0):
+ case (OP_ALG_PKMODE_COPY_NSZ_B0_A1):
+ case (OP_ALG_PKMODE_COPY_NSZ_B0_A2):
+ case (OP_ALG_PKMODE_COPY_NSZ_B0_A3):
+ case (OP_ALG_PKMODE_COPY_NSZ_B1_A0):
+ case (OP_ALG_PKMODE_COPY_NSZ_B1_A1):
+ case (OP_ALG_PKMODE_COPY_NSZ_B1_A2):
+ case (OP_ALG_PKMODE_COPY_NSZ_B1_A3):
+ case (OP_ALG_PKMODE_COPY_NSZ_B2_A0):
+ case (OP_ALG_PKMODE_COPY_NSZ_B2_A1):
+ case (OP_ALG_PKMODE_COPY_NSZ_B2_A2):
+ case (OP_ALG_PKMODE_COPY_NSZ_B2_A3):
+ case (OP_ALG_PKMODE_COPY_NSZ_B3_A0):
+ case (OP_ALG_PKMODE_COPY_NSZ_B3_A1):
+ case (OP_ALG_PKMODE_COPY_NSZ_B3_A2):
+ case (OP_ALG_PKMODE_COPY_NSZ_B3_A3):
+ case (OP_ALG_PKMODE_COPY_NSZ_A_E):
+ case (OP_ALG_PKMODE_COPY_NSZ_A_N):
+ case (OP_ALG_PKMODE_COPY_NSZ_B_E):
+ case (OP_ALG_PKMODE_COPY_NSZ_B_N):
+ case (OP_ALG_PKMODE_COPY_NSZ_N_A):
+ case (OP_ALG_PKMODE_COPY_NSZ_N_B):
+ case (OP_ALG_PKMODE_COPY_NSZ_N_E):
+ case (OP_ALG_PKMODE_COPY_SSZ_A0_B0):
+ case (OP_ALG_PKMODE_COPY_SSZ_A0_B1):
+ case (OP_ALG_PKMODE_COPY_SSZ_A0_B2):
+ case (OP_ALG_PKMODE_COPY_SSZ_A0_B3):
+ case (OP_ALG_PKMODE_COPY_SSZ_A1_B0):
+ case (OP_ALG_PKMODE_COPY_SSZ_A1_B1):
+ case (OP_ALG_PKMODE_COPY_SSZ_A1_B2):
+ case (OP_ALG_PKMODE_COPY_SSZ_A1_B3):
+ case (OP_ALG_PKMODE_COPY_SSZ_A2_B0):
+ case (OP_ALG_PKMODE_COPY_SSZ_A2_B1):
+ case (OP_ALG_PKMODE_COPY_SSZ_A2_B2):
+ case (OP_ALG_PKMODE_COPY_SSZ_A2_B3):
+ case (OP_ALG_PKMODE_COPY_SSZ_A3_B0):
+ case (OP_ALG_PKMODE_COPY_SSZ_A3_B1):
+ case (OP_ALG_PKMODE_COPY_SSZ_A3_B2):
+ case (OP_ALG_PKMODE_COPY_SSZ_A3_B3):
+ case (OP_ALG_PKMODE_COPY_SSZ_B0_A0):
+ case (OP_ALG_PKMODE_COPY_SSZ_B0_A1):
+ case (OP_ALG_PKMODE_COPY_SSZ_B0_A2):
+ case (OP_ALG_PKMODE_COPY_SSZ_B0_A3):
+ case (OP_ALG_PKMODE_COPY_SSZ_B1_A0):
+ case (OP_ALG_PKMODE_COPY_SSZ_B1_A1):
+ case (OP_ALG_PKMODE_COPY_SSZ_B1_A2):
+ case (OP_ALG_PKMODE_COPY_SSZ_B1_A3):
+ case (OP_ALG_PKMODE_COPY_SSZ_B2_A0):
+ case (OP_ALG_PKMODE_COPY_SSZ_B2_A1):
+ case (OP_ALG_PKMODE_COPY_SSZ_B2_A2):
+ case (OP_ALG_PKMODE_COPY_SSZ_B2_A3):
+ case (OP_ALG_PKMODE_COPY_SSZ_B3_A0):
+ case (OP_ALG_PKMODE_COPY_SSZ_B3_A1):
+ case (OP_ALG_PKMODE_COPY_SSZ_B3_A2):
+ case (OP_ALG_PKMODE_COPY_SSZ_B3_A3):
+ case (OP_ALG_PKMODE_COPY_SSZ_A_E):
+ case (OP_ALG_PKMODE_COPY_SSZ_A_N):
+ case (OP_ALG_PKMODE_COPY_SSZ_B_E):
+ case (OP_ALG_PKMODE_COPY_SSZ_B_N):
+ case (OP_ALG_PKMODE_COPY_SSZ_N_A):
+ case (OP_ALG_PKMODE_COPY_SSZ_N_B):
+ case (OP_ALG_PKMODE_COPY_SSZ_N_E):
+ return 0;
+ }
+
+ return -EINVAL;
+}
+
+static inline int
+rta_pkha_operation(struct program *program, uint32_t op_pkha)
+{
+ uint32_t opcode = CMD_OPERATION | OP_TYPE_PK | OP_ALG_PK;
+ uint32_t pkha_func;
+ unsigned int start_pc = program->current_pc;
+ int ret = -EINVAL;
+
+ pkha_func = op_pkha & OP_ALG_PK_FUN_MASK;
+
+ switch (pkha_func) {
+ case (OP_ALG_PKMODE_CLEARMEM):
+ ret = __rta_pkha_clearmem(op_pkha);
+ if (ret < 0) {
+ pr_err("OPERATION PKHA: Type not supported. SEC Program Line: %d\n",
+ program->current_pc);
+ goto err;
+ }
+ break;
+ case (OP_ALG_PKMODE_MOD_ADD):
+ case (OP_ALG_PKMODE_MOD_SUB_AB):
+ case (OP_ALG_PKMODE_MOD_SUB_BA):
+ case (OP_ALG_PKMODE_MOD_MULT):
+ case (OP_ALG_PKMODE_MOD_EXPO):
+ case (OP_ALG_PKMODE_MOD_REDUCT):
+ case (OP_ALG_PKMODE_MOD_INV):
+ case (OP_ALG_PKMODE_MOD_MONT_CNST):
+ case (OP_ALG_PKMODE_MOD_CRT_CNST):
+ case (OP_ALG_PKMODE_MOD_GCD):
+ case (OP_ALG_PKMODE_MOD_PRIMALITY):
+ case (OP_ALG_PKMODE_MOD_SML_EXP):
+ case (OP_ALG_PKMODE_ECC_MOD_ADD):
+ case (OP_ALG_PKMODE_ECC_MOD_DBL):
+ case (OP_ALG_PKMODE_ECC_MOD_MUL):
+ ret = __rta_pkha_mod_arithmetic(op_pkha);
+ if (ret < 0) {
+ pr_err("OPERATION PKHA: Type not supported. SEC Program Line: %d\n",
+ program->current_pc);
+ goto err;
+ }
+ break;
+ case (OP_ALG_PKMODE_COPY_NSZ):
+ case (OP_ALG_PKMODE_COPY_SSZ):
+ ret = __rta_pkha_copymem(op_pkha);
+ if (ret < 0) {
+ pr_err("OPERATION PKHA: Type not supported. SEC Program Line: %d\n",
+ program->current_pc);
+ goto err;
+ }
+ break;
+ default:
+ pr_err("Invalid Operation Command\n");
+ goto err;
+ }
+
+ opcode |= op_pkha;
+
+ __rta_out32(program, opcode);
+ program->current_instruction++;
+ return (int)start_pc;
+
+ err:
+ program->first_error_pc = start_pc;
+ program->current_instruction++;
+ return ret;
+}
+
+#endif /* __RTA_OPERATION_CMD_H__ */
--- /dev/null
+/* SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0)
+ *
+ * Copyright 2008-2016 Freescale Semiconductor Inc.
+ * Copyright 2016,2019 NXP
+ *
+ */
+
+#ifndef __RTA_PROTOCOL_CMD_H__
+#define __RTA_PROTOCOL_CMD_H__
+
+extern enum rta_sec_era rta_sec_era;
+
+static inline int
+__rta_ssl_proto(uint16_t protoinfo)
+{
+ switch (protoinfo) {
+ case OP_PCL_TLS_RSA_EXPORT_WITH_RC4_40_MD5:
+ case OP_PCL_TLS_RSA_WITH_RC4_128_MD5:
+ case OP_PCL_TLS_RSA_WITH_RC4_128_SHA:
+ case OP_PCL_TLS_DH_anon_EXPORT_WITH_RC4_40_MD5:
+ case OP_PCL_TLS_DH_anon_WITH_RC4_128_MD5:
+ case OP_PCL_TLS_KRB5_WITH_RC4_128_SHA:
+ case OP_PCL_TLS_KRB5_WITH_RC4_128_MD5:
+ case OP_PCL_TLS_KRB5_EXPORT_WITH_RC4_40_SHA:
+ case OP_PCL_TLS_KRB5_EXPORT_WITH_RC4_40_MD5:
+ case OP_PCL_TLS_PSK_WITH_RC4_128_SHA:
+ case OP_PCL_TLS_DHE_PSK_WITH_RC4_128_SHA:
+ case OP_PCL_TLS_RSA_PSK_WITH_RC4_128_SHA:
+ case OP_PCL_TLS_ECDH_ECDSA_WITH_RC4_128_SHA:
+ case OP_PCL_TLS_ECDHE_ECDSA_WITH_RC4_128_SHA:
+ case OP_PCL_TLS_ECDH_RSA_WITH_RC4_128_SHA:
+ case OP_PCL_TLS_ECDHE_RSA_WITH_RC4_128_SHA:
+ case OP_PCL_TLS_ECDH_anon_WITH_RC4_128_SHA:
+ case OP_PCL_TLS_ECDHE_PSK_WITH_RC4_128_SHA:
+ if (rta_sec_era == RTA_SEC_ERA_7)
+ return -EINVAL;
+ /* fall through if not Era 7 */
+ case OP_PCL_TLS_RSA_EXPORT_WITH_DES40_CBC_SHA:
+ case OP_PCL_TLS_RSA_WITH_DES_CBC_SHA:
+ case OP_PCL_TLS_RSA_WITH_3DES_EDE_CBC_SHA:
+ case OP_PCL_TLS_DH_DSS_EXPORT_WITH_DES40_CBC_SHA:
+ case OP_PCL_TLS_DH_DSS_WITH_DES_CBC_SHA:
+ case OP_PCL_TLS_DH_DSS_WITH_3DES_EDE_CBC_SHA:
+ case OP_PCL_TLS_DH_RSA_EXPORT_WITH_DES40_CBC_SHA:
+ case OP_PCL_TLS_DH_RSA_WITH_DES_CBC_SHA:
+ case OP_PCL_TLS_DH_RSA_WITH_3DES_EDE_CBC_SHA:
+ case OP_PCL_TLS_DHE_DSS_EXPORT_WITH_DES40_CBC_SHA:
+ case OP_PCL_TLS_DHE_DSS_WITH_DES_CBC_SHA:
+ case OP_PCL_TLS_DHE_DSS_WITH_3DES_EDE_CBC_SHA:
+ case OP_PCL_TLS_DHE_RSA_EXPORT_WITH_DES40_CBC_SHA:
+ case OP_PCL_TLS_DHE_RSA_WITH_DES_CBC_SHA:
+ case OP_PCL_TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA:
+ case OP_PCL_TLS_DH_anon_EXPORT_WITH_DES40_CBC_SHA:
+ case OP_PCL_TLS_DH_anon_WITH_DES_CBC_SHA:
+ case OP_PCL_TLS_DH_anon_WITH_3DES_EDE_CBC_SHA:
+ case OP_PCL_TLS_KRB5_WITH_DES_CBC_SHA:
+ case OP_PCL_TLS_KRB5_WITH_3DES_EDE_CBC_SHA:
+ case OP_PCL_TLS_KRB5_WITH_DES_CBC_MD5:
+ case OP_PCL_TLS_KRB5_WITH_3DES_EDE_CBC_MD5:
+ case OP_PCL_TLS_KRB5_EXPORT_WITH_DES_CBC_40_SHA:
+ case OP_PCL_TLS_KRB5_EXPORT_WITH_DES_CBC_40_MD5:
+ case OP_PCL_TLS_RSA_WITH_AES_128_CBC_SHA:
+ case OP_PCL_TLS_DH_DSS_WITH_AES_128_CBC_SHA:
+ case OP_PCL_TLS_DH_RSA_WITH_AES_128_CBC_SHA:
+ case OP_PCL_TLS_DHE_DSS_WITH_AES_128_CBC_SHA:
+ case OP_PCL_TLS_DHE_RSA_WITH_AES_128_CBC_SHA:
+ case OP_PCL_TLS_DH_anon_WITH_AES_128_CBC_SHA:
+ case OP_PCL_TLS_RSA_WITH_AES_256_CBC_SHA:
+ case OP_PCL_TLS_DH_DSS_WITH_AES_256_CBC_SHA:
+ case OP_PCL_TLS_DH_RSA_WITH_AES_256_CBC_SHA:
+ case OP_PCL_TLS_DHE_DSS_WITH_AES_256_CBC_SHA:
+ case OP_PCL_TLS_DHE_RSA_WITH_AES_256_CBC_SHA:
+ case OP_PCL_TLS_DH_anon_WITH_AES_256_CBC_SHA:
+ case OP_PCL_TLS_DH_DSS_WITH_AES_128_CBC_SHA256:
+ case OP_PCL_TLS_DH_RSA_WITH_AES_128_CBC_SHA256:
+ case OP_PCL_TLS_DHE_DSS_WITH_AES_128_CBC_SHA256:
+ case OP_PCL_TLS_DHE_RSA_WITH_AES_128_CBC_SHA256:
+ case OP_PCL_TLS_DH_DSS_WITH_AES_256_CBC_SHA256:
+ case OP_PCL_TLS_DH_RSA_WITH_AES_256_CBC_SHA256:
+ case OP_PCL_TLS_DHE_DSS_WITH_AES_256_CBC_SHA256:
+ case OP_PCL_TLS_DHE_RSA_WITH_AES_256_CBC_SHA256:
+ case OP_PCL_TLS_DH_anon_WITH_AES_128_CBC_SHA256:
+ case OP_PCL_TLS_DH_anon_WITH_AES_256_CBC_SHA256:
+ case OP_PCL_TLS_PSK_WITH_3DES_EDE_CBC_SHA:
+ case OP_PCL_TLS_PSK_WITH_AES_128_CBC_SHA:
+ case OP_PCL_TLS_PSK_WITH_AES_256_CBC_SHA:
+ case OP_PCL_TLS_DHE_PSK_WITH_3DES_EDE_CBC_SHA:
+ case OP_PCL_TLS_DHE_PSK_WITH_AES_128_CBC_SHA:
+ case OP_PCL_TLS_DHE_PSK_WITH_AES_256_CBC_SHA:
+ case OP_PCL_TLS_RSA_PSK_WITH_3DES_EDE_CBC_SHA:
+ case OP_PCL_TLS_RSA_PSK_WITH_AES_128_CBC_SHA:
+ case OP_PCL_TLS_RSA_PSK_WITH_AES_256_CBC_SHA:
+ case OP_PCL_TLS_RSA_WITH_AES_128_GCM_SHA256:
+ case OP_PCL_TLS_RSA_WITH_AES_256_GCM_SHA384:
+ case OP_PCL_TLS_DHE_RSA_WITH_AES_128_GCM_SHA256:
+ case OP_PCL_TLS_DHE_RSA_WITH_AES_256_GCM_SHA384:
+ case OP_PCL_TLS_DH_RSA_WITH_AES_128_GCM_SHA256:
+ case OP_PCL_TLS_DH_RSA_WITH_AES_256_GCM_SHA384:
+ case OP_PCL_TLS_DHE_DSS_WITH_AES_128_GCM_SHA256:
+ case OP_PCL_TLS_DHE_DSS_WITH_AES_256_GCM_SHA384:
+ case OP_PCL_TLS_DH_DSS_WITH_AES_128_GCM_SHA256:
+ case OP_PCL_TLS_DH_DSS_WITH_AES_256_GCM_SHA384:
+ case OP_PCL_TLS_DH_anon_WITH_AES_128_GCM_SHA256:
+ case OP_PCL_TLS_DH_anon_WITH_AES_256_GCM_SHA384:
+ case OP_PCL_TLS_PSK_WITH_AES_128_GCM_SHA256:
+ case OP_PCL_TLS_PSK_WITH_AES_256_GCM_SHA384:
+ case OP_PCL_TLS_DHE_PSK_WITH_AES_128_GCM_SHA256:
+ case OP_PCL_TLS_DHE_PSK_WITH_AES_256_GCM_SHA384:
+ case OP_PCL_TLS_RSA_PSK_WITH_AES_128_GCM_SHA256:
+ case OP_PCL_TLS_RSA_PSK_WITH_AES_256_GCM_SHA384:
+ case OP_PCL_TLS_PSK_WITH_AES_128_CBC_SHA256:
+ case OP_PCL_TLS_PSK_WITH_AES_256_CBC_SHA384:
+ case OP_PCL_TLS_DHE_PSK_WITH_AES_128_CBC_SHA256:
+ case OP_PCL_TLS_DHE_PSK_WITH_AES_256_CBC_SHA384:
+ case OP_PCL_TLS_RSA_PSK_WITH_AES_128_CBC_SHA256:
+ case OP_PCL_TLS_RSA_PSK_WITH_AES_256_CBC_SHA384:
+ case OP_PCL_TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA:
+ case OP_PCL_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA:
+ case OP_PCL_TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA:
+ case OP_PCL_TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA:
+ case OP_PCL_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA:
+ case OP_PCL_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA:
+ case OP_PCL_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA:
+ case OP_PCL_TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA:
+ case OP_PCL_TLS_ECDH_RSA_WITH_AES_256_CBC_SHA:
+ case OP_PCL_TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA:
+ case OP_PCL_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA:
+ case OP_PCL_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA:
+ case OP_PCL_TLS_ECDH_anon_WITH_3DES_EDE_CBC_SHA:
+ case OP_PCL_TLS_ECDH_anon_WITH_AES_128_CBC_SHA:
+ case OP_PCL_TLS_ECDH_anon_WITH_AES_256_CBC_SHA:
+ case OP_PCL_TLS_SRP_SHA_WITH_3DES_EDE_CBC_SHA:
+ case OP_PCL_TLS_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA:
+ case OP_PCL_TLS_SRP_SHA_DSS_WITH_3DES_EDE_CBC_SHA:
+ case OP_PCL_TLS_SRP_SHA_WITH_AES_128_CBC_SHA:
+ case OP_PCL_TLS_SRP_SHA_RSA_WITH_AES_128_CBC_SHA:
+ case OP_PCL_TLS_SRP_SHA_DSS_WITH_AES_128_CBC_SHA:
+ case OP_PCL_TLS_SRP_SHA_WITH_AES_256_CBC_SHA:
+ case OP_PCL_TLS_SRP_SHA_RSA_WITH_AES_256_CBC_SHA:
+ case OP_PCL_TLS_SRP_SHA_DSS_WITH_AES_256_CBC_SHA:
+ case OP_PCL_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256:
+ case OP_PCL_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384:
+ case OP_PCL_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256:
+ case OP_PCL_TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384:
+ case OP_PCL_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256:
+ case OP_PCL_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384:
+ case OP_PCL_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256:
+ case OP_PCL_TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384:
+ case OP_PCL_TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256:
+ case OP_PCL_TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384:
+ case OP_PCL_TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256:
+ case OP_PCL_TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384:
+ case OP_PCL_TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256:
+ case OP_PCL_TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384:
+ case OP_PCL_TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256:
+ case OP_PCL_TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384:
+ case OP_PCL_TLS_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA:
+ case OP_PCL_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA:
+ case OP_PCL_TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA:
+ case OP_PCL_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256:
+ case OP_PCL_TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA384:
+ case OP_PCL_TLS_RSA_WITH_AES_128_CBC_SHA256:
+ case OP_PCL_TLS_RSA_WITH_AES_256_CBC_SHA256:
+ case OP_PCL_PVT_TLS_3DES_EDE_CBC_MD5:
+ case OP_PCL_PVT_TLS_3DES_EDE_CBC_SHA160:
+ case OP_PCL_PVT_TLS_3DES_EDE_CBC_SHA224:
+ case OP_PCL_PVT_TLS_3DES_EDE_CBC_SHA256:
+ case OP_PCL_PVT_TLS_3DES_EDE_CBC_SHA384:
+ case OP_PCL_PVT_TLS_3DES_EDE_CBC_SHA512:
+ case OP_PCL_PVT_TLS_AES_128_CBC_SHA160:
+ case OP_PCL_PVT_TLS_AES_128_CBC_SHA224:
+ case OP_PCL_PVT_TLS_AES_128_CBC_SHA256:
+ case OP_PCL_PVT_TLS_AES_128_CBC_SHA384:
+ case OP_PCL_PVT_TLS_AES_128_CBC_SHA512:
+ case OP_PCL_PVT_TLS_AES_192_CBC_SHA160:
+ case OP_PCL_PVT_TLS_AES_192_CBC_SHA224:
+ case OP_PCL_PVT_TLS_AES_192_CBC_SHA256:
+ case OP_PCL_PVT_TLS_AES_192_CBC_SHA512:
+ case OP_PCL_PVT_TLS_AES_256_CBC_SHA160:
+ case OP_PCL_PVT_TLS_AES_256_CBC_SHA224:
+ case OP_PCL_PVT_TLS_AES_256_CBC_SHA384:
+ case OP_PCL_PVT_TLS_AES_256_CBC_SHA512:
+ case OP_PCL_PVT_TLS_AES_256_CBC_SHA256:
+ case OP_PCL_PVT_TLS_AES_192_CBC_SHA384:
+ case OP_PCL_PVT_TLS_MASTER_SECRET_PRF_FE:
+ case OP_PCL_PVT_TLS_MASTER_SECRET_PRF_FF:
+ return 0;
+ }
+
+ return -EINVAL;
+}
+
+static inline int
+__rta_ike_proto(uint16_t protoinfo)
+{
+ switch (protoinfo) {
+ case OP_PCL_IKE_HMAC_MD5:
+ case OP_PCL_IKE_HMAC_SHA1:
+ case OP_PCL_IKE_HMAC_AES128_CBC:
+ case OP_PCL_IKE_HMAC_SHA256:
+ case OP_PCL_IKE_HMAC_SHA384:
+ case OP_PCL_IKE_HMAC_SHA512:
+ case OP_PCL_IKE_HMAC_AES128_CMAC:
+ return 0;
+ }
+
+ return -EINVAL;
+}
+
+static inline int
+__rta_ipsec_proto(uint16_t protoinfo)
+{
+ uint16_t proto_cls1 = protoinfo & OP_PCL_IPSEC_CIPHER_MASK;
+ uint16_t proto_cls2 = protoinfo & OP_PCL_IPSEC_AUTH_MASK;
+
+ switch (proto_cls1) {
+ case OP_PCL_IPSEC_AES_NULL_WITH_GMAC:
+ if (rta_sec_era < RTA_SEC_ERA_2)
+ return -EINVAL;
+ /* no break */
+ case OP_PCL_IPSEC_AES_CCM8:
+ case OP_PCL_IPSEC_AES_CCM12:
+ case OP_PCL_IPSEC_AES_CCM16:
+ case OP_PCL_IPSEC_AES_GCM8:
+ case OP_PCL_IPSEC_AES_GCM12:
+ case OP_PCL_IPSEC_AES_GCM16:
+ /* CCM, GCM, GMAC require PROTINFO[7:0] = 0 */
+ if (proto_cls2 == OP_PCL_IPSEC_HMAC_NULL)
+ return 0;
+ return -EINVAL;
+ case OP_PCL_IPSEC_NULL:
+ if (rta_sec_era < RTA_SEC_ERA_2)
+ return -EINVAL;
+ /* no break */
+ case OP_PCL_IPSEC_DES_IV64:
+ case OP_PCL_IPSEC_DES:
+ case OP_PCL_IPSEC_3DES:
+ case OP_PCL_IPSEC_AES_CBC:
+ case OP_PCL_IPSEC_AES_CTR:
+ break;
+ default:
+ return -EINVAL;
+ }
+
+ switch (proto_cls2) {
+ case OP_PCL_IPSEC_HMAC_NULL:
+ case OP_PCL_IPSEC_HMAC_MD5_96:
+ case OP_PCL_IPSEC_HMAC_SHA1_96:
+ case OP_PCL_IPSEC_AES_XCBC_MAC_96:
+ case OP_PCL_IPSEC_HMAC_MD5_128:
+ case OP_PCL_IPSEC_HMAC_SHA1_160:
+ case OP_PCL_IPSEC_AES_CMAC_96:
+ case OP_PCL_IPSEC_HMAC_SHA2_256_128:
+ case OP_PCL_IPSEC_HMAC_SHA2_384_192:
+ case OP_PCL_IPSEC_HMAC_SHA2_512_256:
+ return 0;
+ }
+
+ return -EINVAL;
+}
+
+static inline int
+__rta_srtp_proto(uint16_t protoinfo)
+{
+ uint16_t proto_cls1 = protoinfo & OP_PCL_SRTP_CIPHER_MASK;
+ uint16_t proto_cls2 = protoinfo & OP_PCL_SRTP_AUTH_MASK;
+
+ switch (proto_cls1) {
+ case OP_PCL_SRTP_AES_CTR:
+ switch (proto_cls2) {
+ case OP_PCL_SRTP_HMAC_SHA1_160:
+ return 0;
+ }
+ /* no break */
+ }
+
+ return -EINVAL;
+}
+
+static inline int
+__rta_macsec_proto(uint16_t protoinfo)
+{
+ switch (protoinfo) {
+ case OP_PCL_MACSEC:
+ return 0;
+ }
+
+ return -EINVAL;
+}
+
+static inline int
+__rta_wifi_proto(uint16_t protoinfo)
+{
+ switch (protoinfo) {
+ case OP_PCL_WIFI:
+ return 0;
+ }
+
+ return -EINVAL;
+}
+
+static inline int
+__rta_wimax_proto(uint16_t protoinfo)
+{
+ switch (protoinfo) {
+ case OP_PCL_WIMAX_OFDM:
+ case OP_PCL_WIMAX_OFDMA:
+ return 0;
+ }
+
+ return -EINVAL;
+}
+
+/* Allowed blob proto flags for each SEC Era */
+static const uint32_t proto_blob_flags[] = {
+ OP_PCL_BLOB_FORMAT_MASK | OP_PCL_BLOB_BLACK,
+ OP_PCL_BLOB_FORMAT_MASK | OP_PCL_BLOB_BLACK | OP_PCL_BLOB_TKEK |
+ OP_PCL_BLOB_EKT | OP_PCL_BLOB_REG_MASK,
+ OP_PCL_BLOB_FORMAT_MASK | OP_PCL_BLOB_BLACK | OP_PCL_BLOB_TKEK |
+ OP_PCL_BLOB_EKT | OP_PCL_BLOB_REG_MASK,
+ OP_PCL_BLOB_FORMAT_MASK | OP_PCL_BLOB_BLACK | OP_PCL_BLOB_TKEK |
+ OP_PCL_BLOB_EKT | OP_PCL_BLOB_REG_MASK | OP_PCL_BLOB_SEC_MEM,
+ OP_PCL_BLOB_FORMAT_MASK | OP_PCL_BLOB_BLACK | OP_PCL_BLOB_TKEK |
+ OP_PCL_BLOB_EKT | OP_PCL_BLOB_REG_MASK | OP_PCL_BLOB_SEC_MEM,
+ OP_PCL_BLOB_FORMAT_MASK | OP_PCL_BLOB_BLACK | OP_PCL_BLOB_TKEK |
+ OP_PCL_BLOB_EKT | OP_PCL_BLOB_REG_MASK | OP_PCL_BLOB_SEC_MEM,
+ OP_PCL_BLOB_FORMAT_MASK | OP_PCL_BLOB_BLACK | OP_PCL_BLOB_TKEK |
+ OP_PCL_BLOB_EKT | OP_PCL_BLOB_REG_MASK | OP_PCL_BLOB_SEC_MEM,
+ OP_PCL_BLOB_FORMAT_MASK | OP_PCL_BLOB_BLACK | OP_PCL_BLOB_TKEK |
+ OP_PCL_BLOB_EKT | OP_PCL_BLOB_REG_MASK | OP_PCL_BLOB_SEC_MEM,
+ OP_PCL_BLOB_FORMAT_MASK | OP_PCL_BLOB_BLACK | OP_PCL_BLOB_TKEK |
+ OP_PCL_BLOB_EKT | OP_PCL_BLOB_REG_MASK | OP_PCL_BLOB_SEC_MEM,
+ OP_PCL_BLOB_FORMAT_MASK | OP_PCL_BLOB_BLACK | OP_PCL_BLOB_TKEK |
+ OP_PCL_BLOB_EKT | OP_PCL_BLOB_REG_MASK | OP_PCL_BLOB_SEC_MEM
+};
+
+static inline int
+__rta_blob_proto(uint16_t protoinfo)
+{
+ if (protoinfo & ~proto_blob_flags[rta_sec_era])
+ return -EINVAL;
+
+ switch (protoinfo & OP_PCL_BLOB_FORMAT_MASK) {
+ case OP_PCL_BLOB_FORMAT_NORMAL:
+ case OP_PCL_BLOB_FORMAT_MASTER_VER:
+ case OP_PCL_BLOB_FORMAT_TEST:
+ break;
+ default:
+ return -EINVAL;
+ }
+
+ switch (protoinfo & OP_PCL_BLOB_REG_MASK) {
+ case OP_PCL_BLOB_AFHA_SBOX:
+ if (rta_sec_era < RTA_SEC_ERA_3)
+ return -EINVAL;
+ /* no break */
+ case OP_PCL_BLOB_REG_MEMORY:
+ case OP_PCL_BLOB_REG_KEY1:
+ case OP_PCL_BLOB_REG_KEY2:
+ case OP_PCL_BLOB_REG_SPLIT:
+ case OP_PCL_BLOB_REG_PKE:
+ return 0;
+ }
+
+ return -EINVAL;
+}
+
+static inline int
+__rta_dlc_proto(uint16_t protoinfo)
+{
+ if ((rta_sec_era < RTA_SEC_ERA_2) &&
+ (protoinfo & (OP_PCL_PKPROT_DSA_MSG | OP_PCL_PKPROT_HASH_MASK |
+ OP_PCL_PKPROT_EKT_Z | OP_PCL_PKPROT_DECRYPT_Z |
+ OP_PCL_PKPROT_DECRYPT_PRI)))
+ return -EINVAL;
+
+ switch (protoinfo & OP_PCL_PKPROT_HASH_MASK) {
+ case OP_PCL_PKPROT_HASH_MD5:
+ case OP_PCL_PKPROT_HASH_SHA1:
+ case OP_PCL_PKPROT_HASH_SHA224:
+ case OP_PCL_PKPROT_HASH_SHA256:
+ case OP_PCL_PKPROT_HASH_SHA384:
+ case OP_PCL_PKPROT_HASH_SHA512:
+ break;
+ default:
+ return -EINVAL;
+ }
+
+ return 0;
+}
+
+static inline int
+__rta_rsa_enc_proto(uint16_t protoinfo)
+{
+ switch (protoinfo & OP_PCL_RSAPROT_OP_MASK) {
+ case OP_PCL_RSAPROT_OP_ENC_F_IN:
+ if ((protoinfo & OP_PCL_RSAPROT_FFF_MASK) !=
+ OP_PCL_RSAPROT_FFF_RED)
+ return -EINVAL;
+ break;
+ case OP_PCL_RSAPROT_OP_ENC_F_OUT:
+ switch (protoinfo & OP_PCL_RSAPROT_FFF_MASK) {
+ case OP_PCL_RSAPROT_FFF_RED:
+ case OP_PCL_RSAPROT_FFF_ENC:
+ case OP_PCL_RSAPROT_FFF_EKT:
+ case OP_PCL_RSAPROT_FFF_TK_ENC:
+ case OP_PCL_RSAPROT_FFF_TK_EKT:
+ break;
+ default:
+ return -EINVAL;
+ }
+ break;
+ default:
+ return -EINVAL;
+ }
+
+ return 0;
+}
+
+static inline int
+__rta_rsa_dec_proto(uint16_t protoinfo)
+{
+ switch (protoinfo & OP_PCL_RSAPROT_OP_MASK) {
+ case OP_PCL_RSAPROT_OP_DEC_ND:
+ case OP_PCL_RSAPROT_OP_DEC_PQD:
+ case OP_PCL_RSAPROT_OP_DEC_PQDPDQC:
+ break;
+ default:
+ return -EINVAL;
+ }
+
+ switch (protoinfo & OP_PCL_RSAPROT_PPP_MASK) {
+ case OP_PCL_RSAPROT_PPP_RED:
+ case OP_PCL_RSAPROT_PPP_ENC:
+ case OP_PCL_RSAPROT_PPP_EKT:
+ case OP_PCL_RSAPROT_PPP_TK_ENC:
+ case OP_PCL_RSAPROT_PPP_TK_EKT:
+ break;
+ default:
+ return -EINVAL;
+ }
+
+ if (protoinfo & OP_PCL_RSAPROT_FMT_PKCSV15)
+ switch (protoinfo & OP_PCL_RSAPROT_FFF_MASK) {
+ case OP_PCL_RSAPROT_FFF_RED:
+ case OP_PCL_RSAPROT_FFF_ENC:
+ case OP_PCL_RSAPROT_FFF_EKT:
+ case OP_PCL_RSAPROT_FFF_TK_ENC:
+ case OP_PCL_RSAPROT_FFF_TK_EKT:
+ break;
+ default:
+ return -EINVAL;
+ }
+
+ return 0;
+}
+
+/*
+ * DKP Protocol - Restrictions on key (SRC,DST) combinations
+ * For e.g. key_in_out[0][0] = 1 means (SRC=IMM,DST=IMM) combination is allowed
+ */
+static const uint8_t key_in_out[4][4] = { {1, 0, 0, 0},
+ {1, 1, 1, 1},
+ {1, 0, 1, 0},
+ {1, 0, 0, 1} };
+
+static inline int
+__rta_dkp_proto(uint16_t protoinfo)
+{
+ int key_src = (protoinfo & OP_PCL_DKP_SRC_MASK) >> OP_PCL_DKP_SRC_SHIFT;
+ int key_dst = (protoinfo & OP_PCL_DKP_DST_MASK) >> OP_PCL_DKP_DST_SHIFT;
+
+ if (!key_in_out[key_src][key_dst]) {
+ pr_err("PROTO_DESC: Invalid DKP key (SRC,DST)\n");
+ return -EINVAL;
+ }
+
+ return 0;
+}
+
+
+static inline int
+__rta_3g_dcrc_proto(uint16_t protoinfo)
+{
+ if (rta_sec_era == RTA_SEC_ERA_7)
+ return -EINVAL;
+
+ switch (protoinfo) {
+ case OP_PCL_3G_DCRC_CRC7:
+ case OP_PCL_3G_DCRC_CRC11:
+ return 0;
+ }
+
+ return -EINVAL;
+}
+
+static inline int
+__rta_3g_rlc_proto(uint16_t protoinfo)
+{
+ if (rta_sec_era == RTA_SEC_ERA_7)
+ return -EINVAL;
+
+ switch (protoinfo) {
+ case OP_PCL_3G_RLC_NULL:
+ case OP_PCL_3G_RLC_KASUMI:
+ case OP_PCL_3G_RLC_SNOW:
+ return 0;
+ }
+
+ return -EINVAL;
+}
+
+static inline int
+__rta_lte_pdcp_proto(uint16_t protoinfo)
+{
+ if (rta_sec_era == RTA_SEC_ERA_7)
+ return -EINVAL;
+
+ switch (protoinfo) {
+ case OP_PCL_LTE_ZUC:
+ if (rta_sec_era < RTA_SEC_ERA_5)
+ break;
+ case OP_PCL_LTE_NULL:
+ case OP_PCL_LTE_SNOW:
+ case OP_PCL_LTE_AES:
+ return 0;
+ }
+
+ return -EINVAL;
+}
+
+static inline int
+__rta_lte_pdcp_mixed_proto(uint16_t protoinfo)
+{
+ switch (protoinfo & OP_PCL_LTE_MIXED_AUTH_MASK) {
+ case OP_PCL_LTE_MIXED_AUTH_NULL:
+ case OP_PCL_LTE_MIXED_AUTH_SNOW:
+ case OP_PCL_LTE_MIXED_AUTH_AES:
+ case OP_PCL_LTE_MIXED_AUTH_ZUC:
+ break;
+ default:
+ return -EINVAL;
+ }
+
+ switch (protoinfo & OP_PCL_LTE_MIXED_ENC_MASK) {
+ case OP_PCL_LTE_MIXED_ENC_NULL:
+ case OP_PCL_LTE_MIXED_ENC_SNOW:
+ case OP_PCL_LTE_MIXED_ENC_AES:
+ case OP_PCL_LTE_MIXED_ENC_ZUC:
+ return 0;
+ }
+
+ return -EINVAL;
+}
+
+struct proto_map {
+ uint32_t optype;
+ uint32_t protid;
+ int (*protoinfo_func)(uint16_t);
+};
+
+static const struct proto_map proto_table[] = {
+/*1*/ {OP_TYPE_UNI_PROTOCOL, OP_PCLID_SSL30_PRF, __rta_ssl_proto},
+ {OP_TYPE_UNI_PROTOCOL, OP_PCLID_TLS10_PRF, __rta_ssl_proto},
+ {OP_TYPE_UNI_PROTOCOL, OP_PCLID_TLS11_PRF, __rta_ssl_proto},
+ {OP_TYPE_UNI_PROTOCOL, OP_PCLID_TLS12_PRF, __rta_ssl_proto},
+ {OP_TYPE_UNI_PROTOCOL, OP_PCLID_DTLS_PRF, __rta_ssl_proto},
+ {OP_TYPE_UNI_PROTOCOL, OP_PCLID_IKEV1_PRF, __rta_ike_proto},
+ {OP_TYPE_UNI_PROTOCOL, OP_PCLID_IKEV2_PRF, __rta_ike_proto},
+ {OP_TYPE_UNI_PROTOCOL, OP_PCLID_PUBLICKEYPAIR, __rta_dlc_proto},
+ {OP_TYPE_UNI_PROTOCOL, OP_PCLID_DSASIGN, __rta_dlc_proto},
+ {OP_TYPE_UNI_PROTOCOL, OP_PCLID_DSAVERIFY, __rta_dlc_proto},
+ {OP_TYPE_DECAP_PROTOCOL, OP_PCLID_IPSEC, __rta_ipsec_proto},
+ {OP_TYPE_DECAP_PROTOCOL, OP_PCLID_SRTP, __rta_srtp_proto},
+ {OP_TYPE_DECAP_PROTOCOL, OP_PCLID_SSL30, __rta_ssl_proto},
+ {OP_TYPE_DECAP_PROTOCOL, OP_PCLID_TLS10, __rta_ssl_proto},
+ {OP_TYPE_DECAP_PROTOCOL, OP_PCLID_TLS11, __rta_ssl_proto},
+ {OP_TYPE_DECAP_PROTOCOL, OP_PCLID_TLS12, __rta_ssl_proto},
+ {OP_TYPE_DECAP_PROTOCOL, OP_PCLID_DTLS, __rta_ssl_proto},
+ {OP_TYPE_DECAP_PROTOCOL, OP_PCLID_MACSEC, __rta_macsec_proto},
+ {OP_TYPE_DECAP_PROTOCOL, OP_PCLID_WIFI, __rta_wifi_proto},
+ {OP_TYPE_DECAP_PROTOCOL, OP_PCLID_WIMAX, __rta_wimax_proto},
+/*21*/ {OP_TYPE_DECAP_PROTOCOL, OP_PCLID_BLOB, __rta_blob_proto},
+ {OP_TYPE_UNI_PROTOCOL, OP_PCLID_DIFFIEHELLMAN, __rta_dlc_proto},
+ {OP_TYPE_UNI_PROTOCOL, OP_PCLID_RSAENCRYPT, __rta_rsa_enc_proto},
+ {OP_TYPE_UNI_PROTOCOL, OP_PCLID_RSADECRYPT, __rta_rsa_dec_proto},
+ {OP_TYPE_DECAP_PROTOCOL, OP_PCLID_3G_DCRC, __rta_3g_dcrc_proto},
+ {OP_TYPE_DECAP_PROTOCOL, OP_PCLID_3G_RLC_PDU, __rta_3g_rlc_proto},
+ {OP_TYPE_DECAP_PROTOCOL, OP_PCLID_3G_RLC_SDU, __rta_3g_rlc_proto},
+ {OP_TYPE_DECAP_PROTOCOL, OP_PCLID_LTE_PDCP_USER, __rta_lte_pdcp_proto},
+/*29*/ {OP_TYPE_DECAP_PROTOCOL, OP_PCLID_LTE_PDCP_CTRL, __rta_lte_pdcp_proto},
+ {OP_TYPE_UNI_PROTOCOL, OP_PCLID_DKP_MD5, __rta_dkp_proto},
+ {OP_TYPE_UNI_PROTOCOL, OP_PCLID_DKP_SHA1, __rta_dkp_proto},
+ {OP_TYPE_UNI_PROTOCOL, OP_PCLID_DKP_SHA224, __rta_dkp_proto},
+ {OP_TYPE_UNI_PROTOCOL, OP_PCLID_DKP_SHA256, __rta_dkp_proto},
+ {OP_TYPE_UNI_PROTOCOL, OP_PCLID_DKP_SHA384, __rta_dkp_proto},
+/*35*/ {OP_TYPE_UNI_PROTOCOL, OP_PCLID_DKP_SHA512, __rta_dkp_proto},
+ {OP_TYPE_DECAP_PROTOCOL, OP_PCLID_PUBLICKEYPAIR, __rta_dlc_proto},
+/*37*/ {OP_TYPE_DECAP_PROTOCOL, OP_PCLID_DSASIGN, __rta_dlc_proto},
+/*38*/ {OP_TYPE_DECAP_PROTOCOL, OP_PCLID_LTE_PDCP_CTRL_MIXED,
+ __rta_lte_pdcp_mixed_proto},
+ {OP_TYPE_DECAP_PROTOCOL, OP_PCLID_IPSEC_NEW, __rta_ipsec_proto},
+/*40*/ {OP_TYPE_DECAP_PROTOCOL, OP_PCLID_LTE_PDCP_USER_RN,
+ __rta_lte_pdcp_mixed_proto},
+};
+
+/*
+ * Allowed OPERATION protocols for each SEC Era.
+ * Values represent the number of entries from proto_table[] that are supported.
+ */
+static const unsigned int proto_table_sz[] = {21, 29, 29, 29, 29, 35, 37,
+ 40, 40, 40};
+
+static inline int
+rta_proto_operation(struct program *program, uint32_t optype,
+ uint32_t protid, uint16_t protoinfo)
+{
+ uint32_t opcode = CMD_OPERATION;
+ unsigned int i, found = 0;
+ uint32_t optype_tmp = optype;
+ unsigned int start_pc = program->current_pc;
+ int ret = -EINVAL;
+
+ for (i = 0; i < proto_table_sz[rta_sec_era]; i++) {
+ /* clear last bit in optype to match also decap proto */
+ optype_tmp &= (uint32_t)~(1 << OP_TYPE_SHIFT);
+ if (optype_tmp == proto_table[i].optype) {
+ if (proto_table[i].protid == protid) {
+ /* nothing else to verify */
+ if (proto_table[i].protoinfo_func == NULL) {
+ found = 1;
+ break;
+ }
+ /* check protoinfo */
+ ret = (*proto_table[i].protoinfo_func)
+ (protoinfo);
+ if (ret < 0) {
+ pr_err("PROTO_DESC: Bad PROTO Type. SEC Program Line: %d\n",
+ program->current_pc);
+ goto err;
+ }
+ found = 1;
+ break;
+ }
+ }
+ }
+ if (!found) {
+ pr_err("PROTO_DESC: Operation Type Mismatch. SEC Program Line: %d\n",
+ program->current_pc);
+ goto err;
+ }
+
+ __rta_out32(program, opcode | optype | protid | protoinfo);
+ program->current_instruction++;
+ return (int)start_pc;
+
+ err:
+ program->first_error_pc = start_pc;
+ program->current_instruction++;
+ return ret;
+}
+
+static inline int
+rta_dkp_proto(struct program *program, uint32_t protid,
+ uint16_t key_src, uint16_t key_dst,
+ uint16_t keylen, uint64_t key,
+ enum rta_data_type key_type)
+{
+ unsigned int start_pc = program->current_pc;
+ unsigned int in_words = 0, out_words = 0;
+ int ret;
+
+ key_src &= OP_PCL_DKP_SRC_MASK;
+ key_dst &= OP_PCL_DKP_DST_MASK;
+ keylen &= OP_PCL_DKP_KEY_MASK;
+
+ ret = rta_proto_operation(program, OP_TYPE_UNI_PROTOCOL, protid,
+ key_src | key_dst | keylen);
+ if (ret < 0)
+ return ret;
+
+ if ((key_src == OP_PCL_DKP_SRC_PTR) ||
+ (key_src == OP_PCL_DKP_SRC_SGF)) {
+ __rta_out64(program, program->ps, key);
+ in_words = program->ps ? 2 : 1;
+ } else if (key_src == OP_PCL_DKP_SRC_IMM) {
+ __rta_inline_data(program, key, inline_flags(key_type), keylen);
+ in_words = (unsigned int)((keylen + 3) / 4);
+ }
+
+ if ((key_dst == OP_PCL_DKP_DST_PTR) ||
+ (key_dst == OP_PCL_DKP_DST_SGF)) {
+ out_words = in_words;
+ } else if (key_dst == OP_PCL_DKP_DST_IMM) {
+ out_words = split_key_len(protid) / 4;
+ }
+
+ if (out_words < in_words) {
+ pr_err("PROTO_DESC: DKP doesn't currently support a smaller descriptor\n");
+ program->first_error_pc = start_pc;
+ return -EINVAL;
+ }
+
+ /* If needed, reserve space in resulting descriptor for derived key */
+ program->current_pc += (out_words - in_words);
+
+ return (int)start_pc;
+}
+
+#endif /* __RTA_PROTOCOL_CMD_H__ */
--- /dev/null
+/* SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0)
+ *
+ * Copyright 2008-2016 Freescale Semiconductor Inc.
+ * Copyright 2016,2019 NXP
+ */
+
+#ifndef __RTA_SEC_RUN_TIME_ASM_H__
+#define __RTA_SEC_RUN_TIME_ASM_H__
+
+#include "desc.h"
+
+/* hw/compat.h is not delivered in kernel */
+#ifndef __KERNEL__
+#include "compat.h"
+#endif
+
+/**
+ * enum rta_sec_era - SEC HW block revisions supported by the RTA library
+ * @RTA_SEC_ERA_1: SEC Era 1
+ * @RTA_SEC_ERA_2: SEC Era 2
+ * @RTA_SEC_ERA_3: SEC Era 3
+ * @RTA_SEC_ERA_4: SEC Era 4
+ * @RTA_SEC_ERA_5: SEC Era 5
+ * @RTA_SEC_ERA_6: SEC Era 6
+ * @RTA_SEC_ERA_7: SEC Era 7
+ * @RTA_SEC_ERA_8: SEC Era 8
+ * @MAX_SEC_ERA: maximum SEC HW block revision supported by RTA library
+ */
+enum rta_sec_era {
+ RTA_SEC_ERA_1,
+ RTA_SEC_ERA_2,
+ RTA_SEC_ERA_3,
+ RTA_SEC_ERA_4,
+ RTA_SEC_ERA_5,
+ RTA_SEC_ERA_6,
+ RTA_SEC_ERA_7,
+ RTA_SEC_ERA_8,
+ RTA_SEC_ERA_9,
+ RTA_SEC_ERA_10,
+ MAX_SEC_ERA = RTA_SEC_ERA_10
+};
+
+/**
+ * DEFAULT_SEC_ERA - the default value for the SEC era in case the user provides
+ * an unsupported value.
+ */
+#define DEFAULT_SEC_ERA MAX_SEC_ERA
+
+/**
+ * USER_SEC_ERA - translates the SEC Era from internal to user representation.
+ * @sec_era: SEC Era in internal (library) representation
+ */
+#define USER_SEC_ERA(sec_era) (sec_era + 1)
+
+/**
+ * INTL_SEC_ERA - translates the SEC Era from user representation to internal.
+ * @sec_era: SEC Era in user representation
+ */
+#define INTL_SEC_ERA(sec_era) (sec_era - 1)
+
+/**
+ * enum rta_jump_type - Types of action taken by JUMP command
+ * @LOCAL_JUMP: conditional jump to an offset within the descriptor buffer
+ * @FAR_JUMP: conditional jump to a location outside the descriptor buffer,
+ * indicated by the POINTER field after the JUMP command.
+ * @HALT: conditional halt - stop the execution of the current descriptor and
+ * writes PKHA / Math condition bits as status / error code.
+ * @HALT_STATUS: conditional halt with user-specified status - stop the
+ * execution of the current descriptor and writes the value of
+ * "LOCAL OFFSET" JUMP field as status / error code.
+ * @GOSUB: conditional subroutine call - similar to @LOCAL_JUMP, but also saves
+ * return address in the Return Address register; subroutine calls
+ * cannot be nested.
+ * @RETURN: conditional subroutine return - similar to @LOCAL_JUMP, but the
+ * offset is taken from the Return Address register.
+ * @LOCAL_JUMP_INC: similar to @LOCAL_JUMP, but increment the register specified
+ * in "SRC_DST" JUMP field before evaluating the jump
+ * condition.
+ * @LOCAL_JUMP_DEC: similar to @LOCAL_JUMP, but decrement the register specified
+ * in "SRC_DST" JUMP field before evaluating the jump
+ * condition.
+ */
+enum rta_jump_type {
+ LOCAL_JUMP,
+ FAR_JUMP,
+ HALT,
+ HALT_STATUS,
+ GOSUB,
+ RETURN,
+ LOCAL_JUMP_INC,
+ LOCAL_JUMP_DEC
+};
+
+/**
+ * enum rta_jump_cond - How test conditions are evaluated by JUMP command
+ * @ALL_TRUE: perform action if ALL selected conditions are true
+ * @ALL_FALSE: perform action if ALL selected conditions are false
+ * @ANY_TRUE: perform action if ANY of the selected conditions is true
+ * @ANY_FALSE: perform action if ANY of the selected conditions is false
+ */
+enum rta_jump_cond {
+ ALL_TRUE,
+ ALL_FALSE,
+ ANY_TRUE,
+ ANY_FALSE
+};
+
+/**
+ * enum rta_share_type - Types of sharing for JOB_HDR and SHR_HDR commands
+ * @SHR_NEVER: nothing is shared; descriptors can execute in parallel (i.e. no
+ * dependencies are allowed between them).
+ * @SHR_WAIT: shared descriptor and keys are shared once the descriptor sets
+ * "OK to share" in DECO Control Register (DCTRL).
+ * @SHR_SERIAL: shared descriptor and keys are shared once the descriptor has
+ * completed.
+ * @SHR_ALWAYS: shared descriptor is shared anytime after the descriptor is
+ * loaded.
+ * @SHR_DEFER: valid only for JOB_HDR; sharing type is the one specified
+ * in the shared descriptor associated with the job descriptor.
+ */
+enum rta_share_type {
+ SHR_NEVER,
+ SHR_WAIT,
+ SHR_SERIAL,
+ SHR_ALWAYS,
+ SHR_DEFER
+};
+
+/**
+ * enum rta_data_type - Indicates how is the data provided and how to include it
+ * in the descriptor.
+ * @RTA_DATA_PTR: Data is in memory and accessed by reference; data address is a
+ * physical (bus) address.
+ * @RTA_DATA_IMM: Data is inlined in descriptor and accessed as immediate data;
+ * data address is a virtual address.
+ * @RTA_DATA_IMM_DMA: (AIOP only) Data is inlined in descriptor and accessed as
+ * immediate data; data address is a physical (bus) address
+ * in external memory and CDMA is programmed to transfer the
+ * data into descriptor buffer being built in Workspace Area.
+ */
+enum rta_data_type {
+ RTA_DATA_PTR = 1,
+ RTA_DATA_IMM,
+ RTA_DATA_IMM_DMA
+};
+
+/* Registers definitions */
+enum rta_regs {
+ /* CCB Registers */
+ CONTEXT1 = 1,
+ CONTEXT2,
+ KEY1,
+ KEY2,
+ KEY1SZ,
+ KEY2SZ,
+ ICV1SZ,
+ ICV2SZ,
+ DATA1SZ,
+ DATA2SZ,
+ ALTDS1,
+ IV1SZ,
+ AAD1SZ,
+ MODE1,
+ MODE2,
+ CCTRL,
+ DCTRL,
+ ICTRL,
+ CLRW,
+ CSTAT,
+ IFIFO,
+ NFIFO,
+ OFIFO,
+ PKASZ,
+ PKBSZ,
+ PKNSZ,
+ PKESZ,
+ /* DECO Registers */
+ MATH0,
+ MATH1,
+ MATH2,
+ MATH3,
+ DESCBUF,
+ JOBDESCBUF,
+ SHAREDESCBUF,
+ DPOVRD,
+ DJQDA,
+ DSTAT,
+ DPID,
+ DJQCTRL,
+ ALTSOURCE,
+ SEQINSZ,
+ SEQOUTSZ,
+ VSEQINSZ,
+ VSEQOUTSZ,
+ /* PKHA Registers */
+ PKA,
+ PKN,
+ PKA0,
+ PKA1,
+ PKA2,
+ PKA3,
+ PKB,
+ PKB0,
+ PKB1,
+ PKB2,
+ PKB3,
+ PKE,
+ /* Pseudo registers */
+ AB1,
+ AB2,
+ ABD,
+ IFIFOABD,
+ IFIFOAB1,
+ IFIFOAB2,
+ AFHA_SBOX,
+ MDHA_SPLIT_KEY,
+ JOBSRC,
+ ZERO,
+ ONE,
+ AAD1,
+ IV1,
+ IV2,
+ MSG1,
+ MSG2,
+ MSG,
+ MSG_CKSUM,
+ MSGOUTSNOOP,
+ MSGINSNOOP,
+ ICV1,
+ ICV2,
+ SKIP,
+ NONE,
+ RNGOFIFO,
+ RNG,
+ IDFNS,
+ ODFNS,
+ NFIFOSZ,
+ SZ,
+ PAD,
+ SAD1,
+ AAD2,
+ BIT_DATA,
+ NFIFO_SZL,
+ NFIFO_SZM,
+ NFIFO_L,
+ NFIFO_M,
+ SZL,
+ SZM,
+ JOBDESCBUF_EFF,
+ SHAREDESCBUF_EFF,
+ METADATA,
+ GTR,
+ STR,
+ OFIFO_SYNC,
+ MSGOUTSNOOP_ALT
+};
+
+/* Command flags */
+#define FLUSH1 BIT(0)
+#define LAST1 BIT(1)
+#define LAST2 BIT(2)
+#define IMMED BIT(3)
+#define SGF BIT(4)
+#define VLF BIT(5)
+#define EXT BIT(6)
+#define CONT BIT(7)
+#define SEQ BIT(8)
+#define AIDF BIT(9)
+#define FLUSH2 BIT(10)
+#define CLASS1 BIT(11)
+#define CLASS2 BIT(12)
+#define BOTH BIT(13)
+
+/**
+ * DCOPY - (AIOP only) command param is pointer to external memory
+ *
+ * CDMA must be used to transfer the key via DMA into Workspace Area.
+ * Valid only in combination with IMMED flag.
+ */
+#define DCOPY BIT(30)
+
+#define COPY BIT(31) /* command param is pointer (not immediate)
+ * valid only in combination when IMMED
+ */
+
+#define __COPY_MASK (COPY | DCOPY)
+
+/* SEQ IN/OUT PTR Command specific flags */
+#define RBS BIT(16)
+#define INL BIT(17)
+#define PRE BIT(18)
+#define RTO BIT(19)
+#define RJD BIT(20)
+#define SOP BIT(21)
+#define RST BIT(22)
+#define EWS BIT(23)
+
+#define ENC BIT(14) /* Encrypted Key */
+#define EKT BIT(15) /* AES CCM Encryption (default is
+ * AES ECB Encryption)
+ */
+#define TK BIT(16) /* Trusted Descriptor Key (default is
+ * Job Descriptor Key)
+ */
+#define NWB BIT(17) /* No Write Back Key */
+#define PTS BIT(18) /* Plaintext Store */
+
+/* HEADER Command specific flags */
+#define RIF BIT(16)
+#define DNR BIT(17)
+#define CIF BIT(18)
+#define PD BIT(19)
+#define RSMS BIT(20)
+#define TD BIT(21)
+#define MTD BIT(22)
+#define REO BIT(23)
+#define SHR BIT(24)
+#define SC BIT(25)
+/* Extended HEADER specific flags */
+#define DSV BIT(7)
+#define DSEL_MASK 0x00000007 /* DECO Select */
+#define FTD BIT(8)
+
+/* JUMP Command specific flags */
+#define NIFP BIT(20)
+#define NIP BIT(21)
+#define NOP BIT(22)
+#define NCP BIT(23)
+#define CALM BIT(24)
+
+#define MATH_Z BIT(25)
+#define MATH_N BIT(26)
+#define MATH_NV BIT(27)
+#define MATH_C BIT(28)
+#define PK_0 BIT(29)
+#define PK_GCD_1 BIT(30)
+#define PK_PRIME BIT(31)
+#define SELF BIT(0)
+#define SHRD BIT(1)
+#define JQP BIT(2)
+
+/* NFIFOADD specific flags */
+#define PAD_ZERO BIT(16)
+#define PAD_NONZERO BIT(17)
+#define PAD_INCREMENT BIT(18)
+#define PAD_RANDOM BIT(19)
+#define PAD_ZERO_N1 BIT(20)
+#define PAD_NONZERO_0 BIT(21)
+#define PAD_N1 BIT(23)
+#define PAD_NONZERO_N BIT(24)
+#define OC BIT(25)
+#define BM BIT(26)
+#define PR BIT(27)
+#define PS BIT(28)
+#define BP BIT(29)
+
+/* MOVE Command specific flags */
+#define WAITCOMP BIT(16)
+#define SIZE_WORD BIT(17)
+#define SIZE_BYTE BIT(18)
+#define SIZE_DWORD BIT(19)
+
+/* MATH command specific flags */
+#define IFB MATH_IFB
+#define NFU MATH_NFU
+#define STL MATH_STL
+#define SSEL MATH_SSEL
+#define SWP MATH_SWP
+#define IMMED2 BIT(31)
+
+/**
+ * struct program - descriptor buffer management structure
+ * @current_pc: current offset in descriptor
+ * @current_instruction: current instruction in descriptor
+ * @first_error_pc: offset of the first error in descriptor
+ * @start_pc: start offset in descriptor buffer
+ * @buffer: buffer carrying descriptor
+ * @shrhdr: shared descriptor header
+ * @jobhdr: job descriptor header
+ * @ps: pointer fields size; if ps is true, pointers will be 36bits in
+ * length; if ps is false, pointers will be 32bits in length
+ * @bswap: if true, perform byte swap on a 4-byte boundary
+ */
+struct program {
+ unsigned int current_pc;
+ unsigned int current_instruction;
+ unsigned int first_error_pc;
+ unsigned int start_pc;
+ uint32_t *buffer;
+ uint32_t *shrhdr;
+ uint32_t *jobhdr;
+ bool ps;
+ bool bswap;
+};
+
+static inline void
+rta_program_cntxt_init(struct program *program,
+ uint32_t *buffer, unsigned int offset)
+{
+ program->current_pc = 0;
+ program->current_instruction = 0;
+ program->first_error_pc = 0;
+ program->start_pc = offset;
+ program->buffer = buffer;
+ program->shrhdr = NULL;
+ program->jobhdr = NULL;
+ program->ps = false;
+ program->bswap = false;
+}
+
+static inline int
+rta_program_finalize(struct program *program)
+{
+ /* Descriptor is usually not allowed to go beyond 64 words size */
+ if (program->current_pc > MAX_CAAM_DESCSIZE)
+ pr_warn("Descriptor Size exceeded max limit of 64 words\n");
+
+ /* Descriptor is erroneous */
+ if (program->first_error_pc) {
+ pr_err("Descriptor creation error\n");
+ return -EINVAL;
+ }
+
+ /* Update descriptor length in shared and job descriptor headers */
+ if (program->shrhdr != NULL)
+ *program->shrhdr |= program->bswap ?
+ swab32(program->current_pc) :
+ program->current_pc;
+ else if (program->jobhdr != NULL)
+ *program->jobhdr |= program->bswap ?
+ swab32(program->current_pc) :
+ program->current_pc;
+
+ return (int)program->current_pc;
+}
+
+static inline unsigned int
+rta_program_set_36bit_addr(struct program *program)
+{
+ program->ps = true;
+ return program->current_pc;
+}
+
+static inline unsigned int
+rta_program_set_bswap(struct program *program)
+{
+ program->bswap = true;
+ return program->current_pc;
+}
+
+static inline void
+__rta_out32(struct program *program, uint32_t val)
+{
+ program->buffer[program->current_pc] = program->bswap ?
+ swab32(val) : val;
+ program->current_pc++;
+}
+
+static inline void
+__rta_out_be32(struct program *program, uint32_t val)
+{
+ program->buffer[program->current_pc] = cpu_to_be32(val);
+ program->current_pc++;
+}
+
+static inline void
+__rta_out_le32(struct program *program, uint32_t val)
+{
+ program->buffer[program->current_pc] = cpu_to_le32(val);
+ program->current_pc++;
+}
+
+static inline void
+__rta_out64(struct program *program, bool is_ext, uint64_t val)
+{
+ if (is_ext) {
+ /*
+ * Since we are guaranteed only a 4-byte alignment in the
+ * descriptor buffer, we have to do 2 x 32-bit (word) writes.
+ * For the order of the 2 words to be correct, we need to
+ * take into account the endianness of the CPU.
+ */
+#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+ __rta_out32(program, program->bswap ? lower_32_bits(val) :
+ upper_32_bits(val));
+
+ __rta_out32(program, program->bswap ? upper_32_bits(val) :
+ lower_32_bits(val));
+#else
+ __rta_out32(program, program->bswap ? upper_32_bits(val) :
+ lower_32_bits(val));
+
+ __rta_out32(program, program->bswap ? lower_32_bits(val) :
+ upper_32_bits(val));
+#endif
+ } else {
+ __rta_out32(program, lower_32_bits(val));
+ }
+}
+
+static inline void __rta_out_be64(struct program *program, bool is_ext,
+ uint64_t val)
+{
+ if (is_ext) {
+ __rta_out_be32(program, upper_32_bits(val));
+ __rta_out_be32(program, lower_32_bits(val));
+ } else {
+ __rta_out_be32(program, lower_32_bits(val));
+ }
+}
+
+static inline void __rta_out_le64(struct program *program, bool is_ext,
+ uint64_t val)
+{
+ if (is_ext) {
+ __rta_out_le32(program, lower_32_bits(val));
+ __rta_out_le32(program, upper_32_bits(val));
+ } else {
+ __rta_out_le32(program, lower_32_bits(val));
+ }
+}
+
+static inline unsigned int
+rta_word(struct program *program, uint32_t val)
+{
+ unsigned int start_pc = program->current_pc;
+
+ __rta_out32(program, val);
+
+ return start_pc;
+}
+
+static inline unsigned int
+rta_dword(struct program *program, uint64_t val)
+{
+ unsigned int start_pc = program->current_pc;
+
+ __rta_out64(program, true, val);
+
+ return start_pc;
+}
+
+static inline uint32_t
+inline_flags(enum rta_data_type data_type)
+{
+ switch (data_type) {
+ case RTA_DATA_PTR:
+ return 0;
+ case RTA_DATA_IMM:
+ return IMMED | COPY;
+ case RTA_DATA_IMM_DMA:
+ return IMMED | DCOPY;
+ default:
+ /* warn and default to RTA_DATA_PTR */
+ pr_warn("RTA: defaulting to RTA_DATA_PTR parameter type\n");
+ return 0;
+ }
+}
+
+static inline unsigned int
+rta_copy_data(struct program *program, uint8_t *data, unsigned int length)
+{
+ unsigned int i;
+ unsigned int start_pc = program->current_pc;
+ uint8_t *tmp = (uint8_t *)&program->buffer[program->current_pc];
+
+ for (i = 0; i < length; i++)
+ *tmp++ = data[i];
+ program->current_pc += (length + 3) / 4;
+
+ return start_pc;
+}
+
+#if defined(__EWL__) && defined(AIOP)
+static inline void
+__rta_dma_data(void *ws_dst, uint64_t ext_address, uint16_t size)
+{ cdma_read(ws_dst, ext_address, size); }
+#else
+static inline void
+__rta_dma_data(void *ws_dst __maybe_unused,
+ uint64_t ext_address __maybe_unused,
+ uint16_t size __maybe_unused)
+{ pr_warn("RTA: DCOPY not supported, DMA will be skipped\n"); }
+#endif /* defined(__EWL__) && defined(AIOP) */
+
+static inline void
+__rta_inline_data(struct program *program, uint64_t data,
+ uint32_t copy_data, uint32_t length)
+{
+ if (!copy_data) {
+ __rta_out64(program, length > 4, data);
+ } else if (copy_data & COPY) {
+ uint8_t *tmp = (uint8_t *)&program->buffer[program->current_pc];
+ uint32_t i;
+
+ for (i = 0; i < length; i++)
+ *tmp++ = ((uint8_t *)(uintptr_t)data)[i];
+ program->current_pc += ((length + 3) / 4);
+ } else if (copy_data & DCOPY) {
+ __rta_dma_data(&program->buffer[program->current_pc], data,
+ (uint16_t)length);
+ program->current_pc += ((length + 3) / 4);
+ }
+}
+
+static inline unsigned int
+rta_desc_len(uint32_t *buffer)
+{
+ if ((*buffer & CMD_MASK) == CMD_DESC_HDR) {
+ return *buffer & HDR_DESCLEN_MASK;
+ } else {
+ if (rta_sec_era >= RTA_SEC_ERA_10)
+ return *buffer & HDR_DESCLEN_SHR_MASK_ERA10;
+ else
+ return *buffer & HDR_DESCLEN_SHR_MASK;
+ }
+}
+
+static inline unsigned int
+rta_desc_bytes(uint32_t *buffer)
+{
+ return (unsigned int)(rta_desc_len(buffer) * CAAM_CMD_SZ);
+}
+
+/**
+ * split_key_len - Compute MDHA split key length for a given algorithm
+ * @hash: Hashing algorithm selection, one of OP_ALG_ALGSEL_* or
+ * OP_PCLID_DKP_* - MD5, SHA1, SHA224, SHA256, SHA384, SHA512.
+ *
+ * Return: MDHA split key length
+ */
+static inline uint32_t
+split_key_len(uint32_t hash)
+{
+ /* Sizes for MDHA pads (*not* keys): MD5, SHA1, 224, 256, 384, 512 */
+ static const uint8_t mdpadlen[] = { 16, 20, 32, 32, 64, 64 };
+ uint32_t idx;
+
+ idx = (hash & OP_ALG_ALGSEL_SUBMASK) >> OP_ALG_ALGSEL_SHIFT;
+
+ return (uint32_t)(mdpadlen[idx] * 2);
+}
+
+/**
+ * split_key_pad_len - Compute MDHA split key pad length for a given algorithm
+ * @hash: Hashing algorithm selection, one of OP_ALG_ALGSEL_* - MD5, SHA1,
+ * SHA224, SHA384, SHA512.
+ *
+ * Return: MDHA split key pad length
+ */
+static inline uint32_t
+split_key_pad_len(uint32_t hash)
+{
+ return ALIGN(split_key_len(hash), 16);
+}
+
+static inline unsigned int
+rta_set_label(struct program *program)
+{
+ return program->current_pc + program->start_pc;
+}
+
+static inline int
+rta_patch_move(struct program *program, int line, unsigned int new_ref)
+{
+ uint32_t opcode;
+ bool bswap = program->bswap;
+
+ if (line < 0)
+ return -EINVAL;
+
+ opcode = bswap ? swab32(program->buffer[line]) : program->buffer[line];
+
+ opcode &= (uint32_t)~MOVE_OFFSET_MASK;
+ opcode |= (new_ref << (MOVE_OFFSET_SHIFT + 2)) & MOVE_OFFSET_MASK;
+ program->buffer[line] = bswap ? swab32(opcode) : opcode;
+
+ return 0;
+}
+
+static inline int
+rta_patch_jmp(struct program *program, int line, unsigned int new_ref)
+{
+ uint32_t opcode;
+ bool bswap = program->bswap;
+
+ if (line < 0)
+ return -EINVAL;
+
+ opcode = bswap ? swab32(program->buffer[line]) : program->buffer[line];
+
+ opcode &= (uint32_t)~JUMP_OFFSET_MASK;
+ opcode |= (new_ref - (line + program->start_pc)) & JUMP_OFFSET_MASK;
+ program->buffer[line] = bswap ? swab32(opcode) : opcode;
+
+ return 0;
+}
+
+static inline int
+rta_patch_header(struct program *program, int line, unsigned int new_ref)
+{
+ uint32_t opcode;
+ bool bswap = program->bswap;
+
+ if (line < 0)
+ return -EINVAL;
+
+ opcode = bswap ? swab32(program->buffer[line]) : program->buffer[line];
+ if (rta_sec_era >= RTA_SEC_ERA_10) {
+ opcode &= (uint32_t)~HDR_START_IDX_MASK_ERA10;
+ opcode |= (new_ref << HDR_START_IDX_SHIFT) &
+ HDR_START_IDX_MASK_ERA10;
+ } else {
+ opcode &= (uint32_t)~HDR_START_IDX_MASK;
+ opcode |= (new_ref << HDR_START_IDX_SHIFT) & HDR_START_IDX_MASK;
+ }
+
+ program->buffer[line] = bswap ? swab32(opcode) : opcode;
+
+ return 0;
+}
+
+static inline int
+rta_patch_load(struct program *program, int line, unsigned int new_ref)
+{
+ uint32_t opcode;
+ bool bswap = program->bswap;
+
+ if (line < 0)
+ return -EINVAL;
+
+ opcode = (bswap ? swab32(program->buffer[line]) :
+ program->buffer[line]) & (uint32_t)~LDST_OFFSET_MASK;
+
+ if (opcode & (LDST_SRCDST_WORD_DESCBUF | LDST_CLASS_DECO))
+ opcode |= (new_ref << LDST_OFFSET_SHIFT) & LDST_OFFSET_MASK;
+ else
+ opcode |= (new_ref << (LDST_OFFSET_SHIFT + 2)) &
+ LDST_OFFSET_MASK;
+
+ program->buffer[line] = bswap ? swab32(opcode) : opcode;
+
+ return 0;
+}
+
+static inline int
+rta_patch_store(struct program *program, int line, unsigned int new_ref)
+{
+ uint32_t opcode;
+ bool bswap = program->bswap;
+
+ if (line < 0)
+ return -EINVAL;
+
+ opcode = bswap ? swab32(program->buffer[line]) : program->buffer[line];
+
+ opcode &= (uint32_t)~LDST_OFFSET_MASK;
+
+ switch (opcode & LDST_SRCDST_MASK) {
+ case LDST_SRCDST_WORD_DESCBUF:
+ case LDST_SRCDST_WORD_DESCBUF_JOB:
+ case LDST_SRCDST_WORD_DESCBUF_SHARED:
+ case LDST_SRCDST_WORD_DESCBUF_JOB_WE:
+ case LDST_SRCDST_WORD_DESCBUF_SHARED_WE:
+ opcode |= ((new_ref) << LDST_OFFSET_SHIFT) & LDST_OFFSET_MASK;
+ break;
+ default:
+ opcode |= (new_ref << (LDST_OFFSET_SHIFT + 2)) &
+ LDST_OFFSET_MASK;
+ }
+
+ program->buffer[line] = bswap ? swab32(opcode) : opcode;
+
+ return 0;
+}
+
+static inline int
+rta_patch_raw(struct program *program, int line, unsigned int mask,
+ unsigned int new_val)
+{
+ uint32_t opcode;
+ bool bswap = program->bswap;
+
+ if (line < 0)
+ return -EINVAL;
+
+ opcode = bswap ? swab32(program->buffer[line]) : program->buffer[line];
+
+ opcode &= (uint32_t)~mask;
+ opcode |= new_val & mask;
+ program->buffer[line] = bswap ? swab32(opcode) : opcode;
+
+ return 0;
+}
+
+static inline int
+__rta_map_opcode(uint32_t name, const uint32_t (*map_table)[2],
+ unsigned int num_of_entries, uint32_t *val)
+{
+ unsigned int i;
+
+ for (i = 0; i < num_of_entries; i++)
+ if (map_table[i][0] == name) {
+ *val = map_table[i][1];
+ return 0;
+ }
+
+ return -EINVAL;
+}
+
+static inline void
+__rta_map_flags(uint32_t flags, const uint32_t (*flags_table)[2],
+ unsigned int num_of_entries, uint32_t *opcode)
+{
+ unsigned int i;
+
+ for (i = 0; i < num_of_entries; i++) {
+ if (flags_table[i][0] & flags)
+ *opcode |= flags_table[i][1];
+ }
+}
+
+#endif /* __RTA_SEC_RUN_TIME_ASM_H__ */
--- /dev/null
+/* SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0)
+ *
+ * Copyright 2008-2016 Freescale Semiconductor Inc.
+ * Copyright 2016,2019 NXP
+ */
+
+#ifndef __RTA_SEQ_IN_OUT_PTR_CMD_H__
+#define __RTA_SEQ_IN_OUT_PTR_CMD_H__
+
+extern enum rta_sec_era rta_sec_era;
+
+/* Allowed SEQ IN PTR flags for each SEC Era. */
+static const uint32_t seq_in_ptr_flags[] = {
+ RBS | INL | SGF | PRE | EXT | RTO,
+ RBS | INL | SGF | PRE | EXT | RTO | RJD,
+ RBS | INL | SGF | PRE | EXT | RTO | RJD,
+ RBS | INL | SGF | PRE | EXT | RTO | RJD,
+ RBS | INL | SGF | PRE | EXT | RTO | RJD | SOP,
+ RBS | INL | SGF | PRE | EXT | RTO | RJD | SOP,
+ RBS | INL | SGF | PRE | EXT | RTO | RJD | SOP,
+ RBS | INL | SGF | PRE | EXT | RTO | RJD | SOP,
+ RBS | INL | SGF | PRE | EXT | RTO | RJD | SOP,
+ RBS | INL | SGF | PRE | EXT | RTO | RJD | SOP
+};
+
+/* Allowed SEQ OUT PTR flags for each SEC Era. */
+static const uint32_t seq_out_ptr_flags[] = {
+ SGF | PRE | EXT,
+ SGF | PRE | EXT | RTO,
+ SGF | PRE | EXT | RTO,
+ SGF | PRE | EXT | RTO,
+ SGF | PRE | EXT | RTO | RST | EWS,
+ SGF | PRE | EXT | RTO | RST | EWS,
+ SGF | PRE | EXT | RTO | RST | EWS,
+ SGF | PRE | EXT | RTO | RST | EWS,
+ SGF | PRE | EXT | RTO | RST | EWS,
+ SGF | PRE | EXT | RTO | RST | EWS
+};
+
+static inline int
+rta_seq_in_ptr(struct program *program, uint64_t src,
+ uint32_t length, uint32_t flags)
+{
+ uint32_t opcode = CMD_SEQ_IN_PTR;
+ unsigned int start_pc = program->current_pc;
+ int ret = -EINVAL;
+
+ /* Parameters checking */
+ if ((flags & RTO) && (flags & PRE)) {
+ pr_err("SEQ IN PTR: Invalid usage of RTO and PRE flags\n");
+ goto err;
+ }
+ if (flags & ~seq_in_ptr_flags[rta_sec_era]) {
+ pr_err("SEQ IN PTR: Flag(s) not supported by SEC Era %d\n",
+ USER_SEC_ERA(rta_sec_era));
+ goto err;
+ }
+ if ((flags & INL) && (flags & RJD)) {
+ pr_err("SEQ IN PTR: Invalid usage of INL and RJD flags\n");
+ goto err;
+ }
+ if ((src) && (flags & (SOP | RTO | PRE))) {
+ pr_err("SEQ IN PTR: Invalid usage of RTO or PRE flag\n");
+ goto err;
+ }
+ if ((flags & SOP) && (flags & (RBS | PRE | RTO | EXT))) {
+ pr_err("SEQ IN PTR: Invalid usage of SOP and (RBS or PRE or RTO or EXT) flags\n");
+ goto err;
+ }
+
+ /* write flag fields */
+ if (flags & RBS)
+ opcode |= SQIN_RBS;
+ if (flags & INL)
+ opcode |= SQIN_INL;
+ if (flags & SGF)
+ opcode |= SQIN_SGF;
+ if (flags & PRE)
+ opcode |= SQIN_PRE;
+ if (flags & RTO)
+ opcode |= SQIN_RTO;
+ if (flags & RJD)
+ opcode |= SQIN_RJD;
+ if (flags & SOP)
+ opcode |= SQIN_SOP;
+ if ((length >> 16) || (flags & EXT)) {
+ if (flags & SOP) {
+ pr_err("SEQ IN PTR: Invalid usage of SOP and EXT flags\n");
+ goto err;
+ }
+
+ opcode |= SQIN_EXT;
+ } else {
+ opcode |= length & SQIN_LEN_MASK;
+ }
+
+ __rta_out32(program, opcode);
+ program->current_instruction++;
+
+ /* write pointer or immediate data field */
+ if (!(opcode & (SQIN_PRE | SQIN_RTO | SQIN_SOP)))
+ __rta_out64(program, program->ps, src);
+
+ /* write extended length field */
+ if (opcode & SQIN_EXT)
+ __rta_out32(program, length);
+
+ return (int)start_pc;
+
+ err:
+ program->first_error_pc = start_pc;
+ program->current_instruction++;
+ return ret;
+}
+
+static inline int
+rta_seq_out_ptr(struct program *program, uint64_t dst,
+ uint32_t length, uint32_t flags)
+{
+ uint32_t opcode = CMD_SEQ_OUT_PTR;
+ unsigned int start_pc = program->current_pc;
+ int ret = -EINVAL;
+
+ /* Parameters checking */
+ if (flags & ~seq_out_ptr_flags[rta_sec_era]) {
+ pr_err("SEQ OUT PTR: Flag(s) not supported by SEC Era %d\n",
+ USER_SEC_ERA(rta_sec_era));
+ goto err;
+ }
+ if ((flags & RTO) && (flags & PRE)) {
+ pr_err("SEQ OUT PTR: Invalid usage of RTO and PRE flags\n");
+ goto err;
+ }
+ if ((dst) && (flags & (RTO | PRE))) {
+ pr_err("SEQ OUT PTR: Invalid usage of RTO or PRE flag\n");
+ goto err;
+ }
+ if ((flags & RST) && !(flags & RTO)) {
+ pr_err("SEQ OUT PTR: RST flag must be used with RTO flag\n");
+ goto err;
+ }
+
+ /* write flag fields */
+ if (flags & SGF)
+ opcode |= SQOUT_SGF;
+ if (flags & PRE)
+ opcode |= SQOUT_PRE;
+ if (flags & RTO)
+ opcode |= SQOUT_RTO;
+ if (flags & RST)
+ opcode |= SQOUT_RST;
+ if (flags & EWS)
+ opcode |= SQOUT_EWS;
+ if ((length >> 16) || (flags & EXT))
+ opcode |= SQOUT_EXT;
+ else
+ opcode |= length & SQOUT_LEN_MASK;
+
+ __rta_out32(program, opcode);
+ program->current_instruction++;
+
+ /* write pointer or immediate data field */
+ if (!(opcode & (SQOUT_PRE | SQOUT_RTO)))
+ __rta_out64(program, program->ps, dst);
+
+ /* write extended length field */
+ if (opcode & SQOUT_EXT)
+ __rta_out32(program, length);
+
+ return (int)start_pc;
+
+ err:
+ program->first_error_pc = start_pc;
+ program->current_instruction++;
+ return ret;
+}
+
+#endif /* __RTA_SEQ_IN_OUT_PTR_CMD_H__ */
--- /dev/null
+/* SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0)
+ *
+ * Copyright 2008-2016 Freescale Semiconductor Inc.
+ * Copyright 2016 NXP
+ *
+ */
+
+#ifndef __RTA_SIGNATURE_CMD_H__
+#define __RTA_SIGNATURE_CMD_H__
+
+static inline int
+rta_signature(struct program *program, uint32_t sign_type)
+{
+ uint32_t opcode = CMD_SIGNATURE;
+ unsigned int start_pc = program->current_pc;
+
+ switch (sign_type) {
+ case (SIGN_TYPE_FINAL):
+ case (SIGN_TYPE_FINAL_RESTORE):
+ case (SIGN_TYPE_FINAL_NONZERO):
+ case (SIGN_TYPE_IMM_2):
+ case (SIGN_TYPE_IMM_3):
+ case (SIGN_TYPE_IMM_4):
+ opcode |= sign_type;
+ break;
+ default:
+ pr_err("SIGNATURE Command: Invalid type selection\n");
+ goto err;
+ }
+
+ __rta_out32(program, opcode);
+ program->current_instruction++;
+
+ return (int)start_pc;
+
+ err:
+ program->first_error_pc = start_pc;
+ program->current_instruction++;
+ return -EINVAL;
+}
+
+#endif /* __RTA_SIGNATURE_CMD_H__ */
--- /dev/null
+/* SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0)
+ *
+ * Copyright 2008-2016 Freescale Semiconductor Inc.
+ * Copyright 2016,2019 NXP
+ */
+
+#ifndef __RTA_STORE_CMD_H__
+#define __RTA_STORE_CMD_H__
+
+extern enum rta_sec_era rta_sec_era;
+
+static const uint32_t store_src_table[][2] = {
+/*1*/ { KEY1SZ, LDST_CLASS_1_CCB | LDST_SRCDST_WORD_KEYSZ_REG },
+ { KEY2SZ, LDST_CLASS_2_CCB | LDST_SRCDST_WORD_KEYSZ_REG },
+ { DJQDA, LDST_CLASS_DECO | LDST_SRCDST_WORD_DECO_JQDAR },
+ { MODE1, LDST_CLASS_1_CCB | LDST_SRCDST_WORD_MODE_REG },
+ { MODE2, LDST_CLASS_2_CCB | LDST_SRCDST_WORD_MODE_REG },
+ { DJQCTRL, LDST_CLASS_DECO | LDST_SRCDST_WORD_DECO_JQCTRL },
+ { DATA1SZ, LDST_CLASS_1_CCB | LDST_SRCDST_WORD_DATASZ_REG },
+ { DATA2SZ, LDST_CLASS_2_CCB | LDST_SRCDST_WORD_DATASZ_REG },
+ { DSTAT, LDST_CLASS_DECO | LDST_SRCDST_WORD_DECO_STAT },
+ { ICV1SZ, LDST_CLASS_1_CCB | LDST_SRCDST_WORD_ICVSZ_REG },
+ { ICV2SZ, LDST_CLASS_2_CCB | LDST_SRCDST_WORD_ICVSZ_REG },
+ { DPID, LDST_CLASS_DECO | LDST_SRCDST_WORD_PID },
+ { CCTRL, LDST_SRCDST_WORD_CHACTRL },
+ { ICTRL, LDST_SRCDST_WORD_IRQCTRL },
+ { CLRW, LDST_SRCDST_WORD_CLRW },
+ { MATH0, LDST_CLASS_DECO | LDST_SRCDST_WORD_DECO_MATH0 },
+ { CSTAT, LDST_SRCDST_WORD_STAT },
+ { MATH1, LDST_CLASS_DECO | LDST_SRCDST_WORD_DECO_MATH1 },
+ { MATH2, LDST_CLASS_DECO | LDST_SRCDST_WORD_DECO_MATH2 },
+ { AAD1SZ, LDST_CLASS_1_CCB | LDST_SRCDST_WORD_DECO_AAD_SZ },
+ { MATH3, LDST_CLASS_DECO | LDST_SRCDST_WORD_DECO_MATH3 },
+ { IV1SZ, LDST_CLASS_1_CCB | LDST_SRCDST_WORD_CLASS1_IV_SZ },
+ { PKASZ, LDST_CLASS_1_CCB | LDST_SRCDST_WORD_PKHA_A_SZ },
+ { PKBSZ, LDST_CLASS_1_CCB | LDST_SRCDST_WORD_PKHA_B_SZ },
+ { PKESZ, LDST_CLASS_1_CCB | LDST_SRCDST_WORD_PKHA_E_SZ },
+ { PKNSZ, LDST_CLASS_1_CCB | LDST_SRCDST_WORD_PKHA_N_SZ },
+ { CONTEXT1, LDST_CLASS_1_CCB | LDST_SRCDST_BYTE_CONTEXT },
+ { CONTEXT2, LDST_CLASS_2_CCB | LDST_SRCDST_BYTE_CONTEXT },
+ { DESCBUF, LDST_CLASS_DECO | LDST_SRCDST_WORD_DESCBUF },
+/*30*/ { JOBDESCBUF, LDST_CLASS_DECO | LDST_SRCDST_WORD_DESCBUF_JOB },
+ { SHAREDESCBUF, LDST_CLASS_DECO | LDST_SRCDST_WORD_DESCBUF_SHARED },
+/*32*/ { JOBDESCBUF_EFF, LDST_CLASS_DECO |
+ LDST_SRCDST_WORD_DESCBUF_JOB_WE },
+ { SHAREDESCBUF_EFF, LDST_CLASS_DECO |
+ LDST_SRCDST_WORD_DESCBUF_SHARED_WE },
+/*34*/ { GTR, LDST_CLASS_DECO | LDST_SRCDST_WORD_GTR },
+ { STR, LDST_CLASS_DECO | LDST_SRCDST_WORD_STR }
+};
+
+/*
+ * Allowed STORE sources for each SEC ERA.
+ * Values represent the number of entries from source_src_table[] that are
+ * supported.
+ */
+static const unsigned int store_src_table_sz[] = {29, 31, 33, 33,
+ 33, 33, 35, 35,
+ 35, 35};
+
+static inline int
+rta_store(struct program *program, uint64_t src,
+ uint16_t offset, uint64_t dst, uint32_t length,
+ uint32_t flags)
+{
+ uint32_t opcode = 0, val;
+ int ret = -EINVAL;
+ unsigned int start_pc = program->current_pc;
+
+ if (flags & SEQ)
+ opcode = CMD_SEQ_STORE;
+ else
+ opcode = CMD_STORE;
+
+ /* parameters check */
+ if ((flags & IMMED) && (flags & SGF)) {
+ pr_err("STORE: Invalid flag. SEC PC: %d; Instr: %d\n",
+ program->current_pc, program->current_instruction);
+ goto err;
+ }
+ if ((flags & IMMED) && (offset != 0)) {
+ pr_err("STORE: Invalid flag. SEC PC: %d; Instr: %d\n",
+ program->current_pc, program->current_instruction);
+ goto err;
+ }
+
+ if ((flags & SEQ) && ((src == JOBDESCBUF) || (src == SHAREDESCBUF) ||
+ (src == JOBDESCBUF_EFF) ||
+ (src == SHAREDESCBUF_EFF))) {
+ pr_err("STORE: Invalid SRC type. SEC PC: %d; Instr: %d\n",
+ program->current_pc, program->current_instruction);
+ goto err;
+ }
+
+ if (flags & IMMED)
+ opcode |= LDST_IMM;
+
+ if ((flags & SGF) || (flags & VLF))
+ opcode |= LDST_VLF;
+
+ /*
+ * source for data to be stored can be specified as:
+ * - register location; set in src field[9-15];
+ * - if IMMED flag is set, data is set in value field [0-31];
+ * user can give this value as actual value or pointer to data
+ */
+ if (!(flags & IMMED)) {
+ ret = __rta_map_opcode((uint32_t)src, store_src_table,
+ store_src_table_sz[rta_sec_era], &val);
+ if (ret < 0) {
+ pr_err("STORE: Invalid source. SEC PC: %d; Instr: %d\n",
+ program->current_pc,
+ program->current_instruction);
+ goto err;
+ }
+ opcode |= val;
+ }
+
+ /* DESC BUFFER: length / offset values are specified in 4-byte words */
+ if ((src == DESCBUF) || (src == JOBDESCBUF) || (src == SHAREDESCBUF) ||
+ (src == JOBDESCBUF_EFF) || (src == SHAREDESCBUF_EFF)) {
+ opcode |= (length >> 2);
+ opcode |= (uint32_t)((offset >> 2) << LDST_OFFSET_SHIFT);
+ } else {
+ opcode |= length;
+ opcode |= (uint32_t)(offset << LDST_OFFSET_SHIFT);
+ }
+
+ __rta_out32(program, opcode);
+ program->current_instruction++;
+
+ if ((src == JOBDESCBUF) || (src == SHAREDESCBUF) ||
+ (src == JOBDESCBUF_EFF) || (src == SHAREDESCBUF_EFF))
+ return (int)start_pc;
+
+ /* for STORE, a pointer to where the data will be stored if needed */
+ if (!(flags & SEQ))
+ __rta_out64(program, program->ps, dst);
+
+ /* for IMMED data, place the data here */
+ if (flags & IMMED)
+ __rta_inline_data(program, src, flags & __COPY_MASK, length);
+
+ return (int)start_pc;
+
+ err:
+ program->first_error_pc = start_pc;
+ program->current_instruction++;
+ return ret;
+}
+
+#endif /* __RTA_STORE_CMD_H__ */
CFLAGS += $(WERROR_FLAGS)
CFLAGS += -I$(RTE_SDK)/drivers/bus/dpaa/include
+CFLAGS += -I$(RTE_SDK)/drivers/common/dpaax/caamflib/
CFLAGS += -I$(RTE_SDK)/drivers/crypto/caam_jr
-#sharing the hw flib headers from dpaa2_sec pmd
-CFLAGS += -I$(RTE_SDK)/drivers/crypto/dpaa2_sec/
CFLAGS += -I$(RTE_SDK)/lib/librte_eal/common/include
# versioning export map
#include <caam_jr_log.h>
/* RTA header files */
-#include <hw/desc/common.h>
-#include <hw/desc/algo.h>
+#include <desc/common.h>
+#include <desc/algo.h>
#include <of.h>
#ifdef RTE_LIBRTE_PMD_CAAM_JR_DEBUG
#define CAAM_JR_DBG 1
#include <caam_jr_pvt.h>
#include <caam_jr_log.h>
-/* RTA header files */
-#include <hw/desc/common.h>
-#include <hw/desc/algo.h>
-#include <hw/desc/ipsec.h>
-
/* Used to retry resetting a job ring in SEC hardware. */
#define SEC_TIMEOUT 100000
#ifndef CAAM_JR_PVT_H
#define CAAM_JR_PVT_H
-#include <hw/desc/ipsec.h>
+#include <desc/ipsec.h>
#include <dpaax_iova_table.h>
/* NXP CAAM JR PMD device name */
#include <caam_jr_pvt.h>
#include <caam_jr_log.h>
-/* RTA header files */
-#include <hw/desc/common.h>
-#include <hw/desc/algo.h>
-#include <hw/desc/ipsec.h>
-
/* Prefix path to sysfs directory where UIO device attributes are exported.
* Path for UIO device X is /sys/class/uio/uioX
*/
allow_experimental_apis = true
-includes += include_directories('../dpaa2_sec/')
includes += include_directories('../../bus/dpaa/include/')
+includes += include_directories('../../common/dpaax/caamflib/')
endif
endif
+CFLAGS += -I$(RTE_SDK)/drivers/common/dpaax/caamflib
CFLAGS += -I$(RTE_SDK)/drivers/crypto/dpaa2_sec/
CFLAGS += -I$(RTE_SDK)/drivers/crypto/dpaa2_sec/mc
CFLAGS += -I$(RTE_SDK)/drivers/bus/fslmc/
typedef uint64_t dma_addr_t;
/* RTA header files */
-#include <hw/desc/ipsec.h>
-#include <hw/desc/pdcp.h>
-#include <hw/desc/algo.h>
+#include <desc/ipsec.h>
+#include <desc/pdcp.h>
+#include <desc/algo.h>
/* Minimum job descriptor consists of a oneword job descriptor HEADER and
* a pointer to the shared descriptor
+++ /dev/null
-/* SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0)
- *
- * Copyright 2013-2016 Freescale Semiconductor Inc.
- * Copyright 2016 NXP
- *
- */
-
-#ifndef __RTA_COMPAT_H__
-#define __RTA_COMPAT_H__
-
-#include <stdint.h>
-#include <errno.h>
-
-#ifdef __GLIBC__
-#include <string.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <stdbool.h>
-
-#include <rte_byteorder.h>
-#include <rte_common.h>
-
-#ifndef __BYTE_ORDER__
-#error "Undefined endianness"
-#endif
-
-#else
-#error Environment not supported!
-#endif
-
-#ifndef __always_inline
-#define __always_inline __rte_always_inline
-#endif
-
-#ifndef __always_unused
-#define __always_unused __attribute__((unused))
-#endif
-
-#ifndef __maybe_unused
-#define __maybe_unused __attribute__((unused))
-#endif
-
-#if defined(__GLIBC__) && !defined(pr_debug)
-#if !defined(SUPPRESS_PRINTS) && defined(RTA_DEBUG)
-#define pr_debug(fmt, ...) \
- RTE_LOG(DEBUG, PMD, "%s(): " fmt "\n", __func__, ##__VA_ARGS__)
-#else
-#define pr_debug(fmt, ...) do { } while (0)
-#endif
-#endif /* pr_debug */
-
-#if defined(__GLIBC__) && !defined(pr_err)
-#if !defined(SUPPRESS_PRINTS)
-#define pr_err(fmt, ...) \
- RTE_LOG(ERR, PMD, "%s(): " fmt "\n", __func__, ##__VA_ARGS__)
-#else
-#define pr_err(fmt, ...) do { } while (0)
-#endif
-#endif /* pr_err */
-
-#if defined(__GLIBC__) && !defined(pr_warn)
-#if !defined(SUPPRESS_PRINTS)
-#define pr_warn(fmt, ...) \
- RTE_LOG(WARNING, PMD, "%s(): " fmt "\n", __func__, ##__VA_ARGS__)
-#else
-#define pr_warn(fmt, ...) do { } while (0)
-#endif
-#endif /* pr_warn */
-
-/**
- * ARRAY_SIZE - returns the number of elements in an array
- * @x: array
- */
-#ifndef ARRAY_SIZE
-#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
-#endif
-
-#ifndef ALIGN
-#define ALIGN(x, a) (((x) + ((__typeof__(x))(a) - 1)) & \
- ~((__typeof__(x))(a) - 1))
-#endif
-
-#ifndef BIT
-#define BIT(nr) (1UL << (nr))
-#endif
-
-#ifndef upper_32_bits
-/**
- * upper_32_bits - return bits 32-63 of a number
- * @n: the number we're accessing
- */
-#define upper_32_bits(n) ((uint32_t)(((n) >> 16) >> 16))
-#endif
-
-#ifndef lower_32_bits
-/**
- * lower_32_bits - return bits 0-31 of a number
- * @n: the number we're accessing
- */
-#define lower_32_bits(n) ((uint32_t)(n))
-#endif
-
-/* Use Linux naming convention */
-#ifdef __GLIBC__
- #define swab16(x) rte_bswap16(x)
- #define swab32(x) rte_bswap32(x)
- #define swab64(x) rte_bswap64(x)
- /* Define cpu_to_be32 macro if not defined in the build environment */
- #if !defined(cpu_to_be32)
- #if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
- #define cpu_to_be32(x) (x)
- #else
- #define cpu_to_be32(x) swab32(x)
- #endif
- #endif
- /* Define cpu_to_le32 macro if not defined in the build environment */
- #if !defined(cpu_to_le32)
- #if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
- #define cpu_to_le32(x) swab32(x)
- #else
- #define cpu_to_le32(x) (x)
- #endif
- #endif
-#endif
-
-#endif /* __RTA_COMPAT_H__ */
+++ /dev/null
-/* SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0)
- *
- * Copyright 2008-2016 Freescale Semiconductor Inc.
- * Copyright 2016, 2019 NXP
- *
- */
-
-/*
- * SEC descriptor composition header.
- * Definitions to support SEC descriptor instruction generation
- */
-
-#ifndef __RTA_DESC_H__
-#define __RTA_DESC_H__
-
-/* hw/compat.h is not delivered in kernel */
-#ifndef __KERNEL__
-#include "hw/compat.h"
-#endif
-
-extern enum rta_sec_era rta_sec_era;
-
-/* Max size of any SEC descriptor in 32-bit words, inclusive of header */
-#define MAX_CAAM_DESCSIZE 64
-
-#define CAAM_CMD_SZ sizeof(uint32_t)
-#define CAAM_PTR_SZ sizeof(dma_addr_t)
-#define CAAM_DESC_BYTES_MAX (CAAM_CMD_SZ * MAX_CAAM_DESCSIZE)
-#define DESC_JOB_IO_LEN (CAAM_CMD_SZ * 5 + CAAM_PTR_SZ * 3)
-
-/* Block size of any entity covered/uncovered with a KEK/TKEK */
-#define KEK_BLOCKSIZE 16
-
-/*
- * Supported descriptor command types as they show up
- * inside a descriptor command word.
- */
-#define CMD_SHIFT 27
-#define CMD_MASK (0x1f << CMD_SHIFT)
-
-#define CMD_KEY (0x00 << CMD_SHIFT)
-#define CMD_SEQ_KEY (0x01 << CMD_SHIFT)
-#define CMD_LOAD (0x02 << CMD_SHIFT)
-#define CMD_SEQ_LOAD (0x03 << CMD_SHIFT)
-#define CMD_FIFO_LOAD (0x04 << CMD_SHIFT)
-#define CMD_SEQ_FIFO_LOAD (0x05 << CMD_SHIFT)
-#define CMD_MOVEDW (0x06 << CMD_SHIFT)
-#define CMD_MOVEB (0x07 << CMD_SHIFT)
-#define CMD_STORE (0x0a << CMD_SHIFT)
-#define CMD_SEQ_STORE (0x0b << CMD_SHIFT)
-#define CMD_FIFO_STORE (0x0c << CMD_SHIFT)
-#define CMD_SEQ_FIFO_STORE (0x0d << CMD_SHIFT)
-#define CMD_MOVE_LEN (0x0e << CMD_SHIFT)
-#define CMD_MOVE (0x0f << CMD_SHIFT)
-#define CMD_OPERATION ((uint32_t)(0x10 << CMD_SHIFT))
-#define CMD_SIGNATURE ((uint32_t)(0x12 << CMD_SHIFT))
-#define CMD_JUMP ((uint32_t)(0x14 << CMD_SHIFT))
-#define CMD_MATH ((uint32_t)(0x15 << CMD_SHIFT))
-#define CMD_DESC_HDR ((uint32_t)(0x16 << CMD_SHIFT))
-#define CMD_SHARED_DESC_HDR ((uint32_t)(0x17 << CMD_SHIFT))
-#define CMD_MATHI ((uint32_t)(0x1d << CMD_SHIFT))
-#define CMD_SEQ_IN_PTR ((uint32_t)(0x1e << CMD_SHIFT))
-#define CMD_SEQ_OUT_PTR ((uint32_t)(0x1f << CMD_SHIFT))
-
-/* General-purpose class selector for all commands */
-#define CLASS_SHIFT 25
-#define CLASS_MASK (0x03 << CLASS_SHIFT)
-
-#define CLASS_NONE (0x00 << CLASS_SHIFT)
-#define CLASS_1 (0x01 << CLASS_SHIFT)
-#define CLASS_2 (0x02 << CLASS_SHIFT)
-#define CLASS_BOTH (0x03 << CLASS_SHIFT)
-
-/* ICV Check bits for Algo Operation command */
-#define ICV_CHECK_DISABLE 0
-#define ICV_CHECK_ENABLE 1
-
-/* Encap Mode check bits for Algo Operation command */
-#define DIR_ENC 1
-#define DIR_DEC 0
-
-/*
- * Descriptor header command constructs
- * Covers shared, job, and trusted descriptor headers
- */
-
-/*
- * Extended Job Descriptor Header
- */
-#define HDR_EXT BIT(24)
-
-/*
- * Read input frame as soon as possible (SHR HDR)
- */
-#define HDR_RIF BIT(25)
-
-/*
- * Require SEQ LIODN to be the Same (JOB HDR)
- */
-#define HDR_RSLS BIT(25)
-
-/*
- * Do Not Run - marks a descriptor not executable if there was
- * a preceding error somewhere
- */
-#define HDR_DNR BIT(24)
-
-/*
- * ONE - should always be set. Combination of ONE (always
- * set) and ZRO (always clear) forms an endianness sanity check
- */
-#define HDR_ONE BIT(23)
-#define HDR_ZRO BIT(15)
-
-/* Start Index or SharedDesc Length */
-#define HDR_START_IDX_SHIFT 16
-#define HDR_START_IDX_MASK (0x3f << HDR_START_IDX_SHIFT)
-#define HDR_START_IDX_MASK_ERA10 (0x7f << HDR_START_IDX_SHIFT)
-
-/* If shared descriptor header, 6-bit length */
-#define HDR_DESCLEN_SHR_MASK 0x3f
-/* If shared descriptor header, 7-bit length era10 onwards*/
-#define HDR_DESCLEN_SHR_MASK_ERA10 0x7f
-
-/* If non-shared header, 7-bit length */
-#define HDR_DESCLEN_MASK 0x7f
-
-/* This is a TrustedDesc (if not SharedDesc) */
-#define HDR_TRUSTED BIT(14)
-
-/* Make into TrustedDesc (if not SharedDesc) */
-#define HDR_MAKE_TRUSTED BIT(13)
-
-/* Clear Input FiFO (if SharedDesc) */
-#define HDR_CLEAR_IFIFO BIT(13)
-
-/* Save context if self-shared (if SharedDesc) */
-#define HDR_SAVECTX BIT(12)
-
-/* Next item points to SharedDesc */
-#define HDR_SHARED BIT(12)
-
-/*
- * Reverse Execution Order - execute JobDesc first, then
- * execute SharedDesc (normally SharedDesc goes first).
- */
-#define HDR_REVERSE BIT(11)
-
-/* Propagate DNR property to SharedDesc */
-#define HDR_PROP_DNR BIT(11)
-
-/* DECO Select Valid */
-#define HDR_EXT_DSEL_VALID BIT(7)
-
-/* Fake trusted descriptor */
-#define HDR_EXT_FTD BIT(8)
-
-/* JobDesc/SharedDesc share property */
-#define HDR_SD_SHARE_SHIFT 8
-#define HDR_SD_SHARE_MASK (0x03 << HDR_SD_SHARE_SHIFT)
-#define HDR_JD_SHARE_SHIFT 8
-#define HDR_JD_SHARE_MASK (0x07 << HDR_JD_SHARE_SHIFT)
-
-#define HDR_SHARE_NEVER (0x00 << HDR_SD_SHARE_SHIFT)
-#define HDR_SHARE_WAIT (0x01 << HDR_SD_SHARE_SHIFT)
-#define HDR_SHARE_SERIAL (0x02 << HDR_SD_SHARE_SHIFT)
-#define HDR_SHARE_ALWAYS (0x03 << HDR_SD_SHARE_SHIFT)
-#define HDR_SHARE_DEFER (0x04 << HDR_SD_SHARE_SHIFT)
-
-/* JobDesc/SharedDesc descriptor length */
-#define HDR_JD_LENGTH_MASK 0x7f
-#define HDR_SD_LENGTH_MASK 0x3f
-
-/*
- * KEY/SEQ_KEY Command Constructs
- */
-
-/* Key Destination Class: 01 = Class 1, 02 - Class 2 */
-#define KEY_DEST_CLASS_SHIFT 25
-#define KEY_DEST_CLASS_MASK (0x03 << KEY_DEST_CLASS_SHIFT)
-#define KEY_DEST_CLASS1 (1 << KEY_DEST_CLASS_SHIFT)
-#define KEY_DEST_CLASS2 (2 << KEY_DEST_CLASS_SHIFT)
-
-/* Scatter-Gather Table/Variable Length Field */
-#define KEY_SGF BIT(24)
-#define KEY_VLF BIT(24)
-
-/* Immediate - Key follows command in the descriptor */
-#define KEY_IMM BIT(23)
-
-/*
- * Already in Input Data FIFO - the Input Data Sequence is not read, since it is
- * already in the Input Data FIFO.
- */
-#define KEY_AIDF BIT(23)
-
-/*
- * Encrypted - Key is encrypted either with the KEK, or
- * with the TDKEK if this descriptor is trusted
- */
-#define KEY_ENC BIT(22)
-
-/*
- * No Write Back - Do not allow key to be FIFO STOREd
- */
-#define KEY_NWB BIT(21)
-
-/*
- * Enhanced Encryption of Key
- */
-#define KEY_EKT BIT(20)
-
-/*
- * Encrypted with Trusted Key
- */
-#define KEY_TK BIT(15)
-
-/*
- * Plaintext Store
- */
-#define KEY_PTS BIT(14)
-
-/*
- * KDEST - Key Destination: 0 - class key register,
- * 1 - PKHA 'e', 2 - AFHA Sbox, 3 - MDHA split key
- */
-#define KEY_DEST_SHIFT 16
-#define KEY_DEST_MASK (0x03 << KEY_DEST_SHIFT)
-
-#define KEY_DEST_CLASS_REG (0x00 << KEY_DEST_SHIFT)
-#define KEY_DEST_PKHA_E (0x01 << KEY_DEST_SHIFT)
-#define KEY_DEST_AFHA_SBOX (0x02 << KEY_DEST_SHIFT)
-#define KEY_DEST_MDHA_SPLIT (0x03 << KEY_DEST_SHIFT)
-
-/* Length in bytes */
-#define KEY_LENGTH_MASK 0x000003ff
-
-/*
- * LOAD/SEQ_LOAD/STORE/SEQ_STORE Command Constructs
- */
-
-/*
- * Load/Store Destination: 0 = class independent CCB,
- * 1 = class 1 CCB, 2 = class 2 CCB, 3 = DECO
- */
-#define LDST_CLASS_SHIFT 25
-#define LDST_CLASS_MASK (0x03 << LDST_CLASS_SHIFT)
-#define LDST_CLASS_IND_CCB (0x00 << LDST_CLASS_SHIFT)
-#define LDST_CLASS_1_CCB (0x01 << LDST_CLASS_SHIFT)
-#define LDST_CLASS_2_CCB (0x02 << LDST_CLASS_SHIFT)
-#define LDST_CLASS_DECO (0x03 << LDST_CLASS_SHIFT)
-
-/* Scatter-Gather Table/Variable Length Field */
-#define LDST_SGF BIT(24)
-#define LDST_VLF BIT(24)
-
-/* Immediate - Key follows this command in descriptor */
-#define LDST_IMM_MASK 1
-#define LDST_IMM_SHIFT 23
-#define LDST_IMM BIT(23)
-
-/* SRC/DST - Destination for LOAD, Source for STORE */
-#define LDST_SRCDST_SHIFT 16
-#define LDST_SRCDST_MASK (0x7f << LDST_SRCDST_SHIFT)
-
-#define LDST_SRCDST_BYTE_CONTEXT (0x20 << LDST_SRCDST_SHIFT)
-#define LDST_SRCDST_BYTE_KEY (0x40 << LDST_SRCDST_SHIFT)
-#define LDST_SRCDST_BYTE_INFIFO (0x7c << LDST_SRCDST_SHIFT)
-#define LDST_SRCDST_BYTE_OUTFIFO (0x7e << LDST_SRCDST_SHIFT)
-
-#define LDST_SRCDST_WORD_MODE_REG (0x00 << LDST_SRCDST_SHIFT)
-#define LDST_SRCDST_WORD_DECO_JQCTRL (0x00 << LDST_SRCDST_SHIFT)
-#define LDST_SRCDST_WORD_KEYSZ_REG (0x01 << LDST_SRCDST_SHIFT)
-#define LDST_SRCDST_WORD_DECO_JQDAR (0x01 << LDST_SRCDST_SHIFT)
-#define LDST_SRCDST_WORD_DATASZ_REG (0x02 << LDST_SRCDST_SHIFT)
-#define LDST_SRCDST_WORD_DECO_STAT (0x02 << LDST_SRCDST_SHIFT)
-#define LDST_SRCDST_WORD_ICVSZ_REG (0x03 << LDST_SRCDST_SHIFT)
-#define LDST_SRCDST_BYTE_DCHKSM (0x03 << LDST_SRCDST_SHIFT)
-#define LDST_SRCDST_WORD_PID (0x04 << LDST_SRCDST_SHIFT)
-#define LDST_SRCDST_WORD_CHACTRL (0x06 << LDST_SRCDST_SHIFT)
-#define LDST_SRCDST_WORD_DECOCTRL (0x06 << LDST_SRCDST_SHIFT)
-#define LDST_SRCDST_WORD_IRQCTRL (0x07 << LDST_SRCDST_SHIFT)
-#define LDST_SRCDST_WORD_DECO_PCLOVRD (0x07 << LDST_SRCDST_SHIFT)
-#define LDST_SRCDST_WORD_CLRW (0x08 << LDST_SRCDST_SHIFT)
-#define LDST_SRCDST_WORD_DECO_MATH0 (0x08 << LDST_SRCDST_SHIFT)
-#define LDST_SRCDST_WORD_STAT (0x09 << LDST_SRCDST_SHIFT)
-#define LDST_SRCDST_WORD_DECO_MATH1 (0x09 << LDST_SRCDST_SHIFT)
-#define LDST_SRCDST_WORD_DECO_MATH2 (0x0a << LDST_SRCDST_SHIFT)
-#define LDST_SRCDST_WORD_DECO_AAD_SZ (0x0b << LDST_SRCDST_SHIFT)
-#define LDST_SRCDST_WORD_DECO_MATH3 (0x0b << LDST_SRCDST_SHIFT)
-#define LDST_SRCDST_WORD_CLASS1_IV_SZ (0x0c << LDST_SRCDST_SHIFT)
-#define LDST_SRCDST_WORD_ALTDS_CLASS1 (0x0f << LDST_SRCDST_SHIFT)
-#define LDST_SRCDST_WORD_PKHA_A_SZ (0x10 << LDST_SRCDST_SHIFT)
-#define LDST_SRCDST_WORD_GTR (0x10 << LDST_SRCDST_SHIFT)
-#define LDST_SRCDST_WORD_PKHA_B_SZ (0x11 << LDST_SRCDST_SHIFT)
-#define LDST_SRCDST_WORD_PKHA_N_SZ (0x12 << LDST_SRCDST_SHIFT)
-#define LDST_SRCDST_WORD_PKHA_E_SZ (0x13 << LDST_SRCDST_SHIFT)
-#define LDST_SRCDST_WORD_CLASS_CTX (0x20 << LDST_SRCDST_SHIFT)
-#define LDST_SRCDST_WORD_STR (0x20 << LDST_SRCDST_SHIFT)
-#define LDST_SRCDST_WORD_DESCBUF (0x40 << LDST_SRCDST_SHIFT)
-#define LDST_SRCDST_WORD_DESCBUF_JOB (0x41 << LDST_SRCDST_SHIFT)
-#define LDST_SRCDST_WORD_DESCBUF_SHARED (0x42 << LDST_SRCDST_SHIFT)
-#define LDST_SRCDST_WORD_DESCBUF_JOB_WE (0x45 << LDST_SRCDST_SHIFT)
-#define LDST_SRCDST_WORD_DESCBUF_SHARED_WE (0x46 << LDST_SRCDST_SHIFT)
-#define LDST_SRCDST_WORD_INFO_FIFO_SZL (0x70 << LDST_SRCDST_SHIFT)
-#define LDST_SRCDST_WORD_INFO_FIFO_SZM (0x71 << LDST_SRCDST_SHIFT)
-#define LDST_SRCDST_WORD_INFO_FIFO_L (0x72 << LDST_SRCDST_SHIFT)
-#define LDST_SRCDST_WORD_INFO_FIFO_M (0x73 << LDST_SRCDST_SHIFT)
-#define LDST_SRCDST_WORD_SZL (0x74 << LDST_SRCDST_SHIFT)
-#define LDST_SRCDST_WORD_SZM (0x75 << LDST_SRCDST_SHIFT)
-#define LDST_SRCDST_WORD_IFNSR (0x76 << LDST_SRCDST_SHIFT)
-#define LDST_SRCDST_WORD_OFNSR (0x77 << LDST_SRCDST_SHIFT)
-#define LDST_SRCDST_BYTE_ALTSOURCE (0x78 << LDST_SRCDST_SHIFT)
-#define LDST_SRCDST_WORD_INFO_FIFO (0x7a << LDST_SRCDST_SHIFT)
-
-/* Offset in source/destination */
-#define LDST_OFFSET_SHIFT 8
-#define LDST_OFFSET_MASK (0xff << LDST_OFFSET_SHIFT)
-
-/* LDOFF definitions used when DST = LDST_SRCDST_WORD_DECOCTRL */
-/* These could also be shifted by LDST_OFFSET_SHIFT - this reads better */
-#define LDOFF_CHG_SHARE_SHIFT 0
-#define LDOFF_CHG_SHARE_MASK (0x3 << LDOFF_CHG_SHARE_SHIFT)
-#define LDOFF_CHG_SHARE_NEVER (0x1 << LDOFF_CHG_SHARE_SHIFT)
-#define LDOFF_CHG_SHARE_OK_PROP (0x2 << LDOFF_CHG_SHARE_SHIFT)
-#define LDOFF_CHG_SHARE_OK_NO_PROP (0x3 << LDOFF_CHG_SHARE_SHIFT)
-
-#define LDOFF_ENABLE_AUTO_NFIFO BIT(2)
-#define LDOFF_DISABLE_AUTO_NFIFO BIT(3)
-
-#define LDOFF_CHG_NONSEQLIODN_SHIFT 4
-#define LDOFF_CHG_NONSEQLIODN_MASK (0x3 << LDOFF_CHG_NONSEQLIODN_SHIFT)
-#define LDOFF_CHG_NONSEQLIODN_SEQ (0x1 << LDOFF_CHG_NONSEQLIODN_SHIFT)
-#define LDOFF_CHG_NONSEQLIODN_NON_SEQ (0x2 << LDOFF_CHG_NONSEQLIODN_SHIFT)
-#define LDOFF_CHG_NONSEQLIODN_TRUSTED (0x3 << LDOFF_CHG_NONSEQLIODN_SHIFT)
-
-#define LDOFF_CHG_SEQLIODN_SHIFT 6
-#define LDOFF_CHG_SEQLIODN_MASK (0x3 << LDOFF_CHG_SEQLIODN_SHIFT)
-#define LDOFF_CHG_SEQLIODN_SEQ (0x1 << LDOFF_CHG_SEQLIODN_SHIFT)
-#define LDOFF_CHG_SEQLIODN_NON_SEQ (0x2 << LDOFF_CHG_SEQLIODN_SHIFT)
-#define LDOFF_CHG_SEQLIODN_TRUSTED (0x3 << LDOFF_CHG_SEQLIODN_SHIFT)
-
-/* Data length in bytes */
-#define LDST_LEN_SHIFT 0
-#define LDST_LEN_MASK (0xff << LDST_LEN_SHIFT)
-
-/* Special Length definitions when dst=deco-ctrl */
-#define LDLEN_ENABLE_OSL_COUNT BIT(7)
-#define LDLEN_RST_CHA_OFIFO_PTR BIT(6)
-#define LDLEN_RST_OFIFO BIT(5)
-#define LDLEN_SET_OFIFO_OFF_VALID BIT(4)
-#define LDLEN_SET_OFIFO_OFF_RSVD BIT(3)
-#define LDLEN_SET_OFIFO_OFFSET_SHIFT 0
-#define LDLEN_SET_OFIFO_OFFSET_MASK (3 << LDLEN_SET_OFIFO_OFFSET_SHIFT)
-
-/* CCB Clear Written Register bits */
-#define CLRW_CLR_C1MODE BIT(0)
-#define CLRW_CLR_C1DATAS BIT(2)
-#define CLRW_CLR_C1ICV BIT(3)
-#define CLRW_CLR_C1CTX BIT(5)
-#define CLRW_CLR_C1KEY BIT(6)
-#define CLRW_CLR_PK_A BIT(12)
-#define CLRW_CLR_PK_B BIT(13)
-#define CLRW_CLR_PK_N BIT(14)
-#define CLRW_CLR_PK_E BIT(15)
-#define CLRW_CLR_C2MODE BIT(16)
-#define CLRW_CLR_C2KEYS BIT(17)
-#define CLRW_CLR_C2DATAS BIT(18)
-#define CLRW_CLR_C2CTX BIT(21)
-#define CLRW_CLR_C2KEY BIT(22)
-#define CLRW_RESET_CLS2_DONE BIT(26) /* era 4 */
-#define CLRW_RESET_CLS1_DONE BIT(27) /* era 4 */
-#define CLRW_RESET_CLS2_CHA BIT(28) /* era 4 */
-#define CLRW_RESET_CLS1_CHA BIT(29) /* era 4 */
-#define CLRW_RESET_OFIFO BIT(30) /* era 3 */
-#define CLRW_RESET_IFIFO_DFIFO BIT(31) /* era 3 */
-
-/* CHA Control Register bits */
-#define CCTRL_RESET_CHA_ALL BIT(0)
-#define CCTRL_RESET_CHA_AESA BIT(1)
-#define CCTRL_RESET_CHA_DESA BIT(2)
-#define CCTRL_RESET_CHA_AFHA BIT(3)
-#define CCTRL_RESET_CHA_KFHA BIT(4)
-#define CCTRL_RESET_CHA_SF8A BIT(5)
-#define CCTRL_RESET_CHA_PKHA BIT(6)
-#define CCTRL_RESET_CHA_MDHA BIT(7)
-#define CCTRL_RESET_CHA_CRCA BIT(8)
-#define CCTRL_RESET_CHA_RNG BIT(9)
-#define CCTRL_RESET_CHA_SF9A BIT(10)
-#define CCTRL_RESET_CHA_ZUCE BIT(11)
-#define CCTRL_RESET_CHA_ZUCA BIT(12)
-#define CCTRL_UNLOAD_PK_A0 BIT(16)
-#define CCTRL_UNLOAD_PK_A1 BIT(17)
-#define CCTRL_UNLOAD_PK_A2 BIT(18)
-#define CCTRL_UNLOAD_PK_A3 BIT(19)
-#define CCTRL_UNLOAD_PK_B0 BIT(20)
-#define CCTRL_UNLOAD_PK_B1 BIT(21)
-#define CCTRL_UNLOAD_PK_B2 BIT(22)
-#define CCTRL_UNLOAD_PK_B3 BIT(23)
-#define CCTRL_UNLOAD_PK_N BIT(24)
-#define CCTRL_UNLOAD_PK_A BIT(26)
-#define CCTRL_UNLOAD_PK_B BIT(27)
-#define CCTRL_UNLOAD_SBOX BIT(28)
-
-/* IRQ Control Register (CxCIRQ) bits */
-#define CIRQ_ADI BIT(1)
-#define CIRQ_DDI BIT(2)
-#define CIRQ_RCDI BIT(3)
-#define CIRQ_KDI BIT(4)
-#define CIRQ_S8DI BIT(5)
-#define CIRQ_PDI BIT(6)
-#define CIRQ_MDI BIT(7)
-#define CIRQ_CDI BIT(8)
-#define CIRQ_RNDI BIT(9)
-#define CIRQ_S9DI BIT(10)
-#define CIRQ_ZEDI BIT(11) /* valid for Era 5 or higher */
-#define CIRQ_ZADI BIT(12) /* valid for Era 5 or higher */
-#define CIRQ_AEI BIT(17)
-#define CIRQ_DEI BIT(18)
-#define CIRQ_RCEI BIT(19)
-#define CIRQ_KEI BIT(20)
-#define CIRQ_S8EI BIT(21)
-#define CIRQ_PEI BIT(22)
-#define CIRQ_MEI BIT(23)
-#define CIRQ_CEI BIT(24)
-#define CIRQ_RNEI BIT(25)
-#define CIRQ_S9EI BIT(26)
-#define CIRQ_ZEEI BIT(27) /* valid for Era 5 or higher */
-#define CIRQ_ZAEI BIT(28) /* valid for Era 5 or higher */
-
-/*
- * FIFO_LOAD/FIFO_STORE/SEQ_FIFO_LOAD/SEQ_FIFO_STORE
- * Command Constructs
- */
-
-/*
- * Load Destination: 0 = skip (SEQ_FIFO_LOAD only),
- * 1 = Load for Class1, 2 = Load for Class2, 3 = Load both
- * Store Source: 0 = normal, 1 = Class1key, 2 = Class2key
- */
-#define FIFOLD_CLASS_SHIFT 25
-#define FIFOLD_CLASS_MASK (0x03 << FIFOLD_CLASS_SHIFT)
-#define FIFOLD_CLASS_SKIP (0x00 << FIFOLD_CLASS_SHIFT)
-#define FIFOLD_CLASS_CLASS1 (0x01 << FIFOLD_CLASS_SHIFT)
-#define FIFOLD_CLASS_CLASS2 (0x02 << FIFOLD_CLASS_SHIFT)
-#define FIFOLD_CLASS_BOTH (0x03 << FIFOLD_CLASS_SHIFT)
-
-#define FIFOST_CLASS_SHIFT 25
-#define FIFOST_CLASS_MASK (0x03 << FIFOST_CLASS_SHIFT)
-#define FIFOST_CLASS_NORMAL (0x00 << FIFOST_CLASS_SHIFT)
-#define FIFOST_CLASS_CLASS1KEY (0x01 << FIFOST_CLASS_SHIFT)
-#define FIFOST_CLASS_CLASS2KEY (0x02 << FIFOST_CLASS_SHIFT)
-#define FIFOST_CLASS_BOTH (0x03 << FIFOST_CLASS_SHIFT)
-
-/*
- * Scatter-Gather Table/Variable Length Field
- * If set for FIFO_LOAD, refers to a SG table. Within
- * SEQ_FIFO_LOAD, is variable input sequence
- */
-#define FIFOLDST_SGF_SHIFT 24
-#define FIFOLDST_SGF_MASK (1 << FIFOLDST_SGF_SHIFT)
-#define FIFOLDST_VLF_MASK (1 << FIFOLDST_SGF_SHIFT)
-#define FIFOLDST_SGF BIT(24)
-#define FIFOLDST_VLF BIT(24)
-
-/*
- * Immediate - Data follows command in descriptor
- * AIDF - Already in Input Data FIFO
- */
-#define FIFOLD_IMM_SHIFT 23
-#define FIFOLD_IMM_MASK (1 << FIFOLD_IMM_SHIFT)
-#define FIFOLD_AIDF_MASK (1 << FIFOLD_IMM_SHIFT)
-#define FIFOLD_IMM BIT(23)
-#define FIFOLD_AIDF BIT(23)
-
-#define FIFOST_IMM_SHIFT 23
-#define FIFOST_IMM_MASK (1 << FIFOST_IMM_SHIFT)
-#define FIFOST_IMM BIT(23)
-
-/* Continue - Not the last FIFO store to come */
-#define FIFOST_CONT_SHIFT 23
-#define FIFOST_CONT_MASK (1 << FIFOST_CONT_SHIFT)
-#define FIFOST_CONT BIT(23)
-
-/*
- * Extended Length - use 32-bit extended length that
- * follows the pointer field. Illegal with IMM set
- */
-#define FIFOLDST_EXT_SHIFT 22
-#define FIFOLDST_EXT_MASK (1 << FIFOLDST_EXT_SHIFT)
-#define FIFOLDST_EXT BIT(22)
-
-/* Input data type.*/
-#define FIFOLD_TYPE_SHIFT 16
-#define FIFOLD_CONT_TYPE_SHIFT 19 /* shift past last-flush bits */
-#define FIFOLD_TYPE_MASK (0x3f << FIFOLD_TYPE_SHIFT)
-
-/* PK types */
-#define FIFOLD_TYPE_PK (0x00 << FIFOLD_TYPE_SHIFT)
-#define FIFOLD_TYPE_PK_MASK (0x30 << FIFOLD_TYPE_SHIFT)
-#define FIFOLD_TYPE_PK_TYPEMASK (0x0f << FIFOLD_TYPE_SHIFT)
-#define FIFOLD_TYPE_PK_A0 (0x00 << FIFOLD_TYPE_SHIFT)
-#define FIFOLD_TYPE_PK_A1 (0x01 << FIFOLD_TYPE_SHIFT)
-#define FIFOLD_TYPE_PK_A2 (0x02 << FIFOLD_TYPE_SHIFT)
-#define FIFOLD_TYPE_PK_A3 (0x03 << FIFOLD_TYPE_SHIFT)
-#define FIFOLD_TYPE_PK_B0 (0x04 << FIFOLD_TYPE_SHIFT)
-#define FIFOLD_TYPE_PK_B1 (0x05 << FIFOLD_TYPE_SHIFT)
-#define FIFOLD_TYPE_PK_B2 (0x06 << FIFOLD_TYPE_SHIFT)
-#define FIFOLD_TYPE_PK_B3 (0x07 << FIFOLD_TYPE_SHIFT)
-#define FIFOLD_TYPE_PK_N (0x08 << FIFOLD_TYPE_SHIFT)
-#define FIFOLD_TYPE_PK_A (0x0c << FIFOLD_TYPE_SHIFT)
-#define FIFOLD_TYPE_PK_B (0x0d << FIFOLD_TYPE_SHIFT)
-
-/* Other types. Need to OR in last/flush bits as desired */
-#define FIFOLD_TYPE_MSG_MASK (0x38 << FIFOLD_TYPE_SHIFT)
-#define FIFOLD_TYPE_MSG (0x10 << FIFOLD_TYPE_SHIFT)
-#define FIFOLD_TYPE_MSG1OUT2 (0x18 << FIFOLD_TYPE_SHIFT)
-#define FIFOLD_TYPE_IV (0x20 << FIFOLD_TYPE_SHIFT)
-#define FIFOLD_TYPE_BITDATA (0x28 << FIFOLD_TYPE_SHIFT)
-#define FIFOLD_TYPE_AAD (0x30 << FIFOLD_TYPE_SHIFT)
-#define FIFOLD_TYPE_ICV (0x38 << FIFOLD_TYPE_SHIFT)
-
-/* Last/Flush bits for use with "other" types above */
-#define FIFOLD_TYPE_ACT_MASK (0x07 << FIFOLD_TYPE_SHIFT)
-#define FIFOLD_TYPE_NOACTION (0x00 << FIFOLD_TYPE_SHIFT)
-#define FIFOLD_TYPE_FLUSH1 (0x01 << FIFOLD_TYPE_SHIFT)
-#define FIFOLD_TYPE_LAST1 (0x02 << FIFOLD_TYPE_SHIFT)
-#define FIFOLD_TYPE_LAST2FLUSH (0x03 << FIFOLD_TYPE_SHIFT)
-#define FIFOLD_TYPE_LAST2 (0x04 << FIFOLD_TYPE_SHIFT)
-#define FIFOLD_TYPE_LAST2FLUSH1 (0x05 << FIFOLD_TYPE_SHIFT)
-#define FIFOLD_TYPE_LASTBOTH (0x06 << FIFOLD_TYPE_SHIFT)
-#define FIFOLD_TYPE_LASTBOTHFL (0x07 << FIFOLD_TYPE_SHIFT)
-#define FIFOLD_TYPE_NOINFOFIFO (0x0f << FIFOLD_TYPE_SHIFT)
-
-#define FIFOLDST_LEN_MASK 0xffff
-#define FIFOLDST_EXT_LEN_MASK 0xffffffff
-
-/* Output data types */
-#define FIFOST_TYPE_SHIFT 16
-#define FIFOST_TYPE_MASK (0x3f << FIFOST_TYPE_SHIFT)
-
-#define FIFOST_TYPE_PKHA_A0 (0x00 << FIFOST_TYPE_SHIFT)
-#define FIFOST_TYPE_PKHA_A1 (0x01 << FIFOST_TYPE_SHIFT)
-#define FIFOST_TYPE_PKHA_A2 (0x02 << FIFOST_TYPE_SHIFT)
-#define FIFOST_TYPE_PKHA_A3 (0x03 << FIFOST_TYPE_SHIFT)
-#define FIFOST_TYPE_PKHA_B0 (0x04 << FIFOST_TYPE_SHIFT)
-#define FIFOST_TYPE_PKHA_B1 (0x05 << FIFOST_TYPE_SHIFT)
-#define FIFOST_TYPE_PKHA_B2 (0x06 << FIFOST_TYPE_SHIFT)
-#define FIFOST_TYPE_PKHA_B3 (0x07 << FIFOST_TYPE_SHIFT)
-#define FIFOST_TYPE_PKHA_N (0x08 << FIFOST_TYPE_SHIFT)
-#define FIFOST_TYPE_PKHA_A (0x0c << FIFOST_TYPE_SHIFT)
-#define FIFOST_TYPE_PKHA_B (0x0d << FIFOST_TYPE_SHIFT)
-#define FIFOST_TYPE_AF_SBOX_JKEK (0x20 << FIFOST_TYPE_SHIFT)
-#define FIFOST_TYPE_AF_SBOX_TKEK (0x21 << FIFOST_TYPE_SHIFT)
-#define FIFOST_TYPE_PKHA_E_JKEK (0x22 << FIFOST_TYPE_SHIFT)
-#define FIFOST_TYPE_PKHA_E_TKEK (0x23 << FIFOST_TYPE_SHIFT)
-#define FIFOST_TYPE_KEY_KEK (0x24 << FIFOST_TYPE_SHIFT)
-#define FIFOST_TYPE_KEY_TKEK (0x25 << FIFOST_TYPE_SHIFT)
-#define FIFOST_TYPE_SPLIT_KEK (0x26 << FIFOST_TYPE_SHIFT)
-#define FIFOST_TYPE_SPLIT_TKEK (0x27 << FIFOST_TYPE_SHIFT)
-#define FIFOST_TYPE_OUTFIFO_KEK (0x28 << FIFOST_TYPE_SHIFT)
-#define FIFOST_TYPE_OUTFIFO_TKEK (0x29 << FIFOST_TYPE_SHIFT)
-#define FIFOST_TYPE_MESSAGE_DATA (0x30 << FIFOST_TYPE_SHIFT)
-#define FIFOST_TYPE_MESSAGE_DATA2 (0x31 << FIFOST_TYPE_SHIFT)
-#define FIFOST_TYPE_RNGSTORE (0x34 << FIFOST_TYPE_SHIFT)
-#define FIFOST_TYPE_RNGFIFO (0x35 << FIFOST_TYPE_SHIFT)
-#define FIFOST_TYPE_METADATA (0x3e << FIFOST_TYPE_SHIFT)
-#define FIFOST_TYPE_SKIP (0x3f << FIFOST_TYPE_SHIFT)
-
-/*
- * OPERATION Command Constructs
- */
-
-/* Operation type selectors - OP TYPE */
-#define OP_TYPE_SHIFT 24
-#define OP_TYPE_MASK (0x07 << OP_TYPE_SHIFT)
-
-#define OP_TYPE_UNI_PROTOCOL (0x00 << OP_TYPE_SHIFT)
-#define OP_TYPE_PK (0x01 << OP_TYPE_SHIFT)
-#define OP_TYPE_CLASS1_ALG (0x02 << OP_TYPE_SHIFT)
-#define OP_TYPE_CLASS2_ALG (0x04 << OP_TYPE_SHIFT)
-#define OP_TYPE_DECAP_PROTOCOL (0x06 << OP_TYPE_SHIFT)
-#define OP_TYPE_ENCAP_PROTOCOL (0x07 << OP_TYPE_SHIFT)
-
-/* ProtocolID selectors - PROTID */
-#define OP_PCLID_SHIFT 16
-#define OP_PCLID_MASK (0xff << OP_PCLID_SHIFT)
-
-/* Assuming OP_TYPE = OP_TYPE_UNI_PROTOCOL */
-#define OP_PCLID_IKEV1_PRF (0x01 << OP_PCLID_SHIFT)
-#define OP_PCLID_IKEV2_PRF (0x02 << OP_PCLID_SHIFT)
-#define OP_PCLID_SSL30_PRF (0x08 << OP_PCLID_SHIFT)
-#define OP_PCLID_TLS10_PRF (0x09 << OP_PCLID_SHIFT)
-#define OP_PCLID_TLS11_PRF (0x0a << OP_PCLID_SHIFT)
-#define OP_PCLID_TLS12_PRF (0x0b << OP_PCLID_SHIFT)
-#define OP_PCLID_DTLS_PRF (0x0c << OP_PCLID_SHIFT)
-#define OP_PCLID_PUBLICKEYPAIR (0x14 << OP_PCLID_SHIFT)
-#define OP_PCLID_DSASIGN (0x15 << OP_PCLID_SHIFT)
-#define OP_PCLID_DSAVERIFY (0x16 << OP_PCLID_SHIFT)
-#define OP_PCLID_DIFFIEHELLMAN (0x17 << OP_PCLID_SHIFT)
-#define OP_PCLID_RSAENCRYPT (0x18 << OP_PCLID_SHIFT)
-#define OP_PCLID_RSADECRYPT (0x19 << OP_PCLID_SHIFT)
-#define OP_PCLID_DKP_MD5 (0x20 << OP_PCLID_SHIFT)
-#define OP_PCLID_DKP_SHA1 (0x21 << OP_PCLID_SHIFT)
-#define OP_PCLID_DKP_SHA224 (0x22 << OP_PCLID_SHIFT)
-#define OP_PCLID_DKP_SHA256 (0x23 << OP_PCLID_SHIFT)
-#define OP_PCLID_DKP_SHA384 (0x24 << OP_PCLID_SHIFT)
-#define OP_PCLID_DKP_SHA512 (0x25 << OP_PCLID_SHIFT)
-
-/* Assuming OP_TYPE = OP_TYPE_DECAP_PROTOCOL/ENCAP_PROTOCOL */
-#define OP_PCLID_IPSEC (0x01 << OP_PCLID_SHIFT)
-#define OP_PCLID_SRTP (0x02 << OP_PCLID_SHIFT)
-#define OP_PCLID_MACSEC (0x03 << OP_PCLID_SHIFT)
-#define OP_PCLID_WIFI (0x04 << OP_PCLID_SHIFT)
-#define OP_PCLID_WIMAX (0x05 << OP_PCLID_SHIFT)
-#define OP_PCLID_SSL30 (0x08 << OP_PCLID_SHIFT)
-#define OP_PCLID_TLS10 (0x09 << OP_PCLID_SHIFT)
-#define OP_PCLID_TLS11 (0x0a << OP_PCLID_SHIFT)
-#define OP_PCLID_TLS12 (0x0b << OP_PCLID_SHIFT)
-#define OP_PCLID_DTLS (0x0c << OP_PCLID_SHIFT)
-#define OP_PCLID_BLOB (0x0d << OP_PCLID_SHIFT)
-#define OP_PCLID_IPSEC_NEW (0x11 << OP_PCLID_SHIFT)
-#define OP_PCLID_3G_DCRC (0x31 << OP_PCLID_SHIFT)
-#define OP_PCLID_3G_RLC_PDU (0x32 << OP_PCLID_SHIFT)
-#define OP_PCLID_3G_RLC_SDU (0x33 << OP_PCLID_SHIFT)
-#define OP_PCLID_LTE_PDCP_USER (0x42 << OP_PCLID_SHIFT)
-#define OP_PCLID_LTE_PDCP_CTRL (0x43 << OP_PCLID_SHIFT)
-#define OP_PCLID_LTE_PDCP_CTRL_MIXED (0x44 << OP_PCLID_SHIFT)
-#define OP_PCLID_LTE_PDCP_USER_RN (0x45 << OP_PCLID_SHIFT)
-
-/*
- * ProtocolInfo selectors
- */
-#define OP_PCLINFO_MASK 0xffff
-
-/* for OP_PCLID_IPSEC */
-#define OP_PCL_IPSEC_CIPHER_MASK 0xff00
-#define OP_PCL_IPSEC_AUTH_MASK 0x00ff
-
-#define OP_PCL_IPSEC_DES_IV64 0x0100
-#define OP_PCL_IPSEC_DES 0x0200
-#define OP_PCL_IPSEC_3DES 0x0300
-#define OP_PCL_IPSEC_NULL 0x0B00
-#define OP_PCL_IPSEC_AES_CBC 0x0c00
-#define OP_PCL_IPSEC_AES_CTR 0x0d00
-#define OP_PCL_IPSEC_AES_XTS 0x1600
-#define OP_PCL_IPSEC_AES_CCM8 0x0e00
-#define OP_PCL_IPSEC_AES_CCM12 0x0f00
-#define OP_PCL_IPSEC_AES_CCM16 0x1000
-#define OP_PCL_IPSEC_AES_GCM8 0x1200
-#define OP_PCL_IPSEC_AES_GCM12 0x1300
-#define OP_PCL_IPSEC_AES_GCM16 0x1400
-#define OP_PCL_IPSEC_AES_NULL_WITH_GMAC 0x1500
-
-#define OP_PCL_IPSEC_HMAC_NULL 0x0000
-#define OP_PCL_IPSEC_HMAC_MD5_96 0x0001
-#define OP_PCL_IPSEC_HMAC_SHA1_96 0x0002
-#define OP_PCL_IPSEC_AES_XCBC_MAC_96 0x0005
-#define OP_PCL_IPSEC_HMAC_MD5_128 0x0006
-#define OP_PCL_IPSEC_HMAC_SHA1_160 0x0007
-#define OP_PCL_IPSEC_AES_CMAC_96 0x0008
-#define OP_PCL_IPSEC_HMAC_SHA2_256_128 0x000c
-#define OP_PCL_IPSEC_HMAC_SHA2_384_192 0x000d
-#define OP_PCL_IPSEC_HMAC_SHA2_512_256 0x000e
-
-/* For SRTP - OP_PCLID_SRTP */
-#define OP_PCL_SRTP_CIPHER_MASK 0xff00
-#define OP_PCL_SRTP_AUTH_MASK 0x00ff
-
-#define OP_PCL_SRTP_AES_CTR 0x0d00
-
-#define OP_PCL_SRTP_HMAC_SHA1_160 0x0007
-
-/*
- * For SSL/TLS/DTLS - OP_PCL_TLS
- * For more details see IANA TLS Cipher Suite registry:
- * https://www.iana.org/assignments/tls-parameters/tls-parameters.xhtml
- * Note: for private/internal use (reserved by IANA) - OP_PCL_PVT_TLS
- */
-#define OP_PCL_TLS_RSA_EXPORT_WITH_RC4_40_MD5 0x0003
-#define OP_PCL_TLS_RSA_WITH_RC4_128_MD5 0x0004
-#define OP_PCL_TLS_RSA_WITH_RC4_128_SHA 0x0005
-#define OP_PCL_TLS_RSA_EXPORT_WITH_DES40_CBC_SHA 0x0008
-#define OP_PCL_TLS_RSA_WITH_DES_CBC_SHA 0x0009
-#define OP_PCL_TLS_RSA_WITH_3DES_EDE_CBC_SHA 0x000a
-#define OP_PCL_TLS_DH_DSS_EXPORT_WITH_DES40_CBC_SHA 0x000b
-#define OP_PCL_TLS_DH_DSS_WITH_DES_CBC_SHA 0x000c
-#define OP_PCL_TLS_DH_DSS_WITH_3DES_EDE_CBC_SHA 0x000d
-#define OP_PCL_TLS_DH_RSA_EXPORT_WITH_DES40_CBC_SHA 0x000e
-#define OP_PCL_TLS_DH_RSA_WITH_DES_CBC_SHA 0x000f
-#define OP_PCL_TLS_DH_RSA_WITH_3DES_EDE_CBC_SHA 0x0010
-#define OP_PCL_TLS_DHE_DSS_EXPORT_WITH_DES40_CBC_SHA 0x0011
-#define OP_PCL_TLS_DHE_DSS_WITH_DES_CBC_SHA 0x0012
-#define OP_PCL_TLS_DHE_DSS_WITH_3DES_EDE_CBC_SHA 0x0013
-#define OP_PCL_TLS_DHE_RSA_EXPORT_WITH_DES40_CBC_SHA 0x0014
-#define OP_PCL_TLS_DHE_RSA_WITH_DES_CBC_SHA 0x0015
-#define OP_PCL_TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA 0x0016
-#define OP_PCL_TLS_DH_anon_EXPORT_WITH_RC4_40_MD5 0x0017
-#define OP_PCL_TLS_DH_anon_WITH_RC4_128_MD5 0x0018
-#define OP_PCL_TLS_DH_anon_EXPORT_WITH_DES40_CBC_SHA 0x0019
-#define OP_PCL_TLS_DH_anon_WITH_DES_CBC_SHA 0x001a
-#define OP_PCL_TLS_DH_anon_WITH_3DES_EDE_CBC_SHA 0x001b
-#define OP_PCL_TLS_KRB5_WITH_DES_CBC_SHA 0x001e
-#define OP_PCL_TLS_KRB5_WITH_3DES_EDE_CBC_SHA 0x001f
-#define OP_PCL_TLS_KRB5_WITH_RC4_128_SHA 0x0020
-#define OP_PCL_TLS_KRB5_WITH_3DES_EDE_CBC_MD5 0x0023
-#define OP_PCL_TLS_KRB5_WITH_DES_CBC_MD5 0x0022
-#define OP_PCL_TLS_KRB5_WITH_RC4_128_MD5 0x0024
-#define OP_PCL_TLS_KRB5_EXPORT_WITH_DES_CBC_40_SHA 0x0026
-#define OP_PCL_TLS_KRB5_EXPORT_WITH_RC4_40_SHA 0x0028
-#define OP_PCL_TLS_KRB5_EXPORT_WITH_DES_CBC_40_MD5 0x0029
-#define OP_PCL_TLS_KRB5_EXPORT_WITH_RC4_40_MD5 0x002b
-#define OP_PCL_TLS_RSA_WITH_AES_128_CBC_SHA 0x002f
-#define OP_PCL_TLS_DH_DSS_WITH_AES_128_CBC_SHA 0x0030
-#define OP_PCL_TLS_DH_RSA_WITH_AES_128_CBC_SHA 0x0031
-#define OP_PCL_TLS_DHE_DSS_WITH_AES_128_CBC_SHA 0x0032
-#define OP_PCL_TLS_DHE_RSA_WITH_AES_128_CBC_SHA 0x0033
-#define OP_PCL_TLS_DH_anon_WITH_AES_128_CBC_SHA 0x0034
-#define OP_PCL_TLS_RSA_WITH_AES_256_CBC_SHA 0x0035
-#define OP_PCL_TLS_DH_DSS_WITH_AES_256_CBC_SHA 0x0036
-#define OP_PCL_TLS_DH_RSA_WITH_AES_256_CBC_SHA 0x0037
-#define OP_PCL_TLS_DHE_DSS_WITH_AES_256_CBC_SHA 0x0038
-#define OP_PCL_TLS_DHE_RSA_WITH_AES_256_CBC_SHA 0x0039
-#define OP_PCL_TLS_DH_anon_WITH_AES_256_CBC_SHA 0x003a
-#define OP_PCL_TLS_RSA_WITH_AES_128_CBC_SHA256 0x003c
-#define OP_PCL_TLS_RSA_WITH_AES_256_CBC_SHA256 0x003d
-#define OP_PCL_TLS_DH_DSS_WITH_AES_128_CBC_SHA256 0x003e
-#define OP_PCL_TLS_DH_RSA_WITH_AES_128_CBC_SHA256 0x003f
-#define OP_PCL_TLS_DHE_DSS_WITH_AES_128_CBC_SHA256 0x0040
-#define OP_PCL_TLS_DHE_RSA_WITH_AES_128_CBC_SHA256 0x0067
-#define OP_PCL_TLS_DH_DSS_WITH_AES_256_CBC_SHA256 0x0068
-#define OP_PCL_TLS_DH_RSA_WITH_AES_256_CBC_SHA256 0x0069
-#define OP_PCL_TLS_DHE_DSS_WITH_AES_256_CBC_SHA256 0x006a
-#define OP_PCL_TLS_DHE_RSA_WITH_AES_256_CBC_SHA256 0x006b
-#define OP_PCL_TLS_DH_anon_WITH_AES_128_CBC_SHA256 0x006c
-#define OP_PCL_TLS_DH_anon_WITH_AES_256_CBC_SHA256 0x006d
-#define OP_PCL_TLS_PSK_WITH_RC4_128_SHA 0x008a
-#define OP_PCL_TLS_PSK_WITH_3DES_EDE_CBC_SHA 0x008b
-#define OP_PCL_TLS_PSK_WITH_AES_128_CBC_SHA 0x008c
-#define OP_PCL_TLS_PSK_WITH_AES_256_CBC_SHA 0x008d
-#define OP_PCL_TLS_DHE_PSK_WITH_RC4_128_SHA 0x008e
-#define OP_PCL_TLS_DHE_PSK_WITH_3DES_EDE_CBC_SHA 0x008f
-#define OP_PCL_TLS_DHE_PSK_WITH_AES_128_CBC_SHA 0x0090
-#define OP_PCL_TLS_DHE_PSK_WITH_AES_256_CBC_SHA 0x0091
-#define OP_PCL_TLS_RSA_PSK_WITH_RC4_128_SHA 0x0092
-#define OP_PCL_TLS_RSA_PSK_WITH_3DES_EDE_CBC_SHA 0x0093
-#define OP_PCL_TLS_RSA_PSK_WITH_AES_128_CBC_SHA 0x0094
-#define OP_PCL_TLS_RSA_PSK_WITH_AES_256_CBC_SHA 0x0095
-#define OP_PCL_TLS_RSA_WITH_AES_128_GCM_SHA256 0x009c
-#define OP_PCL_TLS_RSA_WITH_AES_256_GCM_SHA384 0x009d
-#define OP_PCL_TLS_DHE_RSA_WITH_AES_128_GCM_SHA256 0x009e
-#define OP_PCL_TLS_DHE_RSA_WITH_AES_256_GCM_SHA384 0x009f
-#define OP_PCL_TLS_DH_RSA_WITH_AES_128_GCM_SHA256 0x00a0
-#define OP_PCL_TLS_DH_RSA_WITH_AES_256_GCM_SHA384 0x00a1
-#define OP_PCL_TLS_DHE_DSS_WITH_AES_128_GCM_SHA256 0x00a2
-#define OP_PCL_TLS_DHE_DSS_WITH_AES_256_GCM_SHA384 0x00a3
-#define OP_PCL_TLS_DH_DSS_WITH_AES_128_GCM_SHA256 0x00a4
-#define OP_PCL_TLS_DH_DSS_WITH_AES_256_GCM_SHA384 0x00a5
-#define OP_PCL_TLS_DH_anon_WITH_AES_128_GCM_SHA256 0x00a6
-#define OP_PCL_TLS_DH_anon_WITH_AES_256_GCM_SHA384 0x00a7
-#define OP_PCL_TLS_PSK_WITH_AES_128_GCM_SHA256 0x00a8
-#define OP_PCL_TLS_PSK_WITH_AES_256_GCM_SHA384 0x00a9
-#define OP_PCL_TLS_DHE_PSK_WITH_AES_128_GCM_SHA256 0x00aa
-#define OP_PCL_TLS_DHE_PSK_WITH_AES_256_GCM_SHA384 0x00ab
-#define OP_PCL_TLS_RSA_PSK_WITH_AES_128_GCM_SHA256 0x00ac
-#define OP_PCL_TLS_RSA_PSK_WITH_AES_256_GCM_SHA384 0x00ad
-#define OP_PCL_TLS_PSK_WITH_AES_128_CBC_SHA256 0x00ae
-#define OP_PCL_TLS_PSK_WITH_AES_256_CBC_SHA384 0x00af
-#define OP_PCL_TLS_DHE_PSK_WITH_AES_128_CBC_SHA256 0x00b2
-#define OP_PCL_TLS_DHE_PSK_WITH_AES_256_CBC_SHA384 0x00b3
-#define OP_PCL_TLS_RSA_PSK_WITH_AES_128_CBC_SHA256 0x00b6
-#define OP_PCL_TLS_RSA_PSK_WITH_AES_256_CBC_SHA384 0x00b7
-#define OP_PCL_TLS_ECDH_ECDSA_WITH_RC4_128_SHA 0xc002
-#define OP_PCL_TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA 0xc003
-#define OP_PCL_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA 0xc004
-#define OP_PCL_TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA 0xc005
-#define OP_PCL_TLS_ECDHE_ECDSA_WITH_RC4_128_SHA 0xc007
-#define OP_PCL_TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA 0xc008
-#define OP_PCL_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA 0xc009
-#define OP_PCL_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA 0xc00a
-#define OP_PCL_TLS_ECDH_RSA_WITH_RC4_128_SHA 0xc00c
-#define OP_PCL_TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA 0xc00d
-#define OP_PCL_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA 0xc00e
-#define OP_PCL_TLS_ECDH_RSA_WITH_AES_256_CBC_SHA 0xc00f
-#define OP_PCL_TLS_ECDHE_RSA_WITH_RC4_128_SHA 0xc011
-#define OP_PCL_TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA 0xc012
-#define OP_PCL_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA 0xc013
-#define OP_PCL_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA 0xc014
-#define OP_PCL_TLS_ECDH_anon_WITH_RC4_128_SHA 0xc016
-#define OP_PCL_TLS_ECDH_anon_WITH_3DES_EDE_CBC_SHA 0xc017
-#define OP_PCL_TLS_ECDH_anon_WITH_AES_128_CBC_SHA 0xc018
-#define OP_PCL_TLS_ECDH_anon_WITH_AES_256_CBC_SHA 0xc019
-#define OP_PCL_TLS_SRP_SHA_WITH_3DES_EDE_CBC_SHA 0xc01a
-#define OP_PCL_TLS_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA 0xc01b
-#define OP_PCL_TLS_SRP_SHA_DSS_WITH_3DES_EDE_CBC_SHA 0xc01c
-#define OP_PCL_TLS_SRP_SHA_WITH_AES_128_CBC_SHA 0xc01d
-#define OP_PCL_TLS_SRP_SHA_RSA_WITH_AES_128_CBC_SHA 0xc01e
-#define OP_PCL_TLS_SRP_SHA_DSS_WITH_AES_128_CBC_SHA 0xc01f
-#define OP_PCL_TLS_SRP_SHA_WITH_AES_256_CBC_SHA 0xc020
-#define OP_PCL_TLS_SRP_SHA_RSA_WITH_AES_256_CBC_SHA 0xc021
-#define OP_PCL_TLS_SRP_SHA_DSS_WITH_AES_256_CBC_SHA 0xc022
-#define OP_PCL_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256 0xc023
-#define OP_PCL_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384 0xc024
-#define OP_PCL_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256 0xc025
-#define OP_PCL_TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384 0xc026
-#define OP_PCL_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256 0xc027
-#define OP_PCL_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384 0xc028
-#define OP_PCL_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256 0xc029
-#define OP_PCL_TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384 0xc02a
-#define OP_PCL_TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 0xc02b
-#define OP_PCL_TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384 0xc02c
-#define OP_PCL_TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256 0xc02d
-#define OP_PCL_TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384 0xc02e
-#define OP_PCL_TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 0xc02f
-#define OP_PCL_TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 0xc030
-#define OP_PCL_TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256 0xc031
-#define OP_PCL_TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384 0xc032
-#define OP_PCL_TLS_ECDHE_PSK_WITH_RC4_128_SHA 0xc033
-#define OP_PCL_TLS_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA 0xc034
-#define OP_PCL_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA 0xc035
-#define OP_PCL_TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA 0xc036
-#define OP_PCL_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256 0xc037
-#define OP_PCL_TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA384 0xc038
-#define OP_PCL_PVT_TLS_3DES_EDE_CBC_MD5 0xff23
-#define OP_PCL_PVT_TLS_3DES_EDE_CBC_SHA160 0xff30
-#define OP_PCL_PVT_TLS_3DES_EDE_CBC_SHA384 0xff33
-#define OP_PCL_PVT_TLS_3DES_EDE_CBC_SHA224 0xff34
-#define OP_PCL_PVT_TLS_3DES_EDE_CBC_SHA512 0xff35
-#define OP_PCL_PVT_TLS_3DES_EDE_CBC_SHA256 0xff36
-#define OP_PCL_PVT_TLS_AES_256_CBC_SHA160 0xff60
-#define OP_PCL_PVT_TLS_AES_256_CBC_SHA384 0xff63
-#define OP_PCL_PVT_TLS_AES_256_CBC_SHA224 0xff64
-#define OP_PCL_PVT_TLS_AES_256_CBC_SHA512 0xff65
-#define OP_PCL_PVT_TLS_AES_256_CBC_SHA256 0xff66
-#define OP_PCL_PVT_TLS_AES_128_CBC_SHA160 0xff80
-#define OP_PCL_PVT_TLS_AES_128_CBC_SHA384 0xff83
-#define OP_PCL_PVT_TLS_AES_128_CBC_SHA224 0xff84
-#define OP_PCL_PVT_TLS_AES_128_CBC_SHA512 0xff85
-#define OP_PCL_PVT_TLS_AES_128_CBC_SHA256 0xff86
-#define OP_PCL_PVT_TLS_AES_192_CBC_SHA160 0xff90
-#define OP_PCL_PVT_TLS_AES_192_CBC_SHA384 0xff93
-#define OP_PCL_PVT_TLS_AES_192_CBC_SHA224 0xff94
-#define OP_PCL_PVT_TLS_AES_192_CBC_SHA512 0xff95
-#define OP_PCL_PVT_TLS_AES_192_CBC_SHA256 0xff96
-#define OP_PCL_PVT_TLS_MASTER_SECRET_PRF_FE 0xfffe
-#define OP_PCL_PVT_TLS_MASTER_SECRET_PRF_FF 0xffff
-
-/* 802.16 WiMAX protinfos */
-#define OP_PCL_WIMAX_OFDM 0x0201
-#define OP_PCL_WIMAX_OFDMA 0x0231
-
-/* 802.11 WiFi protinfos */
-#define OP_PCL_WIFI 0xac04
-
-/* MacSec protinfos */
-#define OP_PCL_MACSEC 0x0001
-
-/* 3G DCRC protinfos */
-#define OP_PCL_3G_DCRC_CRC7 0x0710
-#define OP_PCL_3G_DCRC_CRC11 0x0B10
-
-/* 3G RLC protinfos */
-#define OP_PCL_3G_RLC_NULL 0x0000
-#define OP_PCL_3G_RLC_KASUMI 0x0001
-#define OP_PCL_3G_RLC_SNOW 0x0002
-
-/* LTE protinfos */
-#define OP_PCL_LTE_NULL 0x0000
-#define OP_PCL_LTE_SNOW 0x0001
-#define OP_PCL_LTE_AES 0x0002
-#define OP_PCL_LTE_ZUC 0x0003
-
-/* LTE mixed protinfos */
-#define OP_PCL_LTE_MIXED_AUTH_SHIFT 0
-#define OP_PCL_LTE_MIXED_AUTH_MASK (3 << OP_PCL_LTE_MIXED_AUTH_SHIFT)
-#define OP_PCL_LTE_MIXED_ENC_SHIFT 8
-#define OP_PCL_LTE_MIXED_ENC_MASK (3 << OP_PCL_LTE_MIXED_ENC_SHIFT)
-#define OP_PCL_LTE_MIXED_AUTH_NULL (OP_PCL_LTE_NULL << \
- OP_PCL_LTE_MIXED_AUTH_SHIFT)
-#define OP_PCL_LTE_MIXED_AUTH_SNOW (OP_PCL_LTE_SNOW << \
- OP_PCL_LTE_MIXED_AUTH_SHIFT)
-#define OP_PCL_LTE_MIXED_AUTH_AES (OP_PCL_LTE_AES << \
- OP_PCL_LTE_MIXED_AUTH_SHIFT)
-#define OP_PCL_LTE_MIXED_AUTH_ZUC (OP_PCL_LTE_ZUC << \
- OP_PCL_LTE_MIXED_AUTH_SHIFT)
-#define OP_PCL_LTE_MIXED_ENC_NULL (OP_PCL_LTE_NULL << \
- OP_PCL_LTE_MIXED_ENC_SHIFT)
-#define OP_PCL_LTE_MIXED_ENC_SNOW (OP_PCL_LTE_SNOW << \
- OP_PCL_LTE_MIXED_ENC_SHIFT)
-#define OP_PCL_LTE_MIXED_ENC_AES (OP_PCL_LTE_AES << \
- OP_PCL_LTE_MIXED_ENC_SHIFT)
-#define OP_PCL_LTE_MIXED_ENC_ZUC (OP_PCL_LTE_ZUC << \
- OP_PCL_LTE_MIXED_ENC_SHIFT)
-
-/* PKI unidirectional protocol protinfo bits */
-#define OP_PCL_PKPROT_DSA_MSG BIT(10)
-#define OP_PCL_PKPROT_HASH_SHIFT 7
-#define OP_PCL_PKPROT_HASH_MASK (7 << OP_PCL_PKPROT_HASH_SHIFT)
-#define OP_PCL_PKPROT_HASH_MD5 (0 << OP_PCL_PKPROT_HASH_SHIFT)
-#define OP_PCL_PKPROT_HASH_SHA1 (1 << OP_PCL_PKPROT_HASH_SHIFT)
-#define OP_PCL_PKPROT_HASH_SHA224 (2 << OP_PCL_PKPROT_HASH_SHIFT)
-#define OP_PCL_PKPROT_HASH_SHA256 (3 << OP_PCL_PKPROT_HASH_SHIFT)
-#define OP_PCL_PKPROT_HASH_SHA384 (4 << OP_PCL_PKPROT_HASH_SHIFT)
-#define OP_PCL_PKPROT_HASH_SHA512 (5 << OP_PCL_PKPROT_HASH_SHIFT)
-#define OP_PCL_PKPROT_EKT_Z BIT(6)
-#define OP_PCL_PKPROT_DECRYPT_Z BIT(5)
-#define OP_PCL_PKPROT_EKT_PRI BIT(4)
-#define OP_PCL_PKPROT_TEST BIT(3)
-#define OP_PCL_PKPROT_DECRYPT_PRI BIT(2)
-#define OP_PCL_PKPROT_ECC BIT(1)
-#define OP_PCL_PKPROT_F2M BIT(0)
-
-/* Blob protinfos */
-#define OP_PCL_BLOB_TKEK_SHIFT 9
-#define OP_PCL_BLOB_TKEK BIT(9)
-#define OP_PCL_BLOB_EKT_SHIFT 8
-#define OP_PCL_BLOB_EKT BIT(8)
-#define OP_PCL_BLOB_REG_SHIFT 4
-#define OP_PCL_BLOB_REG_MASK (0xF << OP_PCL_BLOB_REG_SHIFT)
-#define OP_PCL_BLOB_REG_MEMORY (0x0 << OP_PCL_BLOB_REG_SHIFT)
-#define OP_PCL_BLOB_REG_KEY1 (0x1 << OP_PCL_BLOB_REG_SHIFT)
-#define OP_PCL_BLOB_REG_KEY2 (0x3 << OP_PCL_BLOB_REG_SHIFT)
-#define OP_PCL_BLOB_AFHA_SBOX (0x5 << OP_PCL_BLOB_REG_SHIFT)
-#define OP_PCL_BLOB_REG_SPLIT (0x7 << OP_PCL_BLOB_REG_SHIFT)
-#define OP_PCL_BLOB_REG_PKE (0x9 << OP_PCL_BLOB_REG_SHIFT)
-#define OP_PCL_BLOB_SEC_MEM_SHIFT 3
-#define OP_PCL_BLOB_SEC_MEM BIT(3)
-#define OP_PCL_BLOB_BLACK BIT(2)
-#define OP_PCL_BLOB_FORMAT_SHIFT 0
-#define OP_PCL_BLOB_FORMAT_MASK 0x3
-#define OP_PCL_BLOB_FORMAT_NORMAL 0
-#define OP_PCL_BLOB_FORMAT_MASTER_VER 2
-#define OP_PCL_BLOB_FORMAT_TEST 3
-
-/* IKE / IKEv2 protinfos */
-#define OP_PCL_IKE_HMAC_MD5 0x0100
-#define OP_PCL_IKE_HMAC_SHA1 0x0200
-#define OP_PCL_IKE_HMAC_AES128_CBC 0x0400
-#define OP_PCL_IKE_HMAC_SHA256 0x0500
-#define OP_PCL_IKE_HMAC_SHA384 0x0600
-#define OP_PCL_IKE_HMAC_SHA512 0x0700
-#define OP_PCL_IKE_HMAC_AES128_CMAC 0x0800
-
-/* PKI unidirectional protocol protinfo bits */
-#define OP_PCL_PKPROT_TEST BIT(3)
-#define OP_PCL_PKPROT_DECRYPT BIT(2)
-#define OP_PCL_PKPROT_ECC BIT(1)
-#define OP_PCL_PKPROT_F2M BIT(0)
-
-/* RSA Protinfo */
-#define OP_PCL_RSAPROT_OP_MASK 3
-#define OP_PCL_RSAPROT_OP_ENC_F_IN 0
-#define OP_PCL_RSAPROT_OP_ENC_F_OUT 1
-#define OP_PCL_RSAPROT_OP_DEC_ND 0
-#define OP_PCL_RSAPROT_OP_DEC_PQD 1
-#define OP_PCL_RSAPROT_OP_DEC_PQDPDQC 2
-#define OP_PCL_RSAPROT_FFF_SHIFT 4
-#define OP_PCL_RSAPROT_FFF_MASK (7 << OP_PCL_RSAPROT_FFF_SHIFT)
-#define OP_PCL_RSAPROT_FFF_RED (0 << OP_PCL_RSAPROT_FFF_SHIFT)
-#define OP_PCL_RSAPROT_FFF_ENC (1 << OP_PCL_RSAPROT_FFF_SHIFT)
-#define OP_PCL_RSAPROT_FFF_TK_ENC (5 << OP_PCL_RSAPROT_FFF_SHIFT)
-#define OP_PCL_RSAPROT_FFF_EKT (3 << OP_PCL_RSAPROT_FFF_SHIFT)
-#define OP_PCL_RSAPROT_FFF_TK_EKT (7 << OP_PCL_RSAPROT_FFF_SHIFT)
-#define OP_PCL_RSAPROT_PPP_SHIFT 8
-#define OP_PCL_RSAPROT_PPP_MASK (7 << OP_PCL_RSAPROT_PPP_SHIFT)
-#define OP_PCL_RSAPROT_PPP_RED (0 << OP_PCL_RSAPROT_PPP_SHIFT)
-#define OP_PCL_RSAPROT_PPP_ENC (1 << OP_PCL_RSAPROT_PPP_SHIFT)
-#define OP_PCL_RSAPROT_PPP_TK_ENC (5 << OP_PCL_RSAPROT_PPP_SHIFT)
-#define OP_PCL_RSAPROT_PPP_EKT (3 << OP_PCL_RSAPROT_PPP_SHIFT)
-#define OP_PCL_RSAPROT_PPP_TK_EKT (7 << OP_PCL_RSAPROT_PPP_SHIFT)
-#define OP_PCL_RSAPROT_FMT_PKCSV15 BIT(12)
-
-/* Derived Key Protocol (DKP) Protinfo */
-#define OP_PCL_DKP_SRC_SHIFT 14
-#define OP_PCL_DKP_SRC_MASK (3 << OP_PCL_DKP_SRC_SHIFT)
-#define OP_PCL_DKP_SRC_IMM (0 << OP_PCL_DKP_SRC_SHIFT)
-#define OP_PCL_DKP_SRC_SEQ (1 << OP_PCL_DKP_SRC_SHIFT)
-#define OP_PCL_DKP_SRC_PTR (2 << OP_PCL_DKP_SRC_SHIFT)
-#define OP_PCL_DKP_SRC_SGF (3 << OP_PCL_DKP_SRC_SHIFT)
-#define OP_PCL_DKP_DST_SHIFT 12
-#define OP_PCL_DKP_DST_MASK (3 << OP_PCL_DKP_DST_SHIFT)
-#define OP_PCL_DKP_DST_IMM (0 << OP_PCL_DKP_DST_SHIFT)
-#define OP_PCL_DKP_DST_SEQ (1 << OP_PCL_DKP_DST_SHIFT)
-#define OP_PCL_DKP_DST_PTR (2 << OP_PCL_DKP_DST_SHIFT)
-#define OP_PCL_DKP_DST_SGF (3 << OP_PCL_DKP_DST_SHIFT)
-#define OP_PCL_DKP_KEY_SHIFT 0
-#define OP_PCL_DKP_KEY_MASK (0xfff << OP_PCL_DKP_KEY_SHIFT)
-
-/* For non-protocol/alg-only op commands */
-#define OP_ALG_TYPE_SHIFT 24
-#define OP_ALG_TYPE_MASK (0x7 << OP_ALG_TYPE_SHIFT)
-#define OP_ALG_TYPE_CLASS1 (0x2 << OP_ALG_TYPE_SHIFT)
-#define OP_ALG_TYPE_CLASS2 (0x4 << OP_ALG_TYPE_SHIFT)
-
-#define OP_ALG_ALGSEL_SHIFT 16
-#define OP_ALG_ALGSEL_MASK (0xff << OP_ALG_ALGSEL_SHIFT)
-#define OP_ALG_ALGSEL_SUBMASK (0x0f << OP_ALG_ALGSEL_SHIFT)
-#define OP_ALG_ALGSEL_AES (0x10 << OP_ALG_ALGSEL_SHIFT)
-#define OP_ALG_ALGSEL_DES (0x20 << OP_ALG_ALGSEL_SHIFT)
-#define OP_ALG_ALGSEL_3DES (0x21 << OP_ALG_ALGSEL_SHIFT)
-#define OP_ALG_ALGSEL_ARC4 (0x30 << OP_ALG_ALGSEL_SHIFT)
-#define OP_ALG_ALGSEL_MD5 (0x40 << OP_ALG_ALGSEL_SHIFT)
-#define OP_ALG_ALGSEL_SHA1 (0x41 << OP_ALG_ALGSEL_SHIFT)
-#define OP_ALG_ALGSEL_SHA224 (0x42 << OP_ALG_ALGSEL_SHIFT)
-#define OP_ALG_ALGSEL_SHA256 (0x43 << OP_ALG_ALGSEL_SHIFT)
-#define OP_ALG_ALGSEL_SHA384 (0x44 << OP_ALG_ALGSEL_SHIFT)
-#define OP_ALG_ALGSEL_SHA512 (0x45 << OP_ALG_ALGSEL_SHIFT)
-#define OP_ALG_ALGSEL_RNG (0x50 << OP_ALG_ALGSEL_SHIFT)
-#define OP_ALG_ALGSEL_SNOW_F8 (0x60 << OP_ALG_ALGSEL_SHIFT)
-#define OP_ALG_ALGSEL_KASUMI (0x70 << OP_ALG_ALGSEL_SHIFT)
-#define OP_ALG_ALGSEL_CRC (0x90 << OP_ALG_ALGSEL_SHIFT)
-#define OP_ALG_ALGSEL_SNOW_F9 (0xA0 << OP_ALG_ALGSEL_SHIFT)
-#define OP_ALG_ALGSEL_ZUCE (0xB0 << OP_ALG_ALGSEL_SHIFT)
-#define OP_ALG_ALGSEL_ZUCA (0xC0 << OP_ALG_ALGSEL_SHIFT)
-
-#define OP_ALG_AAI_SHIFT 4
-#define OP_ALG_AAI_MASK (0x3ff << OP_ALG_AAI_SHIFT)
-
-/* block cipher AAI set */
-#define OP_ALG_AESA_MODE_MASK (0xF0 << OP_ALG_AAI_SHIFT)
-#define OP_ALG_AAI_CTR (0x00 << OP_ALG_AAI_SHIFT)
-#define OP_ALG_AAI_CTR_MOD128 (0x00 << OP_ALG_AAI_SHIFT)
-#define OP_ALG_AAI_CTR_MOD8 (0x01 << OP_ALG_AAI_SHIFT)
-#define OP_ALG_AAI_CTR_MOD16 (0x02 << OP_ALG_AAI_SHIFT)
-#define OP_ALG_AAI_CTR_MOD24 (0x03 << OP_ALG_AAI_SHIFT)
-#define OP_ALG_AAI_CTR_MOD32 (0x04 << OP_ALG_AAI_SHIFT)
-#define OP_ALG_AAI_CTR_MOD40 (0x05 << OP_ALG_AAI_SHIFT)
-#define OP_ALG_AAI_CTR_MOD48 (0x06 << OP_ALG_AAI_SHIFT)
-#define OP_ALG_AAI_CTR_MOD56 (0x07 << OP_ALG_AAI_SHIFT)
-#define OP_ALG_AAI_CTR_MOD64 (0x08 << OP_ALG_AAI_SHIFT)
-#define OP_ALG_AAI_CTR_MOD72 (0x09 << OP_ALG_AAI_SHIFT)
-#define OP_ALG_AAI_CTR_MOD80 (0x0a << OP_ALG_AAI_SHIFT)
-#define OP_ALG_AAI_CTR_MOD88 (0x0b << OP_ALG_AAI_SHIFT)
-#define OP_ALG_AAI_CTR_MOD96 (0x0c << OP_ALG_AAI_SHIFT)
-#define OP_ALG_AAI_CTR_MOD104 (0x0d << OP_ALG_AAI_SHIFT)
-#define OP_ALG_AAI_CTR_MOD112 (0x0e << OP_ALG_AAI_SHIFT)
-#define OP_ALG_AAI_CTR_MOD120 (0x0f << OP_ALG_AAI_SHIFT)
-#define OP_ALG_AAI_CBC (0x10 << OP_ALG_AAI_SHIFT)
-#define OP_ALG_AAI_ECB (0x20 << OP_ALG_AAI_SHIFT)
-#define OP_ALG_AAI_CFB (0x30 << OP_ALG_AAI_SHIFT)
-#define OP_ALG_AAI_OFB (0x40 << OP_ALG_AAI_SHIFT)
-#define OP_ALG_AAI_XTS (0x50 << OP_ALG_AAI_SHIFT)
-#define OP_ALG_AAI_CMAC (0x60 << OP_ALG_AAI_SHIFT)
-#define OP_ALG_AAI_XCBC_MAC (0x70 << OP_ALG_AAI_SHIFT)
-#define OP_ALG_AAI_CCM (0x80 << OP_ALG_AAI_SHIFT)
-#define OP_ALG_AAI_GCM (0x90 << OP_ALG_AAI_SHIFT)
-#define OP_ALG_AAI_CBC_XCBCMAC (0xa0 << OP_ALG_AAI_SHIFT)
-#define OP_ALG_AAI_CTR_XCBCMAC (0xb0 << OP_ALG_AAI_SHIFT)
-#define OP_ALG_AAI_CBC_CMAC (0xc0 << OP_ALG_AAI_SHIFT)
-#define OP_ALG_AAI_CTR_CMAC_LTE (0xd0 << OP_ALG_AAI_SHIFT)
-#define OP_ALG_AAI_CTR_CMAC (0xe0 << OP_ALG_AAI_SHIFT)
-#define OP_ALG_AAI_CHECKODD (0x80 << OP_ALG_AAI_SHIFT)
-#define OP_ALG_AAI_DK (0x100 << OP_ALG_AAI_SHIFT)
-#define OP_ALG_AAI_C2K (0x200 << OP_ALG_AAI_SHIFT)
-
-/* randomizer AAI set */
-#define OP_ALG_RNG_MODE_MASK (0x30 << OP_ALG_AAI_SHIFT)
-#define OP_ALG_AAI_RNG (0x00 << OP_ALG_AAI_SHIFT)
-#define OP_ALG_AAI_RNG_NZB (0x10 << OP_ALG_AAI_SHIFT)
-#define OP_ALG_AAI_RNG_OBP (0x20 << OP_ALG_AAI_SHIFT)
-
-/* RNG4 AAI set */
-#define OP_ALG_AAI_RNG4_SH_SHIFT OP_ALG_AAI_SHIFT
-#define OP_ALG_AAI_RNG4_SH_MASK (0x03 << OP_ALG_AAI_RNG4_SH_SHIFT)
-#define OP_ALG_AAI_RNG4_SH_0 (0x00 << OP_ALG_AAI_RNG4_SH_SHIFT)
-#define OP_ALG_AAI_RNG4_SH_1 (0x01 << OP_ALG_AAI_RNG4_SH_SHIFT)
-#define OP_ALG_AAI_RNG4_PS (0x40 << OP_ALG_AAI_SHIFT)
-#define OP_ALG_AAI_RNG4_AI (0x80 << OP_ALG_AAI_SHIFT)
-#define OP_ALG_AAI_RNG4_SK (0x100 << OP_ALG_AAI_SHIFT)
-
-/* hmac/smac AAI set */
-#define OP_ALG_AAI_HASH (0x00 << OP_ALG_AAI_SHIFT)
-#define OP_ALG_AAI_HMAC (0x01 << OP_ALG_AAI_SHIFT)
-#define OP_ALG_AAI_SMAC (0x02 << OP_ALG_AAI_SHIFT)
-#define OP_ALG_AAI_HMAC_PRECOMP (0x04 << OP_ALG_AAI_SHIFT)
-
-/* CRC AAI set*/
-#define OP_ALG_CRC_POLY_MASK (0x07 << OP_ALG_AAI_SHIFT)
-#define OP_ALG_AAI_802 (0x01 << OP_ALG_AAI_SHIFT)
-#define OP_ALG_AAI_3385 (0x02 << OP_ALG_AAI_SHIFT)
-#define OP_ALG_AAI_CUST_POLY (0x04 << OP_ALG_AAI_SHIFT)
-#define OP_ALG_AAI_DIS (0x10 << OP_ALG_AAI_SHIFT)
-#define OP_ALG_AAI_DOS (0x20 << OP_ALG_AAI_SHIFT)
-#define OP_ALG_AAI_DOC (0x40 << OP_ALG_AAI_SHIFT)
-#define OP_ALG_AAI_IVZ (0x80 << OP_ALG_AAI_SHIFT)
-
-/* Kasumi/SNOW/ZUC AAI set */
-#define OP_ALG_AAI_F8 (0xc0 << OP_ALG_AAI_SHIFT)
-#define OP_ALG_AAI_F9 (0xc8 << OP_ALG_AAI_SHIFT)
-#define OP_ALG_AAI_GSM (0x10 << OP_ALG_AAI_SHIFT)
-#define OP_ALG_AAI_EDGE (0x20 << OP_ALG_AAI_SHIFT)
-
-#define OP_ALG_AS_SHIFT 2
-#define OP_ALG_AS_MASK (0x3 << OP_ALG_AS_SHIFT)
-#define OP_ALG_AS_UPDATE (0 << OP_ALG_AS_SHIFT)
-#define OP_ALG_AS_INIT (1 << OP_ALG_AS_SHIFT)
-#define OP_ALG_AS_FINALIZE (2 << OP_ALG_AS_SHIFT)
-#define OP_ALG_AS_INITFINAL (3 << OP_ALG_AS_SHIFT)
-
-#define OP_ALG_ICV_SHIFT 1
-#define OP_ALG_ICV_MASK (1 << OP_ALG_ICV_SHIFT)
-#define OP_ALG_ICV_OFF 0
-#define OP_ALG_ICV_ON BIT(1)
-
-#define OP_ALG_DIR_SHIFT 0
-#define OP_ALG_DIR_MASK 1
-#define OP_ALG_DECRYPT 0
-#define OP_ALG_ENCRYPT BIT(0)
-
-/* PKHA algorithm type set */
-#define OP_ALG_PK 0x00800000
-#define OP_ALG_PK_FUN_MASK 0x3f /* clrmem, modmath, or cpymem */
-
-/* PKHA mode clear memory functions */
-#define OP_ALG_PKMODE_A_RAM BIT(19)
-#define OP_ALG_PKMODE_B_RAM BIT(18)
-#define OP_ALG_PKMODE_E_RAM BIT(17)
-#define OP_ALG_PKMODE_N_RAM BIT(16)
-#define OP_ALG_PKMODE_CLEARMEM BIT(0)
-
-/* PKHA mode clear memory functions */
-#define OP_ALG_PKMODE_CLEARMEM_ALL (OP_ALG_PKMODE_CLEARMEM | \
- OP_ALG_PKMODE_A_RAM | \
- OP_ALG_PKMODE_B_RAM | \
- OP_ALG_PKMODE_N_RAM | \
- OP_ALG_PKMODE_E_RAM)
-#define OP_ALG_PKMODE_CLEARMEM_ABE (OP_ALG_PKMODE_CLEARMEM | \
- OP_ALG_PKMODE_A_RAM | \
- OP_ALG_PKMODE_B_RAM | \
- OP_ALG_PKMODE_E_RAM)
-#define OP_ALG_PKMODE_CLEARMEM_ABN (OP_ALG_PKMODE_CLEARMEM | \
- OP_ALG_PKMODE_A_RAM | \
- OP_ALG_PKMODE_B_RAM | \
- OP_ALG_PKMODE_N_RAM)
-#define OP_ALG_PKMODE_CLEARMEM_AB (OP_ALG_PKMODE_CLEARMEM | \
- OP_ALG_PKMODE_A_RAM | \
- OP_ALG_PKMODE_B_RAM)
-#define OP_ALG_PKMODE_CLEARMEM_AEN (OP_ALG_PKMODE_CLEARMEM | \
- OP_ALG_PKMODE_A_RAM | \
- OP_ALG_PKMODE_E_RAM | \
- OP_ALG_PKMODE_N_RAM)
-#define OP_ALG_PKMODE_CLEARMEM_AE (OP_ALG_PKMODE_CLEARMEM | \
- OP_ALG_PKMODE_A_RAM | \
- OP_ALG_PKMODE_E_RAM)
-#define OP_ALG_PKMODE_CLEARMEM_AN (OP_ALG_PKMODE_CLEARMEM | \
- OP_ALG_PKMODE_A_RAM | \
- OP_ALG_PKMODE_N_RAM)
-#define OP_ALG_PKMODE_CLEARMEM_A (OP_ALG_PKMODE_CLEARMEM | \
- OP_ALG_PKMODE_A_RAM)
-#define OP_ALG_PKMODE_CLEARMEM_BEN (OP_ALG_PKMODE_CLEARMEM | \
- OP_ALG_PKMODE_B_RAM | \
- OP_ALG_PKMODE_E_RAM | \
- OP_ALG_PKMODE_N_RAM)
-#define OP_ALG_PKMODE_CLEARMEM_BE (OP_ALG_PKMODE_CLEARMEM | \
- OP_ALG_PKMODE_B_RAM | \
- OP_ALG_PKMODE_E_RAM)
-#define OP_ALG_PKMODE_CLEARMEM_BN (OP_ALG_PKMODE_CLEARMEM | \
- OP_ALG_PKMODE_B_RAM | \
- OP_ALG_PKMODE_N_RAM)
-#define OP_ALG_PKMODE_CLEARMEM_B (OP_ALG_PKMODE_CLEARMEM | \
- OP_ALG_PKMODE_B_RAM)
-#define OP_ALG_PKMODE_CLEARMEM_EN (OP_ALG_PKMODE_CLEARMEM | \
- OP_ALG_PKMODE_E_RAM | \
- OP_ALG_PKMODE_N_RAM)
-#define OP_ALG_PKMODE_CLEARMEM_E (OP_ALG_PKMODE_CLEARMEM | \
- OP_ALG_PKMODE_E_RAM)
-#define OP_ALG_PKMODE_CLEARMEM_N (OP_ALG_PKMODE_CLEARMEM | \
- OP_ALG_PKMODE_N_RAM)
-
-/* PKHA mode modular-arithmetic functions */
-#define OP_ALG_PKMODE_MOD_IN_MONTY BIT(19)
-#define OP_ALG_PKMODE_MOD_OUT_MONTY BIT(18)
-#define OP_ALG_PKMODE_MOD_F2M BIT(17)
-#define OP_ALG_PKMODE_MOD_R2_IN BIT(16)
-#define OP_ALG_PKMODE_PRJECTV BIT(11)
-#define OP_ALG_PKMODE_TIME_EQ BIT(10)
-
-#define OP_ALG_PKMODE_OUT_B 0x000
-#define OP_ALG_PKMODE_OUT_A 0x100
-
-/*
- * PKHA mode modular-arithmetic integer functions
- * Can be ORed with OP_ALG_PKMODE_OUT_A to change destination from B
- */
-#define OP_ALG_PKMODE_MOD_ADD 0x002
-#define OP_ALG_PKMODE_MOD_SUB_AB 0x003
-#define OP_ALG_PKMODE_MOD_SUB_BA 0x004
-#define OP_ALG_PKMODE_MOD_MULT 0x005
-#define OP_ALG_PKMODE_MOD_MULT_IM (0x005 | OP_ALG_PKMODE_MOD_IN_MONTY)
-#define OP_ALG_PKMODE_MOD_MULT_IM_OM (0x005 | OP_ALG_PKMODE_MOD_IN_MONTY \
- | OP_ALG_PKMODE_MOD_OUT_MONTY)
-#define OP_ALG_PKMODE_MOD_EXPO 0x006
-#define OP_ALG_PKMODE_MOD_EXPO_TEQ (0x006 | OP_ALG_PKMODE_TIME_EQ)
-#define OP_ALG_PKMODE_MOD_EXPO_IM (0x006 | OP_ALG_PKMODE_MOD_IN_MONTY)
-#define OP_ALG_PKMODE_MOD_EXPO_IM_TEQ (0x006 | OP_ALG_PKMODE_MOD_IN_MONTY \
- | OP_ALG_PKMODE_TIME_EQ)
-#define OP_ALG_PKMODE_MOD_REDUCT 0x007
-#define OP_ALG_PKMODE_MOD_INV 0x008
-#define OP_ALG_PKMODE_MOD_ECC_ADD 0x009
-#define OP_ALG_PKMODE_MOD_ECC_DBL 0x00a
-#define OP_ALG_PKMODE_MOD_ECC_MULT 0x00b
-#define OP_ALG_PKMODE_MOD_MONT_CNST 0x00c
-#define OP_ALG_PKMODE_MOD_CRT_CNST 0x00d
-#define OP_ALG_PKMODE_MOD_GCD 0x00e
-#define OP_ALG_PKMODE_MOD_PRIMALITY 0x00f
-#define OP_ALG_PKMODE_MOD_SML_EXP 0x016
-
-/*
- * PKHA mode modular-arithmetic F2m functions
- * Can be ORed with OP_ALG_PKMODE_OUT_A to change destination from B
- */
-#define OP_ALG_PKMODE_F2M_ADD (0x002 | OP_ALG_PKMODE_MOD_F2M)
-#define OP_ALG_PKMODE_F2M_MUL (0x005 | OP_ALG_PKMODE_MOD_F2M)
-#define OP_ALG_PKMODE_F2M_MUL_IM (0x005 | OP_ALG_PKMODE_MOD_F2M \
- | OP_ALG_PKMODE_MOD_IN_MONTY)
-#define OP_ALG_PKMODE_F2M_MUL_IM_OM (0x005 | OP_ALG_PKMODE_MOD_F2M \
- | OP_ALG_PKMODE_MOD_IN_MONTY \
- | OP_ALG_PKMODE_MOD_OUT_MONTY)
-#define OP_ALG_PKMODE_F2M_EXP (0x006 | OP_ALG_PKMODE_MOD_F2M)
-#define OP_ALG_PKMODE_F2M_EXP_TEQ (0x006 | OP_ALG_PKMODE_MOD_F2M \
- | OP_ALG_PKMODE_TIME_EQ)
-#define OP_ALG_PKMODE_F2M_AMODN (0x007 | OP_ALG_PKMODE_MOD_F2M)
-#define OP_ALG_PKMODE_F2M_INV (0x008 | OP_ALG_PKMODE_MOD_F2M)
-#define OP_ALG_PKMODE_F2M_R2 (0x00c | OP_ALG_PKMODE_MOD_F2M)
-#define OP_ALG_PKMODE_F2M_GCD (0x00e | OP_ALG_PKMODE_MOD_F2M)
-#define OP_ALG_PKMODE_F2M_SML_EXP (0x016 | OP_ALG_PKMODE_MOD_F2M)
-
-/*
- * PKHA mode ECC Integer arithmetic functions
- * Can be ORed with OP_ALG_PKMODE_OUT_A to change destination from B
- */
-#define OP_ALG_PKMODE_ECC_MOD_ADD 0x009
-#define OP_ALG_PKMODE_ECC_MOD_ADD_IM_OM_PROJ \
- (0x009 | OP_ALG_PKMODE_MOD_IN_MONTY \
- | OP_ALG_PKMODE_MOD_OUT_MONTY \
- | OP_ALG_PKMODE_PRJECTV)
-#define OP_ALG_PKMODE_ECC_MOD_DBL 0x00a
-#define OP_ALG_PKMODE_ECC_MOD_DBL_IM_OM_PROJ \
- (0x00a | OP_ALG_PKMODE_MOD_IN_MONTY \
- | OP_ALG_PKMODE_MOD_OUT_MONTY \
- | OP_ALG_PKMODE_PRJECTV)
-#define OP_ALG_PKMODE_ECC_MOD_MUL 0x00b
-#define OP_ALG_PKMODE_ECC_MOD_MUL_TEQ (0x00b | OP_ALG_PKMODE_TIME_EQ)
-#define OP_ALG_PKMODE_ECC_MOD_MUL_R2 (0x00b | OP_ALG_PKMODE_MOD_R2_IN)
-#define OP_ALG_PKMODE_ECC_MOD_MUL_R2_TEQ \
- (0x00b | OP_ALG_PKMODE_MOD_R2_IN \
- | OP_ALG_PKMODE_TIME_EQ)
-#define OP_ALG_PKMODE_ECC_MOD_MUL_R2_PROJ \
- (0x00b | OP_ALG_PKMODE_MOD_R2_IN \
- | OP_ALG_PKMODE_PRJECTV)
-#define OP_ALG_PKMODE_ECC_MOD_MUL_R2_PROJ_TEQ \
- (0x00b | OP_ALG_PKMODE_MOD_R2_IN \
- | OP_ALG_PKMODE_PRJECTV \
- | OP_ALG_PKMODE_TIME_EQ)
-
-/*
- * PKHA mode ECC F2m arithmetic functions
- * Can be ORed with OP_ALG_PKMODE_OUT_A to change destination from B
- */
-#define OP_ALG_PKMODE_ECC_F2M_ADD (0x009 | OP_ALG_PKMODE_MOD_F2M)
-#define OP_ALG_PKMODE_ECC_F2M_ADD_IM_OM_PROJ \
- (0x009 | OP_ALG_PKMODE_MOD_F2M \
- | OP_ALG_PKMODE_MOD_IN_MONTY \
- | OP_ALG_PKMODE_MOD_OUT_MONTY \
- | OP_ALG_PKMODE_PRJECTV)
-#define OP_ALG_PKMODE_ECC_F2M_DBL (0x00a | OP_ALG_PKMODE_MOD_F2M)
-#define OP_ALG_PKMODE_ECC_F2M_DBL_IM_OM_PROJ \
- (0x00a | OP_ALG_PKMODE_MOD_F2M \
- | OP_ALG_PKMODE_MOD_IN_MONTY \
- | OP_ALG_PKMODE_MOD_OUT_MONTY \
- | OP_ALG_PKMODE_PRJECTV)
-#define OP_ALG_PKMODE_ECC_F2M_MUL (0x00b | OP_ALG_PKMODE_MOD_F2M)
-#define OP_ALG_PKMODE_ECC_F2M_MUL_TEQ \
- (0x00b | OP_ALG_PKMODE_MOD_F2M \
- | OP_ALG_PKMODE_TIME_EQ)
-#define OP_ALG_PKMODE_ECC_F2M_MUL_R2 \
- (0x00b | OP_ALG_PKMODE_MOD_F2M \
- | OP_ALG_PKMODE_MOD_R2_IN)
-#define OP_ALG_PKMODE_ECC_F2M_MUL_R2_TEQ \
- (0x00b | OP_ALG_PKMODE_MOD_F2M \
- | OP_ALG_PKMODE_MOD_R2_IN \
- | OP_ALG_PKMODE_TIME_EQ)
-#define OP_ALG_PKMODE_ECC_F2M_MUL_R2_PROJ \
- (0x00b | OP_ALG_PKMODE_MOD_F2M \
- | OP_ALG_PKMODE_MOD_R2_IN \
- | OP_ALG_PKMODE_PRJECTV)
-#define OP_ALG_PKMODE_ECC_F2M_MUL_R2_PROJ_TEQ \
- (0x00b | OP_ALG_PKMODE_MOD_F2M \
- | OP_ALG_PKMODE_MOD_R2_IN \
- | OP_ALG_PKMODE_PRJECTV \
- | OP_ALG_PKMODE_TIME_EQ)
-
-/* PKHA mode copy-memory functions */
-#define OP_ALG_PKMODE_SRC_REG_SHIFT 17
-#define OP_ALG_PKMODE_SRC_REG_MASK (7 << OP_ALG_PKMODE_SRC_REG_SHIFT)
-#define OP_ALG_PKMODE_DST_REG_SHIFT 10
-#define OP_ALG_PKMODE_DST_REG_MASK (7 << OP_ALG_PKMODE_DST_REG_SHIFT)
-#define OP_ALG_PKMODE_SRC_SEG_SHIFT 8
-#define OP_ALG_PKMODE_SRC_SEG_MASK (3 << OP_ALG_PKMODE_SRC_SEG_SHIFT)
-#define OP_ALG_PKMODE_DST_SEG_SHIFT 6
-#define OP_ALG_PKMODE_DST_SEG_MASK (3 << OP_ALG_PKMODE_DST_SEG_SHIFT)
-
-#define OP_ALG_PKMODE_SRC_REG_A (0 << OP_ALG_PKMODE_SRC_REG_SHIFT)
-#define OP_ALG_PKMODE_SRC_REG_B (1 << OP_ALG_PKMODE_SRC_REG_SHIFT)
-#define OP_ALG_PKMODE_SRC_REG_N (3 << OP_ALG_PKMODE_SRC_REG_SHIFT)
-#define OP_ALG_PKMODE_DST_REG_A (0 << OP_ALG_PKMODE_DST_REG_SHIFT)
-#define OP_ALG_PKMODE_DST_REG_B (1 << OP_ALG_PKMODE_DST_REG_SHIFT)
-#define OP_ALG_PKMODE_DST_REG_E (2 << OP_ALG_PKMODE_DST_REG_SHIFT)
-#define OP_ALG_PKMODE_DST_REG_N (3 << OP_ALG_PKMODE_DST_REG_SHIFT)
-#define OP_ALG_PKMODE_SRC_SEG_0 (0 << OP_ALG_PKMODE_SRC_SEG_SHIFT)
-#define OP_ALG_PKMODE_SRC_SEG_1 (1 << OP_ALG_PKMODE_SRC_SEG_SHIFT)
-#define OP_ALG_PKMODE_SRC_SEG_2 (2 << OP_ALG_PKMODE_SRC_SEG_SHIFT)
-#define OP_ALG_PKMODE_SRC_SEG_3 (3 << OP_ALG_PKMODE_SRC_SEG_SHIFT)
-#define OP_ALG_PKMODE_DST_SEG_0 (0 << OP_ALG_PKMODE_DST_SEG_SHIFT)
-#define OP_ALG_PKMODE_DST_SEG_1 (1 << OP_ALG_PKMODE_DST_SEG_SHIFT)
-#define OP_ALG_PKMODE_DST_SEG_2 (2 << OP_ALG_PKMODE_DST_SEG_SHIFT)
-#define OP_ALG_PKMODE_DST_SEG_3 (3 << OP_ALG_PKMODE_DST_SEG_SHIFT)
-
-/* PKHA mode copy-memory functions - amount based on N SIZE */
-#define OP_ALG_PKMODE_COPY_NSZ 0x10
-#define OP_ALG_PKMODE_COPY_NSZ_A0_B0 (OP_ALG_PKMODE_COPY_NSZ | \
- OP_ALG_PKMODE_SRC_REG_A | \
- OP_ALG_PKMODE_DST_REG_B)
-#define OP_ALG_PKMODE_COPY_NSZ_A0_B1 (OP_ALG_PKMODE_COPY_NSZ | \
- OP_ALG_PKMODE_SRC_REG_A | \
- OP_ALG_PKMODE_DST_REG_B | \
- OP_ALG_PKMODE_DST_SEG_1)
-#define OP_ALG_PKMODE_COPY_NSZ_A0_B2 (OP_ALG_PKMODE_COPY_NSZ | \
- OP_ALG_PKMODE_SRC_REG_A | \
- OP_ALG_PKMODE_DST_REG_B | \
- OP_ALG_PKMODE_DST_SEG_2)
-#define OP_ALG_PKMODE_COPY_NSZ_A0_B3 (OP_ALG_PKMODE_COPY_NSZ | \
- OP_ALG_PKMODE_SRC_REG_A | \
- OP_ALG_PKMODE_DST_REG_B | \
- OP_ALG_PKMODE_DST_SEG_3)
-
-#define OP_ALG_PKMODE_COPY_NSZ_A1_B0 (OP_ALG_PKMODE_COPY_NSZ | \
- OP_ALG_PKMODE_SRC_REG_A | \
- OP_ALG_PKMODE_SRC_SEG_1 | \
- OP_ALG_PKMODE_DST_REG_B)
-#define OP_ALG_PKMODE_COPY_NSZ_A1_B1 (OP_ALG_PKMODE_COPY_NSZ | \
- OP_ALG_PKMODE_SRC_REG_A | \
- OP_ALG_PKMODE_SRC_SEG_1 | \
- OP_ALG_PKMODE_DST_REG_B | \
- OP_ALG_PKMODE_DST_SEG_1)
-#define OP_ALG_PKMODE_COPY_NSZ_A1_B2 (OP_ALG_PKMODE_COPY_NSZ | \
- OP_ALG_PKMODE_SRC_REG_A | \
- OP_ALG_PKMODE_SRC_SEG_1 | \
- OP_ALG_PKMODE_DST_REG_B | \
- OP_ALG_PKMODE_DST_SEG_2)
-#define OP_ALG_PKMODE_COPY_NSZ_A1_B3 (OP_ALG_PKMODE_COPY_NSZ | \
- OP_ALG_PKMODE_SRC_REG_A | \
- OP_ALG_PKMODE_SRC_SEG_1 | \
- OP_ALG_PKMODE_DST_REG_B | \
- OP_ALG_PKMODE_DST_SEG_3)
-
-#define OP_ALG_PKMODE_COPY_NSZ_A2_B0 (OP_ALG_PKMODE_COPY_NSZ | \
- OP_ALG_PKMODE_SRC_REG_A | \
- OP_ALG_PKMODE_SRC_SEG_2 | \
- OP_ALG_PKMODE_DST_REG_B)
-#define OP_ALG_PKMODE_COPY_NSZ_A2_B1 (OP_ALG_PKMODE_COPY_NSZ | \
- OP_ALG_PKMODE_SRC_REG_A | \
- OP_ALG_PKMODE_SRC_SEG_2 | \
- OP_ALG_PKMODE_DST_REG_B | \
- OP_ALG_PKMODE_DST_SEG_1)
-#define OP_ALG_PKMODE_COPY_NSZ_A2_B2 (OP_ALG_PKMODE_COPY_NSZ | \
- OP_ALG_PKMODE_SRC_REG_A | \
- OP_ALG_PKMODE_SRC_SEG_2 | \
- OP_ALG_PKMODE_DST_REG_B | \
- OP_ALG_PKMODE_DST_SEG_2)
-#define OP_ALG_PKMODE_COPY_NSZ_A2_B3 (OP_ALG_PKMODE_COPY_NSZ | \
- OP_ALG_PKMODE_SRC_REG_A | \
- OP_ALG_PKMODE_SRC_SEG_2 | \
- OP_ALG_PKMODE_DST_REG_B | \
- OP_ALG_PKMODE_DST_SEG_3)
-
-#define OP_ALG_PKMODE_COPY_NSZ_A3_B0 (OP_ALG_PKMODE_COPY_NSZ | \
- OP_ALG_PKMODE_SRC_REG_A | \
- OP_ALG_PKMODE_SRC_SEG_3 | \
- OP_ALG_PKMODE_DST_REG_B)
-#define OP_ALG_PKMODE_COPY_NSZ_A3_B1 (OP_ALG_PKMODE_COPY_NSZ | \
- OP_ALG_PKMODE_SRC_REG_A | \
- OP_ALG_PKMODE_SRC_SEG_3 | \
- OP_ALG_PKMODE_DST_REG_B | \
- OP_ALG_PKMODE_DST_SEG_1)
-#define OP_ALG_PKMODE_COPY_NSZ_A3_B2 (OP_ALG_PKMODE_COPY_NSZ | \
- OP_ALG_PKMODE_SRC_REG_A | \
- OP_ALG_PKMODE_SRC_SEG_3 | \
- OP_ALG_PKMODE_DST_REG_B | \
- OP_ALG_PKMODE_DST_SEG_2)
-#define OP_ALG_PKMODE_COPY_NSZ_A3_B3 (OP_ALG_PKMODE_COPY_NSZ | \
- OP_ALG_PKMODE_SRC_REG_A | \
- OP_ALG_PKMODE_SRC_SEG_3 | \
- OP_ALG_PKMODE_DST_REG_B | \
- OP_ALG_PKMODE_DST_SEG_3)
-
-#define OP_ALG_PKMODE_COPY_NSZ_B0_A0 (OP_ALG_PKMODE_COPY_NSZ | \
- OP_ALG_PKMODE_SRC_REG_B | \
- OP_ALG_PKMODE_DST_REG_A)
-#define OP_ALG_PKMODE_COPY_NSZ_B0_A1 (OP_ALG_PKMODE_COPY_NSZ | \
- OP_ALG_PKMODE_SRC_REG_B | \
- OP_ALG_PKMODE_DST_REG_A | \
- OP_ALG_PKMODE_DST_SEG_1)
-#define OP_ALG_PKMODE_COPY_NSZ_B0_A2 (OP_ALG_PKMODE_COPY_NSZ | \
- OP_ALG_PKMODE_SRC_REG_B | \
- OP_ALG_PKMODE_DST_REG_A | \
- OP_ALG_PKMODE_DST_SEG_2)
-#define OP_ALG_PKMODE_COPY_NSZ_B0_A3 (OP_ALG_PKMODE_COPY_NSZ | \
- OP_ALG_PKMODE_SRC_REG_B | \
- OP_ALG_PKMODE_DST_REG_A | \
- OP_ALG_PKMODE_DST_SEG_3)
-
-#define OP_ALG_PKMODE_COPY_NSZ_B1_A0 (OP_ALG_PKMODE_COPY_NSZ | \
- OP_ALG_PKMODE_SRC_REG_B | \
- OP_ALG_PKMODE_SRC_SEG_1 | \
- OP_ALG_PKMODE_DST_REG_A)
-#define OP_ALG_PKMODE_COPY_NSZ_B1_A1 (OP_ALG_PKMODE_COPY_NSZ | \
- OP_ALG_PKMODE_SRC_REG_B | \
- OP_ALG_PKMODE_SRC_SEG_1 | \
- OP_ALG_PKMODE_DST_REG_A | \
- OP_ALG_PKMODE_DST_SEG_1)
-#define OP_ALG_PKMODE_COPY_NSZ_B1_A2 (OP_ALG_PKMODE_COPY_NSZ | \
- OP_ALG_PKMODE_SRC_REG_B | \
- OP_ALG_PKMODE_SRC_SEG_1 | \
- OP_ALG_PKMODE_DST_REG_A | \
- OP_ALG_PKMODE_DST_SEG_2)
-#define OP_ALG_PKMODE_COPY_NSZ_B1_A3 (OP_ALG_PKMODE_COPY_NSZ | \
- OP_ALG_PKMODE_SRC_REG_B | \
- OP_ALG_PKMODE_SRC_SEG_1 | \
- OP_ALG_PKMODE_DST_REG_A | \
- OP_ALG_PKMODE_DST_SEG_3)
-
-#define OP_ALG_PKMODE_COPY_NSZ_B2_A0 (OP_ALG_PKMODE_COPY_NSZ | \
- OP_ALG_PKMODE_SRC_REG_B | \
- OP_ALG_PKMODE_SRC_SEG_2 | \
- OP_ALG_PKMODE_DST_REG_A)
-#define OP_ALG_PKMODE_COPY_NSZ_B2_A1 (OP_ALG_PKMODE_COPY_NSZ | \
- OP_ALG_PKMODE_SRC_REG_B | \
- OP_ALG_PKMODE_SRC_SEG_2 | \
- OP_ALG_PKMODE_DST_REG_A | \
- OP_ALG_PKMODE_DST_SEG_1)
-#define OP_ALG_PKMODE_COPY_NSZ_B2_A2 (OP_ALG_PKMODE_COPY_NSZ | \
- OP_ALG_PKMODE_SRC_REG_B | \
- OP_ALG_PKMODE_SRC_SEG_2 | \
- OP_ALG_PKMODE_DST_REG_A | \
- OP_ALG_PKMODE_DST_SEG_2)
-#define OP_ALG_PKMODE_COPY_NSZ_B2_A3 (OP_ALG_PKMODE_COPY_NSZ | \
- OP_ALG_PKMODE_SRC_REG_B | \
- OP_ALG_PKMODE_SRC_SEG_2 | \
- OP_ALG_PKMODE_DST_REG_A | \
- OP_ALG_PKMODE_DST_SEG_3)
-
-#define OP_ALG_PKMODE_COPY_NSZ_B3_A0 (OP_ALG_PKMODE_COPY_NSZ | \
- OP_ALG_PKMODE_SRC_REG_B | \
- OP_ALG_PKMODE_SRC_SEG_3 | \
- OP_ALG_PKMODE_DST_REG_A)
-#define OP_ALG_PKMODE_COPY_NSZ_B3_A1 (OP_ALG_PKMODE_COPY_NSZ | \
- OP_ALG_PKMODE_SRC_REG_B | \
- OP_ALG_PKMODE_SRC_SEG_3 | \
- OP_ALG_PKMODE_DST_REG_A | \
- OP_ALG_PKMODE_DST_SEG_1)
-#define OP_ALG_PKMODE_COPY_NSZ_B3_A2 (OP_ALG_PKMODE_COPY_NSZ | \
- OP_ALG_PKMODE_SRC_REG_B | \
- OP_ALG_PKMODE_SRC_SEG_3 | \
- OP_ALG_PKMODE_DST_REG_A | \
- OP_ALG_PKMODE_DST_SEG_2)
-#define OP_ALG_PKMODE_COPY_NSZ_B3_A3 (OP_ALG_PKMODE_COPY_NSZ | \
- OP_ALG_PKMODE_SRC_REG_B | \
- OP_ALG_PKMODE_SRC_SEG_3 | \
- OP_ALG_PKMODE_DST_REG_A | \
- OP_ALG_PKMODE_DST_SEG_3)
-
-#define OP_ALG_PKMODE_COPY_NSZ_A_B (OP_ALG_PKMODE_COPY_NSZ | \
- OP_ALG_PKMODE_SRC_REG_A | \
- OP_ALG_PKMODE_DST_REG_B)
-#define OP_ALG_PKMODE_COPY_NSZ_A_E (OP_ALG_PKMODE_COPY_NSZ | \
- OP_ALG_PKMODE_SRC_REG_A | \
- OP_ALG_PKMODE_DST_REG_E)
-#define OP_ALG_PKMODE_COPY_NSZ_A_N (OP_ALG_PKMODE_COPY_NSZ | \
- OP_ALG_PKMODE_SRC_REG_A | \
- OP_ALG_PKMODE_DST_REG_N)
-#define OP_ALG_PKMODE_COPY_NSZ_B_A (OP_ALG_PKMODE_COPY_NSZ | \
- OP_ALG_PKMODE_SRC_REG_B | \
- OP_ALG_PKMODE_DST_REG_A)
-#define OP_ALG_PKMODE_COPY_NSZ_B_E (OP_ALG_PKMODE_COPY_NSZ | \
- OP_ALG_PKMODE_SRC_REG_B | \
- OP_ALG_PKMODE_DST_REG_E)
-#define OP_ALG_PKMODE_COPY_NSZ_B_N (OP_ALG_PKMODE_COPY_NSZ | \
- OP_ALG_PKMODE_SRC_REG_B | \
- OP_ALG_PKMODE_DST_REG_N)
-#define OP_ALG_PKMODE_COPY_NSZ_N_A (OP_ALG_PKMODE_COPY_NSZ | \
- OP_ALG_PKMODE_SRC_REG_N | \
- OP_ALG_PKMODE_DST_REG_A)
-#define OP_ALG_PKMODE_COPY_NSZ_N_B (OP_ALG_PKMODE_COPY_NSZ | \
- OP_ALG_PKMODE_SRC_REG_N | \
- OP_ALG_PKMODE_DST_REG_B)
-#define OP_ALG_PKMODE_COPY_NSZ_N_E (OP_ALG_PKMODE_COPY_NSZ | \
- OP_ALG_PKMODE_SRC_REG_N | \
- OP_ALG_PKMODE_DST_REG_E)
-
-/* PKHA mode copy-memory functions - amount based on SRC SIZE */
-#define OP_ALG_PKMODE_COPY_SSZ 0x11
-#define OP_ALG_PKMODE_COPY_SSZ_A0_B0 (OP_ALG_PKMODE_COPY_SSZ | \
- OP_ALG_PKMODE_SRC_REG_A | \
- OP_ALG_PKMODE_DST_REG_B)
-#define OP_ALG_PKMODE_COPY_SSZ_A0_B1 (OP_ALG_PKMODE_COPY_SSZ | \
- OP_ALG_PKMODE_SRC_REG_A | \
- OP_ALG_PKMODE_DST_REG_B | \
- OP_ALG_PKMODE_DST_SEG_1)
-#define OP_ALG_PKMODE_COPY_SSZ_A0_B2 (OP_ALG_PKMODE_COPY_SSZ | \
- OP_ALG_PKMODE_SRC_REG_A | \
- OP_ALG_PKMODE_DST_REG_B | \
- OP_ALG_PKMODE_DST_SEG_2)
-#define OP_ALG_PKMODE_COPY_SSZ_A0_B3 (OP_ALG_PKMODE_COPY_SSZ | \
- OP_ALG_PKMODE_SRC_REG_A | \
- OP_ALG_PKMODE_DST_REG_B | \
- OP_ALG_PKMODE_DST_SEG_3)
-
-#define OP_ALG_PKMODE_COPY_SSZ_A1_B0 (OP_ALG_PKMODE_COPY_SSZ | \
- OP_ALG_PKMODE_SRC_REG_A | \
- OP_ALG_PKMODE_SRC_SEG_1 | \
- OP_ALG_PKMODE_DST_REG_B)
-#define OP_ALG_PKMODE_COPY_SSZ_A1_B1 (OP_ALG_PKMODE_COPY_SSZ | \
- OP_ALG_PKMODE_SRC_REG_A | \
- OP_ALG_PKMODE_SRC_SEG_1 | \
- OP_ALG_PKMODE_DST_REG_B | \
- OP_ALG_PKMODE_DST_SEG_1)
-#define OP_ALG_PKMODE_COPY_SSZ_A1_B2 (OP_ALG_PKMODE_COPY_SSZ | \
- OP_ALG_PKMODE_SRC_REG_A | \
- OP_ALG_PKMODE_SRC_SEG_1 | \
- OP_ALG_PKMODE_DST_REG_B | \
- OP_ALG_PKMODE_DST_SEG_2)
-#define OP_ALG_PKMODE_COPY_SSZ_A1_B3 (OP_ALG_PKMODE_COPY_SSZ | \
- OP_ALG_PKMODE_SRC_REG_A | \
- OP_ALG_PKMODE_SRC_SEG_1 | \
- OP_ALG_PKMODE_DST_REG_B | \
- OP_ALG_PKMODE_DST_SEG_3)
-
-#define OP_ALG_PKMODE_COPY_SSZ_A2_B0 (OP_ALG_PKMODE_COPY_SSZ | \
- OP_ALG_PKMODE_SRC_REG_A | \
- OP_ALG_PKMODE_SRC_SEG_2 | \
- OP_ALG_PKMODE_DST_REG_B)
-#define OP_ALG_PKMODE_COPY_SSZ_A2_B1 (OP_ALG_PKMODE_COPY_SSZ | \
- OP_ALG_PKMODE_SRC_REG_A | \
- OP_ALG_PKMODE_SRC_SEG_2 | \
- OP_ALG_PKMODE_DST_REG_B | \
- OP_ALG_PKMODE_DST_SEG_1)
-#define OP_ALG_PKMODE_COPY_SSZ_A2_B2 (OP_ALG_PKMODE_COPY_SSZ | \
- OP_ALG_PKMODE_SRC_REG_A | \
- OP_ALG_PKMODE_SRC_SEG_2 | \
- OP_ALG_PKMODE_DST_REG_B | \
- OP_ALG_PKMODE_DST_SEG_2)
-#define OP_ALG_PKMODE_COPY_SSZ_A2_B3 (OP_ALG_PKMODE_COPY_SSZ | \
- OP_ALG_PKMODE_SRC_REG_A | \
- OP_ALG_PKMODE_SRC_SEG_2 | \
- OP_ALG_PKMODE_DST_REG_B | \
- OP_ALG_PKMODE_DST_SEG_3)
-
-#define OP_ALG_PKMODE_COPY_SSZ_A3_B0 (OP_ALG_PKMODE_COPY_SSZ | \
- OP_ALG_PKMODE_SRC_REG_A | \
- OP_ALG_PKMODE_SRC_SEG_3 | \
- OP_ALG_PKMODE_DST_REG_B)
-#define OP_ALG_PKMODE_COPY_SSZ_A3_B1 (OP_ALG_PKMODE_COPY_SSZ | \
- OP_ALG_PKMODE_SRC_REG_A | \
- OP_ALG_PKMODE_SRC_SEG_3 | \
- OP_ALG_PKMODE_DST_REG_B | \
- OP_ALG_PKMODE_DST_SEG_1)
-#define OP_ALG_PKMODE_COPY_SSZ_A3_B2 (OP_ALG_PKMODE_COPY_SSZ | \
- OP_ALG_PKMODE_SRC_REG_A | \
- OP_ALG_PKMODE_SRC_SEG_3 | \
- OP_ALG_PKMODE_DST_REG_B | \
- OP_ALG_PKMODE_DST_SEG_2)
-#define OP_ALG_PKMODE_COPY_SSZ_A3_B3 (OP_ALG_PKMODE_COPY_SSZ | \
- OP_ALG_PKMODE_SRC_REG_A | \
- OP_ALG_PKMODE_SRC_SEG_3 | \
- OP_ALG_PKMODE_DST_REG_B | \
- OP_ALG_PKMODE_DST_SEG_3)
-
-#define OP_ALG_PKMODE_COPY_SSZ_B0_A0 (OP_ALG_PKMODE_COPY_SSZ | \
- OP_ALG_PKMODE_SRC_REG_B | \
- OP_ALG_PKMODE_DST_REG_A)
-#define OP_ALG_PKMODE_COPY_SSZ_B0_A1 (OP_ALG_PKMODE_COPY_SSZ | \
- OP_ALG_PKMODE_SRC_REG_B | \
- OP_ALG_PKMODE_DST_REG_A | \
- OP_ALG_PKMODE_DST_SEG_1)
-#define OP_ALG_PKMODE_COPY_SSZ_B0_A2 (OP_ALG_PKMODE_COPY_SSZ | \
- OP_ALG_PKMODE_SRC_REG_B | \
- OP_ALG_PKMODE_DST_REG_A | \
- OP_ALG_PKMODE_DST_SEG_2)
-#define OP_ALG_PKMODE_COPY_SSZ_B0_A3 (OP_ALG_PKMODE_COPY_SSZ | \
- OP_ALG_PKMODE_SRC_REG_B | \
- OP_ALG_PKMODE_DST_REG_A | \
- OP_ALG_PKMODE_DST_SEG_3)
-
-#define OP_ALG_PKMODE_COPY_SSZ_B1_A0 (OP_ALG_PKMODE_COPY_SSZ | \
- OP_ALG_PKMODE_SRC_REG_B | \
- OP_ALG_PKMODE_SRC_SEG_1 | \
- OP_ALG_PKMODE_DST_REG_A)
-#define OP_ALG_PKMODE_COPY_SSZ_B1_A1 (OP_ALG_PKMODE_COPY_SSZ | \
- OP_ALG_PKMODE_SRC_REG_B | \
- OP_ALG_PKMODE_SRC_SEG_1 | \
- OP_ALG_PKMODE_DST_REG_A | \
- OP_ALG_PKMODE_DST_SEG_1)
-#define OP_ALG_PKMODE_COPY_SSZ_B1_A2 (OP_ALG_PKMODE_COPY_SSZ | \
- OP_ALG_PKMODE_SRC_REG_B | \
- OP_ALG_PKMODE_SRC_SEG_1 | \
- OP_ALG_PKMODE_DST_REG_A | \
- OP_ALG_PKMODE_DST_SEG_2)
-#define OP_ALG_PKMODE_COPY_SSZ_B1_A3 (OP_ALG_PKMODE_COPY_SSZ | \
- OP_ALG_PKMODE_SRC_REG_B | \
- OP_ALG_PKMODE_SRC_SEG_1 | \
- OP_ALG_PKMODE_DST_REG_A | \
- OP_ALG_PKMODE_DST_SEG_3)
-
-#define OP_ALG_PKMODE_COPY_SSZ_B2_A0 (OP_ALG_PKMODE_COPY_SSZ | \
- OP_ALG_PKMODE_SRC_REG_B | \
- OP_ALG_PKMODE_SRC_SEG_2 | \
- OP_ALG_PKMODE_DST_REG_A)
-#define OP_ALG_PKMODE_COPY_SSZ_B2_A1 (OP_ALG_PKMODE_COPY_SSZ | \
- OP_ALG_PKMODE_SRC_REG_B | \
- OP_ALG_PKMODE_SRC_SEG_2 | \
- OP_ALG_PKMODE_DST_REG_A | \
- OP_ALG_PKMODE_DST_SEG_1)
-#define OP_ALG_PKMODE_COPY_SSZ_B2_A2 (OP_ALG_PKMODE_COPY_SSZ | \
- OP_ALG_PKMODE_SRC_REG_B | \
- OP_ALG_PKMODE_SRC_SEG_2 | \
- OP_ALG_PKMODE_DST_REG_A | \
- OP_ALG_PKMODE_DST_SEG_2)
-#define OP_ALG_PKMODE_COPY_SSZ_B2_A3 (OP_ALG_PKMODE_COPY_SSZ | \
- OP_ALG_PKMODE_SRC_REG_B | \
- OP_ALG_PKMODE_SRC_SEG_2 | \
- OP_ALG_PKMODE_DST_REG_A | \
- OP_ALG_PKMODE_DST_SEG_3)
-
-#define OP_ALG_PKMODE_COPY_SSZ_B3_A0 (OP_ALG_PKMODE_COPY_SSZ | \
- OP_ALG_PKMODE_SRC_REG_B | \
- OP_ALG_PKMODE_SRC_SEG_3 | \
- OP_ALG_PKMODE_DST_REG_A)
-#define OP_ALG_PKMODE_COPY_SSZ_B3_A1 (OP_ALG_PKMODE_COPY_SSZ | \
- OP_ALG_PKMODE_SRC_REG_B | \
- OP_ALG_PKMODE_SRC_SEG_3 | \
- OP_ALG_PKMODE_DST_REG_A | \
- OP_ALG_PKMODE_DST_SEG_1)
-#define OP_ALG_PKMODE_COPY_SSZ_B3_A2 (OP_ALG_PKMODE_COPY_SSZ | \
- OP_ALG_PKMODE_SRC_REG_B | \
- OP_ALG_PKMODE_SRC_SEG_3 | \
- OP_ALG_PKMODE_DST_REG_A | \
- OP_ALG_PKMODE_DST_SEG_2)
-#define OP_ALG_PKMODE_COPY_SSZ_B3_A3 (OP_ALG_PKMODE_COPY_SSZ | \
- OP_ALG_PKMODE_SRC_REG_B | \
- OP_ALG_PKMODE_SRC_SEG_3 | \
- OP_ALG_PKMODE_DST_REG_A | \
- OP_ALG_PKMODE_DST_SEG_3)
-
-#define OP_ALG_PKMODE_COPY_SSZ_A_B (OP_ALG_PKMODE_COPY_SSZ | \
- OP_ALG_PKMODE_SRC_REG_A | \
- OP_ALG_PKMODE_DST_REG_B)
-#define OP_ALG_PKMODE_COPY_SSZ_A_E (OP_ALG_PKMODE_COPY_SSZ | \
- OP_ALG_PKMODE_SRC_REG_A | \
- OP_ALG_PKMODE_DST_REG_E)
-#define OP_ALG_PKMODE_COPY_SSZ_A_N (OP_ALG_PKMODE_COPY_SSZ | \
- OP_ALG_PKMODE_SRC_REG_A | \
- OP_ALG_PKMODE_DST_REG_N)
-#define OP_ALG_PKMODE_COPY_SSZ_B_A (OP_ALG_PKMODE_COPY_SSZ | \
- OP_ALG_PKMODE_SRC_REG_B | \
- OP_ALG_PKMODE_DST_REG_A)
-#define OP_ALG_PKMODE_COPY_SSZ_B_E (OP_ALG_PKMODE_COPY_SSZ | \
- OP_ALG_PKMODE_SRC_REG_B | \
- OP_ALG_PKMODE_DST_REG_E)
-#define OP_ALG_PKMODE_COPY_SSZ_B_N (OP_ALG_PKMODE_COPY_SSZ | \
- OP_ALG_PKMODE_SRC_REG_B | \
- OP_ALG_PKMODE_DST_REG_N)
-#define OP_ALG_PKMODE_COPY_SSZ_N_A (OP_ALG_PKMODE_COPY_SSZ | \
- OP_ALG_PKMODE_SRC_REG_N | \
- OP_ALG_PKMODE_DST_REG_A)
-#define OP_ALG_PKMODE_COPY_SSZ_N_B (OP_ALG_PKMODE_COPY_SSZ | \
- OP_ALG_PKMODE_SRC_REG_N | \
- OP_ALG_PKMODE_DST_REG_B)
-#define OP_ALG_PKMODE_COPY_SSZ_N_E (OP_ALG_PKMODE_COPY_SSZ | \
- OP_ALG_PKMODE_SRC_REG_N | \
- OP_ALG_PKMODE_DST_REG_E)
-
-/*
- * SEQ_IN_PTR Command Constructs
- */
-
-/* Release Buffers */
-#define SQIN_RBS BIT(26)
-
-/* Sequence pointer is really a descriptor */
-#define SQIN_INL BIT(25)
-
-/* Sequence pointer is a scatter-gather table */
-#define SQIN_SGF BIT(24)
-
-/* Appends to a previous pointer */
-#define SQIN_PRE BIT(23)
-
-/* Use extended length following pointer */
-#define SQIN_EXT BIT(22)
-
-/* Restore sequence with pointer/length */
-#define SQIN_RTO BIT(21)
-
-/* Replace job descriptor */
-#define SQIN_RJD BIT(20)
-
-/* Sequence Out Pointer - start a new input sequence using output sequence */
-#define SQIN_SOP BIT(19)
-
-#define SQIN_LEN_SHIFT 0
-#define SQIN_LEN_MASK (0xffff << SQIN_LEN_SHIFT)
-
-/*
- * SEQ_OUT_PTR Command Constructs
- */
-
-/* Sequence pointer is a scatter-gather table */
-#define SQOUT_SGF BIT(24)
-
-/* Appends to a previous pointer */
-#define SQOUT_PRE BIT(23)
-
-/* Restore sequence with pointer/length */
-#define SQOUT_RTO BIT(21)
-
-/*
- * Ignore length field, add current output frame length back to SOL register.
- * Reset tracking length of bytes written to output frame.
- * Must be used together with SQOUT_RTO.
- */
-#define SQOUT_RST BIT(20)
-
-/* Allow "write safe" transactions for this Output Sequence */
-#define SQOUT_EWS BIT(19)
-
-/* Use extended length following pointer */
-#define SQOUT_EXT BIT(22)
-
-#define SQOUT_LEN_SHIFT 0
-#define SQOUT_LEN_MASK (0xffff << SQOUT_LEN_SHIFT)
-
-/*
- * SIGNATURE Command Constructs
- */
-
-/* TYPE field is all that's relevant */
-#define SIGN_TYPE_SHIFT 16
-#define SIGN_TYPE_MASK (0x0f << SIGN_TYPE_SHIFT)
-
-#define SIGN_TYPE_FINAL (0x00 << SIGN_TYPE_SHIFT)
-#define SIGN_TYPE_FINAL_RESTORE (0x01 << SIGN_TYPE_SHIFT)
-#define SIGN_TYPE_FINAL_NONZERO (0x02 << SIGN_TYPE_SHIFT)
-#define SIGN_TYPE_IMM_2 (0x0a << SIGN_TYPE_SHIFT)
-#define SIGN_TYPE_IMM_3 (0x0b << SIGN_TYPE_SHIFT)
-#define SIGN_TYPE_IMM_4 (0x0c << SIGN_TYPE_SHIFT)
-
-/*
- * MOVE Command Constructs
- */
-
-#define MOVE_AUX_SHIFT 25
-#define MOVE_AUX_MASK (3 << MOVE_AUX_SHIFT)
-#define MOVE_AUX_MS (2 << MOVE_AUX_SHIFT)
-#define MOVE_AUX_LS (1 << MOVE_AUX_SHIFT)
-
-#define MOVE_WAITCOMP_SHIFT 24
-#define MOVE_WAITCOMP_MASK (1 << MOVE_WAITCOMP_SHIFT)
-#define MOVE_WAITCOMP BIT(24)
-
-#define MOVE_SRC_SHIFT 20
-#define MOVE_SRC_MASK (0x0f << MOVE_SRC_SHIFT)
-#define MOVE_SRC_CLASS1CTX (0x00 << MOVE_SRC_SHIFT)
-#define MOVE_SRC_CLASS2CTX (0x01 << MOVE_SRC_SHIFT)
-#define MOVE_SRC_OUTFIFO (0x02 << MOVE_SRC_SHIFT)
-#define MOVE_SRC_DESCBUF (0x03 << MOVE_SRC_SHIFT)
-#define MOVE_SRC_MATH0 (0x04 << MOVE_SRC_SHIFT)
-#define MOVE_SRC_MATH1 (0x05 << MOVE_SRC_SHIFT)
-#define MOVE_SRC_MATH2 (0x06 << MOVE_SRC_SHIFT)
-#define MOVE_SRC_MATH3 (0x07 << MOVE_SRC_SHIFT)
-#define MOVE_SRC_INFIFO (0x08 << MOVE_SRC_SHIFT)
-#define MOVE_SRC_INFIFO_CL (0x09 << MOVE_SRC_SHIFT)
-#define MOVE_SRC_INFIFO_NO_NFIFO (0x0a << MOVE_SRC_SHIFT)
-
-#define MOVE_DEST_SHIFT 16
-#define MOVE_DEST_MASK (0x0f << MOVE_DEST_SHIFT)
-#define MOVE_DEST_CLASS1CTX (0x00 << MOVE_DEST_SHIFT)
-#define MOVE_DEST_CLASS2CTX (0x01 << MOVE_DEST_SHIFT)
-#define MOVE_DEST_OUTFIFO (0x02 << MOVE_DEST_SHIFT)
-#define MOVE_DEST_DESCBUF (0x03 << MOVE_DEST_SHIFT)
-#define MOVE_DEST_MATH0 (0x04 << MOVE_DEST_SHIFT)
-#define MOVE_DEST_MATH1 (0x05 << MOVE_DEST_SHIFT)
-#define MOVE_DEST_MATH2 (0x06 << MOVE_DEST_SHIFT)
-#define MOVE_DEST_MATH3 (0x07 << MOVE_DEST_SHIFT)
-#define MOVE_DEST_CLASS1INFIFO (0x08 << MOVE_DEST_SHIFT)
-#define MOVE_DEST_CLASS2INFIFO (0x09 << MOVE_DEST_SHIFT)
-#define MOVE_DEST_INFIFO (0x0a << MOVE_DEST_SHIFT)
-#define MOVE_DEST_PK_A (0x0c << MOVE_DEST_SHIFT)
-#define MOVE_DEST_CLASS1KEY (0x0d << MOVE_DEST_SHIFT)
-#define MOVE_DEST_CLASS2KEY (0x0e << MOVE_DEST_SHIFT)
-#define MOVE_DEST_ALTSOURCE (0x0f << MOVE_DEST_SHIFT)
-
-#define MOVE_OFFSET_SHIFT 8
-#define MOVE_OFFSET_MASK (0xff << MOVE_OFFSET_SHIFT)
-
-#define MOVE_LEN_SHIFT 0
-#define MOVE_LEN_MASK (0xff << MOVE_LEN_SHIFT)
-
-#define MOVELEN_MRSEL_SHIFT 0
-#define MOVELEN_MRSEL_MASK (0x3 << MOVE_LEN_SHIFT)
-#define MOVELEN_MRSEL_MATH0 (0 << MOVELEN_MRSEL_SHIFT)
-#define MOVELEN_MRSEL_MATH1 (1 << MOVELEN_MRSEL_SHIFT)
-#define MOVELEN_MRSEL_MATH2 (2 << MOVELEN_MRSEL_SHIFT)
-#define MOVELEN_MRSEL_MATH3 (3 << MOVELEN_MRSEL_SHIFT)
-
-#define MOVELEN_SIZE_SHIFT 6
-#define MOVELEN_SIZE_MASK (0x3 << MOVELEN_SIZE_SHIFT)
-#define MOVELEN_SIZE_WORD (0x01 << MOVELEN_SIZE_SHIFT)
-#define MOVELEN_SIZE_BYTE (0x02 << MOVELEN_SIZE_SHIFT)
-#define MOVELEN_SIZE_DWORD (0x03 << MOVELEN_SIZE_SHIFT)
-
-/*
- * MATH Command Constructs
- */
-
-#define MATH_IFB_SHIFT 26
-#define MATH_IFB_MASK (1 << MATH_IFB_SHIFT)
-#define MATH_IFB BIT(26)
-
-#define MATH_NFU_SHIFT 25
-#define MATH_NFU_MASK (1 << MATH_NFU_SHIFT)
-#define MATH_NFU BIT(25)
-
-/* STL for MATH, SSEL for MATHI */
-#define MATH_STL_SHIFT 24
-#define MATH_STL_MASK (1 << MATH_STL_SHIFT)
-#define MATH_STL BIT(24)
-
-#define MATH_SSEL_SHIFT 24
-#define MATH_SSEL_MASK (1 << MATH_SSEL_SHIFT)
-#define MATH_SSEL BIT(24)
-
-#define MATH_SWP_SHIFT 0
-#define MATH_SWP_MASK (1 << MATH_SWP_SHIFT)
-#define MATH_SWP BIT(0)
-
-/* Function selectors */
-#define MATH_FUN_SHIFT 20
-#define MATH_FUN_MASK (0x0f << MATH_FUN_SHIFT)
-#define MATH_FUN_ADD (0x00 << MATH_FUN_SHIFT)
-#define MATH_FUN_ADDC (0x01 << MATH_FUN_SHIFT)
-#define MATH_FUN_SUB (0x02 << MATH_FUN_SHIFT)
-#define MATH_FUN_SUBB (0x03 << MATH_FUN_SHIFT)
-#define MATH_FUN_OR (0x04 << MATH_FUN_SHIFT)
-#define MATH_FUN_AND (0x05 << MATH_FUN_SHIFT)
-#define MATH_FUN_XOR (0x06 << MATH_FUN_SHIFT)
-#define MATH_FUN_LSHIFT (0x07 << MATH_FUN_SHIFT)
-#define MATH_FUN_RSHIFT (0x08 << MATH_FUN_SHIFT)
-#define MATH_FUN_SHLD (0x09 << MATH_FUN_SHIFT)
-#define MATH_FUN_ZBYT (0x0a << MATH_FUN_SHIFT) /* ZBYT is for MATH */
-#define MATH_FUN_FBYT (0x0a << MATH_FUN_SHIFT) /* FBYT is for MATHI */
-#define MATH_FUN_BSWAP (0x0b << MATH_FUN_SHIFT)
-
-/* Source 0 selectors */
-#define MATH_SRC0_SHIFT 16
-#define MATH_SRC0_MASK (0x0f << MATH_SRC0_SHIFT)
-#define MATH_SRC0_REG0 (0x00 << MATH_SRC0_SHIFT)
-#define MATH_SRC0_REG1 (0x01 << MATH_SRC0_SHIFT)
-#define MATH_SRC0_REG2 (0x02 << MATH_SRC0_SHIFT)
-#define MATH_SRC0_REG3 (0x03 << MATH_SRC0_SHIFT)
-#define MATH_SRC0_IMM (0x04 << MATH_SRC0_SHIFT)
-#define MATH_SRC0_DPOVRD (0x07 << MATH_SRC0_SHIFT)
-#define MATH_SRC0_SEQINLEN (0x08 << MATH_SRC0_SHIFT)
-#define MATH_SRC0_SEQOUTLEN (0x09 << MATH_SRC0_SHIFT)
-#define MATH_SRC0_VARSEQINLEN (0x0a << MATH_SRC0_SHIFT)
-#define MATH_SRC0_VARSEQOUTLEN (0x0b << MATH_SRC0_SHIFT)
-#define MATH_SRC0_ZERO (0x0c << MATH_SRC0_SHIFT)
-#define MATH_SRC0_ONE (0x0f << MATH_SRC0_SHIFT)
-
-/* Source 1 selectors */
-#define MATH_SRC1_SHIFT 12
-#define MATHI_SRC1_SHIFT 16
-#define MATH_SRC1_MASK (0x0f << MATH_SRC1_SHIFT)
-#define MATH_SRC1_REG0 (0x00 << MATH_SRC1_SHIFT)
-#define MATH_SRC1_REG1 (0x01 << MATH_SRC1_SHIFT)
-#define MATH_SRC1_REG2 (0x02 << MATH_SRC1_SHIFT)
-#define MATH_SRC1_REG3 (0x03 << MATH_SRC1_SHIFT)
-#define MATH_SRC1_IMM (0x04 << MATH_SRC1_SHIFT)
-#define MATH_SRC1_DPOVRD (0x07 << MATH_SRC1_SHIFT)
-#define MATH_SRC1_VARSEQINLEN (0x08 << MATH_SRC1_SHIFT)
-#define MATH_SRC1_VARSEQOUTLEN (0x09 << MATH_SRC1_SHIFT)
-#define MATH_SRC1_INFIFO (0x0a << MATH_SRC1_SHIFT)
-#define MATH_SRC1_OUTFIFO (0x0b << MATH_SRC1_SHIFT)
-#define MATH_SRC1_ONE (0x0c << MATH_SRC1_SHIFT)
-#define MATH_SRC1_JOBSOURCE (0x0d << MATH_SRC1_SHIFT)
-#define MATH_SRC1_ZERO (0x0f << MATH_SRC1_SHIFT)
-
-/* Destination selectors */
-#define MATH_DEST_SHIFT 8
-#define MATHI_DEST_SHIFT 12
-#define MATH_DEST_MASK (0x0f << MATH_DEST_SHIFT)
-#define MATH_DEST_REG0 (0x00 << MATH_DEST_SHIFT)
-#define MATH_DEST_REG1 (0x01 << MATH_DEST_SHIFT)
-#define MATH_DEST_REG2 (0x02 << MATH_DEST_SHIFT)
-#define MATH_DEST_REG3 (0x03 << MATH_DEST_SHIFT)
-#define MATH_DEST_DPOVRD (0x07 << MATH_DEST_SHIFT)
-#define MATH_DEST_SEQINLEN (0x08 << MATH_DEST_SHIFT)
-#define MATH_DEST_SEQOUTLEN (0x09 << MATH_DEST_SHIFT)
-#define MATH_DEST_VARSEQINLEN (0x0a << MATH_DEST_SHIFT)
-#define MATH_DEST_VARSEQOUTLEN (0x0b << MATH_DEST_SHIFT)
-#define MATH_DEST_NONE (0x0f << MATH_DEST_SHIFT)
-
-/* MATHI Immediate value */
-#define MATHI_IMM_SHIFT 4
-#define MATHI_IMM_MASK (0xff << MATHI_IMM_SHIFT)
-
-/* Length selectors */
-#define MATH_LEN_SHIFT 0
-#define MATH_LEN_MASK (0x0f << MATH_LEN_SHIFT)
-#define MATH_LEN_1BYTE 0x01
-#define MATH_LEN_2BYTE 0x02
-#define MATH_LEN_4BYTE 0x04
-#define MATH_LEN_8BYTE 0x08
-
-/*
- * JUMP Command Constructs
- */
-
-#define JUMP_CLASS_SHIFT 25
-#define JUMP_CLASS_MASK (3 << JUMP_CLASS_SHIFT)
-#define JUMP_CLASS_NONE 0
-#define JUMP_CLASS_CLASS1 (1 << JUMP_CLASS_SHIFT)
-#define JUMP_CLASS_CLASS2 (2 << JUMP_CLASS_SHIFT)
-#define JUMP_CLASS_BOTH (3 << JUMP_CLASS_SHIFT)
-
-#define JUMP_JSL_SHIFT 24
-#define JUMP_JSL_MASK (1 << JUMP_JSL_SHIFT)
-#define JUMP_JSL BIT(24)
-
-#define JUMP_TYPE_SHIFT 20
-#define JUMP_TYPE_MASK (0x0f << JUMP_TYPE_SHIFT)
-#define JUMP_TYPE_LOCAL (0x00 << JUMP_TYPE_SHIFT)
-#define JUMP_TYPE_LOCAL_INC (0x01 << JUMP_TYPE_SHIFT)
-#define JUMP_TYPE_GOSUB (0x02 << JUMP_TYPE_SHIFT)
-#define JUMP_TYPE_LOCAL_DEC (0x03 << JUMP_TYPE_SHIFT)
-#define JUMP_TYPE_NONLOCAL (0x04 << JUMP_TYPE_SHIFT)
-#define JUMP_TYPE_RETURN (0x06 << JUMP_TYPE_SHIFT)
-#define JUMP_TYPE_HALT (0x08 << JUMP_TYPE_SHIFT)
-#define JUMP_TYPE_HALT_USER (0x0c << JUMP_TYPE_SHIFT)
-
-#define JUMP_TEST_SHIFT 16
-#define JUMP_TEST_MASK (0x03 << JUMP_TEST_SHIFT)
-#define JUMP_TEST_ALL (0x00 << JUMP_TEST_SHIFT)
-#define JUMP_TEST_INVALL (0x01 << JUMP_TEST_SHIFT)
-#define JUMP_TEST_ANY (0x02 << JUMP_TEST_SHIFT)
-#define JUMP_TEST_INVANY (0x03 << JUMP_TEST_SHIFT)
-
-/* Condition codes. JSL bit is factored in */
-#define JUMP_COND_SHIFT 8
-#define JUMP_COND_MASK ((0xff << JUMP_COND_SHIFT) | JUMP_JSL)
-#define JUMP_COND_PK_0 BIT(15)
-#define JUMP_COND_PK_GCD_1 BIT(14)
-#define JUMP_COND_PK_PRIME BIT(13)
-#define JUMP_COND_MATH_N BIT(11)
-#define JUMP_COND_MATH_Z BIT(10)
-#define JUMP_COND_MATH_C BIT(9)
-#define JUMP_COND_MATH_NV BIT(8)
-
-#define JUMP_COND_JQP (BIT(15) | JUMP_JSL)
-#define JUMP_COND_SHRD (BIT(14) | JUMP_JSL)
-#define JUMP_COND_SELF (BIT(13) | JUMP_JSL)
-#define JUMP_COND_CALM (BIT(12) | JUMP_JSL)
-#define JUMP_COND_NIP (BIT(11) | JUMP_JSL)
-#define JUMP_COND_NIFP (BIT(10) | JUMP_JSL)
-#define JUMP_COND_NOP (BIT(9) | JUMP_JSL)
-#define JUMP_COND_NCP (BIT(8) | JUMP_JSL)
-
-/* Source / destination selectors */
-#define JUMP_SRC_DST_SHIFT 12
-#define JUMP_SRC_DST_MASK (0x0f << JUMP_SRC_DST_SHIFT)
-#define JUMP_SRC_DST_MATH0 (0x00 << JUMP_SRC_DST_SHIFT)
-#define JUMP_SRC_DST_MATH1 (0x01 << JUMP_SRC_DST_SHIFT)
-#define JUMP_SRC_DST_MATH2 (0x02 << JUMP_SRC_DST_SHIFT)
-#define JUMP_SRC_DST_MATH3 (0x03 << JUMP_SRC_DST_SHIFT)
-#define JUMP_SRC_DST_DPOVRD (0x07 << JUMP_SRC_DST_SHIFT)
-#define JUMP_SRC_DST_SEQINLEN (0x08 << JUMP_SRC_DST_SHIFT)
-#define JUMP_SRC_DST_SEQOUTLEN (0x09 << JUMP_SRC_DST_SHIFT)
-#define JUMP_SRC_DST_VARSEQINLEN (0x0a << JUMP_SRC_DST_SHIFT)
-#define JUMP_SRC_DST_VARSEQOUTLEN (0x0b << JUMP_SRC_DST_SHIFT)
-
-#define JUMP_OFFSET_SHIFT 0
-#define JUMP_OFFSET_MASK (0xff << JUMP_OFFSET_SHIFT)
-
-/*
- * NFIFO ENTRY
- * Data Constructs
- *
- */
-#define NFIFOENTRY_DEST_SHIFT 30
-#define NFIFOENTRY_DEST_MASK ((uint32_t)(3 << NFIFOENTRY_DEST_SHIFT))
-#define NFIFOENTRY_DEST_DECO (0 << NFIFOENTRY_DEST_SHIFT)
-#define NFIFOENTRY_DEST_CLASS1 (1 << NFIFOENTRY_DEST_SHIFT)
-#define NFIFOENTRY_DEST_CLASS2 ((uint32_t)(2 << NFIFOENTRY_DEST_SHIFT))
-#define NFIFOENTRY_DEST_BOTH ((uint32_t)(3 << NFIFOENTRY_DEST_SHIFT))
-
-#define NFIFOENTRY_LC2_SHIFT 29
-#define NFIFOENTRY_LC2_MASK (1 << NFIFOENTRY_LC2_SHIFT)
-#define NFIFOENTRY_LC2 BIT(29)
-
-#define NFIFOENTRY_LC1_SHIFT 28
-#define NFIFOENTRY_LC1_MASK (1 << NFIFOENTRY_LC1_SHIFT)
-#define NFIFOENTRY_LC1 BIT(28)
-
-#define NFIFOENTRY_FC2_SHIFT 27
-#define NFIFOENTRY_FC2_MASK (1 << NFIFOENTRY_FC2_SHIFT)
-#define NFIFOENTRY_FC2 BIT(27)
-
-#define NFIFOENTRY_FC1_SHIFT 26
-#define NFIFOENTRY_FC1_MASK (1 << NFIFOENTRY_FC1_SHIFT)
-#define NFIFOENTRY_FC1 BIT(26)
-
-#define NFIFOENTRY_STYPE_SHIFT 24
-#define NFIFOENTRY_STYPE_MASK (3 << NFIFOENTRY_STYPE_SHIFT)
-#define NFIFOENTRY_STYPE_DFIFO (0 << NFIFOENTRY_STYPE_SHIFT)
-#define NFIFOENTRY_STYPE_OFIFO (1 << NFIFOENTRY_STYPE_SHIFT)
-#define NFIFOENTRY_STYPE_PAD (2 << NFIFOENTRY_STYPE_SHIFT)
-#define NFIFOENTRY_STYPE_SNOOP (3 << NFIFOENTRY_STYPE_SHIFT)
-#define NFIFOENTRY_STYPE_ALTSOURCE ((0 << NFIFOENTRY_STYPE_SHIFT) \
- | NFIFOENTRY_AST)
-#define NFIFOENTRY_STYPE_OFIFO_SYNC ((1 << NFIFOENTRY_STYPE_SHIFT) \
- | NFIFOENTRY_AST)
-#define NFIFOENTRY_STYPE_SNOOP_ALT ((3 << NFIFOENTRY_STYPE_SHIFT) \
- | NFIFOENTRY_AST)
-
-#define NFIFOENTRY_DTYPE_SHIFT 20
-#define NFIFOENTRY_DTYPE_MASK (0xF << NFIFOENTRY_DTYPE_SHIFT)
-
-#define NFIFOENTRY_DTYPE_SBOX (0x0 << NFIFOENTRY_DTYPE_SHIFT)
-#define NFIFOENTRY_DTYPE_AAD (0x1 << NFIFOENTRY_DTYPE_SHIFT)
-#define NFIFOENTRY_DTYPE_IV (0x2 << NFIFOENTRY_DTYPE_SHIFT)
-#define NFIFOENTRY_DTYPE_SAD (0x3 << NFIFOENTRY_DTYPE_SHIFT)
-#define NFIFOENTRY_DTYPE_ICV (0xA << NFIFOENTRY_DTYPE_SHIFT)
-#define NFIFOENTRY_DTYPE_SKIP (0xE << NFIFOENTRY_DTYPE_SHIFT)
-#define NFIFOENTRY_DTYPE_MSG (0xF << NFIFOENTRY_DTYPE_SHIFT)
-
-#define NFIFOENTRY_DTYPE_PK_A0 (0x0 << NFIFOENTRY_DTYPE_SHIFT)
-#define NFIFOENTRY_DTYPE_PK_A1 (0x1 << NFIFOENTRY_DTYPE_SHIFT)
-#define NFIFOENTRY_DTYPE_PK_A2 (0x2 << NFIFOENTRY_DTYPE_SHIFT)
-#define NFIFOENTRY_DTYPE_PK_A3 (0x3 << NFIFOENTRY_DTYPE_SHIFT)
-#define NFIFOENTRY_DTYPE_PK_B0 (0x4 << NFIFOENTRY_DTYPE_SHIFT)
-#define NFIFOENTRY_DTYPE_PK_B1 (0x5 << NFIFOENTRY_DTYPE_SHIFT)
-#define NFIFOENTRY_DTYPE_PK_B2 (0x6 << NFIFOENTRY_DTYPE_SHIFT)
-#define NFIFOENTRY_DTYPE_PK_B3 (0x7 << NFIFOENTRY_DTYPE_SHIFT)
-#define NFIFOENTRY_DTYPE_PK_N (0x8 << NFIFOENTRY_DTYPE_SHIFT)
-#define NFIFOENTRY_DTYPE_PK_E (0x9 << NFIFOENTRY_DTYPE_SHIFT)
-#define NFIFOENTRY_DTYPE_PK_A (0xC << NFIFOENTRY_DTYPE_SHIFT)
-#define NFIFOENTRY_DTYPE_PK_B (0xD << NFIFOENTRY_DTYPE_SHIFT)
-
-#define NFIFOENTRY_BND_SHIFT 19
-#define NFIFOENTRY_BND_MASK (1 << NFIFOENTRY_BND_SHIFT)
-#define NFIFOENTRY_BND BIT(19)
-
-#define NFIFOENTRY_PTYPE_SHIFT 16
-#define NFIFOENTRY_PTYPE_MASK (0x7 << NFIFOENTRY_PTYPE_SHIFT)
-
-#define NFIFOENTRY_PTYPE_ZEROS (0x0 << NFIFOENTRY_PTYPE_SHIFT)
-#define NFIFOENTRY_PTYPE_RND_NOZEROS (0x1 << NFIFOENTRY_PTYPE_SHIFT)
-#define NFIFOENTRY_PTYPE_INCREMENT (0x2 << NFIFOENTRY_PTYPE_SHIFT)
-#define NFIFOENTRY_PTYPE_RND (0x3 << NFIFOENTRY_PTYPE_SHIFT)
-#define NFIFOENTRY_PTYPE_ZEROS_NZ (0x4 << NFIFOENTRY_PTYPE_SHIFT)
-#define NFIFOENTRY_PTYPE_RND_NZ_LZ (0x5 << NFIFOENTRY_PTYPE_SHIFT)
-#define NFIFOENTRY_PTYPE_N (0x6 << NFIFOENTRY_PTYPE_SHIFT)
-#define NFIFOENTRY_PTYPE_RND_NZ_N (0x7 << NFIFOENTRY_PTYPE_SHIFT)
-
-#define NFIFOENTRY_OC_SHIFT 15
-#define NFIFOENTRY_OC_MASK (1 << NFIFOENTRY_OC_SHIFT)
-#define NFIFOENTRY_OC BIT(15)
-
-#define NFIFOENTRY_PR_SHIFT 15
-#define NFIFOENTRY_PR_MASK (1 << NFIFOENTRY_PR_SHIFT)
-#define NFIFOENTRY_PR BIT(15)
-
-#define NFIFOENTRY_AST_SHIFT 14
-#define NFIFOENTRY_AST_MASK (1 << NFIFOENTRY_AST_SHIFT)
-#define NFIFOENTRY_AST BIT(14)
-
-#define NFIFOENTRY_BM_SHIFT 11
-#define NFIFOENTRY_BM_MASK (1 << NFIFOENTRY_BM_SHIFT)
-#define NFIFOENTRY_BM BIT(11)
-
-#define NFIFOENTRY_PS_SHIFT 10
-#define NFIFOENTRY_PS_MASK (1 << NFIFOENTRY_PS_SHIFT)
-#define NFIFOENTRY_PS BIT(10)
-
-#define NFIFOENTRY_DLEN_SHIFT 0
-#define NFIFOENTRY_DLEN_MASK (0xFFF << NFIFOENTRY_DLEN_SHIFT)
-
-#define NFIFOENTRY_PLEN_SHIFT 0
-#define NFIFOENTRY_PLEN_MASK (0xFF << NFIFOENTRY_PLEN_SHIFT)
-
-/* Append Load Immediate Command */
-#define FD_CMD_APPEND_LOAD_IMMEDIATE BIT(31)
-
-/* Set SEQ LIODN equal to the Non-SEQ LIODN for the job */
-#define FD_CMD_SET_SEQ_LIODN_EQUAL_NONSEQ_LIODN BIT(30)
-
-/* Frame Descriptor Command for Replacement Job Descriptor */
-#define FD_CMD_REPLACE_JOB_DESC BIT(29)
-
-#endif /* __RTA_DESC_H__ */
+++ /dev/null
-/* SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0)
- *
- * Copyright 2008-2016 Freescale Semiconductor Inc.
- * Copyright 2016,2019 NXP
- *
- */
-
-#ifndef __DESC_ALGO_H__
-#define __DESC_ALGO_H__
-
-#include "hw/rta.h"
-#include "common.h"
-
-/**
- * DOC: Algorithms - Shared Descriptor Constructors
- *
- * Shared descriptors for algorithms (i.e. not for protocols).
- */
-
-/**
- * cnstr_shdsc_zuce - ZUC Enc (EEA2) as a shared descriptor
- * @descbuf: pointer to descriptor-under-construction buffer
- * @ps: if 36/40bit addressing is desired, this parameter must be true
- * @swap: must be true when core endianness doesn't match SEC endianness
- * @cipherdata: pointer to block cipher transform definitions
- * @dir: Cipher direction (DIR_ENC/DIR_DEC)
- *
- * Return: size of descriptor written in words or negative number on error
- */
-static inline int
-cnstr_shdsc_zuce(uint32_t *descbuf, bool ps, bool swap,
- struct alginfo *cipherdata, uint8_t dir)
-{
- struct program prg;
- struct program *p = &prg;
-
- PROGRAM_CNTXT_INIT(p, descbuf, 0);
- if (swap)
- PROGRAM_SET_BSWAP(p);
-
- if (ps)
- PROGRAM_SET_36BIT_ADDR(p);
- SHR_HDR(p, SHR_ALWAYS, 1, 0);
-
- KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
- cipherdata->keylen, INLINE_KEY(cipherdata));
-
- SEQLOAD(p, CONTEXT1, 0, 16, 0);
-
- MATHB(p, SEQINSZ, SUB, MATH2, VSEQINSZ, 4, 0);
- MATHB(p, SEQINSZ, SUB, MATH2, VSEQOUTSZ, 4, 0);
- ALG_OPERATION(p, OP_ALG_ALGSEL_ZUCE, OP_ALG_AAI_F8,
- OP_ALG_AS_INITFINAL, 0, dir);
- SEQFIFOLOAD(p, MSG1, 0, VLF | LAST1);
- SEQFIFOSTORE(p, MSG, 0, 0, VLF);
-
- return PROGRAM_FINALIZE(p);
-}
-
-/**
- * cnstr_shdsc_zuca - ZUC Auth (EIA2) as a shared descriptor
- * @descbuf: pointer to descriptor-under-construction buffer
- * @ps: if 36/40bit addressing is desired, this parameter must be true
- * @swap: must be true when core endianness doesn't match SEC endianness
- * @authdata: pointer to authentication transform definitions
- * @chk_icv: Whether to compare and verify ICV (true/false)
- * @authlen: size of digest
- *
- * The IV prepended before hmac payload must be 8 bytes consisting
- * of COUNT||BEAERER||DIR. The COUNT is of 32-bits, bearer is of 5 bits and
- * direction is of 1 bit - totalling to 38 bits.
- *
- * Return: size of descriptor written in words or negative number on error
- */
-static inline int
-cnstr_shdsc_zuca(uint32_t *descbuf, bool ps, bool swap,
- struct alginfo *authdata, uint8_t chk_icv,
- uint32_t authlen)
-{
- struct program prg;
- struct program *p = &prg;
- int dir = chk_icv ? DIR_DEC : DIR_ENC;
-
- PROGRAM_CNTXT_INIT(p, descbuf, 0);
- if (swap)
- PROGRAM_SET_BSWAP(p);
-
- if (ps)
- PROGRAM_SET_36BIT_ADDR(p);
- SHR_HDR(p, SHR_ALWAYS, 1, 0);
-
- KEY(p, KEY2, authdata->key_enc_flags, authdata->key,
- authdata->keylen, INLINE_KEY(authdata));
-
- SEQLOAD(p, CONTEXT2, 0, 8, 0);
-
- if (chk_icv == ICV_CHECK_ENABLE)
- MATHB(p, SEQINSZ, SUB, authlen, VSEQINSZ, 4, IMMED2);
- else
- MATHB(p, SEQINSZ, SUB, ZERO, VSEQINSZ, 4, 0);
-
- ALG_OPERATION(p, OP_ALG_ALGSEL_ZUCA, OP_ALG_AAI_F9,
- OP_ALG_AS_INITFINAL, chk_icv, dir);
-
- SEQFIFOLOAD(p, MSG2, 0, VLF | CLASS2 | LAST2);
-
- if (chk_icv == ICV_CHECK_ENABLE)
- SEQFIFOLOAD(p, ICV2, authlen, LAST2);
- else
- /* Save lower half of MAC out into a 32-bit sequence */
- SEQSTORE(p, CONTEXT2, 0, authlen, 0);
-
- return PROGRAM_FINALIZE(p);
-}
-
-
-/**
- * cnstr_shdsc_snow_f8 - SNOW/f8 (UEA2) as a shared descriptor
- * @descbuf: pointer to descriptor-under-construction buffer
- * @ps: if 36/40bit addressing is desired, this parameter must be true
- * @swap: must be true when core endianness doesn't match SEC endianness
- * @cipherdata: pointer to block cipher transform definitions
- * @dir: Cipher direction (DIR_ENC/DIR_DEC)
- *
- * Return: size of descriptor written in words or negative number on error
- */
-static inline int
-cnstr_shdsc_snow_f8(uint32_t *descbuf, bool ps, bool swap,
- struct alginfo *cipherdata, uint8_t dir)
-{
- struct program prg;
- struct program *p = &prg;
-
- PROGRAM_CNTXT_INIT(p, descbuf, 0);
- if (swap)
- PROGRAM_SET_BSWAP(p);
-
- if (ps)
- PROGRAM_SET_36BIT_ADDR(p);
- SHR_HDR(p, SHR_ALWAYS, 1, 0);
-
- KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
- cipherdata->keylen, INLINE_KEY(cipherdata));
-
- SEQLOAD(p, CONTEXT1, 0, 16, 0);
-
- MATHB(p, SEQINSZ, SUB, MATH2, VSEQINSZ, 4, 0);
- MATHB(p, SEQINSZ, SUB, MATH2, VSEQOUTSZ, 4, 0);
- ALG_OPERATION(p, OP_ALG_ALGSEL_SNOW_F8, OP_ALG_AAI_F8,
- OP_ALG_AS_INITFINAL, 0, dir);
- SEQFIFOLOAD(p, MSG1, 0, VLF | LAST1);
- SEQFIFOSTORE(p, MSG, 0, 0, VLF);
-
- return PROGRAM_FINALIZE(p);
-}
-
-/**
- * conv_to_zuc_eia_iv - ZUCA IV 16-byte to 8-byte convert
- * function for 3G.
- * @iv: 16 bytes of original IV data.
- *
- * From the original IV, we extract 32-bits of COUNT,
- * 5-bits of bearer and 1-bit of direction.
- * Refer to CAAM refman for ZUCA IV format. Then these values are
- * appended as COUNT||BEARER||DIR continuously to make a 38-bit block.
- * This 38-bit block is copied left justified into 8-byte array used as
- * converted IV.
- *
- * Return: 8-bytes of IV data as understood by SEC HW
- */
-
-static inline uint8_t *conv_to_zuc_eia_iv(uint8_t *iv)
-{
- uint8_t dir = (iv[14] & 0x80) ? 4 : 0;
-
- iv[12] = iv[4] | dir;
- iv[13] = 0;
- iv[14] = 0;
- iv[15] = 0;
-
- iv[8] = iv[0];
- iv[9] = iv[1];
- iv[10] = iv[2];
- iv[11] = iv[3];
-
- return (iv + 8);
-}
-
-/**
- * conv_to_snow_f9_iv - SNOW/f9 (UIA2) IV 16 byte to 12 byte convert
- * function for 3G.
- * @iv: 16 byte original IV data
- *
- * Return: 12 byte IV data as understood by SEC HW
- */
-
-static inline uint8_t *conv_to_snow_f9_iv(uint8_t *iv)
-{
- uint8_t temp = (iv[8] == iv[0]) ? 0 : 4;
-
- iv[12] = iv[4];
- iv[13] = iv[5];
- iv[14] = iv[6];
- iv[15] = iv[7];
-
- iv[8] = temp;
- iv[9] = 0x00;
- iv[10] = 0x00;
- iv[11] = 0x00;
-
- iv[4] = iv[0];
- iv[5] = iv[1];
- iv[6] = iv[2];
- iv[7] = iv[3];
-
- return (iv + 4);
-}
-
-/**
- * cnstr_shdsc_snow_f9 - SNOW/f9 (UIA2) as a shared descriptor
- * @descbuf: pointer to descriptor-under-construction buffer
- * @ps: if 36/40bit addressing is desired, this parameter must be true
- * @swap: must be true when core endianness doesn't match SEC endianness
- * @authdata: pointer to authentication transform definitions
- * @chk_icv: check or generate ICV value
- * @authlen: size of digest
- *
- * Return: size of descriptor written in words or negative number on error
- */
-static inline int
-cnstr_shdsc_snow_f9(uint32_t *descbuf, bool ps, bool swap,
- struct alginfo *authdata, uint8_t chk_icv,
- uint32_t authlen)
-{
- struct program prg;
- struct program *p = &prg;
- int dir = chk_icv ? DIR_DEC : DIR_ENC;
-
- PROGRAM_CNTXT_INIT(p, descbuf, 0);
- if (swap)
- PROGRAM_SET_BSWAP(p);
-
- if (ps)
- PROGRAM_SET_36BIT_ADDR(p);
-
- SHR_HDR(p, SHR_ALWAYS, 1, 0);
-
- KEY(p, KEY2, authdata->key_enc_flags, authdata->key,
- authdata->keylen, INLINE_KEY(authdata));
-
- SEQLOAD(p, CONTEXT2, 0, 12, 0);
-
- if (chk_icv == ICV_CHECK_ENABLE)
- MATHB(p, SEQINSZ, SUB, authlen, VSEQINSZ, 4, IMMED2);
- else
- MATHB(p, SEQINSZ, SUB, ZERO, VSEQINSZ, 4, 0);
-
- ALG_OPERATION(p, OP_ALG_ALGSEL_SNOW_F9, OP_ALG_AAI_F9,
- OP_ALG_AS_INITFINAL, chk_icv, dir);
-
- SEQFIFOLOAD(p, MSG2, 0, VLF | CLASS2 | LAST2);
-
- if (chk_icv == ICV_CHECK_ENABLE)
- SEQFIFOLOAD(p, ICV2, authlen, LAST2);
- else
- /* Save lower half of MAC out into a 32-bit sequence */
- SEQSTORE(p, CONTEXT2, 0, authlen, 0);
-
- return PROGRAM_FINALIZE(p);
-}
-
-/**
- * cnstr_shdsc_blkcipher - block cipher transformation
- * @descbuf: pointer to descriptor-under-construction buffer
- * @ps: if 36/40bit addressing is desired, this parameter must be true
- * @swap: must be true when core endianness doesn't match SEC endianness
- * @share: sharing type of shared descriptor
- * @cipherdata: pointer to block cipher transform definitions
- * Valid algorithm values one of OP_ALG_ALGSEL_* {DES, 3DES, AES}
- * Valid modes for:
- * AES: OP_ALG_AAI_* {CBC, CTR}
- * DES, 3DES: OP_ALG_AAI_CBC
- * @iv: IV data; if NULL, "ivlen" bytes from the input frame will be read as IV
- * @ivlen: IV length
- * @dir: DIR_ENC/DIR_DEC
- *
- * Return: size of descriptor written in words or negative number on error
- */
-static inline int
-cnstr_shdsc_blkcipher(uint32_t *descbuf, bool ps, bool swap,
- enum rta_share_type share,
- struct alginfo *cipherdata, uint8_t *iv,
- uint32_t ivlen, uint8_t dir)
-{
- struct program prg;
- struct program *p = &prg;
- uint32_t iv_off = 0;
- const bool need_dk = (dir == DIR_DEC) &&
- (cipherdata->algtype == OP_ALG_ALGSEL_AES) &&
- (cipherdata->algmode == OP_ALG_AAI_CBC);
- LABEL(keyjmp);
- LABEL(skipdk);
- REFERENCE(pkeyjmp);
- REFERENCE(pskipdk);
-
- PROGRAM_CNTXT_INIT(p, descbuf, 0);
- if (swap)
- PROGRAM_SET_BSWAP(p);
- if (ps)
- PROGRAM_SET_36BIT_ADDR(p);
- SHR_HDR(p, share, 1, SC);
-
- pkeyjmp = JUMP(p, keyjmp, LOCAL_JUMP, ALL_TRUE, SHRD);
- /* Insert Key */
- KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
- cipherdata->keylen, INLINE_KEY(cipherdata));
-
- if (need_dk) {
- ALG_OPERATION(p, cipherdata->algtype, cipherdata->algmode,
- OP_ALG_AS_INITFINAL, ICV_CHECK_DISABLE, dir);
-
- pskipdk = JUMP(p, skipdk, LOCAL_JUMP, ALL_TRUE, 0);
- }
- SET_LABEL(p, keyjmp);
-
- if (need_dk) {
- ALG_OPERATION(p, OP_ALG_ALGSEL_AES, cipherdata->algmode |
- OP_ALG_AAI_DK, OP_ALG_AS_INITFINAL,
- ICV_CHECK_DISABLE, dir);
- SET_LABEL(p, skipdk);
- } else {
- ALG_OPERATION(p, cipherdata->algtype, cipherdata->algmode,
- OP_ALG_AS_INITFINAL, ICV_CHECK_DISABLE, dir);
- }
-
- if (cipherdata->algmode == OP_ALG_AAI_CTR)
- iv_off = 16;
-
- if (iv)
- /* IV load, convert size */
- LOAD(p, (uintptr_t)iv, CONTEXT1, iv_off, ivlen, IMMED | COPY);
- else
- /* IV is present first before the actual message */
- SEQLOAD(p, CONTEXT1, iv_off, ivlen, 0);
-
- MATHB(p, SEQINSZ, SUB, MATH2, VSEQINSZ, 4, 0);
- MATHB(p, SEQINSZ, SUB, MATH2, VSEQOUTSZ, 4, 0);
-
- /* Insert sequence load/store with VLF */
- SEQFIFOLOAD(p, MSG1, 0, VLF | LAST1);
- SEQFIFOSTORE(p, MSG, 0, 0, VLF);
-
- PATCH_JUMP(p, pkeyjmp, keyjmp);
- if (need_dk)
- PATCH_JUMP(p, pskipdk, skipdk);
-
- return PROGRAM_FINALIZE(p);
-}
-
-/**
- * cnstr_shdsc_hmac - HMAC shared
- * @descbuf: pointer to descriptor-under-construction buffer
- * @ps: if 36/40bit addressing is desired, this parameter must be true
- * @swap: must be true when core endianness doesn't match SEC endianness
- * @share: sharing type of shared descriptor
- * @authdata: pointer to authentication transform definitions;
- * message digest algorithm: OP_ALG_ALGSEL_MD5/ SHA1-512.
- * @do_icv: 0 if ICV checking is not desired, any other value if ICV checking
- * is needed for all the packets processed by this shared descriptor
- * @trunc_len: Length of the truncated ICV to be written in the output buffer, 0
- * if no truncation is needed
- *
- * Note: There's no support for keys longer than the block size of the
- * underlying hash function, according to the selected algorithm.
- *
- * Return: size of descriptor written in words or negative number on error
- */
-static inline int
-cnstr_shdsc_hmac(uint32_t *descbuf, bool ps, bool swap,
- enum rta_share_type share,
- struct alginfo *authdata, uint8_t do_icv,
- uint8_t trunc_len)
-{
- struct program prg;
- struct program *p = &prg;
- uint8_t storelen, opicv, dir;
- LABEL(keyjmp);
- LABEL(jmpprecomp);
- REFERENCE(pkeyjmp);
- REFERENCE(pjmpprecomp);
-
- /* Compute fixed-size store based on alg selection */
- switch (authdata->algtype) {
- case OP_ALG_ALGSEL_MD5:
- storelen = 16;
- break;
- case OP_ALG_ALGSEL_SHA1:
- storelen = 20;
- break;
- case OP_ALG_ALGSEL_SHA224:
- storelen = 28;
- break;
- case OP_ALG_ALGSEL_SHA256:
- storelen = 32;
- break;
- case OP_ALG_ALGSEL_SHA384:
- storelen = 48;
- break;
- case OP_ALG_ALGSEL_SHA512:
- storelen = 64;
- break;
- default:
- return -EINVAL;
- }
-
- trunc_len = trunc_len && (trunc_len < storelen) ? trunc_len : storelen;
-
- opicv = do_icv ? ICV_CHECK_ENABLE : ICV_CHECK_DISABLE;
- dir = do_icv ? DIR_DEC : DIR_ENC;
-
- PROGRAM_CNTXT_INIT(p, descbuf, 0);
- if (swap)
- PROGRAM_SET_BSWAP(p);
- if (ps)
- PROGRAM_SET_36BIT_ADDR(p);
- SHR_HDR(p, share, 1, SC);
-
- pkeyjmp = JUMP(p, keyjmp, LOCAL_JUMP, ALL_TRUE, SHRD);
- KEY(p, KEY2, authdata->key_enc_flags, authdata->key, authdata->keylen,
- INLINE_KEY(authdata));
-
- /* Do operation */
- ALG_OPERATION(p, authdata->algtype, OP_ALG_AAI_HMAC,
- OP_ALG_AS_INITFINAL, opicv, dir);
-
- pjmpprecomp = JUMP(p, jmpprecomp, LOCAL_JUMP, ALL_TRUE, 0);
- SET_LABEL(p, keyjmp);
-
- ALG_OPERATION(p, authdata->algtype, OP_ALG_AAI_HMAC_PRECOMP,
- OP_ALG_AS_INITFINAL, opicv, dir);
-
- SET_LABEL(p, jmpprecomp);
-
- /* compute sequences */
- if (opicv == ICV_CHECK_ENABLE)
- MATHB(p, SEQINSZ, SUB, trunc_len, VSEQINSZ, 4, IMMED2);
- else
- MATHB(p, SEQINSZ, SUB, MATH2, VSEQINSZ, 4, 0);
-
- /* Do load (variable length) */
- SEQFIFOLOAD(p, MSG2, 0, VLF | LAST2);
-
- if (opicv == ICV_CHECK_ENABLE)
- SEQFIFOLOAD(p, ICV2, trunc_len, LAST2);
- else
- SEQSTORE(p, CONTEXT2, 0, trunc_len, 0);
-
- PATCH_JUMP(p, pkeyjmp, keyjmp);
- PATCH_JUMP(p, pjmpprecomp, jmpprecomp);
-
- return PROGRAM_FINALIZE(p);
-}
-
-/**
- * cnstr_shdsc_kasumi_f8 - KASUMI F8 (Confidentiality) as a shared descriptor
- * (ETSI "Document 1: f8 and f9 specification")
- * @descbuf: pointer to descriptor-under-construction buffer
- * @ps: if 36/40bit addressing is desired, this parameter must be true
- * @swap: must be true when core endianness doesn't match SEC endianness
- * @cipherdata: pointer to block cipher transform definitions
- * @dir: cipher direction (DIR_ENC/DIR_DEC)
- * @count: count value (32 bits)
- * @bearer: bearer ID (5 bits)
- * @direction: direction (1 bit)
- *
- * Return: size of descriptor written in words or negative number on error
- */
-static inline int
-cnstr_shdsc_kasumi_f8(uint32_t *descbuf, bool ps, bool swap,
- struct alginfo *cipherdata, uint8_t dir)
-{
- struct program prg;
- struct program *p = &prg;
-
- PROGRAM_CNTXT_INIT(p, descbuf, 0);
- if (swap)
- PROGRAM_SET_BSWAP(p);
- if (ps)
- PROGRAM_SET_36BIT_ADDR(p);
- SHR_HDR(p, SHR_ALWAYS, 1, 0);
-
- KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
- cipherdata->keylen, INLINE_KEY(cipherdata));
- SEQLOAD(p, CONTEXT1, 0, 8, 0);
- MATHB(p, SEQINSZ, SUB, MATH2, VSEQINSZ, 4, 0);
- MATHB(p, SEQINSZ, SUB, MATH2, VSEQOUTSZ, 4, 0);
- ALG_OPERATION(p, OP_ALG_ALGSEL_KASUMI, OP_ALG_AAI_F8,
- OP_ALG_AS_INITFINAL, 0, dir);
- SEQFIFOLOAD(p, MSG1, 0, VLF | LAST1);
- SEQFIFOSTORE(p, MSG, 0, 0, VLF);
-
- return PROGRAM_FINALIZE(p);
-}
-
-/**
- * cnstr_shdsc_kasumi_f9 - KASUMI F9 (Integrity) as a shared descriptor
- * (ETSI "Document 1: f8 and f9 specification")
- * @descbuf: pointer to descriptor-under-construction buffer
- * @ps: if 36/40bit addressing is desired, this parameter must be true
- * @swap: must be true when core endianness doesn't match SEC endianness
- * @authdata: pointer to authentication transform definitions
- * @chk_icv: check or generate ICV value
- * @authlen: size of digest
- *
- * Return: size of descriptor written in words or negative number on error
- */
-static inline int
-cnstr_shdsc_kasumi_f9(uint32_t *descbuf, bool ps, bool swap,
- struct alginfo *authdata, uint8_t chk_icv,
- uint32_t authlen)
-{
- struct program prg;
- struct program *p = &prg;
- int dir = chk_icv ? DIR_DEC : DIR_ENC;
-
- PROGRAM_CNTXT_INIT(p, descbuf, 0);
- if (swap)
- PROGRAM_SET_BSWAP(p);
-
- if (ps)
- PROGRAM_SET_36BIT_ADDR(p);
-
- SHR_HDR(p, SHR_ALWAYS, 1, 0);
-
- KEY(p, KEY2, authdata->key_enc_flags, authdata->key,
- authdata->keylen, INLINE_KEY(authdata));
-
- SEQLOAD(p, CONTEXT2, 0, 12, 0);
-
- if (chk_icv == ICV_CHECK_ENABLE)
- MATHB(p, SEQINSZ, SUB, authlen, VSEQINSZ, 4, IMMED2);
- else
- MATHB(p, SEQINSZ, SUB, ZERO, VSEQINSZ, 4, 0);
-
- ALG_OPERATION(p, OP_ALG_ALGSEL_KASUMI, OP_ALG_AAI_F9,
- OP_ALG_AS_INITFINAL, chk_icv, dir);
-
- SEQFIFOLOAD(p, MSG2, 0, VLF | CLASS2 | LAST2);
-
- if (chk_icv == ICV_CHECK_ENABLE)
- SEQFIFOLOAD(p, ICV2, authlen, LAST2);
- else
- /* Save lower half of MAC out into a 32-bit sequence */
- SEQSTORE(p, CONTEXT2, 0, authlen, 0);
-
- return PROGRAM_FINALIZE(p);
-}
-
-/**
- * cnstr_shdsc_crc - CRC32 Accelerator (IEEE 802 CRC32 protocol mode)
- * @descbuf: pointer to descriptor-under-construction buffer
- * @swap: must be true when core endianness doesn't match SEC endianness
- *
- * Return: size of descriptor written in words or negative number on error
- */
-static inline int
-cnstr_shdsc_crc(uint32_t *descbuf, bool swap)
-{
- struct program prg;
- struct program *p = &prg;
-
- PROGRAM_CNTXT_INIT(p, descbuf, 0);
- if (swap)
- PROGRAM_SET_BSWAP(p);
-
- SHR_HDR(p, SHR_ALWAYS, 1, 0);
-
- MATHB(p, SEQINSZ, SUB, MATH2, VSEQINSZ, 4, 0);
- ALG_OPERATION(p, OP_ALG_ALGSEL_CRC,
- OP_ALG_AAI_802 | OP_ALG_AAI_DOC,
- OP_ALG_AS_FINALIZE, 0, DIR_ENC);
- SEQFIFOLOAD(p, MSG2, 0, VLF | LAST2);
- SEQSTORE(p, CONTEXT2, 0, 4, 0);
-
- return PROGRAM_FINALIZE(p);
-}
-
-/**
- * cnstr_shdsc_gcm_encap - AES-GCM encap as a shared descriptor
- * @descbuf: pointer to descriptor-under-construction buffer
- * @ps: if 36/40bit addressing is desired, this parameter must be true
- * @swap: must be true when core endianness doesn't match SEC endianness
- * @share: sharing type of shared descriptor
- * @cipherdata: pointer to block cipher transform definitions
- * Valid algorithm values - OP_ALG_ALGSEL_AES ANDed with
- * OP_ALG_AAI_GCM.
- * @ivlen: Initialization vector length
- * @icvsize: integrity check value (ICV) size (truncated or full)
- *
- * Return: size of descriptor written in words or negative number on error
- */
-static inline int
-cnstr_shdsc_gcm_encap(uint32_t *descbuf, bool ps, bool swap,
- enum rta_share_type share,
- struct alginfo *cipherdata,
- uint32_t ivlen, uint32_t icvsize)
-{
- struct program prg;
- struct program *p = &prg;
-
- LABEL(keyjmp);
- LABEL(zeroassocjump2);
- LABEL(zeroassocjump1);
- LABEL(zeropayloadjump);
- REFERENCE(pkeyjmp);
- REFERENCE(pzeroassocjump2);
- REFERENCE(pzeroassocjump1);
- REFERENCE(pzeropayloadjump);
-
- PROGRAM_CNTXT_INIT(p, descbuf, 0);
-
- if (swap)
- PROGRAM_SET_BSWAP(p);
- if (ps)
- PROGRAM_SET_36BIT_ADDR(p);
-
- SHR_HDR(p, share, 1, SC);
-
- pkeyjmp = JUMP(p, keyjmp, LOCAL_JUMP, ALL_TRUE, SELF | SHRD);
- /* Insert Key */
- KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
- cipherdata->keylen, INLINE_KEY(cipherdata));
-
- SET_LABEL(p, keyjmp);
-
- /* class 1 operation */
- ALG_OPERATION(p, cipherdata->algtype, cipherdata->algmode,
- OP_ALG_AS_INITFINAL, ICV_CHECK_DISABLE, DIR_ENC);
-
- MATHB(p, DPOVRD, AND, 0x7fffffff, MATH3, 4, IMMED2);
-
- /* if assoclen + cryptlen is ZERO, skip to ICV write */
- MATHB(p, SEQINSZ, SUB, ivlen, VSEQOUTSZ, 4, IMMED2);
- pzeroassocjump2 = JUMP(p, zeroassocjump2, LOCAL_JUMP, ALL_TRUE, MATH_Z);
-
- SEQFIFOLOAD(p, IV1, ivlen, FLUSH1);
-
- /* if assoclen is ZERO, skip reading the assoc data */
- MATHB(p, ZERO, ADD, MATH3, VSEQINSZ, 4, 0);
- pzeroassocjump1 = JUMP(p, zeroassocjump1, LOCAL_JUMP, ALL_TRUE, MATH_Z);
-
- /* cryptlen = seqinlen - assoclen */
- MATHB(p, SEQINSZ, SUB, MATH3, VSEQOUTSZ, 4, 0);
-
- /* if cryptlen is ZERO jump to zero-payload commands */
- pzeropayloadjump = JUMP(p, zeropayloadjump, LOCAL_JUMP, ALL_TRUE,
- MATH_Z);
-
- /* read assoc data */
- SEQFIFOLOAD(p, AAD1, 0, CLASS1 | VLF | FLUSH1);
- SET_LABEL(p, zeroassocjump1);
-
- MATHB(p, SEQINSZ, SUB, MATH0, VSEQINSZ, 4, 0);
-
- /* write encrypted data */
- SEQFIFOSTORE(p, MSG, 0, 0, VLF);
-
- /* read payload data */
- SEQFIFOLOAD(p, MSG1, 0, CLASS1 | VLF | LAST1);
-
- /* jump the zero-payload commands */
- JUMP(p, 4, LOCAL_JUMP, ALL_TRUE, 0);
-
- /* zero-payload commands */
- SET_LABEL(p, zeropayloadjump);
-
- /* read assoc data */
- SEQFIFOLOAD(p, AAD1, 0, CLASS1 | VLF | LAST1);
-
- JUMP(p, 2, LOCAL_JUMP, ALL_TRUE, 0);
-
- /* There is no input data */
- SET_LABEL(p, zeroassocjump2);
-
- SEQFIFOLOAD(p, IV1, ivlen, FLUSH1 | LAST1);
-
- /* write ICV */
- SEQSTORE(p, CONTEXT1, 0, icvsize, 0);
-
- PATCH_JUMP(p, pkeyjmp, keyjmp);
- PATCH_JUMP(p, pzeroassocjump2, zeroassocjump2);
- PATCH_JUMP(p, pzeroassocjump1, zeroassocjump1);
- PATCH_JUMP(p, pzeropayloadjump, zeropayloadjump);
-
- return PROGRAM_FINALIZE(p);
-}
-
-/**
- * cnstr_shdsc_gcm_decap - AES-GCM decap as a shared descriptor
- * @descbuf: pointer to descriptor-under-construction buffer
- * @ps: if 36/40bit addressing is desired, this parameter must be true
- * @swap: must be true when core endianness doesn't match SEC endianness
- * @share: sharing type of shared descriptor
- * @cipherdata: pointer to block cipher transform definitions
- * Valid algorithm values - OP_ALG_ALGSEL_AES ANDed with
- * OP_ALG_AAI_GCM.
- * @icvsize: integrity check value (ICV) size (truncated or full)
- *
- * Return: size of descriptor written in words or negative number on error
- */
-static inline int
-cnstr_shdsc_gcm_decap(uint32_t *descbuf, bool ps, bool swap,
- enum rta_share_type share,
- struct alginfo *cipherdata,
- uint32_t ivlen, uint32_t icvsize)
-{
- struct program prg;
- struct program *p = &prg;
-
- LABEL(keyjmp);
- LABEL(zeroassocjump1);
- LABEL(zeropayloadjump);
- REFERENCE(pkeyjmp);
- REFERENCE(pzeroassocjump1);
- REFERENCE(pzeropayloadjump);
-
- PROGRAM_CNTXT_INIT(p, descbuf, 0);
-
- if (swap)
- PROGRAM_SET_BSWAP(p);
- if (ps)
- PROGRAM_SET_36BIT_ADDR(p);
-
- SHR_HDR(p, share, 1, SC);
-
- pkeyjmp = JUMP(p, keyjmp, LOCAL_JUMP, ALL_TRUE, SELF | SHRD);
- /* Insert Key */
- KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
- cipherdata->keylen, INLINE_KEY(cipherdata));
-
- SET_LABEL(p, keyjmp);
-
- /* class 1 operation */
- ALG_OPERATION(p, cipherdata->algtype, cipherdata->algmode,
- OP_ALG_AS_INITFINAL, ICV_CHECK_ENABLE, DIR_DEC);
-
- MATHB(p, DPOVRD, AND, 0x7fffffff, MATH3, 4, IMMED2);
- SEQFIFOLOAD(p, IV1, ivlen, FLUSH1);
-
- /* if assoclen is ZERO, skip reading the assoc data */
- MATHB(p, ZERO, ADD, MATH3, VSEQINSZ, 4, 0);
- pzeroassocjump1 = JUMP(p, zeroassocjump1, LOCAL_JUMP, ALL_TRUE, MATH_Z);
-
- /* read assoc data */
- SEQFIFOLOAD(p, AAD1, 0, CLASS1 | VLF | FLUSH1);
-
- SET_LABEL(p, zeroassocjump1);
-
- /* cryptlen = seqoutlen - assoclen */
- MATHB(p, SEQOUTSZ, SUB, MATH0, VSEQINSZ, 4, 0);
-
- /* jump to zero-payload command if cryptlen is zero */
- pzeropayloadjump = JUMP(p, zeropayloadjump, LOCAL_JUMP, ALL_TRUE,
- MATH_Z);
-
- MATHB(p, SEQOUTSZ, SUB, MATH0, VSEQOUTSZ, 4, 0);
-
- /* store encrypted data */
- SEQFIFOSTORE(p, MSG, 0, 0, VLF);
-
- /* read payload data */
- SEQFIFOLOAD(p, MSG1, 0, CLASS1 | VLF | FLUSH1);
-
- /* zero-payload command */
- SET_LABEL(p, zeropayloadjump);
-
- /* read ICV */
- SEQFIFOLOAD(p, ICV1, icvsize, CLASS1 | LAST1);
-
- PATCH_JUMP(p, pkeyjmp, keyjmp);
- PATCH_JUMP(p, pzeroassocjump1, zeroassocjump1);
- PATCH_JUMP(p, pzeropayloadjump, zeropayloadjump);
-
- return PROGRAM_FINALIZE(p);
-}
-
-#endif /* __DESC_ALGO_H__ */
+++ /dev/null
-/* SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0)
- *
- * Copyright 2008-2016 Freescale Semiconductor Inc.
- * Copyright 2016 NXP
- *
- */
-
-#ifndef __DESC_COMMON_H__
-#define __DESC_COMMON_H__
-
-#include "hw/rta.h"
-
-/**
- * DOC: Shared Descriptor Constructors - shared structures
- *
- * Data structures shared between algorithm, protocol implementations.
- */
-
-/**
- * struct alginfo - Container for algorithm details
- * @algtype: algorithm selector; for valid values, see documentation of the
- * functions where it is used.
- * @keylen: length of the provided algorithm key, in bytes
- * @key: address where algorithm key resides; virtual address if key_type is
- * RTA_DATA_IMM, physical (bus) address if key_type is RTA_DATA_PTR or
- * RTA_DATA_IMM_DMA.
- * @key_enc_flags: key encryption flags; see encrypt_flags parameter of KEY
- * command for valid values.
- * @key_type: enum rta_data_type
- * @algmode: algorithm mode selector; for valid values, see documentation of the
- * functions where it is used.
- */
-struct alginfo {
- uint32_t algtype;
- uint32_t keylen;
- uint64_t key;
- uint32_t key_enc_flags;
- enum rta_data_type key_type;
- uint16_t algmode;
-};
-
-#define INLINE_KEY(alginfo) inline_flags(alginfo->key_type)
-
-/**
- * rta_inline_query() - Provide indications on which data items can be inlined
- * and which shall be referenced in a shared descriptor.
- * @sd_base_len: Shared descriptor base length - bytes consumed by the commands,
- * excluding the data items to be inlined (or corresponding
- * pointer if an item is not inlined). Each cnstr_* function that
- * generates descriptors should have a define mentioning
- * corresponding length.
- * @jd_len: Maximum length of the job descriptor(s) that will be used
- * together with the shared descriptor.
- * @data_len: Array of lengths of the data items trying to be inlined
- * @inl_mask: 32bit mask with bit x = 1 if data item x can be inlined, 0
- * otherwise.
- * @count: Number of data items (size of @data_len array); must be <= 32
- *
- * Return: 0 if data can be inlined / referenced, negative value if not. If 0,
- * check @inl_mask for details.
- */
-static inline int
-rta_inline_query(unsigned int sd_base_len,
- unsigned int jd_len,
- unsigned int *data_len,
- uint32_t *inl_mask,
- unsigned int count)
-{
- int rem_bytes = (int)(CAAM_DESC_BYTES_MAX - sd_base_len - jd_len);
- unsigned int i;
-
- *inl_mask = 0;
- for (i = 0; (i < count) && (rem_bytes > 0); i++) {
- if (rem_bytes - (int)(data_len[i] +
- (count - i - 1) * CAAM_PTR_SZ) >= 0) {
- rem_bytes -= data_len[i];
- *inl_mask |= (1 << i);
- } else {
- rem_bytes -= CAAM_PTR_SZ;
- }
- }
-
- return (rem_bytes >= 0) ? 0 : -1;
-}
-
-/**
- * struct protcmd - Container for Protocol Operation Command fields
- * @optype: command type
- * @protid: protocol Identifier
- * @protinfo: protocol Information
- */
-struct protcmd {
- uint32_t optype;
- uint32_t protid;
- uint16_t protinfo;
-};
-
-#endif /* __DESC_COMMON_H__ */
+++ /dev/null
-/* SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0)
- *
- * Copyright 2008-2016 Freescale Semiconductor Inc.
- * Copyright 2016,2019 NXP
- *
- */
-
-#ifndef __DESC_IPSEC_H__
-#define __DESC_IPSEC_H__
-
-#include "hw/rta.h"
-#include "common.h"
-
-/**
- * DOC: IPsec Shared Descriptor Constructors
- *
- * Shared descriptors for IPsec protocol.
- */
-
-/* General IPSec ESP encap / decap PDB options */
-
-/**
- * PDBOPTS_ESP_ESN - Extended sequence included
- */
-#define PDBOPTS_ESP_ESN 0x10
-
-/**
- * PDBOPTS_ESP_IPVSN - Process IPv6 header
- *
- * Valid only for IPsec legacy mode.
- */
-#define PDBOPTS_ESP_IPVSN 0x02
-
-/**
- * PDBOPTS_ESP_TUNNEL - Tunnel mode next-header byte
- *
- * Valid only for IPsec legacy mode.
- */
-#define PDBOPTS_ESP_TUNNEL 0x01
-
-/* IPSec ESP Encap PDB options */
-
-/**
- * PDBOPTS_ESP_UPDATE_CSUM - Update ip header checksum
- *
- * Valid only for IPsec legacy mode.
- */
-#define PDBOPTS_ESP_UPDATE_CSUM 0x80
-
-/**
- * PDBOPTS_ESP_DIFFSERV - Copy TOS/TC from inner iphdr
- *
- * Valid only for IPsec legacy mode.
- */
-#define PDBOPTS_ESP_DIFFSERV 0x40
-
-/**
- * PDBOPTS_ESP_IVSRC - IV comes from internal random gen
- */
-#define PDBOPTS_ESP_IVSRC 0x20
-
-/**
- * PDBOPTS_ESP_IPHDRSRC - IP header comes from PDB
- *
- * Valid only for IPsec legacy mode.
- */
-#define PDBOPTS_ESP_IPHDRSRC 0x08
-
-/**
- * PDBOPTS_ESP_INCIPHDR - Prepend IP header to output frame
- *
- * Valid only for IPsec legacy mode.
- */
-#define PDBOPTS_ESP_INCIPHDR 0x04
-
-/**
- * PDBOPTS_ESP_OIHI_MASK - Mask for Outer IP Header Included
- *
- * Valid only for IPsec new mode.
- */
-#define PDBOPTS_ESP_OIHI_MASK 0x0c
-
-/**
- * PDBOPTS_ESP_OIHI_PDB_INL - Prepend IP header to output frame from PDB (where
- * it is inlined).
- *
- * Valid only for IPsec new mode.
- */
-#define PDBOPTS_ESP_OIHI_PDB_INL 0x0c
-
-/**
- * PDBOPTS_ESP_OIHI_PDB_REF - Prepend IP header to output frame from PDB
- * (referenced by pointer).
- *
- * Vlid only for IPsec new mode.
- */
-#define PDBOPTS_ESP_OIHI_PDB_REF 0x08
-
-/**
- * PDBOPTS_ESP_OIHI_IF - Prepend IP header to output frame from input frame
- *
- * Valid only for IPsec new mode.
- */
-#define PDBOPTS_ESP_OIHI_IF 0x04
-
-/**
- * PDBOPTS_ESP_NAT - Enable RFC 3948 UDP-encapsulated-ESP
- *
- * Valid only for IPsec new mode.
- */
-#define PDBOPTS_ESP_NAT 0x02
-
-/**
- * PDBOPTS_ESP_NUC - Enable NAT UDP Checksum
- *
- * Valid only for IPsec new mode.
- */
-#define PDBOPTS_ESP_NUC 0x01
-
-/* IPSec ESP Decap PDB options */
-
-/**
- * PDBOPTS_ESP_ARS_MASK - antireplay window mask
- */
-#define PDBOPTS_ESP_ARS_MASK 0xc0
-
-/**
- * PDBOPTS_ESP_ARSNONE - No antireplay window
- */
-#define PDBOPTS_ESP_ARSNONE 0x00
-
-/**
- * PDBOPTS_ESP_ARS64 - 64-entry antireplay window
- */
-#define PDBOPTS_ESP_ARS64 0xc0
-
-/**
- * PDBOPTS_ESP_ARS128 - 128-entry antireplay window
- *
- * Valid only for IPsec new mode.
- */
-#define PDBOPTS_ESP_ARS128 0x80
-
-/**
- * PDBOPTS_ESP_ARS32 - 32-entry antireplay window
- */
-#define PDBOPTS_ESP_ARS32 0x40
-
-/**
- * PDBOPTS_ESP_VERIFY_CSUM - Validate ip header checksum
- *
- * Valid only for IPsec legacy mode.
- */
-#define PDBOPTS_ESP_VERIFY_CSUM 0x20
-
-/**
- * PDBOPTS_ESP_TECN - Implement RRFC6040 ECN tunneling from outer header to
- * inner header.
- *
- * Valid only for IPsec new mode.
- */
-#define PDBOPTS_ESP_TECN 0x20
-
-/**
- * PDBOPTS_ESP_OUTFMT - Output only decapsulation
- *
- * Valid only for IPsec legacy mode.
- */
-#define PDBOPTS_ESP_OUTFMT 0x08
-
-/**
- * PDBOPTS_ESP_AOFL - Adjust out frame len
- *
- * Valid only for IPsec legacy mode and for SEC >= 5.3.
- */
-#define PDBOPTS_ESP_AOFL 0x04
-
-/**
- * PDBOPTS_ESP_ETU - EtherType Update
- *
- * Add corresponding ethertype (0x0800 for IPv4, 0x86dd for IPv6) in the output
- * frame.
- * Valid only for IPsec new mode.
- */
-#define PDBOPTS_ESP_ETU 0x01
-
-#define PDBHMO_ESP_DECAP_SHIFT 28
-#define PDBHMO_ESP_ENCAP_SHIFT 28
-#define PDBNH_ESP_ENCAP_SHIFT 16
-#define PDBNH_ESP_ENCAP_MASK (0xff << PDBNH_ESP_ENCAP_SHIFT)
-#define PDBHDRLEN_ESP_DECAP_SHIFT 16
-#define PDBHDRLEN_MASK (0x0fff << PDBHDRLEN_ESP_DECAP_SHIFT)
-#define PDB_NH_OFFSET_SHIFT 8
-#define PDB_NH_OFFSET_MASK (0xff << PDB_NH_OFFSET_SHIFT)
-
-/**
- * PDBHMO_ESP_DECAP_DTTL - IPsec ESP decrement TTL (IPv4) / Hop limit (IPv6)
- * HMO option.
- */
-#define PDBHMO_ESP_DECAP_DTTL (0x02 << PDBHMO_ESP_DECAP_SHIFT)
-
-/**
- * PDBHMO_ESP_ENCAP_DTTL - IPsec ESP increment TTL (IPv4) / Hop limit (IPv6)
- * HMO option.
- */
-#define PDBHMO_ESP_ENCAP_DTTL (0x02 << PDBHMO_ESP_ENCAP_SHIFT)
-
-/**
- * PDBHMO_ESP_DIFFSERV - (Decap) DiffServ Copy - Copy the IPv4 TOS or IPv6
- * Traffic Class byte from the outer IP header to the
- * inner IP header.
- */
-#define PDBHMO_ESP_DIFFSERV (0x01 << PDBHMO_ESP_DECAP_SHIFT)
-
-/**
- * PDBHMO_ESP_SNR - (Encap) - Sequence Number Rollover control
- *
- * Configures behaviour in case of SN / ESN rollover:
- * error if SNR = 1, rollover allowed if SNR = 0.
- * Valid only for IPsec new mode.
- */
-#define PDBHMO_ESP_SNR (0x01 << PDBHMO_ESP_ENCAP_SHIFT)
-
-/**
- * PDBHMO_ESP_DFBIT - (Encap) Copy DF bit - if an IPv4 tunnel mode outer IP
- * header is coming from the PDB, copy the DF bit from the
- * inner IP header to the outer IP header.
- */
-#define PDBHMO_ESP_DFBIT (0x04 << PDBHMO_ESP_ENCAP_SHIFT)
-
-/**
- * PDBHMO_ESP_DFV - (Decap) - DF bit value
- *
- * If ODF = 1, DF bit in output frame is replaced by DFV.
- * Valid only from SEC Era 5 onwards.
- */
-#define PDBHMO_ESP_DFV (0x04 << PDBHMO_ESP_DECAP_SHIFT)
-
-/**
- * PDBHMO_ESP_ODF - (Decap) Override DF bit in IPv4 header of decapsulated
- * output frame.
- *
- * If ODF = 1, DF is replaced with the value of DFV bit.
- * Valid only from SEC Era 5 onwards.
- */
-#define PDBHMO_ESP_ODF (0x08 << PDBHMO_ESP_DECAP_SHIFT)
-
-/**
- * struct ipsec_encap_cbc - PDB part for IPsec CBC encapsulation
- * @iv: 16-byte array initialization vector
- */
-struct ipsec_encap_cbc {
- uint8_t iv[16];
-};
-
-
-/**
- * struct ipsec_encap_ctr - PDB part for IPsec CTR encapsulation
- * @ctr_nonce: 4-byte array nonce
- * @ctr_initial: initial count constant
- * @iv: initialization vector
- */
-struct ipsec_encap_ctr {
- uint8_t ctr_nonce[4];
- uint32_t ctr_initial;
- uint64_t iv;
-};
-
-/**
- * struct ipsec_encap_ccm - PDB part for IPsec CCM encapsulation
- * @salt: 3-byte array salt (lower 24 bits)
- * @ccm_opt: CCM algorithm options - MSB-LSB description:
- * b0_flags (8b) - CCM B0; use 0x5B for 8-byte ICV, 0x6B for 12-byte ICV,
- * 0x7B for 16-byte ICV (cf. RFC4309, RFC3610)
- * ctr_flags (8b) - counter flags; constant equal to 0x3
- * ctr_initial (16b) - initial count constant
- * @iv: initialization vector
- */
-struct ipsec_encap_ccm {
- uint8_t salt[4];
- uint32_t ccm_opt;
- uint64_t iv;
-};
-
-/**
- * struct ipsec_encap_gcm - PDB part for IPsec GCM encapsulation
- * @salt: 3-byte array salt (lower 24 bits)
- * @rsvd: reserved, do not use
- * @iv: initialization vector
- */
-struct ipsec_encap_gcm {
- uint8_t salt[4];
- uint32_t rsvd;
- uint64_t iv;
-};
-
-/**
- * struct ipsec_encap_pdb - PDB for IPsec encapsulation
- * @options: MSB-LSB description (both for legacy and new modes)
- * hmo (header manipulation options) - 4b
- * reserved - 4b
- * next header (legacy) / reserved (new) - 8b
- * next header offset (legacy) / AOIPHO (actual outer IP header offset) - 8b
- * option flags (depend on selected algorithm) - 8b
- * @seq_num_ext_hi: (optional) IPsec Extended Sequence Number (ESN)
- * @seq_num: IPsec sequence number
- * @spi: IPsec SPI (Security Parameters Index)
- * @ip_hdr_len: optional IP Header length (in bytes)
- * reserved - 16b
- * Opt. IP Hdr Len - 16b
- * @ip_hdr: optional IP Header content (only for IPsec legacy mode)
- */
-struct ipsec_encap_pdb {
- uint32_t options;
- uint32_t seq_num_ext_hi;
- uint32_t seq_num;
- union {
- struct ipsec_encap_cbc cbc;
- struct ipsec_encap_ctr ctr;
- struct ipsec_encap_ccm ccm;
- struct ipsec_encap_gcm gcm;
- };
- uint32_t spi;
- uint32_t ip_hdr_len;
- uint8_t ip_hdr[0];
-};
-
-static inline unsigned int
-__rta_copy_ipsec_encap_pdb(struct program *program,
- struct ipsec_encap_pdb *pdb,
- uint32_t algtype)
-{
- unsigned int start_pc = program->current_pc;
-
- __rta_out32(program, pdb->options);
- __rta_out32(program, pdb->seq_num_ext_hi);
- __rta_out32(program, pdb->seq_num);
-
- switch (algtype & OP_PCL_IPSEC_CIPHER_MASK) {
- case OP_PCL_IPSEC_DES_IV64:
- case OP_PCL_IPSEC_DES:
- case OP_PCL_IPSEC_3DES:
- case OP_PCL_IPSEC_AES_CBC:
- case OP_PCL_IPSEC_NULL:
- rta_copy_data(program, pdb->cbc.iv, sizeof(pdb->cbc.iv));
- break;
-
- case OP_PCL_IPSEC_AES_CTR:
- rta_copy_data(program, pdb->ctr.ctr_nonce,
- sizeof(pdb->ctr.ctr_nonce));
- __rta_out32(program, pdb->ctr.ctr_initial);
- __rta_out64(program, true, pdb->ctr.iv);
- break;
-
- case OP_PCL_IPSEC_AES_CCM8:
- case OP_PCL_IPSEC_AES_CCM12:
- case OP_PCL_IPSEC_AES_CCM16:
- rta_copy_data(program, pdb->ccm.salt, sizeof(pdb->ccm.salt));
- __rta_out32(program, pdb->ccm.ccm_opt);
- __rta_out64(program, true, pdb->ccm.iv);
- break;
-
- case OP_PCL_IPSEC_AES_GCM8:
- case OP_PCL_IPSEC_AES_GCM12:
- case OP_PCL_IPSEC_AES_GCM16:
- case OP_PCL_IPSEC_AES_NULL_WITH_GMAC:
- rta_copy_data(program, pdb->gcm.salt, sizeof(pdb->gcm.salt));
- __rta_out32(program, pdb->gcm.rsvd);
- __rta_out64(program, true, pdb->gcm.iv);
- break;
- }
-
- __rta_out32(program, pdb->spi);
- __rta_out32(program, pdb->ip_hdr_len);
-
- return start_pc;
-}
-
-/**
- * struct ipsec_decap_cbc - PDB part for IPsec CBC decapsulation
- * @rsvd: reserved, do not use
- */
-struct ipsec_decap_cbc {
- uint32_t rsvd[2];
-};
-
-/**
- * struct ipsec_decap_ctr - PDB part for IPsec CTR decapsulation
- * @ctr_nonce: 4-byte array nonce
- * @ctr_initial: initial count constant
- */
-struct ipsec_decap_ctr {
- uint8_t ctr_nonce[4];
- uint32_t ctr_initial;
-};
-
-/**
- * struct ipsec_decap_ccm - PDB part for IPsec CCM decapsulation
- * @salt: 3-byte salt (lower 24 bits)
- * @ccm_opt: CCM algorithm options - MSB-LSB description:
- * b0_flags (8b) - CCM B0; use 0x5B for 8-byte ICV, 0x6B for 12-byte ICV,
- * 0x7B for 16-byte ICV (cf. RFC4309, RFC3610)
- * ctr_flags (8b) - counter flags; constant equal to 0x3
- * ctr_initial (16b) - initial count constant
- */
-struct ipsec_decap_ccm {
- uint8_t salt[4];
- uint32_t ccm_opt;
-};
-
-/**
- * struct ipsec_decap_gcm - PDB part for IPsec GCN decapsulation
- * @salt: 4-byte salt
- * @rsvd: reserved, do not use
- */
-struct ipsec_decap_gcm {
- uint8_t salt[4];
- uint32_t rsvd;
-};
-
-/**
- * struct ipsec_decap_pdb - PDB for IPsec decapsulation
- * @options: MSB-LSB description (both for legacy and new modes)
- * hmo (header manipulation options) - 4b
- * IP header length - 12b
- * next header offset (legacy) / AOIPHO (actual outer IP header offset) - 8b
- * option flags (depend on selected algorithm) - 8b
- * @seq_num_ext_hi: (optional) IPsec Extended Sequence Number (ESN)
- * @seq_num: IPsec sequence number
- * @anti_replay: Anti-replay window; size depends on ARS (option flags);
- * format must be Big Endian, irrespective of platform
- */
-struct ipsec_decap_pdb {
- uint32_t options;
- union {
- struct ipsec_decap_cbc cbc;
- struct ipsec_decap_ctr ctr;
- struct ipsec_decap_ccm ccm;
- struct ipsec_decap_gcm gcm;
- };
- uint32_t seq_num_ext_hi;
- uint32_t seq_num;
- uint32_t anti_replay[4];
-};
-
-static inline unsigned int
-__rta_copy_ipsec_decap_pdb(struct program *program,
- struct ipsec_decap_pdb *pdb,
- uint32_t algtype)
-{
- unsigned int start_pc = program->current_pc;
- unsigned int i, ars;
-
- __rta_out32(program, pdb->options);
-
- switch (algtype & OP_PCL_IPSEC_CIPHER_MASK) {
- case OP_PCL_IPSEC_DES_IV64:
- case OP_PCL_IPSEC_DES:
- case OP_PCL_IPSEC_3DES:
- case OP_PCL_IPSEC_AES_CBC:
- case OP_PCL_IPSEC_NULL:
- __rta_out32(program, pdb->cbc.rsvd[0]);
- __rta_out32(program, pdb->cbc.rsvd[1]);
- break;
-
- case OP_PCL_IPSEC_AES_CTR:
- rta_copy_data(program, pdb->ctr.ctr_nonce,
- sizeof(pdb->ctr.ctr_nonce));
- __rta_out32(program, pdb->ctr.ctr_initial);
- break;
-
- case OP_PCL_IPSEC_AES_CCM8:
- case OP_PCL_IPSEC_AES_CCM12:
- case OP_PCL_IPSEC_AES_CCM16:
- rta_copy_data(program, pdb->ccm.salt, sizeof(pdb->ccm.salt));
- __rta_out32(program, pdb->ccm.ccm_opt);
- break;
-
- case OP_PCL_IPSEC_AES_GCM8:
- case OP_PCL_IPSEC_AES_GCM12:
- case OP_PCL_IPSEC_AES_GCM16:
- case OP_PCL_IPSEC_AES_NULL_WITH_GMAC:
- rta_copy_data(program, pdb->gcm.salt, sizeof(pdb->gcm.salt));
- __rta_out32(program, pdb->gcm.rsvd);
- break;
- }
-
- __rta_out32(program, pdb->seq_num_ext_hi);
- __rta_out32(program, pdb->seq_num);
-
- switch (pdb->options & PDBOPTS_ESP_ARS_MASK) {
- case PDBOPTS_ESP_ARS128:
- ars = 4;
- break;
- case PDBOPTS_ESP_ARS64:
- ars = 2;
- break;
- case PDBOPTS_ESP_ARS32:
- ars = 1;
- break;
- case PDBOPTS_ESP_ARSNONE:
- default:
- ars = 0;
- break;
- }
-
- for (i = 0; i < ars; i++)
- __rta_out_be32(program, pdb->anti_replay[i]);
-
- return start_pc;
-}
-
-/**
- * enum ipsec_icv_size - Type selectors for icv size in IPsec protocol
- * @IPSEC_ICV_MD5_SIZE: full-length MD5 ICV
- * @IPSEC_ICV_MD5_TRUNC_SIZE: truncated MD5 ICV
- */
-enum ipsec_icv_size {
- IPSEC_ICV_MD5_SIZE = 16,
- IPSEC_ICV_MD5_TRUNC_SIZE = 12
-};
-
-/*
- * IPSec ESP Datapath Protocol Override Register (DPOVRD)
- * IPSEC_N_* defines are for IPsec new mode.
- */
-
-/**
- * IPSEC_DPOVRD_USE - DPOVRD will override values specified in the PDB
- */
-#define IPSEC_DPOVRD_USE BIT(31)
-
-/**
- * IPSEC_DPOVRD_ECN_SHIFT - Explicit Congestion Notification
- *
- * If set, MSB of the 4 bits indicates that the 2 LSBs will replace the ECN bits
- * in the IP header.
- */
-#define IPSEC_DPOVRD_ECN_SHIFT 24
-
-/**
- * IPSEC_DPOVRD_ECN_MASK - See IPSEC_DPOVRD_ECN_SHIFT
- */
-#define IPSEC_DPOVRD_ECN_MASK (0xf << IPSEC_ENCAP_DPOVRD_ECN_SHIFT)
-
-/**
- * IPSEC_DPOVRD_IP_HDR_LEN_SHIFT - The length (in bytes) of the portion of the
- * IP header that is not encrypted
- */
-#define IPSEC_DPOVRD_IP_HDR_LEN_SHIFT 16
-
-/**
- * IPSEC_DPOVRD_IP_HDR_LEN_MASK - See IPSEC_DPOVRD_IP_HDR_LEN_SHIFT
- */
-#define IPSEC_DPOVRD_IP_HDR_LEN_MASK (0xff << IPSEC_DPOVRD_IP_HDR_LEN_SHIFT)
-
-/**
- * IPSEC_DPOVRD_NH_OFFSET_SHIFT - The location of the next header field within
- * the IP header of the transport mode packet
- *
- * Encap:
- * ESP_Trailer_NH <-- IP_Hdr[DPOVRD[NH_OFFSET]]
- * IP_Hdr[DPOVRD[NH_OFFSET]] <-- DPOVRD[NH]
- *Decap:
- * IP_Hdr[DPOVRD[NH_OFFSET]] <-- ESP_Trailer_NH
- */
-#define IPSEC_DPOVRD_NH_OFFSET_SHIFT 8
-
-/**
- * IPSEC_DPOVRD_NH_OFFSET_MASK - See IPSEC_DPOVRD_NH_OFFSET_SHIFT
- */
-#define IPSEC_DPOVRD_NH_OFFSET_MASK (0xff << IPSEC_DPOVRD_NH_OFFSET_SHIFT)
-
-/**
- * IPSEC_DPOVRD_NH_MASK - See IPSEC_DPOVRD_NH_OFFSET_SHIFT
- * Valid only for encapsulation.
- */
-#define IPSEC_DPOVRD_NH_MASK 0xff
-
-/**
- * IPSEC_N_ENCAP_DPOVRD_OIM_LEN_SHIFT - Outer IP header Material length (encap)
- * Valid only if L2_COPY is not set.
- */
-#define IPSEC_N_ENCAP_DPOVRD_OIM_LEN_SHIFT 16
-
-/**
- * IPSEC_N_ENCAP_DPOVRD_OIM_LEN_MASK - See IPSEC_N_ENCAP_DPOVRD_OIM_LEN_SHIFT
- */
-#define IPSEC_N_ENCAP_DPOVRD_OIM_LEN_MASK \
- (0xfff << IPSEC_N_ENCAP_DPOVRD_OIM_LEN_SHIFT)
-
-/**
- * IPSEC_N_ENCAP_DPOVRD_L2_LEN_SHIFT - L2 header length
- * Valid only if L2_COPY is set.
- */
-#define IPSEC_N_ENCAP_DPOVRD_L2_LEN_SHIFT 16
-
-/**
- * IPSEC_N_ENCAP_DPOVRD_L2_LEN_MASK - See IPSEC_N_ENCAP_DPOVRD_L2_LEN_SHIFT
- */
-#define IPSEC_N_ENCAP_DPOVRD_L2_LEN_MASK \
- (0xff << IPSEC_N_ENCAP_DPOVRD_L2_LEN_SHIFT)
-
-/**
- * IPSEC_N_ENCAP_DPOVRD_OIMIF - Outer IP header Material in Input Frame
- */
-#define IPSEC_N_ENCAP_DPOVRD_OIMIF BIT(15)
-
-/**
- * IPSEC_N_ENCAP_DPOVRD_L2_COPY - L2 header present in input frame
- *
- * Note: For Era <= 8, this bit is reserved (not used) by HW.
- */
-#define IPSEC_N_ENCAP_DPOVRD_L2_COPY BIT(14)
-
-/**
- * IPSEC_N_ENCAP_DPOVRD_AOIPHO_SHIFT - Actual Outer IP Header Offset (encap)
- */
-#define IPSEC_N_ENCAP_DPOVRD_AOIPHO_SHIFT 8
-
-/**
- * IPSEC_N_ENCAP_DPOVRD_AOIPHO_MASK - See IPSEC_N_ENCAP_DPOVRD_AOIPHO_SHIFT
- */
-#define IPSEC_N_ENCAP_DPOVRD_AOIPHO_MASK \
- (0x3c << IPSEC_N_ENCAP_DPOVRD_AOIPHO_SHIFT)
-
-/**
- * IPSEC_N_ENCAP_DPOVRD_NH_MASK - Next Header
- *
- * Used in the Next Header field of the encapsulated payload.
- */
-#define IPSEC_N_ENCAP_DPOVRD_NH_MASK 0xff
-
-/**
- * IPSEC_N_DECAP_DPOVRD_AOIPHO_SHIFT - Actual Outer IP Header Offset (decap)
- */
-#define IPSEC_N_DECAP_DPOVRD_AOIPHO_SHIFT 12
-
-/**
- * IPSEC_N_DECAP_DPOVRD_AOIPHO_MASK - See IPSEC_N_DECAP_DPOVRD_AOIPHO_SHIFT
- */
-#define IPSEC_N_DECAP_DPOVRD_AOIPHO_MASK \
- (0xff << IPSEC_N_DECAP_DPOVRD_AOIPHO_SHIFT)
-
-/**
- * IPSEC_N_DECAP_DPOVRD_OIM_LEN_MASK - Outer IP header Material length (decap)
- */
-#define IPSEC_N_DECAP_DPOVRD_OIM_LEN_MASK 0xfff
-
-static inline void __gen_auth_key(struct program *program,
- struct alginfo *authdata)
-{
- uint32_t dkp_protid;
-
- switch (authdata->algtype & OP_PCL_IPSEC_AUTH_MASK) {
- case OP_PCL_IPSEC_HMAC_MD5_96:
- case OP_PCL_IPSEC_HMAC_MD5_128:
- dkp_protid = OP_PCLID_DKP_MD5;
- break;
- case OP_PCL_IPSEC_HMAC_SHA1_96:
- case OP_PCL_IPSEC_HMAC_SHA1_160:
- dkp_protid = OP_PCLID_DKP_SHA1;
- break;
- case OP_PCL_IPSEC_HMAC_SHA2_256_128:
- dkp_protid = OP_PCLID_DKP_SHA256;
- break;
- case OP_PCL_IPSEC_HMAC_SHA2_384_192:
- dkp_protid = OP_PCLID_DKP_SHA384;
- break;
- case OP_PCL_IPSEC_HMAC_SHA2_512_256:
- dkp_protid = OP_PCLID_DKP_SHA512;
- break;
- default:
- KEY(program, KEY2, authdata->key_enc_flags, authdata->key,
- authdata->keylen, INLINE_KEY(authdata));
- return;
- }
-
- if (authdata->key_type == RTA_DATA_PTR)
- DKP_PROTOCOL(program, dkp_protid, OP_PCL_DKP_SRC_PTR,
- OP_PCL_DKP_DST_PTR, (uint16_t)authdata->keylen,
- authdata->key, authdata->key_type);
- else
- DKP_PROTOCOL(program, dkp_protid, OP_PCL_DKP_SRC_IMM,
- OP_PCL_DKP_DST_IMM, (uint16_t)authdata->keylen,
- authdata->key, authdata->key_type);
-}
-
-/**
- * cnstr_shdsc_ipsec_encap - IPSec ESP encapsulation protocol-level shared
- * descriptor.
- * @descbuf: pointer to buffer used for descriptor construction
- * @ps: if 36/40bit addressing is desired, this parameter must be true
- * @swap: if true, perform descriptor byte swapping on a 4-byte boundary
- * @share: sharing type of shared descriptor
- * @pdb: pointer to the PDB to be used with this descriptor
- * This structure will be copied inline to the descriptor under
- * construction. No error checking will be made. Refer to the
- * block guide for a details of the encapsulation PDB.
- * @cipherdata: pointer to block cipher transform definitions
- * Valid algorithm values - one of OP_PCL_IPSEC_*
- * @authdata: pointer to authentication transform definitions
- * If an authentication key is required by the protocol:
- * -For SEC Eras 1-5, an MDHA split key must be provided;
- * Note that the size of the split key itself must be specified.
- * -For SEC Eras 6+, a "normal" key must be provided; DKP (Derived
- * Key Protocol) will be used to compute MDHA on the fly in HW.
- * Valid algorithm values - one of OP_PCL_IPSEC_*
- *
- * Return: size of descriptor written in words or negative number on error
- */
-static inline int
-cnstr_shdsc_ipsec_encap(uint32_t *descbuf, bool ps, bool swap,
- enum rta_share_type share,
- struct ipsec_encap_pdb *pdb,
- struct alginfo *cipherdata,
- struct alginfo *authdata)
-{
- struct program prg;
- struct program *p = &prg;
-
- LABEL(keyjmp);
- REFERENCE(pkeyjmp);
- LABEL(hdr);
- REFERENCE(phdr);
-
- PROGRAM_CNTXT_INIT(p, descbuf, 0);
- if (swap)
- PROGRAM_SET_BSWAP(p);
- if (ps)
- PROGRAM_SET_36BIT_ADDR(p);
- phdr = SHR_HDR(p, share, hdr, 0);
- __rta_copy_ipsec_encap_pdb(p, pdb, cipherdata->algtype);
- COPY_DATA(p, pdb->ip_hdr, pdb->ip_hdr_len);
- SET_LABEL(p, hdr);
- pkeyjmp = JUMP(p, keyjmp, LOCAL_JUMP, ALL_TRUE, BOTH|SHRD);
- if (authdata->keylen) {
- if (rta_sec_era < RTA_SEC_ERA_6)
- KEY(p, MDHA_SPLIT_KEY, authdata->key_enc_flags,
- authdata->key, authdata->keylen,
- INLINE_KEY(authdata));
- else
- __gen_auth_key(p, authdata);
- }
- if (cipherdata->keylen)
- KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
- cipherdata->keylen, INLINE_KEY(cipherdata));
- SET_LABEL(p, keyjmp);
- PROTOCOL(p, OP_TYPE_ENCAP_PROTOCOL,
- OP_PCLID_IPSEC,
- (uint16_t)(cipherdata->algtype | authdata->algtype));
- PATCH_JUMP(p, pkeyjmp, keyjmp);
- PATCH_HDR(p, phdr, hdr);
- return PROGRAM_FINALIZE(p);
-}
-
-/**
- * cnstr_shdsc_ipsec_decap - IPSec ESP decapsulation protocol-level shared
- * descriptor.
- * @descbuf: pointer to buffer used for descriptor construction
- * @ps: if 36/40bit addressing is desired, this parameter must be true
- * @swap: if true, perform descriptor byte swapping on a 4-byte boundary
- * @share: sharing type of shared descriptor
- * @pdb: pointer to the PDB to be used with this descriptor
- * This structure will be copied inline to the descriptor under
- * construction. No error checking will be made. Refer to the
- * block guide for details about the decapsulation PDB.
- * @cipherdata: pointer to block cipher transform definitions.
- * Valid algorithm values - one of OP_PCL_IPSEC_*
- * @authdata: pointer to authentication transform definitions
- * If an authentication key is required by the protocol:
- * -For SEC Eras 1-5, an MDHA split key must be provided;
- * Note that the size of the split key itself must be specified.
- * -For SEC Eras 6+, a "normal" key must be provided; DKP (Derived
- * Key Protocol) will be used to compute MDHA on the fly in HW.
- * Valid algorithm values - one of OP_PCL_IPSEC_*
- *
- * Return: size of descriptor written in words or negative number on error
- */
-static inline int
-cnstr_shdsc_ipsec_decap(uint32_t *descbuf, bool ps, bool swap,
- enum rta_share_type share,
- struct ipsec_decap_pdb *pdb,
- struct alginfo *cipherdata,
- struct alginfo *authdata)
-{
- struct program prg;
- struct program *p = &prg;
-
- LABEL(keyjmp);
- REFERENCE(pkeyjmp);
- LABEL(hdr);
- REFERENCE(phdr);
-
- PROGRAM_CNTXT_INIT(p, descbuf, 0);
- if (swap)
- PROGRAM_SET_BSWAP(p);
- if (ps)
- PROGRAM_SET_36BIT_ADDR(p);
- phdr = SHR_HDR(p, share, hdr, 0);
- __rta_copy_ipsec_decap_pdb(p, pdb, cipherdata->algtype);
- SET_LABEL(p, hdr);
- pkeyjmp = JUMP(p, keyjmp, LOCAL_JUMP, ALL_TRUE, BOTH|SHRD);
- if (authdata->keylen) {
- if (rta_sec_era < RTA_SEC_ERA_6)
- KEY(p, MDHA_SPLIT_KEY, authdata->key_enc_flags,
- authdata->key, authdata->keylen,
- INLINE_KEY(authdata));
- else
- __gen_auth_key(p, authdata);
- }
- if (cipherdata->keylen)
- KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
- cipherdata->keylen, INLINE_KEY(cipherdata));
- SET_LABEL(p, keyjmp);
- PROTOCOL(p, OP_TYPE_DECAP_PROTOCOL,
- OP_PCLID_IPSEC,
- (uint16_t)(cipherdata->algtype | authdata->algtype));
- PATCH_JUMP(p, pkeyjmp, keyjmp);
- PATCH_HDR(p, phdr, hdr);
- return PROGRAM_FINALIZE(p);
-}
-
-/**
- * cnstr_shdsc_ipsec_encap_des_aes_xcbc - IPSec DES-CBC/3DES-CBC and
- * AES-XCBC-MAC-96 ESP encapsulation shared descriptor.
- * @descbuf: pointer to buffer used for descriptor construction
- * @pdb: pointer to the PDB to be used with this descriptor
- * This structure will be copied inline to the descriptor under
- * construction. No error checking will be made. Refer to the
- * block guide for a details of the encapsulation PDB.
- * @cipherdata: pointer to block cipher transform definitions
- * Valid algorithm values - OP_PCL_IPSEC_DES, OP_PCL_IPSEC_3DES.
- * @authdata: pointer to authentication transform definitions
- * Valid algorithm value: OP_PCL_IPSEC_AES_XCBC_MAC_96.
- *
- * Supported only for platforms with 32-bit address pointers and SEC ERA 4 or
- * higher. The tunnel/transport mode of the IPsec ESP is supported only if the
- * Outer/Transport IP Header is present in the encapsulation output packet.
- * The descriptor performs DES-CBC/3DES-CBC & HMAC-MD5-96 and then rereads
- * the input packet to do the AES-XCBC-MAC-96 calculation and to overwrite
- * the MD5 ICV.
- * The descriptor uses all the benefits of the built-in protocol by computing
- * the IPsec ESP with a hardware supported algorithms combination
- * (DES-CBC/3DES-CBC & HMAC-MD5-96). The HMAC-MD5 authentication algorithm
- * was chosen in order to speed up the computational time for this intermediate
- * step.
- * Warning: The user must allocate at least 32 bytes for the authentication key
- * (in order to use it also with HMAC-MD5-96),even when using a shorter key
- * for the AES-XCBC-MAC-96.
- *
- * Return: size of descriptor written in words or negative number on error
- */
-static inline int
-cnstr_shdsc_ipsec_encap_des_aes_xcbc(uint32_t *descbuf,
- struct ipsec_encap_pdb *pdb,
- struct alginfo *cipherdata,
- struct alginfo *authdata)
-{
- struct program prg;
- struct program *p = &prg;
-
- LABEL(hdr);
- LABEL(shd_ptr);
- LABEL(keyjump);
- LABEL(outptr);
- LABEL(swapped_seqin_fields);
- LABEL(swapped_seqin_ptr);
- REFERENCE(phdr);
- REFERENCE(pkeyjump);
- REFERENCE(move_outlen);
- REFERENCE(move_seqout_ptr);
- REFERENCE(swapped_seqin_ptr_jump);
- REFERENCE(write_swapped_seqin_ptr);
-
- PROGRAM_CNTXT_INIT(p, descbuf, 0);
- phdr = SHR_HDR(p, SHR_SERIAL, hdr, 0);
- __rta_copy_ipsec_encap_pdb(p, pdb, cipherdata->algtype);
- COPY_DATA(p, pdb->ip_hdr, pdb->ip_hdr_len);
- SET_LABEL(p, hdr);
- pkeyjump = JUMP(p, keyjump, LOCAL_JUMP, ALL_TRUE, SHRD | SELF);
- /*
- * Hard-coded KEY arguments. The descriptor uses all the benefits of
- * the built-in protocol by computing the IPsec ESP with a hardware
- * supported algorithms combination (DES-CBC/3DES-CBC & HMAC-MD5-96).
- * The HMAC-MD5 authentication algorithm was chosen with
- * the keys options from below in order to speed up the computational
- * time for this intermediate step.
- * Warning: The user must allocate at least 32 bytes for
- * the authentication key (in order to use it also with HMAC-MD5-96),
- * even when using a shorter key for the AES-XCBC-MAC-96.
- */
- KEY(p, MDHA_SPLIT_KEY, 0, authdata->key, 32, INLINE_KEY(authdata));
- SET_LABEL(p, keyjump);
- LOAD(p, LDST_SRCDST_WORD_CLRW | CLRW_CLR_C1MODE | CLRW_CLR_C1DATAS |
- CLRW_CLR_C1CTX | CLRW_CLR_C1KEY | CLRW_RESET_CLS1_CHA, CLRW, 0, 4,
- IMMED);
- KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
- cipherdata->keylen, INLINE_KEY(cipherdata));
- PROTOCOL(p, OP_TYPE_ENCAP_PROTOCOL, OP_PCLID_IPSEC,
- (uint16_t)(cipherdata->algtype | OP_PCL_IPSEC_HMAC_MD5_96));
- /* Swap SEQINPTR to SEQOUTPTR. */
- move_seqout_ptr = MOVE(p, DESCBUF, 0, MATH1, 0, 16, WAITCOMP | IMMED);
- MATHB(p, MATH1, AND, ~(CMD_SEQ_IN_PTR ^ CMD_SEQ_OUT_PTR), MATH1,
- 8, IFB | IMMED2);
-/*
- * TODO: RTA currently doesn't support creating a LOAD command
- * with another command as IMM.
- * To be changed when proper support is added in RTA.
- */
- LOAD(p, 0xa00000e5, MATH3, 4, 4, IMMED);
- MATHB(p, MATH3, SHLD, MATH3, MATH3, 8, 0);
- write_swapped_seqin_ptr = MOVE(p, MATH1, 0, DESCBUF, 0, 20, WAITCOMP |
- IMMED);
- swapped_seqin_ptr_jump = JUMP(p, swapped_seqin_ptr, LOCAL_JUMP,
- ALL_TRUE, 0);
- LOAD(p, LDST_SRCDST_WORD_CLRW | CLRW_CLR_C1MODE | CLRW_CLR_C1DATAS |
- CLRW_CLR_C1CTX | CLRW_CLR_C1KEY | CLRW_RESET_CLS1_CHA, CLRW, 0, 4,
- 0);
- SEQOUTPTR(p, 0, 65535, RTO);
- move_outlen = MOVE(p, DESCBUF, 0, MATH0, 4, 8, WAITCOMP | IMMED);
- MATHB(p, MATH0, SUB,
- (uint64_t)(pdb->ip_hdr_len + IPSEC_ICV_MD5_TRUNC_SIZE),
- VSEQINSZ, 4, IMMED2);
- MATHB(p, MATH0, SUB, IPSEC_ICV_MD5_TRUNC_SIZE, VSEQOUTSZ, 4, IMMED2);
- KEY(p, KEY1, authdata->key_enc_flags, authdata->key, authdata->keylen,
- 0);
- ALG_OPERATION(p, OP_ALG_ALGSEL_AES, OP_ALG_AAI_XCBC_MAC,
- OP_ALG_AS_INITFINAL, ICV_CHECK_DISABLE, DIR_ENC);
- SEQFIFOLOAD(p, SKIP, pdb->ip_hdr_len, 0);
- SEQFIFOLOAD(p, MSG1, 0, VLF | FLUSH1 | LAST1);
- SEQFIFOSTORE(p, SKIP, 0, 0, VLF);
- SEQSTORE(p, CONTEXT1, 0, IPSEC_ICV_MD5_TRUNC_SIZE, 0);
-/*
- * TODO: RTA currently doesn't support adding labels in or after Job Descriptor.
- * To be changed when proper support is added in RTA.
- */
- /* Label the Shared Descriptor Pointer */
- SET_LABEL(p, shd_ptr);
- shd_ptr += 1;
- /* Label the Output Pointer */
- SET_LABEL(p, outptr);
- outptr += 3;
- /* Label the first word after JD */
- SET_LABEL(p, swapped_seqin_fields);
- swapped_seqin_fields += 8;
- /* Label the second word after JD */
- SET_LABEL(p, swapped_seqin_ptr);
- swapped_seqin_ptr += 9;
-
- PATCH_HDR(p, phdr, hdr);
- PATCH_JUMP(p, pkeyjump, keyjump);
- PATCH_JUMP(p, swapped_seqin_ptr_jump, swapped_seqin_ptr);
- PATCH_MOVE(p, move_outlen, outptr);
- PATCH_MOVE(p, move_seqout_ptr, shd_ptr);
- PATCH_MOVE(p, write_swapped_seqin_ptr, swapped_seqin_fields);
- return PROGRAM_FINALIZE(p);
-}
-
-/**
- * cnstr_shdsc_ipsec_decap_des_aes_xcbc - IPSec DES-CBC/3DES-CBC and
- * AES-XCBC-MAC-96 ESP decapsulation shared descriptor.
- * @descbuf: pointer to buffer used for descriptor construction
- * @pdb: pointer to the PDB to be used with this descriptor
- * This structure will be copied inline to the descriptor under
- * construction. No error checking will be made. Refer to the
- * block guide for a details of the encapsulation PDB.
- * @cipherdata: pointer to block cipher transform definitions
- * Valid algorithm values - OP_PCL_IPSEC_DES, OP_PCL_IPSEC_3DES.
- * @authdata: pointer to authentication transform definitions
- * Valid algorithm value: OP_PCL_IPSEC_AES_XCBC_MAC_96.
- *
- * Supported only for platforms with 32-bit address pointers and SEC ERA 4 or
- * higher. The tunnel/transport mode of the IPsec ESP is supported only if the
- * Outer/Transport IP Header is present in the decapsulation input packet.
- * The descriptor computes the AES-XCBC-MAC-96 to check if the received ICV
- * is correct, rereads the input packet to compute the MD5 ICV, overwrites
- * the XCBC ICV, and then sends the modified input packet to the
- * DES-CBC/3DES-CBC & HMAC-MD5-96 IPsec.
- * The descriptor uses all the benefits of the built-in protocol by computing
- * the IPsec ESP with a hardware supported algorithms combination
- * (DES-CBC/3DES-CBC & HMAC-MD5-96). The HMAC-MD5 authentication algorithm
- * was chosen in order to speed up the computational time for this intermediate
- * step.
- * Warning: The user must allocate at least 32 bytes for the authentication key
- * (in order to use it also with HMAC-MD5-96),even when using a shorter key
- * for the AES-XCBC-MAC-96.
- *
- * Return: size of descriptor written in words or negative number on error
- */
-static inline int
-cnstr_shdsc_ipsec_decap_des_aes_xcbc(uint32_t *descbuf,
- struct ipsec_decap_pdb *pdb,
- struct alginfo *cipherdata,
- struct alginfo *authdata)
-{
- struct program prg;
- struct program *p = &prg;
- uint32_t ip_hdr_len = (pdb->options & PDBHDRLEN_MASK) >>
- PDBHDRLEN_ESP_DECAP_SHIFT;
-
- LABEL(hdr);
- LABEL(jump_cmd);
- LABEL(keyjump);
- LABEL(outlen);
- LABEL(seqin_ptr);
- LABEL(seqout_ptr);
- LABEL(swapped_seqout_fields);
- LABEL(swapped_seqout_ptr);
- REFERENCE(seqout_ptr_jump);
- REFERENCE(phdr);
- REFERENCE(pkeyjump);
- REFERENCE(move_jump);
- REFERENCE(move_jump_back);
- REFERENCE(move_seqin_ptr);
- REFERENCE(swapped_seqout_ptr_jump);
- REFERENCE(write_swapped_seqout_ptr);
-
- PROGRAM_CNTXT_INIT(p, descbuf, 0);
- phdr = SHR_HDR(p, SHR_SERIAL, hdr, 0);
- __rta_copy_ipsec_decap_pdb(p, pdb, cipherdata->algtype);
- SET_LABEL(p, hdr);
- pkeyjump = JUMP(p, keyjump, LOCAL_JUMP, ALL_TRUE, SHRD | SELF);
- /*
- * Hard-coded KEY arguments. The descriptor uses all the benefits of
- * the built-in protocol by computing the IPsec ESP with a hardware
- * supported algorithms combination (DES-CBC/3DES-CBC & HMAC-MD5-96).
- * The HMAC-MD5 authentication algorithm was chosen with
- * the keys options from bellow in order to speed up the computational
- * time for this intermediate step.
- * Warning: The user must allocate at least 32 bytes for
- * the authentication key (in order to use it also with HMAC-MD5-96),
- * even when using a shorter key for the AES-XCBC-MAC-96.
- */
- KEY(p, MDHA_SPLIT_KEY, 0, authdata->key, 32, INLINE_KEY(authdata));
- SET_LABEL(p, keyjump);
- LOAD(p, LDST_SRCDST_WORD_CLRW | CLRW_CLR_C1MODE | CLRW_CLR_C1DATAS |
- CLRW_CLR_C1CTX | CLRW_CLR_C1KEY | CLRW_RESET_CLS1_CHA, CLRW, 0, 4,
- 0);
- KEY(p, KEY1, authdata->key_enc_flags, authdata->key, authdata->keylen,
- INLINE_KEY(authdata));
- MATHB(p, SEQINSZ, SUB,
- (uint64_t)(ip_hdr_len + IPSEC_ICV_MD5_TRUNC_SIZE), MATH0, 4,
- IMMED2);
- MATHB(p, MATH0, SUB, ZERO, VSEQINSZ, 4, 0);
- ALG_OPERATION(p, OP_ALG_ALGSEL_MD5, OP_ALG_AAI_HMAC_PRECOMP,
- OP_ALG_AS_INITFINAL, ICV_CHECK_DISABLE, DIR_ENC);
- ALG_OPERATION(p, OP_ALG_ALGSEL_AES, OP_ALG_AAI_XCBC_MAC,
- OP_ALG_AS_INITFINAL, ICV_CHECK_ENABLE, DIR_DEC);
- SEQFIFOLOAD(p, SKIP, ip_hdr_len, 0);
- SEQFIFOLOAD(p, MSG1, 0, VLF | FLUSH1);
- SEQFIFOLOAD(p, ICV1, IPSEC_ICV_MD5_TRUNC_SIZE, FLUSH1 | LAST1);
- /* Swap SEQOUTPTR to SEQINPTR. */
- move_seqin_ptr = MOVE(p, DESCBUF, 0, MATH1, 0, 16, WAITCOMP | IMMED);
- MATHB(p, MATH1, OR, CMD_SEQ_IN_PTR ^ CMD_SEQ_OUT_PTR, MATH1, 8,
- IFB | IMMED2);
-/*
- * TODO: RTA currently doesn't support creating a LOAD command
- * with another command as IMM.
- * To be changed when proper support is added in RTA.
- */
- LOAD(p, 0xA00000e1, MATH3, 4, 4, IMMED);
- MATHB(p, MATH3, SHLD, MATH3, MATH3, 8, 0);
- write_swapped_seqout_ptr = MOVE(p, MATH1, 0, DESCBUF, 0, 20, WAITCOMP |
- IMMED);
- swapped_seqout_ptr_jump = JUMP(p, swapped_seqout_ptr, LOCAL_JUMP,
- ALL_TRUE, 0);
-/*
- * TODO: To be changed when proper support is added in RTA (can't load
- * a command that is also written by RTA).
- * Change when proper RTA support is added.
- */
- SET_LABEL(p, jump_cmd);
- WORD(p, 0xA00000f3);
- SEQINPTR(p, 0, 65535, RTO);
- MATHB(p, MATH0, SUB, ZERO, VSEQINSZ, 4, 0);
- MATHB(p, MATH0, ADD, ip_hdr_len, VSEQOUTSZ, 4, IMMED2);
- move_jump = MOVE(p, DESCBUF, 0, OFIFO, 0, 8, WAITCOMP | IMMED);
- move_jump_back = MOVE(p, OFIFO, 0, DESCBUF, 0, 8, IMMED);
- SEQFIFOLOAD(p, SKIP, ip_hdr_len, 0);
- SEQFIFOLOAD(p, MSG2, 0, VLF | LAST2);
- SEQFIFOSTORE(p, SKIP, 0, 0, VLF);
- SEQSTORE(p, CONTEXT2, 0, IPSEC_ICV_MD5_TRUNC_SIZE, 0);
- seqout_ptr_jump = JUMP(p, seqout_ptr, LOCAL_JUMP, ALL_TRUE, CALM);
-
- LOAD(p, LDST_SRCDST_WORD_CLRW | CLRW_CLR_C1MODE | CLRW_CLR_C1DATAS |
- CLRW_CLR_C1CTX | CLRW_CLR_C1KEY | CLRW_CLR_C2MODE |
- CLRW_CLR_C2DATAS | CLRW_CLR_C2CTX | CLRW_RESET_CLS1_CHA, CLRW, 0,
- 4, 0);
- SEQINPTR(p, 0, 65535, RTO);
- MATHB(p, MATH0, ADD,
- (uint64_t)(ip_hdr_len + IPSEC_ICV_MD5_TRUNC_SIZE), SEQINSZ, 4,
- IMMED2);
- KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
- cipherdata->keylen, INLINE_KEY(cipherdata));
- PROTOCOL(p, OP_TYPE_DECAP_PROTOCOL, OP_PCLID_IPSEC,
- (uint16_t)(cipherdata->algtype | OP_PCL_IPSEC_HMAC_MD5_96));
-/*
- * TODO: RTA currently doesn't support adding labels in or after Job Descriptor.
- * To be changed when proper support is added in RTA.
- */
- /* Label the SEQ OUT PTR */
- SET_LABEL(p, seqout_ptr);
- seqout_ptr += 2;
- /* Label the Output Length */
- SET_LABEL(p, outlen);
- outlen += 4;
- /* Label the SEQ IN PTR */
- SET_LABEL(p, seqin_ptr);
- seqin_ptr += 5;
- /* Label the first word after JD */
- SET_LABEL(p, swapped_seqout_fields);
- swapped_seqout_fields += 8;
- /* Label the second word after JD */
- SET_LABEL(p, swapped_seqout_ptr);
- swapped_seqout_ptr += 9;
-
- PATCH_HDR(p, phdr, hdr);
- PATCH_JUMP(p, pkeyjump, keyjump);
- PATCH_JUMP(p, seqout_ptr_jump, seqout_ptr);
- PATCH_JUMP(p, swapped_seqout_ptr_jump, swapped_seqout_ptr);
- PATCH_MOVE(p, move_jump, jump_cmd);
- PATCH_MOVE(p, move_jump_back, seqin_ptr);
- PATCH_MOVE(p, move_seqin_ptr, outlen);
- PATCH_MOVE(p, write_swapped_seqout_ptr, swapped_seqout_fields);
- return PROGRAM_FINALIZE(p);
-}
-
-/**
- * IPSEC_NEW_ENC_BASE_DESC_LEN - IPsec new mode encap shared descriptor length
- *
- * Accounts only for the "base" commands and is intended to be used by upper
- * layers to determine whether Outer IP Header and/or keys can be inlined or
- * not. To be used as first parameter of rta_inline_query().
- */
-#define IPSEC_NEW_ENC_BASE_DESC_LEN (12 * CAAM_CMD_SZ + \
- sizeof(struct ipsec_encap_pdb))
-
-/**
- * IPSEC_NEW_NULL_ENC_BASE_DESC_LEN - IPsec new mode encap shared descriptor
- * length for the case of
- * NULL encryption / authentication
- *
- * Accounts only for the "base" commands and is intended to be used by upper
- * layers to determine whether Outer IP Header and/or key can be inlined or
- * not. To be used as first parameter of rta_inline_query().
- */
-#define IPSEC_NEW_NULL_ENC_BASE_DESC_LEN (11 * CAAM_CMD_SZ + \
- sizeof(struct ipsec_encap_pdb))
-
-/**
- * cnstr_shdsc_ipsec_new_encap - IPSec new mode ESP encapsulation
- * protocol-level shared descriptor.
- * @descbuf: pointer to buffer used for descriptor construction
- * @ps: if 36/40bit addressing is desired, this parameter must be true
- * @swap: must be true when core endianness doesn't match SEC endianness
- * @share: sharing type of shared descriptor
- * @pdb: pointer to the PDB to be used with this descriptor
- * This structure will be copied inline to the descriptor under
- * construction. No error checking will be made. Refer to the
- * block guide for details about the encapsulation PDB.
- * @opt_ip_hdr: pointer to Optional IP Header
- * -if OIHI = PDBOPTS_ESP_OIHI_PDB_INL, opt_ip_hdr points to the buffer to
- * be inlined in the PDB. Number of bytes (buffer size) copied is provided
- * in pdb->ip_hdr_len.
- * -if OIHI = PDBOPTS_ESP_OIHI_PDB_REF, opt_ip_hdr points to the address of
- * the Optional IP Header. The address will be inlined in the PDB verbatim.
- * -for other values of OIHI options field, opt_ip_hdr is not used.
- * @cipherdata: pointer to block cipher transform definitions
- * Valid algorithm values - one of OP_PCL_IPSEC_*
- * @authdata: pointer to authentication transform definitions.
- * If an authentication key is required by the protocol, a "normal"
- * key must be provided; DKP (Derived Key Protocol) will be used to
- * compute MDHA on the fly in HW.
- * Valid algorithm values - one of OP_PCL_IPSEC_*
- *
- * Note: L2 header copy functionality is implemented assuming that bits 14
- * (currently reserved) and 16-23 (part of Outer IP Header Material Length)
- * in DPOVRD register are not used (which is usually the case when L3 header
- * is provided in PDB).
- * When DPOVRD[14] is set, frame starts with an L2 header; in this case, the
- * L2 header length is found at DPOVRD[23:16]. SEC uses this length to copy
- * the header and then it deletes DPOVRD[23:16] (so there is no side effect
- * when later running IPsec protocol).
- *
- * Return: size of descriptor written in words or negative number on error
- */
-static inline int
-cnstr_shdsc_ipsec_new_encap(uint32_t *descbuf, bool ps,
- bool swap,
- enum rta_share_type share,
- struct ipsec_encap_pdb *pdb,
- uint8_t *opt_ip_hdr,
- struct alginfo *cipherdata,
- struct alginfo *authdata)
-{
- struct program prg;
- struct program *p = &prg;
-
- LABEL(keyjmp);
- REFERENCE(pkeyjmp);
- LABEL(hdr);
- REFERENCE(phdr);
- LABEL(l2copy);
- REFERENCE(pl2copy);
-
- if (rta_sec_era < RTA_SEC_ERA_8) {
- pr_err("IPsec new mode encap: available only for Era %d or above\n",
- USER_SEC_ERA(RTA_SEC_ERA_8));
- return -ENOTSUP;
- }
-
- PROGRAM_CNTXT_INIT(p, descbuf, 0);
- if (swap)
- PROGRAM_SET_BSWAP(p);
- if (ps)
- PROGRAM_SET_36BIT_ADDR(p);
- phdr = SHR_HDR(p, share, hdr, 0);
-
- __rta_copy_ipsec_encap_pdb(p, pdb, cipherdata->algtype);
-
- switch (pdb->options & PDBOPTS_ESP_OIHI_MASK) {
- case PDBOPTS_ESP_OIHI_PDB_INL:
- COPY_DATA(p, opt_ip_hdr, pdb->ip_hdr_len);
- break;
- case PDBOPTS_ESP_OIHI_PDB_REF:
- if (ps)
- COPY_DATA(p, opt_ip_hdr, 8);
- else
- COPY_DATA(p, opt_ip_hdr, 4);
- break;
- default:
- break;
- }
- SET_LABEL(p, hdr);
-
- MATHB(p, DPOVRD, AND, IPSEC_N_ENCAP_DPOVRD_L2_COPY, NONE, 4, IMMED2);
- pl2copy = JUMP(p, l2copy, LOCAL_JUMP, ALL_TRUE, MATH_Z);
- MATHI(p, DPOVRD, RSHIFT, IPSEC_N_ENCAP_DPOVRD_L2_LEN_SHIFT, VSEQOUTSZ,
- 1, 0);
- MATHB(p, DPOVRD, AND, ~IPSEC_N_ENCAP_DPOVRD_L2_LEN_MASK, DPOVRD, 4,
- IMMED2);
- /* TODO: CLASS2 corresponds to AUX=2'b10; add more intuitive defines */
- SEQFIFOSTORE(p, METADATA, 0, 0, CLASS2 | VLF);
- SET_LABEL(p, l2copy);
-
- pkeyjmp = JUMP(p, keyjmp, LOCAL_JUMP, ALL_TRUE, SHRD);
- if (authdata->keylen)
- __gen_auth_key(p, authdata);
- if (cipherdata->keylen)
- KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
- cipherdata->keylen, INLINE_KEY(cipherdata));
- SET_LABEL(p, keyjmp);
- PROTOCOL(p, OP_TYPE_ENCAP_PROTOCOL,
- OP_PCLID_IPSEC_NEW,
- (uint16_t)(cipherdata->algtype | authdata->algtype));
- PATCH_JUMP(p, pl2copy, l2copy);
- PATCH_JUMP(p, pkeyjmp, keyjmp);
- PATCH_HDR(p, phdr, hdr);
- return PROGRAM_FINALIZE(p);
-}
-
-/**
- * IPSEC_NEW_DEC_BASE_DESC_LEN - IPsec new mode decap shared descriptor length
- *
- * Accounts only for the "base" commands and is intended to be used by upper
- * layers to determine whether keys can be inlined or not. To be used as first
- * parameter of rta_inline_query().
- */
-#define IPSEC_NEW_DEC_BASE_DESC_LEN (5 * CAAM_CMD_SZ + \
- sizeof(struct ipsec_decap_pdb))
-
-/**
- * IPSEC_NEW_NULL_DEC_BASE_DESC_LEN - IPsec new mode decap shared descriptor
- * length for the case of
- * NULL decryption / authentication
- *
- * Accounts only for the "base" commands and is intended to be used by upper
- * layers to determine whether key can be inlined or not. To be used as first
- * parameter of rta_inline_query().
- */
-#define IPSEC_NEW_NULL_DEC_BASE_DESC_LEN (4 * CAAM_CMD_SZ + \
- sizeof(struct ipsec_decap_pdb))
-
-/**
- * cnstr_shdsc_ipsec_new_decap - IPSec new mode ESP decapsulation protocol-level
- * shared descriptor.
- * @descbuf: pointer to buffer used for descriptor construction
- * @ps: if 36/40bit addressing is desired, this parameter must be true
- * @swap: must be true when core endianness doesn't match SEC endianness
- * @share: sharing type of shared descriptor
- * @pdb: pointer to the PDB to be used with this descriptor
- * This structure will be copied inline to the descriptor under
- * construction. No error checking will be made. Refer to the
- * block guide for details about the decapsulation PDB.
- * @cipherdata: pointer to block cipher transform definitions
- * Valid algorithm values 0 one of OP_PCL_IPSEC_*
- * @authdata: pointer to authentication transform definitions.
- * If an authentication key is required by the protocol, a "normal"
- * key must be provided; DKP (Derived Key Protocol) will be used to
- * compute MDHA on the fly in HW.
- * Valid algorithm values - one of OP_PCL_IPSEC_*
- *
- * Return: size of descriptor written in words or negative number on error
- */
-static inline int
-cnstr_shdsc_ipsec_new_decap(uint32_t *descbuf, bool ps,
- bool swap,
- enum rta_share_type share,
- struct ipsec_decap_pdb *pdb,
- struct alginfo *cipherdata,
- struct alginfo *authdata)
-{
- struct program prg;
- struct program *p = &prg;
-
- LABEL(keyjmp);
- REFERENCE(pkeyjmp);
- LABEL(hdr);
- REFERENCE(phdr);
-
- if (rta_sec_era < RTA_SEC_ERA_8) {
- pr_err("IPsec new mode decap: available only for Era %d or above\n",
- USER_SEC_ERA(RTA_SEC_ERA_8));
- return -ENOTSUP;
- }
-
- PROGRAM_CNTXT_INIT(p, descbuf, 0);
- if (swap)
- PROGRAM_SET_BSWAP(p);
- if (ps)
- PROGRAM_SET_36BIT_ADDR(p);
- phdr = SHR_HDR(p, share, hdr, 0);
- __rta_copy_ipsec_decap_pdb(p, pdb, cipherdata->algtype);
- SET_LABEL(p, hdr);
- pkeyjmp = JUMP(p, keyjmp, LOCAL_JUMP, ALL_TRUE, SHRD);
- if (authdata->keylen)
- __gen_auth_key(p, authdata);
- if (cipherdata->keylen)
- KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
- cipherdata->keylen, INLINE_KEY(cipherdata));
- SET_LABEL(p, keyjmp);
- PROTOCOL(p, OP_TYPE_DECAP_PROTOCOL,
- OP_PCLID_IPSEC_NEW,
- (uint16_t)(cipherdata->algtype | authdata->algtype));
- PATCH_JUMP(p, pkeyjmp, keyjmp);
- PATCH_HDR(p, phdr, hdr);
- return PROGRAM_FINALIZE(p);
-}
-
-/**
- * IPSEC_AUTH_VAR_BASE_DESC_LEN - IPsec encap/decap shared descriptor length
- * for the case of variable-length authentication
- * only data.
- * Note: Only for SoCs with SEC_ERA >= 3.
- *
- * Accounts only for the "base" commands and is intended to be used by upper
- * layers to determine whether keys can be inlined or not. To be used as first
- * parameter of rta_inline_query().
- */
-#define IPSEC_AUTH_VAR_BASE_DESC_LEN (27 * CAAM_CMD_SZ)
-
-/**
- * IPSEC_AUTH_VAR_AES_DEC_BASE_DESC_LEN - IPsec AES decap shared descriptor
- * length for variable-length authentication only
- * data.
- * Note: Only for SoCs with SEC_ERA >= 3.
- *
- * Accounts only for the "base" commands and is intended to be used by upper
- * layers to determine whether key can be inlined or not. To be used as first
- * parameter of rta_inline_query().
- */
-#define IPSEC_AUTH_VAR_AES_DEC_BASE_DESC_LEN \
- (IPSEC_AUTH_VAR_BASE_DESC_LEN + CAAM_CMD_SZ)
-
-/**
- * IPSEC_AUTH_BASE_DESC_LEN - IPsec encap/decap shared descriptor length
- *
- * Accounts only for the "base" commands and is intended to be used by upper
- * layers to determine whether key can be inlined or not. To be used as first
- * parameter of rta_inline_query().
- */
-#define IPSEC_AUTH_BASE_DESC_LEN (19 * CAAM_CMD_SZ)
-
-/**
- * IPSEC_AUTH_AES_DEC_BASE_DESC_LEN - IPsec AES decap shared descriptor length
- *
- * Accounts only for the "base" commands and is intended to be used by upper
- * layers to determine whether key can be inlined or not. To be used as first
- * parameter of rta_inline_query().
- */
-#define IPSEC_AUTH_AES_DEC_BASE_DESC_LEN (IPSEC_AUTH_BASE_DESC_LEN + \
- CAAM_CMD_SZ)
-
-/**
- * cnstr_shdsc_authenc - authenc-like descriptor
- * @descbuf: pointer to buffer used for descriptor construction
- * @ps: if 36/40bit addressing is desired, this parameter must be true
- * @swap: if true, perform descriptor byte swapping on a 4-byte boundary
- * @share: sharing type of shared descriptor
- * @cipherdata: pointer to block cipher transform definitions.
- * Valid algorithm values one of OP_ALG_ALGSEL_* {DES, 3DES, AES}
- * Valid modes for:
- * AES: OP_ALG_AAI_* {CBC, CTR}
- * DES, 3DES: OP_ALG_AAI_CBC
- * @authdata: pointer to authentication transform definitions.
- * Valid algorithm values - one of OP_ALG_ALGSEL_* {MD5, SHA1,
- * SHA224, SHA256, SHA384, SHA512}
- * Note: The key for authentication is supposed to be given as plain text.
- * Note: There's no support for keys longer than the block size of the
- * underlying hash function, according to the selected algorithm.
- *
- * @ivlen: length of the IV to be read from the input frame, before any data
- * to be processed
- *
- * @trunc_len: the length of the ICV to be written to the output frame. If 0,
- * then the corresponding length of the digest, according to the
- * selected algorithm shall be used.
- * @dir: Protocol direction, encapsulation or decapsulation (DIR_ENC/DIR_DEC)
- *
- * Note: Here's how the input frame needs to be formatted so that the processing
- * will be done correctly:
- * For encapsulation:
- * Input:
- * +----+----------------+-----------------------------------------------+
- * | IV | Auth-only head | Padded data to be auth & Enc | Auth-only tail |
- * +----+----------------+-----------------------------------------------+
- * Output:
- * +--------------------------------------+
- * | Authenticated & Encrypted data | ICV |
- * +--------------------------------+-----+
- *
- * For decapsulation:
- * Input:
- * +----+----------------+-----------------+----------------------+
- * | IV | Auth-only head | Auth & Enc data | Auth-only tail | ICV |
- * +----+----------------+-----------------+----------------------+
- * Output:
- * +----+---------------------------+
- * | Decrypted & authenticated data |
- * +----+---------------------------+
- *
- * Note: This descriptor can use per-packet commands, encoded as below in the
- * DPOVRD register:
- * 32 28 16 1
- * +------+------------------------------+
- * | 0x8 | auth_tail_len | auth_hdr_len |
- * +------+------------------------------+
- *
- * This mechanism is available only for SoCs having SEC ERA >= 3. In other
- * words, this will not work for P4080TO2
- *
- * Note: The descriptor does not add any kind of padding to the input data,
- * so the upper layer needs to ensure that the data is padded properly,
- * according to the selected cipher. Failure to do so will result in
- * the descriptor failing with a data-size error.
- *
- * Return: size of descriptor written in words or negative number on error
- */
-static inline int
-cnstr_shdsc_authenc(uint32_t *descbuf, bool ps, bool swap,
- enum rta_share_type share,
- struct alginfo *cipherdata,
- struct alginfo *authdata,
- uint16_t ivlen,
- uint8_t trunc_len, uint8_t dir)
-{
- struct program prg;
- struct program *p = &prg;
- const bool need_dk = (dir == DIR_DEC) &&
- (cipherdata->algtype == OP_ALG_ALGSEL_AES) &&
- (cipherdata->algmode == OP_ALG_AAI_CBC);
- int data_type;
-
- LABEL(keyjmp);
- LABEL(skipkeys);
- LABEL(proc_icv);
- LABEL(no_auth_tail);
- REFERENCE(pkeyjmp);
- REFERENCE(pskipkeys);
- REFERENCE(p_proc_icv);
- REFERENCE(p_no_auth_tail);
-
- PROGRAM_CNTXT_INIT(p, descbuf, 0);
-
- if (swap)
- PROGRAM_SET_BSWAP(p);
- if (ps)
- PROGRAM_SET_36BIT_ADDR(p);
-
- /*
- * Since we currently assume that key length is equal to hash digest
- * size, it's ok to truncate keylen value.
- */
- trunc_len = trunc_len && (trunc_len < authdata->keylen) ?
- trunc_len : (uint8_t)authdata->keylen;
-
- SHR_HDR(p, share, 1, SC);
-
- /* Collect the (auth_tail || auth_hdr) len from DPOVRD */
- MATHB(p, DPOVRD, ADD, 0x80000000, MATH2, 4, IMMED2);
-
- /* Get auth_hdr len in MATH0 */
- MATHB(p, MATH2, AND, 0xFFFF, MATH0, 4, IMMED2);
-
- /* Get auth_tail len in MATH2 */
- MATHB(p, MATH2, AND, 0xFFF0000, MATH2, 4, IMMED2);
- MATHI(p, MATH2, RSHIFT, 16, MATH2, 4, IMMED2);
-
- pkeyjmp = JUMP(p, keyjmp, LOCAL_JUMP, ALL_TRUE, SHRD);
-
- KEY(p, KEY2, authdata->key_enc_flags, authdata->key, authdata->keylen,
- INLINE_KEY(authdata));
-
- /* Insert Key */
- KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
- cipherdata->keylen, INLINE_KEY(cipherdata));
-
- /* Do operation */
- ALG_OPERATION(p, authdata->algtype, OP_ALG_AAI_HMAC,
- OP_ALG_AS_INITFINAL,
- dir == DIR_ENC ? ICV_CHECK_DISABLE : ICV_CHECK_ENABLE,
- dir);
-
- if (need_dk)
- ALG_OPERATION(p, OP_ALG_ALGSEL_AES, cipherdata->algmode,
- OP_ALG_AS_INITFINAL, ICV_CHECK_DISABLE, dir);
- pskipkeys = JUMP(p, skipkeys, LOCAL_JUMP, ALL_TRUE, 0);
-
- SET_LABEL(p, keyjmp);
-
- ALG_OPERATION(p, authdata->algtype, OP_ALG_AAI_HMAC_PRECOMP,
- OP_ALG_AS_INITFINAL,
- dir == DIR_ENC ? ICV_CHECK_DISABLE : ICV_CHECK_ENABLE,
- dir);
-
- if (need_dk) {
- ALG_OPERATION(p, OP_ALG_ALGSEL_AES, cipherdata->algmode |
- OP_ALG_AAI_DK, OP_ALG_AS_INITFINAL,
- ICV_CHECK_DISABLE, dir);
- SET_LABEL(p, skipkeys);
- } else {
- SET_LABEL(p, skipkeys);
- ALG_OPERATION(p, cipherdata->algtype, cipherdata->algmode,
- OP_ALG_AS_INITFINAL, ICV_CHECK_DISABLE, dir);
- }
-
- /* Read IV */
- if (cipherdata->algmode == OP_ALG_AAI_CTR)
- SEQLOAD(p, CONTEXT1, 16, ivlen, 0);
- else
- SEQLOAD(p, CONTEXT1, 0, ivlen, 0);
-
- /*
- * authenticate auth_hdr data
- */
- MATHB(p, MATH0, ADD, ZERO, VSEQINSZ, 4, 0);
- SEQFIFOLOAD(p, MSG2, 0, VLF);
-
- /*
- * Prepare the length of the data to be both encrypted/decrypted
- * and authenticated/checked
- */
- MATHB(p, SEQINSZ, SUB, MATH2, VSEQINSZ, 4, 0);
- if (dir == DIR_DEC) {
- MATHB(p, VSEQINSZ, SUB, trunc_len, VSEQINSZ, 4, IMMED2);
- data_type = MSGINSNOOP;
- } else {
- data_type = MSGOUTSNOOP;
- }
-
- MATHB(p, VSEQINSZ, ADD, ZERO, VSEQOUTSZ, 4, 0);
-
- /* Prepare for writing the output frame */
- SEQFIFOSTORE(p, MSG, 0, 0, VLF);
-
-
- /* Check if there is no auth-tail */
- MATHB(p, MATH2, ADD, ZERO, MATH2, 4, 0);
- p_no_auth_tail = JUMP(p, no_auth_tail, LOCAL_JUMP, ALL_TRUE, MATH_Z);
-
- /*
- * Read input plain/cipher text, encrypt/decrypt & auth & write
- * to output
- */
- SEQFIFOLOAD(p, data_type, 0, VLF | LAST1 | FLUSH1);
-
- /* Authenticate auth tail */
- MATHB(p, MATH2, ADD, ZERO, VSEQINSZ, 4, 0);
- SEQFIFOLOAD(p, MSG2, 0, VLF | LAST2);
-
- /* Jump to process icv */
- p_proc_icv = JUMP(p, proc_icv, LOCAL_JUMP, ALL_FALSE, MATH_Z);
-
- SET_LABEL(p, no_auth_tail);
-
- SEQFIFOLOAD(p, data_type, 0, VLF | LAST1 | LAST2 | FLUSH1);
-
- SET_LABEL(p, proc_icv);
-
- if (dir == DIR_ENC)
- /* Finally, write the ICV */
- SEQSTORE(p, CONTEXT2, 0, trunc_len, 0);
- else
- /* Read the ICV to check */
- SEQFIFOLOAD(p, ICV2, trunc_len, LAST2);
-
- PATCH_JUMP(p, pkeyjmp, keyjmp);
- PATCH_JUMP(p, pskipkeys, skipkeys);
- PATCH_JUMP(p, p_no_auth_tail, no_auth_tail);
- PATCH_JUMP(p, p_proc_icv, proc_icv);
- return PROGRAM_FINALIZE(p);
-}
-
-#endif /* __DESC_IPSEC_H__ */
+++ /dev/null
-/* SPDX-License-Identifier: BSD-3-Clause or GPL-2.0+
- * Copyright 2008-2013 Freescale Semiconductor, Inc.
- * Copyright 2019 NXP
- */
-
-#ifndef __DESC_PDCP_H__
-#define __DESC_PDCP_H__
-
-#include "hw/rta.h"
-#include "common.h"
-
-/**
- * DOC: PDCP Shared Descriptor Constructors
- *
- * Shared descriptors for PDCP protocol.
- */
-
-/**
- * PDCP_NULL_MAX_FRAME_LEN - The maximum frame frame length that is supported by
- * PDCP NULL protocol.
- */
-#define PDCP_NULL_MAX_FRAME_LEN 0x00002FFF
-
-/**
- * PDCP_MAC_I_LEN - The length of the MAC-I for PDCP protocol operation
- */
-#define PDCP_MAC_I_LEN 0x00000004
-
-/**
- * PDCP_MAX_FRAME_LEN_STATUS - The status returned in FD status/command field in
- * case the input frame is larger than
- * PDCP_NULL_MAX_FRAME_LEN.
- */
-#define PDCP_MAX_FRAME_LEN_STATUS 0xF1
-
-/**
- * PDCP_C_PLANE_SN_MASK - This mask is used in the PDCP descriptors for
- * extracting the sequence number (SN) from the PDCP
- * Control Plane header. For PDCP Control Plane, the SN
- * is constant (5 bits) as opposed to PDCP Data Plane
- * (7/12/15 bits).
- */
-#define PDCP_C_PLANE_SN_MASK 0x1F000000
-#define PDCP_C_PLANE_SN_MASK_BE 0x0000001F
-
-/**
- * PDCP_12BIT_SN_MASK - This mask is used in the PDCP descriptors for
- * extracting the sequence number (SN) from the
- * PDCP User Plane header.
- */
-#define PDCP_12BIT_SN_MASK 0xFF0F0000
-#define PDCP_12BIT_SN_MASK_BE 0x00000FFF
-
-/**
- * PDCP_U_PLANE_15BIT_SN_MASK - This mask is used in the PDCP descriptors for
- * extracting the sequence number (SN) from the
- * PDCP User Plane header. For PDCP Control Plane,
- * the SN is constant (5 bits) as opposed to PDCP
- * Data Plane (7/12/15 bits).
- */
-#define PDCP_U_PLANE_15BIT_SN_MASK 0xFF7F0000
-#define PDCP_U_PLANE_15BIT_SN_MASK_BE 0x00007FFF
-
-/**
- * PDCP_U_PLANE_18BIT_SN_MASK - This mask is used in the PDCP descriptors for
- * extracting the sequence number (SN) from the
- * PDCP User Plane header.
- */
-#define PDCP_U_PLANE_18BIT_SN_MASK 0xFFFF0300
-#define PDCP_U_PLANE_18BIT_SN_MASK_BE 0x0003FFFF
-
-/**
- * PDCP_BEARER_MASK - This mask is used masking out the bearer for PDCP
- * processing with SNOW f9 in LTE.
- *
- * The value on which this mask is applied is formatted as below:
- * Count-C (32 bit) | Bearer (5 bit) | Direction (1 bit) | 0 (26 bits)
- *
- * Applying this mask is done for creating the upper 64 bits of the IV needed
- * for SNOW f9.
- *
- * The lower 32 bits of the mask are used for masking the direction for AES
- * CMAC IV.
- */
-#define PDCP_BEARER_MASK 0x00000004FFFFFFFFull
-#define PDCP_BEARER_MASK_BE 0xFFFFFFFF04000000ull
-
-/**
- * PDCP_DIR_MASK - This mask is used masking out the direction for PDCP
- * processing with SNOW f9 in LTE.
- *
- * The value on which this mask is applied is formatted as below:
- * Bearer (5 bit) | Direction (1 bit) | 0 (26 bits)
- *
- * Applying this mask is done for creating the lower 32 bits of the IV needed
- * for SNOW f9.
- *
- * The upper 32 bits of the mask are used for masking the direction for AES
- * CMAC IV.
- */
-#define PDCP_DIR_MASK 0x00000000000000F8ull
-#define PDCP_DIR_MASK_BE 0xF800000000000000ull
-
-/**
- * PDCP_NULL_INT_MAC_I_VAL - The value of the PDCP PDU MAC-I in case NULL
- * integrity is used.
- */
-
-#define PDCP_NULL_INT_MAC_I_VAL 0x00000000
-
-/**
- * PDCP_NULL_INT_ICV_CHECK_FAILED_STATUS - The status used to report ICV check
- * failed in case of NULL integrity
- * Control Plane processing.
- */
-#define PDCP_NULL_INT_ICV_CHECK_FAILED_STATUS 0x0A
-/**
- * PDCP_DPOVRD_HFN_OV_EN - Value to be used in the FD status/cmd field to
- * indicate the HFN override mechanism is active for the
- * frame.
- */
-#define PDCP_DPOVRD_HFN_OV_EN 0x80000000
-
-/**
- * PDCP_P4080REV2_HFN_OV_BUFLEN - The length in bytes of the supplementary space
- * that must be provided by the user at the
- * beginning of the input frame buffer for
- * P4080 REV 2.
- *
- * The format of the frame buffer is the following:
- *
- * |<---PDCP_P4080REV2_HFN_OV_BUFLEN-->|
- * //===================================||============||==============\\
- * || PDCP_DPOVRD_HFN_OV_EN | HFN value || PDCP Header|| PDCP Payload ||
- * \\===================================||============||==============//
- *
- * If HFN override mechanism is not desired, then the MSB of the first 4 bytes
- * must be set to 0b.
- */
-#define PDCP_P4080REV2_HFN_OV_BUFLEN 4
-
-/**
- * enum cipher_type_pdcp - Type selectors for cipher types in PDCP protocol OP
- * instructions.
- * @PDCP_CIPHER_TYPE_NULL: NULL
- * @PDCP_CIPHER_TYPE_SNOW: SNOW F8
- * @PDCP_CIPHER_TYPE_AES: AES
- * @PDCP_CIPHER_TYPE_ZUC: ZUCE
- * @PDCP_CIPHER_TYPE_INVALID: invalid option
- */
-enum cipher_type_pdcp {
- PDCP_CIPHER_TYPE_NULL,
- PDCP_CIPHER_TYPE_SNOW,
- PDCP_CIPHER_TYPE_AES,
- PDCP_CIPHER_TYPE_ZUC,
- PDCP_CIPHER_TYPE_INVALID
-};
-
-/**
- * enum auth_type_pdcp - Type selectors for integrity types in PDCP protocol OP
- * instructions.
- * @PDCP_AUTH_TYPE_NULL: NULL
- * @PDCP_AUTH_TYPE_SNOW: SNOW F9
- * @PDCP_AUTH_TYPE_AES: AES CMAC
- * @PDCP_AUTH_TYPE_ZUC: ZUCA
- * @PDCP_AUTH_TYPE_INVALID: invalid option
- */
-enum auth_type_pdcp {
- PDCP_AUTH_TYPE_NULL,
- PDCP_AUTH_TYPE_SNOW,
- PDCP_AUTH_TYPE_AES,
- PDCP_AUTH_TYPE_ZUC,
- PDCP_AUTH_TYPE_INVALID
-};
-
-/**
- * enum pdcp_dir - Type selectors for direction for PDCP protocol
- * @PDCP_DIR_UPLINK: uplink direction
- * @PDCP_DIR_DOWNLINK: downlink direction
- * @PDCP_DIR_INVALID: invalid option
- */
-enum pdcp_dir {
- PDCP_DIR_UPLINK = 0,
- PDCP_DIR_DOWNLINK = 1,
- PDCP_DIR_INVALID
-};
-
-/**
- * enum pdcp_plane - PDCP domain selectors
- * @PDCP_CONTROL_PLANE: Control Plane
- * @PDCP_DATA_PLANE: Data Plane
- * @PDCP_SHORT_MAC: Short MAC
- */
-enum pdcp_plane {
- PDCP_CONTROL_PLANE,
- PDCP_DATA_PLANE,
- PDCP_SHORT_MAC
-};
-
-/**
- * enum pdcp_sn_size - Sequence Number Size selectors for PDCP protocol
- * @PDCP_SN_SIZE_5: 5bit sequence number
- * @PDCP_SN_SIZE_7: 7bit sequence number
- * @PDCP_SN_SIZE_12: 12bit sequence number
- * @PDCP_SN_SIZE_15: 15bit sequence number
- * @PDCP_SN_SIZE_18: 18bit sequence number
- */
-enum pdcp_sn_size {
- PDCP_SN_SIZE_5 = 5,
- PDCP_SN_SIZE_7 = 7,
- PDCP_SN_SIZE_12 = 12,
- PDCP_SN_SIZE_15 = 15,
- PDCP_SN_SIZE_18 = 18
-};
-
-/*
- * PDCP Control Plane Protocol Data Blocks
- */
-#define PDCP_C_PLANE_PDB_HFN_SHIFT 5
-#define PDCP_C_PLANE_PDB_BEARER_SHIFT 27
-#define PDCP_C_PLANE_PDB_DIR_SHIFT 26
-#define PDCP_C_PLANE_PDB_HFN_THR_SHIFT 5
-
-#define PDCP_U_PLANE_PDB_OPT_SHORT_SN 0x2
-#define PDCP_U_PLANE_PDB_OPT_15B_SN 0x4
-#define PDCP_U_PLANE_PDB_OPT_18B_SN 0x6
-#define PDCP_U_PLANE_PDB_SHORT_SN_HFN_SHIFT 7
-#define PDCP_U_PLANE_PDB_LONG_SN_HFN_SHIFT 12
-#define PDCP_U_PLANE_PDB_15BIT_SN_HFN_SHIFT 15
-#define PDCP_U_PLANE_PDB_18BIT_SN_HFN_SHIFT 18
-#define PDCP_U_PLANE_PDB_BEARER_SHIFT 27
-#define PDCP_U_PLANE_PDB_DIR_SHIFT 26
-#define PDCP_U_PLANE_PDB_SHORT_SN_HFN_THR_SHIFT 7
-#define PDCP_U_PLANE_PDB_LONG_SN_HFN_THR_SHIFT 12
-#define PDCP_U_PLANE_PDB_15BIT_SN_HFN_THR_SHIFT 15
-#define PDCP_U_PLANE_PDB_18BIT_SN_HFN_THR_SHIFT 18
-
-struct pdcp_pdb {
- union {
- uint32_t opt;
- uint32_t rsvd;
- } opt_res;
- uint32_t hfn_res; /* HyperFrame number,(27, 25 or 21 bits),
- * left aligned & right-padded with zeros.
- */
- uint32_t bearer_dir_res;/* Bearer(5 bits), packet direction (1 bit),
- * left aligned & right-padded with zeros.
- */
- uint32_t hfn_thr_res; /* HyperFrame number threshold (27, 25 or 21
- * bits), left aligned & right-padded with
- * zeros.
- */
-};
-
-/*
- * PDCP internal PDB types
- */
-enum pdb_type_e {
- PDCP_PDB_TYPE_NO_PDB,
- PDCP_PDB_TYPE_FULL_PDB,
- PDCP_PDB_TYPE_REDUCED_PDB,
- PDCP_PDB_TYPE_INVALID
-};
-
-/*
- * Function for appending the portion of a PDCP Control Plane shared descriptor
- * which performs NULL encryption and integrity (i.e. copies the input frame
- * to the output frame, appending 32 bits of zeros at the end (MAC-I for
- * NULL integrity).
- */
-static inline int
-pdcp_insert_cplane_null_op(struct program *p,
- bool swap __maybe_unused,
- struct alginfo *cipherdata __maybe_unused,
- struct alginfo *authdata __maybe_unused,
- unsigned int dir,
- enum pdcp_sn_size sn_size __maybe_unused,
- unsigned char era_2_sw_hfn_ovrd __maybe_unused)
-{
- LABEL(local_offset);
- REFERENCE(move_cmd_read_descbuf);
- REFERENCE(move_cmd_write_descbuf);
-
- if (rta_sec_era > RTA_SEC_ERA_2) {
- MATHB(p, SEQINSZ, ADD, ZERO, VSEQINSZ, 4, 0);
- if (dir == OP_TYPE_ENCAP_PROTOCOL)
- MATHB(p, SEQINSZ, ADD, PDCP_MAC_I_LEN, VSEQOUTSZ, 4,
- IMMED2);
- else
- MATHB(p, SEQINSZ, SUB, PDCP_MAC_I_LEN, VSEQOUTSZ, 4,
- IMMED2);
- } else {
- MATHB(p, SEQINSZ, ADD, ONE, VSEQINSZ, 4, 0);
- MATHB(p, VSEQINSZ, SUB, ONE, VSEQINSZ, 4, 0);
-
- if (dir == OP_TYPE_ENCAP_PROTOCOL) {
- MATHB(p, SEQINSZ, ADD, PDCP_MAC_I_LEN, VSEQOUTSZ, 4,
- IMMED2);
- MATHB(p, VSEQINSZ, SUB, ONE, MATH0, 4, 0);
- } else {
- MATHB(p, VSEQINSZ, SUB, PDCP_MAC_I_LEN, VSEQINSZ, 4,
- IMMED2);
- MATHB(p, SEQINSZ, SUB, PDCP_MAC_I_LEN, VSEQOUTSZ, 4,
- IMMED2);
- MATHB(p, VSEQOUTSZ, SUB, ONE, MATH0, 4, 0);
- }
-
- MATHB(p, MATH0, ADD, ONE, MATH0, 4, 0);
-
- /*
- * Since MOVELEN is available only starting with
- * SEC ERA 3, use poor man's MOVELEN: create a MOVE
- * command dynamically by writing the length from M1 by
- * OR-ing the command in the M1 register and MOVE the
- * result into the descriptor buffer. Care must be taken
- * wrt. the location of the command because of SEC
- * pipelining. The actual MOVEs are written at the end
- * of the descriptor due to calculations needed on the
- * offset in the descriptor for the MOVE command.
- */
- move_cmd_read_descbuf = MOVE(p, DESCBUF, 0, MATH0, 0, 6,
- IMMED);
- move_cmd_write_descbuf = MOVE(p, MATH0, 0, DESCBUF, 0, 8,
- WAITCOMP | IMMED);
- }
- MATHB(p, VSEQINSZ, SUB, PDCP_NULL_MAX_FRAME_LEN, NONE, 4,
- IMMED2);
- JUMP(p, PDCP_MAX_FRAME_LEN_STATUS, HALT_STATUS, ALL_FALSE, MATH_N);
-
- if (rta_sec_era > RTA_SEC_ERA_2) {
- if (dir == OP_TYPE_ENCAP_PROTOCOL)
- MATHB(p, VSEQINSZ, ADD, ZERO, MATH0, 4, 0);
- else
- MATHB(p, VSEQOUTSZ, ADD, ZERO, MATH0, 4, 0);
- }
- SEQFIFOSTORE(p, MSG, 0, 0, VLF);
- SEQFIFOLOAD(p, MSG1, 0, VLF | LAST1 | FLUSH1);
-
- if (rta_sec_era > RTA_SEC_ERA_2) {
- MOVE(p, AB1, 0, OFIFO, 0, MATH0, 0);
- } else {
- SET_LABEL(p, local_offset);
-
- /* Shut off automatic Info FIFO entries */
- LOAD(p, 0, DCTRL, LDOFF_DISABLE_AUTO_NFIFO, 0, IMMED);
- /* Placeholder for MOVE command with length from M1 register */
- MOVE(p, IFIFOAB1, 0, OFIFO, 0, 0, IMMED);
- /* Enable automatic Info FIFO entries */
- LOAD(p, 0, DCTRL, LDOFF_ENABLE_AUTO_NFIFO, 0, IMMED);
- }
-
- if (dir == OP_TYPE_ENCAP_PROTOCOL) {
- MATHB(p, MATH1, XOR, MATH1, MATH0, 8, 0);
- MOVE(p, MATH0, 0, OFIFO, 0, 4, IMMED);
- }
-
- if (rta_sec_era < RTA_SEC_ERA_3) {
- PATCH_MOVE(p, move_cmd_read_descbuf, local_offset);
- PATCH_MOVE(p, move_cmd_write_descbuf, local_offset);
- }
-
- return 0;
-}
-
-static inline int
-insert_copy_frame_op(struct program *p,
- struct alginfo *cipherdata __maybe_unused,
- unsigned int dir __maybe_unused)
-{
- LABEL(local_offset);
- REFERENCE(move_cmd_read_descbuf);
- REFERENCE(move_cmd_write_descbuf);
-
- if (rta_sec_era > RTA_SEC_ERA_2) {
- MATHB(p, SEQINSZ, ADD, ZERO, VSEQINSZ, 4, 0);
- MATHB(p, SEQINSZ, ADD, ZERO, VSEQOUTSZ, 4, 0);
- } else {
- MATHB(p, SEQINSZ, ADD, ONE, VSEQINSZ, 4, 0);
- MATHB(p, VSEQINSZ, SUB, ONE, VSEQINSZ, 4, 0);
- MATHB(p, SEQINSZ, ADD, ONE, VSEQOUTSZ, 4, 0);
- MATHB(p, VSEQOUTSZ, SUB, ONE, VSEQOUTSZ, 4, 0);
- MATHB(p, VSEQINSZ, SUB, ONE, MATH0, 4, 0);
- MATHB(p, MATH0, ADD, ONE, MATH0, 4, 0);
-
- /*
- * Since MOVELEN is available only starting with
- * SEC ERA 3, use poor man's MOVELEN: create a MOVE
- * command dynamically by writing the length from M1 by
- * OR-ing the command in the M1 register and MOVE the
- * result into the descriptor buffer. Care must be taken
- * wrt. the location of the command because of SEC
- * pipelining. The actual MOVEs are written at the end
- * of the descriptor due to calculations needed on the
- * offset in the descriptor for the MOVE command.
- */
- move_cmd_read_descbuf = MOVE(p, DESCBUF, 0, MATH0, 0, 6,
- IMMED);
- move_cmd_write_descbuf = MOVE(p, MATH0, 0, DESCBUF, 0, 8,
- WAITCOMP | IMMED);
- }
- MATHB(p, SEQINSZ, SUB, PDCP_NULL_MAX_FRAME_LEN, NONE, 4,
- IFB | IMMED2);
- JUMP(p, PDCP_MAX_FRAME_LEN_STATUS, HALT_STATUS, ALL_FALSE, MATH_N);
-
- if (rta_sec_era > RTA_SEC_ERA_2)
- MATHB(p, VSEQINSZ, ADD, ZERO, MATH0, 4, 0);
-
- SEQFIFOLOAD(p, MSG1, 0, VLF | LAST1 | FLUSH1);
- if (rta_sec_era > RTA_SEC_ERA_2) {
- MOVE(p, AB1, 0, OFIFO, 0, MATH0, 0);
- } else {
- SET_LABEL(p, local_offset);
-
- /* Shut off automatic Info FIFO entries */
- LOAD(p, 0, DCTRL, LDOFF_DISABLE_AUTO_NFIFO, 0, IMMED);
-
- /* Placeholder for MOVE command with length from M0 register */
- MOVE(p, IFIFOAB1, 0, OFIFO, 0, 0, IMMED);
-
- /* Enable automatic Info FIFO entries */
- LOAD(p, 0, DCTRL, LDOFF_ENABLE_AUTO_NFIFO, 0, IMMED);
- }
-
- SEQFIFOSTORE(p, MSG, 0, 0, VLF);
-
- if (rta_sec_era < RTA_SEC_ERA_3) {
- PATCH_MOVE(p, move_cmd_read_descbuf, local_offset);
- PATCH_MOVE(p, move_cmd_write_descbuf, local_offset);
- }
- return 0;
-}
-
-static inline int
-pdcp_insert_cplane_int_only_op(struct program *p,
- bool swap __maybe_unused,
- struct alginfo *cipherdata __maybe_unused,
- struct alginfo *authdata, unsigned int dir,
- enum pdcp_sn_size sn_size,
- unsigned char era_2_sw_hfn_ovrd)
-{
- uint32_t offset = 0, length = 0, sn_mask = 0;
-
- /* 12 bit SN is only supported for protocol offload case */
- if (rta_sec_era >= RTA_SEC_ERA_8 && sn_size == PDCP_SN_SIZE_12) {
- KEY(p, KEY2, authdata->key_enc_flags, authdata->key,
- authdata->keylen, INLINE_KEY(authdata));
-
- PROTOCOL(p, dir, OP_PCLID_LTE_PDCP_USER_RN,
- (uint16_t)authdata->algtype);
- return 0;
- }
-
- /* Non-proto is supported only for 5bit cplane and 18bit uplane */
- switch (sn_size) {
- case PDCP_SN_SIZE_5:
- offset = 7;
- length = 1;
- sn_mask = (swap == false) ? PDCP_C_PLANE_SN_MASK :
- PDCP_C_PLANE_SN_MASK_BE;
- break;
- case PDCP_SN_SIZE_18:
- offset = 5;
- length = 3;
- sn_mask = (swap == false) ? PDCP_U_PLANE_18BIT_SN_MASK :
- PDCP_U_PLANE_18BIT_SN_MASK_BE;
- break;
- case PDCP_SN_SIZE_7:
- case PDCP_SN_SIZE_12:
- case PDCP_SN_SIZE_15:
- pr_err("Invalid sn_size for %s\n", __func__);
- return -ENOTSUP;
-
- }
- LABEL(local_offset);
- REFERENCE(move_cmd_read_descbuf);
- REFERENCE(move_cmd_write_descbuf);
-
- switch (authdata->algtype) {
- case PDCP_AUTH_TYPE_SNOW:
- /* Insert Auth Key */
- KEY(p, KEY2, authdata->key_enc_flags, authdata->key,
- authdata->keylen, INLINE_KEY(authdata));
- SEQLOAD(p, MATH0, offset, length, 0);
- JUMP(p, 1, LOCAL_JUMP, ALL_TRUE, CALM);
-
- if (rta_sec_era > RTA_SEC_ERA_2 ||
- (rta_sec_era == RTA_SEC_ERA_2 &&
- era_2_sw_hfn_ovrd == 0)) {
- SEQINPTR(p, 0, length, RTO);
- } else {
- SEQINPTR(p, 0, 5, RTO);
- SEQFIFOLOAD(p, SKIP, 4, 0);
- }
-
- if (swap == false) {
- MATHB(p, MATH0, AND, sn_mask, MATH1, 8,
- IFB | IMMED2);
- MATHB(p, MATH1, SHLD, MATH1, MATH1, 8, 0);
-
- MOVEB(p, DESCBUF, 8, MATH2, 0, 8, WAITCOMP | IMMED);
-
- MATHB(p, MATH2, AND, PDCP_BEARER_MASK, MATH2, 8,
- IMMED2);
- MOVEB(p, DESCBUF, 0x0C, MATH3, 0, 4, WAITCOMP | IMMED);
- MATHB(p, MATH3, AND, PDCP_DIR_MASK, MATH3, 8, IMMED2);
- MATHB(p, MATH1, OR, MATH2, MATH2, 8, 0);
- MOVEB(p, MATH2, 0, CONTEXT2, 0, 0x0C, WAITCOMP | IMMED);
- } else {
- MATHB(p, MATH0, AND, sn_mask, MATH1, 8,
- IFB | IMMED2);
- MATHB(p, MATH1, SHLD, MATH1, MATH1, 8, 0);
-
- MOVE(p, DESCBUF, 8, MATH2, 0, 8, WAITCOMP | IMMED);
- MATHB(p, MATH2, AND, PDCP_BEARER_MASK_BE, MATH2, 8,
- IMMED2);
-
- MOVE(p, DESCBUF, 0x0C, MATH3, 0, 4, WAITCOMP | IMMED);
- MATHB(p, MATH3, AND, PDCP_DIR_MASK_BE, MATH3, 8,
- IMMED2);
- MATHB(p, MATH1, OR, MATH2, MATH2, 8, 0);
- MOVE(p, MATH2, 0, CONTEXT2, 0, 0x0C, WAITCOMP | IMMED);
- }
-
- if (dir == OP_TYPE_DECAP_PROTOCOL) {
- MATHB(p, SEQINSZ, SUB, PDCP_MAC_I_LEN, MATH1, 4,
- IMMED2);
- } else {
- if (rta_sec_era > RTA_SEC_ERA_2) {
- MATHB(p, SEQINSZ, SUB, ZERO, MATH1, 4,
- 0);
- } else {
- MATHB(p, SEQINSZ, ADD, ONE, MATH1, 4,
- 0);
- MATHB(p, MATH1, SUB, ONE, MATH1, 4,
- 0);
- }
- }
-
- if (rta_sec_era > RTA_SEC_ERA_2) {
- MATHB(p, MATH1, SUB, ZERO, VSEQINSZ, 4, 0);
- MATHB(p, MATH1, SUB, ZERO, VSEQOUTSZ, 4, 0);
- } else {
- MATHB(p, ZERO, ADD, MATH1, VSEQINSZ, 4, 0);
- MATHB(p, ZERO, ADD, MATH1, VSEQOUTSZ, 4, 0);
-
- /*
- * Since MOVELEN is available only starting with
- * SEC ERA 3, use poor man's MOVELEN: create a MOVE
- * command dynamically by writing the length from M1 by
- * OR-ing the command in the M1 register and MOVE the
- * result into the descriptor buffer. Care must be taken
- * wrt. the location of the command because of SEC
- * pipelining. The actual MOVEs are written at the end
- * of the descriptor due to calculations needed on the
- * offset in the descriptor for the MOVE command.
- */
- move_cmd_read_descbuf = MOVE(p, DESCBUF, 0, MATH1, 0, 6,
- IMMED);
- move_cmd_write_descbuf = MOVE(p, MATH1, 0, DESCBUF, 0,
- 8, WAITCOMP | IMMED);
- }
-
- SEQFIFOSTORE(p, MSG, 0, 0, VLF);
- ALG_OPERATION(p, OP_ALG_ALGSEL_SNOW_F9, OP_ALG_AAI_F9,
- OP_ALG_AS_INITFINAL,
- dir == OP_TYPE_ENCAP_PROTOCOL ?
- ICV_CHECK_DISABLE : ICV_CHECK_ENABLE,
- DIR_ENC);
-
- if (rta_sec_era > RTA_SEC_ERA_2) {
- SEQFIFOLOAD(p, MSGINSNOOP, 0,
- VLF | LAST1 | LAST2 | FLUSH1);
- MOVE(p, AB1, 0, OFIFO, 0, MATH1, 0);
- } else {
- SEQFIFOLOAD(p, MSGINSNOOP, 0,
- VLF | LAST1 | LAST2 | FLUSH1);
- SET_LABEL(p, local_offset);
-
- /* Shut off automatic Info FIFO entries */
- LOAD(p, 0, DCTRL, LDOFF_DISABLE_AUTO_NFIFO, 0, IMMED);
- /*
- * Placeholder for MOVE command with length from M1
- * register
- */
- MOVE(p, IFIFOAB1, 0, OFIFO, 0, 0, IMMED);
- /* Enable automatic Info FIFO entries */
- LOAD(p, 0, DCTRL, LDOFF_ENABLE_AUTO_NFIFO, 0, IMMED);
- }
-
- if (dir == OP_TYPE_DECAP_PROTOCOL)
- SEQFIFOLOAD(p, ICV2, 4, LAST2);
- else
- SEQSTORE(p, CONTEXT2, 0, 4, 0);
-
- break;
-
- case PDCP_AUTH_TYPE_AES:
- /* Insert Auth Key */
- KEY(p, KEY1, authdata->key_enc_flags, authdata->key,
- authdata->keylen, INLINE_KEY(authdata));
- SEQLOAD(p, MATH0, offset, length, 0);
- JUMP(p, 1, LOCAL_JUMP, ALL_TRUE, CALM);
- if (rta_sec_era > RTA_SEC_ERA_2 ||
- (rta_sec_era == RTA_SEC_ERA_2 &&
- era_2_sw_hfn_ovrd == 0)) {
- SEQINPTR(p, 0, length, RTO);
- } else {
- SEQINPTR(p, 0, 5, RTO);
- SEQFIFOLOAD(p, SKIP, 4, 0);
- }
-
- if (swap == false) {
- MATHB(p, MATH0, AND, sn_mask, MATH1, 8,
- IFB | IMMED2);
- MATHB(p, MATH1, SHLD, MATH1, MATH1, 8, 0);
-
- MOVEB(p, DESCBUF, 8, MATH2, 0, 8, WAITCOMP | IMMED);
- MATHB(p, MATH1, OR, MATH2, MATH2, 8, 0);
- MOVEB(p, MATH2, 0, IFIFOAB1, 0, 8, IMMED);
- } else {
- MATHB(p, MATH0, AND, sn_mask, MATH1, 8,
- IFB | IMMED2);
- MATHB(p, MATH1, SHLD, MATH1, MATH1, 8, 0);
-
- MOVE(p, DESCBUF, 8, MATH2, 0, 8, WAITCOMP | IMMED);
- MATHB(p, MATH1, OR, MATH2, MATH2, 8, 0);
- MOVE(p, MATH2, 0, IFIFOAB1, 0, 8, IMMED);
- }
-
- if (dir == OP_TYPE_DECAP_PROTOCOL) {
- MATHB(p, SEQINSZ, SUB, PDCP_MAC_I_LEN, MATH1, 4,
- IMMED2);
- } else {
- if (rta_sec_era > RTA_SEC_ERA_2) {
- MATHB(p, SEQINSZ, SUB, ZERO, MATH1, 4,
- 0);
- } else {
- MATHB(p, SEQINSZ, ADD, ONE, MATH1, 4,
- 0);
- MATHB(p, MATH1, SUB, ONE, MATH1, 4,
- 0);
- }
- }
-
- if (rta_sec_era > RTA_SEC_ERA_2) {
- MATHB(p, MATH1, SUB, ZERO, VSEQINSZ, 4, 0);
- MATHB(p, MATH1, SUB, ZERO, VSEQOUTSZ, 4, 0);
- } else {
- MATHB(p, ZERO, ADD, MATH1, VSEQINSZ, 4, 0);
- MATHB(p, ZERO, ADD, MATH1, VSEQOUTSZ, 4, 0);
-
- /*
- * Since MOVELEN is available only starting with
- * SEC ERA 3, use poor man's MOVELEN: create a MOVE
- * command dynamically by writing the length from M1 by
- * OR-ing the command in the M1 register and MOVE the
- * result into the descriptor buffer. Care must be taken
- * wrt. the location of the command because of SEC
- * pipelining. The actual MOVEs are written at the end
- * of the descriptor due to calculations needed on the
- * offset in the descriptor for the MOVE command.
- */
- move_cmd_read_descbuf = MOVE(p, DESCBUF, 0, MATH1, 0, 6,
- IMMED);
- move_cmd_write_descbuf = MOVE(p, MATH1, 0, DESCBUF, 0,
- 8, WAITCOMP | IMMED);
- }
- SEQFIFOSTORE(p, MSG, 0, 0, VLF);
- ALG_OPERATION(p, OP_ALG_ALGSEL_AES,
- OP_ALG_AAI_CMAC,
- OP_ALG_AS_INITFINAL,
- dir == OP_TYPE_ENCAP_PROTOCOL ?
- ICV_CHECK_DISABLE : ICV_CHECK_ENABLE,
- DIR_ENC);
-
- if (rta_sec_era > RTA_SEC_ERA_2) {
- MOVE(p, AB2, 0, OFIFO, 0, MATH1, 0);
- SEQFIFOLOAD(p, MSGINSNOOP, 0,
- VLF | LAST1 | LAST2 | FLUSH1);
- } else {
- SEQFIFOLOAD(p, MSGINSNOOP, 0,
- VLF | LAST1 | LAST2 | FLUSH1);
- SET_LABEL(p, local_offset);
-
- /* Shut off automatic Info FIFO entries */
- LOAD(p, 0, DCTRL, LDOFF_DISABLE_AUTO_NFIFO, 0, IMMED);
-
- /*
- * Placeholder for MOVE command with length from
- * M1 register
- */
- MOVE(p, IFIFOAB2, 0, OFIFO, 0, 0, IMMED);
-
- /* Enable automatic Info FIFO entries */
- LOAD(p, 0, DCTRL, LDOFF_ENABLE_AUTO_NFIFO, 0, IMMED);
- }
-
- if (dir == OP_TYPE_DECAP_PROTOCOL)
- SEQFIFOLOAD(p, ICV1, 4, LAST1 | FLUSH1);
- else
- SEQSTORE(p, CONTEXT1, 0, 4, 0);
-
- break;
-
- case PDCP_AUTH_TYPE_ZUC:
- if (rta_sec_era < RTA_SEC_ERA_5) {
- pr_err("Invalid era for selected algorithm\n");
- return -ENOTSUP;
- }
- /* Insert Auth Key */
- KEY(p, KEY2, authdata->key_enc_flags, authdata->key,
- authdata->keylen, INLINE_KEY(authdata));
- SEQLOAD(p, MATH0, offset, length, 0);
- JUMP(p, 1, LOCAL_JUMP, ALL_TRUE, CALM);
- SEQINPTR(p, 0, length, RTO);
- if (swap == false) {
- MATHB(p, MATH0, AND, sn_mask, MATH1, 8,
- IFB | IMMED2);
- MATHB(p, MATH1, SHLD, MATH1, MATH1, 8, 0);
-
- MOVEB(p, DESCBUF, 8, MATH2, 0, 8, WAITCOMP | IMMED);
- MATHB(p, MATH1, OR, MATH2, MATH2, 8, 0);
- MOVEB(p, MATH2, 0, CONTEXT2, 0, 8, IMMED);
-
- } else {
- MATHB(p, MATH0, AND, sn_mask, MATH1, 8,
- IFB | IMMED2);
- MATHB(p, MATH1, SHLD, MATH1, MATH1, 8, 0);
-
- MOVE(p, DESCBUF, 8, MATH2, 0, 8, WAITCOMP | IMMED);
- MATHB(p, MATH1, OR, MATH2, MATH2, 8, 0);
- MOVE(p, MATH2, 0, CONTEXT2, 0, 8, IMMED);
- }
- if (dir == OP_TYPE_DECAP_PROTOCOL)
- MATHB(p, SEQINSZ, SUB, PDCP_MAC_I_LEN, MATH1, 4,
- IMMED2);
- else
- MATHB(p, SEQINSZ, SUB, ZERO, MATH1, 4, 0);
-
- MATHB(p, MATH1, SUB, ZERO, VSEQINSZ, 4, 0);
- MATHB(p, MATH1, SUB, ZERO, VSEQOUTSZ, 4, 0);
- SEQFIFOSTORE(p, MSG, 0, 0, VLF);
- ALG_OPERATION(p, OP_ALG_ALGSEL_ZUCA,
- OP_ALG_AAI_F9,
- OP_ALG_AS_INITFINAL,
- dir == OP_TYPE_ENCAP_PROTOCOL ?
- ICV_CHECK_DISABLE : ICV_CHECK_ENABLE,
- DIR_ENC);
- SEQFIFOLOAD(p, MSGINSNOOP, 0, VLF | LAST1 | LAST2 | FLUSH1);
- MOVE(p, AB1, 0, OFIFO, 0, MATH1, 0);
-
- if (dir == OP_TYPE_DECAP_PROTOCOL)
- SEQFIFOLOAD(p, ICV2, 4, LAST2);
- else
- SEQSTORE(p, CONTEXT2, 0, 4, 0);
-
- break;
-
- default:
- pr_err("%s: Invalid integrity algorithm selected: %d\n",
- "pdcp_insert_cplane_int_only_op", authdata->algtype);
- return -EINVAL;
- }
-
- if (rta_sec_era < RTA_SEC_ERA_3) {
- PATCH_MOVE(p, move_cmd_read_descbuf, local_offset);
- PATCH_MOVE(p, move_cmd_write_descbuf, local_offset);
- }
-
- return 0;
-}
-
-static inline int
-pdcp_insert_cplane_enc_only_op(struct program *p,
- bool swap __maybe_unused,
- struct alginfo *cipherdata,
- struct alginfo *authdata __maybe_unused,
- unsigned int dir,
- enum pdcp_sn_size sn_size,
- unsigned char era_2_sw_hfn_ovrd __maybe_unused)
-{
- uint32_t offset = 0, length = 0, sn_mask = 0;
- /* Insert Cipher Key */
- KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
- cipherdata->keylen, INLINE_KEY(cipherdata));
-
- if ((rta_sec_era >= RTA_SEC_ERA_8 && sn_size != PDCP_SN_SIZE_18 &&
- !(rta_sec_era == RTA_SEC_ERA_8 &&
- authdata->algtype == 0))
- || (rta_sec_era == RTA_SEC_ERA_10)) {
- if (sn_size == PDCP_SN_SIZE_5)
- PROTOCOL(p, dir, OP_PCLID_LTE_PDCP_CTRL_MIXED,
- (uint16_t)cipherdata->algtype << 8);
- else
- PROTOCOL(p, dir, OP_PCLID_LTE_PDCP_USER_RN,
- (uint16_t)cipherdata->algtype << 8);
- return 0;
- }
- /* Non-proto is supported only for 5bit cplane and 18bit uplane */
- switch (sn_size) {
- case PDCP_SN_SIZE_5:
- offset = 7;
- length = 1;
- sn_mask = (swap == false) ? PDCP_C_PLANE_SN_MASK :
- PDCP_C_PLANE_SN_MASK_BE;
- break;
- case PDCP_SN_SIZE_18:
- offset = 5;
- length = 3;
- sn_mask = (swap == false) ? PDCP_U_PLANE_18BIT_SN_MASK :
- PDCP_U_PLANE_18BIT_SN_MASK_BE;
- break;
- case PDCP_SN_SIZE_12:
- offset = 6;
- length = 2;
- sn_mask = (swap == false) ? PDCP_12BIT_SN_MASK :
- PDCP_12BIT_SN_MASK_BE;
- break;
- case PDCP_SN_SIZE_7:
- case PDCP_SN_SIZE_15:
- pr_err("Invalid sn_size for %s\n", __func__);
- return -ENOTSUP;
- }
-
- SEQLOAD(p, MATH0, offset, length, 0);
- JUMP(p, 1, LOCAL_JUMP, ALL_TRUE, CALM);
- MATHB(p, MATH0, AND, sn_mask, MATH1, 8, IFB | IMMED2);
- SEQSTORE(p, MATH0, offset, length, 0);
- MATHB(p, MATH1, SHLD, MATH1, MATH1, 8, 0);
- MOVEB(p, DESCBUF, 8, MATH2, 0, 8, WAITCOMP | IMMED);
- MATHB(p, MATH1, OR, MATH2, MATH2, 8, 0);
-
- switch (cipherdata->algtype) {
- case PDCP_CIPHER_TYPE_SNOW:
- MOVEB(p, MATH2, 0, CONTEXT1, 0, 8, WAITCOMP | IMMED);
-
- if (rta_sec_era > RTA_SEC_ERA_2) {
- MATHB(p, SEQINSZ, SUB, ZERO, VSEQINSZ, 4, 0);
- } else {
- MATHB(p, SEQINSZ, SUB, ONE, MATH1, 4, 0);
- MATHB(p, MATH1, ADD, ONE, VSEQINSZ, 4, 0);
- }
-
- if (dir == OP_TYPE_ENCAP_PROTOCOL)
- MATHB(p, SEQINSZ, ADD, PDCP_MAC_I_LEN, VSEQOUTSZ, 4,
- IMMED2);
- else
- MATHB(p, SEQINSZ, SUB, PDCP_MAC_I_LEN, VSEQOUTSZ, 4,
- IMMED2);
- SEQFIFOSTORE(p, MSG, 0, 0, VLF | CONT);
- ALG_OPERATION(p, OP_ALG_ALGSEL_SNOW_F8,
- OP_ALG_AAI_F8,
- OP_ALG_AS_INITFINAL, ICV_CHECK_DISABLE,
- dir == OP_TYPE_ENCAP_PROTOCOL ?
- DIR_ENC : DIR_DEC);
- break;
-
- case PDCP_CIPHER_TYPE_AES:
- MOVEB(p, MATH2, 0, CONTEXT1, 0x10, 0x10, WAITCOMP | IMMED);
-
- if (rta_sec_era > RTA_SEC_ERA_2) {
- MATHB(p, SEQINSZ, SUB, ZERO, VSEQINSZ, 4, 0);
- } else {
- MATHB(p, SEQINSZ, SUB, ONE, MATH1, 4, 0);
- MATHB(p, MATH1, ADD, ONE, VSEQINSZ, 4, 0);
- }
-
- if (dir == OP_TYPE_ENCAP_PROTOCOL)
- MATHB(p, SEQINSZ, ADD, PDCP_MAC_I_LEN, VSEQOUTSZ, 4,
- IMMED2);
- else
- MATHB(p, SEQINSZ, SUB, PDCP_MAC_I_LEN, VSEQOUTSZ, 4,
- IMMED2);
-
- SEQFIFOSTORE(p, MSG, 0, 0, VLF | CONT);
- ALG_OPERATION(p, OP_ALG_ALGSEL_AES,
- OP_ALG_AAI_CTR,
- OP_ALG_AS_INITFINAL,
- ICV_CHECK_DISABLE,
- dir == OP_TYPE_ENCAP_PROTOCOL ?
- DIR_ENC : DIR_DEC);
- break;
-
- case PDCP_CIPHER_TYPE_ZUC:
- if (rta_sec_era < RTA_SEC_ERA_5) {
- pr_err("Invalid era for selected algorithm\n");
- return -ENOTSUP;
- }
-
- MOVEB(p, MATH2, 0, CONTEXT1, 0, 0x08, IMMED);
- MOVEB(p, MATH2, 0, CONTEXT1, 0x08, 0x08, WAITCOMP | IMMED);
- MATHB(p, SEQINSZ, SUB, ZERO, VSEQINSZ, 4, 0);
- if (dir == OP_TYPE_ENCAP_PROTOCOL)
- MATHB(p, SEQINSZ, ADD, PDCP_MAC_I_LEN, VSEQOUTSZ, 4,
- IMMED2);
- else
- MATHB(p, SEQINSZ, SUB, PDCP_MAC_I_LEN, VSEQOUTSZ, 4,
- IMMED2);
-
- SEQFIFOSTORE(p, MSG, 0, 0, VLF | CONT);
- ALG_OPERATION(p, OP_ALG_ALGSEL_ZUCE,
- OP_ALG_AAI_F8,
- OP_ALG_AS_INITFINAL,
- ICV_CHECK_DISABLE,
- dir == OP_TYPE_ENCAP_PROTOCOL ?
- DIR_ENC : DIR_DEC);
- break;
-
- default:
- pr_err("%s: Invalid encrypt algorithm selected: %d\n",
- "pdcp_insert_cplane_enc_only_op", cipherdata->algtype);
- return -EINVAL;
- }
-
- if (dir == OP_TYPE_ENCAP_PROTOCOL) {
- SEQFIFOLOAD(p, MSG1, 0, VLF);
- FIFOLOAD(p, MSG1, PDCP_NULL_INT_MAC_I_VAL, 4,
- LAST1 | FLUSH1 | IMMED);
- } else {
- SEQFIFOLOAD(p, MSG1, 0, VLF | LAST1 | FLUSH1);
- MOVE(p, OFIFO, 0, MATH1, 4, PDCP_MAC_I_LEN, WAITCOMP | IMMED);
- MATHB(p, MATH1, XOR, PDCP_NULL_INT_MAC_I_VAL, NONE, 4, IMMED2);
- JUMP(p, PDCP_NULL_INT_ICV_CHECK_FAILED_STATUS,
- HALT_STATUS, ALL_FALSE, MATH_Z);
- }
-
- return 0;
-}
-
-static inline int
-pdcp_insert_uplane_snow_snow_op(struct program *p,
- bool swap __maybe_unused,
- struct alginfo *cipherdata,
- struct alginfo *authdata,
- unsigned int dir,
- enum pdcp_sn_size sn_size,
- unsigned char era_2_sw_hfn_ovrd __maybe_unused)
-{
- uint32_t offset = 0, length = 0, sn_mask = 0;
-
- KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
- cipherdata->keylen, INLINE_KEY(cipherdata));
- KEY(p, KEY2, authdata->key_enc_flags, authdata->key, authdata->keylen,
- INLINE_KEY(authdata));
-
- if (rta_sec_era >= RTA_SEC_ERA_8 && sn_size != PDCP_SN_SIZE_18) {
- int pclid;
-
- if (sn_size == PDCP_SN_SIZE_5)
- pclid = OP_PCLID_LTE_PDCP_CTRL_MIXED;
- else
- pclid = OP_PCLID_LTE_PDCP_USER_RN;
-
- PROTOCOL(p, dir, pclid,
- ((uint16_t)cipherdata->algtype << 8) |
- (uint16_t)authdata->algtype);
-
- return 0;
- }
- /* Non-proto is supported only for 5bit cplane and 18bit uplane */
- switch (sn_size) {
- case PDCP_SN_SIZE_5:
- offset = 7;
- length = 1;
- sn_mask = (swap == false) ? PDCP_C_PLANE_SN_MASK :
- PDCP_C_PLANE_SN_MASK_BE;
- break;
- case PDCP_SN_SIZE_18:
- offset = 5;
- length = 3;
- sn_mask = (swap == false) ? PDCP_U_PLANE_18BIT_SN_MASK :
- PDCP_U_PLANE_18BIT_SN_MASK_BE;
- break;
- case PDCP_SN_SIZE_7:
- case PDCP_SN_SIZE_12:
- case PDCP_SN_SIZE_15:
- pr_err("Invalid sn_size for %s\n", __func__);
- return -ENOTSUP;
- }
-
- if (dir == OP_TYPE_ENCAP_PROTOCOL)
- MATHB(p, SEQINSZ, SUB, length, VSEQINSZ, 4, IMMED2);
-
- SEQLOAD(p, MATH0, offset, length, 0);
- JUMP(p, 1, LOCAL_JUMP, ALL_TRUE, CALM);
- MOVEB(p, MATH0, offset, IFIFOAB2, 0, length, IMMED);
- MATHB(p, MATH0, AND, sn_mask, MATH1, 8, IFB | IMMED2);
-
- SEQSTORE(p, MATH0, offset, length, 0);
- MATHB(p, MATH1, SHLD, MATH1, MATH1, 8, 0);
- MOVEB(p, DESCBUF, 8, MATH2, 0, 8, WAITCOMP | IMMED);
- MATHB(p, MATH1, OR, MATH2, MATH1, 8, 0);
- MOVEB(p, MATH1, 0, CONTEXT1, 0, 8, IMMED);
- MOVEB(p, MATH1, 0, CONTEXT2, 0, 4, WAITCOMP | IMMED);
- if (swap == false) {
- MATHB(p, MATH1, AND, upper_32_bits(PDCP_BEARER_MASK),
- MATH2, 4, IMMED2);
- MATHB(p, MATH1, AND, lower_32_bits(PDCP_DIR_MASK),
- MATH3, 4, IMMED2);
- } else {
- MATHB(p, MATH1, AND, lower_32_bits(PDCP_BEARER_MASK_BE),
- MATH2, 4, IMMED2);
- MATHB(p, MATH1, AND, upper_32_bits(PDCP_DIR_MASK_BE),
- MATH3, 4, IMMED2);
- }
- MATHB(p, MATH3, SHLD, MATH3, MATH3, 8, 0);
-
- MOVEB(p, MATH2, 4, OFIFO, 0, 12, IMMED);
- MOVE(p, OFIFO, 0, CONTEXT2, 4, 12, IMMED);
- if (dir == OP_TYPE_ENCAP_PROTOCOL) {
- MATHB(p, SEQINSZ, ADD, PDCP_MAC_I_LEN, VSEQOUTSZ, 4, IMMED2);
- } else {
- MATHI(p, SEQINSZ, SUB, PDCP_MAC_I_LEN, VSEQOUTSZ, 4, IMMED2);
- MATHI(p, SEQINSZ, SUB, PDCP_MAC_I_LEN, VSEQINSZ, 4, IMMED2);
- }
-
- if (dir == OP_TYPE_ENCAP_PROTOCOL)
- SEQFIFOSTORE(p, MSG, 0, 0, VLF);
- else
- SEQFIFOSTORE(p, MSG, 0, 0, VLF | CONT);
-
- ALG_OPERATION(p, OP_ALG_ALGSEL_SNOW_F9,
- OP_ALG_AAI_F9,
- OP_ALG_AS_INITFINAL,
- dir == OP_TYPE_ENCAP_PROTOCOL ?
- ICV_CHECK_DISABLE : ICV_CHECK_ENABLE,
- DIR_DEC);
- ALG_OPERATION(p, OP_ALG_ALGSEL_SNOW_F8,
- OP_ALG_AAI_F8,
- OP_ALG_AS_INITFINAL,
- ICV_CHECK_DISABLE,
- dir == OP_TYPE_ENCAP_PROTOCOL ? DIR_ENC : DIR_DEC);
-
- if (dir == OP_TYPE_ENCAP_PROTOCOL) {
- SEQFIFOLOAD(p, MSGINSNOOP, 0, VLF | LAST2);
- MOVE(p, CONTEXT2, 0, IFIFOAB1, 0, 4, LAST1 | FLUSH1 | IMMED);
- } else {
- SEQFIFOLOAD(p, MSGOUTSNOOP, 0, VLF | LAST2);
- SEQFIFOLOAD(p, MSG1, 4, LAST1 | FLUSH1);
- JUMP(p, 1, LOCAL_JUMP, ALL_TRUE, CLASS1 | NOP | NIFP);
-
- if (rta_sec_era >= RTA_SEC_ERA_6)
- LOAD(p, 0, DCTRL, 0, LDLEN_RST_CHA_OFIFO_PTR, IMMED);
-
- MOVE(p, OFIFO, 0, MATH0, 0, 4, WAITCOMP | IMMED);
-
- NFIFOADD(p, IFIFO, ICV2, 4, LAST2);
-
- if (rta_sec_era <= RTA_SEC_ERA_2) {
- /* Shut off automatic Info FIFO entries */
- LOAD(p, 0, DCTRL, LDOFF_DISABLE_AUTO_NFIFO, 0, IMMED);
- MOVE(p, MATH0, 0, IFIFOAB2, 0, 4, WAITCOMP | IMMED);
- } else {
- MOVE(p, MATH0, 0, IFIFO, 0, 4, WAITCOMP | IMMED);
- }
- }
-
- return 0;
-}
-
-static inline int
-pdcp_insert_uplane_zuc_zuc_op(struct program *p,
- bool swap __maybe_unused,
- struct alginfo *cipherdata,
- struct alginfo *authdata,
- unsigned int dir,
- enum pdcp_sn_size sn_size,
- unsigned char era_2_sw_hfn_ovrd __maybe_unused)
-{
- uint32_t offset = 0, length = 0, sn_mask = 0;
-
- LABEL(keyjump);
- REFERENCE(pkeyjump);
-
- if (rta_sec_era < RTA_SEC_ERA_5) {
- pr_err("Invalid era for selected algorithm\n");
- return -ENOTSUP;
- }
-
- pkeyjump = JUMP(p, keyjump, LOCAL_JUMP, ALL_TRUE, SHRD | SELF | BOTH);
- KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
- cipherdata->keylen, INLINE_KEY(cipherdata));
- KEY(p, KEY2, authdata->key_enc_flags, authdata->key, authdata->keylen,
- INLINE_KEY(authdata));
-
- SET_LABEL(p, keyjump);
- PATCH_JUMP(p, pkeyjump, keyjump);
-
- if (rta_sec_era >= RTA_SEC_ERA_8 && sn_size != PDCP_SN_SIZE_18) {
- int pclid;
-
- if (sn_size == PDCP_SN_SIZE_5)
- pclid = OP_PCLID_LTE_PDCP_CTRL_MIXED;
- else
- pclid = OP_PCLID_LTE_PDCP_USER_RN;
-
- PROTOCOL(p, dir, pclid,
- ((uint16_t)cipherdata->algtype << 8) |
- (uint16_t)authdata->algtype);
-
- return 0;
- }
- /* Non-proto is supported only for 5bit cplane and 18bit uplane */
- switch (sn_size) {
- case PDCP_SN_SIZE_5:
- offset = 7;
- length = 1;
- sn_mask = (swap == false) ? PDCP_C_PLANE_SN_MASK :
- PDCP_C_PLANE_SN_MASK_BE;
- break;
- case PDCP_SN_SIZE_18:
- offset = 5;
- length = 3;
- sn_mask = (swap == false) ? PDCP_U_PLANE_18BIT_SN_MASK :
- PDCP_U_PLANE_18BIT_SN_MASK_BE;
- break;
- case PDCP_SN_SIZE_7:
- case PDCP_SN_SIZE_12:
- case PDCP_SN_SIZE_15:
- pr_err("Invalid sn_size for %s\n", __func__);
- return -ENOTSUP;
- }
-
- SEQLOAD(p, MATH0, offset, length, 0);
- JUMP(p, 1, LOCAL_JUMP, ALL_TRUE, CALM);
- MOVEB(p, MATH0, offset, IFIFOAB2, 0, length, IMMED);
- MATHB(p, MATH0, AND, sn_mask, MATH1, 8, IFB | IMMED2);
- MATHB(p, MATH1, SHLD, MATH1, MATH1, 8, 0);
-
- MOVEB(p, DESCBUF, 8, MATH2, 0, 8, WAITCOMP | IMMED);
- MATHB(p, MATH1, OR, MATH2, MATH2, 8, 0);
- MOVEB(p, MATH2, 0, CONTEXT1, 0, 8, IMMED);
-
- MOVEB(p, MATH2, 0, CONTEXT2, 0, 8, WAITCOMP | IMMED);
-
- if (dir == OP_TYPE_ENCAP_PROTOCOL)
- MATHB(p, SEQINSZ, ADD, PDCP_MAC_I_LEN, VSEQOUTSZ, 4, IMMED2);
- else
- MATHB(p, SEQINSZ, SUB, PDCP_MAC_I_LEN, VSEQOUTSZ, 4, IMMED2);
-
- MATHB(p, SEQINSZ, SUB, ZERO, VSEQINSZ, 4, 0);
- SEQSTORE(p, MATH0, offset, length, 0);
-
- if (dir == OP_TYPE_ENCAP_PROTOCOL) {
- SEQFIFOSTORE(p, MSG, 0, 0, VLF);
- SEQFIFOLOAD(p, MSGINSNOOP, 0, VLF | LAST2);
- } else {
- SEQFIFOSTORE(p, MSG, 0, 0, VLF | CONT);
- SEQFIFOLOAD(p, MSGOUTSNOOP, 0, VLF | LAST1 | FLUSH1);
- }
-
- ALG_OPERATION(p, OP_ALG_ALGSEL_ZUCA,
- OP_ALG_AAI_F9,
- OP_ALG_AS_INITFINAL,
- dir == OP_TYPE_ENCAP_PROTOCOL ?
- ICV_CHECK_DISABLE : ICV_CHECK_ENABLE,
- DIR_ENC);
-
- ALG_OPERATION(p, OP_ALG_ALGSEL_ZUCE,
- OP_ALG_AAI_F8,
- OP_ALG_AS_INITFINAL,
- ICV_CHECK_DISABLE,
- dir == OP_TYPE_ENCAP_PROTOCOL ? DIR_ENC : DIR_DEC);
-
- if (dir == OP_TYPE_ENCAP_PROTOCOL) {
- MOVE(p, CONTEXT2, 0, IFIFOAB1, 0, 4, LAST1 | FLUSH1 | IMMED);
- } else {
- /* Save ICV */
- MOVEB(p, OFIFO, 0, MATH0, 0, 4, IMMED);
-
- LOAD(p, NFIFOENTRY_STYPE_ALTSOURCE |
- NFIFOENTRY_DEST_CLASS2 |
- NFIFOENTRY_DTYPE_ICV |
- NFIFOENTRY_LC2 | 4, NFIFO_SZL, 0, 4, IMMED);
- MOVEB(p, MATH0, 0, ALTSOURCE, 0, 4, WAITCOMP | IMMED);
- }
-
- /* Reset ZUCA mode and done interrupt */
- LOAD(p, CLRW_CLR_C2MODE, CLRW, 0, 4, IMMED);
- LOAD(p, CIRQ_ZADI, ICTRL, 0, 4, IMMED);
-
- return 0;
-}
-
-static inline int
-pdcp_insert_uplane_aes_aes_op(struct program *p,
- bool swap __maybe_unused,
- struct alginfo *cipherdata,
- struct alginfo *authdata,
- unsigned int dir,
- enum pdcp_sn_size sn_size,
- unsigned char era_2_sw_hfn_ovrd __maybe_unused)
-{
- uint32_t offset = 0, length = 0, sn_mask = 0;
-
- if ((rta_sec_era >= RTA_SEC_ERA_8 && sn_size != PDCP_SN_SIZE_18)) {
- /* Insert Auth Key */
- KEY(p, KEY2, authdata->key_enc_flags, authdata->key,
- authdata->keylen, INLINE_KEY(authdata));
-
- /* Insert Cipher Key */
- KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
- cipherdata->keylen, INLINE_KEY(cipherdata));
-
- PROTOCOL(p, dir, OP_PCLID_LTE_PDCP_USER_RN,
- ((uint16_t)cipherdata->algtype << 8) |
- (uint16_t)authdata->algtype);
- return 0;
- }
-
- /* Non-proto is supported only for 5bit cplane and 18bit uplane */
- switch (sn_size) {
- case PDCP_SN_SIZE_18:
- offset = 5;
- length = 3;
- sn_mask = (swap == false) ? PDCP_U_PLANE_18BIT_SN_MASK :
- PDCP_U_PLANE_18BIT_SN_MASK_BE;
- break;
-
- default:
- pr_err("Invalid sn_size for %s\n", __func__);
- return -ENOTSUP;
- }
-
- SEQLOAD(p, MATH0, offset, length, 0);
- JUMP(p, 1, LOCAL_JUMP, ALL_TRUE, CALM);
- MATHB(p, MATH0, AND, sn_mask, MATH1, 8, IFB | IMMED2);
-
- MATHB(p, MATH1, SHLD, MATH1, MATH1, 8, 0);
- MOVEB(p, DESCBUF, 8, MATH2, 0, 0x08, WAITCOMP | IMMED);
- MATHB(p, MATH1, OR, MATH2, MATH2, 8, 0);
- SEQSTORE(p, MATH0, offset, length, 0);
-
- if (dir == OP_TYPE_ENCAP_PROTOCOL) {
- KEY(p, KEY1, authdata->key_enc_flags, authdata->key,
- authdata->keylen, INLINE_KEY(authdata));
- MOVEB(p, MATH2, 0, IFIFOAB1, 0, 0x08, IMMED);
- MOVEB(p, MATH0, offset, IFIFOAB1, 0, length, IMMED);
-
- MATHB(p, SEQINSZ, SUB, ZERO, VSEQINSZ, 4, 0);
- MATHB(p, VSEQINSZ, ADD, PDCP_MAC_I_LEN, VSEQOUTSZ, 4, IMMED2);
-
- ALG_OPERATION(p, OP_ALG_ALGSEL_AES,
- OP_ALG_AAI_CMAC,
- OP_ALG_AS_INITFINAL,
- ICV_CHECK_DISABLE,
- DIR_DEC);
- SEQFIFOLOAD(p, MSG1, 0, VLF | LAST1 | FLUSH1);
- MOVEB(p, CONTEXT1, 0, MATH3, 0, 4, WAITCOMP | IMMED);
-
- LOAD(p, CLRW_RESET_CLS1_CHA |
- CLRW_CLR_C1KEY |
- CLRW_CLR_C1CTX |
- CLRW_CLR_C1ICV |
- CLRW_CLR_C1DATAS |
- CLRW_CLR_C1MODE,
- CLRW, 0, 4, IMMED);
-
- KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
- cipherdata->keylen, INLINE_KEY(cipherdata));
-
- MOVEB(p, MATH2, 0, CONTEXT1, 16, 8, IMMED);
- SEQINPTR(p, 0, PDCP_NULL_MAX_FRAME_LEN, RTO);
-
- ALG_OPERATION(p, OP_ALG_ALGSEL_AES,
- OP_ALG_AAI_CTR,
- OP_ALG_AS_INITFINAL,
- ICV_CHECK_DISABLE,
- DIR_ENC);
-
- SEQFIFOSTORE(p, MSG, 0, 0, VLF);
-
- SEQFIFOLOAD(p, SKIP, length, 0);
-
- SEQFIFOLOAD(p, MSG1, 0, VLF);
- MOVEB(p, MATH3, 0, IFIFOAB1, 0, 4, LAST1 | FLUSH1 | IMMED);
- } else {
- MOVEB(p, MATH2, 0, CONTEXT1, 16, 8, IMMED);
- MOVEB(p, MATH2, 0, CONTEXT2, 0, 8, IMMED);
-
- MATHB(p, SEQINSZ, SUB, ZERO, VSEQINSZ, 4, 0);
- MATHB(p, SEQINSZ, SUB, PDCP_MAC_I_LEN, VSEQOUTSZ, 4, IMMED2);
-
- KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
- cipherdata->keylen, INLINE_KEY(cipherdata));
-
- ALG_OPERATION(p, OP_ALG_ALGSEL_AES,
- OP_ALG_AAI_CTR,
- OP_ALG_AS_INITFINAL,
- ICV_CHECK_DISABLE,
- DIR_DEC);
-
- SEQFIFOSTORE(p, MSG, 0, 0, VLF | CONT);
- SEQFIFOLOAD(p, MSG1, 0, VLF | LAST1 | FLUSH1);
-
- MOVEB(p, OFIFO, 0, MATH3, 0, 4, IMMED);
-
- LOAD(p, CLRW_RESET_CLS1_CHA |
- CLRW_CLR_C1KEY |
- CLRW_CLR_C1CTX |
- CLRW_CLR_C1ICV |
- CLRW_CLR_C1DATAS |
- CLRW_CLR_C1MODE,
- CLRW, 0, 4, IMMED);
-
- KEY(p, KEY1, authdata->key_enc_flags, authdata->key,
- authdata->keylen, INLINE_KEY(authdata));
-
- SEQINPTR(p, 0, 0, SOP);
-
- ALG_OPERATION(p, OP_ALG_ALGSEL_AES,
- OP_ALG_AAI_CMAC,
- OP_ALG_AS_INITFINAL,
- ICV_CHECK_ENABLE,
- DIR_DEC);
-
- MATHB(p, SEQINSZ, SUB, ZERO, VSEQINSZ, 4, 0);
-
- MOVE(p, CONTEXT2, 0, IFIFOAB1, 0, 8, IMMED);
-
- SEQFIFOLOAD(p, MSG1, 0, VLF | LAST1 | FLUSH1);
-
- LOAD(p, NFIFOENTRY_STYPE_ALTSOURCE |
- NFIFOENTRY_DEST_CLASS1 |
- NFIFOENTRY_DTYPE_ICV |
- NFIFOENTRY_LC1 |
- NFIFOENTRY_FC1 | 4, NFIFO_SZL, 0, 4, IMMED);
- MOVEB(p, MATH3, 0, ALTSOURCE, 0, 4, IMMED);
- }
-
- return 0;
-}
-
-static inline int
-pdcp_insert_cplane_acc_op(struct program *p,
- bool swap __maybe_unused,
- struct alginfo *cipherdata,
- struct alginfo *authdata,
- unsigned int dir,
- enum pdcp_sn_size sn_size,
- unsigned char era_2_hfn_ovrd __maybe_unused)
-{
- /* Insert Auth Key */
- KEY(p, KEY2, authdata->key_enc_flags, authdata->key, authdata->keylen,
- INLINE_KEY(authdata));
-
- /* Insert Cipher Key */
- KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
- cipherdata->keylen, INLINE_KEY(cipherdata));
-
- if (sn_size == PDCP_SN_SIZE_5)
- PROTOCOL(p, dir, OP_PCLID_LTE_PDCP_CTRL,
- (uint16_t)cipherdata->algtype);
- else
- PROTOCOL(p, dir, OP_PCLID_LTE_PDCP_USER_RN,
- ((uint16_t)cipherdata->algtype << 8) |
- (uint16_t)authdata->algtype);
-
- return 0;
-}
-
-static inline int
-pdcp_insert_cplane_snow_aes_op(struct program *p,
- bool swap __maybe_unused,
- struct alginfo *cipherdata,
- struct alginfo *authdata,
- unsigned int dir,
- enum pdcp_sn_size sn_size,
- unsigned char era_2_sw_hfn_ovrd)
-{
- uint32_t offset = 0, length = 0, sn_mask = 0;
-
- LABEL(back_to_sd_offset);
- LABEL(end_desc);
- LABEL(local_offset);
- LABEL(jump_to_beginning);
- LABEL(fifo_load_mac_i_offset);
- REFERENCE(seqin_ptr_read);
- REFERENCE(seqin_ptr_write);
- REFERENCE(seq_out_read);
- REFERENCE(jump_back_to_sd_cmd);
- REFERENCE(move_mac_i_to_desc_buf);
-
- if ((rta_sec_era >= RTA_SEC_ERA_8 && sn_size != PDCP_SN_SIZE_18) ||
- (rta_sec_era == RTA_SEC_ERA_10)) {
- KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
- cipherdata->keylen, INLINE_KEY(cipherdata));
- KEY(p, KEY2, authdata->key_enc_flags, authdata->key,
- authdata->keylen, INLINE_KEY(authdata));
-
- if (sn_size == PDCP_SN_SIZE_5)
- PROTOCOL(p, dir, OP_PCLID_LTE_PDCP_CTRL_MIXED,
- ((uint16_t)cipherdata->algtype << 8) |
- (uint16_t)authdata->algtype);
- else
- PROTOCOL(p, dir, OP_PCLID_LTE_PDCP_USER_RN,
- ((uint16_t)cipherdata->algtype << 8) |
- (uint16_t)authdata->algtype);
-
- return 0;
- }
- /* Non-proto is supported only for 5bit cplane and 18bit uplane */
- switch (sn_size) {
- case PDCP_SN_SIZE_5:
- offset = 7;
- length = 1;
- sn_mask = (swap == false) ? PDCP_C_PLANE_SN_MASK :
- PDCP_C_PLANE_SN_MASK_BE;
- break;
- case PDCP_SN_SIZE_18:
- offset = 5;
- length = 3;
- sn_mask = (swap == false) ? PDCP_U_PLANE_18BIT_SN_MASK :
- PDCP_U_PLANE_18BIT_SN_MASK_BE;
- break;
- case PDCP_SN_SIZE_7:
- case PDCP_SN_SIZE_12:
- case PDCP_SN_SIZE_15:
- pr_err("Invalid sn_size for %s\n", __func__);
- return -ENOTSUP;
-
- }
-
- SEQLOAD(p, MATH0, offset, length, 0);
- JUMP(p, 1, LOCAL_JUMP, ALL_TRUE, CALM);
- MATHB(p, MATH0, AND, sn_mask, MATH1, 8, IFB | IMMED2);
- MATHB(p, MATH1, SHLD, MATH1, MATH1, 8, 0);
- MOVEB(p, DESCBUF, 4, MATH2, 0, 0x08, WAITCOMP | IMMED);
- MATHB(p, MATH1, OR, MATH2, MATH2, 8, 0);
- SEQSTORE(p, MATH0, offset, length, 0);
- if (dir == OP_TYPE_ENCAP_PROTOCOL) {
- if (rta_sec_era > RTA_SEC_ERA_2 ||
- (rta_sec_era == RTA_SEC_ERA_2 &&
- era_2_sw_hfn_ovrd == 0)) {
- SEQINPTR(p, 0, length, RTO);
- } else {
- SEQINPTR(p, 0, 5, RTO);
- SEQFIFOLOAD(p, SKIP, 4, 0);
- }
- KEY(p, KEY1, authdata->key_enc_flags, authdata->key,
- authdata->keylen, INLINE_KEY(authdata));
- MOVEB(p, MATH2, 0, IFIFOAB1, 0, 0x08, IMMED);
-
- if (rta_sec_era > RTA_SEC_ERA_2) {
- MATHB(p, SEQINSZ, SUB, ZERO, VSEQINSZ, 4, 0);
- MATHB(p, SEQINSZ, SUB, ZERO, MATH1, 4, 0);
- MATHB(p, VSEQINSZ, ADD, PDCP_MAC_I_LEN - 1, VSEQOUTSZ,
- 4, IMMED2);
- } else {
- MATHB(p, SEQINSZ, SUB, MATH3, VSEQINSZ, 4, 0);
- MATHB(p, VSEQINSZ, ADD, PDCP_MAC_I_LEN - 1, VSEQOUTSZ,
- 4, IMMED2);
- /*
- * Note: Although the calculations below might seem a
- * little off, the logic is the following:
- *
- * - SEQ IN PTR RTO below needs the full length of the
- * frame; in case of P4080_REV_2_HFN_OV_WORKAROUND,
- * this means the length of the frame to be processed
- * + 4 bytes (the HFN override flag and value).
- * The length of the frame to be processed minus 1
- * byte is in the VSIL register (because
- * VSIL = SIL + 3, due to 1 byte, the header being
- * already written by the SEQ STORE above). So for
- * calculating the length to use in RTO, I add one
- * to the VSIL value in order to obtain the total
- * frame length. This helps in case of P4080 which
- * can have the value 0 as an operand in a MATH
- * command only as SRC1 When the HFN override
- * workaround is not enabled, the length of the
- * frame is given by the SIL register; the
- * calculation is similar to the one in the SEC 4.2
- * and SEC 5.3 cases.
- */
- if (era_2_sw_hfn_ovrd)
- MATHB(p, VSEQOUTSZ, ADD, ONE, MATH1, 4,
- 0);
- else
- MATHB(p, SEQINSZ, ADD, MATH3, MATH1, 4,
- 0);
- }
- /*
- * Placeholder for filling the length in
- * SEQIN PTR RTO below
- */
- seqin_ptr_read = MOVE(p, DESCBUF, 0, MATH1, 0, 6, IMMED);
- seqin_ptr_write = MOVE(p, MATH1, 0, DESCBUF, 0, 8,
- WAITCOMP | IMMED);
- ALG_OPERATION(p, OP_ALG_ALGSEL_AES,
- OP_ALG_AAI_CMAC,
- OP_ALG_AS_INITFINAL,
- ICV_CHECK_DISABLE,
- DIR_DEC);
- SEQFIFOLOAD(p, MSG1, 0, VLF | LAST1 | FLUSH1);
- MOVEB(p, CONTEXT1, 0, MATH3, 0, 4, WAITCOMP | IMMED);
- if (rta_sec_era <= RTA_SEC_ERA_3)
- LOAD(p, CLRW_CLR_C1KEY |
- CLRW_CLR_C1CTX |
- CLRW_CLR_C1ICV |
- CLRW_CLR_C1DATAS |
- CLRW_CLR_C1MODE,
- CLRW, 0, 4, IMMED);
- else
- LOAD(p, CLRW_RESET_CLS1_CHA |
- CLRW_CLR_C1KEY |
- CLRW_CLR_C1CTX |
- CLRW_CLR_C1ICV |
- CLRW_CLR_C1DATAS |
- CLRW_CLR_C1MODE,
- CLRW, 0, 4, IMMED);
-
- if (rta_sec_era <= RTA_SEC_ERA_3)
- LOAD(p, CCTRL_RESET_CHA_ALL, CCTRL, 0, 4, IMMED);
-
- KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
- cipherdata->keylen, INLINE_KEY(cipherdata));
- SET_LABEL(p, local_offset);
- MOVEB(p, MATH2, 0, CONTEXT1, 0, 8, IMMED);
- SEQINPTR(p, 0, 0, RTO);
-
- if (rta_sec_era == RTA_SEC_ERA_2 && era_2_sw_hfn_ovrd) {
- SEQFIFOLOAD(p, SKIP, 5, 0);
- MATHB(p, SEQINSZ, ADD, ONE, SEQINSZ, 4, 0);
- }
-
- MATHB(p, SEQINSZ, SUB, length, VSEQINSZ, 4, IMMED2);
- ALG_OPERATION(p, OP_ALG_ALGSEL_SNOW_F8,
- OP_ALG_AAI_F8,
- OP_ALG_AS_INITFINAL,
- ICV_CHECK_DISABLE,
- DIR_ENC);
- SEQFIFOSTORE(p, MSG, 0, 0, VLF);
-
- if (rta_sec_era > RTA_SEC_ERA_2 ||
- (rta_sec_era == RTA_SEC_ERA_2 &&
- era_2_sw_hfn_ovrd == 0))
- SEQFIFOLOAD(p, SKIP, length, 0);
-
- SEQFIFOLOAD(p, MSG1, 0, VLF);
- MOVEB(p, MATH3, 0, IFIFOAB1, 0, 4, LAST1 | FLUSH1 | IMMED);
- PATCH_MOVE(p, seqin_ptr_read, local_offset);
- PATCH_MOVE(p, seqin_ptr_write, local_offset);
- } else {
- MOVEB(p, MATH2, 0, CONTEXT1, 0, 8, IMMED);
-
- if (rta_sec_era >= RTA_SEC_ERA_5)
- MOVE(p, CONTEXT1, 0, CONTEXT2, 0, 8, IMMED);
-
- if (rta_sec_era > RTA_SEC_ERA_2)
- MATHB(p, SEQINSZ, SUB, ZERO, VSEQINSZ, 4, 0);
- else
- MATHB(p, SEQINSZ, SUB, MATH3, VSEQINSZ, 4, 0);
-
- MATHI(p, SEQINSZ, SUB, PDCP_MAC_I_LEN, VSEQOUTSZ, 4, IMMED2);
-/*
- * TODO: To be changed when proper support is added in RTA (can't load a
- * command that is also written by RTA (or patch it for that matter).
- * Change when proper RTA support is added.
- */
- if (p->ps)
- WORD(p, 0x168B0004);
- else
- WORD(p, 0x16880404);
-
- jump_back_to_sd_cmd = JUMP(p, 0, LOCAL_JUMP, ALL_TRUE, 0);
- /*
- * Placeholder for command reading the SEQ OUT command in
- * JD. Done for rereading the decrypted data and performing
- * the integrity check
- */
-/*
- * TODO: RTA currently doesn't support patching of length of a MOVE command
- * Thus, it is inserted as a raw word, as per PS setting.
- */
- if (p->ps)
- seq_out_read = MOVE(p, DESCBUF, 0, MATH1, 0, 20,
- WAITCOMP | IMMED);
- else
- seq_out_read = MOVE(p, DESCBUF, 0, MATH1, 0, 16,
- WAITCOMP | IMMED);
-
- MATHB(p, MATH1, XOR, CMD_SEQ_IN_PTR ^ CMD_SEQ_OUT_PTR, MATH1, 4,
- IMMED2);
- /* Placeholder for overwriting the SEQ IN with SEQ OUT */
-/*
- * TODO: RTA currently doesn't support patching of length of a MOVE command
- * Thus, it is inserted as a raw word, as per PS setting.
- */
- if (p->ps)
- MOVE(p, MATH1, 0, DESCBUF, 0, 24, IMMED);
- else
- MOVE(p, MATH1, 0, DESCBUF, 0, 20, IMMED);
-
- KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
- cipherdata->keylen, INLINE_KEY(cipherdata));
-
- if (rta_sec_era >= RTA_SEC_ERA_4)
- MOVE(p, CONTEXT1, 0, CONTEXT2, 0, 8, IMMED);
- else
- MOVE(p, CONTEXT1, 0, MATH3, 0, 8, IMMED);
-
- ALG_OPERATION(p, OP_ALG_ALGSEL_SNOW_F8,
- OP_ALG_AAI_F8,
- OP_ALG_AS_INITFINAL,
- ICV_CHECK_DISABLE,
- DIR_DEC);
- SEQFIFOSTORE(p, MSG, 0, 0, VLF | CONT);
- SEQFIFOLOAD(p, MSG1, 0, VLF | LAST1 | FLUSH1);
-
- if (rta_sec_era <= RTA_SEC_ERA_3)
- move_mac_i_to_desc_buf = MOVE(p, OFIFO, 0, DESCBUF, 0,
- 4, WAITCOMP | IMMED);
- else
- MOVE(p, OFIFO, 0, MATH3, 0, 4, IMMED);
-
- if (rta_sec_era <= RTA_SEC_ERA_3)
- LOAD(p, CCTRL_RESET_CHA_ALL, CCTRL, 0, 4, IMMED);
- else
- LOAD(p, CLRW_RESET_CLS1_CHA |
- CLRW_CLR_C1KEY |
- CLRW_CLR_C1CTX |
- CLRW_CLR_C1ICV |
- CLRW_CLR_C1DATAS |
- CLRW_CLR_C1MODE,
- CLRW, 0, 4, IMMED);
-
- KEY(p, KEY1, authdata->key_enc_flags, authdata->key,
- authdata->keylen, INLINE_KEY(authdata));
- /*
- * Placeholder for jump in SD for executing the new SEQ IN PTR
- * command (which is actually the old SEQ OUT PTR command
- * copied over from JD.
- */
- SET_LABEL(p, jump_to_beginning);
- JUMP(p, 1 - jump_to_beginning, LOCAL_JUMP, ALL_TRUE, 0);
- SET_LABEL(p, back_to_sd_offset);
- ALG_OPERATION(p, OP_ALG_ALGSEL_AES,
- OP_ALG_AAI_CMAC,
- OP_ALG_AS_INITFINAL,
- ICV_CHECK_ENABLE,
- DIR_DEC);
-
- /* Read the # of bytes written in the output buffer + 1 (HDR) */
- MATHI(p, VSEQOUTSZ, ADD, length, VSEQINSZ, 4, IMMED2);
-
- if (rta_sec_era <= RTA_SEC_ERA_3)
- MOVE(p, MATH3, 0, IFIFOAB1, 0, 8, IMMED);
- else
- MOVE(p, CONTEXT2, 0, IFIFOAB1, 0, 8, IMMED);
-
- if (rta_sec_era == RTA_SEC_ERA_2 && era_2_sw_hfn_ovrd)
- SEQFIFOLOAD(p, SKIP, 4, 0);
-
- SEQFIFOLOAD(p, MSG1, 0, VLF | LAST1 | FLUSH1);
-
- if (rta_sec_era >= RTA_SEC_ERA_4) {
- LOAD(p, NFIFOENTRY_STYPE_ALTSOURCE |
- NFIFOENTRY_DEST_CLASS1 |
- NFIFOENTRY_DTYPE_ICV |
- NFIFOENTRY_LC1 |
- NFIFOENTRY_FC1 | 4, NFIFO_SZL, 0, 4, IMMED);
- MOVE(p, MATH3, 0, ALTSOURCE, 0, 4, IMMED);
- } else {
- SET_LABEL(p, fifo_load_mac_i_offset);
- FIFOLOAD(p, ICV1, fifo_load_mac_i_offset, 4,
- LAST1 | FLUSH1 | IMMED);
- }
-
- SET_LABEL(p, end_desc);
-
- if (!p->ps) {
- PATCH_MOVE(p, seq_out_read, end_desc + 1);
- PATCH_JUMP(p, jump_back_to_sd_cmd,
- back_to_sd_offset + jump_back_to_sd_cmd - 5);
-
- if (rta_sec_era <= RTA_SEC_ERA_3)
- PATCH_MOVE(p, move_mac_i_to_desc_buf,
- fifo_load_mac_i_offset + 1);
- } else {
- PATCH_MOVE(p, seq_out_read, end_desc + 2);
- PATCH_JUMP(p, jump_back_to_sd_cmd,
- back_to_sd_offset + jump_back_to_sd_cmd - 5);
-
- if (rta_sec_era <= RTA_SEC_ERA_3)
- PATCH_MOVE(p, move_mac_i_to_desc_buf,
- fifo_load_mac_i_offset + 1);
- }
- }
-
- return 0;
-}
-
-static inline int
-pdcp_insert_cplane_aes_snow_op(struct program *p,
- bool swap __maybe_unused,
- struct alginfo *cipherdata,
- struct alginfo *authdata,
- unsigned int dir,
- enum pdcp_sn_size sn_size,
- unsigned char era_2_sw_hfn_ovrd __maybe_unused)
-{
- uint32_t offset = 0, length = 0, sn_mask = 0;
-
- KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
- cipherdata->keylen, INLINE_KEY(cipherdata));
- KEY(p, KEY2, authdata->key_enc_flags, authdata->key, authdata->keylen,
- INLINE_KEY(authdata));
-
- if ((rta_sec_era >= RTA_SEC_ERA_8 && sn_size != PDCP_SN_SIZE_18) ||
- (rta_sec_era == RTA_SEC_ERA_10)) {
- int pclid;
-
- if (sn_size == PDCP_SN_SIZE_5)
- pclid = OP_PCLID_LTE_PDCP_CTRL_MIXED;
- else
- pclid = OP_PCLID_LTE_PDCP_USER_RN;
-
- PROTOCOL(p, dir, pclid,
- ((uint16_t)cipherdata->algtype << 8) |
- (uint16_t)authdata->algtype);
-
- return 0;
- }
- /* Non-proto is supported only for 5bit cplane and 18bit uplane */
- switch (sn_size) {
- case PDCP_SN_SIZE_5:
- offset = 7;
- length = 1;
- sn_mask = (swap == false) ? PDCP_C_PLANE_SN_MASK :
- PDCP_C_PLANE_SN_MASK_BE;
- break;
- case PDCP_SN_SIZE_18:
- offset = 5;
- length = 3;
- sn_mask = (swap == false) ? PDCP_U_PLANE_18BIT_SN_MASK :
- PDCP_U_PLANE_18BIT_SN_MASK_BE;
- break;
- case PDCP_SN_SIZE_7:
- case PDCP_SN_SIZE_12:
- case PDCP_SN_SIZE_15:
- pr_err("Invalid sn_size for %s\n", __func__);
- return -ENOTSUP;
-
- }
-
- if (dir == OP_TYPE_ENCAP_PROTOCOL)
- MATHB(p, SEQINSZ, SUB, length, VSEQINSZ, 4, IMMED2);
-
- SEQLOAD(p, MATH0, offset, length, 0);
- JUMP(p, 1, LOCAL_JUMP, ALL_TRUE, CALM);
- MOVEB(p, MATH0, offset, IFIFOAB2, 0, length, IMMED);
- MATHB(p, MATH0, AND, sn_mask, MATH1, 8, IFB | IMMED2);
-
- SEQSTORE(p, MATH0, offset, length, 0);
- MATHB(p, MATH1, SHLD, MATH1, MATH1, 8, 0);
- MOVEB(p, DESCBUF, 4, MATH2, 0, 8, WAITCOMP | IMMED);
- MATHB(p, MATH1, OR, MATH2, MATH1, 8, 0);
- MOVEB(p, MATH1, 0, CONTEXT1, 16, 8, IMMED);
- MOVEB(p, MATH1, 0, CONTEXT2, 0, 4, IMMED);
- if (swap == false) {
- MATHB(p, MATH1, AND, upper_32_bits(PDCP_BEARER_MASK), MATH2, 4,
- IMMED2);
- MATHB(p, MATH1, AND, lower_32_bits(PDCP_DIR_MASK), MATH3, 4,
- IMMED2);
- } else {
- MATHB(p, MATH1, AND, lower_32_bits(PDCP_BEARER_MASK_BE), MATH2,
- 4, IMMED2);
- MATHB(p, MATH1, AND, upper_32_bits(PDCP_DIR_MASK_BE), MATH3,
- 4, IMMED2);
- }
- MATHB(p, MATH3, SHLD, MATH3, MATH3, 8, 0);
- MOVEB(p, MATH2, 4, OFIFO, 0, 12, IMMED);
- MOVE(p, OFIFO, 0, CONTEXT2, 4, 12, IMMED);
- if (dir == OP_TYPE_ENCAP_PROTOCOL) {
- MATHB(p, SEQINSZ, ADD, PDCP_MAC_I_LEN, VSEQOUTSZ, 4, IMMED2);
- } else {
- MATHB(p, SEQINSZ, SUB, PDCP_MAC_I_LEN, MATH1, 4, IMMED2);
-
- MATHB(p, ZERO, ADD, MATH1, VSEQOUTSZ, 4, 0);
- MATHB(p, ZERO, ADD, MATH1, VSEQINSZ, 4, 0);
- }
-
- if (dir == OP_TYPE_ENCAP_PROTOCOL)
- SEQFIFOSTORE(p, MSG, 0, 0, VLF);
- else
- SEQFIFOSTORE(p, MSG, 0, 0, VLF | CONT);
-
- ALG_OPERATION(p, OP_ALG_ALGSEL_SNOW_F9,
- OP_ALG_AAI_F9,
- OP_ALG_AS_INITFINAL,
- dir == OP_TYPE_ENCAP_PROTOCOL ?
- ICV_CHECK_DISABLE : ICV_CHECK_ENABLE,
- DIR_DEC);
- ALG_OPERATION(p, OP_ALG_ALGSEL_AES,
- OP_ALG_AAI_CTR,
- OP_ALG_AS_INITFINAL,
- ICV_CHECK_DISABLE,
- dir == OP_TYPE_ENCAP_PROTOCOL ? DIR_ENC : DIR_DEC);
-
- if (dir == OP_TYPE_ENCAP_PROTOCOL) {
- SEQFIFOLOAD(p, MSGINSNOOP, 0, VLF | LAST2);
- MOVE(p, CONTEXT2, 0, IFIFOAB1, 0, 4, LAST1 | FLUSH1 | IMMED);
- } else {
- SEQFIFOLOAD(p, MSGOUTSNOOP, 0, VLF | LAST2);
- SEQFIFOLOAD(p, MSG1, 4, LAST1 | FLUSH1);
- JUMP(p, 1, LOCAL_JUMP, ALL_TRUE, CLASS1 | NOP | NIFP);
-
- if (rta_sec_era >= RTA_SEC_ERA_6)
- LOAD(p, 0, DCTRL, 0, LDLEN_RST_CHA_OFIFO_PTR, IMMED);
-
- MOVE(p, OFIFO, 0, MATH0, 0, 4, WAITCOMP | IMMED);
-
- NFIFOADD(p, IFIFO, ICV2, 4, LAST2);
-
- if (rta_sec_era <= RTA_SEC_ERA_2) {
- /* Shut off automatic Info FIFO entries */
- LOAD(p, 0, DCTRL, LDOFF_DISABLE_AUTO_NFIFO, 0, IMMED);
- MOVE(p, MATH0, 0, IFIFOAB2, 0, 4, WAITCOMP | IMMED);
- } else {
- MOVE(p, MATH0, 0, IFIFO, 0, 4, WAITCOMP | IMMED);
- }
- }
-
- return 0;
-}
-
-static inline int
-pdcp_insert_cplane_snow_zuc_op(struct program *p,
- bool swap __maybe_unused,
- struct alginfo *cipherdata,
- struct alginfo *authdata,
- unsigned int dir,
- enum pdcp_sn_size sn_size,
- unsigned char era_2_sw_hfn_ovrd __maybe_unused)
-{
- uint32_t offset = 0, length = 0, sn_mask = 0;
-
- LABEL(keyjump);
- REFERENCE(pkeyjump);
-
- if (rta_sec_era < RTA_SEC_ERA_5) {
- pr_err("Invalid era for selected algorithm\n");
- return -ENOTSUP;
- }
-
- pkeyjump = JUMP(p, keyjump, LOCAL_JUMP, ALL_TRUE, SHRD | SELF | BOTH);
- KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
- cipherdata->keylen, INLINE_KEY(cipherdata));
- KEY(p, KEY2, authdata->key_enc_flags, authdata->key, authdata->keylen,
- INLINE_KEY(authdata));
-
- SET_LABEL(p, keyjump);
-
- if ((rta_sec_era >= RTA_SEC_ERA_8 && sn_size != PDCP_SN_SIZE_18) ||
- (rta_sec_era == RTA_SEC_ERA_10)) {
- int pclid;
-
- if (sn_size == PDCP_SN_SIZE_5)
- pclid = OP_PCLID_LTE_PDCP_CTRL_MIXED;
- else
- pclid = OP_PCLID_LTE_PDCP_USER_RN;
-
- PROTOCOL(p, dir, pclid,
- ((uint16_t)cipherdata->algtype << 8) |
- (uint16_t)authdata->algtype);
- return 0;
- }
- /* Non-proto is supported only for 5bit cplane and 18bit uplane */
- switch (sn_size) {
- case PDCP_SN_SIZE_5:
- offset = 7;
- length = 1;
- sn_mask = (swap == false) ? PDCP_C_PLANE_SN_MASK :
- PDCP_C_PLANE_SN_MASK_BE;
- break;
- case PDCP_SN_SIZE_18:
- offset = 5;
- length = 3;
- sn_mask = (swap == false) ? PDCP_U_PLANE_18BIT_SN_MASK :
- PDCP_U_PLANE_18BIT_SN_MASK_BE;
- break;
- case PDCP_SN_SIZE_7:
- case PDCP_SN_SIZE_12:
- case PDCP_SN_SIZE_15:
- pr_err("Invalid sn_size for %s\n", __func__);
- return -ENOTSUP;
-
- }
-
- SEQLOAD(p, MATH0, offset, length, 0);
- JUMP(p, 1, LOCAL_JUMP, ALL_TRUE, CALM);
- MOVEB(p, MATH0, offset, IFIFOAB2, 0, length, IMMED);
- MATHB(p, MATH0, AND, sn_mask, MATH1, 8, IFB | IMMED2);
-
- MATHB(p, MATH1, SHLD, MATH1, MATH1, 8, 0);
- MOVEB(p, DESCBUF, 4, MATH2, 0, 8, WAITCOMP | IMMED);
- MATHB(p, MATH1, OR, MATH2, MATH2, 8, 0);
- MOVEB(p, MATH2, 0, CONTEXT1, 0, 8, IMMED);
- MOVEB(p, MATH2, 0, CONTEXT2, 0, 8, WAITCOMP | IMMED);
-
- if (dir == OP_TYPE_ENCAP_PROTOCOL)
- MATHB(p, SEQINSZ, ADD, PDCP_MAC_I_LEN, VSEQOUTSZ, 4, IMMED2);
- else
- MATHB(p, SEQINSZ, SUB, PDCP_MAC_I_LEN, VSEQOUTSZ, 4, IMMED2);
-
- MATHB(p, SEQINSZ, SUB, ZERO, VSEQINSZ, 4, 0);
- SEQSTORE(p, MATH0, offset, length, 0);
-
- if (dir == OP_TYPE_ENCAP_PROTOCOL) {
- SEQFIFOSTORE(p, MSG, 0, 0, VLF);
- SEQFIFOLOAD(p, MSGINSNOOP, 0, VLF | LAST2);
- } else {
- SEQFIFOSTORE(p, MSG, 0, 0, VLF | CONT);
- SEQFIFOLOAD(p, MSGOUTSNOOP, 0, VLF | LAST1 | FLUSH1);
- }
-
- ALG_OPERATION(p, OP_ALG_ALGSEL_ZUCA,
- OP_ALG_AAI_F9,
- OP_ALG_AS_INITFINAL,
- dir == OP_TYPE_ENCAP_PROTOCOL ?
- ICV_CHECK_DISABLE : ICV_CHECK_ENABLE,
- DIR_ENC);
-
- ALG_OPERATION(p, OP_ALG_ALGSEL_SNOW_F8,
- OP_ALG_AAI_F8,
- OP_ALG_AS_INITFINAL,
- ICV_CHECK_DISABLE,
- dir == OP_TYPE_ENCAP_PROTOCOL ? DIR_ENC : DIR_DEC);
- if (dir == OP_TYPE_ENCAP_PROTOCOL) {
- MOVE(p, CONTEXT2, 0, IFIFOAB1, 0, 4, LAST1 | FLUSH1 | IMMED);
- } else {
- /* Save ICV */
- MOVE(p, OFIFO, 0, MATH0, 0, 4, IMMED);
- LOAD(p, NFIFOENTRY_STYPE_ALTSOURCE |
- NFIFOENTRY_DEST_CLASS2 |
- NFIFOENTRY_DTYPE_ICV |
- NFIFOENTRY_LC2 | 4, NFIFO_SZL, 0, 4, IMMED);
- MOVE(p, MATH0, 0, ALTSOURCE, 0, 4, WAITCOMP | IMMED);
- }
-
- /* Reset ZUCA mode and done interrupt */
- LOAD(p, CLRW_CLR_C2MODE, CLRW, 0, 4, IMMED);
- LOAD(p, CIRQ_ZADI, ICTRL, 0, 4, IMMED);
-
- PATCH_JUMP(p, pkeyjump, keyjump);
- return 0;
-}
-
-static inline int
-pdcp_insert_cplane_aes_zuc_op(struct program *p,
- bool swap __maybe_unused,
- struct alginfo *cipherdata,
- struct alginfo *authdata,
- unsigned int dir,
- enum pdcp_sn_size sn_size,
- unsigned char era_2_sw_hfn_ovrd __maybe_unused)
-{
- uint32_t offset = 0, length = 0, sn_mask = 0;
- LABEL(keyjump);
- REFERENCE(pkeyjump);
-
- if (rta_sec_era < RTA_SEC_ERA_5) {
- pr_err("Invalid era for selected algorithm\n");
- return -ENOTSUP;
- }
-
- pkeyjump = JUMP(p, keyjump, LOCAL_JUMP, ALL_TRUE, SHRD | SELF | BOTH);
- KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
- cipherdata->keylen, INLINE_KEY(cipherdata));
- KEY(p, KEY2, authdata->key_enc_flags, authdata->key, authdata->keylen,
- INLINE_KEY(authdata));
-
- if ((rta_sec_era >= RTA_SEC_ERA_8 && sn_size != PDCP_SN_SIZE_18) ||
- (rta_sec_era == RTA_SEC_ERA_10)) {
- int pclid;
-
- if (sn_size == PDCP_SN_SIZE_5)
- pclid = OP_PCLID_LTE_PDCP_CTRL_MIXED;
- else
- pclid = OP_PCLID_LTE_PDCP_USER_RN;
-
- PROTOCOL(p, dir, pclid,
- ((uint16_t)cipherdata->algtype << 8) |
- (uint16_t)authdata->algtype);
-
- return 0;
- }
- /* Non-proto is supported only for 5bit cplane and 18bit uplane */
- switch (sn_size) {
- case PDCP_SN_SIZE_5:
- offset = 7;
- length = 1;
- sn_mask = (swap == false) ? PDCP_C_PLANE_SN_MASK :
- PDCP_C_PLANE_SN_MASK_BE;
- break;
- case PDCP_SN_SIZE_18:
- offset = 5;
- length = 3;
- sn_mask = (swap == false) ? PDCP_U_PLANE_18BIT_SN_MASK :
- PDCP_U_PLANE_18BIT_SN_MASK_BE;
- break;
- case PDCP_SN_SIZE_7:
- case PDCP_SN_SIZE_12:
- case PDCP_SN_SIZE_15:
- pr_err("Invalid sn_size for %s\n", __func__);
- return -ENOTSUP;
-
- }
-
- SET_LABEL(p, keyjump);
- SEQLOAD(p, MATH0, offset, length, 0);
- JUMP(p, 1, LOCAL_JUMP, ALL_TRUE, CALM);
- MOVEB(p, MATH0, offset, IFIFOAB2, 0, length, IMMED);
- MATHB(p, MATH0, AND, sn_mask, MATH1, 8, IFB | IMMED2);
-
- MATHB(p, MATH1, SHLD, MATH1, MATH1, 8, 0);
- MOVEB(p, DESCBUF, 4, MATH2, 0, 8, WAITCOMP | IMMED);
- MATHB(p, MATH1, OR, MATH2, MATH2, 8, 0);
- MOVEB(p, MATH2, 0, CONTEXT1, 16, 8, IMMED);
- MOVEB(p, MATH2, 0, CONTEXT2, 0, 8, WAITCOMP | IMMED);
-
- if (dir == OP_TYPE_ENCAP_PROTOCOL)
- MATHB(p, SEQINSZ, ADD, PDCP_MAC_I_LEN, VSEQOUTSZ, 4, IMMED2);
- else
- MATHB(p, SEQINSZ, SUB, PDCP_MAC_I_LEN, VSEQOUTSZ, 4, IMMED2);
-
- MATHB(p, SEQINSZ, SUB, ZERO, VSEQINSZ, 4, 0);
- SEQSTORE(p, MATH0, offset, length, 0);
-
- if (dir == OP_TYPE_ENCAP_PROTOCOL) {
- SEQFIFOSTORE(p, MSG, 0, 0, VLF);
- SEQFIFOLOAD(p, MSGINSNOOP, 0, VLF | LAST2);
- } else {
- SEQFIFOSTORE(p, MSG, 0, 0, VLF | CONT);
- SEQFIFOLOAD(p, MSGOUTSNOOP, 0, VLF | LAST1 | FLUSH1);
- }
-
- ALG_OPERATION(p, OP_ALG_ALGSEL_ZUCA,
- OP_ALG_AAI_F9,
- OP_ALG_AS_INITFINAL,
- dir == OP_TYPE_ENCAP_PROTOCOL ?
- ICV_CHECK_DISABLE : ICV_CHECK_ENABLE,
- DIR_ENC);
-
- ALG_OPERATION(p, OP_ALG_ALGSEL_AES,
- OP_ALG_AAI_CTR,
- OP_ALG_AS_INITFINAL,
- ICV_CHECK_DISABLE,
- dir == OP_TYPE_ENCAP_PROTOCOL ? DIR_ENC : DIR_DEC);
-
- if (dir == OP_TYPE_ENCAP_PROTOCOL) {
- MOVE(p, CONTEXT2, 0, IFIFOAB1, 0, 4, LAST1 | FLUSH1 | IMMED);
- } else {
- /* Save ICV */
- MOVE(p, OFIFO, 0, MATH0, 0, 4, IMMED);
-
- LOAD(p, NFIFOENTRY_STYPE_ALTSOURCE |
- NFIFOENTRY_DEST_CLASS2 |
- NFIFOENTRY_DTYPE_ICV |
- NFIFOENTRY_LC2 | 4, NFIFO_SZL, 0, 4, IMMED);
- MOVE(p, MATH0, 0, ALTSOURCE, 0, 4, WAITCOMP | IMMED);
- }
-
- /* Reset ZUCA mode and done interrupt */
- LOAD(p, CLRW_CLR_C2MODE, CLRW, 0, 4, IMMED);
- LOAD(p, CIRQ_ZADI, ICTRL, 0, 4, IMMED);
-
- PATCH_JUMP(p, pkeyjump, keyjump);
-
- return 0;
-}
-
-static inline int
-pdcp_insert_cplane_zuc_snow_op(struct program *p,
- bool swap __maybe_unused,
- struct alginfo *cipherdata,
- struct alginfo *authdata,
- unsigned int dir,
- enum pdcp_sn_size sn_size,
- unsigned char era_2_sw_hfn_ovrd __maybe_unused)
-{
- uint32_t offset = 0, length = 0, sn_mask = 0;
- LABEL(keyjump);
- REFERENCE(pkeyjump);
-
- if (rta_sec_era < RTA_SEC_ERA_5) {
- pr_err("Invalid era for selected algorithm\n");
- return -ENOTSUP;
- }
-
- pkeyjump = JUMP(p, keyjump, LOCAL_JUMP, ALL_TRUE, SHRD | SELF | BOTH);
- KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
- cipherdata->keylen, INLINE_KEY(cipherdata));
- KEY(p, KEY2, authdata->key_enc_flags, authdata->key, authdata->keylen,
- INLINE_KEY(authdata));
-
- if ((rta_sec_era >= RTA_SEC_ERA_8 && sn_size != PDCP_SN_SIZE_18) ||
- (rta_sec_era == RTA_SEC_ERA_10)) {
- int pclid;
-
- if (sn_size == PDCP_SN_SIZE_5)
- pclid = OP_PCLID_LTE_PDCP_CTRL_MIXED;
- else
- pclid = OP_PCLID_LTE_PDCP_USER_RN;
-
- PROTOCOL(p, dir, pclid,
- ((uint16_t)cipherdata->algtype << 8) |
- (uint16_t)authdata->algtype);
-
- return 0;
- }
- /* Non-proto is supported only for 5bit cplane and 18bit uplane */
- switch (sn_size) {
- case PDCP_SN_SIZE_5:
- offset = 7;
- length = 1;
- sn_mask = (swap == false) ? PDCP_C_PLANE_SN_MASK :
- PDCP_C_PLANE_SN_MASK_BE;
- break;
- case PDCP_SN_SIZE_18:
- offset = 5;
- length = 3;
- sn_mask = (swap == false) ? PDCP_U_PLANE_18BIT_SN_MASK :
- PDCP_U_PLANE_18BIT_SN_MASK_BE;
- break;
- case PDCP_SN_SIZE_7:
- case PDCP_SN_SIZE_12:
- case PDCP_SN_SIZE_15:
- pr_err("Invalid sn_size for %s\n", __func__);
- return -ENOTSUP;
-
- }
- SET_LABEL(p, keyjump);
- SEQLOAD(p, MATH0, offset, length, 0);
- JUMP(p, 1, LOCAL_JUMP, ALL_TRUE, CALM);
- MOVEB(p, MATH0, offset, IFIFOAB2, 0, length, IMMED);
- MATHB(p, MATH0, AND, sn_mask, MATH1, 8, IFB | IMMED2);
-
- MATHB(p, MATH1, SHLD, MATH1, MATH1, 8, 0);
- MOVEB(p, DESCBUF, 4, MATH2, 0, 8, WAITCOMP | IMMED);
- MATHB(p, MATH1, OR, MATH2, MATH1, 8, 0);
- MOVEB(p, MATH1, 0, CONTEXT1, 0, 8, IMMED);
- MOVEB(p, MATH1, 0, CONTEXT2, 0, 4, IMMED);
- if (swap == false) {
- MATHB(p, MATH1, AND, upper_32_bits(PDCP_BEARER_MASK), MATH2,
- 4, IMMED2);
- MATHB(p, MATH1, AND, lower_32_bits(PDCP_DIR_MASK), MATH3,
- 4, IMMED2);
- } else {
- MATHB(p, MATH1, AND, lower_32_bits(PDCP_BEARER_MASK_BE), MATH2,
- 4, IMMED2);
- MATHB(p, MATH1, AND, upper_32_bits(PDCP_DIR_MASK_BE), MATH3,
- 4, IMMED2);
- }
- MATHB(p, MATH3, SHLD, MATH3, MATH3, 8, 0);
- MOVEB(p, MATH2, 4, OFIFO, 0, 12, IMMED);
- MOVE(p, OFIFO, 0, CONTEXT2, 4, 12, IMMED);
-
- if (dir == OP_TYPE_ENCAP_PROTOCOL) {
- MATHB(p, SEQINSZ, ADD, PDCP_MAC_I_LEN, VSEQOUTSZ, 4, IMMED2);
- MATHB(p, SEQINSZ, SUB, ZERO, VSEQINSZ, 4, 0);
- } else {
- MATHB(p, SEQINSZ, SUB, PDCP_MAC_I_LEN, VSEQOUTSZ, 4, IMMED2);
- MATHB(p, VSEQOUTSZ, SUB, ZERO, VSEQINSZ, 4, 0);
- }
-
- SEQSTORE(p, MATH0, offset, length, 0);
-
- if (dir == OP_TYPE_ENCAP_PROTOCOL) {
- SEQFIFOSTORE(p, MSG, 0, 0, VLF);
- SEQFIFOLOAD(p, MSGINSNOOP, 0, VLF | LAST2);
- } else {
- SEQFIFOSTORE(p, MSG, 0, 0, VLF | CONT);
- SEQFIFOLOAD(p, MSGOUTSNOOP, 0, VLF | LAST2);
- }
-
- ALG_OPERATION(p, OP_ALG_ALGSEL_SNOW_F9,
- OP_ALG_AAI_F9,
- OP_ALG_AS_INITFINAL,
- dir == OP_TYPE_ENCAP_PROTOCOL ?
- ICV_CHECK_DISABLE : ICV_CHECK_ENABLE,
- DIR_DEC);
-
- ALG_OPERATION(p, OP_ALG_ALGSEL_ZUCE,
- OP_ALG_AAI_F8,
- OP_ALG_AS_INITFINAL,
- ICV_CHECK_DISABLE,
- dir == OP_TYPE_ENCAP_PROTOCOL ? DIR_ENC : DIR_DEC);
-
- if (dir == OP_TYPE_ENCAP_PROTOCOL) {
- MOVE(p, CONTEXT2, 0, IFIFOAB1, 0, 4, LAST1 | FLUSH1 | IMMED);
- } else {
- SEQFIFOLOAD(p, MSG1, 4, LAST1 | FLUSH1);
- JUMP(p, 1, LOCAL_JUMP, ALL_TRUE, CLASS1 | NOP | NIFP);
-
- if (rta_sec_era >= RTA_SEC_ERA_6)
- /*
- * For SEC ERA 6, there's a problem with the OFIFO
- * pointer, and thus it needs to be reset here before
- * moving to M0.
- */
- LOAD(p, 0, DCTRL, 0, LDLEN_RST_CHA_OFIFO_PTR, IMMED);
-
- /* Put ICV to M0 before sending it to C2 for comparison. */
- MOVEB(p, OFIFO, 0, MATH0, 0, 4, WAITCOMP | IMMED);
-
- LOAD(p, NFIFOENTRY_STYPE_ALTSOURCE |
- NFIFOENTRY_DEST_CLASS2 |
- NFIFOENTRY_DTYPE_ICV |
- NFIFOENTRY_LC2 | 4, NFIFO_SZL, 0, 4, IMMED);
- MOVEB(p, MATH0, 0, ALTSOURCE, 0, 4, IMMED);
- }
-
- PATCH_JUMP(p, pkeyjump, keyjump);
- return 0;
-}
-
-static inline int
-pdcp_insert_cplane_zuc_aes_op(struct program *p,
- bool swap __maybe_unused,
- struct alginfo *cipherdata,
- struct alginfo *authdata,
- unsigned int dir,
- enum pdcp_sn_size sn_size,
- unsigned char era_2_sw_hfn_ovrd __maybe_unused)
-{
- uint32_t offset = 0, length = 0, sn_mask = 0;
- if (rta_sec_era < RTA_SEC_ERA_5) {
- pr_err("Invalid era for selected algorithm\n");
- return -ENOTSUP;
- }
-
- if ((rta_sec_era >= RTA_SEC_ERA_8 && sn_size != PDCP_SN_SIZE_18) ||
- (rta_sec_era == RTA_SEC_ERA_10)) {
- int pclid;
-
- KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
- cipherdata->keylen, INLINE_KEY(cipherdata));
- KEY(p, KEY2, authdata->key_enc_flags, authdata->key,
- authdata->keylen, INLINE_KEY(authdata));
-
- if (sn_size == PDCP_SN_SIZE_5)
- pclid = OP_PCLID_LTE_PDCP_CTRL_MIXED;
- else
- pclid = OP_PCLID_LTE_PDCP_USER_RN;
-
- PROTOCOL(p, dir, pclid,
- ((uint16_t)cipherdata->algtype << 8) |
- (uint16_t)authdata->algtype);
- return 0;
- }
- /* Non-proto is supported only for 5bit cplane and 18bit uplane */
- switch (sn_size) {
- case PDCP_SN_SIZE_5:
- offset = 7;
- length = 1;
- sn_mask = (swap == false) ? PDCP_C_PLANE_SN_MASK :
- PDCP_C_PLANE_SN_MASK_BE;
- break;
- case PDCP_SN_SIZE_18:
- offset = 5;
- length = 3;
- sn_mask = (swap == false) ? PDCP_U_PLANE_18BIT_SN_MASK :
- PDCP_U_PLANE_18BIT_SN_MASK_BE;
- break;
- case PDCP_SN_SIZE_7:
- case PDCP_SN_SIZE_12:
- case PDCP_SN_SIZE_15:
- pr_err("Invalid sn_size for %s\n", __func__);
- return -ENOTSUP;
- }
-
- SEQLOAD(p, MATH0, offset, length, 0);
- JUMP(p, 1, LOCAL_JUMP, ALL_TRUE, CALM);
- MATHB(p, MATH0, AND, sn_mask, MATH1, 8, IFB | IMMED2);
-
- MATHB(p, MATH1, SHLD, MATH1, MATH1, 8, 0);
- MOVEB(p, DESCBUF, 4, MATH2, 0, 0x08, WAITCOMP | IMMED);
- MATHB(p, MATH1, OR, MATH2, MATH2, 8, 0);
- SEQSTORE(p, MATH0, offset, length, 0);
- if (dir == OP_TYPE_ENCAP_PROTOCOL) {
- KEY(p, KEY1, authdata->key_enc_flags, authdata->key,
- authdata->keylen, INLINE_KEY(authdata));
- MOVEB(p, MATH2, 0, IFIFOAB1, 0, 0x08, IMMED);
- MOVEB(p, MATH0, offset, IFIFOAB1, 0, length, IMMED);
-
- MATHB(p, SEQINSZ, SUB, ZERO, VSEQINSZ, 4, 0);
- MATHB(p, VSEQINSZ, ADD, PDCP_MAC_I_LEN, VSEQOUTSZ, 4, IMMED2);
-
- ALG_OPERATION(p, OP_ALG_ALGSEL_AES,
- OP_ALG_AAI_CMAC,
- OP_ALG_AS_INITFINAL,
- ICV_CHECK_DISABLE,
- DIR_DEC);
- SEQFIFOLOAD(p, MSG1, 0, VLF | LAST1 | FLUSH1);
- MOVEB(p, CONTEXT1, 0, MATH3, 0, 4, WAITCOMP | IMMED);
- LOAD(p, CLRW_RESET_CLS1_CHA |
- CLRW_CLR_C1KEY |
- CLRW_CLR_C1CTX |
- CLRW_CLR_C1ICV |
- CLRW_CLR_C1DATAS |
- CLRW_CLR_C1MODE,
- CLRW, 0, 4, IMMED);
-
- KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
- cipherdata->keylen, INLINE_KEY(cipherdata));
-
- MOVEB(p, MATH2, 0, CONTEXT1, 0, 8, IMMED);
- SEQINPTR(p, 0, PDCP_NULL_MAX_FRAME_LEN, RTO);
-
- ALG_OPERATION(p, OP_ALG_ALGSEL_ZUCE,
- OP_ALG_AAI_F8,
- OP_ALG_AS_INITFINAL,
- ICV_CHECK_DISABLE,
- DIR_ENC);
- SEQFIFOSTORE(p, MSG, 0, 0, VLF);
-
- SEQFIFOLOAD(p, SKIP, length, 0);
-
- SEQFIFOLOAD(p, MSG1, 0, VLF);
- MOVEB(p, MATH3, 0, IFIFOAB1, 0, 4, LAST1 | FLUSH1 | IMMED);
- } else {
- MOVEB(p, MATH2, 0, CONTEXT1, 0, 8, IMMED);
-
- MOVE(p, CONTEXT1, 0, CONTEXT2, 0, 8, IMMED);
-
- MATHB(p, SEQINSZ, SUB, ZERO, VSEQINSZ, 4, 0);
-
- MATHB(p, SEQINSZ, SUB, PDCP_MAC_I_LEN, VSEQOUTSZ, 4, IMMED2);
-
- KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
- cipherdata->keylen, INLINE_KEY(cipherdata));
-
- MOVE(p, CONTEXT1, 0, CONTEXT2, 0, 8, IMMED);
-
- ALG_OPERATION(p, OP_ALG_ALGSEL_ZUCE,
- OP_ALG_AAI_F8,
- OP_ALG_AS_INITFINAL,
- ICV_CHECK_DISABLE,
- DIR_DEC);
- SEQFIFOSTORE(p, MSG, 0, 0, VLF | CONT);
- SEQFIFOLOAD(p, MSG1, 0, VLF | LAST1 | FLUSH1);
-
- MOVEB(p, OFIFO, 0, MATH3, 0, 4, IMMED);
-
- LOAD(p, CLRW_RESET_CLS1_CHA |
- CLRW_CLR_C1KEY |
- CLRW_CLR_C1CTX |
- CLRW_CLR_C1ICV |
- CLRW_CLR_C1DATAS |
- CLRW_CLR_C1MODE,
- CLRW, 0, 4, IMMED);
-
- KEY(p, KEY1, authdata->key_enc_flags, authdata->key,
- authdata->keylen, INLINE_KEY(authdata));
-
- SEQINPTR(p, 0, 0, SOP);
-
- ALG_OPERATION(p, OP_ALG_ALGSEL_AES,
- OP_ALG_AAI_CMAC,
- OP_ALG_AS_INITFINAL,
- ICV_CHECK_ENABLE,
- DIR_DEC);
-
- MATHB(p, SEQINSZ, SUB, ZERO, VSEQINSZ, 4, 0);
-
- MOVE(p, CONTEXT2, 0, IFIFOAB1, 0, 8, IMMED);
-
- SEQFIFOLOAD(p, MSG1, 0, VLF | LAST1 | FLUSH1);
-
- LOAD(p, NFIFOENTRY_STYPE_ALTSOURCE |
- NFIFOENTRY_DEST_CLASS1 |
- NFIFOENTRY_DTYPE_ICV |
- NFIFOENTRY_LC1 |
- NFIFOENTRY_FC1 | 4, NFIFO_SZL, 0, 4, IMMED);
- MOVEB(p, MATH3, 0, ALTSOURCE, 0, 4, IMMED);
- }
-
- return 0;
-}
-
-static inline int
-pdcp_insert_uplane_no_int_op(struct program *p,
- bool swap __maybe_unused,
- struct alginfo *cipherdata,
- unsigned int dir,
- enum pdcp_sn_size sn_size)
-{
- int op;
- uint32_t sn_mask;
-
- /* Insert Cipher Key */
- KEY(p, KEY1, cipherdata->key_enc_flags, cipherdata->key,
- cipherdata->keylen, INLINE_KEY(cipherdata));
-
- if ((rta_sec_era >= RTA_SEC_ERA_8 && sn_size == PDCP_SN_SIZE_15) ||
- (rta_sec_era >= RTA_SEC_ERA_10)) {
- PROTOCOL(p, dir, OP_PCLID_LTE_PDCP_USER,
- (uint16_t)cipherdata->algtype);
- return 0;
- }
-
- if (sn_size == PDCP_SN_SIZE_15) {
- SEQLOAD(p, MATH0, 6, 2, 0);
- sn_mask = (swap == false) ? PDCP_U_PLANE_15BIT_SN_MASK :
- PDCP_U_PLANE_15BIT_SN_MASK_BE;
- } else { /* SN Size == PDCP_SN_SIZE_18 */
- SEQLOAD(p, MATH0, 5, 3, 0);
- sn_mask = (swap == false) ? PDCP_U_PLANE_18BIT_SN_MASK :
- PDCP_U_PLANE_18BIT_SN_MASK_BE;
- }
- JUMP(p, 1, LOCAL_JUMP, ALL_TRUE, CALM);
- MATHB(p, MATH0, AND, sn_mask, MATH1, 8, IFB | IMMED2);
-
- if (sn_size == PDCP_SN_SIZE_15)
- SEQSTORE(p, MATH0, 6, 2, 0);
- else /* SN Size == PDCP_SN_SIZE_18 */
- SEQSTORE(p, MATH0, 5, 3, 0);
-
- MATHB(p, MATH1, SHLD, MATH1, MATH1, 8, 0);
- MOVEB(p, DESCBUF, 8, MATH2, 0, 8, WAITCOMP | IMMED);
- MATHB(p, MATH1, OR, MATH2, MATH2, 8, 0);
-
- MATHB(p, SEQINSZ, SUB, MATH3, VSEQINSZ, 4, 0);
- MATHB(p, SEQINSZ, SUB, MATH3, VSEQOUTSZ, 4, 0);
-
- SEQFIFOSTORE(p, MSG, 0, 0, VLF);
-
- op = dir == OP_TYPE_ENCAP_PROTOCOL ? DIR_ENC : DIR_DEC;
- switch (cipherdata->algtype) {
- case PDCP_CIPHER_TYPE_SNOW:
- MOVEB(p, MATH2, 0, CONTEXT1, 0, 8, WAITCOMP | IMMED);
- ALG_OPERATION(p, OP_ALG_ALGSEL_SNOW_F8,
- OP_ALG_AAI_F8,
- OP_ALG_AS_INITFINAL,
- ICV_CHECK_DISABLE,
- op);
- break;
-
- case PDCP_CIPHER_TYPE_AES:
- MOVEB(p, MATH2, 0, CONTEXT1, 0x10, 0x10, WAITCOMP | IMMED);
- ALG_OPERATION(p, OP_ALG_ALGSEL_AES,
- OP_ALG_AAI_CTR,
- OP_ALG_AS_INITFINAL,
- ICV_CHECK_DISABLE,
- op);
- break;
-
- case PDCP_CIPHER_TYPE_ZUC:
- if (rta_sec_era < RTA_SEC_ERA_5) {
- pr_err("Invalid era for selected algorithm\n");
- return -ENOTSUP;
- }
- MOVEB(p, MATH2, 0, CONTEXT1, 0, 0x08, IMMED);
- MOVEB(p, MATH2, 0, CONTEXT1, 0x08, 0x08, WAITCOMP | IMMED);
-
- ALG_OPERATION(p, OP_ALG_ALGSEL_ZUCE,
- OP_ALG_AAI_F8,
- OP_ALG_AS_INITFINAL,
- ICV_CHECK_DISABLE,
- op);
- break;
-
- default:
- pr_err("%s: Invalid encrypt algorithm selected: %d\n",
- "pdcp_insert_uplane_15bit_op", cipherdata->algtype);
- return -EINVAL;
- }
-
- SEQFIFOLOAD(p, MSG1, 0, VLF | LAST1 | FLUSH1);
-
- return 0;
-}
-
-/*
- * Function for inserting the snippet of code responsible for creating
- * the HFN override code via either DPOVRD or via the input frame.
- */
-static inline int
-insert_hfn_ov_op(struct program *p,
- uint32_t shift,
- enum pdb_type_e pdb_type,
- unsigned char era_2_sw_hfn_ovrd)
-{
- uint32_t imm = PDCP_DPOVRD_HFN_OV_EN;
- uint16_t hfn_pdb_offset;
- LABEL(keyjump);
- REFERENCE(pkeyjump);
-
- if (rta_sec_era == RTA_SEC_ERA_2 && !era_2_sw_hfn_ovrd)
- return 0;
-
- switch (pdb_type) {
- case PDCP_PDB_TYPE_NO_PDB:
- /*
- * If there is no PDB, then HFN override mechanism does not
- * make any sense, thus in this case the function will
- * return the pointer to the current position in the
- * descriptor buffer
- */
- return 0;
-
- case PDCP_PDB_TYPE_REDUCED_PDB:
- hfn_pdb_offset = 4;
- break;
-
- case PDCP_PDB_TYPE_FULL_PDB:
- hfn_pdb_offset = 8;
- break;
-
- default:
- return -EINVAL;
- }
-
- if (rta_sec_era > RTA_SEC_ERA_2) {
- MATHB(p, DPOVRD, AND, imm, NONE, 8, IFB | IMMED2);
- } else {
- SEQLOAD(p, MATH0, 4, 4, 0);
- JUMP(p, 1, LOCAL_JUMP, ALL_TRUE, CALM);
- MATHB(p, MATH0, AND, imm, NONE, 8, IFB | IMMED2);
- SEQSTORE(p, MATH0, 4, 4, 0);
- }
-
- pkeyjump = JUMP(p, keyjump, LOCAL_JUMP, ALL_TRUE, MATH_Z);
-
- if (rta_sec_era > RTA_SEC_ERA_2)
- MATHI(p, DPOVRD, LSHIFT, shift, MATH0, 4, IMMED2);
- else
- MATHB(p, MATH0, LSHIFT, shift, MATH0, 4, IMMED2);
-
- MATHB(p, MATH0, SHLD, MATH0, MATH0, 8, 0);
- MOVE(p, MATH0, 0, DESCBUF, hfn_pdb_offset, 4, IMMED);
-
- if (rta_sec_era >= RTA_SEC_ERA_8)
- /*
- * For ERA8, DPOVRD could be handled by the PROTOCOL command
- * itself. For now, this is not done. Thus, clear DPOVRD here
- * to alleviate any side-effects.
- */
- MATHB(p, DPOVRD, AND, ZERO, DPOVRD, 4, STL);
-
- SET_LABEL(p, keyjump);
- PATCH_JUMP(p, pkeyjump, keyjump);
- return 0;
-}
-
-/*
- * PDCP Control PDB creation function
- */
-static inline enum pdb_type_e
-cnstr_pdcp_c_plane_pdb(struct program *p,
- uint32_t hfn,
- enum pdcp_sn_size sn_size,
- unsigned char bearer,
- unsigned char direction,
- uint32_t hfn_threshold,
- struct alginfo *cipherdata,
- struct alginfo *authdata)
-{
- struct pdcp_pdb pdb;
- enum pdb_type_e
- pdb_mask[PDCP_CIPHER_TYPE_INVALID][PDCP_AUTH_TYPE_INVALID] = {
- { /* NULL */
- PDCP_PDB_TYPE_NO_PDB, /* NULL */
- PDCP_PDB_TYPE_FULL_PDB, /* SNOW f9 */
- PDCP_PDB_TYPE_FULL_PDB, /* AES CMAC */
- PDCP_PDB_TYPE_FULL_PDB /* ZUC-I */
- },
- { /* SNOW f8 */
- PDCP_PDB_TYPE_FULL_PDB, /* NULL */
- PDCP_PDB_TYPE_FULL_PDB, /* SNOW f9 */
- PDCP_PDB_TYPE_REDUCED_PDB, /* AES CMAC */
- PDCP_PDB_TYPE_REDUCED_PDB /* ZUC-I */
- },
- { /* AES CTR */
- PDCP_PDB_TYPE_FULL_PDB, /* NULL */
- PDCP_PDB_TYPE_REDUCED_PDB, /* SNOW f9 */
- PDCP_PDB_TYPE_FULL_PDB, /* AES CMAC */
- PDCP_PDB_TYPE_REDUCED_PDB /* ZUC-I */
- },
- { /* ZUC-E */
- PDCP_PDB_TYPE_FULL_PDB, /* NULL */
- PDCP_PDB_TYPE_REDUCED_PDB, /* SNOW f9 */
- PDCP_PDB_TYPE_REDUCED_PDB, /* AES CMAC */
- PDCP_PDB_TYPE_FULL_PDB /* ZUC-I */
- },
- };
-
- if (rta_sec_era >= RTA_SEC_ERA_8) {
- memset(&pdb, 0x00, sizeof(struct pdcp_pdb));
-
- /* To support 12-bit seq numbers, we use u-plane opt in pdb.
- * SEC supports 5-bit only with c-plane opt in pdb.
- */
- if (sn_size == PDCP_SN_SIZE_12) {
- pdb.hfn_res = hfn << PDCP_U_PLANE_PDB_LONG_SN_HFN_SHIFT;
- pdb.bearer_dir_res = (uint32_t)
- ((bearer << PDCP_U_PLANE_PDB_BEARER_SHIFT) |
- (direction << PDCP_U_PLANE_PDB_DIR_SHIFT));
-
- pdb.hfn_thr_res =
- hfn_threshold << PDCP_U_PLANE_PDB_LONG_SN_HFN_THR_SHIFT;
-
- } else {
- /* This means 5-bit c-plane.
- * Here we use c-plane opt in pdb
- */
-
- /* This is a HW issue. Bit 2 should be set to zero,
- * but it does not work this way. Override here.
- */
- pdb.opt_res.rsvd = 0x00000002;
-
- /* Copy relevant information from user to PDB */
- pdb.hfn_res = hfn << PDCP_C_PLANE_PDB_HFN_SHIFT;
- pdb.bearer_dir_res = (uint32_t)
- ((bearer << PDCP_C_PLANE_PDB_BEARER_SHIFT) |
- (direction << PDCP_C_PLANE_PDB_DIR_SHIFT));
- pdb.hfn_thr_res =
- hfn_threshold << PDCP_C_PLANE_PDB_HFN_THR_SHIFT;
- }
-
- /* copy PDB in descriptor*/
- __rta_out32(p, pdb.opt_res.opt);
- __rta_out32(p, pdb.hfn_res);
- __rta_out32(p, pdb.bearer_dir_res);
- __rta_out32(p, pdb.hfn_thr_res);
-
- return PDCP_PDB_TYPE_FULL_PDB;
- }
-
- switch (pdb_mask[cipherdata->algtype][authdata->algtype]) {
- case PDCP_PDB_TYPE_NO_PDB:
- break;
-
- case PDCP_PDB_TYPE_REDUCED_PDB:
- __rta_out32(p, (hfn << PDCP_C_PLANE_PDB_HFN_SHIFT));
- __rta_out32(p,
- (uint32_t)((bearer <<
- PDCP_C_PLANE_PDB_BEARER_SHIFT) |
- (direction <<
- PDCP_C_PLANE_PDB_DIR_SHIFT)));
- break;
-
- case PDCP_PDB_TYPE_FULL_PDB:
- memset(&pdb, 0x00, sizeof(struct pdcp_pdb));
-
- /* This is a HW issue. Bit 2 should be set to zero,
- * but it does not work this way. Override here.
- */
- pdb.opt_res.rsvd = 0x00000002;
-
- /* Copy relevant information from user to PDB */
- pdb.hfn_res = hfn << PDCP_C_PLANE_PDB_HFN_SHIFT;
- pdb.bearer_dir_res = (uint32_t)
- ((bearer << PDCP_C_PLANE_PDB_BEARER_SHIFT) |
- (direction << PDCP_C_PLANE_PDB_DIR_SHIFT));
- pdb.hfn_thr_res =
- hfn_threshold << PDCP_C_PLANE_PDB_HFN_THR_SHIFT;
-
- /* copy PDB in descriptor*/
- __rta_out32(p, pdb.opt_res.opt);
- __rta_out32(p, pdb.hfn_res);
- __rta_out32(p, pdb.bearer_dir_res);
- __rta_out32(p, pdb.hfn_thr_res);
-
- break;
-
- default:
- return PDCP_PDB_TYPE_INVALID;
- }
-
- return pdb_mask[cipherdata->algtype][authdata->algtype];
-}
-
-/*
- * PDCP UPlane PDB creation function
- */
-static inline enum pdb_type_e
-cnstr_pdcp_u_plane_pdb(struct program *p,
- enum pdcp_sn_size sn_size,
- uint32_t hfn, unsigned short bearer,
- unsigned short direction,
- uint32_t hfn_threshold,
- struct alginfo *cipherdata,
- struct alginfo *authdata)
-{
- struct pdcp_pdb pdb;
- enum pdb_type_e pdb_type = PDCP_PDB_TYPE_FULL_PDB;
- enum pdb_type_e
- pdb_mask[PDCP_CIPHER_TYPE_INVALID][PDCP_AUTH_TYPE_INVALID] = {
- { /* NULL */
- PDCP_PDB_TYPE_NO_PDB, /* NULL */
- PDCP_PDB_TYPE_FULL_PDB, /* SNOW f9 */
- PDCP_PDB_TYPE_FULL_PDB, /* AES CMAC */
- PDCP_PDB_TYPE_FULL_PDB /* ZUC-I */
- },
- { /* SNOW f8 */
- PDCP_PDB_TYPE_FULL_PDB, /* NULL */
- PDCP_PDB_TYPE_FULL_PDB, /* SNOW f9 */
- PDCP_PDB_TYPE_REDUCED_PDB, /* AES CMAC */
- PDCP_PDB_TYPE_REDUCED_PDB /* ZUC-I */
- },
- { /* AES CTR */
- PDCP_PDB_TYPE_FULL_PDB, /* NULL */
- PDCP_PDB_TYPE_REDUCED_PDB, /* SNOW f9 */
- PDCP_PDB_TYPE_FULL_PDB, /* AES CMAC */
- PDCP_PDB_TYPE_REDUCED_PDB /* ZUC-I */
- },
- { /* ZUC-E */
- PDCP_PDB_TYPE_FULL_PDB, /* NULL */
- PDCP_PDB_TYPE_REDUCED_PDB, /* SNOW f9 */
- PDCP_PDB_TYPE_REDUCED_PDB, /* AES CMAC */
- PDCP_PDB_TYPE_FULL_PDB /* ZUC-I */
- },
- };
-
- /* Read options from user */
- /* Depending on sequence number length, the HFN and HFN threshold
- * have different lengths.
- */
- memset(&pdb, 0x00, sizeof(struct pdcp_pdb));
-
- switch (sn_size) {
- case PDCP_SN_SIZE_7:
- pdb.opt_res.opt |= PDCP_U_PLANE_PDB_OPT_SHORT_SN;
- pdb.hfn_res = hfn << PDCP_U_PLANE_PDB_SHORT_SN_HFN_SHIFT;
- pdb.hfn_thr_res =
- hfn_threshold<<PDCP_U_PLANE_PDB_SHORT_SN_HFN_THR_SHIFT;
- break;
-
- case PDCP_SN_SIZE_12:
- pdb.opt_res.opt &= (uint32_t)(~PDCP_U_PLANE_PDB_OPT_SHORT_SN);
- pdb.hfn_res = hfn << PDCP_U_PLANE_PDB_LONG_SN_HFN_SHIFT;
- pdb.hfn_thr_res =
- hfn_threshold<<PDCP_U_PLANE_PDB_LONG_SN_HFN_THR_SHIFT;
- break;
-
- case PDCP_SN_SIZE_15:
- pdb.opt_res.opt = (uint32_t)(PDCP_U_PLANE_PDB_OPT_15B_SN);
- pdb.hfn_res = hfn << PDCP_U_PLANE_PDB_15BIT_SN_HFN_SHIFT;
- pdb.hfn_thr_res =
- hfn_threshold<<PDCP_U_PLANE_PDB_15BIT_SN_HFN_THR_SHIFT;
- break;
-
- case PDCP_SN_SIZE_18:
- pdb.opt_res.opt = (uint32_t)(PDCP_U_PLANE_PDB_OPT_18B_SN);
- pdb.hfn_res = hfn << PDCP_U_PLANE_PDB_18BIT_SN_HFN_SHIFT;
- pdb.hfn_thr_res =
- hfn_threshold<<PDCP_U_PLANE_PDB_18BIT_SN_HFN_THR_SHIFT;
-
- if (rta_sec_era <= RTA_SEC_ERA_8) {
- if (cipherdata && authdata)
- pdb_type = pdb_mask[cipherdata->algtype]
- [authdata->algtype];
- }
- break;
-
- default:
- pr_err("Invalid Sequence Number Size setting in PDB\n");
- return -EINVAL;
- }
-
- pdb.bearer_dir_res = (uint32_t)
- ((bearer << PDCP_U_PLANE_PDB_BEARER_SHIFT) |
- (direction << PDCP_U_PLANE_PDB_DIR_SHIFT));
-
- switch (pdb_type) {
- case PDCP_PDB_TYPE_NO_PDB:
- break;
-
- case PDCP_PDB_TYPE_REDUCED_PDB:
- __rta_out32(p, pdb.hfn_res);
- __rta_out32(p, pdb.bearer_dir_res);
- break;
-
- case PDCP_PDB_TYPE_FULL_PDB:
- /* copy PDB in descriptor*/
- __rta_out32(p, pdb.opt_res.opt);
- __rta_out32(p, pdb.hfn_res);
- __rta_out32(p, pdb.bearer_dir_res);
- __rta_out32(p, pdb.hfn_thr_res);
-
- break;
-
- default:
- return PDCP_PDB_TYPE_INVALID;
- }
-
- return pdb_type;
-}
-/**
- * cnstr_shdsc_pdcp_c_plane_encap - Function for creating a PDCP Control Plane
- * encapsulation descriptor.
- * @descbuf: pointer to buffer for descriptor construction
- * @ps: if 36/40bit addressing is desired, this parameter must be true
- * @swap: must be true when core endianness doesn't match SEC endianness
- * @hfn: starting Hyper Frame Number to be used together with the SN from the
- * PDCP frames.
- * @sn_size: size of sequence numbers, only 5/12 bit sequence numbers are valid
- * @bearer: radio bearer ID
- * @direction: the direction of the PDCP frame (UL/DL)
- * @hfn_threshold: HFN value that once reached triggers a warning from SEC that
- * keys should be renegotiated at the earliest convenience.
- * @cipherdata: pointer to block cipher transform definitions
- * Valid algorithm values are those from cipher_type_pdcp enum.
- * @authdata: pointer to authentication transform definitions
- * Valid algorithm values are those from auth_type_pdcp enum.
- * @era_2_sw_hfn_ovrd: if software HFN override mechanism is desired for
- * this descriptor. Note: Can only be used for
- * SEC ERA 2.
- * Return: size of descriptor written in words or negative number on error.
- * Once the function returns, the value of this parameter can be used
- * for reclaiming the space that wasn't used for the descriptor.
- *
- * Note: descbuf must be large enough to contain a full 256 byte long
- * descriptor; after the function returns, by subtracting the actual number of
- * bytes used, the user can reuse the remaining buffer space for other purposes.
- */
-static inline int
-cnstr_shdsc_pdcp_c_plane_encap(uint32_t *descbuf,
- bool ps,
- bool swap,
- uint32_t hfn,
- enum pdcp_sn_size sn_size,
- unsigned char bearer,
- unsigned char direction,
- uint32_t hfn_threshold,
- struct alginfo *cipherdata,
- struct alginfo *authdata,
- unsigned char era_2_sw_hfn_ovrd)
-{
- static int
- (*pdcp_cp_fp[PDCP_CIPHER_TYPE_INVALID][PDCP_AUTH_TYPE_INVALID])
- (struct program*, bool swap, struct alginfo *,
- struct alginfo *, unsigned int, enum pdcp_sn_size,
- unsigned char __maybe_unused) = {
- { /* NULL */
- pdcp_insert_cplane_null_op, /* NULL */
- pdcp_insert_cplane_int_only_op, /* SNOW f9 */
- pdcp_insert_cplane_int_only_op, /* AES CMAC */
- pdcp_insert_cplane_int_only_op /* ZUC-I */
- },
- { /* SNOW f8 */
- pdcp_insert_cplane_enc_only_op, /* NULL */
- pdcp_insert_cplane_acc_op, /* SNOW f9 */
- pdcp_insert_cplane_snow_aes_op, /* AES CMAC */
- pdcp_insert_cplane_snow_zuc_op /* ZUC-I */
- },
- { /* AES CTR */
- pdcp_insert_cplane_enc_only_op, /* NULL */
- pdcp_insert_cplane_aes_snow_op, /* SNOW f9 */
- pdcp_insert_cplane_acc_op, /* AES CMAC */
- pdcp_insert_cplane_aes_zuc_op /* ZUC-I */
- },
- { /* ZUC-E */
- pdcp_insert_cplane_enc_only_op, /* NULL */
- pdcp_insert_cplane_zuc_snow_op, /* SNOW f9 */
- pdcp_insert_cplane_zuc_aes_op, /* AES CMAC */
- pdcp_insert_cplane_acc_op /* ZUC-I */
- },
- };
- static enum rta_share_type
- desc_share[PDCP_CIPHER_TYPE_INVALID][PDCP_AUTH_TYPE_INVALID] = {
- { /* NULL */
- SHR_WAIT, /* NULL */
- SHR_ALWAYS, /* SNOW f9 */
- SHR_ALWAYS, /* AES CMAC */
- SHR_ALWAYS /* ZUC-I */
- },
- { /* SNOW f8 */
- SHR_ALWAYS, /* NULL */
- SHR_ALWAYS, /* SNOW f9 */
- SHR_WAIT, /* AES CMAC */
- SHR_WAIT /* ZUC-I */
- },
- { /* AES CTR */
- SHR_ALWAYS, /* NULL */
- SHR_ALWAYS, /* SNOW f9 */
- SHR_ALWAYS, /* AES CMAC */
- SHR_WAIT /* ZUC-I */
- },
- { /* ZUC-E */
- SHR_ALWAYS, /* NULL */
- SHR_WAIT, /* SNOW f9 */
- SHR_WAIT, /* AES CMAC */
- SHR_ALWAYS /* ZUC-I */
- },
- };
- enum pdb_type_e pdb_type;
- struct program prg;
- struct program *p = &prg;
- int err;
- LABEL(pdb_end);
-
- if (rta_sec_era != RTA_SEC_ERA_2 && era_2_sw_hfn_ovrd) {
- pr_err("Cannot select SW HFN override for other era than 2");
- return -EINVAL;
- }
-
- if (sn_size != PDCP_SN_SIZE_12 && sn_size != PDCP_SN_SIZE_5) {
- pr_err("C-plane supports only 5-bit and 12-bit sequence numbers\n");
- return -EINVAL;
- }
-
- PROGRAM_CNTXT_INIT(p, descbuf, 0);
- if (swap)
- PROGRAM_SET_BSWAP(p);
- if (ps)
- PROGRAM_SET_36BIT_ADDR(p);
-
- SHR_HDR(p, desc_share[cipherdata->algtype][authdata->algtype], 0, 0);
-
- pdb_type = cnstr_pdcp_c_plane_pdb(p,
- hfn,
- sn_size,
- bearer,
- direction,
- hfn_threshold,
- cipherdata,
- authdata);
-
- SET_LABEL(p, pdb_end);
-
- err = insert_hfn_ov_op(p, sn_size, pdb_type,
- era_2_sw_hfn_ovrd);
- if (err)
- return err;
-
- err = pdcp_cp_fp[cipherdata->algtype][authdata->algtype](p,
- swap,
- cipherdata,
- authdata,
- OP_TYPE_ENCAP_PROTOCOL,
- sn_size,
- era_2_sw_hfn_ovrd);
- if (err)
- return err;
-
- PATCH_HDR(p, 0, pdb_end);
-
- return PROGRAM_FINALIZE(p);
-}
-
-/**
- * cnstr_shdsc_pdcp_c_plane_decap - Function for creating a PDCP Control Plane
- * decapsulation descriptor.
- * @descbuf: pointer to buffer for descriptor construction
- * @ps: if 36/40bit addressing is desired, this parameter must be true
- * @swap: must be true when core endianness doesn't match SEC endianness
- * @hfn: starting Hyper Frame Number to be used together with the SN from the
- * PDCP frames.
- * @sn_size: size of sequence numbers, only 5/12 bit sequence numbers are valid
- * @bearer: radio bearer ID
- * @direction: the direction of the PDCP frame (UL/DL)
- * @hfn_threshold: HFN value that once reached triggers a warning from SEC that
- * keys should be renegotiated at the earliest convenience.
- * @cipherdata: pointer to block cipher transform definitions
- * Valid algorithm values are those from cipher_type_pdcp enum.
- * @authdata: pointer to authentication transform definitions
- * Valid algorithm values are those from auth_type_pdcp enum.
- * @era_2_sw_hfn_ovrd: if software HFN override mechanism is desired for
- * this descriptor. Note: Can only be used for
- * SEC ERA 2.
- *
- * Return: size of descriptor written in words or negative number on error.
- * Once the function returns, the value of this parameter can be used
- * for reclaiming the space that wasn't used for the descriptor.
- *
- * Note: descbuf must be large enough to contain a full 256 byte long
- * descriptor; after the function returns, by subtracting the actual number of
- * bytes used, the user can reuse the remaining buffer space for other purposes.
- */
-static inline int
-cnstr_shdsc_pdcp_c_plane_decap(uint32_t *descbuf,
- bool ps,
- bool swap,
- uint32_t hfn,
- enum pdcp_sn_size sn_size,
- unsigned char bearer,
- unsigned char direction,
- uint32_t hfn_threshold,
- struct alginfo *cipherdata,
- struct alginfo *authdata,
- unsigned char era_2_sw_hfn_ovrd)
-{
- static int
- (*pdcp_cp_fp[PDCP_CIPHER_TYPE_INVALID][PDCP_AUTH_TYPE_INVALID])
- (struct program*, bool swap, struct alginfo *,
- struct alginfo *, unsigned int, enum pdcp_sn_size,
- unsigned char) = {
- { /* NULL */
- pdcp_insert_cplane_null_op, /* NULL */
- pdcp_insert_cplane_int_only_op, /* SNOW f9 */
- pdcp_insert_cplane_int_only_op, /* AES CMAC */
- pdcp_insert_cplane_int_only_op /* ZUC-I */
- },
- { /* SNOW f8 */
- pdcp_insert_cplane_enc_only_op, /* NULL */
- pdcp_insert_cplane_acc_op, /* SNOW f9 */
- pdcp_insert_cplane_snow_aes_op, /* AES CMAC */
- pdcp_insert_cplane_snow_zuc_op /* ZUC-I */
- },
- { /* AES CTR */
- pdcp_insert_cplane_enc_only_op, /* NULL */
- pdcp_insert_cplane_aes_snow_op, /* SNOW f9 */
- pdcp_insert_cplane_acc_op, /* AES CMAC */
- pdcp_insert_cplane_aes_zuc_op /* ZUC-I */
- },
- { /* ZUC-E */
- pdcp_insert_cplane_enc_only_op, /* NULL */
- pdcp_insert_cplane_zuc_snow_op, /* SNOW f9 */
- pdcp_insert_cplane_zuc_aes_op, /* AES CMAC */
- pdcp_insert_cplane_acc_op /* ZUC-I */
- },
- };
- static enum rta_share_type
- desc_share[PDCP_CIPHER_TYPE_INVALID][PDCP_AUTH_TYPE_INVALID] = {
- { /* NULL */
- SHR_WAIT, /* NULL */
- SHR_ALWAYS, /* SNOW f9 */
- SHR_ALWAYS, /* AES CMAC */
- SHR_ALWAYS /* ZUC-I */
- },
- { /* SNOW f8 */
- SHR_ALWAYS, /* NULL */
- SHR_ALWAYS, /* SNOW f9 */
- SHR_WAIT, /* AES CMAC */
- SHR_WAIT /* ZUC-I */
- },
- { /* AES CTR */
- SHR_ALWAYS, /* NULL */
- SHR_ALWAYS, /* SNOW f9 */
- SHR_ALWAYS, /* AES CMAC */
- SHR_WAIT /* ZUC-I */
- },
- { /* ZUC-E */
- SHR_ALWAYS, /* NULL */
- SHR_WAIT, /* SNOW f9 */
- SHR_WAIT, /* AES CMAC */
- SHR_ALWAYS /* ZUC-I */
- },
- };
- enum pdb_type_e pdb_type;
- struct program prg;
- struct program *p = &prg;
- int err;
- LABEL(pdb_end);
-
- if (rta_sec_era != RTA_SEC_ERA_2 && era_2_sw_hfn_ovrd) {
- pr_err("Cannot select SW HFN override for other era than 2");
- return -EINVAL;
- }
-
- if (sn_size != PDCP_SN_SIZE_12 && sn_size != PDCP_SN_SIZE_5) {
- pr_err("C-plane supports only 5-bit and 12-bit sequence numbers\n");
- return -EINVAL;
- }
-
- PROGRAM_CNTXT_INIT(p, descbuf, 0);
- if (swap)
- PROGRAM_SET_BSWAP(p);
- if (ps)
- PROGRAM_SET_36BIT_ADDR(p);
-
- SHR_HDR(p, desc_share[cipherdata->algtype][authdata->algtype], 0, 0);
-
- pdb_type = cnstr_pdcp_c_plane_pdb(p,
- hfn,
- sn_size,
- bearer,
- direction,
- hfn_threshold,
- cipherdata,
- authdata);
-
- SET_LABEL(p, pdb_end);
-
- err = insert_hfn_ov_op(p, sn_size, pdb_type,
- era_2_sw_hfn_ovrd);
- if (err)
- return err;
-
- err = pdcp_cp_fp[cipherdata->algtype][authdata->algtype](p,
- swap,
- cipherdata,
- authdata,
- OP_TYPE_DECAP_PROTOCOL,
- sn_size,
- era_2_sw_hfn_ovrd);
- if (err)
- return err;
-
- PATCH_HDR(p, 0, pdb_end);
-
- return PROGRAM_FINALIZE(p);
-}
-
-static int
-pdcp_insert_uplane_with_int_op(struct program *p,
- bool swap __maybe_unused,
- struct alginfo *cipherdata,
- struct alginfo *authdata,
- enum pdcp_sn_size sn_size,
- unsigned char era_2_sw_hfn_ovrd,
- unsigned int dir)
-{
- static int
- (*pdcp_cp_fp[PDCP_CIPHER_TYPE_INVALID][PDCP_AUTH_TYPE_INVALID])
- (struct program*, bool swap, struct alginfo *,
- struct alginfo *, unsigned int, enum pdcp_sn_size,
- unsigned char __maybe_unused) = {
- { /* NULL */
- pdcp_insert_cplane_null_op, /* NULL */
- pdcp_insert_cplane_int_only_op, /* SNOW f9 */
- pdcp_insert_cplane_int_only_op, /* AES CMAC */
- pdcp_insert_cplane_int_only_op /* ZUC-I */
- },
- { /* SNOW f8 */
- pdcp_insert_cplane_enc_only_op, /* NULL */
- pdcp_insert_uplane_snow_snow_op, /* SNOW f9 */
- pdcp_insert_cplane_snow_aes_op, /* AES CMAC */
- pdcp_insert_cplane_snow_zuc_op /* ZUC-I */
- },
- { /* AES CTR */
- pdcp_insert_cplane_enc_only_op, /* NULL */
- pdcp_insert_cplane_aes_snow_op, /* SNOW f9 */
- pdcp_insert_uplane_aes_aes_op, /* AES CMAC */
- pdcp_insert_cplane_aes_zuc_op /* ZUC-I */
- },
- { /* ZUC-E */
- pdcp_insert_cplane_enc_only_op, /* NULL */
- pdcp_insert_cplane_zuc_snow_op, /* SNOW f9 */
- pdcp_insert_cplane_zuc_aes_op, /* AES CMAC */
- pdcp_insert_uplane_zuc_zuc_op /* ZUC-I */
- },
- };
- int err;
-
- err = pdcp_cp_fp[cipherdata->algtype][authdata->algtype](p,
- swap,
- cipherdata,
- authdata,
- dir,
- sn_size,
- era_2_sw_hfn_ovrd);
- if (err)
- return err;
-
- return 0;
-}
-
-
-/**
- * cnstr_shdsc_pdcp_u_plane_encap - Function for creating a PDCP User Plane
- * encapsulation descriptor.
- * @descbuf: pointer to buffer for descriptor construction
- * @ps: if 36/40bit addressing is desired, this parameter must be true
- * @swap: must be true when core endianness doesn't match SEC endianness
- * @sn_size: selects Sequence Number Size: 7/12/15 bits
- * @hfn: starting Hyper Frame Number to be used together with the SN from the
- * PDCP frames.
- * @bearer: radio bearer ID
- * @direction: the direction of the PDCP frame (UL/DL)
- * @hfn_threshold: HFN value that once reached triggers a warning from SEC that
- * keys should be renegotiated at the earliest convenience.
- * @cipherdata: pointer to block cipher transform definitions
- * Valid algorithm values are those from cipher_type_pdcp enum.
- * @era_2_sw_hfn_ovrd: if software HFN override mechanism is desired for
- * this descriptor. Note: Can only be used for
- * SEC ERA 2.
- *
- * Return: size of descriptor written in words or negative number on error.
- * Once the function returns, the value of this parameter can be used
- * for reclaiming the space that wasn't used for the descriptor.
- *
- * Note: descbuf must be large enough to contain a full 256 byte long
- * descriptor; after the function returns, by subtracting the actual number of
- * bytes used, the user can reuse the remaining buffer space for other purposes.
- */
-static inline int
-cnstr_shdsc_pdcp_u_plane_encap(uint32_t *descbuf,
- bool ps,
- bool swap,
- enum pdcp_sn_size sn_size,
- uint32_t hfn,
- unsigned short bearer,
- unsigned short direction,
- uint32_t hfn_threshold,
- struct alginfo *cipherdata,
- struct alginfo *authdata,
- unsigned char era_2_sw_hfn_ovrd)
-{
- struct program prg;
- struct program *p = &prg;
- int err;
- enum pdb_type_e pdb_type;
- static enum rta_share_type
- desc_share[PDCP_CIPHER_TYPE_INVALID][PDCP_AUTH_TYPE_INVALID] = {
- { /* NULL */
- SHR_WAIT, /* NULL */
- SHR_ALWAYS, /* SNOW f9 */
- SHR_ALWAYS, /* AES CMAC */
- SHR_ALWAYS /* ZUC-I */
- },
- { /* SNOW f8 */
- SHR_ALWAYS, /* NULL */
- SHR_ALWAYS, /* SNOW f9 */
- SHR_WAIT, /* AES CMAC */
- SHR_WAIT /* ZUC-I */
- },
- { /* AES CTR */
- SHR_ALWAYS, /* NULL */
- SHR_ALWAYS, /* SNOW f9 */
- SHR_ALWAYS, /* AES CMAC */
- SHR_WAIT /* ZUC-I */
- },
- { /* ZUC-E */
- SHR_ALWAYS, /* NULL */
- SHR_WAIT, /* SNOW f9 */
- SHR_WAIT, /* AES CMAC */
- SHR_ALWAYS /* ZUC-I */
- },
- };
- LABEL(pdb_end);
-
- if (rta_sec_era != RTA_SEC_ERA_2 && era_2_sw_hfn_ovrd) {
- pr_err("Cannot select SW HFN ovrd for other era than 2");
- return -EINVAL;
- }
-
- if (authdata && !authdata->algtype && rta_sec_era < RTA_SEC_ERA_8) {
- pr_err("Cannot use u-plane auth with era < 8");
- return -EINVAL;
- }
-
- PROGRAM_CNTXT_INIT(p, descbuf, 0);
- if (swap)
- PROGRAM_SET_BSWAP(p);
- if (ps)
- PROGRAM_SET_36BIT_ADDR(p);
-
- if (authdata)
- SHR_HDR(p, desc_share[cipherdata->algtype][authdata->algtype], 0, 0);
- else
- SHR_HDR(p, SHR_ALWAYS, 0, 0);
- pdb_type = cnstr_pdcp_u_plane_pdb(p, sn_size, hfn,
- bearer, direction, hfn_threshold,
- cipherdata, authdata);
- if (pdb_type == PDCP_PDB_TYPE_INVALID) {
- pr_err("Error creating PDCP UPlane PDB\n");
- return -EINVAL;
- }
- SET_LABEL(p, pdb_end);
-
- err = insert_hfn_ov_op(p, sn_size, pdb_type, era_2_sw_hfn_ovrd);
- if (err)
- return err;
-
- switch (sn_size) {
- case PDCP_SN_SIZE_7:
- case PDCP_SN_SIZE_12:
- switch (cipherdata->algtype) {
- case PDCP_CIPHER_TYPE_ZUC:
- if (rta_sec_era < RTA_SEC_ERA_5) {
- pr_err("Invalid era for selected algorithm\n");
- return -ENOTSUP;
- }
- /* fallthrough */
- case PDCP_CIPHER_TYPE_AES:
- case PDCP_CIPHER_TYPE_SNOW:
- case PDCP_CIPHER_TYPE_NULL:
- if (rta_sec_era == RTA_SEC_ERA_8 &&
- authdata && authdata->algtype == 0){
- err = pdcp_insert_uplane_with_int_op(p, swap,
- cipherdata, authdata,
- sn_size, era_2_sw_hfn_ovrd,
- OP_TYPE_ENCAP_PROTOCOL);
- if (err)
- return err;
- break;
- }
-
- if (pdb_type != PDCP_PDB_TYPE_FULL_PDB) {
- pr_err("PDB type must be FULL for PROTO desc\n");
- return -EINVAL;
- }
-
- /* Insert auth key if requested */
- if (authdata && authdata->algtype) {
- KEY(p, KEY2, authdata->key_enc_flags,
- (uint64_t)authdata->key, authdata->keylen,
- INLINE_KEY(authdata));
- }
- /* Insert Cipher Key */
- KEY(p, KEY1, cipherdata->key_enc_flags,
- (uint64_t)cipherdata->key, cipherdata->keylen,
- INLINE_KEY(cipherdata));
-
- if (authdata)
- PROTOCOL(p, OP_TYPE_ENCAP_PROTOCOL,
- OP_PCLID_LTE_PDCP_USER_RN,
- ((uint16_t)cipherdata->algtype << 8) |
- (uint16_t)authdata->algtype);
- else
- PROTOCOL(p, OP_TYPE_ENCAP_PROTOCOL,
- OP_PCLID_LTE_PDCP_USER,
- (uint16_t)cipherdata->algtype);
- break;
- default:
- pr_err("%s: Invalid encrypt algorithm selected: %d\n",
- "cnstr_pcl_shdsc_pdcp_u_plane_decap",
- cipherdata->algtype);
- return -EINVAL;
- }
- break;
-
- case PDCP_SN_SIZE_15:
- case PDCP_SN_SIZE_18:
- if (authdata) {
- err = pdcp_insert_uplane_with_int_op(p, swap,
- cipherdata, authdata,
- sn_size, era_2_sw_hfn_ovrd,
- OP_TYPE_ENCAP_PROTOCOL);
- if (err)
- return err;
-
- break;
- }
-
- switch (cipherdata->algtype) {
- case PDCP_CIPHER_TYPE_NULL:
- insert_copy_frame_op(p,
- cipherdata,
- OP_TYPE_ENCAP_PROTOCOL);
- break;
-
- default:
- err = pdcp_insert_uplane_no_int_op(p, swap, cipherdata,
- OP_TYPE_ENCAP_PROTOCOL, sn_size);
- if (err)
- return err;
- break;
- }
- break;
-
- case PDCP_SN_SIZE_5:
- default:
- pr_err("Invalid SN size selected\n");
- return -ENOTSUP;
- }
-
- PATCH_HDR(p, 0, pdb_end);
- return PROGRAM_FINALIZE(p);
-}
-
-/**
- * cnstr_shdsc_pdcp_u_plane_decap - Function for creating a PDCP User Plane
- * decapsulation descriptor.
- * @descbuf: pointer to buffer for descriptor construction
- * @ps: if 36/40bit addressing is desired, this parameter must be true
- * @swap: must be true when core endianness doesn't match SEC endianness
- * @sn_size: selects Sequence Number Size: 7/12/15 bits
- * @hfn: starting Hyper Frame Number to be used together with the SN from the
- * PDCP frames.
- * @bearer: radio bearer ID
- * @direction: the direction of the PDCP frame (UL/DL)
- * @hfn_threshold: HFN value that once reached triggers a warning from SEC that
- * keys should be renegotiated at the earliest convenience.
- * @cipherdata: pointer to block cipher transform definitions
- * Valid algorithm values are those from cipher_type_pdcp enum.
- * @era_2_sw_hfn_ovrd: if software HFN override mechanism is desired for
- * this descriptor. Note: Can only be used for
- * SEC ERA 2.
- *
- * Return: size of descriptor written in words or negative number on error.
- * Once the function returns, the value of this parameter can be used
- * for reclaiming the space that wasn't used for the descriptor.
- *
- * Note: descbuf must be large enough to contain a full 256 byte long
- * descriptor; after the function returns, by subtracting the actual number of
- * bytes used, the user can reuse the remaining buffer space for other purposes.
- */
-static inline int
-cnstr_shdsc_pdcp_u_plane_decap(uint32_t *descbuf,
- bool ps,
- bool swap,
- enum pdcp_sn_size sn_size,
- uint32_t hfn,
- unsigned short bearer,
- unsigned short direction,
- uint32_t hfn_threshold,
- struct alginfo *cipherdata,
- struct alginfo *authdata,
- unsigned char era_2_sw_hfn_ovrd)
-{
- struct program prg;
- struct program *p = &prg;
- int err;
- enum pdb_type_e pdb_type;
- static enum rta_share_type
- desc_share[PDCP_CIPHER_TYPE_INVALID][PDCP_AUTH_TYPE_INVALID] = {
- { /* NULL */
- SHR_WAIT, /* NULL */
- SHR_ALWAYS, /* SNOW f9 */
- SHR_ALWAYS, /* AES CMAC */
- SHR_ALWAYS /* ZUC-I */
- },
- { /* SNOW f8 */
- SHR_ALWAYS, /* NULL */
- SHR_ALWAYS, /* SNOW f9 */
- SHR_WAIT, /* AES CMAC */
- SHR_WAIT /* ZUC-I */
- },
- { /* AES CTR */
- SHR_ALWAYS, /* NULL */
- SHR_ALWAYS, /* SNOW f9 */
- SHR_ALWAYS, /* AES CMAC */
- SHR_WAIT /* ZUC-I */
- },
- { /* ZUC-E */
- SHR_ALWAYS, /* NULL */
- SHR_WAIT, /* SNOW f9 */
- SHR_WAIT, /* AES CMAC */
- SHR_ALWAYS /* ZUC-I */
- },
- };
-
- LABEL(pdb_end);
-
- if (rta_sec_era != RTA_SEC_ERA_2 && era_2_sw_hfn_ovrd) {
- pr_err("Cannot select SW HFN override for other era than 2");
- return -EINVAL;
- }
-
- if (authdata && !authdata->algtype && rta_sec_era < RTA_SEC_ERA_8) {
- pr_err("Cannot use u-plane auth with era < 8");
- return -EINVAL;
- }
-
- PROGRAM_CNTXT_INIT(p, descbuf, 0);
- if (swap)
- PROGRAM_SET_BSWAP(p);
- if (ps)
- PROGRAM_SET_36BIT_ADDR(p);
- if (authdata)
- SHR_HDR(p, desc_share[cipherdata->algtype][authdata->algtype], 0, 0);
- else
- SHR_HDR(p, SHR_ALWAYS, 0, 0);
-
- pdb_type = cnstr_pdcp_u_plane_pdb(p, sn_size, hfn, bearer,
- direction, hfn_threshold,
- cipherdata, authdata);
- if (pdb_type == PDCP_PDB_TYPE_INVALID) {
- pr_err("Error creating PDCP UPlane PDB\n");
- return -EINVAL;
- }
- SET_LABEL(p, pdb_end);
-
- err = insert_hfn_ov_op(p, sn_size, pdb_type, era_2_sw_hfn_ovrd);
- if (err)
- return err;
-
- switch (sn_size) {
- case PDCP_SN_SIZE_7:
- case PDCP_SN_SIZE_12:
- switch (cipherdata->algtype) {
- case PDCP_CIPHER_TYPE_ZUC:
- if (rta_sec_era < RTA_SEC_ERA_5) {
- pr_err("Invalid era for selected algorithm\n");
- return -ENOTSUP;
- }
- /* fallthrough */
- case PDCP_CIPHER_TYPE_AES:
- case PDCP_CIPHER_TYPE_SNOW:
- case PDCP_CIPHER_TYPE_NULL:
- if (pdb_type != PDCP_PDB_TYPE_FULL_PDB) {
- pr_err("PDB type must be FULL for PROTO desc\n");
- return -EINVAL;
- }
-
- /* Insert auth key if requested */
- if (authdata && authdata->algtype)
- KEY(p, KEY2, authdata->key_enc_flags,
- (uint64_t)authdata->key, authdata->keylen,
- INLINE_KEY(authdata));
-
- /* Insert Cipher Key */
- KEY(p, KEY1, cipherdata->key_enc_flags,
- cipherdata->key, cipherdata->keylen,
- INLINE_KEY(cipherdata));
- if (authdata)
- PROTOCOL(p, OP_TYPE_DECAP_PROTOCOL,
- OP_PCLID_LTE_PDCP_USER_RN,
- ((uint16_t)cipherdata->algtype << 8) |
- (uint16_t)authdata->algtype);
- else
- PROTOCOL(p, OP_TYPE_DECAP_PROTOCOL,
- OP_PCLID_LTE_PDCP_USER,
- (uint16_t)cipherdata->algtype);
- break;
- default:
- pr_err("%s: Invalid encrypt algorithm selected: %d\n",
- "cnstr_pcl_shdsc_pdcp_u_plane_decap",
- cipherdata->algtype);
- return -EINVAL;
- }
- break;
-
- case PDCP_SN_SIZE_15:
- case PDCP_SN_SIZE_18:
- if (authdata) {
- err = pdcp_insert_uplane_with_int_op(p, swap,
- cipherdata, authdata,
- sn_size, era_2_sw_hfn_ovrd,
- OP_TYPE_DECAP_PROTOCOL);
- if (err)
- return err;
-
- break;
- }
-
- switch (cipherdata->algtype) {
- case PDCP_CIPHER_TYPE_NULL:
- insert_copy_frame_op(p,
- cipherdata,
- OP_TYPE_DECAP_PROTOCOL);
- break;
-
- default:
- err = pdcp_insert_uplane_no_int_op(p, swap, cipherdata,
- OP_TYPE_DECAP_PROTOCOL, sn_size);
- if (err)
- return err;
- break;
- }
- break;
-
- case PDCP_SN_SIZE_5:
- default:
- pr_err("Invalid SN size selected\n");
- return -ENOTSUP;
- }
-
- PATCH_HDR(p, 0, pdb_end);
- return PROGRAM_FINALIZE(p);
-}
-
-/**
- * cnstr_shdsc_pdcp_short_mac - Function for creating a PDCP Short MAC
- * descriptor.
- * @descbuf: pointer to buffer for descriptor construction
- * @ps: if 36/40bit addressing is desired, this parameter must be true
- * @swap: must be true when core endianness doesn't match SEC endianness
- * @authdata: pointer to authentication transform definitions
- * Valid algorithm values are those from auth_type_pdcp enum.
- *
- * Return: size of descriptor written in words or negative number on error.
- * Once the function returns, the value of this parameter can be used
- * for reclaiming the space that wasn't used for the descriptor.
- *
- * Note: descbuf must be large enough to contain a full 256 byte long
- * descriptor; after the function returns, by subtracting the actual number of
- * bytes used, the user can reuse the remaining buffer space for other purposes.
- */
-static inline int
-cnstr_shdsc_pdcp_short_mac(uint32_t *descbuf,
- bool ps,
- bool swap,
- struct alginfo *authdata)
-{
- struct program prg;
- struct program *p = &prg;
- uint32_t iv[3] = {0, 0, 0};
- LABEL(local_offset);
- REFERENCE(move_cmd_read_descbuf);
- REFERENCE(move_cmd_write_descbuf);
-
- PROGRAM_CNTXT_INIT(p, descbuf, 0);
- if (swap)
- PROGRAM_SET_BSWAP(p);
- if (ps)
- PROGRAM_SET_36BIT_ADDR(p);
-
- SHR_HDR(p, SHR_ALWAYS, 1, 0);
-
- if (rta_sec_era > RTA_SEC_ERA_2) {
- MATHB(p, SEQINSZ, SUB, ZERO, VSEQINSZ, 4, 0);
- MATHB(p, SEQINSZ, SUB, ZERO, MATH1, 4, 0);
- } else {
- MATHB(p, SEQINSZ, ADD, ONE, MATH1, 4, 0);
- MATHB(p, MATH1, SUB, ONE, MATH1, 4, 0);
- MATHB(p, ZERO, ADD, MATH1, VSEQINSZ, 4, 0);
- MOVE(p, MATH1, 0, MATH0, 0, 8, IMMED);
-
- /*
- * Since MOVELEN is available only starting with
- * SEC ERA 3, use poor man's MOVELEN: create a MOVE
- * command dynamically by writing the length from M1 by
- * OR-ing the command in the M1 register and MOVE the
- * result into the descriptor buffer. Care must be taken
- * wrt. the location of the command because of SEC
- * pipelining. The actual MOVEs are written at the end
- * of the descriptor due to calculations needed on the
- * offset in the descriptor for the MOVE command.
- */
- move_cmd_read_descbuf = MOVE(p, DESCBUF, 0, MATH0, 0, 6,
- IMMED);
- move_cmd_write_descbuf = MOVE(p, MATH0, 0, DESCBUF, 0, 8,
- WAITCOMP | IMMED);
- }
- MATHB(p, ZERO, ADD, MATH1, VSEQOUTSZ, 4, 0);
-
- switch (authdata->algtype) {
- case PDCP_AUTH_TYPE_NULL:
- SEQFIFOSTORE(p, MSG, 0, 0, VLF);
- if (rta_sec_era > RTA_SEC_ERA_2) {
- MOVE(p, AB1, 0, OFIFO, 0, MATH1, 0);
- } else {
- SET_LABEL(p, local_offset);
-
- /* Shut off automatic Info FIFO entries */
- LOAD(p, 0, DCTRL, LDOFF_DISABLE_AUTO_NFIFO, 0, IMMED);
-
- /* Placeholder for MOVE command with length from M1
- * register
- */
- MOVE(p, IFIFOAB1, 0, OFIFO, 0, 0, IMMED);
-
- /* Enable automatic Info FIFO entries */
- LOAD(p, 0, DCTRL, LDOFF_ENABLE_AUTO_NFIFO, 0, IMMED);
- }
-
- LOAD(p, (uintptr_t)iv, MATH0, 0, 8, IMMED | COPY);
- SEQFIFOLOAD(p, MSG1, 0, VLF | LAST1 | LAST2 | FLUSH1);
- SEQSTORE(p, MATH0, 0, 4, 0);
-
- break;
-
- case PDCP_AUTH_TYPE_SNOW:
- iv[0] = 0xFFFFFFFF;
- iv[1] = swap ? swab32(0x04000000) : 0x04000000;
- iv[2] = swap ? swab32(0xF8000000) : 0xF8000000;
-
- KEY(p, KEY2, authdata->key_enc_flags, authdata->key,
- authdata->keylen, INLINE_KEY(authdata));
- LOAD(p, (uintptr_t)&iv, CONTEXT2, 0, 12, IMMED | COPY);
- ALG_OPERATION(p, OP_ALG_ALGSEL_SNOW_F9,
- OP_ALG_AAI_F9,
- OP_ALG_AS_INITFINAL,
- ICV_CHECK_DISABLE,
- DIR_ENC);
- SEQFIFOSTORE(p, MSG, 0, 0, VLF);
-
- if (rta_sec_era > RTA_SEC_ERA_2) {
- MOVE(p, AB1, 0, OFIFO, 0, MATH1, 0);
- } else {
- SET_LABEL(p, local_offset);
-
-
- /* Shut off automatic Info FIFO entries */
- LOAD(p, 0, DCTRL, LDOFF_DISABLE_AUTO_NFIFO, 0, IMMED);
-
- /* Placeholder for MOVE command with length from M1
- * register
- */
- MOVE(p, IFIFOAB1, 0, OFIFO, 0, 0, IMMED);
-
- /* Enable automatic Info FIFO entries */
- LOAD(p, 0, DCTRL, LDOFF_ENABLE_AUTO_NFIFO, 0, IMMED);
- }
- SEQFIFOLOAD(p, MSGINSNOOP, 0, VLF | LAST1 | LAST2 | FLUSH1);
- SEQSTORE(p, CONTEXT2, 0, 4, 0);
-
- break;
-
- case PDCP_AUTH_TYPE_AES:
- iv[0] = 0xFFFFFFFF;
- iv[1] = swap ? swab32(0xFC000000) : 0xFC000000;
- iv[2] = 0x00000000; /* unused */
-
- KEY(p, KEY1, authdata->key_enc_flags, authdata->key,
- authdata->keylen, INLINE_KEY(authdata));
- LOAD(p, (uintptr_t)&iv, MATH0, 0, 8, IMMED | COPY);
- MOVE(p, MATH0, 0, IFIFOAB1, 0, 8, IMMED);
- ALG_OPERATION(p, OP_ALG_ALGSEL_AES,
- OP_ALG_AAI_CMAC,
- OP_ALG_AS_INITFINAL,
- ICV_CHECK_DISABLE,
- DIR_ENC);
- SEQFIFOSTORE(p, MSG, 0, 0, VLF);
-
- if (rta_sec_era > RTA_SEC_ERA_2) {
- MOVE(p, AB2, 0, OFIFO, 0, MATH1, 0);
- } else {
- SET_LABEL(p, local_offset);
-
- /* Shut off automatic Info FIFO entries */
- LOAD(p, 0, DCTRL, LDOFF_DISABLE_AUTO_NFIFO, 0, IMMED);
-
- /* Placeholder for MOVE command with length from M1
- * register
- */
- MOVE(p, IFIFOAB2, 0, OFIFO, 0, 0, IMMED);
-
- /* Enable automatic Info FIFO entries */
- LOAD(p, 0, DCTRL, LDOFF_ENABLE_AUTO_NFIFO, 0, IMMED);
- }
- SEQFIFOLOAD(p, MSGINSNOOP, 0, VLF | LAST1 | LAST2 | FLUSH1);
- SEQSTORE(p, CONTEXT1, 0, 4, 0);
-
- break;
-
- case PDCP_AUTH_TYPE_ZUC:
- if (rta_sec_era < RTA_SEC_ERA_5) {
- pr_err("Invalid era for selected algorithm\n");
- return -ENOTSUP;
- }
- iv[0] = 0xFFFFFFFF;
- iv[1] = swap ? swab32(0xFC000000) : 0xFC000000;
- iv[2] = 0x00000000; /* unused */
-
- KEY(p, KEY2, authdata->key_enc_flags, authdata->key,
- authdata->keylen, INLINE_KEY(authdata));
- LOAD(p, (uintptr_t)&iv, CONTEXT2, 0, 12, IMMED | COPY);
- ALG_OPERATION(p, OP_ALG_ALGSEL_ZUCA,
- OP_ALG_AAI_F9,
- OP_ALG_AS_INITFINAL,
- ICV_CHECK_DISABLE,
- DIR_ENC);
- SEQFIFOSTORE(p, MSG, 0, 0, VLF);
- MOVE(p, AB1, 0, OFIFO, 0, MATH1, 0);
- SEQFIFOLOAD(p, MSGINSNOOP, 0, VLF | LAST1 | LAST2 | FLUSH1);
- SEQSTORE(p, CONTEXT2, 0, 4, 0);
-
- break;
-
- default:
- pr_err("%s: Invalid integrity algorithm selected: %d\n",
- "cnstr_shdsc_pdcp_short_mac", authdata->algtype);
- return -EINVAL;
- }
-
-
- if (rta_sec_era < RTA_SEC_ERA_3) {
- PATCH_MOVE(p, move_cmd_read_descbuf, local_offset);
- PATCH_MOVE(p, move_cmd_write_descbuf, local_offset);
- }
-
- return PROGRAM_FINALIZE(p);
-}
-
-#endif /* __DESC_PDCP_H__ */
+++ /dev/null
-/* SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0)
- *
- * Copyright 2008-2016 Freescale Semiconductor Inc.
- * Copyright 2016 NXP
- *
- */
-
-#ifndef __RTA_RTA_H__
-#define __RTA_RTA_H__
-
-#include "rta/sec_run_time_asm.h"
-#include "rta/fifo_load_store_cmd.h"
-#include "rta/header_cmd.h"
-#include "rta/jump_cmd.h"
-#include "rta/key_cmd.h"
-#include "rta/load_cmd.h"
-#include "rta/math_cmd.h"
-#include "rta/move_cmd.h"
-#include "rta/nfifo_cmd.h"
-#include "rta/operation_cmd.h"
-#include "rta/protocol_cmd.h"
-#include "rta/seq_in_out_ptr_cmd.h"
-#include "rta/signature_cmd.h"
-#include "rta/store_cmd.h"
-
-/**
- * DOC: About
- *
- * RTA (Runtime Assembler) Library is an easy and flexible runtime method for
- * writing SEC descriptors. It implements a thin abstraction layer above
- * SEC commands set; the resulting code is compact and similar to a
- * descriptor sequence.
- *
- * RTA library improves comprehension of the SEC code, adds flexibility for
- * writing complex descriptors and keeps the code lightweight. Should be used
- * by whom needs to encode descriptors at runtime, with comprehensible flow
- * control in descriptor.
- */
-
-/**
- * DOC: Usage
- *
- * RTA is used in kernel space by the SEC / CAAM (Cryptographic Acceleration and
- * Assurance Module) kernel module (drivers/crypto/caam) and SEC / CAAM QI
- * kernel module (Freescale QorIQ SDK).
- *
- * RTA is used in user space by USDPAA - User Space DataPath Acceleration
- * Architecture (Freescale QorIQ SDK).
- */
-
-/**
- * DOC: Descriptor Buffer Management Routines
- *
- * Contains details of RTA descriptor buffer management and SEC Era
- * management routines.
- */
-
-/**
- * PROGRAM_CNTXT_INIT - must be called before any descriptor run-time assembly
- * call type field carry info i.e. whether descriptor is
- * shared or job descriptor.
- * @program: pointer to struct program
- * @buffer: input buffer where the descriptor will be placed (uint32_t *)
- * @offset: offset in input buffer from where the data will be written
- * (unsigned int)
- */
-#define PROGRAM_CNTXT_INIT(program, buffer, offset) \
- rta_program_cntxt_init(program, buffer, offset)
-
-/**
- * PROGRAM_FINALIZE - must be called to mark completion of RTA call.
- * @program: pointer to struct program
- *
- * Return: total size of the descriptor in words or negative number on error.
- */
-#define PROGRAM_FINALIZE(program) rta_program_finalize(program)
-
-/**
- * PROGRAM_SET_36BIT_ADDR - must be called to set pointer size to 36 bits
- * @program: pointer to struct program
- *
- * Return: current size of the descriptor in words (unsigned int).
- */
-#define PROGRAM_SET_36BIT_ADDR(program) rta_program_set_36bit_addr(program)
-
-/**
- * PROGRAM_SET_BSWAP - must be called to enable byte swapping
- * @program: pointer to struct program
- *
- * Byte swapping on a 4-byte boundary will be performed at the end - when
- * calling PROGRAM_FINALIZE().
- *
- * Return: current size of the descriptor in words (unsigned int).
- */
-#define PROGRAM_SET_BSWAP(program) rta_program_set_bswap(program)
-
-/**
- * WORD - must be called to insert in descriptor buffer a 32bit value
- * @program: pointer to struct program
- * @val: input value to be written in descriptor buffer (uint32_t)
- *
- * Return: the descriptor buffer offset where this command is inserted
- * (unsigned int).
- */
-#define WORD(program, val) rta_word(program, val)
-
-/**
- * DWORD - must be called to insert in descriptor buffer a 64bit value
- * @program: pointer to struct program
- * @val: input value to be written in descriptor buffer (uint64_t)
- *
- * Return: the descriptor buffer offset where this command is inserted
- * (unsigned int).
- */
-#define DWORD(program, val) rta_dword(program, val)
-
-/**
- * COPY_DATA - must be called to insert in descriptor buffer data larger than
- * 64bits.
- * @program: pointer to struct program
- * @data: input data to be written in descriptor buffer (uint8_t *)
- * @len: length of input data (unsigned int)
- *
- * Return: the descriptor buffer offset where this command is inserted
- * (unsigned int).
- */
-#define COPY_DATA(program, data, len) rta_copy_data(program, (data), (len))
-
-/**
- * DESC_LEN - determines job / shared descriptor buffer length (in words)
- * @buffer: descriptor buffer (uint32_t *)
- *
- * Return: descriptor buffer length in words (unsigned int).
- */
-#define DESC_LEN(buffer) rta_desc_len(buffer)
-
-/**
- * DESC_BYTES - determines job / shared descriptor buffer length (in bytes)
- * @buffer: descriptor buffer (uint32_t *)
- *
- * Return: descriptor buffer length in bytes (unsigned int).
- */
-#define DESC_BYTES(buffer) rta_desc_bytes(buffer)
-
-/*
- * SEC HW block revision.
- *
- * This *must not be confused with SEC version*:
- * - SEC HW block revision format is "v"
- * - SEC revision format is "x.y"
- */
-extern enum rta_sec_era rta_sec_era;
-
-/**
- * rta_set_sec_era - Set SEC Era HW block revision for which the RTA library
- * will generate the descriptors.
- * @era: SEC Era (enum rta_sec_era)
- *
- * Return: 0 if the ERA was set successfully, -1 otherwise (int)
- *
- * Warning 1: Must be called *only once*, *before* using any other RTA API
- * routine.
- *
- * Warning 2: *Not thread safe*.
- */
-static inline int
-rta_set_sec_era(enum rta_sec_era era)
-{
- if (era > MAX_SEC_ERA) {
- rta_sec_era = DEFAULT_SEC_ERA;
- pr_err("Unsupported SEC ERA. Defaulting to ERA %d\n",
- DEFAULT_SEC_ERA + 1);
- return -1;
- }
-
- rta_sec_era = era;
- return 0;
-}
-
-/**
- * rta_get_sec_era - Get SEC Era HW block revision for which the RTA library
- * will generate the descriptors.
- *
- * Return: SEC Era (unsigned int).
- */
-static inline unsigned int
-rta_get_sec_era(void)
-{
- return rta_sec_era;
-}
-
-/**
- * DOC: SEC Commands Routines
- *
- * Contains details of RTA wrapper routines over SEC engine commands.
- */
-
-/**
- * SHR_HDR - Configures Shared Descriptor HEADER command
- * @program: pointer to struct program
- * @share: descriptor share state (enum rta_share_type)
- * @start_idx: index in descriptor buffer where the execution of the shared
- * descriptor should start (@c unsigned int).
- * @flags: operational flags: RIF, DNR, CIF, SC, PD
- *
- * Return: On success, descriptor buffer offset where this command is inserted.
- * On error, a negative error code; first error program counter will
- * point to offset in descriptor buffer where the instruction should
- * have been written.
- */
-#define SHR_HDR(program, share, start_idx, flags) \
- rta_shr_header(program, share, start_idx, flags)
-
-/**
- * JOB_HDR - Configures JOB Descriptor HEADER command
- * @program: pointer to struct program
- * @share: descriptor share state (enum rta_share_type)
- * @start_idx: index in descriptor buffer where the execution of the job
- * descriptor should start (unsigned int). In case SHR bit is present
- * in flags, this will be the shared descriptor length.
- * @share_desc: pointer to shared descriptor, in case SHR bit is set (uint64_t)
- * @flags: operational flags: RSMS, DNR, TD, MTD, REO, SHR
- *
- * Return: On success, descriptor buffer offset where this command is inserted.
- * On error, a negative error code; first error program counter will
- * point to offset in descriptor buffer where the instruction should
- * have been written.
- */
-#define JOB_HDR(program, share, start_idx, share_desc, flags) \
- rta_job_header(program, share, start_idx, share_desc, flags, 0)
-
-/**
- * JOB_HDR_EXT - Configures JOB Descriptor HEADER command
- * @program: pointer to struct program
- * @share: descriptor share state (enum rta_share_type)
- * @start_idx: index in descriptor buffer where the execution of the job
- * descriptor should start (unsigned int). In case SHR bit is present
- * in flags, this will be the shared descriptor length.
- * @share_desc: pointer to shared descriptor, in case SHR bit is set (uint64_t)
- * @flags: operational flags: RSMS, DNR, TD, MTD, REO, SHR
- * @ext_flags: extended header flags: DSV (DECO Select Valid), DECO Id (limited
- * by DSEL_MASK).
- *
- * Return: On success, descriptor buffer offset where this command is inserted.
- * On error, a negative error code; first error program counter will
- * point to offset in descriptor buffer where the instruction should
- * have been written.
- */
-#define JOB_HDR_EXT(program, share, start_idx, share_desc, flags, ext_flags) \
- rta_job_header(program, share, start_idx, share_desc, flags | EXT, \
- ext_flags)
-
-/**
- * MOVE - Configures MOVE and MOVE_LEN commands
- * @program: pointer to struct program
- * @src: internal source of data that will be moved: CONTEXT1, CONTEXT2, OFIFO,
- * DESCBUF, MATH0-MATH3, IFIFOABD, IFIFOAB1, IFIFOAB2, AB1, AB2, ABD.
- * @src_offset: offset in source data (uint16_t)
- * @dst: internal destination of data that will be moved: CONTEXT1, CONTEXT2,
- * OFIFO, DESCBUF, MATH0-MATH3, IFIFOAB1, IFIFOAB2, IFIFO, PKA, KEY1,
- * KEY2, ALTSOURCE.
- * @dst_offset: offset in destination data (uint16_t)
- * @length: size of data to be moved: for MOVE must be specified as immediate
- * value and IMMED flag must be set; for MOVE_LEN must be specified
- * using MATH0-MATH3.
- * @opt: operational flags: WAITCOMP, FLUSH1, FLUSH2, LAST1, LAST2, SIZE_WORD,
- * SIZE_BYTE, SIZE_DWORD, IMMED (not valid for MOVE_LEN).
- *
- * Return: On success, descriptor buffer offset where this command is inserted.
- * On error, a negative error code; first error program counter will
- * point to offset in descriptor buffer where the instruction should
- * have been written.
- */
-#define MOVE(program, src, src_offset, dst, dst_offset, length, opt) \
- rta_move(program, __MOVE, src, src_offset, dst, dst_offset, length, opt)
-
-/**
- * MOVEB - Configures MOVEB command
- * @program: pointer to struct program
- * @src: internal source of data that will be moved: CONTEXT1, CONTEXT2, OFIFO,
- * DESCBUF, MATH0-MATH3, IFIFOABD, IFIFOAB1, IFIFOAB2, AB1, AB2, ABD.
- * @src_offset: offset in source data (uint16_t)
- * @dst: internal destination of data that will be moved: CONTEXT1, CONTEXT2,
- * OFIFO, DESCBUF, MATH0-MATH3, IFIFOAB1, IFIFOAB2, IFIFO, PKA, KEY1,
- * KEY2, ALTSOURCE.
- * @dst_offset: offset in destination data (uint16_t)
- * @length: size of data to be moved: for MOVE must be specified as immediate
- * value and IMMED flag must be set; for MOVE_LEN must be specified
- * using MATH0-MATH3.
- * @opt: operational flags: WAITCOMP, FLUSH1, FLUSH2, LAST1, LAST2, SIZE_WORD,
- * SIZE_BYTE, SIZE_DWORD, IMMED (not valid for MOVE_LEN).
- *
- * Identical with MOVE command if byte swapping not enabled; else - when src/dst
- * is descriptor buffer or MATH registers, data type is byte array when MOVE
- * data type is 4-byte array and vice versa.
- *
- * Return: On success, descriptor buffer offset where this command is inserted.
- * On error, a negative error code; first error program counter will
- * point to offset in descriptor buffer where the instruction should
- * have been written.
- */
-#define MOVEB(program, src, src_offset, dst, dst_offset, length, opt) \
- rta_move(program, __MOVEB, src, src_offset, dst, dst_offset, length, \
- opt)
-
-/**
- * MOVEDW - Configures MOVEDW command
- * @program: pointer to struct program
- * @src: internal source of data that will be moved: CONTEXT1, CONTEXT2, OFIFO,
- * DESCBUF, MATH0-MATH3, IFIFOABD, IFIFOAB1, IFIFOAB2, AB1, AB2, ABD.
- * @src_offset: offset in source data (uint16_t)
- * @dst: internal destination of data that will be moved: CONTEXT1, CONTEXT2,
- * OFIFO, DESCBUF, MATH0-MATH3, IFIFOAB1, IFIFOAB2, IFIFO, PKA, KEY1,
- * KEY2, ALTSOURCE.
- * @dst_offset: offset in destination data (uint16_t)
- * @length: size of data to be moved: for MOVE must be specified as immediate
- * value and IMMED flag must be set; for MOVE_LEN must be specified
- * using MATH0-MATH3.
- * @opt: operational flags: WAITCOMP, FLUSH1, FLUSH2, LAST1, LAST2, SIZE_WORD,
- * SIZE_BYTE, SIZE_DWORD, IMMED (not valid for MOVE_LEN).
- *
- * Identical with MOVE command, with the following differences: data type is
- * 8-byte array; word swapping is performed when SEC is programmed in little
- * endian mode.
- *
- * Return: On success, descriptor buffer offset where this command is inserted.
- * On error, a negative error code; first error program counter will
- * point to offset in descriptor buffer where the instruction should
- * have been written.
- */
-#define MOVEDW(program, src, src_offset, dst, dst_offset, length, opt) \
- rta_move(program, __MOVEDW, src, src_offset, dst, dst_offset, length, \
- opt)
-
-/**
- * FIFOLOAD - Configures FIFOLOAD command to load message data, PKHA data, IV,
- * ICV, AAD and bit length message data into Input Data FIFO.
- * @program: pointer to struct program
- * @data: input data type to store: PKHA registers, IFIFO, MSG1, MSG2,
- * MSGOUTSNOOP, MSGINSNOOP, IV1, IV2, AAD1, ICV1, ICV2, BIT_DATA, SKIP.
- * @src: pointer or actual data in case of immediate load; IMMED, COPY and DCOPY
- * flags indicate action taken (inline imm data, inline ptr, inline from
- * ptr).
- * @length: number of bytes to load (uint32_t)
- * @flags: operational flags: SGF, IMMED, EXT, CLASS1, CLASS2, BOTH, FLUSH1,
- * LAST1, LAST2, COPY, DCOPY.
- *
- * Return: On success, descriptor buffer offset where this command is inserted.
- * On error, a negative error code; first error program counter will
- * point to offset in descriptor buffer where the instruction should
- * have been written.
- */
-#define FIFOLOAD(program, data, src, length, flags) \
- rta_fifo_load(program, data, src, length, flags)
-
-/**
- * SEQFIFOLOAD - Configures SEQ FIFOLOAD command to load message data, PKHA
- * data, IV, ICV, AAD and bit length message data into Input Data
- * FIFO.
- * @program: pointer to struct program
- * @data: input data type to store: PKHA registers, IFIFO, MSG1, MSG2,
- * MSGOUTSNOOP, MSGINSNOOP, IV1, IV2, AAD1, ICV1, ICV2, BIT_DATA, SKIP.
- * @length: number of bytes to load; can be set to 0 for SEQ command w/ VLF set
- * (uint32_t).
- * @flags: operational flags: VLF, CLASS1, CLASS2, BOTH, FLUSH1, LAST1, LAST2,
- * AIDF.
- *
- * Return: On success, descriptor buffer offset where this command is inserted.
- * On error, a negative error code; first error program counter will
- * point to offset in descriptor buffer where the instruction should
- * have been written.
- */
-#define SEQFIFOLOAD(program, data, length, flags) \
- rta_fifo_load(program, data, NONE, length, flags|SEQ)
-
-/**
- * FIFOSTORE - Configures FIFOSTORE command, to move data from Output Data FIFO
- * to external memory via DMA.
- * @program: pointer to struct program
- * @data: output data type to store: PKHA registers, IFIFO, OFIFO, RNG,
- * RNGOFIFO, AFHA_SBOX, MDHA_SPLIT_KEY, MSG, KEY1, KEY2, SKIP.
- * @encrypt_flags: store data encryption mode: EKT, TK
- * @dst: pointer to store location (uint64_t)
- * @length: number of bytes to load (uint32_t)
- * @flags: operational flags: SGF, CONT, EXT, CLASS1, CLASS2, BOTH
- *
- * Return: On success, descriptor buffer offset where this command is inserted.
- * On error, a negative error code; first error program counter will
- * point to offset in descriptor buffer where the instruction should
- * have been written.
- */
-#define FIFOSTORE(program, data, encrypt_flags, dst, length, flags) \
- rta_fifo_store(program, data, encrypt_flags, dst, length, flags)
-
-/**
- * SEQFIFOSTORE - Configures SEQ FIFOSTORE command, to move data from Output
- * Data FIFO to external memory via DMA.
- * @program: pointer to struct program
- * @data: output data type to store: PKHA registers, IFIFO, OFIFO, RNG,
- * RNGOFIFO, AFHA_SBOX, MDHA_SPLIT_KEY, MSG, KEY1, KEY2, METADATA, SKIP.
- * @encrypt_flags: store data encryption mode: EKT, TK
- * @length: number of bytes to load; can be set to 0 for SEQ command w/ VLF set
- * (uint32_t).
- * @flags: operational flags: VLF, CONT, EXT, CLASS1, CLASS2, BOTH
- *
- * Return: On success, descriptor buffer offset where this command is inserted.
- * On error, a negative error code; first error program counter will
- * point to offset in descriptor buffer where the instruction should
- * have been written.
- */
-#define SEQFIFOSTORE(program, data, encrypt_flags, length, flags) \
- rta_fifo_store(program, data, encrypt_flags, 0, length, flags|SEQ)
-
-/**
- * KEY - Configures KEY and SEQ KEY commands
- * @program: pointer to struct program
- * @key_dst: key store location: KEY1, KEY2, PKE, AFHA_SBOX, MDHA_SPLIT_KEY
- * @encrypt_flags: key encryption mode: ENC, EKT, TK, NWB, PTS
- * @src: pointer or actual data in case of immediate load (uint64_t); IMMED,
- * COPY and DCOPY flags indicate action taken (inline imm data,
- * inline ptr, inline from ptr).
- * @length: number of bytes to load; can be set to 0 for SEQ command w/ VLF set
- * (uint32_t).
- * @flags: operational flags: for KEY: SGF, IMMED, COPY, DCOPY; for SEQKEY: SEQ,
- * VLF, AIDF.
- *
- * Return: On success, descriptor buffer offset where this command is inserted.
- * On error, a negative error code; first error program counter will
- * point to offset in descriptor buffer where the instruction should
- * have been written.
- */
-#define KEY(program, key_dst, encrypt_flags, src, length, flags) \
- rta_key(program, key_dst, encrypt_flags, src, length, flags)
-
-/**
- * SEQINPTR - Configures SEQ IN PTR command
- * @program: pointer to struct program
- * @src: starting address for Input Sequence (uint64_t)
- * @length: number of bytes in (or to be added to) Input Sequence (uint32_t)
- * @flags: operational flags: RBS, INL, SGF, PRE, EXT, RTO, RJD, SOP (when PRE,
- * RTO or SOP are set, @src parameter must be 0).
- *
- * Return: On success, descriptor buffer offset where this command is inserted.
- * On error, a negative error code; first error program counter will
- * point to offset in descriptor buffer where the instruction should
- * have been written.
- */
-#define SEQINPTR(program, src, length, flags) \
- rta_seq_in_ptr(program, src, length, flags)
-
-/**
- * SEQOUTPTR - Configures SEQ OUT PTR command
- * @program: pointer to struct program
- * @dst: starting address for Output Sequence (uint64_t)
- * @length: number of bytes in (or to be added to) Output Sequence (uint32_t)
- * @flags: operational flags: SGF, PRE, EXT, RTO, RST, EWS (when PRE or RTO are
- * set, @dst parameter must be 0).
- *
- * Return: On success, descriptor buffer offset where this command is inserted.
- * On error, a negative error code; first error program counter will
- * point to offset in descriptor buffer where the instruction should
- * have been written.
- */
-#define SEQOUTPTR(program, dst, length, flags) \
- rta_seq_out_ptr(program, dst, length, flags)
-
-/**
- * ALG_OPERATION - Configures ALGORITHM OPERATION command
- * @program: pointer to struct program
- * @cipher_alg: algorithm to be used
- * @aai: Additional Algorithm Information; contains mode information that is
- * associated with the algorithm (check desc.h for specific values).
- * @algo_state: algorithm state; defines the state of the algorithm that is
- * being executed (check desc.h file for specific values).
- * @icv_check: ICV checking; selects whether the algorithm should check
- * calculated ICV with known ICV: ICV_CHECK_ENABLE,
- * ICV_CHECK_DISABLE.
- * @enc: selects between encryption and decryption: DIR_ENC, DIR_DEC
- *
- * Return: On success, descriptor buffer offset where this command is inserted.
- * On error, a negative error code; first error program counter will
- * point to offset in descriptor buffer where the instruction should
- * have been written.
- */
-#define ALG_OPERATION(program, cipher_alg, aai, algo_state, icv_check, enc) \
- rta_operation(program, cipher_alg, aai, algo_state, icv_check, enc)
-
-/**
- * PROTOCOL - Configures PROTOCOL OPERATION command
- * @program: pointer to struct program
- * @optype: operation type: OP_TYPE_UNI_PROTOCOL / OP_TYPE_DECAP_PROTOCOL /
- * OP_TYPE_ENCAP_PROTOCOL.
- * @protid: protocol identifier value (check desc.h file for specific values)
- * @protoinfo: protocol dependent value (check desc.h file for specific values)
- *
- * Return: On success, descriptor buffer offset where this command is inserted.
- * On error, a negative error code; first error program counter will
- * point to offset in descriptor buffer where the instruction should
- * have been written.
- */
-#define PROTOCOL(program, optype, protid, protoinfo) \
- rta_proto_operation(program, optype, protid, protoinfo)
-
-/**
- * DKP_PROTOCOL - Configures DKP (Derived Key Protocol) PROTOCOL command
- * @program: pointer to struct program
- * @protid: protocol identifier value - one of the following:
- * OP_PCLID_DKP_{MD5 | SHA1 | SHA224 | SHA256 | SHA384 | SHA512}
- * @key_src: How the initial ("negotiated") key is provided to the DKP protocol.
- * Valid values - one of OP_PCL_DKP_SRC_{IMM, SEQ, PTR, SGF}. Not all
- * (key_src,key_dst) combinations are allowed.
- * @key_dst: How the derived ("split") key is returned by the DKP protocol.
- * Valid values - one of OP_PCL_DKP_DST_{IMM, SEQ, PTR, SGF}. Not all
- * (key_src,key_dst) combinations are allowed.
- * @keylen: length of the initial key, in bytes (uint16_t)
- * @key: address where algorithm key resides; virtual address if key_type is
- * RTA_DATA_IMM, physical (bus) address if key_type is RTA_DATA_PTR or
- * RTA_DATA_IMM_DMA.
- * @key_type: enum rta_data_type
- * Return: On success, descriptor buffer offset where this command is inserted.
- * On error, a negative error code; first error program counter will
- * point to offset in descriptor buffer where the instruction should
- * have been written.
- */
-#define DKP_PROTOCOL(program, protid, key_src, key_dst, keylen, key, key_type) \
- rta_dkp_proto(program, protid, key_src, key_dst, keylen, key, key_type)
-
-/**
- * PKHA_OPERATION - Configures PKHA OPERATION command
- * @program: pointer to struct program
- * @op_pkha: PKHA operation; indicates the modular arithmetic function to
- * execute (check desc.h file for specific values).
- *
- * Return: On success, descriptor buffer offset where this command is inserted.
- * On error, a negative error code; first error program counter will
- * point to offset in descriptor buffer where the instruction should
- * have been written.
- */
-#define PKHA_OPERATION(program, op_pkha) rta_pkha_operation(program, op_pkha)
-
-/**
- * JUMP - Configures JUMP command
- * @program: pointer to struct program
- * @addr: local offset for local jumps or address pointer for non-local jumps;
- * IMM or PTR macros must be used to indicate type.
- * @jump_type: type of action taken by jump (enum rta_jump_type)
- * @test_type: defines how jump conditions are evaluated (enum rta_jump_cond)
- * @cond: jump conditions: operational flags - DONE1, DONE2, BOTH; various
- * sharing and wait conditions (JSL = 1) - NIFP, NIP, NOP, NCP, CALM,
- * SELF, SHARED, JQP; Math and PKHA status conditions (JSL = 0) - Z, N,
- * NV, C, PK0, PK1, PKP.
- *
- * Return: On success, descriptor buffer offset where this command is inserted.
- * On error, a negative error code; first error program counter will
- * point to offset in descriptor buffer where the instruction should
- * have been written.
- */
-#define JUMP(program, addr, jump_type, test_type, cond) \
- rta_jump(program, addr, jump_type, test_type, cond, NONE)
-
-/**
- * JUMP_INC - Configures JUMP_INC command
- * @program: pointer to struct program
- * @addr: local offset; IMM or PTR macros must be used to indicate type
- * @test_type: defines how jump conditions are evaluated (enum rta_jump_cond)
- * @cond: jump conditions: Math status conditions (JSL = 0): Z, N, NV, C
- * @src_dst: register to increment / decrement: MATH0-MATH3, DPOVRD, SEQINSZ,
- * SEQOUTSZ, VSEQINSZ, VSEQOUTSZ.
- *
- * Return: On success, descriptor buffer offset where this command is inserted.
- * On error, a negative error code; first error program counter will
- * point to offset in descriptor buffer where the instruction should
- * have been written.
- */
-#define JUMP_INC(program, addr, test_type, cond, src_dst) \
- rta_jump(program, addr, LOCAL_JUMP_INC, test_type, cond, src_dst)
-
-/**
- * JUMP_DEC - Configures JUMP_DEC command
- * @program: pointer to struct program
- * @addr: local offset; IMM or PTR macros must be used to indicate type
- * @test_type: defines how jump conditions are evaluated (enum rta_jump_cond)
- * @cond: jump conditions: Math status conditions (JSL = 0): Z, N, NV, C
- * @src_dst: register to increment / decrement: MATH0-MATH3, DPOVRD, SEQINSZ,
- * SEQOUTSZ, VSEQINSZ, VSEQOUTSZ.
- *
- * Return: On success, descriptor buffer offset where this command is inserted.
- * On error, a negative error code; first error program counter will
- * point to offset in descriptor buffer where the instruction should
- * have been written.
- */
-#define JUMP_DEC(program, addr, test_type, cond, src_dst) \
- rta_jump(program, addr, LOCAL_JUMP_DEC, test_type, cond, src_dst)
-
-/**
- * LOAD - Configures LOAD command to load data registers from descriptor or from
- * a memory location.
- * @program: pointer to struct program
- * @addr: immediate value or pointer to the data to be loaded; IMMED, COPY and
- * DCOPY flags indicate action taken (inline imm data, inline ptr, inline
- * from ptr).
- * @dst: destination register (uint64_t)
- * @offset: start point to write data in destination register (uint32_t)
- * @length: number of bytes to load (uint32_t)
- * @flags: operational flags: VLF, IMMED, COPY, DCOPY
- *
- * Return: On success, descriptor buffer offset where this command is inserted.
- * On error, a negative error code; first error program counter will
- * point to offset in descriptor buffer where the instruction should
- * have been written.
- */
-#define LOAD(program, addr, dst, offset, length, flags) \
- rta_load(program, addr, dst, offset, length, flags)
-
-/**
- * SEQLOAD - Configures SEQ LOAD command to load data registers from descriptor
- * or from a memory location.
- * @program: pointer to struct program
- * @dst: destination register (uint64_t)
- * @offset: start point to write data in destination register (uint32_t)
- * @length: number of bytes to load (uint32_t)
- * @flags: operational flags: SGF
- *
- * Return: On success, descriptor buffer offset where this command is inserted.
- * On error, a negative error code; first error program counter will
- * point to offset in descriptor buffer where the instruction should
- * have been written.
- */
-#define SEQLOAD(program, dst, offset, length, flags) \
- rta_load(program, NONE, dst, offset, length, flags|SEQ)
-
-/**
- * STORE - Configures STORE command to read data from registers and write them
- * to a memory location.
- * @program: pointer to struct program
- * @src: immediate value or source register for data to be stored: KEY1SZ,
- * KEY2SZ, DJQDA, MODE1, MODE2, DJQCTRL, DATA1SZ, DATA2SZ, DSTAT, ICV1SZ,
- * ICV2SZ, DPID, CCTRL, ICTRL, CLRW, CSTAT, MATH0-MATH3, PKHA registers,
- * CONTEXT1, CONTEXT2, DESCBUF, JOBDESCBUF, SHAREDESCBUF. In case of
- * immediate value, IMMED, COPY and DCOPY flags indicate action taken
- * (inline imm data, inline ptr, inline from ptr).
- * @offset: start point for reading from source register (uint16_t)
- * @dst: pointer to store location (uint64_t)
- * @length: number of bytes to store (uint32_t)
- * @flags: operational flags: VLF, IMMED, COPY, DCOPY
- *
- * Return: On success, descriptor buffer offset where this command is inserted.
- * On error, a negative error code; first error program counter will
- * point to offset in descriptor buffer where the instruction should
- * have been written.
- */
-#define STORE(program, src, offset, dst, length, flags) \
- rta_store(program, src, offset, dst, length, flags)
-
-/**
- * SEQSTORE - Configures SEQ STORE command to read data from registers and write
- * them to a memory location.
- * @program: pointer to struct program
- * @src: immediate value or source register for data to be stored: KEY1SZ,
- * KEY2SZ, DJQDA, MODE1, MODE2, DJQCTRL, DATA1SZ, DATA2SZ, DSTAT, ICV1SZ,
- * ICV2SZ, DPID, CCTRL, ICTRL, CLRW, CSTAT, MATH0-MATH3, PKHA registers,
- * CONTEXT1, CONTEXT2, DESCBUF, JOBDESCBUF, SHAREDESCBUF. In case of
- * immediate value, IMMED, COPY and DCOPY flags indicate action taken
- * (inline imm data, inline ptr, inline from ptr).
- * @offset: start point for reading from source register (uint16_t)
- * @length: number of bytes to store (uint32_t)
- * @flags: operational flags: SGF, IMMED, COPY, DCOPY
- *
- * Return: On success, descriptor buffer offset where this command is inserted.
- * On error, a negative error code; first error program counter will
- * point to offset in descriptor buffer where the instruction should
- * have been written.
- */
-#define SEQSTORE(program, src, offset, length, flags) \
- rta_store(program, src, offset, NONE, length, flags|SEQ)
-
-/**
- * MATHB - Configures MATHB command to perform binary operations
- * @program: pointer to struct program
- * @operand1: first operand: MATH0-MATH3, DPOVRD, SEQINSZ, SEQOUTSZ, VSEQINSZ,
- * VSEQOUTSZ, ZERO, ONE, NONE, Immediate value. IMMED must be used to
- * indicate immediate value.
- * @operator: function to be performed: ADD, ADDC, SUB, SUBB, OR, AND, XOR,
- * LSHIFT, RSHIFT, SHLD.
- * @operand2: second operand: MATH0-MATH3, DPOVRD, VSEQINSZ, VSEQOUTSZ, ABD,
- * OFIFO, JOBSRC, ZERO, ONE, Immediate value. IMMED2 must be used to
- * indicate immediate value.
- * @result: destination for the result: MATH0-MATH3, DPOVRD, SEQINSZ, SEQOUTSZ,
- * NONE, VSEQINSZ, VSEQOUTSZ.
- * @length: length in bytes of the operation and the immediate value, if there
- * is one (int).
- * @opt: operational flags: IFB, NFU, STL, SWP, IMMED, IMMED2
- *
- * Return: On success, descriptor buffer offset where this command is inserted.
- * On error, a negative error code; first error program counter will
- * point to offset in descriptor buffer where the instruction should
- * have been written.
- */
-#define MATHB(program, operand1, operator, operand2, result, length, opt) \
- rta_math(program, operand1, MATH_FUN_##operator, operand2, result, \
- length, opt)
-
-/**
- * MATHI - Configures MATHI command to perform binary operations
- * @program: pointer to struct program
- * @operand: if !SSEL: MATH0-MATH3, DPOVRD, SEQINSZ, SEQOUTSZ, VSEQINSZ,
- * VSEQOUTSZ, ZERO, ONE.
- * if SSEL: MATH0-MATH3, DPOVRD, VSEQINSZ, VSEQOUTSZ, ABD, OFIFO,
- * JOBSRC, ZERO, ONE.
- * @operator: function to be performed: ADD, ADDC, SUB, SUBB, OR, AND, XOR,
- * LSHIFT, RSHIFT, FBYT (for !SSEL only).
- * @imm: Immediate value (uint8_t). IMMED must be used to indicate immediate
- * value.
- * @result: destination for the result: MATH0-MATH3, DPOVRD, SEQINSZ, SEQOUTSZ,
- * NONE, VSEQINSZ, VSEQOUTSZ.
- * @length: length in bytes of the operation and the immediate value, if there
- * is one (int). @imm is left-extended with zeros if needed.
- * @opt: operational flags: NFU, SSEL, SWP, IMMED
- *
- * If !SSEL, @operand <@operator> @imm -> @result
- * If SSEL, @imm <@operator> @operand -> @result
- *
- * Return: On success, descriptor buffer offset where this command is inserted.
- * On error, a negative error code; first error program counter will
- * point to offset in descriptor buffer where the instruction should
- * have been written.
- */
-#define MATHI(program, operand, operator, imm, result, length, opt) \
- rta_mathi(program, operand, MATH_FUN_##operator, imm, result, length, \
- opt)
-
-/**
- * MATHU - Configures MATHU command to perform unary operations
- * @program: pointer to struct program
- * @operand1: operand: MATH0-MATH3, DPOVRD, SEQINSZ, SEQOUTSZ, VSEQINSZ,
- * VSEQOUTSZ, ZERO, ONE, NONE, Immediate value. IMMED must be used to
- * indicate immediate value.
- * @operator: function to be performed: ZBYT, BSWAP
- * @result: destination for the result: MATH0-MATH3, DPOVRD, SEQINSZ, SEQOUTSZ,
- * NONE, VSEQINSZ, VSEQOUTSZ.
- * @length: length in bytes of the operation and the immediate value, if there
- * is one (int).
- * @opt: operational flags: NFU, STL, SWP, IMMED
- *
- * Return: On success, descriptor buffer offset where this command is inserted.
- * On error, a negative error code; first error program counter will
- * point to offset in descriptor buffer where the instruction should
- * have been written.
- */
-#define MATHU(program, operand1, operator, result, length, opt) \
- rta_math(program, operand1, MATH_FUN_##operator, NONE, result, length, \
- opt)
-
-/**
- * SIGNATURE - Configures SIGNATURE command
- * @program: pointer to struct program
- * @sign_type: signature type: SIGN_TYPE_FINAL, SIGN_TYPE_FINAL_RESTORE,
- * SIGN_TYPE_FINAL_NONZERO, SIGN_TYPE_IMM_2, SIGN_TYPE_IMM_3,
- * SIGN_TYPE_IMM_4.
- *
- * After SIGNATURE command, DWORD or WORD must be used to insert signature in
- * descriptor buffer.
- *
- * Return: On success, descriptor buffer offset where this command is inserted.
- * On error, a negative error code; first error program counter will
- * point to offset in descriptor buffer where the instruction should
- * have been written.
- */
-#define SIGNATURE(program, sign_type) rta_signature(program, sign_type)
-
-/**
- * NFIFOADD - Configures NFIFO command, a shortcut of RTA Load command to write
- * to iNfo FIFO.
- * @program: pointer to struct program
- * @src: source for the input data in Alignment Block:IFIFO, OFIFO, PAD,
- * MSGOUTSNOOP, ALTSOURCE, OFIFO_SYNC, MSGOUTSNOOP_ALT.
- * @data: type of data that is going through the Input Data FIFO: MSG, MSG1,
- * MSG2, IV1, IV2, ICV1, ICV2, SAD1, AAD1, AAD2, AFHA_SBOX, SKIP,
- * PKHA registers, AB1, AB2, ABD.
- * @length: length of the data copied in FIFO registers (uint32_t)
- * @flags: select options between:
- * -operational flags: LAST1, LAST2, FLUSH1, FLUSH2, OC, BP
- * -when PAD is selected as source: BM, PR, PS
- * -padding type: <em>PAD_ZERO, PAD_NONZERO, PAD_INCREMENT, PAD_RANDOM,
- * PAD_ZERO_N1, PAD_NONZERO_0, PAD_N1, PAD_NONZERO_N
- *
- * Return: On success, descriptor buffer offset where this command is inserted.
- * On error, a negative error code; first error program counter will
- * point to offset in descriptor buffer where the instruction should
- * have been written.
- */
-#define NFIFOADD(program, src, data, length, flags) \
- rta_nfifo_load(program, src, data, length, flags)
-
-/**
- * DOC: Self Referential Code Management Routines
- *
- * Contains details of RTA self referential code routines.
- */
-
-/**
- * REFERENCE - initialize a variable used for storing an index inside a
- * descriptor buffer.
- * @ref: reference to a descriptor buffer's index where an update is required
- * with a value that will be known latter in the program flow.
- */
-#define REFERENCE(ref) int ref = -1
-
-/**
- * LABEL - initialize a variable used for storing an index inside a descriptor
- * buffer.
- * @label: label stores the value with what should be updated the REFERENCE line
- * in the descriptor buffer.
- */
-#define LABEL(label) unsigned int label = 0
-
-/**
- * SET_LABEL - set a LABEL value
- * @program: pointer to struct program
- * @label: value that will be inserted in a line previously written in the
- * descriptor buffer.
- */
-#define SET_LABEL(program, label) (label = rta_set_label(program))
-
-/**
- * PATCH_JUMP - Auxiliary command to resolve self referential code
- * @program: buffer to be updated (struct program *)
- * @line: position in descriptor buffer where the update will be done; this
- * value is previously retained in program flow using a reference near
- * the sequence to be modified.
- * @new_ref: updated value that will be inserted in descriptor buffer at the
- * specified line; this value is previously obtained using SET_LABEL
- * macro near the line that will be used as reference (unsigned int).
- * For JUMP command, the value represents the offset field (in words).
- *
- * Return: 0 in case of success, a negative error code if it fails
- */
-#define PATCH_JUMP(program, line, new_ref) rta_patch_jmp(program, line, new_ref)
-
-/**
- * PATCH_MOVE - Auxiliary command to resolve self referential code
- * @program: buffer to be updated (struct program *)
- * @line: position in descriptor buffer where the update will be done; this
- * value is previously retained in program flow using a reference near
- * the sequence to be modified.
- * @new_ref: updated value that will be inserted in descriptor buffer at the
- * specified line; this value is previously obtained using SET_LABEL
- * macro near the line that will be used as reference (unsigned int).
- * For MOVE command, the value represents the offset field (in words).
- *
- * Return: 0 in case of success, a negative error code if it fails
- */
-#define PATCH_MOVE(program, line, new_ref) \
- rta_patch_move(program, line, new_ref)
-
-/**
- * PATCH_LOAD - Auxiliary command to resolve self referential code
- * @program: buffer to be updated (struct program *)
- * @line: position in descriptor buffer where the update will be done; this
- * value is previously retained in program flow using a reference near
- * the sequence to be modified.
- * @new_ref: updated value that will be inserted in descriptor buffer at the
- * specified line; this value is previously obtained using SET_LABEL
- * macro near the line that will be used as reference (unsigned int).
- * For LOAD command, the value represents the offset field (in words).
- *
- * Return: 0 in case of success, a negative error code if it fails
- */
-#define PATCH_LOAD(program, line, new_ref) \
- rta_patch_load(program, line, new_ref)
-
-/**
- * PATCH_STORE - Auxiliary command to resolve self referential code
- * @program: buffer to be updated (struct program *)
- * @line: position in descriptor buffer where the update will be done; this
- * value is previously retained in program flow using a reference near
- * the sequence to be modified.
- * @new_ref: updated value that will be inserted in descriptor buffer at the
- * specified line; this value is previously obtained using SET_LABEL
- * macro near the line that will be used as reference (unsigned int).
- * For STORE command, the value represents the offset field (in words).
- *
- * Return: 0 in case of success, a negative error code if it fails
- */
-#define PATCH_STORE(program, line, new_ref) \
- rta_patch_store(program, line, new_ref)
-
-/**
- * PATCH_HDR - Auxiliary command to resolve self referential code
- * @program: buffer to be updated (struct program *)
- * @line: position in descriptor buffer where the update will be done; this
- * value is previously retained in program flow using a reference near
- * the sequence to be modified.
- * @new_ref: updated value that will be inserted in descriptor buffer at the
- * specified line; this value is previously obtained using SET_LABEL
- * macro near the line that will be used as reference (unsigned int).
- * For HEADER command, the value represents the start index field.
- *
- * Return: 0 in case of success, a negative error code if it fails
- */
-#define PATCH_HDR(program, line, new_ref) \
- rta_patch_header(program, line, new_ref)
-
-/**
- * PATCH_RAW - Auxiliary command to resolve self referential code
- * @program: buffer to be updated (struct program *)
- * @line: position in descriptor buffer where the update will be done; this
- * value is previously retained in program flow using a reference near
- * the sequence to be modified.
- * @mask: mask to be used for applying the new value (unsigned int). The mask
- * selects which bits from the provided @new_val are taken into
- * consideration when overwriting the existing value.
- * @new_val: updated value that will be masked using the provided mask value
- * and inserted in descriptor buffer at the specified line.
- *
- * Return: 0 in case of success, a negative error code if it fails
- */
-#define PATCH_RAW(program, line, mask, new_val) \
- rta_patch_raw(program, line, mask, new_val)
-
-#endif /* __RTA_RTA_H__ */
+++ /dev/null
-/* SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0)
- *
- * Copyright 2008-2016 Freescale Semiconductor Inc.
- * Copyright 2016,2019 NXP
- */
-
-#ifndef __RTA_FIFO_LOAD_STORE_CMD_H__
-#define __RTA_FIFO_LOAD_STORE_CMD_H__
-
-extern enum rta_sec_era rta_sec_era;
-
-static const uint32_t fifo_load_table[][2] = {
-/*1*/ { PKA0, FIFOLD_CLASS_CLASS1 | FIFOLD_TYPE_PK_A0 },
- { PKA1, FIFOLD_CLASS_CLASS1 | FIFOLD_TYPE_PK_A1 },
- { PKA2, FIFOLD_CLASS_CLASS1 | FIFOLD_TYPE_PK_A2 },
- { PKA3, FIFOLD_CLASS_CLASS1 | FIFOLD_TYPE_PK_A3 },
- { PKB0, FIFOLD_CLASS_CLASS1 | FIFOLD_TYPE_PK_B0 },
- { PKB1, FIFOLD_CLASS_CLASS1 | FIFOLD_TYPE_PK_B1 },
- { PKB2, FIFOLD_CLASS_CLASS1 | FIFOLD_TYPE_PK_B2 },
- { PKB3, FIFOLD_CLASS_CLASS1 | FIFOLD_TYPE_PK_B3 },
- { PKA, FIFOLD_CLASS_CLASS1 | FIFOLD_TYPE_PK_A },
- { PKB, FIFOLD_CLASS_CLASS1 | FIFOLD_TYPE_PK_B },
- { PKN, FIFOLD_CLASS_CLASS1 | FIFOLD_TYPE_PK_N },
- { SKIP, FIFOLD_CLASS_SKIP },
- { MSG1, FIFOLD_CLASS_CLASS1 | FIFOLD_TYPE_MSG },
- { MSG2, FIFOLD_CLASS_CLASS2 | FIFOLD_TYPE_MSG },
- { MSGOUTSNOOP, FIFOLD_CLASS_BOTH | FIFOLD_TYPE_MSG1OUT2 },
- { MSGINSNOOP, FIFOLD_CLASS_BOTH | FIFOLD_TYPE_MSG },
- { IV1, FIFOLD_CLASS_CLASS1 | FIFOLD_TYPE_IV },
- { IV2, FIFOLD_CLASS_CLASS2 | FIFOLD_TYPE_IV },
- { AAD1, FIFOLD_CLASS_CLASS1 | FIFOLD_TYPE_AAD },
- { ICV1, FIFOLD_CLASS_CLASS1 | FIFOLD_TYPE_ICV },
- { ICV2, FIFOLD_CLASS_CLASS2 | FIFOLD_TYPE_ICV },
- { BIT_DATA, FIFOLD_TYPE_BITDATA },
-/*23*/ { IFIFO, FIFOLD_CLASS_CLASS1 | FIFOLD_TYPE_NOINFOFIFO }
-};
-
-/*
- * Allowed FIFO_LOAD input data types for each SEC Era.
- * Values represent the number of entries from fifo_load_table[] that are
- * supported.
- */
-static const unsigned int fifo_load_table_sz[] = {22, 22, 23, 23,
- 23, 23, 23, 23,
- 23, 23};
-
-static inline int
-rta_fifo_load(struct program *program, uint32_t src,
- uint64_t loc, uint32_t length, uint32_t flags)
-{
- uint32_t opcode = 0;
- uint32_t ext_length = 0, val = 0;
- int ret = -EINVAL;
- bool is_seq_cmd = false;
- unsigned int start_pc = program->current_pc;
-
- /* write command type field */
- if (flags & SEQ) {
- opcode = CMD_SEQ_FIFO_LOAD;
- is_seq_cmd = true;
- } else {
- opcode = CMD_FIFO_LOAD;
- }
-
- /* Parameters checking */
- if (is_seq_cmd) {
- if ((flags & IMMED) || (flags & SGF)) {
- pr_err("SEQ FIFO LOAD: Invalid command\n");
- goto err;
- }
- if ((rta_sec_era <= RTA_SEC_ERA_5) && (flags & AIDF)) {
- pr_err("SEQ FIFO LOAD: Flag(s) not supported by SEC Era %d\n",
- USER_SEC_ERA(rta_sec_era));
- goto err;
- }
- if ((flags & VLF) && ((flags & EXT) || (length >> 16))) {
- pr_err("SEQ FIFO LOAD: Invalid usage of VLF\n");
- goto err;
- }
- } else {
- if (src == SKIP) {
- pr_err("FIFO LOAD: Invalid src\n");
- goto err;
- }
- if ((flags & AIDF) || (flags & VLF)) {
- pr_err("FIFO LOAD: Invalid command\n");
- goto err;
- }
- if ((flags & IMMED) && (flags & SGF)) {
- pr_err("FIFO LOAD: Invalid usage of SGF and IMM\n");
- goto err;
- }
- if ((flags & IMMED) && ((flags & EXT) || (length >> 16))) {
- pr_err("FIFO LOAD: Invalid usage of EXT and IMM\n");
- goto err;
- }
- }
-
- /* write input data type field */
- ret = __rta_map_opcode(src, fifo_load_table,
- fifo_load_table_sz[rta_sec_era], &val);
- if (ret < 0) {
- pr_err("FIFO LOAD: Source value is not supported. SEC Program Line: %d\n",
- program->current_pc);
- goto err;
- }
- opcode |= val;
-
- if (flags & CLASS1)
- opcode |= FIFOLD_CLASS_CLASS1;
- if (flags & CLASS2)
- opcode |= FIFOLD_CLASS_CLASS2;
- if (flags & BOTH)
- opcode |= FIFOLD_CLASS_BOTH;
-
- /* write fields: SGF|VLF, IMM, [LC1, LC2, F1] */
- if (flags & FLUSH1)
- opcode |= FIFOLD_TYPE_FLUSH1;
- if (flags & LAST1)
- opcode |= FIFOLD_TYPE_LAST1;
- if (flags & LAST2)
- opcode |= FIFOLD_TYPE_LAST2;
- if (!is_seq_cmd) {
- if (flags & SGF)
- opcode |= FIFOLDST_SGF;
- if (flags & IMMED)
- opcode |= FIFOLD_IMM;
- } else {
- if (flags & VLF)
- opcode |= FIFOLDST_VLF;
- if (flags & AIDF)
- opcode |= FIFOLD_AIDF;
- }
-
- /*
- * Verify if extended length is required. In case of BITDATA, calculate
- * number of full bytes and additional valid bits.
- */
- if ((flags & EXT) || (length >> 16)) {
- opcode |= FIFOLDST_EXT;
- if (src == BIT_DATA) {
- ext_length = (length / 8);
- length = (length % 8);
- } else {
- ext_length = length;
- length = 0;
- }
- }
- opcode |= (uint16_t) length;
-
- __rta_out32(program, opcode);
- program->current_instruction++;
-
- /* write pointer or immediate data field */
- if (flags & IMMED)
- __rta_inline_data(program, loc, flags & __COPY_MASK, length);
- else if (!is_seq_cmd)
- __rta_out64(program, program->ps, loc);
-
- /* write extended length field */
- if (opcode & FIFOLDST_EXT)
- __rta_out32(program, ext_length);
-
- return (int)start_pc;
-
- err:
- program->first_error_pc = start_pc;
- program->current_instruction++;
- return ret;
-}
-
-static const uint32_t fifo_store_table[][2] = {
-/*1*/ { PKA0, FIFOST_TYPE_PKHA_A0 },
- { PKA1, FIFOST_TYPE_PKHA_A1 },
- { PKA2, FIFOST_TYPE_PKHA_A2 },
- { PKA3, FIFOST_TYPE_PKHA_A3 },
- { PKB0, FIFOST_TYPE_PKHA_B0 },
- { PKB1, FIFOST_TYPE_PKHA_B1 },
- { PKB2, FIFOST_TYPE_PKHA_B2 },
- { PKB3, FIFOST_TYPE_PKHA_B3 },
- { PKA, FIFOST_TYPE_PKHA_A },
- { PKB, FIFOST_TYPE_PKHA_B },
- { PKN, FIFOST_TYPE_PKHA_N },
- { PKE, FIFOST_TYPE_PKHA_E_JKEK },
- { RNG, FIFOST_TYPE_RNGSTORE },
- { RNGOFIFO, FIFOST_TYPE_RNGFIFO },
- { AFHA_SBOX, FIFOST_TYPE_AF_SBOX_JKEK },
- { MDHA_SPLIT_KEY, FIFOST_CLASS_CLASS2KEY | FIFOST_TYPE_SPLIT_KEK },
- { MSG, FIFOST_TYPE_MESSAGE_DATA },
- { KEY1, FIFOST_CLASS_CLASS1KEY | FIFOST_TYPE_KEY_KEK },
- { KEY2, FIFOST_CLASS_CLASS2KEY | FIFOST_TYPE_KEY_KEK },
- { OFIFO, FIFOST_TYPE_OUTFIFO_KEK},
- { SKIP, FIFOST_TYPE_SKIP },
-/*22*/ { METADATA, FIFOST_TYPE_METADATA},
- { MSG_CKSUM, FIFOST_TYPE_MESSAGE_DATA2 }
-};
-
-/*
- * Allowed FIFO_STORE output data types for each SEC Era.
- * Values represent the number of entries from fifo_store_table[] that are
- * supported.
- */
-static const unsigned int fifo_store_table_sz[] = {21, 21, 21, 21,
- 22, 22, 22, 23,
- 23, 23};
-
-static inline int
-rta_fifo_store(struct program *program, uint32_t src,
- uint32_t encrypt_flags, uint64_t dst,
- uint32_t length, uint32_t flags)
-{
- uint32_t opcode = 0;
- uint32_t val = 0;
- int ret = -EINVAL;
- bool is_seq_cmd = false;
- unsigned int start_pc = program->current_pc;
-
- /* write command type field */
- if (flags & SEQ) {
- opcode = CMD_SEQ_FIFO_STORE;
- is_seq_cmd = true;
- } else {
- opcode = CMD_FIFO_STORE;
- }
-
- /* Parameter checking */
- if (is_seq_cmd) {
- if ((flags & VLF) && ((length >> 16) || (flags & EXT))) {
- pr_err("SEQ FIFO STORE: Invalid usage of VLF\n");
- goto err;
- }
- if (dst) {
- pr_err("SEQ FIFO STORE: Invalid command\n");
- goto err;
- }
- if ((src == METADATA) && (flags & (CONT | EXT))) {
- pr_err("SEQ FIFO STORE: Invalid flags\n");
- goto err;
- }
- } else {
- if (((src == RNGOFIFO) && ((dst) || (flags & EXT))) ||
- (src == METADATA)) {
- pr_err("FIFO STORE: Invalid destination\n");
- goto err;
- }
- }
- if ((rta_sec_era == RTA_SEC_ERA_7) && (src == AFHA_SBOX)) {
- pr_err("FIFO STORE: AFHA S-box not supported by SEC Era %d\n",
- USER_SEC_ERA(rta_sec_era));
- goto err;
- }
-
- /* write output data type field */
- ret = __rta_map_opcode(src, fifo_store_table,
- fifo_store_table_sz[rta_sec_era], &val);
- if (ret < 0) {
- pr_err("FIFO STORE: Source type not supported. SEC Program Line: %d\n",
- program->current_pc);
- goto err;
- }
- opcode |= val;
-
- if (encrypt_flags & TK)
- opcode |= (0x1 << FIFOST_TYPE_SHIFT);
- if (encrypt_flags & EKT) {
- if (rta_sec_era == RTA_SEC_ERA_1) {
- pr_err("FIFO STORE: AES-CCM source types not supported\n");
- ret = -EINVAL;
- goto err;
- }
- opcode |= (0x10 << FIFOST_TYPE_SHIFT);
- opcode &= (uint32_t)~(0x20 << FIFOST_TYPE_SHIFT);
- }
-
- /* write flags fields */
- if (flags & CONT)
- opcode |= FIFOST_CONT;
- if ((flags & VLF) && (is_seq_cmd))
- opcode |= FIFOLDST_VLF;
- if ((flags & SGF) && (!is_seq_cmd))
- opcode |= FIFOLDST_SGF;
- if (flags & CLASS1)
- opcode |= FIFOST_CLASS_CLASS1KEY;
- if (flags & CLASS2)
- opcode |= FIFOST_CLASS_CLASS2KEY;
- if (flags & BOTH)
- opcode |= FIFOST_CLASS_BOTH;
-
- /* Verify if extended length is required */
- if ((length >> 16) || (flags & EXT))
- opcode |= FIFOLDST_EXT;
- else
- opcode |= (uint16_t) length;
-
- __rta_out32(program, opcode);
- program->current_instruction++;
-
- /* write pointer field */
- if ((!is_seq_cmd) && (dst))
- __rta_out64(program, program->ps, dst);
-
- /* write extended length field */
- if (opcode & FIFOLDST_EXT)
- __rta_out32(program, length);
-
- return (int)start_pc;
-
- err:
- program->first_error_pc = start_pc;
- program->current_instruction++;
- return ret;
-}
-
-#endif /* __RTA_FIFO_LOAD_STORE_CMD_H__ */
+++ /dev/null
-/* SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0)
- *
- * Copyright 2008-2016 Freescale Semiconductor Inc.
- * Copyright 2016,2019 NXP
- */
-
-#ifndef __RTA_HEADER_CMD_H__
-#define __RTA_HEADER_CMD_H__
-
-extern enum rta_sec_era rta_sec_era;
-
-/* Allowed job header flags for each SEC Era. */
-static const uint32_t job_header_flags[] = {
- DNR | TD | MTD | SHR | REO,
- DNR | TD | MTD | SHR | REO | RSMS,
- DNR | TD | MTD | SHR | REO | RSMS,
- DNR | TD | MTD | SHR | REO | RSMS,
- DNR | TD | MTD | SHR | REO | RSMS | EXT,
- DNR | TD | MTD | SHR | REO | RSMS | EXT,
- DNR | TD | MTD | SHR | REO | RSMS | EXT,
- DNR | TD | MTD | SHR | REO | EXT,
- DNR | TD | MTD | SHR | REO | EXT,
- DNR | TD | MTD | SHR | REO | EXT
-};
-
-/* Allowed shared header flags for each SEC Era. */
-static const uint32_t shr_header_flags[] = {
- DNR | SC | PD,
- DNR | SC | PD | CIF,
- DNR | SC | PD | CIF,
- DNR | SC | PD | CIF | RIF,
- DNR | SC | PD | CIF | RIF,
- DNR | SC | PD | CIF | RIF,
- DNR | SC | PD | CIF | RIF,
- DNR | SC | PD | CIF | RIF,
- DNR | SC | PD | CIF | RIF,
- DNR | SC | PD | CIF | RIF
-};
-
-static inline int
-rta_shr_header(struct program *program,
- enum rta_share_type share,
- unsigned int start_idx,
- uint32_t flags)
-{
- uint32_t opcode = CMD_SHARED_DESC_HDR;
- unsigned int start_pc = program->current_pc;
-
- if (flags & ~shr_header_flags[rta_sec_era]) {
- pr_err("SHR_DESC: Flag(s) not supported by SEC Era %d\n",
- USER_SEC_ERA(rta_sec_era));
- goto err;
- }
-
- switch (share) {
- case SHR_ALWAYS:
- opcode |= HDR_SHARE_ALWAYS;
- break;
- case SHR_SERIAL:
- opcode |= HDR_SHARE_SERIAL;
- break;
- case SHR_NEVER:
- /*
- * opcode |= HDR_SHARE_NEVER;
- * HDR_SHARE_NEVER is 0
- */
- break;
- case SHR_WAIT:
- opcode |= HDR_SHARE_WAIT;
- break;
- default:
- pr_err("SHR_DESC: SHARE VALUE is not supported. SEC Program Line: %d\n",
- program->current_pc);
- goto err;
- }
-
- opcode |= HDR_ONE;
- if (rta_sec_era >= RTA_SEC_ERA_10)
- opcode |= (start_idx << HDR_START_IDX_SHIFT) &
- HDR_START_IDX_MASK_ERA10;
- else
- opcode |= (start_idx << HDR_START_IDX_SHIFT) &
- HDR_START_IDX_MASK;
-
- if (flags & DNR)
- opcode |= HDR_DNR;
- if (flags & CIF)
- opcode |= HDR_CLEAR_IFIFO;
- if (flags & SC)
- opcode |= HDR_SAVECTX;
- if (flags & PD)
- opcode |= HDR_PROP_DNR;
- if (flags & RIF)
- opcode |= HDR_RIF;
-
- __rta_out32(program, opcode);
- program->current_instruction++;
-
- if (program->current_instruction == 1)
- program->shrhdr = program->buffer;
-
- return (int)start_pc;
-
- err:
- program->first_error_pc = start_pc;
- program->current_instruction++;
- return -EINVAL;
-}
-
-static inline int
-rta_job_header(struct program *program,
- enum rta_share_type share,
- unsigned int start_idx,
- uint64_t shr_desc, uint32_t flags,
- uint32_t ext_flags)
-{
- uint32_t opcode = CMD_DESC_HDR;
- uint32_t hdr_ext = 0;
- unsigned int start_pc = program->current_pc;
-
- if (flags & ~job_header_flags[rta_sec_era]) {
- pr_err("JOB_DESC: Flag(s) not supported by SEC Era %d\n",
- USER_SEC_ERA(rta_sec_era));
- goto err;
- }
-
- switch (share) {
- case SHR_ALWAYS:
- opcode |= HDR_SHARE_ALWAYS;
- break;
- case SHR_SERIAL:
- opcode |= HDR_SHARE_SERIAL;
- break;
- case SHR_NEVER:
- /*
- * opcode |= HDR_SHARE_NEVER;
- * HDR_SHARE_NEVER is 0
- */
- break;
- case SHR_WAIT:
- opcode |= HDR_SHARE_WAIT;
- break;
- case SHR_DEFER:
- opcode |= HDR_SHARE_DEFER;
- break;
- default:
- pr_err("JOB_DESC: SHARE VALUE is not supported. SEC Program Line: %d\n",
- program->current_pc);
- goto err;
- }
-
- if ((flags & TD) && (flags & REO)) {
- pr_err("JOB_DESC: REO flag not supported for trusted descriptors. SEC Program Line: %d\n",
- program->current_pc);
- goto err;
- }
-
- if ((rta_sec_era < RTA_SEC_ERA_7) && (flags & MTD) && !(flags & TD)) {
- pr_err("JOB_DESC: Trying to MTD a descriptor that is not a TD. SEC Program Line: %d\n",
- program->current_pc);
- goto err;
- }
-
- if ((flags & EXT) && !(flags & SHR) && (start_idx < 2)) {
- pr_err("JOB_DESC: Start index must be >= 2 in case of no SHR and EXT. SEC Program Line: %d\n",
- program->current_pc);
- goto err;
- }
-
- opcode |= HDR_ONE;
- if (rta_sec_era >= RTA_SEC_ERA_10)
- opcode |= (start_idx << HDR_START_IDX_SHIFT) &
- HDR_START_IDX_MASK_ERA10;
- else
- opcode |= (start_idx << HDR_START_IDX_SHIFT) &
- HDR_START_IDX_MASK;
-
- if (flags & EXT) {
- opcode |= HDR_EXT;
-
- if (ext_flags & DSV) {
- hdr_ext |= HDR_EXT_DSEL_VALID;
- hdr_ext |= ext_flags & DSEL_MASK;
- }
-
- if (ext_flags & FTD) {
- if (rta_sec_era <= RTA_SEC_ERA_5) {
- pr_err("JOB_DESC: Fake trusted descriptor not supported by SEC Era %d\n",
- USER_SEC_ERA(rta_sec_era));
- goto err;
- }
-
- hdr_ext |= HDR_EXT_FTD;
- }
- }
- if (flags & RSMS)
- opcode |= HDR_RSLS;
- if (flags & DNR)
- opcode |= HDR_DNR;
- if (flags & TD)
- opcode |= HDR_TRUSTED;
- if (flags & MTD)
- opcode |= HDR_MAKE_TRUSTED;
- if (flags & REO)
- opcode |= HDR_REVERSE;
- if (flags & SHR)
- opcode |= HDR_SHARED;
-
- __rta_out32(program, opcode);
- program->current_instruction++;
-
- if (program->current_instruction == 1) {
- program->jobhdr = program->buffer;
-
- if (opcode & HDR_SHARED)
- __rta_out64(program, program->ps, shr_desc);
- }
-
- if (flags & EXT)
- __rta_out32(program, hdr_ext);
-
- /* Note: descriptor length is set in program_finalize routine */
- return (int)start_pc;
-
- err:
- program->first_error_pc = start_pc;
- program->current_instruction++;
- return -EINVAL;
-}
-
-#endif /* __RTA_HEADER_CMD_H__ */
+++ /dev/null
-/* SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0)
- *
- * Copyright 2008-2016 Freescale Semiconductor Inc.
- * Copyright 2016,2019 NXP
- */
-
-#ifndef __RTA_JUMP_CMD_H__
-#define __RTA_JUMP_CMD_H__
-
-extern enum rta_sec_era rta_sec_era;
-
-static const uint32_t jump_test_cond[][2] = {
- { NIFP, JUMP_COND_NIFP },
- { NIP, JUMP_COND_NIP },
- { NOP, JUMP_COND_NOP },
- { NCP, JUMP_COND_NCP },
- { CALM, JUMP_COND_CALM },
- { SELF, JUMP_COND_SELF },
- { SHRD, JUMP_COND_SHRD },
- { JQP, JUMP_COND_JQP },
- { MATH_Z, JUMP_COND_MATH_Z },
- { MATH_N, JUMP_COND_MATH_N },
- { MATH_NV, JUMP_COND_MATH_NV },
- { MATH_C, JUMP_COND_MATH_C },
- { PK_0, JUMP_COND_PK_0 },
- { PK_GCD_1, JUMP_COND_PK_GCD_1 },
- { PK_PRIME, JUMP_COND_PK_PRIME },
- { CLASS1, JUMP_CLASS_CLASS1 },
- { CLASS2, JUMP_CLASS_CLASS2 },
- { BOTH, JUMP_CLASS_BOTH }
-};
-
-static const uint32_t jump_test_math_cond[][2] = {
- { MATH_Z, JUMP_COND_MATH_Z },
- { MATH_N, JUMP_COND_MATH_N },
- { MATH_NV, JUMP_COND_MATH_NV },
- { MATH_C, JUMP_COND_MATH_C }
-};
-
-static const uint32_t jump_src_dst[][2] = {
- { MATH0, JUMP_SRC_DST_MATH0 },
- { MATH1, JUMP_SRC_DST_MATH1 },
- { MATH2, JUMP_SRC_DST_MATH2 },
- { MATH3, JUMP_SRC_DST_MATH3 },
- { DPOVRD, JUMP_SRC_DST_DPOVRD },
- { SEQINSZ, JUMP_SRC_DST_SEQINLEN },
- { SEQOUTSZ, JUMP_SRC_DST_SEQOUTLEN },
- { VSEQINSZ, JUMP_SRC_DST_VARSEQINLEN },
- { VSEQOUTSZ, JUMP_SRC_DST_VARSEQOUTLEN }
-};
-
-static inline int
-rta_jump(struct program *program, uint64_t address,
- enum rta_jump_type jump_type,
- enum rta_jump_cond test_type,
- uint32_t test_condition, uint32_t src_dst)
-{
- uint32_t opcode = CMD_JUMP;
- unsigned int start_pc = program->current_pc;
- int ret = -EINVAL;
-
- if (((jump_type == GOSUB) || (jump_type == RETURN)) &&
- (rta_sec_era < RTA_SEC_ERA_4)) {
- pr_err("JUMP: Jump type not supported by SEC Era %d\n",
- USER_SEC_ERA(rta_sec_era));
- goto err;
- }
-
- if (((jump_type == LOCAL_JUMP_INC) || (jump_type == LOCAL_JUMP_DEC)) &&
- (rta_sec_era <= RTA_SEC_ERA_5)) {
- pr_err("JUMP_INCDEC: Jump type not supported by SEC Era %d\n",
- USER_SEC_ERA(rta_sec_era));
- goto err;
- }
-
- switch (jump_type) {
- case (LOCAL_JUMP):
- /*
- * opcode |= JUMP_TYPE_LOCAL;
- * JUMP_TYPE_LOCAL is 0
- */
- break;
- case (HALT):
- opcode |= JUMP_TYPE_HALT;
- break;
- case (HALT_STATUS):
- opcode |= JUMP_TYPE_HALT_USER;
- break;
- case (FAR_JUMP):
- opcode |= JUMP_TYPE_NONLOCAL;
- break;
- case (GOSUB):
- opcode |= JUMP_TYPE_GOSUB;
- break;
- case (RETURN):
- opcode |= JUMP_TYPE_RETURN;
- break;
- case (LOCAL_JUMP_INC):
- opcode |= JUMP_TYPE_LOCAL_INC;
- break;
- case (LOCAL_JUMP_DEC):
- opcode |= JUMP_TYPE_LOCAL_DEC;
- break;
- default:
- pr_err("JUMP: Invalid jump type. SEC Program Line: %d\n",
- program->current_pc);
- goto err;
- }
-
- switch (test_type) {
- case (ALL_TRUE):
- /*
- * opcode |= JUMP_TEST_ALL;
- * JUMP_TEST_ALL is 0
- */
- break;
- case (ALL_FALSE):
- opcode |= JUMP_TEST_INVALL;
- break;
- case (ANY_TRUE):
- opcode |= JUMP_TEST_ANY;
- break;
- case (ANY_FALSE):
- opcode |= JUMP_TEST_INVANY;
- break;
- default:
- pr_err("JUMP: test type not supported. SEC Program Line: %d\n",
- program->current_pc);
- goto err;
- }
-
- /* write test condition field */
- if ((jump_type != LOCAL_JUMP_INC) && (jump_type != LOCAL_JUMP_DEC)) {
- __rta_map_flags(test_condition, jump_test_cond,
- ARRAY_SIZE(jump_test_cond), &opcode);
- } else {
- uint32_t val = 0;
-
- ret = __rta_map_opcode(src_dst, jump_src_dst,
- ARRAY_SIZE(jump_src_dst), &val);
- if (ret < 0) {
- pr_err("JUMP_INCDEC: SRC_DST not supported. SEC PC: %d; Instr: %d\n",
- program->current_pc,
- program->current_instruction);
- goto err;
- }
- opcode |= val;
-
- __rta_map_flags(test_condition, jump_test_math_cond,
- ARRAY_SIZE(jump_test_math_cond), &opcode);
- }
-
- /* write local offset field for local jumps and user-defined halt */
- if ((jump_type == LOCAL_JUMP) || (jump_type == LOCAL_JUMP_INC) ||
- (jump_type == LOCAL_JUMP_DEC) || (jump_type == GOSUB) ||
- (jump_type == HALT_STATUS))
- opcode |= (uint32_t)(address & JUMP_OFFSET_MASK);
-
- __rta_out32(program, opcode);
- program->current_instruction++;
-
- if (jump_type == FAR_JUMP)
- __rta_out64(program, program->ps, address);
-
- return (int)start_pc;
-
- err:
- program->first_error_pc = start_pc;
- program->current_instruction++;
- return ret;
-}
-
-#endif /* __RTA_JUMP_CMD_H__ */
+++ /dev/null
-/* SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0)
- *
- * Copyright 2008-2016 Freescale Semiconductor Inc.
- * Copyright 2016,2019 NXP
- */
-
-#ifndef __RTA_KEY_CMD_H__
-#define __RTA_KEY_CMD_H__
-
-extern enum rta_sec_era rta_sec_era;
-
-/* Allowed encryption flags for each SEC Era */
-static const uint32_t key_enc_flags[] = {
- ENC,
- ENC | NWB | EKT | TK,
- ENC | NWB | EKT | TK,
- ENC | NWB | EKT | TK,
- ENC | NWB | EKT | TK,
- ENC | NWB | EKT | TK,
- ENC | NWB | EKT | TK | PTS,
- ENC | NWB | EKT | TK | PTS,
- ENC | NWB | EKT | TK | PTS,
- ENC | NWB | EKT | TK | PTS
-};
-
-static inline int
-rta_key(struct program *program, uint32_t key_dst,
- uint32_t encrypt_flags, uint64_t src, uint32_t length,
- uint32_t flags)
-{
- uint32_t opcode = 0;
- bool is_seq_cmd = false;
- unsigned int start_pc = program->current_pc;
-
- if (encrypt_flags & ~key_enc_flags[rta_sec_era]) {
- pr_err("KEY: Flag(s) not supported by SEC Era %d\n",
- USER_SEC_ERA(rta_sec_era));
- goto err;
- }
-
- /* write cmd type */
- if (flags & SEQ) {
- opcode = CMD_SEQ_KEY;
- is_seq_cmd = true;
- } else {
- opcode = CMD_KEY;
- }
-
- /* check parameters */
- if (is_seq_cmd) {
- if ((flags & IMMED) || (flags & SGF)) {
- pr_err("SEQKEY: Invalid flag. SEC PC: %d; Instr: %d\n",
- program->current_pc,
- program->current_instruction);
- goto err;
- }
- if ((rta_sec_era <= RTA_SEC_ERA_5) &&
- ((flags & VLF) || (flags & AIDF))) {
- pr_err("SEQKEY: Flag(s) not supported by SEC Era %d\n",
- USER_SEC_ERA(rta_sec_era));
- goto err;
- }
- } else {
- if ((flags & AIDF) || (flags & VLF)) {
- pr_err("KEY: Invalid flag. SEC PC: %d; Instr: %d\n",
- program->current_pc,
- program->current_instruction);
- goto err;
- }
- if ((flags & SGF) && (flags & IMMED)) {
- pr_err("KEY: Invalid flag. SEC PC: %d; Instr: %d\n",
- program->current_pc,
- program->current_instruction);
- goto err;
- }
- }
-
- if ((encrypt_flags & PTS) &&
- ((encrypt_flags & ENC) || (encrypt_flags & NWB) ||
- (key_dst == PKE))) {
- pr_err("KEY: Invalid flag / destination. SEC PC: %d; Instr: %d\n",
- program->current_pc, program->current_instruction);
- goto err;
- }
-
- if (key_dst == AFHA_SBOX) {
- if (rta_sec_era == RTA_SEC_ERA_7) {
- pr_err("KEY: AFHA S-box not supported by SEC Era %d\n",
- USER_SEC_ERA(rta_sec_era));
- goto err;
- }
-
- if (flags & IMMED) {
- pr_err("KEY: Invalid flag. SEC PC: %d; Instr: %d\n",
- program->current_pc,
- program->current_instruction);
- goto err;
- }
-
- /*
- * Sbox data loaded into the ARC-4 processor must be exactly
- * 258 bytes long, or else a data sequence error is generated.
- */
- if (length != 258) {
- pr_err("KEY: Invalid length. SEC PC: %d; Instr: %d\n",
- program->current_pc,
- program->current_instruction);
- goto err;
- }
- }
-
- /* write key destination and class fields */
- switch (key_dst) {
- case (KEY1):
- opcode |= KEY_DEST_CLASS1;
- break;
- case (KEY2):
- opcode |= KEY_DEST_CLASS2;
- break;
- case (PKE):
- opcode |= KEY_DEST_CLASS1 | KEY_DEST_PKHA_E;
- break;
- case (AFHA_SBOX):
- opcode |= KEY_DEST_CLASS1 | KEY_DEST_AFHA_SBOX;
- break;
- case (MDHA_SPLIT_KEY):
- opcode |= KEY_DEST_CLASS2 | KEY_DEST_MDHA_SPLIT;
- break;
- default:
- pr_err("KEY: Invalid destination. SEC PC: %d; Instr: %d\n",
- program->current_pc, program->current_instruction);
- goto err;
- }
-
- /* write key length */
- length &= KEY_LENGTH_MASK;
- opcode |= length;
-
- /* write key command specific flags */
- if (encrypt_flags & ENC) {
- /* Encrypted (black) keys must be padded to 8 bytes (CCM) or
- * 16 bytes (ECB) depending on EKT bit. AES-CCM encrypted keys
- * (EKT = 1) have 6-byte nonce and 6-byte MAC after padding.
- */
- opcode |= KEY_ENC;
- if (encrypt_flags & EKT) {
- opcode |= KEY_EKT;
- length = ALIGN(length, 8);
- length += 12;
- } else {
- length = ALIGN(length, 16);
- }
- if (encrypt_flags & TK)
- opcode |= KEY_TK;
- }
- if (encrypt_flags & NWB)
- opcode |= KEY_NWB;
- if (encrypt_flags & PTS)
- opcode |= KEY_PTS;
-
- /* write general command flags */
- if (!is_seq_cmd) {
- if (flags & IMMED)
- opcode |= KEY_IMM;
- if (flags & SGF)
- opcode |= KEY_SGF;
- } else {
- if (flags & AIDF)
- opcode |= KEY_AIDF;
- if (flags & VLF)
- opcode |= KEY_VLF;
- }
-
- __rta_out32(program, opcode);
- program->current_instruction++;
-
- if (flags & IMMED)
- __rta_inline_data(program, src, flags & __COPY_MASK, length);
- else
- __rta_out64(program, program->ps, src);
-
- return (int)start_pc;
-
- err:
- program->first_error_pc = start_pc;
- program->current_instruction++;
- return -EINVAL;
-}
-
-#endif /* __RTA_KEY_CMD_H__ */
+++ /dev/null
-/* SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0)
- *
- * Copyright 2008-2016 Freescale Semiconductor Inc.
- * Copyright 2016,2019 NXP
- */
-
-#ifndef __RTA_LOAD_CMD_H__
-#define __RTA_LOAD_CMD_H__
-
-extern enum rta_sec_era rta_sec_era;
-
-/* Allowed length and offset masks for each SEC Era in case DST = DCTRL */
-static const uint32_t load_len_mask_allowed[] = {
- 0x000000ee,
- 0x000000fe,
- 0x000000fe,
- 0x000000fe,
- 0x000000fe,
- 0x000000fe,
- 0x000000fe,
- 0x000000fe,
- 0x000000fe,
- 0x000000fe
-};
-
-static const uint32_t load_off_mask_allowed[] = {
- 0x0000000f,
- 0x000000ff,
- 0x000000ff,
- 0x000000ff,
- 0x000000ff,
- 0x000000ff,
- 0x000000ff,
- 0x000000ff,
- 0x000000ff,
- 0x000000ff
-};
-
-#define IMM_MUST 0
-#define IMM_CAN 1
-#define IMM_NO 2
-#define IMM_DSNM 3 /* it doesn't matter the src type */
-
-enum e_lenoff {
- LENOF_03,
- LENOF_4,
- LENOF_48,
- LENOF_448,
- LENOF_18,
- LENOF_32,
- LENOF_24,
- LENOF_16,
- LENOF_8,
- LENOF_128,
- LENOF_256,
- DSNM /* it doesn't matter the length/offset values */
-};
-
-struct load_map {
- uint32_t dst;
- uint32_t dst_opcode;
- enum e_lenoff len_off;
- uint8_t imm_src;
-
-};
-
-static const struct load_map load_dst[] = {
-/*1*/ { KEY1SZ, LDST_CLASS_1_CCB | LDST_SRCDST_WORD_KEYSZ_REG,
- LENOF_4, IMM_MUST },
- { KEY2SZ, LDST_CLASS_2_CCB | LDST_SRCDST_WORD_KEYSZ_REG,
- LENOF_4, IMM_MUST },
- { DATA1SZ, LDST_CLASS_1_CCB | LDST_SRCDST_WORD_DATASZ_REG,
- LENOF_448, IMM_MUST },
- { DATA2SZ, LDST_CLASS_2_CCB | LDST_SRCDST_WORD_DATASZ_REG,
- LENOF_448, IMM_MUST },
- { ICV1SZ, LDST_CLASS_1_CCB | LDST_SRCDST_WORD_ICVSZ_REG,
- LENOF_4, IMM_MUST },
- { ICV2SZ, LDST_CLASS_2_CCB | LDST_SRCDST_WORD_ICVSZ_REG,
- LENOF_4, IMM_MUST },
- { CCTRL, LDST_CLASS_IND_CCB | LDST_SRCDST_WORD_CHACTRL,
- LENOF_4, IMM_MUST },
- { DCTRL, LDST_CLASS_DECO | LDST_IMM | LDST_SRCDST_WORD_DECOCTRL,
- DSNM, IMM_DSNM },
- { ICTRL, LDST_CLASS_IND_CCB | LDST_SRCDST_WORD_IRQCTRL,
- LENOF_4, IMM_MUST },
- { DPOVRD, LDST_CLASS_DECO | LDST_SRCDST_WORD_DECO_PCLOVRD,
- LENOF_4, IMM_MUST },
- { CLRW, LDST_CLASS_IND_CCB | LDST_SRCDST_WORD_CLRW,
- LENOF_4, IMM_MUST },
- { AAD1SZ, LDST_CLASS_1_CCB | LDST_SRCDST_WORD_DECO_AAD_SZ,
- LENOF_4, IMM_MUST },
- { IV1SZ, LDST_CLASS_1_CCB | LDST_SRCDST_WORD_CLASS1_IV_SZ,
- LENOF_4, IMM_MUST },
- { ALTDS1, LDST_CLASS_1_CCB | LDST_SRCDST_WORD_ALTDS_CLASS1,
- LENOF_448, IMM_MUST },
- { PKASZ, LDST_CLASS_1_CCB | LDST_SRCDST_WORD_PKHA_A_SZ,
- LENOF_4, IMM_MUST, },
- { PKBSZ, LDST_CLASS_1_CCB | LDST_SRCDST_WORD_PKHA_B_SZ,
- LENOF_4, IMM_MUST },
- { PKNSZ, LDST_CLASS_1_CCB | LDST_SRCDST_WORD_PKHA_N_SZ,
- LENOF_4, IMM_MUST },
- { PKESZ, LDST_CLASS_1_CCB | LDST_SRCDST_WORD_PKHA_E_SZ,
- LENOF_4, IMM_MUST },
- { NFIFO, LDST_CLASS_IND_CCB | LDST_SRCDST_WORD_INFO_FIFO,
- LENOF_48, IMM_MUST },
- { IFIFO, LDST_SRCDST_BYTE_INFIFO, LENOF_18, IMM_MUST },
- { OFIFO, LDST_SRCDST_BYTE_OUTFIFO, LENOF_18, IMM_MUST },
- { MATH0, LDST_CLASS_DECO | LDST_SRCDST_WORD_DECO_MATH0,
- LENOF_32, IMM_CAN },
- { MATH1, LDST_CLASS_DECO | LDST_SRCDST_WORD_DECO_MATH1,
- LENOF_24, IMM_CAN },
- { MATH2, LDST_CLASS_DECO | LDST_SRCDST_WORD_DECO_MATH2,
- LENOF_16, IMM_CAN },
- { MATH3, LDST_CLASS_DECO | LDST_SRCDST_WORD_DECO_MATH3,
- LENOF_8, IMM_CAN },
- { CONTEXT1, LDST_CLASS_1_CCB | LDST_SRCDST_BYTE_CONTEXT,
- LENOF_128, IMM_CAN },
- { CONTEXT2, LDST_CLASS_2_CCB | LDST_SRCDST_BYTE_CONTEXT,
- LENOF_128, IMM_CAN },
- { KEY1, LDST_CLASS_1_CCB | LDST_SRCDST_BYTE_KEY,
- LENOF_32, IMM_CAN },
- { KEY2, LDST_CLASS_2_CCB | LDST_SRCDST_BYTE_KEY,
- LENOF_32, IMM_CAN },
- { DESCBUF, LDST_CLASS_DECO | LDST_SRCDST_WORD_DESCBUF,
- LENOF_256, IMM_NO },
- { DPID, LDST_CLASS_DECO | LDST_SRCDST_WORD_PID,
- LENOF_448, IMM_MUST },
-/*32*/ { IDFNS, LDST_SRCDST_WORD_IFNSR, LENOF_18, IMM_MUST },
- { ODFNS, LDST_SRCDST_WORD_OFNSR, LENOF_18, IMM_MUST },
- { ALTSOURCE, LDST_SRCDST_BYTE_ALTSOURCE, LENOF_18, IMM_MUST },
-/*35*/ { NFIFO_SZL, LDST_SRCDST_WORD_INFO_FIFO_SZL, LENOF_48, IMM_MUST },
- { NFIFO_SZM, LDST_SRCDST_WORD_INFO_FIFO_SZM, LENOF_03, IMM_MUST },
- { NFIFO_L, LDST_SRCDST_WORD_INFO_FIFO_L, LENOF_48, IMM_MUST },
- { NFIFO_M, LDST_SRCDST_WORD_INFO_FIFO_M, LENOF_03, IMM_MUST },
- { SZL, LDST_SRCDST_WORD_SZL, LENOF_48, IMM_MUST },
-/*40*/ { SZM, LDST_SRCDST_WORD_SZM, LENOF_03, IMM_MUST }
-};
-
-/*
- * Allowed LOAD destinations for each SEC Era.
- * Values represent the number of entries from load_dst[] that are supported.
- */
-static const unsigned int load_dst_sz[] = { 31, 34, 34, 40, 40,
- 40, 40, 40, 40, 40};
-
-static inline int
-load_check_len_offset(int pos, uint32_t length, uint32_t offset)
-{
- if ((load_dst[pos].dst == DCTRL) &&
- ((length & ~load_len_mask_allowed[rta_sec_era]) ||
- (offset & ~load_off_mask_allowed[rta_sec_era])))
- goto err;
-
- switch (load_dst[pos].len_off) {
- case (LENOF_03):
- if ((length > 3) || (offset))
- goto err;
- break;
- case (LENOF_4):
- if ((length != 4) || (offset != 0))
- goto err;
- break;
- case (LENOF_48):
- if (!(((length == 4) && (offset == 0)) ||
- ((length == 8) && (offset == 0))))
- goto err;
- break;
- case (LENOF_448):
- if (!(((length == 4) && (offset == 0)) ||
- ((length == 4) && (offset == 4)) ||
- ((length == 8) && (offset == 0))))
- goto err;
- break;
- case (LENOF_18):
- if ((length < 1) || (length > 8) || (offset != 0))
- goto err;
- break;
- case (LENOF_32):
- if ((length > 32) || (offset > 32) || ((offset + length) > 32))
- goto err;
- break;
- case (LENOF_24):
- if ((length > 24) || (offset > 24) || ((offset + length) > 24))
- goto err;
- break;
- case (LENOF_16):
- if ((length > 16) || (offset > 16) || ((offset + length) > 16))
- goto err;
- break;
- case (LENOF_8):
- if ((length > 8) || (offset > 8) || ((offset + length) > 8))
- goto err;
- break;
- case (LENOF_128):
- if ((length > 128) || (offset > 128) ||
- ((offset + length) > 128))
- goto err;
- break;
- case (LENOF_256):
- if ((length < 1) || (length > 256) || ((length + offset) > 256))
- goto err;
- break;
- case (DSNM):
- break;
- default:
- goto err;
- }
-
- return 0;
-err:
- return -EINVAL;
-}
-
-static inline int
-rta_load(struct program *program, uint64_t src, uint64_t dst,
- uint32_t offset, uint32_t length, uint32_t flags)
-{
- uint32_t opcode = 0;
- int pos = -1, ret = -EINVAL;
- unsigned int start_pc = program->current_pc, i;
-
- if (flags & SEQ)
- opcode = CMD_SEQ_LOAD;
- else
- opcode = CMD_LOAD;
-
- if ((length & 0xffffff00) || (offset & 0xffffff00)) {
- pr_err("LOAD: Bad length/offset passed. Should be 8 bits\n");
- goto err;
- }
-
- if (flags & SGF)
- opcode |= LDST_SGF;
- if (flags & VLF)
- opcode |= LDST_VLF;
-
- /* check load destination, length and offset and source type */
- for (i = 0; i < load_dst_sz[rta_sec_era]; i++)
- if (dst == load_dst[i].dst) {
- pos = (int)i;
- break;
- }
- if (-1 == pos) {
- pr_err("LOAD: Invalid dst. SEC Program Line: %d\n",
- program->current_pc);
- goto err;
- }
-
- if (flags & IMMED) {
- if (load_dst[pos].imm_src == IMM_NO) {
- pr_err("LOAD: Invalid source type. SEC Program Line: %d\n",
- program->current_pc);
- goto err;
- }
- opcode |= LDST_IMM;
- } else if (load_dst[pos].imm_src == IMM_MUST) {
- pr_err("LOAD IMM: Invalid source type. SEC Program Line: %d\n",
- program->current_pc);
- goto err;
- }
-
- ret = load_check_len_offset(pos, length, offset);
- if (ret < 0) {
- pr_err("LOAD: Invalid length/offset. SEC Program Line: %d\n",
- program->current_pc);
- goto err;
- }
-
- opcode |= load_dst[pos].dst_opcode;
-
- /* DESC BUFFER: length / offset values are specified in 4-byte words */
- if (dst == DESCBUF) {
- opcode |= (length >> 2);
- opcode |= ((offset >> 2) << LDST_OFFSET_SHIFT);
- } else {
- opcode |= length;
- opcode |= (offset << LDST_OFFSET_SHIFT);
- }
-
- __rta_out32(program, opcode);
- program->current_instruction++;
-
- /* DECO CONTROL: skip writing pointer of imm data */
- if (dst == DCTRL)
- return (int)start_pc;
-
- /*
- * For data copy, 3 possible ways to specify how to copy data:
- * - IMMED & !COPY: copy data directly from src( max 8 bytes)
- * - IMMED & COPY: copy data imm from the location specified by user
- * - !IMMED and is not SEQ cmd: copy the address
- */
- if (flags & IMMED)
- __rta_inline_data(program, src, flags & __COPY_MASK, length);
- else if (!(flags & SEQ))
- __rta_out64(program, program->ps, src);
-
- return (int)start_pc;
-
- err:
- program->first_error_pc = start_pc;
- program->current_instruction++;
- return ret;
-}
-
-#endif /* __RTA_LOAD_CMD_H__*/
+++ /dev/null
-/* SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0)
- *
- * Copyright 2008-2016 Freescale Semiconductor Inc.
- * Copyright 2016,2019 NXP
- */
-
-#ifndef __RTA_MATH_CMD_H__
-#define __RTA_MATH_CMD_H__
-
-extern enum rta_sec_era rta_sec_era;
-
-static const uint32_t math_op1[][2] = {
-/*1*/ { MATH0, MATH_SRC0_REG0 },
- { MATH1, MATH_SRC0_REG1 },
- { MATH2, MATH_SRC0_REG2 },
- { MATH3, MATH_SRC0_REG3 },
- { SEQINSZ, MATH_SRC0_SEQINLEN },
- { SEQOUTSZ, MATH_SRC0_SEQOUTLEN },
- { VSEQINSZ, MATH_SRC0_VARSEQINLEN },
- { VSEQOUTSZ, MATH_SRC0_VARSEQOUTLEN },
- { ZERO, MATH_SRC0_ZERO },
-/*10*/ { NONE, 0 }, /* dummy value */
- { DPOVRD, MATH_SRC0_DPOVRD },
- { ONE, MATH_SRC0_ONE }
-};
-
-/*
- * Allowed MATH op1 sources for each SEC Era.
- * Values represent the number of entries from math_op1[] that are supported.
- */
-static const unsigned int math_op1_sz[] = {10, 10, 12, 12, 12, 12,
- 12, 12, 12, 12};
-
-static const uint32_t math_op2[][2] = {
-/*1*/ { MATH0, MATH_SRC1_REG0 },
- { MATH1, MATH_SRC1_REG1 },
- { MATH2, MATH_SRC1_REG2 },
- { MATH3, MATH_SRC1_REG3 },
- { ABD, MATH_SRC1_INFIFO },
- { OFIFO, MATH_SRC1_OUTFIFO },
- { ONE, MATH_SRC1_ONE },
-/*8*/ { NONE, 0 }, /* dummy value */
- { JOBSRC, MATH_SRC1_JOBSOURCE },
- { DPOVRD, MATH_SRC1_DPOVRD },
- { VSEQINSZ, MATH_SRC1_VARSEQINLEN },
- { VSEQOUTSZ, MATH_SRC1_VARSEQOUTLEN },
-/*13*/ { ZERO, MATH_SRC1_ZERO }
-};
-
-/*
- * Allowed MATH op2 sources for each SEC Era.
- * Values represent the number of entries from math_op2[] that are supported.
- */
-static const unsigned int math_op2_sz[] = {8, 9, 13, 13, 13, 13, 13, 13,
- 13, 13};
-
-static const uint32_t math_result[][2] = {
-/*1*/ { MATH0, MATH_DEST_REG0 },
- { MATH1, MATH_DEST_REG1 },
- { MATH2, MATH_DEST_REG2 },
- { MATH3, MATH_DEST_REG3 },
- { SEQINSZ, MATH_DEST_SEQINLEN },
- { SEQOUTSZ, MATH_DEST_SEQOUTLEN },
- { VSEQINSZ, MATH_DEST_VARSEQINLEN },
- { VSEQOUTSZ, MATH_DEST_VARSEQOUTLEN },
-/*9*/ { NONE, MATH_DEST_NONE },
- { DPOVRD, MATH_DEST_DPOVRD }
-};
-
-/*
- * Allowed MATH result destinations for each SEC Era.
- * Values represent the number of entries from math_result[] that are
- * supported.
- */
-static const unsigned int math_result_sz[] = {9, 9, 10, 10, 10, 10, 10, 10,
- 10, 10};
-
-static inline int
-rta_math(struct program *program, uint64_t operand1,
- uint32_t op, uint64_t operand2, uint32_t result,
- int length, uint32_t options)
-{
- uint32_t opcode = CMD_MATH;
- uint32_t val = 0;
- int ret = -EINVAL;
- unsigned int start_pc = program->current_pc;
-
- if (((op == MATH_FUN_BSWAP) && (rta_sec_era < RTA_SEC_ERA_4)) ||
- ((op == MATH_FUN_ZBYT) && (rta_sec_era < RTA_SEC_ERA_2))) {
- pr_err("MATH: operation not supported by SEC Era %d. SEC PC: %d; Instr: %d\n",
- USER_SEC_ERA(rta_sec_era), program->current_pc,
- program->current_instruction);
- goto err;
- }
-
- if (options & SWP) {
- if (rta_sec_era < RTA_SEC_ERA_7) {
- pr_err("MATH: operation not supported by SEC Era %d. SEC PC: %d; Instr: %d\n",
- USER_SEC_ERA(rta_sec_era), program->current_pc,
- program->current_instruction);
- goto err;
- }
-
- if ((options & IFB) ||
- (!(options & IMMED) && !(options & IMMED2)) ||
- ((options & IMMED) && (options & IMMED2))) {
- pr_err("MATH: SWP - invalid configuration. SEC PC: %d; Instr: %d\n",
- program->current_pc,
- program->current_instruction);
- goto err;
- }
- }
-
- /*
- * SHLD operation is different from others and we
- * assume that we can have _NONE as first operand
- * or _SEQINSZ as second operand
- */
- if ((op != MATH_FUN_SHLD) && ((operand1 == NONE) ||
- (operand2 == SEQINSZ))) {
- pr_err("MATH: Invalid operand. SEC PC: %d; Instr: %d\n",
- program->current_pc, program->current_instruction);
- goto err;
- }
-
- /*
- * We first check if it is unary operation. In that
- * case second operand must be _NONE
- */
- if (((op == MATH_FUN_ZBYT) || (op == MATH_FUN_BSWAP)) &&
- (operand2 != NONE)) {
- pr_err("MATH: Invalid operand2. SEC PC: %d; Instr: %d\n",
- program->current_pc, program->current_instruction);
- goto err;
- }
-
- /* Write first operand field */
- if (options & IMMED) {
- opcode |= MATH_SRC0_IMM;
- } else {
- ret = __rta_map_opcode((uint32_t)operand1, math_op1,
- math_op1_sz[rta_sec_era], &val);
- if (ret < 0) {
- pr_err("MATH: operand1 not supported. SEC PC: %d; Instr: %d\n",
- program->current_pc,
- program->current_instruction);
- goto err;
- }
- opcode |= val;
- }
-
- /* Write second operand field */
- if (options & IMMED2) {
- opcode |= MATH_SRC1_IMM;
- } else {
- ret = __rta_map_opcode((uint32_t)operand2, math_op2,
- math_op2_sz[rta_sec_era], &val);
- if (ret < 0) {
- pr_err("MATH: operand2 not supported. SEC PC: %d; Instr: %d\n",
- program->current_pc,
- program->current_instruction);
- goto err;
- }
- opcode |= val;
- }
-
- /* Write result field */
- ret = __rta_map_opcode(result, math_result, math_result_sz[rta_sec_era],
- &val);
- if (ret < 0) {
- pr_err("MATH: result not supported. SEC PC: %d; Instr: %d\n",
- program->current_pc, program->current_instruction);
- goto err;
- }
- opcode |= val;
-
- /*
- * as we encode operations with their "real" values, we do not
- * to translate but we do need to validate the value
- */
- switch (op) {
- /*Binary operators */
- case (MATH_FUN_ADD):
- case (MATH_FUN_ADDC):
- case (MATH_FUN_SUB):
- case (MATH_FUN_SUBB):
- case (MATH_FUN_OR):
- case (MATH_FUN_AND):
- case (MATH_FUN_XOR):
- case (MATH_FUN_LSHIFT):
- case (MATH_FUN_RSHIFT):
- case (MATH_FUN_SHLD):
- /* Unary operators */
- case (MATH_FUN_ZBYT):
- case (MATH_FUN_BSWAP):
- opcode |= op;
- break;
- default:
- pr_err("MATH: operator is not supported. SEC PC: %d; Instr: %d\n",
- program->current_pc, program->current_instruction);
- ret = -EINVAL;
- goto err;
- }
-
- opcode |= (options & ~(IMMED | IMMED2));
-
- /* Verify length */
- switch (length) {
- case (1):
- opcode |= MATH_LEN_1BYTE;
- break;
- case (2):
- opcode |= MATH_LEN_2BYTE;
- break;
- case (4):
- opcode |= MATH_LEN_4BYTE;
- break;
- case (8):
- opcode |= MATH_LEN_8BYTE;
- break;
- default:
- pr_err("MATH: length is not supported. SEC PC: %d; Instr: %d\n",
- program->current_pc, program->current_instruction);
- ret = -EINVAL;
- goto err;
- }
-
- __rta_out32(program, opcode);
- program->current_instruction++;
-
- /* Write immediate value */
- if ((options & IMMED) && !(options & IMMED2)) {
- __rta_out64(program, (length > 4) && !(options & IFB),
- operand1);
- } else if ((options & IMMED2) && !(options & IMMED)) {
- __rta_out64(program, (length > 4) && !(options & IFB),
- operand2);
- } else if ((options & IMMED) && (options & IMMED2)) {
- __rta_out32(program, lower_32_bits(operand1));
- __rta_out32(program, lower_32_bits(operand2));
- }
-
- return (int)start_pc;
-
- err:
- program->first_error_pc = start_pc;
- program->current_instruction++;
- return ret;
-}
-
-static inline int
-rta_mathi(struct program *program, uint64_t operand,
- uint32_t op, uint8_t imm, uint32_t result,
- int length, uint32_t options)
-{
- uint32_t opcode = CMD_MATHI;
- uint32_t val = 0;
- int ret = -EINVAL;
- unsigned int start_pc = program->current_pc;
-
- if (rta_sec_era < RTA_SEC_ERA_6) {
- pr_err("MATHI: Command not supported by SEC Era %d. SEC PC: %d; Instr: %d\n",
- USER_SEC_ERA(rta_sec_era), program->current_pc,
- program->current_instruction);
- goto err;
- }
-
- if (((op == MATH_FUN_FBYT) && (options & SSEL))) {
- pr_err("MATHI: Illegal combination - FBYT and SSEL. SEC PC: %d; Instr: %d\n",
- program->current_pc, program->current_instruction);
- goto err;
- }
-
- if ((options & SWP) && (rta_sec_era < RTA_SEC_ERA_7)) {
- pr_err("MATHI: SWP not supported by SEC Era %d. SEC PC: %d; Instr: %d\n",
- USER_SEC_ERA(rta_sec_era), program->current_pc,
- program->current_instruction);
- goto err;
- }
-
- /* Write first operand field */
- if (!(options & SSEL))
- ret = __rta_map_opcode((uint32_t)operand, math_op1,
- math_op1_sz[rta_sec_era], &val);
- else
- ret = __rta_map_opcode((uint32_t)operand, math_op2,
- math_op2_sz[rta_sec_era], &val);
- if (ret < 0) {
- pr_err("MATHI: operand not supported. SEC PC: %d; Instr: %d\n",
- program->current_pc, program->current_instruction);
- goto err;
- }
-
- if (!(options & SSEL))
- opcode |= val;
- else
- opcode |= (val << (MATHI_SRC1_SHIFT - MATH_SRC1_SHIFT));
-
- /* Write second operand field */
- opcode |= (imm << MATHI_IMM_SHIFT);
-
- /* Write result field */
- ret = __rta_map_opcode(result, math_result, math_result_sz[rta_sec_era],
- &val);
- if (ret < 0) {
- pr_err("MATHI: result not supported. SEC PC: %d; Instr: %d\n",
- program->current_pc, program->current_instruction);
- goto err;
- }
- opcode |= (val << (MATHI_DEST_SHIFT - MATH_DEST_SHIFT));
-
- /*
- * as we encode operations with their "real" values, we do not have to
- * translate but we do need to validate the value
- */
- switch (op) {
- case (MATH_FUN_ADD):
- case (MATH_FUN_ADDC):
- case (MATH_FUN_SUB):
- case (MATH_FUN_SUBB):
- case (MATH_FUN_OR):
- case (MATH_FUN_AND):
- case (MATH_FUN_XOR):
- case (MATH_FUN_LSHIFT):
- case (MATH_FUN_RSHIFT):
- case (MATH_FUN_FBYT):
- opcode |= op;
- break;
- default:
- pr_err("MATHI: operator not supported. SEC PC: %d; Instr: %d\n",
- program->current_pc, program->current_instruction);
- ret = -EINVAL;
- goto err;
- }
-
- opcode |= options;
-
- /* Verify length */
- switch (length) {
- case (1):
- opcode |= MATH_LEN_1BYTE;
- break;
- case (2):
- opcode |= MATH_LEN_2BYTE;
- break;
- case (4):
- opcode |= MATH_LEN_4BYTE;
- break;
- case (8):
- opcode |= MATH_LEN_8BYTE;
- break;
- default:
- pr_err("MATHI: length %d not supported. SEC PC: %d; Instr: %d\n",
- length, program->current_pc,
- program->current_instruction);
- ret = -EINVAL;
- goto err;
- }
-
- __rta_out32(program, opcode);
- program->current_instruction++;
-
- return (int)start_pc;
-
- err:
- program->first_error_pc = start_pc;
- program->current_instruction++;
- return ret;
-}
-
-#endif /* __RTA_MATH_CMD_H__ */
+++ /dev/null
-/* SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0)
- *
- * Copyright 2008-2016 Freescale Semiconductor Inc.
- * Copyright 2016,2019 NXP
- */
-
-#ifndef __RTA_MOVE_CMD_H__
-#define __RTA_MOVE_CMD_H__
-
-#define MOVE_SET_AUX_SRC 0x01
-#define MOVE_SET_AUX_DST 0x02
-#define MOVE_SET_AUX_LS 0x03
-#define MOVE_SET_LEN_16b 0x04
-
-#define MOVE_SET_AUX_MATH 0x10
-#define MOVE_SET_AUX_MATH_SRC (MOVE_SET_AUX_SRC | MOVE_SET_AUX_MATH)
-#define MOVE_SET_AUX_MATH_DST (MOVE_SET_AUX_DST | MOVE_SET_AUX_MATH)
-
-#define MASK_16b 0xFF
-
-/* MOVE command type */
-#define __MOVE 1
-#define __MOVEB 2
-#define __MOVEDW 3
-
-extern enum rta_sec_era rta_sec_era;
-
-static const uint32_t move_src_table[][2] = {
-/*1*/ { CONTEXT1, MOVE_SRC_CLASS1CTX },
- { CONTEXT2, MOVE_SRC_CLASS2CTX },
- { OFIFO, MOVE_SRC_OUTFIFO },
- { DESCBUF, MOVE_SRC_DESCBUF },
- { MATH0, MOVE_SRC_MATH0 },
- { MATH1, MOVE_SRC_MATH1 },
- { MATH2, MOVE_SRC_MATH2 },
- { MATH3, MOVE_SRC_MATH3 },
-/*9*/ { IFIFOABD, MOVE_SRC_INFIFO },
- { IFIFOAB1, MOVE_SRC_INFIFO_CL | MOVE_AUX_LS },
- { IFIFOAB2, MOVE_SRC_INFIFO_CL },
-/*12*/ { ABD, MOVE_SRC_INFIFO_NO_NFIFO },
- { AB1, MOVE_SRC_INFIFO_NO_NFIFO | MOVE_AUX_LS },
- { AB2, MOVE_SRC_INFIFO_NO_NFIFO | MOVE_AUX_MS }
-};
-
-/* Allowed MOVE / MOVE_LEN sources for each SEC Era.
- * Values represent the number of entries from move_src_table[] that are
- * supported.
- */
-static const unsigned int move_src_table_sz[] = {9, 11, 14, 14, 14, 14, 14, 14,
- 14, 14};
-
-static const uint32_t move_dst_table[][2] = {
-/*1*/ { CONTEXT1, MOVE_DEST_CLASS1CTX },
- { CONTEXT2, MOVE_DEST_CLASS2CTX },
- { OFIFO, MOVE_DEST_OUTFIFO },
- { DESCBUF, MOVE_DEST_DESCBUF },
- { MATH0, MOVE_DEST_MATH0 },
- { MATH1, MOVE_DEST_MATH1 },
- { MATH2, MOVE_DEST_MATH2 },
- { MATH3, MOVE_DEST_MATH3 },
- { IFIFOAB1, MOVE_DEST_CLASS1INFIFO },
- { IFIFOAB2, MOVE_DEST_CLASS2INFIFO },
- { PKA, MOVE_DEST_PK_A },
- { KEY1, MOVE_DEST_CLASS1KEY },
- { KEY2, MOVE_DEST_CLASS2KEY },
-/*14*/ { IFIFO, MOVE_DEST_INFIFO },
-/*15*/ { ALTSOURCE, MOVE_DEST_ALTSOURCE}
-};
-
-/* Allowed MOVE / MOVE_LEN destinations for each SEC Era.
- * Values represent the number of entries from move_dst_table[] that are
- * supported.
- */
-static const
-unsigned int move_dst_table_sz[] = {13, 14, 14, 15, 15, 15, 15, 15, 15, 15};
-
-static inline int
-set_move_offset(struct program *program __maybe_unused,
- uint64_t src, uint16_t src_offset,
- uint64_t dst, uint16_t dst_offset,
- uint16_t *offset, uint16_t *opt);
-
-static inline int
-math_offset(uint16_t offset);
-
-static inline int
-rta_move(struct program *program, int cmd_type, uint64_t src,
- uint16_t src_offset, uint64_t dst,
- uint16_t dst_offset, uint32_t length, uint32_t flags)
-{
- uint32_t opcode = 0;
- uint16_t offset = 0, opt = 0;
- uint32_t val = 0;
- int ret = -EINVAL;
- bool is_move_len_cmd = false;
- unsigned int start_pc = program->current_pc;
-
- if ((rta_sec_era < RTA_SEC_ERA_7) && (cmd_type != __MOVE)) {
- pr_err("MOVE: MOVEB / MOVEDW not supported by SEC Era %d. SEC PC: %d; Instr: %d\n",
- USER_SEC_ERA(rta_sec_era), program->current_pc,
- program->current_instruction);
- goto err;
- }
-
- /* write command type */
- if (cmd_type == __MOVEB) {
- opcode = CMD_MOVEB;
- } else if (cmd_type == __MOVEDW) {
- opcode = CMD_MOVEDW;
- } else if (!(flags & IMMED)) {
- if (rta_sec_era < RTA_SEC_ERA_3) {
- pr_err("MOVE: MOVE_LEN not supported by SEC Era %d. SEC PC: %d; Instr: %d\n",
- USER_SEC_ERA(rta_sec_era), program->current_pc,
- program->current_instruction);
- goto err;
- }
-
- if ((length != MATH0) && (length != MATH1) &&
- (length != MATH2) && (length != MATH3)) {
- pr_err("MOVE: MOVE_LEN length must be MATH[0-3]. SEC PC: %d; Instr: %d\n",
- program->current_pc,
- program->current_instruction);
- goto err;
- }
-
- opcode = CMD_MOVE_LEN;
- is_move_len_cmd = true;
- } else {
- opcode = CMD_MOVE;
- }
-
- /* write offset first, to check for invalid combinations or incorrect
- * offset values sooner; decide which offset should be here
- * (src or dst)
- */
- ret = set_move_offset(program, src, src_offset, dst, dst_offset,
- &offset, &opt);
- if (ret < 0)
- goto err;
-
- opcode |= (offset << MOVE_OFFSET_SHIFT) & MOVE_OFFSET_MASK;
-
- /* set AUX field if required */
- if (opt == MOVE_SET_AUX_SRC) {
- opcode |= ((src_offset / 16) << MOVE_AUX_SHIFT) & MOVE_AUX_MASK;
- } else if (opt == MOVE_SET_AUX_DST) {
- opcode |= ((dst_offset / 16) << MOVE_AUX_SHIFT) & MOVE_AUX_MASK;
- } else if (opt == MOVE_SET_AUX_LS) {
- opcode |= MOVE_AUX_LS;
- } else if (opt & MOVE_SET_AUX_MATH) {
- if (opt & MOVE_SET_AUX_SRC)
- offset = src_offset;
- else
- offset = dst_offset;
-
- if (rta_sec_era < RTA_SEC_ERA_6) {
- if (offset)
- pr_debug("MOVE: Offset not supported by SEC Era %d. SEC PC: %d; Instr: %d\n",
- USER_SEC_ERA(rta_sec_era),
- program->current_pc,
- program->current_instruction);
- /* nothing to do for offset = 0 */
- } else {
- ret = math_offset(offset);
- if (ret < 0) {
- pr_err("MOVE: Invalid offset in MATH register. SEC PC: %d; Instr: %d\n",
- program->current_pc,
- program->current_instruction);
- goto err;
- }
-
- opcode |= (uint32_t)ret;
- }
- }
-
- /* write source field */
- ret = __rta_map_opcode((uint32_t)src, move_src_table,
- move_src_table_sz[rta_sec_era], &val);
- if (ret < 0) {
- pr_err("MOVE: Invalid SRC. SEC PC: %d; Instr: %d\n",
- program->current_pc, program->current_instruction);
- goto err;
- }
- opcode |= val;
-
- /* write destination field */
- ret = __rta_map_opcode((uint32_t)dst, move_dst_table,
- move_dst_table_sz[rta_sec_era], &val);
- if (ret < 0) {
- pr_err("MOVE: Invalid DST. SEC PC: %d; Instr: %d\n",
- program->current_pc, program->current_instruction);
- goto err;
- }
- opcode |= val;
-
- /* write flags */
- if (flags & (FLUSH1 | FLUSH2))
- opcode |= MOVE_AUX_MS;
- if (flags & (LAST2 | LAST1))
- opcode |= MOVE_AUX_LS;
- if (flags & WAITCOMP)
- opcode |= MOVE_WAITCOMP;
-
- if (!is_move_len_cmd) {
- /* write length */
- if (opt == MOVE_SET_LEN_16b)
- opcode |= (length & (MOVE_OFFSET_MASK | MOVE_LEN_MASK));
- else
- opcode |= (length & MOVE_LEN_MASK);
- } else {
- /* write mrsel */
- switch (length) {
- case (MATH0):
- /*
- * opcode |= MOVELEN_MRSEL_MATH0;
- * MOVELEN_MRSEL_MATH0 is 0
- */
- break;
- case (MATH1):
- opcode |= MOVELEN_MRSEL_MATH1;
- break;
- case (MATH2):
- opcode |= MOVELEN_MRSEL_MATH2;
- break;
- case (MATH3):
- opcode |= MOVELEN_MRSEL_MATH3;
- break;
- }
-
- /* write size */
- if (rta_sec_era >= RTA_SEC_ERA_7) {
- if (flags & SIZE_WORD)
- opcode |= MOVELEN_SIZE_WORD;
- else if (flags & SIZE_BYTE)
- opcode |= MOVELEN_SIZE_BYTE;
- else if (flags & SIZE_DWORD)
- opcode |= MOVELEN_SIZE_DWORD;
- }
- }
-
- __rta_out32(program, opcode);
- program->current_instruction++;
-
- return (int)start_pc;
-
- err:
- program->first_error_pc = start_pc;
- program->current_instruction++;
- return ret;
-}
-
-static inline int
-set_move_offset(struct program *program __maybe_unused,
- uint64_t src, uint16_t src_offset,
- uint64_t dst, uint16_t dst_offset,
- uint16_t *offset, uint16_t *opt)
-{
- switch (src) {
- case (CONTEXT1):
- case (CONTEXT2):
- if (dst == DESCBUF) {
- *opt = MOVE_SET_AUX_SRC;
- *offset = dst_offset;
- } else if ((dst == KEY1) || (dst == KEY2)) {
- if ((src_offset) && (dst_offset)) {
- pr_err("MOVE: Bad offset. SEC PC: %d; Instr: %d\n",
- program->current_pc,
- program->current_instruction);
- goto err;
- }
- if (dst_offset) {
- *opt = MOVE_SET_AUX_LS;
- *offset = dst_offset;
- } else {
- *offset = src_offset;
- }
- } else {
- if ((dst == MATH0) || (dst == MATH1) ||
- (dst == MATH2) || (dst == MATH3)) {
- *opt = MOVE_SET_AUX_MATH_DST;
- } else if (((dst == OFIFO) || (dst == ALTSOURCE)) &&
- (src_offset % 4)) {
- pr_err("MOVE: Bad offset alignment. SEC PC: %d; Instr: %d\n",
- program->current_pc,
- program->current_instruction);
- goto err;
- }
-
- *offset = src_offset;
- }
- break;
-
- case (OFIFO):
- if (dst == OFIFO) {
- pr_err("MOVE: Invalid DST. SEC PC: %d; Instr: %d\n",
- program->current_pc,
- program->current_instruction);
- goto err;
- }
- if (((dst == IFIFOAB1) || (dst == IFIFOAB2) ||
- (dst == IFIFO) || (dst == PKA)) &&
- (src_offset || dst_offset)) {
- pr_err("MOVE: Offset should be zero. SEC PC: %d; Instr: %d\n",
- program->current_pc,
- program->current_instruction);
- goto err;
- }
- *offset = dst_offset;
- break;
-
- case (DESCBUF):
- if ((dst == CONTEXT1) || (dst == CONTEXT2)) {
- *opt = MOVE_SET_AUX_DST;
- } else if ((dst == MATH0) || (dst == MATH1) ||
- (dst == MATH2) || (dst == MATH3)) {
- *opt = MOVE_SET_AUX_MATH_DST;
- } else if (dst == DESCBUF) {
- pr_err("MOVE: Invalid DST. SEC PC: %d; Instr: %d\n",
- program->current_pc,
- program->current_instruction);
- goto err;
- } else if (((dst == OFIFO) || (dst == ALTSOURCE)) &&
- (src_offset % 4)) {
- pr_err("MOVE: Invalid offset alignment. SEC PC: %d; Instr %d\n",
- program->current_pc,
- program->current_instruction);
- goto err;
- }
-
- *offset = src_offset;
- break;
-
- case (MATH0):
- case (MATH1):
- case (MATH2):
- case (MATH3):
- if ((dst == OFIFO) || (dst == ALTSOURCE)) {
- if (src_offset % 4) {
- pr_err("MOVE: Bad offset alignment. SEC PC: %d; Instr: %d\n",
- program->current_pc,
- program->current_instruction);
- goto err;
- }
- *offset = src_offset;
- } else if ((dst == IFIFOAB1) || (dst == IFIFOAB2) ||
- (dst == IFIFO) || (dst == PKA)) {
- *offset = src_offset;
- } else {
- *offset = dst_offset;
-
- /*
- * This condition is basically the negation of:
- * dst in { CONTEXT[1-2], MATH[0-3] }
- */
- if ((dst != KEY1) && (dst != KEY2))
- *opt = MOVE_SET_AUX_MATH_SRC;
- }
- break;
-
- case (IFIFOABD):
- case (IFIFOAB1):
- case (IFIFOAB2):
- case (ABD):
- case (AB1):
- case (AB2):
- if ((dst == IFIFOAB1) || (dst == IFIFOAB2) ||
- (dst == IFIFO) || (dst == PKA) || (dst == ALTSOURCE)) {
- pr_err("MOVE: Bad DST. SEC PC: %d; Instr: %d\n",
- program->current_pc,
- program->current_instruction);
- goto err;
- } else {
- if (dst == OFIFO) {
- *opt = MOVE_SET_LEN_16b;
- } else {
- if (dst_offset % 4) {
- pr_err("MOVE: Bad offset alignment. SEC PC: %d; Instr: %d\n",
- program->current_pc,
- program->current_instruction);
- goto err;
- }
- *offset = dst_offset;
- }
- }
- break;
- default:
- break;
- }
-
- return 0;
- err:
- return -EINVAL;
-}
-
-static inline int
-math_offset(uint16_t offset)
-{
- switch (offset) {
- case 0:
- return 0;
- case 4:
- return MOVE_AUX_LS;
- case 6:
- return MOVE_AUX_MS;
- case 7:
- return MOVE_AUX_LS | MOVE_AUX_MS;
- }
-
- return -EINVAL;
-}
-
-#endif /* __RTA_MOVE_CMD_H__ */
+++ /dev/null
-/* SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0)
- *
- * Copyright 2008-2016 Freescale Semiconductor Inc.
- * Copyright 2016,2019 NXP
- */
-
-#ifndef __RTA_NFIFO_CMD_H__
-#define __RTA_NFIFO_CMD_H__
-
-extern enum rta_sec_era rta_sec_era;
-
-static const uint32_t nfifo_src[][2] = {
-/*1*/ { IFIFO, NFIFOENTRY_STYPE_DFIFO },
- { OFIFO, NFIFOENTRY_STYPE_OFIFO },
- { PAD, NFIFOENTRY_STYPE_PAD },
-/*4*/ { MSGOUTSNOOP, NFIFOENTRY_STYPE_SNOOP | NFIFOENTRY_DEST_BOTH },
-/*5*/ { ALTSOURCE, NFIFOENTRY_STYPE_ALTSOURCE },
- { OFIFO_SYNC, NFIFOENTRY_STYPE_OFIFO_SYNC },
-/*7*/ { MSGOUTSNOOP_ALT, NFIFOENTRY_STYPE_SNOOP_ALT | NFIFOENTRY_DEST_BOTH }
-};
-
-/*
- * Allowed NFIFO LOAD sources for each SEC Era.
- * Values represent the number of entries from nfifo_src[] that are supported.
- */
-static const unsigned int nfifo_src_sz[] = {4, 5, 5, 5, 5, 5, 5, 7, 7, 7};
-
-static const uint32_t nfifo_data[][2] = {
- { MSG, NFIFOENTRY_DTYPE_MSG },
- { MSG1, NFIFOENTRY_DEST_CLASS1 | NFIFOENTRY_DTYPE_MSG },
- { MSG2, NFIFOENTRY_DEST_CLASS2 | NFIFOENTRY_DTYPE_MSG },
- { IV1, NFIFOENTRY_DEST_CLASS1 | NFIFOENTRY_DTYPE_IV },
- { IV2, NFIFOENTRY_DEST_CLASS2 | NFIFOENTRY_DTYPE_IV },
- { ICV1, NFIFOENTRY_DEST_CLASS1 | NFIFOENTRY_DTYPE_ICV },
- { ICV2, NFIFOENTRY_DEST_CLASS2 | NFIFOENTRY_DTYPE_ICV },
- { SAD1, NFIFOENTRY_DEST_CLASS1 | NFIFOENTRY_DTYPE_SAD },
- { AAD1, NFIFOENTRY_DEST_CLASS1 | NFIFOENTRY_DTYPE_AAD },
- { AAD2, NFIFOENTRY_DEST_CLASS2 | NFIFOENTRY_DTYPE_AAD },
- { AFHA_SBOX, NFIFOENTRY_DEST_CLASS1 | NFIFOENTRY_DTYPE_SBOX },
- { SKIP, NFIFOENTRY_DTYPE_SKIP },
- { PKE, NFIFOENTRY_DEST_CLASS1 | NFIFOENTRY_DTYPE_PK_E },
- { PKN, NFIFOENTRY_DEST_CLASS1 | NFIFOENTRY_DTYPE_PK_N },
- { PKA, NFIFOENTRY_DEST_CLASS1 | NFIFOENTRY_DTYPE_PK_A },
- { PKA0, NFIFOENTRY_DEST_CLASS1 | NFIFOENTRY_DTYPE_PK_A0 },
- { PKA1, NFIFOENTRY_DEST_CLASS1 | NFIFOENTRY_DTYPE_PK_A1 },
- { PKA2, NFIFOENTRY_DEST_CLASS1 | NFIFOENTRY_DTYPE_PK_A2 },
- { PKA3, NFIFOENTRY_DEST_CLASS1 | NFIFOENTRY_DTYPE_PK_A3 },
- { PKB, NFIFOENTRY_DEST_CLASS1 | NFIFOENTRY_DTYPE_PK_B },
- { PKB0, NFIFOENTRY_DEST_CLASS1 | NFIFOENTRY_DTYPE_PK_B0 },
- { PKB1, NFIFOENTRY_DEST_CLASS1 | NFIFOENTRY_DTYPE_PK_B1 },
- { PKB2, NFIFOENTRY_DEST_CLASS1 | NFIFOENTRY_DTYPE_PK_B2 },
- { PKB3, NFIFOENTRY_DEST_CLASS1 | NFIFOENTRY_DTYPE_PK_B3 },
- { AB1, NFIFOENTRY_DEST_CLASS1 },
- { AB2, NFIFOENTRY_DEST_CLASS2 },
- { ABD, NFIFOENTRY_DEST_DECO }
-};
-
-static const uint32_t nfifo_flags[][2] = {
-/*1*/ { LAST1, NFIFOENTRY_LC1 },
- { LAST2, NFIFOENTRY_LC2 },
- { FLUSH1, NFIFOENTRY_FC1 },
- { BP, NFIFOENTRY_BND },
- { PAD_ZERO, NFIFOENTRY_PTYPE_ZEROS },
- { PAD_NONZERO, NFIFOENTRY_PTYPE_RND_NOZEROS },
- { PAD_INCREMENT, NFIFOENTRY_PTYPE_INCREMENT },
- { PAD_RANDOM, NFIFOENTRY_PTYPE_RND },
- { PAD_ZERO_N1, NFIFOENTRY_PTYPE_ZEROS_NZ },
- { PAD_NONZERO_0, NFIFOENTRY_PTYPE_RND_NZ_LZ },
- { PAD_N1, NFIFOENTRY_PTYPE_N },
-/*12*/ { PAD_NONZERO_N, NFIFOENTRY_PTYPE_RND_NZ_N },
- { FLUSH2, NFIFOENTRY_FC2 },
- { OC, NFIFOENTRY_OC }
-};
-
-/*
- * Allowed NFIFO LOAD flags for each SEC Era.
- * Values represent the number of entries from nfifo_flags[] that are supported.
- */
-static const unsigned int nfifo_flags_sz[] = {12, 14, 14, 14, 14, 14,
- 14, 14, 14, 14};
-
-static const uint32_t nfifo_pad_flags[][2] = {
- { BM, NFIFOENTRY_BM },
- { PS, NFIFOENTRY_PS },
- { PR, NFIFOENTRY_PR }
-};
-
-/*
- * Allowed NFIFO LOAD pad flags for each SEC Era.
- * Values represent the number of entries from nfifo_pad_flags[] that are
- * supported.
- */
-static const unsigned int nfifo_pad_flags_sz[] = {2, 2, 2, 2, 3, 3, 3, 3, 3, 3};
-
-static inline int
-rta_nfifo_load(struct program *program, uint32_t src,
- uint32_t data, uint32_t length, uint32_t flags)
-{
- uint32_t opcode = 0, val;
- int ret = -EINVAL;
- uint32_t load_cmd = CMD_LOAD | LDST_IMM | LDST_CLASS_IND_CCB |
- LDST_SRCDST_WORD_INFO_FIFO;
- unsigned int start_pc = program->current_pc;
-
- if ((data == AFHA_SBOX) && (rta_sec_era == RTA_SEC_ERA_7)) {
- pr_err("NFIFO: AFHA S-box not supported by SEC Era %d\n",
- USER_SEC_ERA(rta_sec_era));
- goto err;
- }
-
- /* write source field */
- ret = __rta_map_opcode(src, nfifo_src, nfifo_src_sz[rta_sec_era], &val);
- if (ret < 0) {
- pr_err("NFIFO: Invalid SRC. SEC PC: %d; Instr: %d\n",
- program->current_pc, program->current_instruction);
- goto err;
- }
- opcode |= val;
-
- /* write type field */
- ret = __rta_map_opcode(data, nfifo_data, ARRAY_SIZE(nfifo_data), &val);
- if (ret < 0) {
- pr_err("NFIFO: Invalid data. SEC PC: %d; Instr: %d\n",
- program->current_pc, program->current_instruction);
- goto err;
- }
- opcode |= val;
-
- /* write DL field */
- if (!(flags & EXT)) {
- opcode |= length & NFIFOENTRY_DLEN_MASK;
- load_cmd |= 4;
- } else {
- load_cmd |= 8;
- }
-
- /* write flags */
- __rta_map_flags(flags, nfifo_flags, nfifo_flags_sz[rta_sec_era],
- &opcode);
-
- /* in case of padding, check the destination */
- if (src == PAD)
- __rta_map_flags(flags, nfifo_pad_flags,
- nfifo_pad_flags_sz[rta_sec_era], &opcode);
-
- /* write LOAD command first */
- __rta_out32(program, load_cmd);
- __rta_out32(program, opcode);
-
- if (flags & EXT)
- __rta_out32(program, length & NFIFOENTRY_DLEN_MASK);
-
- program->current_instruction++;
-
- return (int)start_pc;
-
- err:
- program->first_error_pc = start_pc;
- program->current_instruction++;
- return ret;
-}
-
-#endif /* __RTA_NFIFO_CMD_H__ */
+++ /dev/null
-/* SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0)
- *
- * Copyright 2008-2016 Freescale Semiconductor Inc.
- * Copyright 2016,2019 NXP
- */
-
-#ifndef __RTA_OPERATION_CMD_H__
-#define __RTA_OPERATION_CMD_H__
-
-#if defined(RTE_TOOLCHAIN_GCC) && (GCC_VERSION >= 70000)
-#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
-#endif
-
-extern enum rta_sec_era rta_sec_era;
-
-static inline int
-__rta_alg_aai_aes(uint16_t aai)
-{
- uint16_t aes_mode = aai & OP_ALG_AESA_MODE_MASK;
-
- if (aai & OP_ALG_AAI_C2K) {
- if (rta_sec_era < RTA_SEC_ERA_5)
- return -1;
- if ((aes_mode != OP_ALG_AAI_CCM) &&
- (aes_mode != OP_ALG_AAI_GCM))
- return -EINVAL;
- }
-
- switch (aes_mode) {
- case OP_ALG_AAI_CBC_CMAC:
- case OP_ALG_AAI_CTR_CMAC_LTE:
- case OP_ALG_AAI_CTR_CMAC:
- if (rta_sec_era < RTA_SEC_ERA_2)
- return -EINVAL;
- /* no break */
- case OP_ALG_AAI_CTR:
- case OP_ALG_AAI_CBC:
- case OP_ALG_AAI_ECB:
- case OP_ALG_AAI_OFB:
- case OP_ALG_AAI_CFB:
- case OP_ALG_AAI_XTS:
- case OP_ALG_AAI_CMAC:
- case OP_ALG_AAI_XCBC_MAC:
- case OP_ALG_AAI_CCM:
- case OP_ALG_AAI_GCM:
- case OP_ALG_AAI_CBC_XCBCMAC:
- case OP_ALG_AAI_CTR_XCBCMAC:
- return 0;
- }
-
- return -EINVAL;
-}
-
-static inline int
-__rta_alg_aai_des(uint16_t aai)
-{
- uint16_t aai_code = (uint16_t)(aai & ~OP_ALG_AAI_CHECKODD);
-
- switch (aai_code) {
- case OP_ALG_AAI_CBC:
- case OP_ALG_AAI_ECB:
- case OP_ALG_AAI_CFB:
- case OP_ALG_AAI_OFB:
- return 0;
- }
-
- return -EINVAL;
-}
-
-static inline int
-__rta_alg_aai_md5(uint16_t aai)
-{
- switch (aai) {
- case OP_ALG_AAI_HMAC:
- if (rta_sec_era < RTA_SEC_ERA_2)
- return -EINVAL;
- /* no break */
- case OP_ALG_AAI_SMAC:
- case OP_ALG_AAI_HASH:
- case OP_ALG_AAI_HMAC_PRECOMP:
- return 0;
- }
-
- return -EINVAL;
-}
-
-static inline int
-__rta_alg_aai_sha(uint16_t aai)
-{
- switch (aai) {
- case OP_ALG_AAI_HMAC:
- if (rta_sec_era < RTA_SEC_ERA_2)
- return -EINVAL;
- /* no break */
- case OP_ALG_AAI_HASH:
- case OP_ALG_AAI_HMAC_PRECOMP:
- return 0;
- }
-
- return -EINVAL;
-}
-
-static inline int
-__rta_alg_aai_rng(uint16_t aai)
-{
- uint16_t rng_mode = aai & OP_ALG_RNG_MODE_MASK;
- uint16_t rng_sh = aai & OP_ALG_AAI_RNG4_SH_MASK;
-
- switch (rng_mode) {
- case OP_ALG_AAI_RNG:
- case OP_ALG_AAI_RNG_NZB:
- case OP_ALG_AAI_RNG_OBP:
- break;
- default:
- return -EINVAL;
- }
-
- /* State Handle bits are valid only for SEC Era >= 5 */
- if ((rta_sec_era < RTA_SEC_ERA_5) && rng_sh)
- return -EINVAL;
-
- /* PS, AI, SK bits are also valid only for SEC Era >= 5 */
- if ((rta_sec_era < RTA_SEC_ERA_5) && (aai &
- (OP_ALG_AAI_RNG4_PS | OP_ALG_AAI_RNG4_AI | OP_ALG_AAI_RNG4_SK)))
- return -EINVAL;
-
- switch (rng_sh) {
- case OP_ALG_AAI_RNG4_SH_0:
- case OP_ALG_AAI_RNG4_SH_1:
- return 0;
- }
-
- return -EINVAL;
-}
-
-static inline int
-__rta_alg_aai_crc(uint16_t aai)
-{
- uint16_t aai_code = aai & OP_ALG_CRC_POLY_MASK;
-
- switch (aai_code) {
- case OP_ALG_AAI_802:
- case OP_ALG_AAI_3385:
- case OP_ALG_AAI_CUST_POLY:
- return 0;
- }
-
- return -EINVAL;
-}
-
-static inline int
-__rta_alg_aai_kasumi(uint16_t aai)
-{
- switch (aai) {
- case OP_ALG_AAI_GSM:
- case OP_ALG_AAI_EDGE:
- case OP_ALG_AAI_F8:
- case OP_ALG_AAI_F9:
- return 0;
- }
-
- return -EINVAL;
-}
-
-static inline int
-__rta_alg_aai_snow_f9(uint16_t aai)
-{
- if (aai == OP_ALG_AAI_F9)
- return 0;
-
- return -EINVAL;
-}
-
-static inline int
-__rta_alg_aai_snow_f8(uint16_t aai)
-{
- if (aai == OP_ALG_AAI_F8)
- return 0;
-
- return -EINVAL;
-}
-
-static inline int
-__rta_alg_aai_zuce(uint16_t aai)
-{
- if (aai == OP_ALG_AAI_F8)
- return 0;
-
- return -EINVAL;
-}
-
-static inline int
-__rta_alg_aai_zuca(uint16_t aai)
-{
- if (aai == OP_ALG_AAI_F9)
- return 0;
-
- return -EINVAL;
-}
-
-struct alg_aai_map {
- uint32_t chipher_algo;
- int (*aai_func)(uint16_t);
- uint32_t class;
-};
-
-static const struct alg_aai_map alg_table[] = {
-/*1*/ { OP_ALG_ALGSEL_AES, __rta_alg_aai_aes, OP_TYPE_CLASS1_ALG },
- { OP_ALG_ALGSEL_DES, __rta_alg_aai_des, OP_TYPE_CLASS1_ALG },
- { OP_ALG_ALGSEL_3DES, __rta_alg_aai_des, OP_TYPE_CLASS1_ALG },
- { OP_ALG_ALGSEL_MD5, __rta_alg_aai_md5, OP_TYPE_CLASS2_ALG },
- { OP_ALG_ALGSEL_SHA1, __rta_alg_aai_md5, OP_TYPE_CLASS2_ALG },
- { OP_ALG_ALGSEL_SHA224, __rta_alg_aai_sha, OP_TYPE_CLASS2_ALG },
- { OP_ALG_ALGSEL_SHA256, __rta_alg_aai_sha, OP_TYPE_CLASS2_ALG },
- { OP_ALG_ALGSEL_SHA384, __rta_alg_aai_sha, OP_TYPE_CLASS2_ALG },
- { OP_ALG_ALGSEL_SHA512, __rta_alg_aai_sha, OP_TYPE_CLASS2_ALG },
- { OP_ALG_ALGSEL_RNG, __rta_alg_aai_rng, OP_TYPE_CLASS1_ALG },
-/*11*/ { OP_ALG_ALGSEL_CRC, __rta_alg_aai_crc, OP_TYPE_CLASS2_ALG },
- { OP_ALG_ALGSEL_ARC4, NULL, OP_TYPE_CLASS1_ALG },
- { OP_ALG_ALGSEL_SNOW_F8, __rta_alg_aai_snow_f8, OP_TYPE_CLASS1_ALG },
-/*14*/ { OP_ALG_ALGSEL_KASUMI, __rta_alg_aai_kasumi, OP_TYPE_CLASS1_ALG },
- { OP_ALG_ALGSEL_SNOW_F9, __rta_alg_aai_snow_f9, OP_TYPE_CLASS2_ALG },
- { OP_ALG_ALGSEL_ZUCE, __rta_alg_aai_zuce, OP_TYPE_CLASS1_ALG },
-/*17*/ { OP_ALG_ALGSEL_ZUCA, __rta_alg_aai_zuca, OP_TYPE_CLASS2_ALG }
-};
-
-/*
- * Allowed OPERATION algorithms for each SEC Era.
- * Values represent the number of entries from alg_table[] that are supported.
- */
-static const unsigned int alg_table_sz[] = {14, 15, 15, 15, 17, 17,
- 11, 17, 17, 17};
-
-static inline int
-rta_operation(struct program *program, uint32_t cipher_algo,
- uint16_t aai, uint8_t algo_state,
- int icv_checking, int enc)
-{
- uint32_t opcode = CMD_OPERATION;
- unsigned int i, found = 0;
- unsigned int start_pc = program->current_pc;
- int ret;
-
- for (i = 0; i < alg_table_sz[rta_sec_era]; i++) {
- if (alg_table[i].chipher_algo == cipher_algo) {
- opcode |= cipher_algo | alg_table[i].class;
- /* nothing else to verify */
- if (alg_table[i].aai_func == NULL) {
- found = 1;
- break;
- }
-
- aai &= OP_ALG_AAI_MASK;
-
- ret = (*alg_table[i].aai_func)(aai);
- if (ret < 0) {
- pr_err("OPERATION: Bad AAI Type. SEC Program Line: %d\n",
- program->current_pc);
- goto err;
- }
- opcode |= aai;
- found = 1;
- break;
- }
- }
- if (!found) {
- pr_err("OPERATION: Invalid Command. SEC Program Line: %d\n",
- program->current_pc);
- ret = -EINVAL;
- goto err;
- }
-
- switch (algo_state) {
- case OP_ALG_AS_UPDATE:
- case OP_ALG_AS_INIT:
- case OP_ALG_AS_FINALIZE:
- case OP_ALG_AS_INITFINAL:
- opcode |= algo_state;
- break;
- default:
- pr_err("Invalid Operation Command\n");
- ret = -EINVAL;
- goto err;
- }
-
- switch (icv_checking) {
- case ICV_CHECK_DISABLE:
- /*
- * opcode |= OP_ALG_ICV_OFF;
- * OP_ALG_ICV_OFF is 0
- */
- break;
- case ICV_CHECK_ENABLE:
- opcode |= OP_ALG_ICV_ON;
- break;
- default:
- pr_err("Invalid Operation Command\n");
- ret = -EINVAL;
- goto err;
- }
-
- switch (enc) {
- case DIR_DEC:
- /*
- * opcode |= OP_ALG_DECRYPT;
- * OP_ALG_DECRYPT is 0
- */
- break;
- case DIR_ENC:
- opcode |= OP_ALG_ENCRYPT;
- break;
- default:
- pr_err("Invalid Operation Command\n");
- ret = -EINVAL;
- goto err;
- }
-
- __rta_out32(program, opcode);
- program->current_instruction++;
- return (int)start_pc;
-
- err:
- program->first_error_pc = start_pc;
- return ret;
-}
-
-/*
- * OPERATION PKHA routines
- */
-static inline int
-__rta_pkha_clearmem(uint32_t pkha_op)
-{
- switch (pkha_op) {
- case (OP_ALG_PKMODE_CLEARMEM_ALL):
- case (OP_ALG_PKMODE_CLEARMEM_ABE):
- case (OP_ALG_PKMODE_CLEARMEM_ABN):
- case (OP_ALG_PKMODE_CLEARMEM_AB):
- case (OP_ALG_PKMODE_CLEARMEM_AEN):
- case (OP_ALG_PKMODE_CLEARMEM_AE):
- case (OP_ALG_PKMODE_CLEARMEM_AN):
- case (OP_ALG_PKMODE_CLEARMEM_A):
- case (OP_ALG_PKMODE_CLEARMEM_BEN):
- case (OP_ALG_PKMODE_CLEARMEM_BE):
- case (OP_ALG_PKMODE_CLEARMEM_BN):
- case (OP_ALG_PKMODE_CLEARMEM_B):
- case (OP_ALG_PKMODE_CLEARMEM_EN):
- case (OP_ALG_PKMODE_CLEARMEM_N):
- case (OP_ALG_PKMODE_CLEARMEM_E):
- return 0;
- }
-
- return -EINVAL;
-}
-
-static inline int
-__rta_pkha_mod_arithmetic(uint32_t pkha_op)
-{
- pkha_op &= (uint32_t)~OP_ALG_PKMODE_OUT_A;
-
- switch (pkha_op) {
- case (OP_ALG_PKMODE_MOD_ADD):
- case (OP_ALG_PKMODE_MOD_SUB_AB):
- case (OP_ALG_PKMODE_MOD_SUB_BA):
- case (OP_ALG_PKMODE_MOD_MULT):
- case (OP_ALG_PKMODE_MOD_MULT_IM):
- case (OP_ALG_PKMODE_MOD_MULT_IM_OM):
- case (OP_ALG_PKMODE_MOD_EXPO):
- case (OP_ALG_PKMODE_MOD_EXPO_TEQ):
- case (OP_ALG_PKMODE_MOD_EXPO_IM):
- case (OP_ALG_PKMODE_MOD_EXPO_IM_TEQ):
- case (OP_ALG_PKMODE_MOD_REDUCT):
- case (OP_ALG_PKMODE_MOD_INV):
- case (OP_ALG_PKMODE_MOD_MONT_CNST):
- case (OP_ALG_PKMODE_MOD_CRT_CNST):
- case (OP_ALG_PKMODE_MOD_GCD):
- case (OP_ALG_PKMODE_MOD_PRIMALITY):
- case (OP_ALG_PKMODE_MOD_SML_EXP):
- case (OP_ALG_PKMODE_F2M_ADD):
- case (OP_ALG_PKMODE_F2M_MUL):
- case (OP_ALG_PKMODE_F2M_MUL_IM):
- case (OP_ALG_PKMODE_F2M_MUL_IM_OM):
- case (OP_ALG_PKMODE_F2M_EXP):
- case (OP_ALG_PKMODE_F2M_EXP_TEQ):
- case (OP_ALG_PKMODE_F2M_AMODN):
- case (OP_ALG_PKMODE_F2M_INV):
- case (OP_ALG_PKMODE_F2M_R2):
- case (OP_ALG_PKMODE_F2M_GCD):
- case (OP_ALG_PKMODE_F2M_SML_EXP):
- case (OP_ALG_PKMODE_ECC_F2M_ADD):
- case (OP_ALG_PKMODE_ECC_F2M_ADD_IM_OM_PROJ):
- case (OP_ALG_PKMODE_ECC_F2M_DBL):
- case (OP_ALG_PKMODE_ECC_F2M_DBL_IM_OM_PROJ):
- case (OP_ALG_PKMODE_ECC_F2M_MUL):
- case (OP_ALG_PKMODE_ECC_F2M_MUL_TEQ):
- case (OP_ALG_PKMODE_ECC_F2M_MUL_R2):
- case (OP_ALG_PKMODE_ECC_F2M_MUL_R2_TEQ):
- case (OP_ALG_PKMODE_ECC_F2M_MUL_R2_PROJ):
- case (OP_ALG_PKMODE_ECC_F2M_MUL_R2_PROJ_TEQ):
- case (OP_ALG_PKMODE_ECC_MOD_ADD):
- case (OP_ALG_PKMODE_ECC_MOD_ADD_IM_OM_PROJ):
- case (OP_ALG_PKMODE_ECC_MOD_DBL):
- case (OP_ALG_PKMODE_ECC_MOD_DBL_IM_OM_PROJ):
- case (OP_ALG_PKMODE_ECC_MOD_MUL):
- case (OP_ALG_PKMODE_ECC_MOD_MUL_TEQ):
- case (OP_ALG_PKMODE_ECC_MOD_MUL_R2):
- case (OP_ALG_PKMODE_ECC_MOD_MUL_R2_TEQ):
- case (OP_ALG_PKMODE_ECC_MOD_MUL_R2_PROJ):
- case (OP_ALG_PKMODE_ECC_MOD_MUL_R2_PROJ_TEQ):
- return 0;
- }
-
- return -EINVAL;
-}
-
-static inline int
-__rta_pkha_copymem(uint32_t pkha_op)
-{
- switch (pkha_op) {
- case (OP_ALG_PKMODE_COPY_NSZ_A0_B0):
- case (OP_ALG_PKMODE_COPY_NSZ_A0_B1):
- case (OP_ALG_PKMODE_COPY_NSZ_A0_B2):
- case (OP_ALG_PKMODE_COPY_NSZ_A0_B3):
- case (OP_ALG_PKMODE_COPY_NSZ_A1_B0):
- case (OP_ALG_PKMODE_COPY_NSZ_A1_B1):
- case (OP_ALG_PKMODE_COPY_NSZ_A1_B2):
- case (OP_ALG_PKMODE_COPY_NSZ_A1_B3):
- case (OP_ALG_PKMODE_COPY_NSZ_A2_B0):
- case (OP_ALG_PKMODE_COPY_NSZ_A2_B1):
- case (OP_ALG_PKMODE_COPY_NSZ_A2_B2):
- case (OP_ALG_PKMODE_COPY_NSZ_A2_B3):
- case (OP_ALG_PKMODE_COPY_NSZ_A3_B0):
- case (OP_ALG_PKMODE_COPY_NSZ_A3_B1):
- case (OP_ALG_PKMODE_COPY_NSZ_A3_B2):
- case (OP_ALG_PKMODE_COPY_NSZ_A3_B3):
- case (OP_ALG_PKMODE_COPY_NSZ_B0_A0):
- case (OP_ALG_PKMODE_COPY_NSZ_B0_A1):
- case (OP_ALG_PKMODE_COPY_NSZ_B0_A2):
- case (OP_ALG_PKMODE_COPY_NSZ_B0_A3):
- case (OP_ALG_PKMODE_COPY_NSZ_B1_A0):
- case (OP_ALG_PKMODE_COPY_NSZ_B1_A1):
- case (OP_ALG_PKMODE_COPY_NSZ_B1_A2):
- case (OP_ALG_PKMODE_COPY_NSZ_B1_A3):
- case (OP_ALG_PKMODE_COPY_NSZ_B2_A0):
- case (OP_ALG_PKMODE_COPY_NSZ_B2_A1):
- case (OP_ALG_PKMODE_COPY_NSZ_B2_A2):
- case (OP_ALG_PKMODE_COPY_NSZ_B2_A3):
- case (OP_ALG_PKMODE_COPY_NSZ_B3_A0):
- case (OP_ALG_PKMODE_COPY_NSZ_B3_A1):
- case (OP_ALG_PKMODE_COPY_NSZ_B3_A2):
- case (OP_ALG_PKMODE_COPY_NSZ_B3_A3):
- case (OP_ALG_PKMODE_COPY_NSZ_A_E):
- case (OP_ALG_PKMODE_COPY_NSZ_A_N):
- case (OP_ALG_PKMODE_COPY_NSZ_B_E):
- case (OP_ALG_PKMODE_COPY_NSZ_B_N):
- case (OP_ALG_PKMODE_COPY_NSZ_N_A):
- case (OP_ALG_PKMODE_COPY_NSZ_N_B):
- case (OP_ALG_PKMODE_COPY_NSZ_N_E):
- case (OP_ALG_PKMODE_COPY_SSZ_A0_B0):
- case (OP_ALG_PKMODE_COPY_SSZ_A0_B1):
- case (OP_ALG_PKMODE_COPY_SSZ_A0_B2):
- case (OP_ALG_PKMODE_COPY_SSZ_A0_B3):
- case (OP_ALG_PKMODE_COPY_SSZ_A1_B0):
- case (OP_ALG_PKMODE_COPY_SSZ_A1_B1):
- case (OP_ALG_PKMODE_COPY_SSZ_A1_B2):
- case (OP_ALG_PKMODE_COPY_SSZ_A1_B3):
- case (OP_ALG_PKMODE_COPY_SSZ_A2_B0):
- case (OP_ALG_PKMODE_COPY_SSZ_A2_B1):
- case (OP_ALG_PKMODE_COPY_SSZ_A2_B2):
- case (OP_ALG_PKMODE_COPY_SSZ_A2_B3):
- case (OP_ALG_PKMODE_COPY_SSZ_A3_B0):
- case (OP_ALG_PKMODE_COPY_SSZ_A3_B1):
- case (OP_ALG_PKMODE_COPY_SSZ_A3_B2):
- case (OP_ALG_PKMODE_COPY_SSZ_A3_B3):
- case (OP_ALG_PKMODE_COPY_SSZ_B0_A0):
- case (OP_ALG_PKMODE_COPY_SSZ_B0_A1):
- case (OP_ALG_PKMODE_COPY_SSZ_B0_A2):
- case (OP_ALG_PKMODE_COPY_SSZ_B0_A3):
- case (OP_ALG_PKMODE_COPY_SSZ_B1_A0):
- case (OP_ALG_PKMODE_COPY_SSZ_B1_A1):
- case (OP_ALG_PKMODE_COPY_SSZ_B1_A2):
- case (OP_ALG_PKMODE_COPY_SSZ_B1_A3):
- case (OP_ALG_PKMODE_COPY_SSZ_B2_A0):
- case (OP_ALG_PKMODE_COPY_SSZ_B2_A1):
- case (OP_ALG_PKMODE_COPY_SSZ_B2_A2):
- case (OP_ALG_PKMODE_COPY_SSZ_B2_A3):
- case (OP_ALG_PKMODE_COPY_SSZ_B3_A0):
- case (OP_ALG_PKMODE_COPY_SSZ_B3_A1):
- case (OP_ALG_PKMODE_COPY_SSZ_B3_A2):
- case (OP_ALG_PKMODE_COPY_SSZ_B3_A3):
- case (OP_ALG_PKMODE_COPY_SSZ_A_E):
- case (OP_ALG_PKMODE_COPY_SSZ_A_N):
- case (OP_ALG_PKMODE_COPY_SSZ_B_E):
- case (OP_ALG_PKMODE_COPY_SSZ_B_N):
- case (OP_ALG_PKMODE_COPY_SSZ_N_A):
- case (OP_ALG_PKMODE_COPY_SSZ_N_B):
- case (OP_ALG_PKMODE_COPY_SSZ_N_E):
- return 0;
- }
-
- return -EINVAL;
-}
-
-static inline int
-rta_pkha_operation(struct program *program, uint32_t op_pkha)
-{
- uint32_t opcode = CMD_OPERATION | OP_TYPE_PK | OP_ALG_PK;
- uint32_t pkha_func;
- unsigned int start_pc = program->current_pc;
- int ret = -EINVAL;
-
- pkha_func = op_pkha & OP_ALG_PK_FUN_MASK;
-
- switch (pkha_func) {
- case (OP_ALG_PKMODE_CLEARMEM):
- ret = __rta_pkha_clearmem(op_pkha);
- if (ret < 0) {
- pr_err("OPERATION PKHA: Type not supported. SEC Program Line: %d\n",
- program->current_pc);
- goto err;
- }
- break;
- case (OP_ALG_PKMODE_MOD_ADD):
- case (OP_ALG_PKMODE_MOD_SUB_AB):
- case (OP_ALG_PKMODE_MOD_SUB_BA):
- case (OP_ALG_PKMODE_MOD_MULT):
- case (OP_ALG_PKMODE_MOD_EXPO):
- case (OP_ALG_PKMODE_MOD_REDUCT):
- case (OP_ALG_PKMODE_MOD_INV):
- case (OP_ALG_PKMODE_MOD_MONT_CNST):
- case (OP_ALG_PKMODE_MOD_CRT_CNST):
- case (OP_ALG_PKMODE_MOD_GCD):
- case (OP_ALG_PKMODE_MOD_PRIMALITY):
- case (OP_ALG_PKMODE_MOD_SML_EXP):
- case (OP_ALG_PKMODE_ECC_MOD_ADD):
- case (OP_ALG_PKMODE_ECC_MOD_DBL):
- case (OP_ALG_PKMODE_ECC_MOD_MUL):
- ret = __rta_pkha_mod_arithmetic(op_pkha);
- if (ret < 0) {
- pr_err("OPERATION PKHA: Type not supported. SEC Program Line: %d\n",
- program->current_pc);
- goto err;
- }
- break;
- case (OP_ALG_PKMODE_COPY_NSZ):
- case (OP_ALG_PKMODE_COPY_SSZ):
- ret = __rta_pkha_copymem(op_pkha);
- if (ret < 0) {
- pr_err("OPERATION PKHA: Type not supported. SEC Program Line: %d\n",
- program->current_pc);
- goto err;
- }
- break;
- default:
- pr_err("Invalid Operation Command\n");
- goto err;
- }
-
- opcode |= op_pkha;
-
- __rta_out32(program, opcode);
- program->current_instruction++;
- return (int)start_pc;
-
- err:
- program->first_error_pc = start_pc;
- program->current_instruction++;
- return ret;
-}
-
-#endif /* __RTA_OPERATION_CMD_H__ */
+++ /dev/null
-/* SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0)
- *
- * Copyright 2008-2016 Freescale Semiconductor Inc.
- * Copyright 2016,2019 NXP
- *
- */
-
-#ifndef __RTA_PROTOCOL_CMD_H__
-#define __RTA_PROTOCOL_CMD_H__
-
-extern enum rta_sec_era rta_sec_era;
-
-static inline int
-__rta_ssl_proto(uint16_t protoinfo)
-{
- switch (protoinfo) {
- case OP_PCL_TLS_RSA_EXPORT_WITH_RC4_40_MD5:
- case OP_PCL_TLS_RSA_WITH_RC4_128_MD5:
- case OP_PCL_TLS_RSA_WITH_RC4_128_SHA:
- case OP_PCL_TLS_DH_anon_EXPORT_WITH_RC4_40_MD5:
- case OP_PCL_TLS_DH_anon_WITH_RC4_128_MD5:
- case OP_PCL_TLS_KRB5_WITH_RC4_128_SHA:
- case OP_PCL_TLS_KRB5_WITH_RC4_128_MD5:
- case OP_PCL_TLS_KRB5_EXPORT_WITH_RC4_40_SHA:
- case OP_PCL_TLS_KRB5_EXPORT_WITH_RC4_40_MD5:
- case OP_PCL_TLS_PSK_WITH_RC4_128_SHA:
- case OP_PCL_TLS_DHE_PSK_WITH_RC4_128_SHA:
- case OP_PCL_TLS_RSA_PSK_WITH_RC4_128_SHA:
- case OP_PCL_TLS_ECDH_ECDSA_WITH_RC4_128_SHA:
- case OP_PCL_TLS_ECDHE_ECDSA_WITH_RC4_128_SHA:
- case OP_PCL_TLS_ECDH_RSA_WITH_RC4_128_SHA:
- case OP_PCL_TLS_ECDHE_RSA_WITH_RC4_128_SHA:
- case OP_PCL_TLS_ECDH_anon_WITH_RC4_128_SHA:
- case OP_PCL_TLS_ECDHE_PSK_WITH_RC4_128_SHA:
- if (rta_sec_era == RTA_SEC_ERA_7)
- return -EINVAL;
- /* fall through if not Era 7 */
- case OP_PCL_TLS_RSA_EXPORT_WITH_DES40_CBC_SHA:
- case OP_PCL_TLS_RSA_WITH_DES_CBC_SHA:
- case OP_PCL_TLS_RSA_WITH_3DES_EDE_CBC_SHA:
- case OP_PCL_TLS_DH_DSS_EXPORT_WITH_DES40_CBC_SHA:
- case OP_PCL_TLS_DH_DSS_WITH_DES_CBC_SHA:
- case OP_PCL_TLS_DH_DSS_WITH_3DES_EDE_CBC_SHA:
- case OP_PCL_TLS_DH_RSA_EXPORT_WITH_DES40_CBC_SHA:
- case OP_PCL_TLS_DH_RSA_WITH_DES_CBC_SHA:
- case OP_PCL_TLS_DH_RSA_WITH_3DES_EDE_CBC_SHA:
- case OP_PCL_TLS_DHE_DSS_EXPORT_WITH_DES40_CBC_SHA:
- case OP_PCL_TLS_DHE_DSS_WITH_DES_CBC_SHA:
- case OP_PCL_TLS_DHE_DSS_WITH_3DES_EDE_CBC_SHA:
- case OP_PCL_TLS_DHE_RSA_EXPORT_WITH_DES40_CBC_SHA:
- case OP_PCL_TLS_DHE_RSA_WITH_DES_CBC_SHA:
- case OP_PCL_TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA:
- case OP_PCL_TLS_DH_anon_EXPORT_WITH_DES40_CBC_SHA:
- case OP_PCL_TLS_DH_anon_WITH_DES_CBC_SHA:
- case OP_PCL_TLS_DH_anon_WITH_3DES_EDE_CBC_SHA:
- case OP_PCL_TLS_KRB5_WITH_DES_CBC_SHA:
- case OP_PCL_TLS_KRB5_WITH_3DES_EDE_CBC_SHA:
- case OP_PCL_TLS_KRB5_WITH_DES_CBC_MD5:
- case OP_PCL_TLS_KRB5_WITH_3DES_EDE_CBC_MD5:
- case OP_PCL_TLS_KRB5_EXPORT_WITH_DES_CBC_40_SHA:
- case OP_PCL_TLS_KRB5_EXPORT_WITH_DES_CBC_40_MD5:
- case OP_PCL_TLS_RSA_WITH_AES_128_CBC_SHA:
- case OP_PCL_TLS_DH_DSS_WITH_AES_128_CBC_SHA:
- case OP_PCL_TLS_DH_RSA_WITH_AES_128_CBC_SHA:
- case OP_PCL_TLS_DHE_DSS_WITH_AES_128_CBC_SHA:
- case OP_PCL_TLS_DHE_RSA_WITH_AES_128_CBC_SHA:
- case OP_PCL_TLS_DH_anon_WITH_AES_128_CBC_SHA:
- case OP_PCL_TLS_RSA_WITH_AES_256_CBC_SHA:
- case OP_PCL_TLS_DH_DSS_WITH_AES_256_CBC_SHA:
- case OP_PCL_TLS_DH_RSA_WITH_AES_256_CBC_SHA:
- case OP_PCL_TLS_DHE_DSS_WITH_AES_256_CBC_SHA:
- case OP_PCL_TLS_DHE_RSA_WITH_AES_256_CBC_SHA:
- case OP_PCL_TLS_DH_anon_WITH_AES_256_CBC_SHA:
- case OP_PCL_TLS_DH_DSS_WITH_AES_128_CBC_SHA256:
- case OP_PCL_TLS_DH_RSA_WITH_AES_128_CBC_SHA256:
- case OP_PCL_TLS_DHE_DSS_WITH_AES_128_CBC_SHA256:
- case OP_PCL_TLS_DHE_RSA_WITH_AES_128_CBC_SHA256:
- case OP_PCL_TLS_DH_DSS_WITH_AES_256_CBC_SHA256:
- case OP_PCL_TLS_DH_RSA_WITH_AES_256_CBC_SHA256:
- case OP_PCL_TLS_DHE_DSS_WITH_AES_256_CBC_SHA256:
- case OP_PCL_TLS_DHE_RSA_WITH_AES_256_CBC_SHA256:
- case OP_PCL_TLS_DH_anon_WITH_AES_128_CBC_SHA256:
- case OP_PCL_TLS_DH_anon_WITH_AES_256_CBC_SHA256:
- case OP_PCL_TLS_PSK_WITH_3DES_EDE_CBC_SHA:
- case OP_PCL_TLS_PSK_WITH_AES_128_CBC_SHA:
- case OP_PCL_TLS_PSK_WITH_AES_256_CBC_SHA:
- case OP_PCL_TLS_DHE_PSK_WITH_3DES_EDE_CBC_SHA:
- case OP_PCL_TLS_DHE_PSK_WITH_AES_128_CBC_SHA:
- case OP_PCL_TLS_DHE_PSK_WITH_AES_256_CBC_SHA:
- case OP_PCL_TLS_RSA_PSK_WITH_3DES_EDE_CBC_SHA:
- case OP_PCL_TLS_RSA_PSK_WITH_AES_128_CBC_SHA:
- case OP_PCL_TLS_RSA_PSK_WITH_AES_256_CBC_SHA:
- case OP_PCL_TLS_RSA_WITH_AES_128_GCM_SHA256:
- case OP_PCL_TLS_RSA_WITH_AES_256_GCM_SHA384:
- case OP_PCL_TLS_DHE_RSA_WITH_AES_128_GCM_SHA256:
- case OP_PCL_TLS_DHE_RSA_WITH_AES_256_GCM_SHA384:
- case OP_PCL_TLS_DH_RSA_WITH_AES_128_GCM_SHA256:
- case OP_PCL_TLS_DH_RSA_WITH_AES_256_GCM_SHA384:
- case OP_PCL_TLS_DHE_DSS_WITH_AES_128_GCM_SHA256:
- case OP_PCL_TLS_DHE_DSS_WITH_AES_256_GCM_SHA384:
- case OP_PCL_TLS_DH_DSS_WITH_AES_128_GCM_SHA256:
- case OP_PCL_TLS_DH_DSS_WITH_AES_256_GCM_SHA384:
- case OP_PCL_TLS_DH_anon_WITH_AES_128_GCM_SHA256:
- case OP_PCL_TLS_DH_anon_WITH_AES_256_GCM_SHA384:
- case OP_PCL_TLS_PSK_WITH_AES_128_GCM_SHA256:
- case OP_PCL_TLS_PSK_WITH_AES_256_GCM_SHA384:
- case OP_PCL_TLS_DHE_PSK_WITH_AES_128_GCM_SHA256:
- case OP_PCL_TLS_DHE_PSK_WITH_AES_256_GCM_SHA384:
- case OP_PCL_TLS_RSA_PSK_WITH_AES_128_GCM_SHA256:
- case OP_PCL_TLS_RSA_PSK_WITH_AES_256_GCM_SHA384:
- case OP_PCL_TLS_PSK_WITH_AES_128_CBC_SHA256:
- case OP_PCL_TLS_PSK_WITH_AES_256_CBC_SHA384:
- case OP_PCL_TLS_DHE_PSK_WITH_AES_128_CBC_SHA256:
- case OP_PCL_TLS_DHE_PSK_WITH_AES_256_CBC_SHA384:
- case OP_PCL_TLS_RSA_PSK_WITH_AES_128_CBC_SHA256:
- case OP_PCL_TLS_RSA_PSK_WITH_AES_256_CBC_SHA384:
- case OP_PCL_TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA:
- case OP_PCL_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA:
- case OP_PCL_TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA:
- case OP_PCL_TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA:
- case OP_PCL_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA:
- case OP_PCL_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA:
- case OP_PCL_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA:
- case OP_PCL_TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA:
- case OP_PCL_TLS_ECDH_RSA_WITH_AES_256_CBC_SHA:
- case OP_PCL_TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA:
- case OP_PCL_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA:
- case OP_PCL_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA:
- case OP_PCL_TLS_ECDH_anon_WITH_3DES_EDE_CBC_SHA:
- case OP_PCL_TLS_ECDH_anon_WITH_AES_128_CBC_SHA:
- case OP_PCL_TLS_ECDH_anon_WITH_AES_256_CBC_SHA:
- case OP_PCL_TLS_SRP_SHA_WITH_3DES_EDE_CBC_SHA:
- case OP_PCL_TLS_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA:
- case OP_PCL_TLS_SRP_SHA_DSS_WITH_3DES_EDE_CBC_SHA:
- case OP_PCL_TLS_SRP_SHA_WITH_AES_128_CBC_SHA:
- case OP_PCL_TLS_SRP_SHA_RSA_WITH_AES_128_CBC_SHA:
- case OP_PCL_TLS_SRP_SHA_DSS_WITH_AES_128_CBC_SHA:
- case OP_PCL_TLS_SRP_SHA_WITH_AES_256_CBC_SHA:
- case OP_PCL_TLS_SRP_SHA_RSA_WITH_AES_256_CBC_SHA:
- case OP_PCL_TLS_SRP_SHA_DSS_WITH_AES_256_CBC_SHA:
- case OP_PCL_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256:
- case OP_PCL_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384:
- case OP_PCL_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256:
- case OP_PCL_TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384:
- case OP_PCL_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256:
- case OP_PCL_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384:
- case OP_PCL_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256:
- case OP_PCL_TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384:
- case OP_PCL_TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256:
- case OP_PCL_TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384:
- case OP_PCL_TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256:
- case OP_PCL_TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384:
- case OP_PCL_TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256:
- case OP_PCL_TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384:
- case OP_PCL_TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256:
- case OP_PCL_TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384:
- case OP_PCL_TLS_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA:
- case OP_PCL_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA:
- case OP_PCL_TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA:
- case OP_PCL_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256:
- case OP_PCL_TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA384:
- case OP_PCL_TLS_RSA_WITH_AES_128_CBC_SHA256:
- case OP_PCL_TLS_RSA_WITH_AES_256_CBC_SHA256:
- case OP_PCL_PVT_TLS_3DES_EDE_CBC_MD5:
- case OP_PCL_PVT_TLS_3DES_EDE_CBC_SHA160:
- case OP_PCL_PVT_TLS_3DES_EDE_CBC_SHA224:
- case OP_PCL_PVT_TLS_3DES_EDE_CBC_SHA256:
- case OP_PCL_PVT_TLS_3DES_EDE_CBC_SHA384:
- case OP_PCL_PVT_TLS_3DES_EDE_CBC_SHA512:
- case OP_PCL_PVT_TLS_AES_128_CBC_SHA160:
- case OP_PCL_PVT_TLS_AES_128_CBC_SHA224:
- case OP_PCL_PVT_TLS_AES_128_CBC_SHA256:
- case OP_PCL_PVT_TLS_AES_128_CBC_SHA384:
- case OP_PCL_PVT_TLS_AES_128_CBC_SHA512:
- case OP_PCL_PVT_TLS_AES_192_CBC_SHA160:
- case OP_PCL_PVT_TLS_AES_192_CBC_SHA224:
- case OP_PCL_PVT_TLS_AES_192_CBC_SHA256:
- case OP_PCL_PVT_TLS_AES_192_CBC_SHA512:
- case OP_PCL_PVT_TLS_AES_256_CBC_SHA160:
- case OP_PCL_PVT_TLS_AES_256_CBC_SHA224:
- case OP_PCL_PVT_TLS_AES_256_CBC_SHA384:
- case OP_PCL_PVT_TLS_AES_256_CBC_SHA512:
- case OP_PCL_PVT_TLS_AES_256_CBC_SHA256:
- case OP_PCL_PVT_TLS_AES_192_CBC_SHA384:
- case OP_PCL_PVT_TLS_MASTER_SECRET_PRF_FE:
- case OP_PCL_PVT_TLS_MASTER_SECRET_PRF_FF:
- return 0;
- }
-
- return -EINVAL;
-}
-
-static inline int
-__rta_ike_proto(uint16_t protoinfo)
-{
- switch (protoinfo) {
- case OP_PCL_IKE_HMAC_MD5:
- case OP_PCL_IKE_HMAC_SHA1:
- case OP_PCL_IKE_HMAC_AES128_CBC:
- case OP_PCL_IKE_HMAC_SHA256:
- case OP_PCL_IKE_HMAC_SHA384:
- case OP_PCL_IKE_HMAC_SHA512:
- case OP_PCL_IKE_HMAC_AES128_CMAC:
- return 0;
- }
-
- return -EINVAL;
-}
-
-static inline int
-__rta_ipsec_proto(uint16_t protoinfo)
-{
- uint16_t proto_cls1 = protoinfo & OP_PCL_IPSEC_CIPHER_MASK;
- uint16_t proto_cls2 = protoinfo & OP_PCL_IPSEC_AUTH_MASK;
-
- switch (proto_cls1) {
- case OP_PCL_IPSEC_AES_NULL_WITH_GMAC:
- if (rta_sec_era < RTA_SEC_ERA_2)
- return -EINVAL;
- /* no break */
- case OP_PCL_IPSEC_AES_CCM8:
- case OP_PCL_IPSEC_AES_CCM12:
- case OP_PCL_IPSEC_AES_CCM16:
- case OP_PCL_IPSEC_AES_GCM8:
- case OP_PCL_IPSEC_AES_GCM12:
- case OP_PCL_IPSEC_AES_GCM16:
- /* CCM, GCM, GMAC require PROTINFO[7:0] = 0 */
- if (proto_cls2 == OP_PCL_IPSEC_HMAC_NULL)
- return 0;
- return -EINVAL;
- case OP_PCL_IPSEC_NULL:
- if (rta_sec_era < RTA_SEC_ERA_2)
- return -EINVAL;
- /* no break */
- case OP_PCL_IPSEC_DES_IV64:
- case OP_PCL_IPSEC_DES:
- case OP_PCL_IPSEC_3DES:
- case OP_PCL_IPSEC_AES_CBC:
- case OP_PCL_IPSEC_AES_CTR:
- break;
- default:
- return -EINVAL;
- }
-
- switch (proto_cls2) {
- case OP_PCL_IPSEC_HMAC_NULL:
- case OP_PCL_IPSEC_HMAC_MD5_96:
- case OP_PCL_IPSEC_HMAC_SHA1_96:
- case OP_PCL_IPSEC_AES_XCBC_MAC_96:
- case OP_PCL_IPSEC_HMAC_MD5_128:
- case OP_PCL_IPSEC_HMAC_SHA1_160:
- case OP_PCL_IPSEC_AES_CMAC_96:
- case OP_PCL_IPSEC_HMAC_SHA2_256_128:
- case OP_PCL_IPSEC_HMAC_SHA2_384_192:
- case OP_PCL_IPSEC_HMAC_SHA2_512_256:
- return 0;
- }
-
- return -EINVAL;
-}
-
-static inline int
-__rta_srtp_proto(uint16_t protoinfo)
-{
- uint16_t proto_cls1 = protoinfo & OP_PCL_SRTP_CIPHER_MASK;
- uint16_t proto_cls2 = protoinfo & OP_PCL_SRTP_AUTH_MASK;
-
- switch (proto_cls1) {
- case OP_PCL_SRTP_AES_CTR:
- switch (proto_cls2) {
- case OP_PCL_SRTP_HMAC_SHA1_160:
- return 0;
- }
- /* no break */
- }
-
- return -EINVAL;
-}
-
-static inline int
-__rta_macsec_proto(uint16_t protoinfo)
-{
- switch (protoinfo) {
- case OP_PCL_MACSEC:
- return 0;
- }
-
- return -EINVAL;
-}
-
-static inline int
-__rta_wifi_proto(uint16_t protoinfo)
-{
- switch (protoinfo) {
- case OP_PCL_WIFI:
- return 0;
- }
-
- return -EINVAL;
-}
-
-static inline int
-__rta_wimax_proto(uint16_t protoinfo)
-{
- switch (protoinfo) {
- case OP_PCL_WIMAX_OFDM:
- case OP_PCL_WIMAX_OFDMA:
- return 0;
- }
-
- return -EINVAL;
-}
-
-/* Allowed blob proto flags for each SEC Era */
-static const uint32_t proto_blob_flags[] = {
- OP_PCL_BLOB_FORMAT_MASK | OP_PCL_BLOB_BLACK,
- OP_PCL_BLOB_FORMAT_MASK | OP_PCL_BLOB_BLACK | OP_PCL_BLOB_TKEK |
- OP_PCL_BLOB_EKT | OP_PCL_BLOB_REG_MASK,
- OP_PCL_BLOB_FORMAT_MASK | OP_PCL_BLOB_BLACK | OP_PCL_BLOB_TKEK |
- OP_PCL_BLOB_EKT | OP_PCL_BLOB_REG_MASK,
- OP_PCL_BLOB_FORMAT_MASK | OP_PCL_BLOB_BLACK | OP_PCL_BLOB_TKEK |
- OP_PCL_BLOB_EKT | OP_PCL_BLOB_REG_MASK | OP_PCL_BLOB_SEC_MEM,
- OP_PCL_BLOB_FORMAT_MASK | OP_PCL_BLOB_BLACK | OP_PCL_BLOB_TKEK |
- OP_PCL_BLOB_EKT | OP_PCL_BLOB_REG_MASK | OP_PCL_BLOB_SEC_MEM,
- OP_PCL_BLOB_FORMAT_MASK | OP_PCL_BLOB_BLACK | OP_PCL_BLOB_TKEK |
- OP_PCL_BLOB_EKT | OP_PCL_BLOB_REG_MASK | OP_PCL_BLOB_SEC_MEM,
- OP_PCL_BLOB_FORMAT_MASK | OP_PCL_BLOB_BLACK | OP_PCL_BLOB_TKEK |
- OP_PCL_BLOB_EKT | OP_PCL_BLOB_REG_MASK | OP_PCL_BLOB_SEC_MEM,
- OP_PCL_BLOB_FORMAT_MASK | OP_PCL_BLOB_BLACK | OP_PCL_BLOB_TKEK |
- OP_PCL_BLOB_EKT | OP_PCL_BLOB_REG_MASK | OP_PCL_BLOB_SEC_MEM,
- OP_PCL_BLOB_FORMAT_MASK | OP_PCL_BLOB_BLACK | OP_PCL_BLOB_TKEK |
- OP_PCL_BLOB_EKT | OP_PCL_BLOB_REG_MASK | OP_PCL_BLOB_SEC_MEM,
- OP_PCL_BLOB_FORMAT_MASK | OP_PCL_BLOB_BLACK | OP_PCL_BLOB_TKEK |
- OP_PCL_BLOB_EKT | OP_PCL_BLOB_REG_MASK | OP_PCL_BLOB_SEC_MEM
-};
-
-static inline int
-__rta_blob_proto(uint16_t protoinfo)
-{
- if (protoinfo & ~proto_blob_flags[rta_sec_era])
- return -EINVAL;
-
- switch (protoinfo & OP_PCL_BLOB_FORMAT_MASK) {
- case OP_PCL_BLOB_FORMAT_NORMAL:
- case OP_PCL_BLOB_FORMAT_MASTER_VER:
- case OP_PCL_BLOB_FORMAT_TEST:
- break;
- default:
- return -EINVAL;
- }
-
- switch (protoinfo & OP_PCL_BLOB_REG_MASK) {
- case OP_PCL_BLOB_AFHA_SBOX:
- if (rta_sec_era < RTA_SEC_ERA_3)
- return -EINVAL;
- /* no break */
- case OP_PCL_BLOB_REG_MEMORY:
- case OP_PCL_BLOB_REG_KEY1:
- case OP_PCL_BLOB_REG_KEY2:
- case OP_PCL_BLOB_REG_SPLIT:
- case OP_PCL_BLOB_REG_PKE:
- return 0;
- }
-
- return -EINVAL;
-}
-
-static inline int
-__rta_dlc_proto(uint16_t protoinfo)
-{
- if ((rta_sec_era < RTA_SEC_ERA_2) &&
- (protoinfo & (OP_PCL_PKPROT_DSA_MSG | OP_PCL_PKPROT_HASH_MASK |
- OP_PCL_PKPROT_EKT_Z | OP_PCL_PKPROT_DECRYPT_Z |
- OP_PCL_PKPROT_DECRYPT_PRI)))
- return -EINVAL;
-
- switch (protoinfo & OP_PCL_PKPROT_HASH_MASK) {
- case OP_PCL_PKPROT_HASH_MD5:
- case OP_PCL_PKPROT_HASH_SHA1:
- case OP_PCL_PKPROT_HASH_SHA224:
- case OP_PCL_PKPROT_HASH_SHA256:
- case OP_PCL_PKPROT_HASH_SHA384:
- case OP_PCL_PKPROT_HASH_SHA512:
- break;
- default:
- return -EINVAL;
- }
-
- return 0;
-}
-
-static inline int
-__rta_rsa_enc_proto(uint16_t protoinfo)
-{
- switch (protoinfo & OP_PCL_RSAPROT_OP_MASK) {
- case OP_PCL_RSAPROT_OP_ENC_F_IN:
- if ((protoinfo & OP_PCL_RSAPROT_FFF_MASK) !=
- OP_PCL_RSAPROT_FFF_RED)
- return -EINVAL;
- break;
- case OP_PCL_RSAPROT_OP_ENC_F_OUT:
- switch (protoinfo & OP_PCL_RSAPROT_FFF_MASK) {
- case OP_PCL_RSAPROT_FFF_RED:
- case OP_PCL_RSAPROT_FFF_ENC:
- case OP_PCL_RSAPROT_FFF_EKT:
- case OP_PCL_RSAPROT_FFF_TK_ENC:
- case OP_PCL_RSAPROT_FFF_TK_EKT:
- break;
- default:
- return -EINVAL;
- }
- break;
- default:
- return -EINVAL;
- }
-
- return 0;
-}
-
-static inline int
-__rta_rsa_dec_proto(uint16_t protoinfo)
-{
- switch (protoinfo & OP_PCL_RSAPROT_OP_MASK) {
- case OP_PCL_RSAPROT_OP_DEC_ND:
- case OP_PCL_RSAPROT_OP_DEC_PQD:
- case OP_PCL_RSAPROT_OP_DEC_PQDPDQC:
- break;
- default:
- return -EINVAL;
- }
-
- switch (protoinfo & OP_PCL_RSAPROT_PPP_MASK) {
- case OP_PCL_RSAPROT_PPP_RED:
- case OP_PCL_RSAPROT_PPP_ENC:
- case OP_PCL_RSAPROT_PPP_EKT:
- case OP_PCL_RSAPROT_PPP_TK_ENC:
- case OP_PCL_RSAPROT_PPP_TK_EKT:
- break;
- default:
- return -EINVAL;
- }
-
- if (protoinfo & OP_PCL_RSAPROT_FMT_PKCSV15)
- switch (protoinfo & OP_PCL_RSAPROT_FFF_MASK) {
- case OP_PCL_RSAPROT_FFF_RED:
- case OP_PCL_RSAPROT_FFF_ENC:
- case OP_PCL_RSAPROT_FFF_EKT:
- case OP_PCL_RSAPROT_FFF_TK_ENC:
- case OP_PCL_RSAPROT_FFF_TK_EKT:
- break;
- default:
- return -EINVAL;
- }
-
- return 0;
-}
-
-/*
- * DKP Protocol - Restrictions on key (SRC,DST) combinations
- * For e.g. key_in_out[0][0] = 1 means (SRC=IMM,DST=IMM) combination is allowed
- */
-static const uint8_t key_in_out[4][4] = { {1, 0, 0, 0},
- {1, 1, 1, 1},
- {1, 0, 1, 0},
- {1, 0, 0, 1} };
-
-static inline int
-__rta_dkp_proto(uint16_t protoinfo)
-{
- int key_src = (protoinfo & OP_PCL_DKP_SRC_MASK) >> OP_PCL_DKP_SRC_SHIFT;
- int key_dst = (protoinfo & OP_PCL_DKP_DST_MASK) >> OP_PCL_DKP_DST_SHIFT;
-
- if (!key_in_out[key_src][key_dst]) {
- pr_err("PROTO_DESC: Invalid DKP key (SRC,DST)\n");
- return -EINVAL;
- }
-
- return 0;
-}
-
-
-static inline int
-__rta_3g_dcrc_proto(uint16_t protoinfo)
-{
- if (rta_sec_era == RTA_SEC_ERA_7)
- return -EINVAL;
-
- switch (protoinfo) {
- case OP_PCL_3G_DCRC_CRC7:
- case OP_PCL_3G_DCRC_CRC11:
- return 0;
- }
-
- return -EINVAL;
-}
-
-static inline int
-__rta_3g_rlc_proto(uint16_t protoinfo)
-{
- if (rta_sec_era == RTA_SEC_ERA_7)
- return -EINVAL;
-
- switch (protoinfo) {
- case OP_PCL_3G_RLC_NULL:
- case OP_PCL_3G_RLC_KASUMI:
- case OP_PCL_3G_RLC_SNOW:
- return 0;
- }
-
- return -EINVAL;
-}
-
-static inline int
-__rta_lte_pdcp_proto(uint16_t protoinfo)
-{
- if (rta_sec_era == RTA_SEC_ERA_7)
- return -EINVAL;
-
- switch (protoinfo) {
- case OP_PCL_LTE_ZUC:
- if (rta_sec_era < RTA_SEC_ERA_5)
- break;
- case OP_PCL_LTE_NULL:
- case OP_PCL_LTE_SNOW:
- case OP_PCL_LTE_AES:
- return 0;
- }
-
- return -EINVAL;
-}
-
-static inline int
-__rta_lte_pdcp_mixed_proto(uint16_t protoinfo)
-{
- switch (protoinfo & OP_PCL_LTE_MIXED_AUTH_MASK) {
- case OP_PCL_LTE_MIXED_AUTH_NULL:
- case OP_PCL_LTE_MIXED_AUTH_SNOW:
- case OP_PCL_LTE_MIXED_AUTH_AES:
- case OP_PCL_LTE_MIXED_AUTH_ZUC:
- break;
- default:
- return -EINVAL;
- }
-
- switch (protoinfo & OP_PCL_LTE_MIXED_ENC_MASK) {
- case OP_PCL_LTE_MIXED_ENC_NULL:
- case OP_PCL_LTE_MIXED_ENC_SNOW:
- case OP_PCL_LTE_MIXED_ENC_AES:
- case OP_PCL_LTE_MIXED_ENC_ZUC:
- return 0;
- }
-
- return -EINVAL;
-}
-
-struct proto_map {
- uint32_t optype;
- uint32_t protid;
- int (*protoinfo_func)(uint16_t);
-};
-
-static const struct proto_map proto_table[] = {
-/*1*/ {OP_TYPE_UNI_PROTOCOL, OP_PCLID_SSL30_PRF, __rta_ssl_proto},
- {OP_TYPE_UNI_PROTOCOL, OP_PCLID_TLS10_PRF, __rta_ssl_proto},
- {OP_TYPE_UNI_PROTOCOL, OP_PCLID_TLS11_PRF, __rta_ssl_proto},
- {OP_TYPE_UNI_PROTOCOL, OP_PCLID_TLS12_PRF, __rta_ssl_proto},
- {OP_TYPE_UNI_PROTOCOL, OP_PCLID_DTLS_PRF, __rta_ssl_proto},
- {OP_TYPE_UNI_PROTOCOL, OP_PCLID_IKEV1_PRF, __rta_ike_proto},
- {OP_TYPE_UNI_PROTOCOL, OP_PCLID_IKEV2_PRF, __rta_ike_proto},
- {OP_TYPE_UNI_PROTOCOL, OP_PCLID_PUBLICKEYPAIR, __rta_dlc_proto},
- {OP_TYPE_UNI_PROTOCOL, OP_PCLID_DSASIGN, __rta_dlc_proto},
- {OP_TYPE_UNI_PROTOCOL, OP_PCLID_DSAVERIFY, __rta_dlc_proto},
- {OP_TYPE_DECAP_PROTOCOL, OP_PCLID_IPSEC, __rta_ipsec_proto},
- {OP_TYPE_DECAP_PROTOCOL, OP_PCLID_SRTP, __rta_srtp_proto},
- {OP_TYPE_DECAP_PROTOCOL, OP_PCLID_SSL30, __rta_ssl_proto},
- {OP_TYPE_DECAP_PROTOCOL, OP_PCLID_TLS10, __rta_ssl_proto},
- {OP_TYPE_DECAP_PROTOCOL, OP_PCLID_TLS11, __rta_ssl_proto},
- {OP_TYPE_DECAP_PROTOCOL, OP_PCLID_TLS12, __rta_ssl_proto},
- {OP_TYPE_DECAP_PROTOCOL, OP_PCLID_DTLS, __rta_ssl_proto},
- {OP_TYPE_DECAP_PROTOCOL, OP_PCLID_MACSEC, __rta_macsec_proto},
- {OP_TYPE_DECAP_PROTOCOL, OP_PCLID_WIFI, __rta_wifi_proto},
- {OP_TYPE_DECAP_PROTOCOL, OP_PCLID_WIMAX, __rta_wimax_proto},
-/*21*/ {OP_TYPE_DECAP_PROTOCOL, OP_PCLID_BLOB, __rta_blob_proto},
- {OP_TYPE_UNI_PROTOCOL, OP_PCLID_DIFFIEHELLMAN, __rta_dlc_proto},
- {OP_TYPE_UNI_PROTOCOL, OP_PCLID_RSAENCRYPT, __rta_rsa_enc_proto},
- {OP_TYPE_UNI_PROTOCOL, OP_PCLID_RSADECRYPT, __rta_rsa_dec_proto},
- {OP_TYPE_DECAP_PROTOCOL, OP_PCLID_3G_DCRC, __rta_3g_dcrc_proto},
- {OP_TYPE_DECAP_PROTOCOL, OP_PCLID_3G_RLC_PDU, __rta_3g_rlc_proto},
- {OP_TYPE_DECAP_PROTOCOL, OP_PCLID_3G_RLC_SDU, __rta_3g_rlc_proto},
- {OP_TYPE_DECAP_PROTOCOL, OP_PCLID_LTE_PDCP_USER, __rta_lte_pdcp_proto},
-/*29*/ {OP_TYPE_DECAP_PROTOCOL, OP_PCLID_LTE_PDCP_CTRL, __rta_lte_pdcp_proto},
- {OP_TYPE_UNI_PROTOCOL, OP_PCLID_DKP_MD5, __rta_dkp_proto},
- {OP_TYPE_UNI_PROTOCOL, OP_PCLID_DKP_SHA1, __rta_dkp_proto},
- {OP_TYPE_UNI_PROTOCOL, OP_PCLID_DKP_SHA224, __rta_dkp_proto},
- {OP_TYPE_UNI_PROTOCOL, OP_PCLID_DKP_SHA256, __rta_dkp_proto},
- {OP_TYPE_UNI_PROTOCOL, OP_PCLID_DKP_SHA384, __rta_dkp_proto},
-/*35*/ {OP_TYPE_UNI_PROTOCOL, OP_PCLID_DKP_SHA512, __rta_dkp_proto},
- {OP_TYPE_DECAP_PROTOCOL, OP_PCLID_PUBLICKEYPAIR, __rta_dlc_proto},
-/*37*/ {OP_TYPE_DECAP_PROTOCOL, OP_PCLID_DSASIGN, __rta_dlc_proto},
-/*38*/ {OP_TYPE_DECAP_PROTOCOL, OP_PCLID_LTE_PDCP_CTRL_MIXED,
- __rta_lte_pdcp_mixed_proto},
- {OP_TYPE_DECAP_PROTOCOL, OP_PCLID_IPSEC_NEW, __rta_ipsec_proto},
-/*40*/ {OP_TYPE_DECAP_PROTOCOL, OP_PCLID_LTE_PDCP_USER_RN,
- __rta_lte_pdcp_mixed_proto},
-};
-
-/*
- * Allowed OPERATION protocols for each SEC Era.
- * Values represent the number of entries from proto_table[] that are supported.
- */
-static const unsigned int proto_table_sz[] = {21, 29, 29, 29, 29, 35, 37,
- 40, 40, 40};
-
-static inline int
-rta_proto_operation(struct program *program, uint32_t optype,
- uint32_t protid, uint16_t protoinfo)
-{
- uint32_t opcode = CMD_OPERATION;
- unsigned int i, found = 0;
- uint32_t optype_tmp = optype;
- unsigned int start_pc = program->current_pc;
- int ret = -EINVAL;
-
- for (i = 0; i < proto_table_sz[rta_sec_era]; i++) {
- /* clear last bit in optype to match also decap proto */
- optype_tmp &= (uint32_t)~(1 << OP_TYPE_SHIFT);
- if (optype_tmp == proto_table[i].optype) {
- if (proto_table[i].protid == protid) {
- /* nothing else to verify */
- if (proto_table[i].protoinfo_func == NULL) {
- found = 1;
- break;
- }
- /* check protoinfo */
- ret = (*proto_table[i].protoinfo_func)
- (protoinfo);
- if (ret < 0) {
- pr_err("PROTO_DESC: Bad PROTO Type. SEC Program Line: %d\n",
- program->current_pc);
- goto err;
- }
- found = 1;
- break;
- }
- }
- }
- if (!found) {
- pr_err("PROTO_DESC: Operation Type Mismatch. SEC Program Line: %d\n",
- program->current_pc);
- goto err;
- }
-
- __rta_out32(program, opcode | optype | protid | protoinfo);
- program->current_instruction++;
- return (int)start_pc;
-
- err:
- program->first_error_pc = start_pc;
- program->current_instruction++;
- return ret;
-}
-
-static inline int
-rta_dkp_proto(struct program *program, uint32_t protid,
- uint16_t key_src, uint16_t key_dst,
- uint16_t keylen, uint64_t key,
- enum rta_data_type key_type)
-{
- unsigned int start_pc = program->current_pc;
- unsigned int in_words = 0, out_words = 0;
- int ret;
-
- key_src &= OP_PCL_DKP_SRC_MASK;
- key_dst &= OP_PCL_DKP_DST_MASK;
- keylen &= OP_PCL_DKP_KEY_MASK;
-
- ret = rta_proto_operation(program, OP_TYPE_UNI_PROTOCOL, protid,
- key_src | key_dst | keylen);
- if (ret < 0)
- return ret;
-
- if ((key_src == OP_PCL_DKP_SRC_PTR) ||
- (key_src == OP_PCL_DKP_SRC_SGF)) {
- __rta_out64(program, program->ps, key);
- in_words = program->ps ? 2 : 1;
- } else if (key_src == OP_PCL_DKP_SRC_IMM) {
- __rta_inline_data(program, key, inline_flags(key_type), keylen);
- in_words = (unsigned int)((keylen + 3) / 4);
- }
-
- if ((key_dst == OP_PCL_DKP_DST_PTR) ||
- (key_dst == OP_PCL_DKP_DST_SGF)) {
- out_words = in_words;
- } else if (key_dst == OP_PCL_DKP_DST_IMM) {
- out_words = split_key_len(protid) / 4;
- }
-
- if (out_words < in_words) {
- pr_err("PROTO_DESC: DKP doesn't currently support a smaller descriptor\n");
- program->first_error_pc = start_pc;
- return -EINVAL;
- }
-
- /* If needed, reserve space in resulting descriptor for derived key */
- program->current_pc += (out_words - in_words);
-
- return (int)start_pc;
-}
-
-#endif /* __RTA_PROTOCOL_CMD_H__ */
+++ /dev/null
-/* SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0)
- *
- * Copyright 2008-2016 Freescale Semiconductor Inc.
- * Copyright 2016,2019 NXP
- */
-
-#ifndef __RTA_SEC_RUN_TIME_ASM_H__
-#define __RTA_SEC_RUN_TIME_ASM_H__
-
-#include "hw/desc.h"
-
-/* hw/compat.h is not delivered in kernel */
-#ifndef __KERNEL__
-#include "hw/compat.h"
-#endif
-
-/**
- * enum rta_sec_era - SEC HW block revisions supported by the RTA library
- * @RTA_SEC_ERA_1: SEC Era 1
- * @RTA_SEC_ERA_2: SEC Era 2
- * @RTA_SEC_ERA_3: SEC Era 3
- * @RTA_SEC_ERA_4: SEC Era 4
- * @RTA_SEC_ERA_5: SEC Era 5
- * @RTA_SEC_ERA_6: SEC Era 6
- * @RTA_SEC_ERA_7: SEC Era 7
- * @RTA_SEC_ERA_8: SEC Era 8
- * @MAX_SEC_ERA: maximum SEC HW block revision supported by RTA library
- */
-enum rta_sec_era {
- RTA_SEC_ERA_1,
- RTA_SEC_ERA_2,
- RTA_SEC_ERA_3,
- RTA_SEC_ERA_4,
- RTA_SEC_ERA_5,
- RTA_SEC_ERA_6,
- RTA_SEC_ERA_7,
- RTA_SEC_ERA_8,
- RTA_SEC_ERA_9,
- RTA_SEC_ERA_10,
- MAX_SEC_ERA = RTA_SEC_ERA_10
-};
-
-/**
- * DEFAULT_SEC_ERA - the default value for the SEC era in case the user provides
- * an unsupported value.
- */
-#define DEFAULT_SEC_ERA MAX_SEC_ERA
-
-/**
- * USER_SEC_ERA - translates the SEC Era from internal to user representation.
- * @sec_era: SEC Era in internal (library) representation
- */
-#define USER_SEC_ERA(sec_era) (sec_era + 1)
-
-/**
- * INTL_SEC_ERA - translates the SEC Era from user representation to internal.
- * @sec_era: SEC Era in user representation
- */
-#define INTL_SEC_ERA(sec_era) (sec_era - 1)
-
-/**
- * enum rta_jump_type - Types of action taken by JUMP command
- * @LOCAL_JUMP: conditional jump to an offset within the descriptor buffer
- * @FAR_JUMP: conditional jump to a location outside the descriptor buffer,
- * indicated by the POINTER field after the JUMP command.
- * @HALT: conditional halt - stop the execution of the current descriptor and
- * writes PKHA / Math condition bits as status / error code.
- * @HALT_STATUS: conditional halt with user-specified status - stop the
- * execution of the current descriptor and writes the value of
- * "LOCAL OFFSET" JUMP field as status / error code.
- * @GOSUB: conditional subroutine call - similar to @LOCAL_JUMP, but also saves
- * return address in the Return Address register; subroutine calls
- * cannot be nested.
- * @RETURN: conditional subroutine return - similar to @LOCAL_JUMP, but the
- * offset is taken from the Return Address register.
- * @LOCAL_JUMP_INC: similar to @LOCAL_JUMP, but increment the register specified
- * in "SRC_DST" JUMP field before evaluating the jump
- * condition.
- * @LOCAL_JUMP_DEC: similar to @LOCAL_JUMP, but decrement the register specified
- * in "SRC_DST" JUMP field before evaluating the jump
- * condition.
- */
-enum rta_jump_type {
- LOCAL_JUMP,
- FAR_JUMP,
- HALT,
- HALT_STATUS,
- GOSUB,
- RETURN,
- LOCAL_JUMP_INC,
- LOCAL_JUMP_DEC
-};
-
-/**
- * enum rta_jump_cond - How test conditions are evaluated by JUMP command
- * @ALL_TRUE: perform action if ALL selected conditions are true
- * @ALL_FALSE: perform action if ALL selected conditions are false
- * @ANY_TRUE: perform action if ANY of the selected conditions is true
- * @ANY_FALSE: perform action if ANY of the selected conditions is false
- */
-enum rta_jump_cond {
- ALL_TRUE,
- ALL_FALSE,
- ANY_TRUE,
- ANY_FALSE
-};
-
-/**
- * enum rta_share_type - Types of sharing for JOB_HDR and SHR_HDR commands
- * @SHR_NEVER: nothing is shared; descriptors can execute in parallel (i.e. no
- * dependencies are allowed between them).
- * @SHR_WAIT: shared descriptor and keys are shared once the descriptor sets
- * "OK to share" in DECO Control Register (DCTRL).
- * @SHR_SERIAL: shared descriptor and keys are shared once the descriptor has
- * completed.
- * @SHR_ALWAYS: shared descriptor is shared anytime after the descriptor is
- * loaded.
- * @SHR_DEFER: valid only for JOB_HDR; sharing type is the one specified
- * in the shared descriptor associated with the job descriptor.
- */
-enum rta_share_type {
- SHR_NEVER,
- SHR_WAIT,
- SHR_SERIAL,
- SHR_ALWAYS,
- SHR_DEFER
-};
-
-/**
- * enum rta_data_type - Indicates how is the data provided and how to include it
- * in the descriptor.
- * @RTA_DATA_PTR: Data is in memory and accessed by reference; data address is a
- * physical (bus) address.
- * @RTA_DATA_IMM: Data is inlined in descriptor and accessed as immediate data;
- * data address is a virtual address.
- * @RTA_DATA_IMM_DMA: (AIOP only) Data is inlined in descriptor and accessed as
- * immediate data; data address is a physical (bus) address
- * in external memory and CDMA is programmed to transfer the
- * data into descriptor buffer being built in Workspace Area.
- */
-enum rta_data_type {
- RTA_DATA_PTR = 1,
- RTA_DATA_IMM,
- RTA_DATA_IMM_DMA
-};
-
-/* Registers definitions */
-enum rta_regs {
- /* CCB Registers */
- CONTEXT1 = 1,
- CONTEXT2,
- KEY1,
- KEY2,
- KEY1SZ,
- KEY2SZ,
- ICV1SZ,
- ICV2SZ,
- DATA1SZ,
- DATA2SZ,
- ALTDS1,
- IV1SZ,
- AAD1SZ,
- MODE1,
- MODE2,
- CCTRL,
- DCTRL,
- ICTRL,
- CLRW,
- CSTAT,
- IFIFO,
- NFIFO,
- OFIFO,
- PKASZ,
- PKBSZ,
- PKNSZ,
- PKESZ,
- /* DECO Registers */
- MATH0,
- MATH1,
- MATH2,
- MATH3,
- DESCBUF,
- JOBDESCBUF,
- SHAREDESCBUF,
- DPOVRD,
- DJQDA,
- DSTAT,
- DPID,
- DJQCTRL,
- ALTSOURCE,
- SEQINSZ,
- SEQOUTSZ,
- VSEQINSZ,
- VSEQOUTSZ,
- /* PKHA Registers */
- PKA,
- PKN,
- PKA0,
- PKA1,
- PKA2,
- PKA3,
- PKB,
- PKB0,
- PKB1,
- PKB2,
- PKB3,
- PKE,
- /* Pseudo registers */
- AB1,
- AB2,
- ABD,
- IFIFOABD,
- IFIFOAB1,
- IFIFOAB2,
- AFHA_SBOX,
- MDHA_SPLIT_KEY,
- JOBSRC,
- ZERO,
- ONE,
- AAD1,
- IV1,
- IV2,
- MSG1,
- MSG2,
- MSG,
- MSG_CKSUM,
- MSGOUTSNOOP,
- MSGINSNOOP,
- ICV1,
- ICV2,
- SKIP,
- NONE,
- RNGOFIFO,
- RNG,
- IDFNS,
- ODFNS,
- NFIFOSZ,
- SZ,
- PAD,
- SAD1,
- AAD2,
- BIT_DATA,
- NFIFO_SZL,
- NFIFO_SZM,
- NFIFO_L,
- NFIFO_M,
- SZL,
- SZM,
- JOBDESCBUF_EFF,
- SHAREDESCBUF_EFF,
- METADATA,
- GTR,
- STR,
- OFIFO_SYNC,
- MSGOUTSNOOP_ALT
-};
-
-/* Command flags */
-#define FLUSH1 BIT(0)
-#define LAST1 BIT(1)
-#define LAST2 BIT(2)
-#define IMMED BIT(3)
-#define SGF BIT(4)
-#define VLF BIT(5)
-#define EXT BIT(6)
-#define CONT BIT(7)
-#define SEQ BIT(8)
-#define AIDF BIT(9)
-#define FLUSH2 BIT(10)
-#define CLASS1 BIT(11)
-#define CLASS2 BIT(12)
-#define BOTH BIT(13)
-
-/**
- * DCOPY - (AIOP only) command param is pointer to external memory
- *
- * CDMA must be used to transfer the key via DMA into Workspace Area.
- * Valid only in combination with IMMED flag.
- */
-#define DCOPY BIT(30)
-
-#define COPY BIT(31) /* command param is pointer (not immediate)
- * valid only in combination when IMMED
- */
-
-#define __COPY_MASK (COPY | DCOPY)
-
-/* SEQ IN/OUT PTR Command specific flags */
-#define RBS BIT(16)
-#define INL BIT(17)
-#define PRE BIT(18)
-#define RTO BIT(19)
-#define RJD BIT(20)
-#define SOP BIT(21)
-#define RST BIT(22)
-#define EWS BIT(23)
-
-#define ENC BIT(14) /* Encrypted Key */
-#define EKT BIT(15) /* AES CCM Encryption (default is
- * AES ECB Encryption)
- */
-#define TK BIT(16) /* Trusted Descriptor Key (default is
- * Job Descriptor Key)
- */
-#define NWB BIT(17) /* No Write Back Key */
-#define PTS BIT(18) /* Plaintext Store */
-
-/* HEADER Command specific flags */
-#define RIF BIT(16)
-#define DNR BIT(17)
-#define CIF BIT(18)
-#define PD BIT(19)
-#define RSMS BIT(20)
-#define TD BIT(21)
-#define MTD BIT(22)
-#define REO BIT(23)
-#define SHR BIT(24)
-#define SC BIT(25)
-/* Extended HEADER specific flags */
-#define DSV BIT(7)
-#define DSEL_MASK 0x00000007 /* DECO Select */
-#define FTD BIT(8)
-
-/* JUMP Command specific flags */
-#define NIFP BIT(20)
-#define NIP BIT(21)
-#define NOP BIT(22)
-#define NCP BIT(23)
-#define CALM BIT(24)
-
-#define MATH_Z BIT(25)
-#define MATH_N BIT(26)
-#define MATH_NV BIT(27)
-#define MATH_C BIT(28)
-#define PK_0 BIT(29)
-#define PK_GCD_1 BIT(30)
-#define PK_PRIME BIT(31)
-#define SELF BIT(0)
-#define SHRD BIT(1)
-#define JQP BIT(2)
-
-/* NFIFOADD specific flags */
-#define PAD_ZERO BIT(16)
-#define PAD_NONZERO BIT(17)
-#define PAD_INCREMENT BIT(18)
-#define PAD_RANDOM BIT(19)
-#define PAD_ZERO_N1 BIT(20)
-#define PAD_NONZERO_0 BIT(21)
-#define PAD_N1 BIT(23)
-#define PAD_NONZERO_N BIT(24)
-#define OC BIT(25)
-#define BM BIT(26)
-#define PR BIT(27)
-#define PS BIT(28)
-#define BP BIT(29)
-
-/* MOVE Command specific flags */
-#define WAITCOMP BIT(16)
-#define SIZE_WORD BIT(17)
-#define SIZE_BYTE BIT(18)
-#define SIZE_DWORD BIT(19)
-
-/* MATH command specific flags */
-#define IFB MATH_IFB
-#define NFU MATH_NFU
-#define STL MATH_STL
-#define SSEL MATH_SSEL
-#define SWP MATH_SWP
-#define IMMED2 BIT(31)
-
-/**
- * struct program - descriptor buffer management structure
- * @current_pc: current offset in descriptor
- * @current_instruction: current instruction in descriptor
- * @first_error_pc: offset of the first error in descriptor
- * @start_pc: start offset in descriptor buffer
- * @buffer: buffer carrying descriptor
- * @shrhdr: shared descriptor header
- * @jobhdr: job descriptor header
- * @ps: pointer fields size; if ps is true, pointers will be 36bits in
- * length; if ps is false, pointers will be 32bits in length
- * @bswap: if true, perform byte swap on a 4-byte boundary
- */
-struct program {
- unsigned int current_pc;
- unsigned int current_instruction;
- unsigned int first_error_pc;
- unsigned int start_pc;
- uint32_t *buffer;
- uint32_t *shrhdr;
- uint32_t *jobhdr;
- bool ps;
- bool bswap;
-};
-
-static inline void
-rta_program_cntxt_init(struct program *program,
- uint32_t *buffer, unsigned int offset)
-{
- program->current_pc = 0;
- program->current_instruction = 0;
- program->first_error_pc = 0;
- program->start_pc = offset;
- program->buffer = buffer;
- program->shrhdr = NULL;
- program->jobhdr = NULL;
- program->ps = false;
- program->bswap = false;
-}
-
-static inline int
-rta_program_finalize(struct program *program)
-{
- /* Descriptor is usually not allowed to go beyond 64 words size */
- if (program->current_pc > MAX_CAAM_DESCSIZE)
- pr_warn("Descriptor Size exceeded max limit of 64 words\n");
-
- /* Descriptor is erroneous */
- if (program->first_error_pc) {
- pr_err("Descriptor creation error\n");
- return -EINVAL;
- }
-
- /* Update descriptor length in shared and job descriptor headers */
- if (program->shrhdr != NULL)
- *program->shrhdr |= program->bswap ?
- swab32(program->current_pc) :
- program->current_pc;
- else if (program->jobhdr != NULL)
- *program->jobhdr |= program->bswap ?
- swab32(program->current_pc) :
- program->current_pc;
-
- return (int)program->current_pc;
-}
-
-static inline unsigned int
-rta_program_set_36bit_addr(struct program *program)
-{
- program->ps = true;
- return program->current_pc;
-}
-
-static inline unsigned int
-rta_program_set_bswap(struct program *program)
-{
- program->bswap = true;
- return program->current_pc;
-}
-
-static inline void
-__rta_out32(struct program *program, uint32_t val)
-{
- program->buffer[program->current_pc] = program->bswap ?
- swab32(val) : val;
- program->current_pc++;
-}
-
-static inline void
-__rta_out_be32(struct program *program, uint32_t val)
-{
- program->buffer[program->current_pc] = cpu_to_be32(val);
- program->current_pc++;
-}
-
-static inline void
-__rta_out_le32(struct program *program, uint32_t val)
-{
- program->buffer[program->current_pc] = cpu_to_le32(val);
- program->current_pc++;
-}
-
-static inline void
-__rta_out64(struct program *program, bool is_ext, uint64_t val)
-{
- if (is_ext) {
- /*
- * Since we are guaranteed only a 4-byte alignment in the
- * descriptor buffer, we have to do 2 x 32-bit (word) writes.
- * For the order of the 2 words to be correct, we need to
- * take into account the endianness of the CPU.
- */
-#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
- __rta_out32(program, program->bswap ? lower_32_bits(val) :
- upper_32_bits(val));
-
- __rta_out32(program, program->bswap ? upper_32_bits(val) :
- lower_32_bits(val));
-#else
- __rta_out32(program, program->bswap ? upper_32_bits(val) :
- lower_32_bits(val));
-
- __rta_out32(program, program->bswap ? lower_32_bits(val) :
- upper_32_bits(val));
-#endif
- } else {
- __rta_out32(program, lower_32_bits(val));
- }
-}
-
-static inline void __rta_out_be64(struct program *program, bool is_ext,
- uint64_t val)
-{
- if (is_ext) {
- __rta_out_be32(program, upper_32_bits(val));
- __rta_out_be32(program, lower_32_bits(val));
- } else {
- __rta_out_be32(program, lower_32_bits(val));
- }
-}
-
-static inline void __rta_out_le64(struct program *program, bool is_ext,
- uint64_t val)
-{
- if (is_ext) {
- __rta_out_le32(program, lower_32_bits(val));
- __rta_out_le32(program, upper_32_bits(val));
- } else {
- __rta_out_le32(program, lower_32_bits(val));
- }
-}
-
-static inline unsigned int
-rta_word(struct program *program, uint32_t val)
-{
- unsigned int start_pc = program->current_pc;
-
- __rta_out32(program, val);
-
- return start_pc;
-}
-
-static inline unsigned int
-rta_dword(struct program *program, uint64_t val)
-{
- unsigned int start_pc = program->current_pc;
-
- __rta_out64(program, true, val);
-
- return start_pc;
-}
-
-static inline uint32_t
-inline_flags(enum rta_data_type data_type)
-{
- switch (data_type) {
- case RTA_DATA_PTR:
- return 0;
- case RTA_DATA_IMM:
- return IMMED | COPY;
- case RTA_DATA_IMM_DMA:
- return IMMED | DCOPY;
- default:
- /* warn and default to RTA_DATA_PTR */
- pr_warn("RTA: defaulting to RTA_DATA_PTR parameter type\n");
- return 0;
- }
-}
-
-static inline unsigned int
-rta_copy_data(struct program *program, uint8_t *data, unsigned int length)
-{
- unsigned int i;
- unsigned int start_pc = program->current_pc;
- uint8_t *tmp = (uint8_t *)&program->buffer[program->current_pc];
-
- for (i = 0; i < length; i++)
- *tmp++ = data[i];
- program->current_pc += (length + 3) / 4;
-
- return start_pc;
-}
-
-#if defined(__EWL__) && defined(AIOP)
-static inline void
-__rta_dma_data(void *ws_dst, uint64_t ext_address, uint16_t size)
-{ cdma_read(ws_dst, ext_address, size); }
-#else
-static inline void
-__rta_dma_data(void *ws_dst __maybe_unused,
- uint64_t ext_address __maybe_unused,
- uint16_t size __maybe_unused)
-{ pr_warn("RTA: DCOPY not supported, DMA will be skipped\n"); }
-#endif /* defined(__EWL__) && defined(AIOP) */
-
-static inline void
-__rta_inline_data(struct program *program, uint64_t data,
- uint32_t copy_data, uint32_t length)
-{
- if (!copy_data) {
- __rta_out64(program, length > 4, data);
- } else if (copy_data & COPY) {
- uint8_t *tmp = (uint8_t *)&program->buffer[program->current_pc];
- uint32_t i;
-
- for (i = 0; i < length; i++)
- *tmp++ = ((uint8_t *)(uintptr_t)data)[i];
- program->current_pc += ((length + 3) / 4);
- } else if (copy_data & DCOPY) {
- __rta_dma_data(&program->buffer[program->current_pc], data,
- (uint16_t)length);
- program->current_pc += ((length + 3) / 4);
- }
-}
-
-static inline unsigned int
-rta_desc_len(uint32_t *buffer)
-{
- if ((*buffer & CMD_MASK) == CMD_DESC_HDR) {
- return *buffer & HDR_DESCLEN_MASK;
- } else {
- if (rta_sec_era >= RTA_SEC_ERA_10)
- return *buffer & HDR_DESCLEN_SHR_MASK_ERA10;
- else
- return *buffer & HDR_DESCLEN_SHR_MASK;
- }
-}
-
-static inline unsigned int
-rta_desc_bytes(uint32_t *buffer)
-{
- return (unsigned int)(rta_desc_len(buffer) * CAAM_CMD_SZ);
-}
-
-/**
- * split_key_len - Compute MDHA split key length for a given algorithm
- * @hash: Hashing algorithm selection, one of OP_ALG_ALGSEL_* or
- * OP_PCLID_DKP_* - MD5, SHA1, SHA224, SHA256, SHA384, SHA512.
- *
- * Return: MDHA split key length
- */
-static inline uint32_t
-split_key_len(uint32_t hash)
-{
- /* Sizes for MDHA pads (*not* keys): MD5, SHA1, 224, 256, 384, 512 */
- static const uint8_t mdpadlen[] = { 16, 20, 32, 32, 64, 64 };
- uint32_t idx;
-
- idx = (hash & OP_ALG_ALGSEL_SUBMASK) >> OP_ALG_ALGSEL_SHIFT;
-
- return (uint32_t)(mdpadlen[idx] * 2);
-}
-
-/**
- * split_key_pad_len - Compute MDHA split key pad length for a given algorithm
- * @hash: Hashing algorithm selection, one of OP_ALG_ALGSEL_* - MD5, SHA1,
- * SHA224, SHA384, SHA512.
- *
- * Return: MDHA split key pad length
- */
-static inline uint32_t
-split_key_pad_len(uint32_t hash)
-{
- return ALIGN(split_key_len(hash), 16);
-}
-
-static inline unsigned int
-rta_set_label(struct program *program)
-{
- return program->current_pc + program->start_pc;
-}
-
-static inline int
-rta_patch_move(struct program *program, int line, unsigned int new_ref)
-{
- uint32_t opcode;
- bool bswap = program->bswap;
-
- if (line < 0)
- return -EINVAL;
-
- opcode = bswap ? swab32(program->buffer[line]) : program->buffer[line];
-
- opcode &= (uint32_t)~MOVE_OFFSET_MASK;
- opcode |= (new_ref << (MOVE_OFFSET_SHIFT + 2)) & MOVE_OFFSET_MASK;
- program->buffer[line] = bswap ? swab32(opcode) : opcode;
-
- return 0;
-}
-
-static inline int
-rta_patch_jmp(struct program *program, int line, unsigned int new_ref)
-{
- uint32_t opcode;
- bool bswap = program->bswap;
-
- if (line < 0)
- return -EINVAL;
-
- opcode = bswap ? swab32(program->buffer[line]) : program->buffer[line];
-
- opcode &= (uint32_t)~JUMP_OFFSET_MASK;
- opcode |= (new_ref - (line + program->start_pc)) & JUMP_OFFSET_MASK;
- program->buffer[line] = bswap ? swab32(opcode) : opcode;
-
- return 0;
-}
-
-static inline int
-rta_patch_header(struct program *program, int line, unsigned int new_ref)
-{
- uint32_t opcode;
- bool bswap = program->bswap;
-
- if (line < 0)
- return -EINVAL;
-
- opcode = bswap ? swab32(program->buffer[line]) : program->buffer[line];
- if (rta_sec_era >= RTA_SEC_ERA_10) {
- opcode &= (uint32_t)~HDR_START_IDX_MASK_ERA10;
- opcode |= (new_ref << HDR_START_IDX_SHIFT) &
- HDR_START_IDX_MASK_ERA10;
- } else {
- opcode &= (uint32_t)~HDR_START_IDX_MASK;
- opcode |= (new_ref << HDR_START_IDX_SHIFT) & HDR_START_IDX_MASK;
- }
-
- program->buffer[line] = bswap ? swab32(opcode) : opcode;
-
- return 0;
-}
-
-static inline int
-rta_patch_load(struct program *program, int line, unsigned int new_ref)
-{
- uint32_t opcode;
- bool bswap = program->bswap;
-
- if (line < 0)
- return -EINVAL;
-
- opcode = (bswap ? swab32(program->buffer[line]) :
- program->buffer[line]) & (uint32_t)~LDST_OFFSET_MASK;
-
- if (opcode & (LDST_SRCDST_WORD_DESCBUF | LDST_CLASS_DECO))
- opcode |= (new_ref << LDST_OFFSET_SHIFT) & LDST_OFFSET_MASK;
- else
- opcode |= (new_ref << (LDST_OFFSET_SHIFT + 2)) &
- LDST_OFFSET_MASK;
-
- program->buffer[line] = bswap ? swab32(opcode) : opcode;
-
- return 0;
-}
-
-static inline int
-rta_patch_store(struct program *program, int line, unsigned int new_ref)
-{
- uint32_t opcode;
- bool bswap = program->bswap;
-
- if (line < 0)
- return -EINVAL;
-
- opcode = bswap ? swab32(program->buffer[line]) : program->buffer[line];
-
- opcode &= (uint32_t)~LDST_OFFSET_MASK;
-
- switch (opcode & LDST_SRCDST_MASK) {
- case LDST_SRCDST_WORD_DESCBUF:
- case LDST_SRCDST_WORD_DESCBUF_JOB:
- case LDST_SRCDST_WORD_DESCBUF_SHARED:
- case LDST_SRCDST_WORD_DESCBUF_JOB_WE:
- case LDST_SRCDST_WORD_DESCBUF_SHARED_WE:
- opcode |= ((new_ref) << LDST_OFFSET_SHIFT) & LDST_OFFSET_MASK;
- break;
- default:
- opcode |= (new_ref << (LDST_OFFSET_SHIFT + 2)) &
- LDST_OFFSET_MASK;
- }
-
- program->buffer[line] = bswap ? swab32(opcode) : opcode;
-
- return 0;
-}
-
-static inline int
-rta_patch_raw(struct program *program, int line, unsigned int mask,
- unsigned int new_val)
-{
- uint32_t opcode;
- bool bswap = program->bswap;
-
- if (line < 0)
- return -EINVAL;
-
- opcode = bswap ? swab32(program->buffer[line]) : program->buffer[line];
-
- opcode &= (uint32_t)~mask;
- opcode |= new_val & mask;
- program->buffer[line] = bswap ? swab32(opcode) : opcode;
-
- return 0;
-}
-
-static inline int
-__rta_map_opcode(uint32_t name, const uint32_t (*map_table)[2],
- unsigned int num_of_entries, uint32_t *val)
-{
- unsigned int i;
-
- for (i = 0; i < num_of_entries; i++)
- if (map_table[i][0] == name) {
- *val = map_table[i][1];
- return 0;
- }
-
- return -EINVAL;
-}
-
-static inline void
-__rta_map_flags(uint32_t flags, const uint32_t (*flags_table)[2],
- unsigned int num_of_entries, uint32_t *opcode)
-{
- unsigned int i;
-
- for (i = 0; i < num_of_entries; i++) {
- if (flags_table[i][0] & flags)
- *opcode |= flags_table[i][1];
- }
-}
-
-#endif /* __RTA_SEC_RUN_TIME_ASM_H__ */
+++ /dev/null
-/* SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0)
- *
- * Copyright 2008-2016 Freescale Semiconductor Inc.
- * Copyright 2016,2019 NXP
- */
-
-#ifndef __RTA_SEQ_IN_OUT_PTR_CMD_H__
-#define __RTA_SEQ_IN_OUT_PTR_CMD_H__
-
-extern enum rta_sec_era rta_sec_era;
-
-/* Allowed SEQ IN PTR flags for each SEC Era. */
-static const uint32_t seq_in_ptr_flags[] = {
- RBS | INL | SGF | PRE | EXT | RTO,
- RBS | INL | SGF | PRE | EXT | RTO | RJD,
- RBS | INL | SGF | PRE | EXT | RTO | RJD,
- RBS | INL | SGF | PRE | EXT | RTO | RJD,
- RBS | INL | SGF | PRE | EXT | RTO | RJD | SOP,
- RBS | INL | SGF | PRE | EXT | RTO | RJD | SOP,
- RBS | INL | SGF | PRE | EXT | RTO | RJD | SOP,
- RBS | INL | SGF | PRE | EXT | RTO | RJD | SOP,
- RBS | INL | SGF | PRE | EXT | RTO | RJD | SOP,
- RBS | INL | SGF | PRE | EXT | RTO | RJD | SOP
-};
-
-/* Allowed SEQ OUT PTR flags for each SEC Era. */
-static const uint32_t seq_out_ptr_flags[] = {
- SGF | PRE | EXT,
- SGF | PRE | EXT | RTO,
- SGF | PRE | EXT | RTO,
- SGF | PRE | EXT | RTO,
- SGF | PRE | EXT | RTO | RST | EWS,
- SGF | PRE | EXT | RTO | RST | EWS,
- SGF | PRE | EXT | RTO | RST | EWS,
- SGF | PRE | EXT | RTO | RST | EWS,
- SGF | PRE | EXT | RTO | RST | EWS,
- SGF | PRE | EXT | RTO | RST | EWS
-};
-
-static inline int
-rta_seq_in_ptr(struct program *program, uint64_t src,
- uint32_t length, uint32_t flags)
-{
- uint32_t opcode = CMD_SEQ_IN_PTR;
- unsigned int start_pc = program->current_pc;
- int ret = -EINVAL;
-
- /* Parameters checking */
- if ((flags & RTO) && (flags & PRE)) {
- pr_err("SEQ IN PTR: Invalid usage of RTO and PRE flags\n");
- goto err;
- }
- if (flags & ~seq_in_ptr_flags[rta_sec_era]) {
- pr_err("SEQ IN PTR: Flag(s) not supported by SEC Era %d\n",
- USER_SEC_ERA(rta_sec_era));
- goto err;
- }
- if ((flags & INL) && (flags & RJD)) {
- pr_err("SEQ IN PTR: Invalid usage of INL and RJD flags\n");
- goto err;
- }
- if ((src) && (flags & (SOP | RTO | PRE))) {
- pr_err("SEQ IN PTR: Invalid usage of RTO or PRE flag\n");
- goto err;
- }
- if ((flags & SOP) && (flags & (RBS | PRE | RTO | EXT))) {
- pr_err("SEQ IN PTR: Invalid usage of SOP and (RBS or PRE or RTO or EXT) flags\n");
- goto err;
- }
-
- /* write flag fields */
- if (flags & RBS)
- opcode |= SQIN_RBS;
- if (flags & INL)
- opcode |= SQIN_INL;
- if (flags & SGF)
- opcode |= SQIN_SGF;
- if (flags & PRE)
- opcode |= SQIN_PRE;
- if (flags & RTO)
- opcode |= SQIN_RTO;
- if (flags & RJD)
- opcode |= SQIN_RJD;
- if (flags & SOP)
- opcode |= SQIN_SOP;
- if ((length >> 16) || (flags & EXT)) {
- if (flags & SOP) {
- pr_err("SEQ IN PTR: Invalid usage of SOP and EXT flags\n");
- goto err;
- }
-
- opcode |= SQIN_EXT;
- } else {
- opcode |= length & SQIN_LEN_MASK;
- }
-
- __rta_out32(program, opcode);
- program->current_instruction++;
-
- /* write pointer or immediate data field */
- if (!(opcode & (SQIN_PRE | SQIN_RTO | SQIN_SOP)))
- __rta_out64(program, program->ps, src);
-
- /* write extended length field */
- if (opcode & SQIN_EXT)
- __rta_out32(program, length);
-
- return (int)start_pc;
-
- err:
- program->first_error_pc = start_pc;
- program->current_instruction++;
- return ret;
-}
-
-static inline int
-rta_seq_out_ptr(struct program *program, uint64_t dst,
- uint32_t length, uint32_t flags)
-{
- uint32_t opcode = CMD_SEQ_OUT_PTR;
- unsigned int start_pc = program->current_pc;
- int ret = -EINVAL;
-
- /* Parameters checking */
- if (flags & ~seq_out_ptr_flags[rta_sec_era]) {
- pr_err("SEQ OUT PTR: Flag(s) not supported by SEC Era %d\n",
- USER_SEC_ERA(rta_sec_era));
- goto err;
- }
- if ((flags & RTO) && (flags & PRE)) {
- pr_err("SEQ OUT PTR: Invalid usage of RTO and PRE flags\n");
- goto err;
- }
- if ((dst) && (flags & (RTO | PRE))) {
- pr_err("SEQ OUT PTR: Invalid usage of RTO or PRE flag\n");
- goto err;
- }
- if ((flags & RST) && !(flags & RTO)) {
- pr_err("SEQ OUT PTR: RST flag must be used with RTO flag\n");
- goto err;
- }
-
- /* write flag fields */
- if (flags & SGF)
- opcode |= SQOUT_SGF;
- if (flags & PRE)
- opcode |= SQOUT_PRE;
- if (flags & RTO)
- opcode |= SQOUT_RTO;
- if (flags & RST)
- opcode |= SQOUT_RST;
- if (flags & EWS)
- opcode |= SQOUT_EWS;
- if ((length >> 16) || (flags & EXT))
- opcode |= SQOUT_EXT;
- else
- opcode |= length & SQOUT_LEN_MASK;
-
- __rta_out32(program, opcode);
- program->current_instruction++;
-
- /* write pointer or immediate data field */
- if (!(opcode & (SQOUT_PRE | SQOUT_RTO)))
- __rta_out64(program, program->ps, dst);
-
- /* write extended length field */
- if (opcode & SQOUT_EXT)
- __rta_out32(program, length);
-
- return (int)start_pc;
-
- err:
- program->first_error_pc = start_pc;
- program->current_instruction++;
- return ret;
-}
-
-#endif /* __RTA_SEQ_IN_OUT_PTR_CMD_H__ */
+++ /dev/null
-/* SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0)
- *
- * Copyright 2008-2016 Freescale Semiconductor Inc.
- * Copyright 2016 NXP
- *
- */
-
-#ifndef __RTA_SIGNATURE_CMD_H__
-#define __RTA_SIGNATURE_CMD_H__
-
-static inline int
-rta_signature(struct program *program, uint32_t sign_type)
-{
- uint32_t opcode = CMD_SIGNATURE;
- unsigned int start_pc = program->current_pc;
-
- switch (sign_type) {
- case (SIGN_TYPE_FINAL):
- case (SIGN_TYPE_FINAL_RESTORE):
- case (SIGN_TYPE_FINAL_NONZERO):
- case (SIGN_TYPE_IMM_2):
- case (SIGN_TYPE_IMM_3):
- case (SIGN_TYPE_IMM_4):
- opcode |= sign_type;
- break;
- default:
- pr_err("SIGNATURE Command: Invalid type selection\n");
- goto err;
- }
-
- __rta_out32(program, opcode);
- program->current_instruction++;
-
- return (int)start_pc;
-
- err:
- program->first_error_pc = start_pc;
- program->current_instruction++;
- return -EINVAL;
-}
-
-#endif /* __RTA_SIGNATURE_CMD_H__ */
+++ /dev/null
-/* SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0)
- *
- * Copyright 2008-2016 Freescale Semiconductor Inc.
- * Copyright 2016,2019 NXP
- */
-
-#ifndef __RTA_STORE_CMD_H__
-#define __RTA_STORE_CMD_H__
-
-extern enum rta_sec_era rta_sec_era;
-
-static const uint32_t store_src_table[][2] = {
-/*1*/ { KEY1SZ, LDST_CLASS_1_CCB | LDST_SRCDST_WORD_KEYSZ_REG },
- { KEY2SZ, LDST_CLASS_2_CCB | LDST_SRCDST_WORD_KEYSZ_REG },
- { DJQDA, LDST_CLASS_DECO | LDST_SRCDST_WORD_DECO_JQDAR },
- { MODE1, LDST_CLASS_1_CCB | LDST_SRCDST_WORD_MODE_REG },
- { MODE2, LDST_CLASS_2_CCB | LDST_SRCDST_WORD_MODE_REG },
- { DJQCTRL, LDST_CLASS_DECO | LDST_SRCDST_WORD_DECO_JQCTRL },
- { DATA1SZ, LDST_CLASS_1_CCB | LDST_SRCDST_WORD_DATASZ_REG },
- { DATA2SZ, LDST_CLASS_2_CCB | LDST_SRCDST_WORD_DATASZ_REG },
- { DSTAT, LDST_CLASS_DECO | LDST_SRCDST_WORD_DECO_STAT },
- { ICV1SZ, LDST_CLASS_1_CCB | LDST_SRCDST_WORD_ICVSZ_REG },
- { ICV2SZ, LDST_CLASS_2_CCB | LDST_SRCDST_WORD_ICVSZ_REG },
- { DPID, LDST_CLASS_DECO | LDST_SRCDST_WORD_PID },
- { CCTRL, LDST_SRCDST_WORD_CHACTRL },
- { ICTRL, LDST_SRCDST_WORD_IRQCTRL },
- { CLRW, LDST_SRCDST_WORD_CLRW },
- { MATH0, LDST_CLASS_DECO | LDST_SRCDST_WORD_DECO_MATH0 },
- { CSTAT, LDST_SRCDST_WORD_STAT },
- { MATH1, LDST_CLASS_DECO | LDST_SRCDST_WORD_DECO_MATH1 },
- { MATH2, LDST_CLASS_DECO | LDST_SRCDST_WORD_DECO_MATH2 },
- { AAD1SZ, LDST_CLASS_1_CCB | LDST_SRCDST_WORD_DECO_AAD_SZ },
- { MATH3, LDST_CLASS_DECO | LDST_SRCDST_WORD_DECO_MATH3 },
- { IV1SZ, LDST_CLASS_1_CCB | LDST_SRCDST_WORD_CLASS1_IV_SZ },
- { PKASZ, LDST_CLASS_1_CCB | LDST_SRCDST_WORD_PKHA_A_SZ },
- { PKBSZ, LDST_CLASS_1_CCB | LDST_SRCDST_WORD_PKHA_B_SZ },
- { PKESZ, LDST_CLASS_1_CCB | LDST_SRCDST_WORD_PKHA_E_SZ },
- { PKNSZ, LDST_CLASS_1_CCB | LDST_SRCDST_WORD_PKHA_N_SZ },
- { CONTEXT1, LDST_CLASS_1_CCB | LDST_SRCDST_BYTE_CONTEXT },
- { CONTEXT2, LDST_CLASS_2_CCB | LDST_SRCDST_BYTE_CONTEXT },
- { DESCBUF, LDST_CLASS_DECO | LDST_SRCDST_WORD_DESCBUF },
-/*30*/ { JOBDESCBUF, LDST_CLASS_DECO | LDST_SRCDST_WORD_DESCBUF_JOB },
- { SHAREDESCBUF, LDST_CLASS_DECO | LDST_SRCDST_WORD_DESCBUF_SHARED },
-/*32*/ { JOBDESCBUF_EFF, LDST_CLASS_DECO |
- LDST_SRCDST_WORD_DESCBUF_JOB_WE },
- { SHAREDESCBUF_EFF, LDST_CLASS_DECO |
- LDST_SRCDST_WORD_DESCBUF_SHARED_WE },
-/*34*/ { GTR, LDST_CLASS_DECO | LDST_SRCDST_WORD_GTR },
- { STR, LDST_CLASS_DECO | LDST_SRCDST_WORD_STR }
-};
-
-/*
- * Allowed STORE sources for each SEC ERA.
- * Values represent the number of entries from source_src_table[] that are
- * supported.
- */
-static const unsigned int store_src_table_sz[] = {29, 31, 33, 33,
- 33, 33, 35, 35,
- 35, 35};
-
-static inline int
-rta_store(struct program *program, uint64_t src,
- uint16_t offset, uint64_t dst, uint32_t length,
- uint32_t flags)
-{
- uint32_t opcode = 0, val;
- int ret = -EINVAL;
- unsigned int start_pc = program->current_pc;
-
- if (flags & SEQ)
- opcode = CMD_SEQ_STORE;
- else
- opcode = CMD_STORE;
-
- /* parameters check */
- if ((flags & IMMED) && (flags & SGF)) {
- pr_err("STORE: Invalid flag. SEC PC: %d; Instr: %d\n",
- program->current_pc, program->current_instruction);
- goto err;
- }
- if ((flags & IMMED) && (offset != 0)) {
- pr_err("STORE: Invalid flag. SEC PC: %d; Instr: %d\n",
- program->current_pc, program->current_instruction);
- goto err;
- }
-
- if ((flags & SEQ) && ((src == JOBDESCBUF) || (src == SHAREDESCBUF) ||
- (src == JOBDESCBUF_EFF) ||
- (src == SHAREDESCBUF_EFF))) {
- pr_err("STORE: Invalid SRC type. SEC PC: %d; Instr: %d\n",
- program->current_pc, program->current_instruction);
- goto err;
- }
-
- if (flags & IMMED)
- opcode |= LDST_IMM;
-
- if ((flags & SGF) || (flags & VLF))
- opcode |= LDST_VLF;
-
- /*
- * source for data to be stored can be specified as:
- * - register location; set in src field[9-15];
- * - if IMMED flag is set, data is set in value field [0-31];
- * user can give this value as actual value or pointer to data
- */
- if (!(flags & IMMED)) {
- ret = __rta_map_opcode((uint32_t)src, store_src_table,
- store_src_table_sz[rta_sec_era], &val);
- if (ret < 0) {
- pr_err("STORE: Invalid source. SEC PC: %d; Instr: %d\n",
- program->current_pc,
- program->current_instruction);
- goto err;
- }
- opcode |= val;
- }
-
- /* DESC BUFFER: length / offset values are specified in 4-byte words */
- if ((src == DESCBUF) || (src == JOBDESCBUF) || (src == SHAREDESCBUF) ||
- (src == JOBDESCBUF_EFF) || (src == SHAREDESCBUF_EFF)) {
- opcode |= (length >> 2);
- opcode |= (uint32_t)((offset >> 2) << LDST_OFFSET_SHIFT);
- } else {
- opcode |= length;
- opcode |= (uint32_t)(offset << LDST_OFFSET_SHIFT);
- }
-
- __rta_out32(program, opcode);
- program->current_instruction++;
-
- if ((src == JOBDESCBUF) || (src == SHAREDESCBUF) ||
- (src == JOBDESCBUF_EFF) || (src == SHAREDESCBUF_EFF))
- return (int)start_pc;
-
- /* for STORE, a pointer to where the data will be stored if needed */
- if (!(flags & SEQ))
- __rta_out64(program, program->ps, dst);
-
- /* for IMMED data, place the data here */
- if (flags & IMMED)
- __rta_inline_data(program, src, flags & __COPY_MASK, length);
-
- return (int)start_pc;
-
- err:
- program->first_error_pc = start_pc;
- program->current_instruction++;
- return ret;
-}
-
-#endif /* __RTA_STORE_CMD_H__ */
allow_experimental_apis = true
-includes += include_directories('mc', 'hw')
+includes += include_directories('mc', '../../common/dpaax/caamflib')
CFLAGS += -I$(RTE_SDK)/drivers/bus/dpaa/include
CFLAGS += -I$(RTE_SDK)/drivers/bus/dpaa/base/qbman
CFLAGS += -I$(RTE_SDK)/drivers/crypto/dpaa_sec/
-#sharing the hw flib headers from dpaa2_sec pmd
-CFLAGS += -I$(RTE_SDK)/drivers/crypto/dpaa2_sec/
+CFLAGS += -I$(RTE_SDK)/drivers/common/dpaax/caamflib/
CFLAGS += -I$(RTE_SDK)/lib/librte_eal/common/include
LDLIBS += -lrte_eal -lrte_mbuf -lrte_mempool -lrte_ring
LDLIBS += -lrte_cryptodev
#include <of.h>
/* RTA header files */
-#include <hw/desc/common.h>
-#include <hw/desc/algo.h>
-#include <hw/desc/ipsec.h>
-#include <hw/desc/pdcp.h>
+#include <desc/common.h>
+#include <desc/algo.h>
+#include <desc/ipsec.h>
+#include <desc/pdcp.h>
#include <rte_dpaa_bus.h>
#include <dpaa_sec.h>
allow_experimental_apis = true
-includes += include_directories('../dpaa2_sec/')
+includes += include_directories('../../bus/dpaa/include')
+includes += include_directories('../../common/dpaax/caamflib/')
git.droids-corp.org / dpdk.git / commitdiff