Ruchika Gupta | ac1b269 | 2014-10-15 11:35:30 +0530 | [diff] [blame] | 1 | /* |
| 2 | * caam descriptor construction helper functions |
| 3 | * |
| 4 | * Copyright 2008-2014 Freescale Semiconductor, Inc. |
| 5 | * |
| 6 | * SPDX-License-Identifier: GPL-2.0+ |
| 7 | * |
| 8 | * Based on desc_constr.h file in linux drivers/crypto/caam |
| 9 | */ |
| 10 | |
| 11 | #include <linux/compat.h> |
| 12 | #include "desc.h" |
| 13 | |
| 14 | #define IMMEDIATE (1 << 23) |
| 15 | #define CAAM_CMD_SZ sizeof(u32) |
| 16 | #define CAAM_PTR_SZ sizeof(dma_addr_t) |
| 17 | #define CAAM_DESC_BYTES_MAX (CAAM_CMD_SZ * MAX_CAAM_DESCSIZE) |
| 18 | #define DESC_JOB_IO_LEN (CAAM_CMD_SZ * 5 + CAAM_PTR_SZ * 3) |
| 19 | |
| 20 | #ifdef DEBUG |
| 21 | #define PRINT_POS do { printf("%02d: %s\n", desc_len(desc),\ |
| 22 | &__func__[sizeof("append")]); \ |
| 23 | } while (0) |
| 24 | #else |
| 25 | #define PRINT_POS |
| 26 | #endif |
| 27 | |
| 28 | #define SET_OK_NO_PROP_ERRORS (IMMEDIATE | LDST_CLASS_DECO | \ |
| 29 | LDST_SRCDST_WORD_DECOCTRL | \ |
| 30 | (LDOFF_CHG_SHARE_OK_NO_PROP << \ |
| 31 | LDST_OFFSET_SHIFT)) |
| 32 | #define DISABLE_AUTO_INFO_FIFO (IMMEDIATE | LDST_CLASS_DECO | \ |
| 33 | LDST_SRCDST_WORD_DECOCTRL | \ |
| 34 | (LDOFF_DISABLE_AUTO_NFIFO << LDST_OFFSET_SHIFT)) |
| 35 | #define ENABLE_AUTO_INFO_FIFO (IMMEDIATE | LDST_CLASS_DECO | \ |
| 36 | LDST_SRCDST_WORD_DECOCTRL | \ |
| 37 | (LDOFF_ENABLE_AUTO_NFIFO << LDST_OFFSET_SHIFT)) |
| 38 | |
Aneesh Bansal | 4342182 | 2015-10-29 22:58:03 +0530 | [diff] [blame] | 39 | #ifdef CONFIG_PHYS_64BIT |
| 40 | union ptr_addr_t { |
| 41 | u64 m_whole; |
| 42 | struct { |
| 43 | #ifdef CONFIG_SYS_FSL_SEC_LE |
| 44 | u32 low; |
| 45 | u32 high; |
| 46 | #elif defined(CONFIG_SYS_FSL_SEC_BE) |
| 47 | u32 high; |
| 48 | u32 low; |
| 49 | #else |
| 50 | #error Neither CONFIG_SYS_FSL_SEC_LE nor CONFIG_SYS_FSL_SEC_BE is defined |
| 51 | #endif |
| 52 | } m_halfs; |
| 53 | }; |
| 54 | #endif |
| 55 | |
Aneesh Bansal | a2ecfff | 2016-02-15 15:12:56 +0530 | [diff] [blame] | 56 | static inline void pdb_add_ptr(dma_addr_t *offset, dma_addr_t ptr) |
| 57 | { |
| 58 | #ifdef CONFIG_PHYS_64BIT |
| 59 | /* The Position of low and high part of 64 bit address |
| 60 | * will depend on the endianness of CAAM Block */ |
| 61 | union ptr_addr_t *ptr_addr = (union ptr_addr_t *)offset; |
| 62 | ptr_addr->m_halfs.high = (u32)(ptr >> 32); |
| 63 | ptr_addr->m_halfs.low = (u32)ptr; |
| 64 | #else |
| 65 | *offset = ptr; |
| 66 | #endif |
| 67 | } |
| 68 | |
Ruchika Gupta | ac1b269 | 2014-10-15 11:35:30 +0530 | [diff] [blame] | 69 | static inline int desc_len(u32 *desc) |
| 70 | { |
| 71 | return *desc & HDR_DESCLEN_MASK; |
| 72 | } |
| 73 | |
| 74 | static inline int desc_bytes(void *desc) |
| 75 | { |
| 76 | return desc_len(desc) * CAAM_CMD_SZ; |
| 77 | } |
| 78 | |
| 79 | static inline u32 *desc_end(u32 *desc) |
| 80 | { |
| 81 | return desc + desc_len(desc); |
| 82 | } |
| 83 | |
Aneesh Bansal | a2ecfff | 2016-02-15 15:12:56 +0530 | [diff] [blame] | 84 | static inline void *desc_pdb(u32 *desc) |
| 85 | { |
| 86 | return desc + 1; |
| 87 | } |
| 88 | |
Ruchika Gupta | ac1b269 | 2014-10-15 11:35:30 +0530 | [diff] [blame] | 89 | static inline void init_desc(u32 *desc, u32 options) |
| 90 | { |
| 91 | *desc = (options | HDR_ONE) + 1; |
| 92 | } |
| 93 | |
| 94 | static inline void init_job_desc(u32 *desc, u32 options) |
| 95 | { |
| 96 | init_desc(desc, CMD_DESC_HDR | options); |
| 97 | } |
| 98 | |
Aneesh Bansal | a2ecfff | 2016-02-15 15:12:56 +0530 | [diff] [blame] | 99 | static inline void init_job_desc_pdb(u32 *desc, u32 options, size_t pdb_bytes) |
| 100 | { |
| 101 | u32 pdb_len = (pdb_bytes + CAAM_CMD_SZ - 1) / CAAM_CMD_SZ; |
| 102 | |
| 103 | init_job_desc(desc, |
| 104 | (((pdb_len + 1) << HDR_START_IDX_SHIFT) + pdb_len) | |
| 105 | options); |
| 106 | } |
| 107 | |
Ruchika Gupta | ac1b269 | 2014-10-15 11:35:30 +0530 | [diff] [blame] | 108 | static inline void append_ptr(u32 *desc, dma_addr_t ptr) |
| 109 | { |
| 110 | dma_addr_t *offset = (dma_addr_t *)desc_end(desc); |
| 111 | |
Aneesh Bansal | 4342182 | 2015-10-29 22:58:03 +0530 | [diff] [blame] | 112 | #ifdef CONFIG_PHYS_64BIT |
| 113 | /* The Position of low and high part of 64 bit address |
| 114 | * will depend on the endianness of CAAM Block */ |
Saksham Jain | de5ba06 | 2016-03-23 16:24:41 +0530 | [diff] [blame] | 115 | union ptr_addr_t *ptr_addr = (union ptr_addr_t *)offset; |
| 116 | ptr_addr->m_halfs.high = (u32)(ptr >> 32); |
| 117 | ptr_addr->m_halfs.low = (u32)ptr; |
Aneesh Bansal | 4342182 | 2015-10-29 22:58:03 +0530 | [diff] [blame] | 118 | #else |
Ruchika Gupta | ac1b269 | 2014-10-15 11:35:30 +0530 | [diff] [blame] | 119 | *offset = ptr; |
Aneesh Bansal | 4342182 | 2015-10-29 22:58:03 +0530 | [diff] [blame] | 120 | #endif |
Ruchika Gupta | ac1b269 | 2014-10-15 11:35:30 +0530 | [diff] [blame] | 121 | |
| 122 | (*desc) += CAAM_PTR_SZ / CAAM_CMD_SZ; |
| 123 | } |
| 124 | |
| 125 | static inline void append_data(u32 *desc, void *data, int len) |
| 126 | { |
| 127 | u32 *offset = desc_end(desc); |
| 128 | |
| 129 | if (len) /* avoid sparse warning: memcpy with byte count of 0 */ |
| 130 | memcpy(offset, data, len); |
| 131 | |
| 132 | (*desc) += (len + CAAM_CMD_SZ - 1) / CAAM_CMD_SZ; |
| 133 | } |
| 134 | |
| 135 | static inline void append_cmd(u32 *desc, u32 command) |
| 136 | { |
| 137 | u32 *cmd = desc_end(desc); |
| 138 | |
| 139 | *cmd = command; |
| 140 | |
| 141 | (*desc)++; |
| 142 | } |
| 143 | |
| 144 | #define append_u32 append_cmd |
| 145 | |
| 146 | static inline void append_u64(u32 *desc, u64 data) |
| 147 | { |
| 148 | u32 *offset = desc_end(desc); |
| 149 | |
| 150 | *offset = upper_32_bits(data); |
| 151 | *(++offset) = lower_32_bits(data); |
| 152 | |
| 153 | (*desc) += 2; |
| 154 | } |
| 155 | |
| 156 | /* Write command without affecting header, and return pointer to next word */ |
| 157 | static inline u32 *write_cmd(u32 *desc, u32 command) |
| 158 | { |
| 159 | *desc = command; |
| 160 | |
| 161 | return desc + 1; |
| 162 | } |
| 163 | |
| 164 | static inline void append_cmd_ptr(u32 *desc, dma_addr_t ptr, int len, |
| 165 | u32 command) |
| 166 | { |
| 167 | append_cmd(desc, command | len); |
| 168 | append_ptr(desc, ptr); |
| 169 | } |
| 170 | |
| 171 | /* Write length after pointer, rather than inside command */ |
| 172 | static inline void append_cmd_ptr_extlen(u32 *desc, dma_addr_t ptr, |
| 173 | unsigned int len, u32 command) |
| 174 | { |
| 175 | append_cmd(desc, command); |
| 176 | if (!(command & (SQIN_RTO | SQIN_PRE))) |
| 177 | append_ptr(desc, ptr); |
| 178 | append_cmd(desc, len); |
| 179 | } |
| 180 | |
| 181 | static inline void append_cmd_data(u32 *desc, void *data, int len, |
| 182 | u32 command) |
| 183 | { |
| 184 | append_cmd(desc, command | IMMEDIATE | len); |
| 185 | append_data(desc, data, len); |
| 186 | } |
| 187 | |
| 188 | #define APPEND_CMD_RET(cmd, op) \ |
| 189 | static inline u32 *append_##cmd(u32 *desc, u32 options) \ |
| 190 | { \ |
| 191 | u32 *cmd = desc_end(desc); \ |
| 192 | PRINT_POS; \ |
| 193 | append_cmd(desc, CMD_##op | options); \ |
| 194 | return cmd; \ |
| 195 | } |
| 196 | APPEND_CMD_RET(jump, JUMP) |
| 197 | APPEND_CMD_RET(move, MOVE) |
| 198 | |
| 199 | static inline void set_jump_tgt_here(u32 *desc, u32 *jump_cmd) |
| 200 | { |
| 201 | *jump_cmd = *jump_cmd | (desc_len(desc) - (jump_cmd - desc)); |
| 202 | } |
| 203 | |
| 204 | static inline void set_move_tgt_here(u32 *desc, u32 *move_cmd) |
| 205 | { |
| 206 | *move_cmd &= ~MOVE_OFFSET_MASK; |
| 207 | *move_cmd = *move_cmd | ((desc_len(desc) << (MOVE_OFFSET_SHIFT + 2)) & |
| 208 | MOVE_OFFSET_MASK); |
| 209 | } |
| 210 | |
| 211 | #define APPEND_CMD(cmd, op) \ |
| 212 | static inline void append_##cmd(u32 *desc, u32 options) \ |
| 213 | { \ |
| 214 | PRINT_POS; \ |
| 215 | append_cmd(desc, CMD_##op | options); \ |
| 216 | } |
| 217 | APPEND_CMD(operation, OPERATION) |
| 218 | |
| 219 | #define APPEND_CMD_LEN(cmd, op) \ |
| 220 | static inline void append_##cmd(u32 *desc, unsigned int len, u32 options) \ |
| 221 | { \ |
| 222 | PRINT_POS; \ |
| 223 | append_cmd(desc, CMD_##op | len | options); \ |
| 224 | } |
| 225 | APPEND_CMD_LEN(seq_store, SEQ_STORE) |
| 226 | APPEND_CMD_LEN(seq_fifo_load, SEQ_FIFO_LOAD) |
| 227 | APPEND_CMD_LEN(seq_fifo_store, SEQ_FIFO_STORE) |
| 228 | |
| 229 | #define APPEND_CMD_PTR(cmd, op) \ |
| 230 | static inline void append_##cmd(u32 *desc, dma_addr_t ptr, unsigned int len, \ |
| 231 | u32 options) \ |
| 232 | { \ |
| 233 | PRINT_POS; \ |
| 234 | append_cmd_ptr(desc, ptr, len, CMD_##op | options); \ |
| 235 | } |
| 236 | APPEND_CMD_PTR(key, KEY) |
| 237 | APPEND_CMD_PTR(load, LOAD) |
| 238 | APPEND_CMD_PTR(fifo_load, FIFO_LOAD) |
| 239 | APPEND_CMD_PTR(fifo_store, FIFO_STORE) |
| 240 | |
| 241 | static inline void append_store(u32 *desc, dma_addr_t ptr, unsigned int len, |
| 242 | u32 options) |
| 243 | { |
| 244 | u32 cmd_src; |
| 245 | |
| 246 | cmd_src = options & LDST_SRCDST_MASK; |
| 247 | |
| 248 | append_cmd(desc, CMD_STORE | options | len); |
| 249 | |
| 250 | /* The following options do not require pointer */ |
| 251 | if (!(cmd_src == LDST_SRCDST_WORD_DESCBUF_SHARED || |
| 252 | cmd_src == LDST_SRCDST_WORD_DESCBUF_JOB || |
| 253 | cmd_src == LDST_SRCDST_WORD_DESCBUF_JOB_WE || |
| 254 | cmd_src == LDST_SRCDST_WORD_DESCBUF_SHARED_WE)) |
| 255 | append_ptr(desc, ptr); |
| 256 | } |
| 257 | |
| 258 | #define APPEND_SEQ_PTR_INTLEN(cmd, op) \ |
| 259 | static inline void append_seq_##cmd##_ptr_intlen(u32 *desc, dma_addr_t ptr, \ |
| 260 | unsigned int len, \ |
| 261 | u32 options) \ |
| 262 | { \ |
| 263 | PRINT_POS; \ |
| 264 | if (options & (SQIN_RTO | SQIN_PRE)) \ |
| 265 | append_cmd(desc, CMD_SEQ_##op##_PTR | len | options); \ |
| 266 | else \ |
| 267 | append_cmd_ptr(desc, ptr, len, CMD_SEQ_##op##_PTR | options); \ |
| 268 | } |
| 269 | APPEND_SEQ_PTR_INTLEN(in, IN) |
| 270 | APPEND_SEQ_PTR_INTLEN(out, OUT) |
| 271 | |
| 272 | #define APPEND_CMD_PTR_TO_IMM(cmd, op) \ |
| 273 | static inline void append_##cmd##_as_imm(u32 *desc, void *data, \ |
| 274 | unsigned int len, u32 options) \ |
| 275 | { \ |
| 276 | PRINT_POS; \ |
| 277 | append_cmd_data(desc, data, len, CMD_##op | options); \ |
| 278 | } |
| 279 | APPEND_CMD_PTR_TO_IMM(load, LOAD); |
| 280 | APPEND_CMD_PTR_TO_IMM(fifo_load, FIFO_LOAD); |
| 281 | |
| 282 | #define APPEND_CMD_PTR_EXTLEN(cmd, op) \ |
| 283 | static inline void append_##cmd##_extlen(u32 *desc, dma_addr_t ptr, \ |
| 284 | unsigned int len, u32 options) \ |
| 285 | { \ |
| 286 | PRINT_POS; \ |
| 287 | append_cmd_ptr_extlen(desc, ptr, len, CMD_##op | SQIN_EXT | options); \ |
| 288 | } |
| 289 | APPEND_CMD_PTR_EXTLEN(seq_in_ptr, SEQ_IN_PTR) |
| 290 | APPEND_CMD_PTR_EXTLEN(seq_out_ptr, SEQ_OUT_PTR) |
| 291 | |
| 292 | /* |
| 293 | * Determine whether to store length internally or externally depending on |
| 294 | * the size of its type |
| 295 | */ |
| 296 | #define APPEND_CMD_PTR_LEN(cmd, op, type) \ |
| 297 | static inline void append_##cmd(u32 *desc, dma_addr_t ptr, \ |
| 298 | type len, u32 options) \ |
| 299 | { \ |
| 300 | PRINT_POS; \ |
| 301 | if (sizeof(type) > sizeof(u16)) \ |
| 302 | append_##cmd##_extlen(desc, ptr, len, options); \ |
| 303 | else \ |
| 304 | append_##cmd##_intlen(desc, ptr, len, options); \ |
| 305 | } |
| 306 | APPEND_CMD_PTR_LEN(seq_in_ptr, SEQ_IN_PTR, u32) |
| 307 | APPEND_CMD_PTR_LEN(seq_out_ptr, SEQ_OUT_PTR, u32) |
| 308 | |
| 309 | /* |
| 310 | * 2nd variant for commands whose specified immediate length differs |
| 311 | * from length of immediate data provided, e.g., split keys |
| 312 | */ |
| 313 | #define APPEND_CMD_PTR_TO_IMM2(cmd, op) \ |
| 314 | static inline void append_##cmd##_as_imm(u32 *desc, void *data, \ |
| 315 | unsigned int data_len, \ |
| 316 | unsigned int len, u32 options) \ |
| 317 | { \ |
| 318 | PRINT_POS; \ |
| 319 | append_cmd(desc, CMD_##op | IMMEDIATE | len | options); \ |
| 320 | append_data(desc, data, data_len); \ |
| 321 | } |
| 322 | APPEND_CMD_PTR_TO_IMM2(key, KEY); |
| 323 | |
| 324 | #define APPEND_CMD_RAW_IMM(cmd, op, type) \ |
| 325 | static inline void append_##cmd##_imm_##type(u32 *desc, type immediate, \ |
| 326 | u32 options) \ |
| 327 | { \ |
| 328 | PRINT_POS; \ |
| 329 | append_cmd(desc, CMD_##op | IMMEDIATE | options | sizeof(type)); \ |
| 330 | append_cmd(desc, immediate); \ |
| 331 | } |
| 332 | APPEND_CMD_RAW_IMM(load, LOAD, u32); |