crypto/qat: support AES-CCM
[dpdk.git] / drivers / crypto / qat / qat_crypto_capabilities.h
1 /*-
2  *   BSD LICENSE
3  *
4  *   Copyright(c) 2017 Intel Corporation. All rights reserved.
5  *   All rights reserved.
6  *
7  *   Redistribution and use in source and binary forms, with or without
8  *   modification, are permitted provided that the following conditions
9  *   are met:
10  *
11  *     * Redistributions of source code must retain the above copyright
12  *       notice, this list of conditions and the following disclaimer.
13  *     * Redistributions in binary form must reproduce the above copyright
14  *       notice, this list of conditions and the following disclaimer in
15  *       the documentation and/or other materials provided with the
16  *       distribution.
17  *     * Neither the name of Intel Corporation nor the names of its
18  *       contributors may be used to endorse or promote products derived
19  *       from this software without specific prior written permission.
20  *
21  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32  */
33
34 #ifndef _QAT_CRYPTO_CAPABILITIES_H_
35 #define _QAT_CRYPTO_CAPABILITIES_H_
36
37 #define QAT_BASE_GEN1_SYM_CAPABILITIES                                  \
38         {       /* SHA1 HMAC */                                         \
39                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
40                 {.sym = {                                               \
41                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
42                         {.auth = {                                      \
43                                 .algo = RTE_CRYPTO_AUTH_SHA1_HMAC,      \
44                                 .block_size = 64,                       \
45                                 .key_size = {                           \
46                                         .min = 1,                       \
47                                         .max = 64,                      \
48                                         .increment = 1                  \
49                                 },                                      \
50                                 .digest_size = {                        \
51                                         .min = 20,                      \
52                                         .max = 20,                      \
53                                         .increment = 0                  \
54                                 },                                      \
55                                 .iv_size = { 0 }                        \
56                         }, }                                            \
57                 }, }                                                    \
58         },                                                              \
59         {       /* SHA224 HMAC */                                       \
60                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
61                 {.sym = {                                               \
62                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
63                         {.auth = {                                      \
64                                 .algo = RTE_CRYPTO_AUTH_SHA224_HMAC,    \
65                                 .block_size = 64,                       \
66                                 .key_size = {                           \
67                                         .min = 1,                       \
68                                         .max = 64,                      \
69                                         .increment = 1                  \
70                                 },                                      \
71                                 .digest_size = {                        \
72                                         .min = 28,                      \
73                                         .max = 28,                      \
74                                         .increment = 0                  \
75                                 },                                      \
76                                 .iv_size = { 0 }                        \
77                         }, }                                            \
78                 }, }                                                    \
79         },                                                              \
80         {       /* SHA256 HMAC */                                       \
81                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
82                 {.sym = {                                               \
83                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
84                         {.auth = {                                      \
85                                 .algo = RTE_CRYPTO_AUTH_SHA256_HMAC,    \
86                                 .block_size = 64,                       \
87                                 .key_size = {                           \
88                                         .min = 1,                       \
89                                         .max = 64,                      \
90                                         .increment = 1                  \
91                                 },                                      \
92                                 .digest_size = {                        \
93                                         .min = 32,                      \
94                                         .max = 32,                      \
95                                         .increment = 0                  \
96                                 },                                      \
97                                 .iv_size = { 0 }                        \
98                         }, }                                            \
99                 }, }                                                    \
100         },                                                              \
101         {       /* SHA384 HMAC */                                       \
102                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
103                 {.sym = {                                               \
104                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
105                         {.auth = {                                      \
106                                 .algo = RTE_CRYPTO_AUTH_SHA384_HMAC,    \
107                                 .block_size = 128,                      \
108                                 .key_size = {                           \
109                                         .min = 1,                       \
110                                         .max = 128,                     \
111                                         .increment = 1                  \
112                                 },                                      \
113                                 .digest_size = {                        \
114                                         .min = 48,                      \
115                                         .max = 48,                      \
116                                         .increment = 0                  \
117                                 },                                      \
118                                 .iv_size = { 0 }                        \
119                         }, }                                            \
120                 }, }                                                    \
121         },                                                              \
122         {       /* SHA512 HMAC */                                       \
123                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
124                 {.sym = {                                               \
125                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
126                         {.auth = {                                      \
127                                 .algo = RTE_CRYPTO_AUTH_SHA512_HMAC,    \
128                                 .block_size = 128,                      \
129                                 .key_size = {                           \
130                                         .min = 1,                       \
131                                         .max = 128,                     \
132                                         .increment = 1                  \
133                                 },                                      \
134                                 .digest_size = {                        \
135                                         .min = 64,                      \
136                                         .max = 64,                      \
137                                         .increment = 0                  \
138                                 },                                      \
139                                 .iv_size = { 0 }                        \
140                         }, }                                            \
141                 }, }                                                    \
142         },                                                              \
143         {       /* MD5 HMAC */                                          \
144                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
145                 {.sym = {                                               \
146                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
147                         {.auth = {                                      \
148                                 .algo = RTE_CRYPTO_AUTH_MD5_HMAC,       \
149                                 .block_size = 64,                       \
150                                 .key_size = {                           \
151                                         .min = 1,                       \
152                                         .max = 64,                      \
153                                         .increment = 1                  \
154                                 },                                      \
155                                 .digest_size = {                        \
156                                         .min = 16,                      \
157                                         .max = 16,                      \
158                                         .increment = 0                  \
159                                 },                                      \
160                                 .iv_size = { 0 }                        \
161                         }, }                                            \
162                 }, }                                                    \
163         },                                                              \
164         {       /* AES XCBC MAC */                                      \
165                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
166                 {.sym = {                                               \
167                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
168                         {.auth = {                                      \
169                                 .algo = RTE_CRYPTO_AUTH_AES_XCBC_MAC,   \
170                                 .block_size = 16,                       \
171                                 .key_size = {                           \
172                                         .min = 16,                      \
173                                         .max = 16,                      \
174                                         .increment = 0                  \
175                                 },                                      \
176                                 .digest_size = {                        \
177                                         .min = 16,                      \
178                                         .max = 16,                      \
179                                         .increment = 0                  \
180                                 },                                      \
181                                 .aad_size = { 0 },                      \
182                                 .iv_size = { 0 }                        \
183                         }, }                                            \
184                 }, }                                                    \
185         },                                                              \
186         {       /* AES CCM */                                           \
187                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
188                 {.sym = {                                               \
189                         .xform_type = RTE_CRYPTO_SYM_XFORM_AEAD,        \
190                         {.aead = {                                      \
191                                 .algo = RTE_CRYPTO_AEAD_AES_CCM,        \
192                                 .block_size = 16,                       \
193                                 .key_size = {                           \
194                                         .min = 16,                      \
195                                         .max = 16,                      \
196                                         .increment = 0                  \
197                                 },                                      \
198                                 .digest_size = {                        \
199                                         .min = 4,                       \
200                                         .max = 16,                      \
201                                         .increment = 2                  \
202                                 },                                      \
203                                 .aad_size = {                           \
204                                         .min = 0,                       \
205                                         .max = 224,                     \
206                                         .increment = 1                  \
207                                 },                                      \
208                                 .iv_size = {                            \
209                                         .min = 7,                       \
210                                         .max = 13,                      \
211                                         .increment = 1                  \
212                                 },                                      \
213                         }, }                                            \
214                 }, }                                                    \
215         },                                                              \
216         {       /* AES GCM */                                           \
217                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
218                 {.sym = {                                               \
219                         .xform_type = RTE_CRYPTO_SYM_XFORM_AEAD,        \
220                         {.aead = {                                      \
221                                 .algo = RTE_CRYPTO_AEAD_AES_GCM,        \
222                                 .block_size = 16,                       \
223                                 .key_size = {                           \
224                                         .min = 16,                      \
225                                         .max = 32,                      \
226                                         .increment = 8                  \
227                                 },                                      \
228                                 .digest_size = {                        \
229                                         .min = 8,                       \
230                                         .max = 16,                      \
231                                         .increment = 4                  \
232                                 },                                      \
233                                 .aad_size = {                           \
234                                         .min = 0,                       \
235                                         .max = 240,                     \
236                                         .increment = 1                  \
237                                 },                                      \
238                                 .iv_size = {                            \
239                                         .min = 12,                      \
240                                         .max = 12,                      \
241                                         .increment = 0                  \
242                                 },                                      \
243                         }, }                                            \
244                 }, }                                                    \
245         },                                                              \
246         {       /* AES GMAC (AUTH) */                                   \
247                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
248                 {.sym = {                                               \
249                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
250                         {.auth = {                                      \
251                                 .algo = RTE_CRYPTO_AUTH_AES_GMAC,       \
252                                 .block_size = 16,                       \
253                                 .key_size = {                           \
254                                         .min = 16,                      \
255                                         .max = 32,                      \
256                                         .increment = 8                  \
257                                 },                                      \
258                                 .digest_size = {                        \
259                                         .min = 8,                       \
260                                         .max = 16,                      \
261                                         .increment = 4                  \
262                                 },                                      \
263                                 .iv_size = {                            \
264                                         .min = 12,                      \
265                                         .max = 12,                      \
266                                         .increment = 0                  \
267                                 }                                       \
268                         }, }                                            \
269                 }, }                                                    \
270         },                                                              \
271         {       /* SNOW 3G (UIA2) */                                    \
272                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
273                 {.sym = {                                               \
274                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
275                         {.auth = {                                      \
276                                 .algo = RTE_CRYPTO_AUTH_SNOW3G_UIA2,    \
277                                 .block_size = 16,                       \
278                                 .key_size = {                           \
279                                         .min = 16,                      \
280                                         .max = 16,                      \
281                                         .increment = 0                  \
282                                 },                                      \
283                                 .digest_size = {                        \
284                                         .min = 4,                       \
285                                         .max = 4,                       \
286                                         .increment = 0                  \
287                                 },                                      \
288                                 .iv_size = {                            \
289                                         .min = 16,                      \
290                                         .max = 16,                      \
291                                         .increment = 0                  \
292                                 }                                       \
293                         }, }                                            \
294                 }, }                                                    \
295         },                                                              \
296         {       /* AES CBC */                                           \
297                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
298                 {.sym = {                                               \
299                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
300                         {.cipher = {                                    \
301                                 .algo = RTE_CRYPTO_CIPHER_AES_CBC,      \
302                                 .block_size = 16,                       \
303                                 .key_size = {                           \
304                                         .min = 16,                      \
305                                         .max = 32,                      \
306                                         .increment = 8                  \
307                                 },                                      \
308                                 .iv_size = {                            \
309                                         .min = 16,                      \
310                                         .max = 16,                      \
311                                         .increment = 0                  \
312                                 }                                       \
313                         }, }                                            \
314                 }, }                                                    \
315         },                                                              \
316         {       /* AES DOCSIS BPI */                                    \
317                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
318                 {.sym = {                                               \
319                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
320                         {.cipher = {                                    \
321                                 .algo = RTE_CRYPTO_CIPHER_AES_DOCSISBPI,\
322                                 .block_size = 16,                       \
323                                 .key_size = {                           \
324                                         .min = 16,                      \
325                                         .max = 16,                      \
326                                         .increment = 0                  \
327                                 },                                      \
328                                 .iv_size = {                            \
329                                         .min = 16,                      \
330                                         .max = 16,                      \
331                                         .increment = 0                  \
332                                 }                                       \
333                         }, }                                            \
334                 }, }                                                    \
335         },                                                              \
336         {       /* SNOW 3G (UEA2) */                                    \
337                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
338                 {.sym = {                                               \
339                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
340                         {.cipher = {                                    \
341                                 .algo = RTE_CRYPTO_CIPHER_SNOW3G_UEA2,  \
342                                 .block_size = 16,                       \
343                                 .key_size = {                           \
344                                         .min = 16,                      \
345                                         .max = 16,                      \
346                                         .increment = 0                  \
347                                 },                                      \
348                                 .iv_size = {                            \
349                                         .min = 16,                      \
350                                         .max = 16,                      \
351                                         .increment = 0                  \
352                                 }                                       \
353                         }, }                                            \
354                 }, }                                                    \
355         },                                                              \
356         {       /* AES CTR */                                           \
357                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
358                 {.sym = {                                               \
359                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
360                         {.cipher = {                                    \
361                                 .algo = RTE_CRYPTO_CIPHER_AES_CTR,      \
362                                 .block_size = 16,                       \
363                                 .key_size = {                           \
364                                         .min = 16,                      \
365                                         .max = 32,                      \
366                                         .increment = 8                  \
367                                 },                                      \
368                                 .iv_size = {                            \
369                                         .min = 16,                      \
370                                         .max = 16,                      \
371                                         .increment = 0                  \
372                                 }                                       \
373                         }, }                                            \
374                 }, }                                                    \
375         },                                                              \
376         {       /* NULL (AUTH) */                                       \
377                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
378                 {.sym = {                                               \
379                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
380                         {.auth = {                                      \
381                                 .algo = RTE_CRYPTO_AUTH_NULL,           \
382                                 .block_size = 1,                        \
383                                 .key_size = {                           \
384                                         .min = 0,                       \
385                                         .max = 0,                       \
386                                         .increment = 0                  \
387                                 },                                      \
388                                 .digest_size = {                        \
389                                         .min = 0,                       \
390                                         .max = 0,                       \
391                                         .increment = 0                  \
392                                 },                                      \
393                                 .iv_size = { 0 }                        \
394                         }, },                                           \
395                 }, },                                                   \
396         },                                                              \
397         {       /* NULL (CIPHER) */                                     \
398                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
399                 {.sym = {                                               \
400                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
401                         {.cipher = {                                    \
402                                 .algo = RTE_CRYPTO_CIPHER_NULL,         \
403                                 .block_size = 1,                        \
404                                 .key_size = {                           \
405                                         .min = 0,                       \
406                                         .max = 0,                       \
407                                         .increment = 0                  \
408                                 },                                      \
409                                 .iv_size = {                            \
410                                         .min = 0,                       \
411                                         .max = 0,                       \
412                                         .increment = 0                  \
413                                 }                                       \
414                         }, },                                           \
415                 }, }                                                    \
416         },                                                              \
417         {       /* KASUMI (F8) */                                       \
418                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
419                 {.sym = {                                               \
420                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
421                         {.cipher = {                                    \
422                                 .algo = RTE_CRYPTO_CIPHER_KASUMI_F8,    \
423                                 .block_size = 8,                        \
424                                 .key_size = {                           \
425                                         .min = 16,                      \
426                                         .max = 16,                      \
427                                         .increment = 0                  \
428                                 },                                      \
429                                 .iv_size = {                            \
430                                         .min = 8,                       \
431                                         .max = 8,                       \
432                                         .increment = 0                  \
433                                 }                                       \
434                         }, }                                            \
435                 }, }                                                    \
436         },                                                              \
437         {       /* KASUMI (F9) */                                       \
438                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
439                 {.sym = {                                               \
440                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
441                         {.auth = {                                      \
442                                 .algo = RTE_CRYPTO_AUTH_KASUMI_F9,      \
443                                 .block_size = 8,                        \
444                                 .key_size = {                           \
445                                         .min = 16,                      \
446                                         .max = 16,                      \
447                                         .increment = 0                  \
448                                 },                                      \
449                                 .digest_size = {                        \
450                                         .min = 4,                       \
451                                         .max = 4,                       \
452                                         .increment = 0                  \
453                                 },                                      \
454                                 .iv_size = { 0 }                        \
455                         }, }                                            \
456                 }, }                                                    \
457         },                                                              \
458         {       /* 3DES CBC */                                          \
459                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
460                 {.sym = {                                               \
461                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
462                         {.cipher = {                                    \
463                                 .algo = RTE_CRYPTO_CIPHER_3DES_CBC,     \
464                                 .block_size = 8,                        \
465                                 .key_size = {                           \
466                                         .min = 16,                      \
467                                         .max = 24,                      \
468                                         .increment = 8                  \
469                                 },                                      \
470                                 .iv_size = {                            \
471                                         .min = 8,                       \
472                                         .max = 8,                       \
473                                         .increment = 0                  \
474                                 }                                       \
475                         }, }                                            \
476                 }, }                                                    \
477         },                                                              \
478         {       /* 3DES CTR */                                          \
479                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
480                 {.sym = {                                               \
481                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
482                         {.cipher = {                                    \
483                                 .algo = RTE_CRYPTO_CIPHER_3DES_CTR,     \
484                                 .block_size = 8,                        \
485                                 .key_size = {                           \
486                                         .min = 16,                      \
487                                         .max = 24,                      \
488                                         .increment = 8                  \
489                                 },                                      \
490                                 .iv_size = {                            \
491                                         .min = 8,                       \
492                                         .max = 8,                       \
493                                         .increment = 0                  \
494                                 }                                       \
495                         }, }                                            \
496                 }, }                                                    \
497         },                                                              \
498         {       /* DES CBC */                                           \
499                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
500                 {.sym = {                                               \
501                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
502                         {.cipher = {                                    \
503                                 .algo = RTE_CRYPTO_CIPHER_DES_CBC,      \
504                                 .block_size = 8,                        \
505                                 .key_size = {                           \
506                                         .min = 8,                       \
507                                         .max = 8,                       \
508                                         .increment = 0                  \
509                                 },                                      \
510                                 .iv_size = {                            \
511                                         .min = 8,                       \
512                                         .max = 8,                       \
513                                         .increment = 0                  \
514                                 }                                       \
515                         }, }                                            \
516                 }, }                                                    \
517         },                                                              \
518         {       /* DES DOCSISBPI */                                     \
519                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
520                 {.sym = {                                               \
521                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
522                         {.cipher = {                                    \
523                                 .algo = RTE_CRYPTO_CIPHER_DES_DOCSISBPI,\
524                                 .block_size = 8,                        \
525                                 .key_size = {                           \
526                                         .min = 8,                       \
527                                         .max = 8,                       \
528                                         .increment = 0                  \
529                                 },                                      \
530                                 .iv_size = {                            \
531                                         .min = 8,                       \
532                                         .max = 8,                       \
533                                         .increment = 0                  \
534                                 }                                       \
535                         }, }                                            \
536                 }, }                                                    \
537         }
538
539 #define QAT_EXTRA_GEN2_SYM_CAPABILITIES                                 \
540         {       /* ZUC (EEA3) */                                        \
541                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
542                 {.sym = {                                               \
543                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,      \
544                         {.cipher = {                                    \
545                                 .algo = RTE_CRYPTO_CIPHER_ZUC_EEA3,     \
546                                 .block_size = 16,                       \
547                                 .key_size = {                           \
548                                         .min = 16,                      \
549                                         .max = 16,                      \
550                                         .increment = 0                  \
551                                 },                                      \
552                                 .iv_size = {                            \
553                                         .min = 16,                      \
554                                         .max = 16,                      \
555                                         .increment = 0                  \
556                                 }                                       \
557                         }, }                                            \
558                 }, }                                                    \
559         },                                                              \
560         {       /* ZUC (EIA3) */                                        \
561                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,                     \
562                 {.sym = {                                               \
563                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,        \
564                         {.auth = {                                      \
565                                 .algo = RTE_CRYPTO_AUTH_ZUC_EIA3,       \
566                                 .block_size = 16,                       \
567                                 .key_size = {                           \
568                                         .min = 16,                      \
569                                         .max = 16,                      \
570                                         .increment = 0                  \
571                                 },                                      \
572                                 .digest_size = {                        \
573                                         .min = 4,                       \
574                                         .max = 4,                       \
575                                         .increment = 0                  \
576                                 },                                      \
577                                 .iv_size = {                            \
578                                         .min = 16,                      \
579                                         .max = 16,                      \
580                                         .increment = 0                  \
581                                 }                                       \
582                         }, }                                            \
583                 }, }                                                    \
584         }
585
586 #endif /* _QAT_CRYPTO_CAPABILITIES_H_ */