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