From: Hemant Agrawal Date: Tue, 13 Aug 2019 07:20:16 +0000 (+0530) Subject: common/dpaax: move shared sec HW code from dpaa2_sec X-Git-Url: http://git.droids-corp.org/?a=commitdiff_plain;h=c0ded849131598760a25e96ff368d035838af0b3;p=dpdk.git common/dpaax: move shared sec HW code from dpaa2_sec The SEC HW code is being shared by multiple NXP based drivers. It is better to place it at a common place. Current users are: 1. DPAA2_SEC 2. DPAA_SEC 3. CAAM_JR Signed-off-by: Hemant Agrawal Acked-by: Akhil Goyal --- diff --git a/drivers/common/dpaax/caamflib/compat.h b/drivers/common/dpaax/caamflib/compat.h new file mode 100644 index 0000000000..ce946ccb5c --- /dev/null +++ b/drivers/common/dpaax/caamflib/compat.h @@ -0,0 +1,126 @@ +/* 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 +#include + +#ifdef __GLIBC__ +#include +#include +#include +#include + +#include +#include + +#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__ */ diff --git a/drivers/common/dpaax/caamflib/desc.h b/drivers/common/dpaax/caamflib/desc.h new file mode 100644 index 0000000000..e4139aaa9f --- /dev/null +++ b/drivers/common/dpaax/caamflib/desc.h @@ -0,0 +1,2110 @@ +/* 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__ */ diff --git a/drivers/common/dpaax/caamflib/desc/algo.h b/drivers/common/dpaax/caamflib/desc/algo.h new file mode 100644 index 0000000000..83dbb80ce4 --- /dev/null +++ b/drivers/common/dpaax/caamflib/desc/algo.h @@ -0,0 +1,787 @@ +/* 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__ */ diff --git a/drivers/common/dpaax/caamflib/desc/common.h b/drivers/common/dpaax/caamflib/desc/common.h new file mode 100644 index 0000000000..816baacfdb --- /dev/null +++ b/drivers/common/dpaax/caamflib/desc/common.h @@ -0,0 +1,98 @@ +/* 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__ */ diff --git a/drivers/common/dpaax/caamflib/desc/ipsec.h b/drivers/common/dpaax/caamflib/desc/ipsec.h new file mode 100644 index 0000000000..f33c68cc9d --- /dev/null +++ b/drivers/common/dpaax/caamflib/desc/ipsec.h @@ -0,0 +1,1615 @@ +/* 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__ */ diff --git a/drivers/common/dpaax/caamflib/desc/pdcp.h b/drivers/common/dpaax/caamflib/desc/pdcp.h new file mode 100644 index 0000000000..b5e2d24e47 --- /dev/null +++ b/drivers/common/dpaax/caamflib/desc/pdcp.h @@ -0,0 +1,3753 @@ +/* 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<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__ */ diff --git a/drivers/common/dpaax/caamflib/rta.h b/drivers/common/dpaax/caamflib/rta.h new file mode 100644 index 0000000000..c4bbad0b41 --- /dev/null +++ b/drivers/common/dpaax/caamflib/rta.h @@ -0,0 +1,921 @@ +/* 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: 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__ */ diff --git a/drivers/common/dpaax/caamflib/rta/fifo_load_store_cmd.h b/drivers/common/dpaax/caamflib/rta/fifo_load_store_cmd.h new file mode 100644 index 0000000000..287e09cd75 --- /dev/null +++ b/drivers/common/dpaax/caamflib/rta/fifo_load_store_cmd.h @@ -0,0 +1,314 @@ +/* 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__ */ diff --git a/drivers/common/dpaax/caamflib/rta/header_cmd.h b/drivers/common/dpaax/caamflib/rta/header_cmd.h new file mode 100644 index 0000000000..45aefa04c1 --- /dev/null +++ b/drivers/common/dpaax/caamflib/rta/header_cmd.h @@ -0,0 +1,231 @@ +/* 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__ */ diff --git a/drivers/common/dpaax/caamflib/rta/jump_cmd.h b/drivers/common/dpaax/caamflib/rta/jump_cmd.h new file mode 100644 index 0000000000..18f781e373 --- /dev/null +++ b/drivers/common/dpaax/caamflib/rta/jump_cmd.h @@ -0,0 +1,173 @@ +/* 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__ */ diff --git a/drivers/common/dpaax/caamflib/rta/key_cmd.h b/drivers/common/dpaax/caamflib/rta/key_cmd.h new file mode 100644 index 0000000000..ec3fbcaf61 --- /dev/null +++ b/drivers/common/dpaax/caamflib/rta/key_cmd.h @@ -0,0 +1,190 @@ +/* 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__ */ diff --git a/drivers/common/dpaax/caamflib/rta/load_cmd.h b/drivers/common/dpaax/caamflib/rta/load_cmd.h new file mode 100644 index 0000000000..38e253c220 --- /dev/null +++ b/drivers/common/dpaax/caamflib/rta/load_cmd.h @@ -0,0 +1,306 @@ +/* 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__*/ diff --git a/drivers/common/dpaax/caamflib/rta/math_cmd.h b/drivers/common/dpaax/caamflib/rta/math_cmd.h new file mode 100644 index 0000000000..cca70f7e04 --- /dev/null +++ b/drivers/common/dpaax/caamflib/rta/math_cmd.h @@ -0,0 +1,371 @@ +/* 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__ */ diff --git a/drivers/common/dpaax/caamflib/rta/move_cmd.h b/drivers/common/dpaax/caamflib/rta/move_cmd.h new file mode 100644 index 0000000000..d2151c6dd7 --- /dev/null +++ b/drivers/common/dpaax/caamflib/rta/move_cmd.h @@ -0,0 +1,412 @@ +/* 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__ */ diff --git a/drivers/common/dpaax/caamflib/rta/nfifo_cmd.h b/drivers/common/dpaax/caamflib/rta/nfifo_cmd.h new file mode 100644 index 0000000000..85092d9612 --- /dev/null +++ b/drivers/common/dpaax/caamflib/rta/nfifo_cmd.h @@ -0,0 +1,163 @@ +/* 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__ */ diff --git a/drivers/common/dpaax/caamflib/rta/operation_cmd.h b/drivers/common/dpaax/caamflib/rta/operation_cmd.h new file mode 100644 index 0000000000..9a1788c0f9 --- /dev/null +++ b/drivers/common/dpaax/caamflib/rta/operation_cmd.h @@ -0,0 +1,570 @@ +/* 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__ */ diff --git a/drivers/common/dpaax/caamflib/rta/protocol_cmd.h b/drivers/common/dpaax/caamflib/rta/protocol_cmd.h new file mode 100644 index 0000000000..e9f20703f2 --- /dev/null +++ b/drivers/common/dpaax/caamflib/rta/protocol_cmd.h @@ -0,0 +1,710 @@ +/* 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__ */ diff --git a/drivers/common/dpaax/caamflib/rta/sec_run_time_asm.h b/drivers/common/dpaax/caamflib/rta/sec_run_time_asm.h new file mode 100644 index 0000000000..f40eaadea3 --- /dev/null +++ b/drivers/common/dpaax/caamflib/rta/sec_run_time_asm.h @@ -0,0 +1,823 @@ +/* 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__ */ diff --git a/drivers/common/dpaax/caamflib/rta/seq_in_out_ptr_cmd.h b/drivers/common/dpaax/caamflib/rta/seq_in_out_ptr_cmd.h new file mode 100644 index 0000000000..5e6af0c834 --- /dev/null +++ b/drivers/common/dpaax/caamflib/rta/seq_in_out_ptr_cmd.h @@ -0,0 +1,178 @@ +/* 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__ */ diff --git a/drivers/common/dpaax/caamflib/rta/signature_cmd.h b/drivers/common/dpaax/caamflib/rta/signature_cmd.h new file mode 100644 index 0000000000..4f694ac239 --- /dev/null +++ b/drivers/common/dpaax/caamflib/rta/signature_cmd.h @@ -0,0 +1,42 @@ +/* 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__ */ diff --git a/drivers/common/dpaax/caamflib/rta/store_cmd.h b/drivers/common/dpaax/caamflib/rta/store_cmd.h new file mode 100644 index 0000000000..5de47d0536 --- /dev/null +++ b/drivers/common/dpaax/caamflib/rta/store_cmd.h @@ -0,0 +1,152 @@ +/* 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__ */ diff --git a/drivers/crypto/caam_jr/Makefile b/drivers/crypto/caam_jr/Makefile index 0a8a2150be..c232a20ba3 100644 --- a/drivers/crypto/caam_jr/Makefile +++ b/drivers/crypto/caam_jr/Makefile @@ -17,9 +17,8 @@ CFLAGS += -O3 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 diff --git a/drivers/crypto/caam_jr/caam_jr.c b/drivers/crypto/caam_jr/caam_jr.c index 6ceba18f1a..2fe18187a5 100644 --- a/drivers/crypto/caam_jr/caam_jr.c +++ b/drivers/crypto/caam_jr/caam_jr.c @@ -25,8 +25,8 @@ #include /* RTA header files */ -#include -#include +#include +#include #include #ifdef RTE_LIBRTE_PMD_CAAM_JR_DEBUG #define CAAM_JR_DBG 1 diff --git a/drivers/crypto/caam_jr/caam_jr_hw.c b/drivers/crypto/caam_jr/caam_jr_hw.c index 4a2b089955..4dc7089945 100644 --- a/drivers/crypto/caam_jr/caam_jr_hw.c +++ b/drivers/crypto/caam_jr/caam_jr_hw.c @@ -16,11 +16,6 @@ #include #include -/* RTA header files */ -#include -#include -#include - /* Used to retry resetting a job ring in SEC hardware. */ #define SEC_TIMEOUT 100000 diff --git a/drivers/crypto/caam_jr/caam_jr_pvt.h b/drivers/crypto/caam_jr/caam_jr_pvt.h index d32291b605..98cd4438aa 100644 --- a/drivers/crypto/caam_jr/caam_jr_pvt.h +++ b/drivers/crypto/caam_jr/caam_jr_pvt.h @@ -5,7 +5,7 @@ #ifndef CAAM_JR_PVT_H #define CAAM_JR_PVT_H -#include +#include #include /* NXP CAAM JR PMD device name */ diff --git a/drivers/crypto/caam_jr/caam_jr_uio.c b/drivers/crypto/caam_jr/caam_jr_uio.c index afd75c9a62..b1bb44ca42 100644 --- a/drivers/crypto/caam_jr/caam_jr_uio.c +++ b/drivers/crypto/caam_jr/caam_jr_uio.c @@ -23,11 +23,6 @@ #include #include -/* RTA header files */ -#include -#include -#include - /* Prefix path to sysfs directory where UIO device attributes are exported. * Path for UIO device X is /sys/class/uio/uioX */ diff --git a/drivers/crypto/caam_jr/meson.build b/drivers/crypto/caam_jr/meson.build index 4c66dd8446..825fefd75f 100644 --- a/drivers/crypto/caam_jr/meson.build +++ b/drivers/crypto/caam_jr/meson.build @@ -14,5 +14,5 @@ sources = files('caam_jr_capabilities.c', allow_experimental_apis = true -includes += include_directories('../dpaa2_sec/') includes += include_directories('../../bus/dpaa/include/') +includes += include_directories('../../common/dpaax/caamflib/') diff --git a/drivers/crypto/dpaa2_sec/Makefile b/drivers/crypto/dpaa2_sec/Makefile index 9c6657e52b..1f288116ee 100644 --- a/drivers/crypto/dpaa2_sec/Makefile +++ b/drivers/crypto/dpaa2_sec/Makefile @@ -20,6 +20,7 @@ CFLAGS += -Wno-implicit-fallthrough 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/ diff --git a/drivers/crypto/dpaa2_sec/dpaa2_sec_dpseci.c b/drivers/crypto/dpaa2_sec/dpaa2_sec_dpseci.c index 1008164109..1fe088ad72 100644 --- a/drivers/crypto/dpaa2_sec/dpaa2_sec_dpseci.c +++ b/drivers/crypto/dpaa2_sec/dpaa2_sec_dpseci.c @@ -37,9 +37,9 @@ typedef uint64_t dma_addr_t; /* RTA header files */ -#include -#include -#include +#include +#include +#include /* Minimum job descriptor consists of a oneword job descriptor HEADER and * a pointer to the shared descriptor diff --git a/drivers/crypto/dpaa2_sec/hw/compat.h b/drivers/crypto/dpaa2_sec/hw/compat.h deleted file mode 100644 index ce946ccb5c..0000000000 --- a/drivers/crypto/dpaa2_sec/hw/compat.h +++ /dev/null @@ -1,126 +0,0 @@ -/* 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 -#include - -#ifdef __GLIBC__ -#include -#include -#include -#include - -#include -#include - -#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__ */ diff --git a/drivers/crypto/dpaa2_sec/hw/desc.h b/drivers/crypto/dpaa2_sec/hw/desc.h deleted file mode 100644 index 667da971bf..0000000000 --- a/drivers/crypto/dpaa2_sec/hw/desc.h +++ /dev/null @@ -1,2110 +0,0 @@ -/* 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__ */ diff --git a/drivers/crypto/dpaa2_sec/hw/desc/algo.h b/drivers/crypto/dpaa2_sec/hw/desc/algo.h deleted file mode 100644 index c41cb22922..0000000000 --- a/drivers/crypto/dpaa2_sec/hw/desc/algo.h +++ /dev/null @@ -1,787 +0,0 @@ -/* 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__ */ diff --git a/drivers/crypto/dpaa2_sec/hw/desc/common.h b/drivers/crypto/dpaa2_sec/hw/desc/common.h deleted file mode 100644 index 98425d8b29..0000000000 --- a/drivers/crypto/dpaa2_sec/hw/desc/common.h +++ /dev/null @@ -1,98 +0,0 @@ -/* 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__ */ diff --git a/drivers/crypto/dpaa2_sec/hw/desc/ipsec.h b/drivers/crypto/dpaa2_sec/hw/desc/ipsec.h deleted file mode 100644 index d1ffd7fd23..0000000000 --- a/drivers/crypto/dpaa2_sec/hw/desc/ipsec.h +++ /dev/null @@ -1,1615 +0,0 @@ -/* 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__ */ diff --git a/drivers/crypto/dpaa2_sec/hw/desc/pdcp.h b/drivers/crypto/dpaa2_sec/hw/desc/pdcp.h deleted file mode 100644 index b514914ecc..0000000000 --- a/drivers/crypto/dpaa2_sec/hw/desc/pdcp.h +++ /dev/null @@ -1,3753 +0,0 @@ -/* 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<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__ */ diff --git a/drivers/crypto/dpaa2_sec/hw/rta.h b/drivers/crypto/dpaa2_sec/hw/rta.h deleted file mode 100644 index c4bbad0b41..0000000000 --- a/drivers/crypto/dpaa2_sec/hw/rta.h +++ /dev/null @@ -1,921 +0,0 @@ -/* 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: 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__ */ diff --git a/drivers/crypto/dpaa2_sec/hw/rta/fifo_load_store_cmd.h b/drivers/crypto/dpaa2_sec/hw/rta/fifo_load_store_cmd.h deleted file mode 100644 index 287e09cd75..0000000000 --- a/drivers/crypto/dpaa2_sec/hw/rta/fifo_load_store_cmd.h +++ /dev/null @@ -1,314 +0,0 @@ -/* 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__ */ diff --git a/drivers/crypto/dpaa2_sec/hw/rta/header_cmd.h b/drivers/crypto/dpaa2_sec/hw/rta/header_cmd.h deleted file mode 100644 index 45aefa04c1..0000000000 --- a/drivers/crypto/dpaa2_sec/hw/rta/header_cmd.h +++ /dev/null @@ -1,231 +0,0 @@ -/* 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__ */ diff --git a/drivers/crypto/dpaa2_sec/hw/rta/jump_cmd.h b/drivers/crypto/dpaa2_sec/hw/rta/jump_cmd.h deleted file mode 100644 index 18f781e373..0000000000 --- a/drivers/crypto/dpaa2_sec/hw/rta/jump_cmd.h +++ /dev/null @@ -1,173 +0,0 @@ -/* 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__ */ diff --git a/drivers/crypto/dpaa2_sec/hw/rta/key_cmd.h b/drivers/crypto/dpaa2_sec/hw/rta/key_cmd.h deleted file mode 100644 index ec3fbcaf61..0000000000 --- a/drivers/crypto/dpaa2_sec/hw/rta/key_cmd.h +++ /dev/null @@ -1,190 +0,0 @@ -/* 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__ */ diff --git a/drivers/crypto/dpaa2_sec/hw/rta/load_cmd.h b/drivers/crypto/dpaa2_sec/hw/rta/load_cmd.h deleted file mode 100644 index 38e253c220..0000000000 --- a/drivers/crypto/dpaa2_sec/hw/rta/load_cmd.h +++ /dev/null @@ -1,306 +0,0 @@ -/* 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__*/ diff --git a/drivers/crypto/dpaa2_sec/hw/rta/math_cmd.h b/drivers/crypto/dpaa2_sec/hw/rta/math_cmd.h deleted file mode 100644 index cca70f7e04..0000000000 --- a/drivers/crypto/dpaa2_sec/hw/rta/math_cmd.h +++ /dev/null @@ -1,371 +0,0 @@ -/* 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__ */ diff --git a/drivers/crypto/dpaa2_sec/hw/rta/move_cmd.h b/drivers/crypto/dpaa2_sec/hw/rta/move_cmd.h deleted file mode 100644 index d2151c6dd7..0000000000 --- a/drivers/crypto/dpaa2_sec/hw/rta/move_cmd.h +++ /dev/null @@ -1,412 +0,0 @@ -/* 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__ */ diff --git a/drivers/crypto/dpaa2_sec/hw/rta/nfifo_cmd.h b/drivers/crypto/dpaa2_sec/hw/rta/nfifo_cmd.h deleted file mode 100644 index 85092d9612..0000000000 --- a/drivers/crypto/dpaa2_sec/hw/rta/nfifo_cmd.h +++ /dev/null @@ -1,163 +0,0 @@ -/* 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__ */ diff --git a/drivers/crypto/dpaa2_sec/hw/rta/operation_cmd.h b/drivers/crypto/dpaa2_sec/hw/rta/operation_cmd.h deleted file mode 100644 index 9a1788c0f9..0000000000 --- a/drivers/crypto/dpaa2_sec/hw/rta/operation_cmd.h +++ /dev/null @@ -1,570 +0,0 @@ -/* 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__ */ diff --git a/drivers/crypto/dpaa2_sec/hw/rta/protocol_cmd.h b/drivers/crypto/dpaa2_sec/hw/rta/protocol_cmd.h deleted file mode 100644 index e9f20703f2..0000000000 --- a/drivers/crypto/dpaa2_sec/hw/rta/protocol_cmd.h +++ /dev/null @@ -1,710 +0,0 @@ -/* 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__ */ diff --git a/drivers/crypto/dpaa2_sec/hw/rta/sec_run_time_asm.h b/drivers/crypto/dpaa2_sec/hw/rta/sec_run_time_asm.h deleted file mode 100644 index d8cdebd201..0000000000 --- a/drivers/crypto/dpaa2_sec/hw/rta/sec_run_time_asm.h +++ /dev/null @@ -1,823 +0,0 @@ -/* 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__ */ diff --git a/drivers/crypto/dpaa2_sec/hw/rta/seq_in_out_ptr_cmd.h b/drivers/crypto/dpaa2_sec/hw/rta/seq_in_out_ptr_cmd.h deleted file mode 100644 index 5e6af0c834..0000000000 --- a/drivers/crypto/dpaa2_sec/hw/rta/seq_in_out_ptr_cmd.h +++ /dev/null @@ -1,178 +0,0 @@ -/* 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__ */ diff --git a/drivers/crypto/dpaa2_sec/hw/rta/signature_cmd.h b/drivers/crypto/dpaa2_sec/hw/rta/signature_cmd.h deleted file mode 100644 index 4f694ac239..0000000000 --- a/drivers/crypto/dpaa2_sec/hw/rta/signature_cmd.h +++ /dev/null @@ -1,42 +0,0 @@ -/* 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__ */ diff --git a/drivers/crypto/dpaa2_sec/hw/rta/store_cmd.h b/drivers/crypto/dpaa2_sec/hw/rta/store_cmd.h deleted file mode 100644 index 5de47d0536..0000000000 --- a/drivers/crypto/dpaa2_sec/hw/rta/store_cmd.h +++ /dev/null @@ -1,152 +0,0 @@ -/* 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__ */ diff --git a/drivers/crypto/dpaa2_sec/meson.build b/drivers/crypto/dpaa2_sec/meson.build index 23affa8a69..1b749186ce 100644 --- a/drivers/crypto/dpaa2_sec/meson.build +++ b/drivers/crypto/dpaa2_sec/meson.build @@ -14,4 +14,4 @@ sources = files('dpaa2_sec_dpseci.c', allow_experimental_apis = true -includes += include_directories('mc', 'hw') +includes += include_directories('mc', '../../common/dpaax/caamflib') diff --git a/drivers/crypto/dpaa_sec/Makefile b/drivers/crypto/dpaa_sec/Makefile index 353c2549f6..abbcc86662 100644 --- a/drivers/crypto/dpaa_sec/Makefile +++ b/drivers/crypto/dpaa_sec/Makefile @@ -18,8 +18,7 @@ CFLAGS += -I$(RTE_SDK)/drivers/bus/dpaa 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 diff --git a/drivers/crypto/dpaa_sec/dpaa_sec.c b/drivers/crypto/dpaa_sec/dpaa_sec.c index 211029fe50..7c37136fae 100644 --- a/drivers/crypto/dpaa_sec/dpaa_sec.c +++ b/drivers/crypto/dpaa_sec/dpaa_sec.c @@ -30,10 +30,10 @@ #include /* RTA header files */ -#include -#include -#include -#include +#include +#include +#include +#include #include #include diff --git a/drivers/crypto/dpaa_sec/meson.build b/drivers/crypto/dpaa_sec/meson.build index 7b9a019b92..8744a05f05 100644 --- a/drivers/crypto/dpaa_sec/meson.build +++ b/drivers/crypto/dpaa_sec/meson.build @@ -11,4 +11,5 @@ sources = files('dpaa_sec.c') allow_experimental_apis = true -includes += include_directories('../dpaa2_sec/') +includes += include_directories('../../bus/dpaa/include') +includes += include_directories('../../common/dpaax/caamflib/')