net/bnxt: check access denied for HWRM commands
[dpdk.git] / drivers / crypto / ccp / ccp_pmd_ops.c
1 /*   SPDX-License-Identifier: BSD-3-Clause
2  *   Copyright(c) 2018 Advanced Micro Devices, Inc. All rights reserved.
3  */
4
5 #include <string.h>
6
7 #include <rte_common.h>
8 #include <rte_cryptodev_pmd.h>
9 #include <rte_malloc.h>
10
11 #include "ccp_pmd_private.h"
12 #include "ccp_dev.h"
13 #include "ccp_crypto.h"
14
15 #define CCP_BASE_SYM_CRYPTO_CAPABILITIES                                \
16         {       /* SHA1 */                                              \
17                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
18                 {.sym = {                                               \
19                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
20                         {.auth = {                                      \
21                                  .algo = RTE_CRYPTO_AUTH_SHA1,          \
22                                  .block_size = 64,                      \
23                                  .key_size = {                          \
24                                          .min = 0,                      \
25                                          .max = 0,                      \
26                                          .increment = 0                 \
27                                  },                                     \
28                                  .digest_size = {                       \
29                                          .min = 20,                     \
30                                          .max = 20,                     \
31                                          .increment = 0                 \
32                                  },                                     \
33                                  .aad_size = { 0 }                      \
34                          }, }                                           \
35                 }, }                                                    \
36         },                                                              \
37         {       /* SHA1 HMAC */                                         \
38                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
39                 {.sym = {                                               \
40                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
41                         {.auth = {                                      \
42                                  .algo = RTE_CRYPTO_AUTH_SHA1_HMAC,     \
43                                  .block_size = 64,                      \
44                                  .key_size = {                          \
45                                          .min = 1,                      \
46                                          .max = 64,                     \
47                                          .increment = 1                 \
48                                  },                                     \
49                                  .digest_size = {                       \
50                                          .min = 20,                     \
51                                          .max = 20,                     \
52                                          .increment = 0                 \
53                                  },                                     \
54                                  .aad_size = { 0 }                      \
55                          }, }                                           \
56                 }, }                                                    \
57         },                                                              \
58         {       /* SHA224 */                                            \
59                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
60                 {.sym = {                                               \
61                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
62                         {.auth = {                                      \
63                                  .algo = RTE_CRYPTO_AUTH_SHA224,        \
64                                  .block_size = 64,                      \
65                                  .key_size = {                          \
66                                          .min = 0,                      \
67                                          .max = 0,                      \
68                                          .increment = 0                 \
69                                  },                                     \
70                                  .digest_size = {                       \
71                                          .min = 28,                     \
72                                          .max = 28,                     \
73                                          .increment = 0                 \
74                                  },                                     \
75                                  .aad_size = { 0 }                      \
76                          }, }                                           \
77                 }, }                                                    \
78         },                                                              \
79         {       /* SHA224 HMAC */                                       \
80                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
81                 {.sym = {                                               \
82                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
83                         {.auth = {                                      \
84                                  .algo = RTE_CRYPTO_AUTH_SHA224_HMAC,   \
85                                  .block_size = 64,                      \
86                                  .key_size = {                          \
87                                          .min = 1,                      \
88                                          .max = 64,                     \
89                                          .increment = 1                 \
90                                  },                                     \
91                                  .digest_size = {                       \
92                                          .min = 28,                     \
93                                          .max = 28,                     \
94                                          .increment = 0                 \
95                                  },                                     \
96                                  .aad_size = { 0 }                      \
97                          }, }                                           \
98                 }, }                                                    \
99         },                                                              \
100         {       /* SHA3-224 */                                          \
101                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
102                 {.sym = {                                               \
103                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
104                         {.auth = {                                      \
105                                  .algo = RTE_CRYPTO_AUTH_SHA3_224,      \
106                                  .block_size = 144,                     \
107                                  .key_size = {                          \
108                                          .min = 0,                      \
109                                          .max = 0,                      \
110                                          .increment = 0                 \
111                                  },                                     \
112                                  .digest_size = {                       \
113                                          .min = 28,                     \
114                                          .max = 28,                     \
115                                          .increment = 0                 \
116                                  },                                     \
117                                  .aad_size = { 0 }                      \
118                          }, }                                           \
119                 }, }                                                    \
120         },                                                              \
121         {       /* SHA3-224  HMAC*/                                     \
122                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
123                 {.sym = {                                               \
124                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
125                         {.auth = {                                      \
126                                  .algo = RTE_CRYPTO_AUTH_SHA3_224_HMAC, \
127                                  .block_size = 144,                     \
128                                  .key_size = {                          \
129                                          .min = 1,                      \
130                                          .max = 144,                    \
131                                          .increment = 1                 \
132                                  },                                     \
133                                  .digest_size = {                       \
134                                          .min = 28,                     \
135                                          .max = 28,                     \
136                                          .increment = 0                 \
137                                  },                                     \
138                                  .aad_size = { 0 }                      \
139                          }, }                                           \
140                 }, }                                                    \
141         },                                                              \
142         {       /* SHA256 */                                            \
143                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
144                 {.sym = {                                               \
145                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
146                         {.auth = {                                      \
147                                  .algo = RTE_CRYPTO_AUTH_SHA256,        \
148                                  .block_size = 64,                      \
149                                  .key_size = {                          \
150                                          .min = 0,                      \
151                                          .max = 0,                      \
152                                          .increment = 0                 \
153                                  },                                     \
154                                  .digest_size = {                       \
155                                          .min = 32,                     \
156                                          .max = 32,                     \
157                                          .increment = 0                 \
158                                  },                                     \
159                                  .aad_size = { 0 }                      \
160                          }, }                                           \
161                 }, }                                                    \
162         },                                                              \
163         {       /* SHA256 HMAC */                                       \
164                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
165                 {.sym = {                                               \
166                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
167                         {.auth = {                                      \
168                                  .algo = RTE_CRYPTO_AUTH_SHA256_HMAC,   \
169                                  .block_size = 64,                      \
170                                  .key_size = {                          \
171                                          .min = 1,                      \
172                                          .max = 64,                     \
173                                          .increment = 1                 \
174                                  },                                     \
175                                  .digest_size = {                       \
176                                          .min = 32,                     \
177                                          .max = 32,                     \
178                                          .increment = 0                 \
179                                  },                                     \
180                                  .aad_size = { 0 }                      \
181                          }, }                                           \
182                 }, }                                                    \
183         },                                                              \
184         {       /* SHA3-256 */                                          \
185                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
186                 {.sym = {                                               \
187                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
188                         {.auth = {                                      \
189                                  .algo = RTE_CRYPTO_AUTH_SHA3_256,      \
190                                  .block_size = 136,                     \
191                                  .key_size = {                          \
192                                          .min = 0,                      \
193                                          .max = 0,                      \
194                                          .increment = 0                 \
195                                  },                                     \
196                                  .digest_size = {                       \
197                                          .min = 32,                     \
198                                          .max = 32,                     \
199                                          .increment = 0                 \
200                                  },                                     \
201                                  .aad_size = { 0 }                      \
202                          }, }                                           \
203                 }, }                                                    \
204         },                                                              \
205         {       /* SHA3-256-HMAC */                                     \
206                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
207                 {.sym = {                                               \
208                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
209                         {.auth = {                                      \
210                                  .algo = RTE_CRYPTO_AUTH_SHA3_256_HMAC, \
211                                  .block_size = 136,                     \
212                                  .key_size = {                          \
213                                          .min = 1,                      \
214                                          .max = 136,                    \
215                                          .increment = 1                 \
216                                  },                                     \
217                                  .digest_size = {                       \
218                                          .min = 32,                     \
219                                          .max = 32,                     \
220                                          .increment = 0                 \
221                                  },                                     \
222                                  .aad_size = { 0 }                      \
223                          }, }                                           \
224                 }, }                                                    \
225         },                                                              \
226         {       /* SHA384 */                                            \
227                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
228                 {.sym = {                                               \
229                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
230                         {.auth = {                                      \
231                                  .algo = RTE_CRYPTO_AUTH_SHA384,        \
232                                  .block_size = 128,                     \
233                                  .key_size = {                          \
234                                          .min = 0,                      \
235                                          .max = 0,                      \
236                                          .increment = 0                 \
237                                  },                                     \
238                                  .digest_size = {                       \
239                                          .min = 48,                     \
240                                          .max = 48,                     \
241                                          .increment = 0                 \
242                                  },                                     \
243                                  .aad_size = { 0 }                      \
244                          }, }                                           \
245                 }, }                                                    \
246         },                                                              \
247         {       /* SHA384 HMAC */                                       \
248                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
249                 {.sym = {                                               \
250                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
251                         {.auth = {                                      \
252                                  .algo = RTE_CRYPTO_AUTH_SHA384_HMAC,   \
253                                  .block_size = 128,                     \
254                                  .key_size = {                          \
255                                          .min = 1,                      \
256                                          .max = 128,                    \
257                                          .increment = 1                 \
258                                  },                                     \
259                                  .digest_size = {                       \
260                                          .min = 48,                     \
261                                          .max = 48,                     \
262                                          .increment = 0                 \
263                                  },                                     \
264                                  .aad_size = { 0 }                      \
265                          }, }                                           \
266                 }, }                                                    \
267         },                                                              \
268         {       /* SHA3-384 */                                          \
269                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
270                 {.sym = {                                               \
271                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
272                         {.auth = {                                      \
273                                  .algo = RTE_CRYPTO_AUTH_SHA3_384,      \
274                                  .block_size = 104,                     \
275                                  .key_size = {                          \
276                                          .min = 0,                      \
277                                          .max = 0,                      \
278                                          .increment = 0                 \
279                                  },                                     \
280                                  .digest_size = {                       \
281                                          .min = 48,                     \
282                                          .max = 48,                     \
283                                          .increment = 0                 \
284                                  },                                     \
285                                  .aad_size = { 0 }                      \
286                          }, }                                           \
287                 }, }                                                    \
288         },                                                              \
289         {       /* SHA3-384-HMAC */                                     \
290                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
291                 {.sym = {                                               \
292                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
293                         {.auth = {                                      \
294                                  .algo = RTE_CRYPTO_AUTH_SHA3_384_HMAC, \
295                                  .block_size = 104,                     \
296                                  .key_size = {                          \
297                                          .min = 1,                      \
298                                          .max = 104,                    \
299                                          .increment = 1                 \
300                                  },                                     \
301                                  .digest_size = {                       \
302                                          .min = 48,                     \
303                                          .max = 48,                     \
304                                          .increment = 0                 \
305                                  },                                     \
306                                  .aad_size = { 0 }                      \
307                          }, }                                           \
308                 }, }                                                    \
309         },                                                              \
310         {       /* SHA512  */                                           \
311                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
312                 {.sym = {                                               \
313                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
314                         {.auth = {                                      \
315                                  .algo = RTE_CRYPTO_AUTH_SHA512,        \
316                                  .block_size = 128,                     \
317                                  .key_size = {                          \
318                                          .min = 0,                      \
319                                          .max = 0,                      \
320                                          .increment = 0                 \
321                                  },                                     \
322                                  .digest_size = {                       \
323                                          .min = 64,                     \
324                                          .max = 64,                     \
325                                          .increment = 0                 \
326                                  },                                     \
327                                  .aad_size = { 0 }                      \
328                          }, }                                           \
329                 }, }                                                    \
330         },                                                              \
331         {       /* SHA512 HMAC */                                       \
332                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
333                 {.sym = {                                               \
334                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
335                         {.auth = {                                      \
336                                  .algo = RTE_CRYPTO_AUTH_SHA512_HMAC,   \
337                                  .block_size = 128,                     \
338                                  .key_size = {                          \
339                                          .min = 1,                      \
340                                          .max = 128,                    \
341                                          .increment = 1                 \
342                                  },                                     \
343                                  .digest_size = {                       \
344                                          .min = 64,                     \
345                                          .max = 64,                     \
346                                          .increment = 0                 \
347                                  },                                     \
348                                  .aad_size = { 0 }                      \
349                          }, }                                           \
350                 }, }                                                    \
351         },                                                              \
352         {       /* SHA3-512  */                                         \
353                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
354                 {.sym = {                                               \
355                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
356                         {.auth = {                                      \
357                                  .algo = RTE_CRYPTO_AUTH_SHA3_512,      \
358                                  .block_size = 72,                      \
359                                  .key_size = {                          \
360                                          .min = 0,                      \
361                                          .max = 0,                      \
362                                          .increment = 0                 \
363                                  },                                     \
364                                  .digest_size = {                       \
365                                          .min = 64,                     \
366                                          .max = 64,                     \
367                                          .increment = 0                 \
368                                  },                                     \
369                                  .aad_size = { 0 }                      \
370                          }, }                                           \
371                 }, }                                                    \
372         },                                                              \
373         {       /* SHA3-512-HMAC  */                                    \
374                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
375                 {.sym = {                                               \
376                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
377                         {.auth = {                                      \
378                                  .algo = RTE_CRYPTO_AUTH_SHA3_512_HMAC, \
379                                  .block_size = 72,                      \
380                                  .key_size = {                          \
381                                          .min = 1,                      \
382                                          .max = 72,                     \
383                                          .increment = 1                 \
384                                  },                                     \
385                                  .digest_size = {                       \
386                                          .min = 64,                     \
387                                          .max = 64,                     \
388                                          .increment = 0                 \
389                                  },                                     \
390                                  .aad_size = { 0 }                      \
391                         }, }                                            \
392                 }, }                                                    \
393         },                                                              \
394         {       /*AES-CMAC */                                           \
395                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
396                 {.sym = {                                               \
397                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
398                         {.auth = {                                      \
399                                  .algo = RTE_CRYPTO_AUTH_AES_CMAC,      \
400                                  .block_size = 16,                      \
401                                  .key_size = {                          \
402                                          .min = 16,                     \
403                                          .max = 32,                     \
404                                          .increment = 8                 \
405                                  },                                     \
406                                  .digest_size = {                       \
407                                          .min = 16,                     \
408                                          .max = 16,                     \
409                                          .increment = 0                 \
410                                  },                                     \
411                         }, }                                            \
412                 }, }                                                    \
413         },                                                              \
414         {       /* AES ECB */                                           \
415                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
416                 {.sym = {                                               \
417                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
418                         {.cipher = {                                    \
419                                 .algo = RTE_CRYPTO_CIPHER_AES_ECB,      \
420                                 .block_size = 16,                       \
421                                 .key_size = {                           \
422                                    .min = 16,                           \
423                                    .max = 32,                           \
424                                    .increment = 8                       \
425                                 },                                      \
426                                 .iv_size = {                            \
427                                    .min = 0,                            \
428                                    .max = 0,                            \
429                                    .increment = 0                       \
430                                 }                                       \
431                         }, }                                            \
432                 }, }                                                    \
433         },                                                              \
434         {       /* AES CBC */                                           \
435                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
436                 {.sym = {                                               \
437                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
438                         {.cipher = {                                    \
439                                 .algo = RTE_CRYPTO_CIPHER_AES_CBC,      \
440                                 .block_size = 16,                       \
441                                 .key_size = {                           \
442                                         .min = 16,                      \
443                                         .max = 32,                      \
444                                         .increment = 8                  \
445                                 },                                      \
446                                 .iv_size = {                            \
447                                         .min = 16,                      \
448                                         .max = 16,                      \
449                                         .increment = 0                  \
450                                 }                                       \
451                         }, }                                            \
452                 }, }                                                    \
453         },                                                              \
454         {       /* AES CTR */                                           \
455                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
456                 {.sym = {                                               \
457                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
458                         {.cipher = {                                    \
459                                 .algo = RTE_CRYPTO_CIPHER_AES_CTR,      \
460                                 .block_size = 16,                       \
461                                 .key_size = {                           \
462                                         .min = 16,                      \
463                                         .max = 32,                      \
464                                         .increment = 8                  \
465                                 },                                      \
466                                 .iv_size = {                            \
467                                         .min = 16,                      \
468                                         .max = 16,                      \
469                                         .increment = 0                  \
470                                 }                                       \
471                         }, }                                            \
472                 }, }                                                    \
473         },                                                              \
474         {       /* 3DES CBC */                                          \
475                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
476                 {.sym = {                                               \
477                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
478                         {.cipher = {                                    \
479                                 .algo = RTE_CRYPTO_CIPHER_3DES_CBC,     \
480                                 .block_size = 8,                        \
481                                 .key_size = {                           \
482                                         .min = 16,                      \
483                                         .max = 24,                      \
484                                         .increment = 8                  \
485                                 },                                      \
486                                 .iv_size = {                            \
487                                         .min = 8,                       \
488                                         .max = 8,                       \
489                                         .increment = 0                  \
490                                 }                                       \
491                         }, }                                            \
492                 }, }                                                    \
493         },                                                              \
494         {       /* AES GCM */                                           \
495                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
496                 {.sym = {                                               \
497                         .xform_type = RTE_CRYPTO_SYM_XFORM_AEAD,        \
498                         {.aead = {                                      \
499                                  .algo = RTE_CRYPTO_AEAD_AES_GCM,       \
500                                  .block_size = 16,                      \
501                                  .key_size = {                          \
502                                          .min = 16,                     \
503                                          .max = 32,                     \
504                                          .increment = 8                 \
505                                  },                                     \
506                                  .digest_size = {                       \
507                                          .min = 16,                     \
508                                          .max = 16,                     \
509                                          .increment = 0                 \
510                                  },                                     \
511                                  .aad_size = {                          \
512                                          .min = 0,                      \
513                                          .max = 65535,                  \
514                                          .increment = 1                 \
515                                  },                                     \
516                                  .iv_size = {                           \
517                                          .min = 12,                     \
518                                          .max = 16,                     \
519                                          .increment = 4                 \
520                                  },                                     \
521                         }, }                                            \
522                 }, }                                                    \
523         }
524
525 #define CCP_EXTRA_SYM_CRYPTO_CAPABILITIES                               \
526         {       /* MD5 HMAC */                                          \
527                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
528                 {.sym = {                                               \
529                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
530                         {.auth = {                                      \
531                                  .algo = RTE_CRYPTO_AUTH_MD5_HMAC,      \
532                                  .block_size = 64,                      \
533                                  .key_size = {                          \
534                                          .min = 1,                      \
535                                          .max = 64,                     \
536                                          .increment = 1                 \
537                                  },                                     \
538                                  .digest_size = {                       \
539                                          .min = 16,                     \
540                                          .max = 16,                     \
541                                          .increment = 0                 \
542                                  },                                     \
543                                  .aad_size = { 0 }                      \
544                         }, }                                            \
545                 }, }                                                    \
546         }
547
548 static const struct rte_cryptodev_capabilities ccp_crypto_cap[] = {
549         CCP_BASE_SYM_CRYPTO_CAPABILITIES,
550         RTE_CRYPTODEV_END_OF_CAPABILITIES_LIST()
551 };
552
553 static const struct rte_cryptodev_capabilities ccp_crypto_cap_complete[] = {
554         CCP_EXTRA_SYM_CRYPTO_CAPABILITIES,
555         CCP_BASE_SYM_CRYPTO_CAPABILITIES,
556         RTE_CRYPTODEV_END_OF_CAPABILITIES_LIST()
557 };
558
559 static int
560 ccp_pmd_config(struct rte_cryptodev *dev __rte_unused,
561                struct rte_cryptodev_config *config __rte_unused)
562 {
563         return 0;
564 }
565
566 static int
567 ccp_pmd_start(struct rte_cryptodev *dev)
568 {
569         return ccp_dev_start(dev);
570 }
571
572 static void
573 ccp_pmd_stop(struct rte_cryptodev *dev __rte_unused)
574 {
575
576 }
577
578 static int
579 ccp_pmd_close(struct rte_cryptodev *dev __rte_unused)
580 {
581         return 0;
582 }
583
584 static void
585 ccp_pmd_stats_get(struct rte_cryptodev *dev,
586                   struct rte_cryptodev_stats *stats)
587 {
588         int qp_id;
589
590         for (qp_id = 0; qp_id < dev->data->nb_queue_pairs; qp_id++) {
591                 struct ccp_qp *qp = dev->data->queue_pairs[qp_id];
592
593                 stats->enqueued_count += qp->qp_stats.enqueued_count;
594                 stats->dequeued_count += qp->qp_stats.dequeued_count;
595
596                 stats->enqueue_err_count += qp->qp_stats.enqueue_err_count;
597                 stats->dequeue_err_count += qp->qp_stats.dequeue_err_count;
598         }
599
600 }
601
602 static void
603 ccp_pmd_stats_reset(struct rte_cryptodev *dev)
604 {
605         int qp_id;
606
607         for (qp_id = 0; qp_id < dev->data->nb_queue_pairs; qp_id++) {
608                 struct ccp_qp *qp = dev->data->queue_pairs[qp_id];
609
610                 memset(&qp->qp_stats, 0, sizeof(qp->qp_stats));
611         }
612 }
613
614 static void
615 ccp_pmd_info_get(struct rte_cryptodev *dev,
616                  struct rte_cryptodev_info *dev_info)
617 {
618         struct ccp_private *internals = dev->data->dev_private;
619
620         if (dev_info != NULL) {
621                 dev_info->driver_id = dev->driver_id;
622                 dev_info->feature_flags = dev->feature_flags;
623                 dev_info->capabilities = ccp_crypto_cap;
624                 if (internals->auth_opt == 1)
625                         dev_info->capabilities = ccp_crypto_cap_complete;
626                 dev_info->max_nb_queue_pairs = internals->max_nb_qpairs;
627                 /* No limit of number of sessions */
628                 dev_info->sym.max_nb_sessions = 0;
629         }
630 }
631
632 static int
633 ccp_pmd_qp_release(struct rte_cryptodev *dev, uint16_t qp_id)
634 {
635         struct ccp_qp *qp;
636
637         if (dev->data->queue_pairs[qp_id] != NULL) {
638                 qp = (struct ccp_qp *)dev->data->queue_pairs[qp_id];
639                 rte_ring_free(qp->processed_pkts);
640                 rte_mempool_free(qp->batch_mp);
641                 rte_free(qp);
642                 dev->data->queue_pairs[qp_id] = NULL;
643         }
644         return 0;
645 }
646
647 static int
648 ccp_pmd_qp_set_unique_name(struct rte_cryptodev *dev,
649                 struct ccp_qp *qp)
650 {
651         unsigned int n = snprintf(qp->name, sizeof(qp->name),
652                         "ccp_pmd_%u_qp_%u",
653                         dev->data->dev_id, qp->id);
654
655         if (n > sizeof(qp->name))
656                 return -1;
657
658         return 0;
659 }
660
661 static struct rte_ring *
662 ccp_pmd_qp_create_batch_info_ring(struct ccp_qp *qp,
663                                   unsigned int ring_size, int socket_id)
664 {
665         struct rte_ring *r;
666
667         r = rte_ring_lookup(qp->name);
668         if (r) {
669                 if (r->size >= ring_size) {
670                         CCP_LOG_INFO(
671                                 "Reusing ring %s for processed packets",
672                                 qp->name);
673                         return r;
674                 }
675                 CCP_LOG_INFO(
676                         "Unable to reuse ring %s for processed packets",
677                          qp->name);
678                 return NULL;
679         }
680
681         return rte_ring_create(qp->name, ring_size, socket_id,
682                         RING_F_SP_ENQ | RING_F_SC_DEQ);
683 }
684
685 static int
686 ccp_pmd_qp_setup(struct rte_cryptodev *dev, uint16_t qp_id,
687                  const struct rte_cryptodev_qp_conf *qp_conf,
688                  int socket_id, struct rte_mempool *session_pool)
689 {
690         struct ccp_private *internals = dev->data->dev_private;
691         struct ccp_qp *qp;
692         int retval = 0;
693
694         if (qp_id >= internals->max_nb_qpairs) {
695                 CCP_LOG_ERR("Invalid qp_id %u, should be less than %u",
696                             qp_id, internals->max_nb_qpairs);
697                 return (-EINVAL);
698         }
699
700         /* Free memory prior to re-allocation if needed. */
701         if (dev->data->queue_pairs[qp_id] != NULL)
702                 ccp_pmd_qp_release(dev, qp_id);
703
704         /* Allocate the queue pair data structure. */
705         qp = rte_zmalloc_socket("CCP Crypto PMD Queue Pair", sizeof(*qp),
706                                         RTE_CACHE_LINE_SIZE, socket_id);
707         if (qp == NULL) {
708                 CCP_LOG_ERR("Failed to allocate queue pair memory");
709                 return (-ENOMEM);
710         }
711
712         qp->dev = dev;
713         qp->id = qp_id;
714         dev->data->queue_pairs[qp_id] = qp;
715
716         retval = ccp_pmd_qp_set_unique_name(dev, qp);
717         if (retval) {
718                 CCP_LOG_ERR("Failed to create unique name for ccp qp");
719                 goto qp_setup_cleanup;
720         }
721
722         qp->processed_pkts = ccp_pmd_qp_create_batch_info_ring(qp,
723                         qp_conf->nb_descriptors, socket_id);
724         if (qp->processed_pkts == NULL) {
725                 CCP_LOG_ERR("Failed to create batch info ring");
726                 goto qp_setup_cleanup;
727         }
728
729         qp->sess_mp = session_pool;
730
731         /* mempool for batch info */
732         qp->batch_mp = rte_mempool_create(
733                                 qp->name,
734                                 qp_conf->nb_descriptors,
735                                 sizeof(struct ccp_batch_info),
736                                 RTE_CACHE_LINE_SIZE,
737                                 0, NULL, NULL, NULL, NULL,
738                                 SOCKET_ID_ANY, 0);
739         if (qp->batch_mp == NULL)
740                 goto qp_setup_cleanup;
741         memset(&qp->qp_stats, 0, sizeof(qp->qp_stats));
742         return 0;
743
744 qp_setup_cleanup:
745         dev->data->queue_pairs[qp_id] = NULL;
746         if (qp)
747                 rte_free(qp);
748         return -1;
749 }
750
751 static uint32_t
752 ccp_pmd_qp_count(struct rte_cryptodev *dev)
753 {
754         return dev->data->nb_queue_pairs;
755 }
756
757 static unsigned
758 ccp_pmd_sym_session_get_size(struct rte_cryptodev *dev __rte_unused)
759 {
760         return sizeof(struct ccp_session);
761 }
762
763 static int
764 ccp_pmd_sym_session_configure(struct rte_cryptodev *dev,
765                           struct rte_crypto_sym_xform *xform,
766                           struct rte_cryptodev_sym_session *sess,
767                           struct rte_mempool *mempool)
768 {
769         int ret;
770         void *sess_private_data;
771         struct ccp_private *internals;
772
773         if (unlikely(sess == NULL || xform == NULL)) {
774                 CCP_LOG_ERR("Invalid session struct or xform");
775                 return -ENOMEM;
776         }
777
778         if (rte_mempool_get(mempool, &sess_private_data)) {
779                 CCP_LOG_ERR("Couldn't get object from session mempool");
780                 return -ENOMEM;
781         }
782         internals = (struct ccp_private *)dev->data->dev_private;
783         ret = ccp_set_session_parameters(sess_private_data, xform, internals);
784         if (ret != 0) {
785                 CCP_LOG_ERR("failed configure session parameters");
786
787                 /* Return session to mempool */
788                 rte_mempool_put(mempool, sess_private_data);
789                 return ret;
790         }
791         set_sym_session_private_data(sess, dev->driver_id,
792                                  sess_private_data);
793
794         return 0;
795 }
796
797 static void
798 ccp_pmd_sym_session_clear(struct rte_cryptodev *dev,
799                       struct rte_cryptodev_sym_session *sess)
800 {
801         uint8_t index = dev->driver_id;
802         void *sess_priv = get_sym_session_private_data(sess, index);
803
804         if (sess_priv) {
805                 struct rte_mempool *sess_mp = rte_mempool_from_obj(sess_priv);
806
807                 rte_mempool_put(sess_mp, sess_priv);
808                 memset(sess_priv, 0, sizeof(struct ccp_session));
809                 set_sym_session_private_data(sess, index, NULL);
810         }
811 }
812
813 struct rte_cryptodev_ops ccp_ops = {
814                 .dev_configure          = ccp_pmd_config,
815                 .dev_start              = ccp_pmd_start,
816                 .dev_stop               = ccp_pmd_stop,
817                 .dev_close              = ccp_pmd_close,
818
819                 .stats_get              = ccp_pmd_stats_get,
820                 .stats_reset            = ccp_pmd_stats_reset,
821
822                 .dev_infos_get          = ccp_pmd_info_get,
823
824                 .queue_pair_setup       = ccp_pmd_qp_setup,
825                 .queue_pair_release     = ccp_pmd_qp_release,
826                 .queue_pair_count       = ccp_pmd_qp_count,
827
828                 .sym_session_get_size   = ccp_pmd_sym_session_get_size,
829                 .sym_session_configure  = ccp_pmd_sym_session_configure,
830                 .sym_session_clear      = ccp_pmd_sym_session_clear,
831 };
832
833 struct rte_cryptodev_ops *ccp_pmd_ops = &ccp_ops;