1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright 2017-2018 NXP 3 */ 4 5 #ifndef CAAM_JR_PVT_H 6 #define CAAM_JR_PVT_H 7 8 #include <desc/ipsec.h> 9 #include <dpaax_iova_table.h> 10 11 /* NXP CAAM JR PMD device name */ 12 13 #define CAAM_JR_ALG_UNSUPPORT (-1) 14 15 /* Minimum job descriptor consists of a oneword job descriptor HEADER and 16 * a pointer to the shared descriptor. 17 */ 18 #define MIN_JOB_DESC_SIZE (CAAM_CMD_SZ + CAAM_PTR_SZ) 19 #define CAAM_JOB_DESC_SIZE 13 20 21 /* CTX_POOL_NUM_BUFS is set as per the ipsec-secgw application */ 22 #define CTX_POOL_NUM_BUFS 32000 23 #define CTX_POOL_CACHE_SIZE 512 24 25 #define DIR_ENC 1 26 #define DIR_DEC 0 27 28 #define JR_MAX_NB_MAX_DIGEST 32 29 30 #define RTE_CAAM_JR_PMD_MAX_NB_SESSIONS 2048 31 32 33 /* Return codes for SEC user space driver APIs */ 34 enum sec_return_code_e { 35 SEC_SUCCESS = 0, /* Operation executed successfully.*/ 36 SEC_INVALID_INPUT_PARAM, /* API received an invalid input 37 * parameter 38 */ 39 SEC_OUT_OF_MEMORY, /* Memory allocation failed. */ 40 SEC_DESCRIPTOR_IN_FLIGHT, /* API function indicates there are 41 * descriptors in flight 42 * for SEC to process. 43 */ 44 SEC_LAST_DESCRIPTOR_IN_FLIGHT, /* API function indicates there is one 45 * last descriptor in flight 46 * for SEC to process that. 47 */ 48 SEC_PROCESSING_ERROR, /* Indicates a SEC processing error 49 * occurred on a Job Ring which requires 50 * a SEC user space driver shutdown. Can 51 * be returned from sec_poll_job_ring(). 52 * Then the only other API that can be 53 * called after this error is 54 * sec_release(). 55 */ 56 SEC_DESC_PROCESSING_ERROR, /* Indicates a SEC descriptor processing 57 * error occurred on a Job Ring. Can be 58 * returned from sec_poll_job_ring(). 59 * The driver was able to reset job ring 60 * and job ring can be used like in a 61 * normal case. 62 */ 63 SEC_JR_IS_FULL, /* Job Ring is full. There is no more 64 * room in the JR for new descriptors. 65 * This can happen if the descriptor RX 66 * rate is higher than SEC's capacity. 67 */ 68 SEC_DRIVER_RELEASE_IN_PROGRESS, /* SEC driver shutdown is in progress, 69 * descriptors processing or polling is 70 * allowed. 71 */ 72 SEC_DRIVER_ALREADY_INITIALIZED, /* SEC driver is already initialized.*/ 73 SEC_DRIVER_NOT_INITIALIZED, /* SEC driver is NOT initialized. */ 74 SEC_JOB_RING_RESET_IN_PROGRESS, /* Job ring is resetting due to a 75 * per-descriptor SEC processing error 76 * ::SEC_desc_PROCESSING_ERROR. Reset is 77 * finished when sec_poll_job_ring() 78 * return. Then the job ring can be used 79 * again. 80 */ 81 SEC_RESET_ENGINE_FAILED, /* Resetting of SEC Engine by SEC Kernel 82 * Driver Failed 83 */ 84 SEC_ENABLE_IRQS_FAILED, /* Enabling of IRQs in SEC Kernel Driver 85 * Failed 86 */ 87 SEC_DISABLE_IRQS_FAILED, /* Disabling of IRQs in SEC Kernel 88 * Driver Failed 89 */ 90 /* END OF VALID VALUES */ 91 92 SEC_RETURN_CODE_MAX_VALUE, /* Invalid value for return code. It is 93 * used to mark the end of the return 94 * code values. @note ALL new return 95 * code values MUST be added before 96 * ::SEC_RETURN_CODE_MAX_VALUE! 97 */ 98 }; 99 100 enum caam_jr_op_type { 101 CAAM_JR_NONE, /* No Cipher operations*/ 102 CAAM_JR_CIPHER,/* CIPHER operations */ 103 CAAM_JR_AUTH, /* Authentication Operations */ 104 CAAM_JR_AEAD, /* Authenticated Encryption with associated data */ 105 CAAM_JR_IPSEC, /* IPSEC protocol operations*/ 106 CAAM_JR_PDCP, /* PDCP protocol operations*/ 107 CAAM_JR_PKC, /* Public Key Cryptographic Operations */ 108 CAAM_JR_MAX 109 }; 110 111 struct caam_jr_session { 112 uint8_t dir; /* Operation Direction */ 113 enum rte_crypto_cipher_algorithm cipher_alg; /* Cipher Algorithm*/ 114 enum rte_crypto_auth_algorithm auth_alg; /* Authentication Algorithm*/ 115 enum rte_crypto_aead_algorithm aead_alg; /* AEAD Algorithm*/ 116 enum rte_security_session_protocol proto_alg; /* Security Algorithm*/ 117 union { 118 struct { 119 uint8_t *data; /* pointer to key data */ 120 size_t length; /* key length in bytes */ 121 } aead_key; 122 struct { 123 struct { 124 uint8_t *data; /* pointer to key data */ 125 size_t length; /* key length in bytes */ 126 } cipher_key; 127 struct { 128 uint8_t *data; /* pointer to key data */ 129 size_t length; /* key length in bytes */ 130 } auth_key; 131 }; 132 }; 133 struct { 134 uint16_t length; 135 uint16_t offset; 136 } iv; /* Initialisation vector parameters */ 137 uint16_t auth_only_len; /* Length of data for Auth only */ 138 uint32_t digest_length; 139 struct ipsec_encap_pdb encap_pdb; 140 struct ip ip4_hdr; 141 struct ipsec_decap_pdb decap_pdb; 142 struct caam_jr_qp *qp; 143 struct sec_cdb *cdb; /* cmd block associated with qp */ 144 struct rte_mempool *ctx_pool; /* session mempool for caam_jr_op_ctx */ 145 }; 146 147 /* 148 * 16-byte hardware scatter/gather table 149 */ 150 151 #define SEC4_SG_LEN_EXT 0x80000000 /* Entry points to table */ 152 #define SEC4_SG_LEN_FIN 0x40000000 /* Last ent in table */ 153 #define SEC4_SG_BPID_MASK 0x000000ff 154 #define SEC4_SG_BPID_SHIFT 16 155 #define SEC4_SG_LEN_MASK 0x3fffffff /* Excludes EXT and FINAL */ 156 #define SEC4_SG_OFFSET_MASK 0x00001fff 157 158 struct sec4_sg_entry { 159 uint64_t ptr; 160 uint32_t len; 161 uint32_t bpid_offset; 162 }; 163 164 #define MAX_SG_ENTRIES 16 165 #define SG_CACHELINE_0 0 166 #define SG_CACHELINE_1 4 167 #define SG_CACHELINE_2 8 168 #define SG_CACHELINE_3 12 169 170 /* Structure encompassing a job descriptor which is to be processed 171 * by SEC. User should also initialise this structure with the callback 172 * function pointer which will be called by driver after recieving proccessed 173 * descriptor from SEC. User data is also passed in this data structure which 174 * will be sent as an argument to the user callback function. 175 */ 176 struct job_descriptor { 177 uint32_t desc[CAAM_JOB_DESC_SIZE]; 178 }; 179 180 struct caam_jr_op_ctx { 181 struct job_descriptor jobdes; 182 /* sg[0] output, sg[1] input, others are possible sub frames */ 183 struct sec4_sg_entry sg[MAX_SG_ENTRIES]; 184 struct rte_crypto_op *op; 185 struct rte_mempool *ctx_pool; /* mempool pointer for caam_jr_op_ctx */ 186 int64_t vtop_offset; 187 uint8_t digest[JR_MAX_NB_MAX_DIGEST]; 188 }; 189 190 /** 191 * Checksum 192 * 193 * @param buffer calculate chksum for buffer 194 * @param len buffer length 195 * 196 * @return checksum value in host cpu order 197 */ 198 static inline uint16_t 199 calc_chksum(void *buffer, int len) 200 { 201 uint16_t *buf = (uint16_t *)buffer; 202 uint32_t sum = 0; 203 uint16_t result; 204 205 for (sum = 0; len > 1; len -= 2) 206 sum += *buf++; 207 208 if (len == 1) 209 sum += *(unsigned char *)buf; 210 211 sum = (sum >> 16) + (sum & 0xFFFF); 212 sum += (sum >> 16); 213 result = ~sum; 214 215 return result; 216 } 217 struct uio_job_ring { 218 uint32_t jr_id; 219 int uio_fd; 220 void *register_base_addr; 221 int map_size; 222 int uio_minor_number; 223 }; 224 225 int sec_cleanup(void); 226 int sec_configure(void); 227 void sec_uio_job_rings_init(void); 228 struct uio_job_ring *config_job_ring(void); 229 void free_job_ring(int uio_fd); 230 231 /* For Dma memory allocation of specified length and alignment */ 232 static inline void * 233 caam_jr_dma_mem_alloc(size_t align, size_t len) 234 { 235 return rte_malloc("mem_alloc", len, align); 236 } 237 238 /* For freeing dma memory */ 239 static inline void 240 caam_jr_dma_free(void *ptr) 241 { 242 rte_free(ptr); 243 } 244 245 static inline rte_iova_t 246 caam_jr_mem_vtop(void *vaddr) 247 { 248 const struct rte_memseg *ms; 249 250 ms = rte_mem_virt2memseg(vaddr, NULL); 251 if (ms) 252 return ms->iova + RTE_PTR_DIFF(vaddr, ms->addr); 253 return (size_t)NULL; 254 } 255 256 static inline void * 257 caam_jr_dma_ptov(rte_iova_t paddr) 258 { 259 void *va; 260 va = dpaax_iova_table_get_va(paddr); 261 if (likely(va != NULL)) 262 return va; 263 264 return rte_mem_iova2virt(paddr); 265 } 266 267 /* Virtual to physical address conversion */ 268 static inline rte_iova_t caam_jr_dma_vtop(void *ptr) 269 { 270 return caam_jr_mem_vtop(ptr); 271 } 272 273 /** @brief Request to SEC kernel driver to enable interrupts for 274 * descriptor finished processing 275 * Use UIO to communicate with SEC kernel driver: write command 276 * value that indicates an IRQ enable action into UIO file descriptor 277 * of this job ring. 278 * 279 * @param [in] uio_fd Job Ring UIO File descriptor 280 * @retval 0 for success 281 * @retval -1 value for error 282 */ 283 int caam_jr_enable_irqs(int uio_fd); 284 285 /** @brief Request to SEC kernel driver to disable interrupts for descriptor 286 * finished processing 287 * Use UIO to communicate with SEC kernel driver: write command 288 * value that indicates an IRQ disable action into UIO file descriptor 289 * of this job ring. 290 * 291 * @param [in] uio_fd UIO File descripto 292 * @retval 0 for success 293 * @retval -1 value for error 294 * 295 */ 296 int caam_jr_disable_irqs(int uio_fd); 297 298 #endif 299