mirror of
https://github.com/AsahiLinux/u-boot
synced 2024-11-06 05:04:26 +00:00
30325c2c4f
On aarch64 running with dcache off, will result in an unaligned access exception: => dcache off => hash sha1 $kernel_addr_r 100 "Synchronous Abort" handler, esr 0x96000061 elr: 00000000960317d8 lr : 00000000960316a4 (reloc) elr: 00000000fbd787d8 lr : 00000000fbd786a4 [..] The compiler emits a "stur x1, [x0, #12]". x1 is might just be 32 bit aligned pointer. Remove the unused u64 element from the union to drop the minimal alignment to 32 bit. Also remove the union, because it is no more needed. Signed-off-by: Michael Walle <michael@walle.cc> Reviewed-by: Priyanka Jain <priyanka.jain@nxp.com>
330 lines
8.3 KiB
C
330 lines
8.3 KiB
C
/* SPDX-License-Identifier: GPL-2.0+ */
|
|
/*
|
|
* caam descriptor construction helper functions
|
|
*
|
|
* Copyright 2008-2014 Freescale Semiconductor, Inc.
|
|
*
|
|
* Based on desc_constr.h file in linux drivers/crypto/caam
|
|
*/
|
|
|
|
#include <linux/compat.h>
|
|
#include "desc.h"
|
|
|
|
#define IMMEDIATE (1 << 23)
|
|
#define CAAM_CMD_SZ sizeof(u32)
|
|
#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)
|
|
|
|
#ifdef DEBUG
|
|
#define PRINT_POS do { printf("%02d: %s\n", desc_len(desc),\
|
|
&__func__[sizeof("append")]); \
|
|
} while (0)
|
|
#else
|
|
#define PRINT_POS
|
|
#endif
|
|
|
|
#define SET_OK_NO_PROP_ERRORS (IMMEDIATE | LDST_CLASS_DECO | \
|
|
LDST_SRCDST_WORD_DECOCTRL | \
|
|
(LDOFF_CHG_SHARE_OK_NO_PROP << \
|
|
LDST_OFFSET_SHIFT))
|
|
#define DISABLE_AUTO_INFO_FIFO (IMMEDIATE | LDST_CLASS_DECO | \
|
|
LDST_SRCDST_WORD_DECOCTRL | \
|
|
(LDOFF_DISABLE_AUTO_NFIFO << LDST_OFFSET_SHIFT))
|
|
#define ENABLE_AUTO_INFO_FIFO (IMMEDIATE | LDST_CLASS_DECO | \
|
|
LDST_SRCDST_WORD_DECOCTRL | \
|
|
(LDOFF_ENABLE_AUTO_NFIFO << LDST_OFFSET_SHIFT))
|
|
|
|
#ifdef CONFIG_PHYS_64BIT
|
|
struct ptr_addr_t {
|
|
#ifdef CONFIG_SYS_FSL_SEC_LE
|
|
u32 low;
|
|
u32 high;
|
|
#elif defined(CONFIG_SYS_FSL_SEC_BE)
|
|
u32 high;
|
|
u32 low;
|
|
#else
|
|
#error Neither CONFIG_SYS_FSL_SEC_LE nor CONFIG_SYS_FSL_SEC_BE is defined
|
|
#endif
|
|
};
|
|
#endif
|
|
|
|
static inline void pdb_add_ptr(dma_addr_t *offset, dma_addr_t ptr)
|
|
{
|
|
#ifdef CONFIG_PHYS_64BIT
|
|
/* The Position of low and high part of 64 bit address
|
|
* will depend on the endianness of CAAM Block */
|
|
struct ptr_addr_t *ptr_addr = (struct ptr_addr_t *)offset;
|
|
|
|
ptr_addr->high = (u32)(ptr >> 32);
|
|
ptr_addr->low = (u32)ptr;
|
|
#else
|
|
*offset = ptr;
|
|
#endif
|
|
}
|
|
|
|
static inline int desc_len(u32 *desc)
|
|
{
|
|
return *desc & HDR_DESCLEN_MASK;
|
|
}
|
|
|
|
static inline int desc_bytes(void *desc)
|
|
{
|
|
return desc_len(desc) * CAAM_CMD_SZ;
|
|
}
|
|
|
|
static inline u32 *desc_end(u32 *desc)
|
|
{
|
|
return desc + desc_len(desc);
|
|
}
|
|
|
|
static inline void *desc_pdb(u32 *desc)
|
|
{
|
|
return desc + 1;
|
|
}
|
|
|
|
static inline void init_desc(u32 *desc, u32 options)
|
|
{
|
|
*desc = (options | HDR_ONE) + 1;
|
|
}
|
|
|
|
static inline void init_job_desc(u32 *desc, u32 options)
|
|
{
|
|
init_desc(desc, CMD_DESC_HDR | options);
|
|
}
|
|
|
|
static inline void init_job_desc_pdb(u32 *desc, u32 options, size_t pdb_bytes)
|
|
{
|
|
u32 pdb_len = (pdb_bytes + CAAM_CMD_SZ - 1) / CAAM_CMD_SZ;
|
|
|
|
init_job_desc(desc,
|
|
(((pdb_len + 1) << HDR_START_IDX_SHIFT) + pdb_len) |
|
|
options);
|
|
}
|
|
|
|
static inline void append_ptr(u32 *desc, dma_addr_t ptr)
|
|
{
|
|
dma_addr_t *offset = (dma_addr_t *)desc_end(desc);
|
|
|
|
#ifdef CONFIG_PHYS_64BIT
|
|
/* The Position of low and high part of 64 bit address
|
|
* will depend on the endianness of CAAM Block */
|
|
struct ptr_addr_t *ptr_addr = (struct ptr_addr_t *)offset;
|
|
|
|
ptr_addr->high = (u32)(ptr >> 32);
|
|
ptr_addr->low = (u32)ptr;
|
|
#else
|
|
*offset = ptr;
|
|
#endif
|
|
|
|
(*desc) += CAAM_PTR_SZ / CAAM_CMD_SZ;
|
|
}
|
|
|
|
static inline void append_data(u32 *desc, void *data, int len)
|
|
{
|
|
u32 *offset = desc_end(desc);
|
|
|
|
if (len) /* avoid sparse warning: memcpy with byte count of 0 */
|
|
memcpy(offset, data, len);
|
|
|
|
(*desc) += (len + CAAM_CMD_SZ - 1) / CAAM_CMD_SZ;
|
|
}
|
|
|
|
static inline void append_cmd(u32 *desc, u32 command)
|
|
{
|
|
u32 *cmd = desc_end(desc);
|
|
|
|
*cmd = command;
|
|
|
|
(*desc)++;
|
|
}
|
|
|
|
#define append_u32 append_cmd
|
|
|
|
static inline void append_u64(u32 *desc, u64 data)
|
|
{
|
|
u32 *offset = desc_end(desc);
|
|
|
|
*offset = upper_32_bits(data);
|
|
*(++offset) = lower_32_bits(data);
|
|
|
|
(*desc) += 2;
|
|
}
|
|
|
|
/* Write command without affecting header, and return pointer to next word */
|
|
static inline u32 *write_cmd(u32 *desc, u32 command)
|
|
{
|
|
*desc = command;
|
|
|
|
return desc + 1;
|
|
}
|
|
|
|
static inline void append_cmd_ptr(u32 *desc, dma_addr_t ptr, int len,
|
|
u32 command)
|
|
{
|
|
append_cmd(desc, command | len);
|
|
append_ptr(desc, ptr);
|
|
}
|
|
|
|
/* Write length after pointer, rather than inside command */
|
|
static inline void append_cmd_ptr_extlen(u32 *desc, dma_addr_t ptr,
|
|
unsigned int len, u32 command)
|
|
{
|
|
append_cmd(desc, command);
|
|
if (!(command & (SQIN_RTO | SQIN_PRE)))
|
|
append_ptr(desc, ptr);
|
|
append_cmd(desc, len);
|
|
}
|
|
|
|
static inline void append_cmd_data(u32 *desc, void *data, int len,
|
|
u32 command)
|
|
{
|
|
append_cmd(desc, command | IMMEDIATE | len);
|
|
append_data(desc, data, len);
|
|
}
|
|
|
|
#define APPEND_CMD_RET(cmd, op) \
|
|
static inline u32 *append_##cmd(u32 *desc, u32 options) \
|
|
{ \
|
|
u32 *cmd = desc_end(desc); \
|
|
PRINT_POS; \
|
|
append_cmd(desc, CMD_##op | options); \
|
|
return cmd; \
|
|
}
|
|
APPEND_CMD_RET(jump, JUMP)
|
|
APPEND_CMD_RET(move, MOVE)
|
|
|
|
static inline void set_jump_tgt_here(u32 *desc, u32 *jump_cmd)
|
|
{
|
|
*jump_cmd = *jump_cmd | (desc_len(desc) - (jump_cmd - desc));
|
|
}
|
|
|
|
static inline void set_move_tgt_here(u32 *desc, u32 *move_cmd)
|
|
{
|
|
*move_cmd &= ~MOVE_OFFSET_MASK;
|
|
*move_cmd = *move_cmd | ((desc_len(desc) << (MOVE_OFFSET_SHIFT + 2)) &
|
|
MOVE_OFFSET_MASK);
|
|
}
|
|
|
|
#define APPEND_CMD(cmd, op) \
|
|
static inline void append_##cmd(u32 *desc, u32 options) \
|
|
{ \
|
|
PRINT_POS; \
|
|
append_cmd(desc, CMD_##op | options); \
|
|
}
|
|
APPEND_CMD(operation, OPERATION)
|
|
|
|
#define APPEND_CMD_LEN(cmd, op) \
|
|
static inline void append_##cmd(u32 *desc, unsigned int len, u32 options) \
|
|
{ \
|
|
PRINT_POS; \
|
|
append_cmd(desc, CMD_##op | len | options); \
|
|
}
|
|
APPEND_CMD_LEN(seq_store, SEQ_STORE)
|
|
APPEND_CMD_LEN(seq_fifo_load, SEQ_FIFO_LOAD)
|
|
APPEND_CMD_LEN(seq_fifo_store, SEQ_FIFO_STORE)
|
|
|
|
#define APPEND_CMD_PTR(cmd, op) \
|
|
static inline void append_##cmd(u32 *desc, dma_addr_t ptr, unsigned int len, \
|
|
u32 options) \
|
|
{ \
|
|
PRINT_POS; \
|
|
append_cmd_ptr(desc, ptr, len, CMD_##op | options); \
|
|
}
|
|
APPEND_CMD_PTR(key, KEY)
|
|
APPEND_CMD_PTR(load, LOAD)
|
|
APPEND_CMD_PTR(fifo_load, FIFO_LOAD)
|
|
APPEND_CMD_PTR(fifo_store, FIFO_STORE)
|
|
|
|
static inline void append_store(u32 *desc, dma_addr_t ptr, unsigned int len,
|
|
u32 options)
|
|
{
|
|
u32 cmd_src;
|
|
|
|
cmd_src = options & LDST_SRCDST_MASK;
|
|
|
|
append_cmd(desc, CMD_STORE | options | len);
|
|
|
|
/* The following options do not require pointer */
|
|
if (!(cmd_src == LDST_SRCDST_WORD_DESCBUF_SHARED ||
|
|
cmd_src == LDST_SRCDST_WORD_DESCBUF_JOB ||
|
|
cmd_src == LDST_SRCDST_WORD_DESCBUF_JOB_WE ||
|
|
cmd_src == LDST_SRCDST_WORD_DESCBUF_SHARED_WE))
|
|
append_ptr(desc, ptr);
|
|
}
|
|
|
|
#define APPEND_SEQ_PTR_INTLEN(cmd, op) \
|
|
static inline void append_seq_##cmd##_ptr_intlen(u32 *desc, dma_addr_t ptr, \
|
|
unsigned int len, \
|
|
u32 options) \
|
|
{ \
|
|
PRINT_POS; \
|
|
if (options & (SQIN_RTO | SQIN_PRE)) \
|
|
append_cmd(desc, CMD_SEQ_##op##_PTR | len | options); \
|
|
else \
|
|
append_cmd_ptr(desc, ptr, len, CMD_SEQ_##op##_PTR | options); \
|
|
}
|
|
APPEND_SEQ_PTR_INTLEN(in, IN)
|
|
APPEND_SEQ_PTR_INTLEN(out, OUT)
|
|
|
|
#define APPEND_CMD_PTR_TO_IMM(cmd, op) \
|
|
static inline void append_##cmd##_as_imm(u32 *desc, void *data, \
|
|
unsigned int len, u32 options) \
|
|
{ \
|
|
PRINT_POS; \
|
|
append_cmd_data(desc, data, len, CMD_##op | options); \
|
|
}
|
|
APPEND_CMD_PTR_TO_IMM(load, LOAD);
|
|
APPEND_CMD_PTR_TO_IMM(fifo_load, FIFO_LOAD);
|
|
|
|
#define APPEND_CMD_PTR_EXTLEN(cmd, op) \
|
|
static inline void append_##cmd##_extlen(u32 *desc, dma_addr_t ptr, \
|
|
unsigned int len, u32 options) \
|
|
{ \
|
|
PRINT_POS; \
|
|
append_cmd_ptr_extlen(desc, ptr, len, CMD_##op | SQIN_EXT | options); \
|
|
}
|
|
APPEND_CMD_PTR_EXTLEN(seq_in_ptr, SEQ_IN_PTR)
|
|
APPEND_CMD_PTR_EXTLEN(seq_out_ptr, SEQ_OUT_PTR)
|
|
|
|
/*
|
|
* Determine whether to store length internally or externally depending on
|
|
* the size of its type
|
|
*/
|
|
#define APPEND_CMD_PTR_LEN(cmd, op, type) \
|
|
static inline void append_##cmd(u32 *desc, dma_addr_t ptr, \
|
|
type len, u32 options) \
|
|
{ \
|
|
PRINT_POS; \
|
|
if (sizeof(type) > sizeof(u16)) \
|
|
append_##cmd##_extlen(desc, ptr, len, options); \
|
|
else \
|
|
append_##cmd##_intlen(desc, ptr, len, options); \
|
|
}
|
|
APPEND_CMD_PTR_LEN(seq_in_ptr, SEQ_IN_PTR, u32)
|
|
APPEND_CMD_PTR_LEN(seq_out_ptr, SEQ_OUT_PTR, u32)
|
|
|
|
/*
|
|
* 2nd variant for commands whose specified immediate length differs
|
|
* from length of immediate data provided, e.g., split keys
|
|
*/
|
|
#define APPEND_CMD_PTR_TO_IMM2(cmd, op) \
|
|
static inline void append_##cmd##_as_imm(u32 *desc, void *data, \
|
|
unsigned int data_len, \
|
|
unsigned int len, u32 options) \
|
|
{ \
|
|
PRINT_POS; \
|
|
append_cmd(desc, CMD_##op | IMMEDIATE | len | options); \
|
|
append_data(desc, data, data_len); \
|
|
}
|
|
APPEND_CMD_PTR_TO_IMM2(key, KEY);
|
|
|
|
#define APPEND_CMD_RAW_IMM(cmd, op, type) \
|
|
static inline void append_##cmd##_imm_##type(u32 *desc, type immediate, \
|
|
u32 options) \
|
|
{ \
|
|
PRINT_POS; \
|
|
append_cmd(desc, CMD_##op | IMMEDIATE | options | sizeof(type)); \
|
|
append_cmd(desc, immediate); \
|
|
}
|
|
APPEND_CMD_RAW_IMM(load, LOAD, u32);
|