Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright(c) 2015-2022 Intel Corporation
3 : : */
4 : :
5 : : #ifndef _QAT_SYM_H_
6 : : #define _QAT_SYM_H_
7 : :
8 : : #include <cryptodev_pmd.h>
9 : : #include <rte_net_crc.h>
10 : :
11 : : #ifdef BUILD_QAT_SYM
12 : : #ifdef RTE_QAT_OPENSSL
13 : : #include <openssl/evp.h>
14 : : #endif
15 : : #include <rte_security_driver.h>
16 : :
17 : : #include "qat_common.h"
18 : : #include "qat_sym_session.h"
19 : : #include "qat_crypto.h"
20 : : #include "qat_logs.h"
21 : :
22 : : #define BYTE_LENGTH 8
23 : : /* bpi is only used for partial blocks of DES and AES
24 : : * so AES block len can be assumed as max len for iv, src and dst
25 : : */
26 : : #define BPI_MAX_ENCR_IV_LEN ICP_QAT_HW_AES_BLK_SZ
27 : :
28 : : /** Intel(R) QAT Symmetric Crypto PMD name */
29 : : #define CRYPTODEV_NAME_QAT_SYM_PMD crypto_qat
30 : :
31 : : /* Internal capabilities */
32 : : #define QAT_SYM_CAP_MIXED_CRYPTO (1 << 0)
33 : : #define QAT_SYM_CAP_CIPHER_CRC (1 << 1)
34 : : #define QAT_SYM_CAP_VALID (1 << 31)
35 : :
36 : : /**
37 : : * Macro to add a sym capability
38 : : * helper function to add an sym capability
39 : : * <n: name> <b: block size> <k: key size> <d: digest size>
40 : : * <a: aad_size> <i: iv_size>
41 : : **/
42 : : #define QAT_SYM_PLAIN_AUTH_CAP(n, b, d) \
43 : : { \
44 : : .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC, \
45 : : {.sym = { \
46 : : .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH, \
47 : : {.auth = { \
48 : : .algo = RTE_CRYPTO_AUTH_##n, \
49 : : b, d \
50 : : }, } \
51 : : }, } \
52 : : }
53 : :
54 : : #define QAT_SYM_AUTH_CAP(n, b, k, d, a, i) \
55 : : { \
56 : : .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC, \
57 : : {.sym = { \
58 : : .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH, \
59 : : {.auth = { \
60 : : .algo = RTE_CRYPTO_AUTH_##n, \
61 : : b, k, d, a, i \
62 : : }, } \
63 : : }, } \
64 : : }
65 : :
66 : : #define QAT_SYM_AEAD_CAP(n, b, k, d, a, i) \
67 : : { \
68 : : .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC, \
69 : : {.sym = { \
70 : : .xform_type = RTE_CRYPTO_SYM_XFORM_AEAD, \
71 : : {.aead = { \
72 : : .algo = RTE_CRYPTO_AEAD_##n, \
73 : : b, k, d, a, i \
74 : : }, } \
75 : : }, } \
76 : : }
77 : :
78 : : #define QAT_SYM_CIPHER_CAP(n, b, k, i) \
79 : : { \
80 : : .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC, \
81 : : {.sym = { \
82 : : .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER, \
83 : : {.cipher = { \
84 : : .algo = RTE_CRYPTO_CIPHER_##n, \
85 : : b, k, i \
86 : : }, } \
87 : : }, } \
88 : : }
89 : :
90 : : /*
91 : : * Maximum number of SGL entries
92 : : */
93 : : #define QAT_SYM_SGL_MAX_NUMBER 16
94 : :
95 : : /* Maximum data length for single pass GMAC: 2^14-1 */
96 : : #define QAT_AES_GMAC_SPC_MAX_SIZE 16383
97 : :
98 : : /* Digest length for GCM Algo is 16 bytes */
99 : : #define GCM_256_DIGEST_LEN 16
100 : :
101 : : /* IV length for GCM algo is 12 bytes */
102 : : #define GCM_IV_LENGTH_GEN_LCE 12
103 : :
104 : : struct qat_sym_session;
105 : :
106 : : struct __rte_cache_aligned __rte_packed_begin qat_sym_sgl {
107 : : qat_sgl_hdr;
108 : : struct qat_flat_buf buffers[QAT_SYM_SGL_MAX_NUMBER];
109 : : } __rte_packed_end;
110 : :
111 : : struct qat_sym_op_cookie {
112 : : struct qat_sym_sgl qat_sgl_src;
113 : : struct qat_sym_sgl qat_sgl_dst;
114 : : phys_addr_t qat_sgl_src_phys_addr;
115 : : phys_addr_t qat_sgl_dst_phys_addr;
116 : : union {
117 : : /* Used for Single-Pass AES-GMAC only */
118 : : struct {
119 : : alignas(RTE_CACHE_LINE_SIZE) struct __rte_packed_begin
120 : : icp_qat_hw_cipher_algo_blk cd_cipher __rte_packed_end;
121 : : phys_addr_t cd_phys_addr;
122 : : } spc_gmac;
123 : : } opt;
124 : : uint8_t digest_null[4];
125 : : phys_addr_t digest_null_phys_addr;
126 : : enum rte_crypto_op_status status;
127 : : };
128 : :
129 : : struct qat_sym_dp_ctx {
130 : : struct qat_sym_session *session;
131 : : uint32_t tail;
132 : : uint32_t head;
133 : : uint16_t cached_enqueue;
134 : : uint16_t cached_dequeue;
135 : : };
136 : :
137 : : uint16_t
138 : : qat_sym_enqueue_burst(void *qp, struct rte_crypto_op **ops,
139 : : uint16_t nb_ops);
140 : :
141 : : uint16_t
142 : : qat_sym_dequeue_burst(void *qp, struct rte_crypto_op **ops,
143 : : uint16_t nb_ops);
144 : :
145 : : uint16_t
146 : : qat_sym_dequeue_burst_gen_lce(void *qp, struct rte_crypto_op **ops, uint16_t nb_ops);
147 : :
148 : : #ifdef RTE_QAT_OPENSSL
149 : : /** Encrypt a single partial block
150 : : * Depends on openssl libcrypto
151 : : * Uses ECB+XOR to do CFB encryption, same result, more performant
152 : : */
153 : : static inline int
154 : 0 : bpi_cipher_encrypt(uint8_t *src, uint8_t *dst,
155 : : uint8_t *iv, int ivlen, int srclen,
156 : : void *bpi_ctx)
157 : : {
158 : : EVP_CIPHER_CTX *ctx = (EVP_CIPHER_CTX *)bpi_ctx;
159 : : int encrypted_ivlen;
160 : : uint8_t encrypted_iv[BPI_MAX_ENCR_IV_LEN];
161 : : uint8_t *encr = encrypted_iv;
162 : :
163 : : /* ECB method: encrypt the IV, then XOR this with plaintext */
164 [ # # ]: 0 : if (EVP_EncryptUpdate(ctx, encrypted_iv, &encrypted_ivlen, iv, ivlen)
165 : : <= 0)
166 : 0 : goto cipher_encrypt_err;
167 : :
168 [ # # ]: 0 : for (; srclen != 0; --srclen, ++dst, ++src, ++encr)
169 : 0 : *dst = *src ^ *encr;
170 : :
171 : : return 0;
172 : :
173 : : cipher_encrypt_err:
174 : 0 : QAT_DP_LOG(ERR, "libcrypto ECB cipher encrypt failed");
175 : 0 : return -EINVAL;
176 : : }
177 : : #else
178 : : static __rte_always_inline void
179 : : bpi_cipher_ipsec(uint8_t *src, uint8_t *dst, uint8_t *iv, int srclen,
180 : : uint64_t *expkey, IMB_MGR *m, uint8_t docsis_key_len)
181 : : {
182 : : if (docsis_key_len == ICP_QAT_HW_AES_128_KEY_SZ)
183 : : IMB_AES128_CFB_ONE(m, dst, src, (uint64_t *)iv, expkey, srclen);
184 : : else if (docsis_key_len == ICP_QAT_HW_AES_256_KEY_SZ)
185 : : IMB_AES256_CFB_ONE(m, dst, src, (uint64_t *)iv, expkey, srclen);
186 : : else if (docsis_key_len == ICP_QAT_HW_DES_KEY_SZ)
187 : : des_cfb_one(dst, src, (uint64_t *)iv, expkey, srclen);
188 : : }
189 : : #endif
190 : :
191 : : static inline uint32_t
192 : 0 : qat_bpicipher_postprocess(struct qat_sym_session *ctx,
193 : : struct rte_crypto_op *op)
194 : : {
195 : 0 : int block_len = qat_cipher_get_block_size(ctx->qat_cipher_alg);
196 : : struct rte_crypto_sym_op *sym_op = op->sym;
197 [ # # ]: 0 : uint8_t last_block_len = block_len > 0 ?
198 : 0 : sym_op->cipher.data.length % block_len : 0;
199 : :
200 [ # # ]: 0 : if (last_block_len > 0 &&
201 [ # # ]: 0 : ctx->qat_dir == ICP_QAT_HW_CIPHER_ENCRYPT) {
202 : :
203 : : /* Encrypt last block */
204 : : uint8_t *last_block, *dst, *iv;
205 : : uint32_t last_block_offset;
206 : :
207 : 0 : last_block_offset = sym_op->cipher.data.offset +
208 : 0 : sym_op->cipher.data.length - last_block_len;
209 : 0 : last_block = rte_pktmbuf_mtod_offset(sym_op->m_src, uint8_t *,
210 : : last_block_offset);
211 : :
212 [ # # ]: 0 : if (unlikely(sym_op->m_dst != NULL))
213 : : /* out-of-place operation (OOP) */
214 : 0 : dst = rte_pktmbuf_mtod_offset(sym_op->m_dst,
215 : : uint8_t *,
216 : : last_block_offset);
217 : : else
218 : : dst = last_block;
219 : :
220 [ # # ]: 0 : if (last_block_len < sym_op->cipher.data.length)
221 : : /* use previous block ciphertext as IV */
222 : 0 : iv = dst - block_len;
223 : : else
224 : : /* runt block, i.e. less than one full block */
225 : 0 : iv = rte_crypto_op_ctod_offset(op, uint8_t *,
226 : : ctx->cipher_iv.offset);
227 : :
228 : : #if RTE_LOG_DP_LEVEL >= RTE_LOG_DEBUG
229 : : QAT_DP_HEXDUMP_LOG(DEBUG, "BPI: src before post-process:",
230 : : last_block, last_block_len);
231 : : if (sym_op->m_dst != NULL)
232 : : QAT_DP_HEXDUMP_LOG(DEBUG,
233 : : "BPI: dst before post-process:",
234 : : dst, last_block_len);
235 : : #endif
236 : : #ifdef RTE_QAT_OPENSSL
237 : 0 : bpi_cipher_encrypt(last_block, dst, iv, block_len,
238 : : last_block_len, ctx->bpi_ctx);
239 : : #else
240 : : bpi_cipher_ipsec(last_block, dst, iv, last_block_len, ctx->expkey,
241 : : ctx->mb_mgr, ctx->docsis_key_len);
242 : : #endif
243 : : #if RTE_LOG_DP_LEVEL >= RTE_LOG_DEBUG
244 : : QAT_DP_HEXDUMP_LOG(DEBUG, "BPI: src after post-process:",
245 : : last_block, last_block_len);
246 : : if (sym_op->m_dst != NULL)
247 : : QAT_DP_HEXDUMP_LOG(DEBUG,
248 : : "BPI: dst after post-process:",
249 : : dst, last_block_len);
250 : : #endif
251 : : }
252 : 0 : return sym_op->cipher.data.length - last_block_len;
253 : : }
254 : :
255 : : static inline void
256 : 0 : qat_crc_verify(struct qat_sym_session *ctx, struct rte_crypto_op *op)
257 : : {
258 : : struct rte_crypto_sym_op *sym_op = op->sym;
259 : : uint32_t crc_data_ofs, crc_data_len, crc;
260 : : uint8_t *crc_data;
261 : :
262 [ # # ]: 0 : if (ctx->qat_dir == ICP_QAT_HW_CIPHER_DECRYPT &&
263 [ # # ]: 0 : sym_op->auth.data.length != 0) {
264 : :
265 : 0 : crc_data_ofs = sym_op->auth.data.offset;
266 : : crc_data_len = sym_op->auth.data.length;
267 : 0 : crc_data = rte_pktmbuf_mtod_offset(sym_op->m_src, uint8_t *,
268 : : crc_data_ofs);
269 : :
270 : 0 : crc = rte_net_crc_calc(ctx->crc, crc_data, crc_data_len);
271 : :
272 [ # # ]: 0 : if (crc != *(uint32_t *)(crc_data + crc_data_len))
273 : 0 : op->status = RTE_CRYPTO_OP_STATUS_AUTH_FAILED;
274 : : }
275 : 0 : }
276 : :
277 : : static inline void
278 : 0 : qat_crc_generate(struct qat_sym_session *ctx,
279 : : struct rte_crypto_op *op)
280 : : {
281 : : struct rte_crypto_sym_op *sym_op = op->sym;
282 : : uint32_t *crc, crc_data_len;
283 : : uint8_t *crc_data;
284 : :
285 [ # # ]: 0 : if (ctx->qat_dir == ICP_QAT_HW_CIPHER_ENCRYPT &&
286 [ # # ]: 0 : sym_op->auth.data.length != 0 &&
287 [ # # ]: 0 : sym_op->m_src->nb_segs == 1) {
288 : :
289 : : crc_data_len = sym_op->auth.data.length;
290 : 0 : crc_data = rte_pktmbuf_mtod_offset(sym_op->m_src, uint8_t *,
291 : : sym_op->auth.data.offset);
292 : 0 : crc = (uint32_t *)(crc_data + crc_data_len);
293 : 0 : *crc = rte_net_crc_calc(ctx->crc, crc_data, crc_data_len);
294 : : }
295 : 0 : }
296 : :
297 : : static inline void
298 : 0 : qat_sym_preprocess_requests(void **ops, uint16_t nb_ops)
299 : : {
300 : : struct rte_crypto_op *op;
301 : : struct qat_sym_session *ctx;
302 : : uint16_t i;
303 : :
304 [ # # ]: 0 : for (i = 0; i < nb_ops; i++) {
305 : 0 : op = (struct rte_crypto_op *)ops[i];
306 : :
307 [ # # ]: 0 : if (op->sess_type == RTE_CRYPTO_OP_SECURITY_SESSION) {
308 : 0 : ctx = SECURITY_GET_SESS_PRIV(op->sym->session);
309 : :
310 : : #ifdef RTE_QAT_OPENSSL
311 [ # # ]: 0 : if (ctx == NULL || ctx->bpi_ctx == NULL)
312 : : #else
313 : : if (ctx == NULL || ctx->mb_mgr == NULL)
314 : : #endif
315 : 0 : continue;
316 : :
317 [ # # ]: 0 : if (ctx->qat_cmd != ICP_QAT_FW_LA_CMD_CIPHER_CRC)
318 : 0 : qat_crc_generate(ctx, op);
319 : : }
320 : : }
321 : 0 : }
322 : :
323 : : static __rte_always_inline int
324 : 0 : qat_sym_process_response(void **op, uint8_t *resp, void *op_cookie,
325 : : uint64_t *dequeue_err_count __rte_unused)
326 : : {
327 : : struct icp_qat_fw_comn_resp *resp_msg =
328 : : (struct icp_qat_fw_comn_resp *)resp;
329 : 0 : struct rte_crypto_op *rx_op = (struct rte_crypto_op *)(uintptr_t)
330 : 0 : (resp_msg->opaque_data);
331 : : struct qat_sym_session *sess;
332 : : uint8_t is_docsis_sec;
333 : : struct qat_sym_op_cookie *cookie = NULL;
334 : :
335 : : #if RTE_LOG_DP_LEVEL >= RTE_LOG_DEBUG
336 : : QAT_DP_HEXDUMP_LOG(DEBUG, "qat_response:", (uint8_t *)resp_msg,
337 : : sizeof(struct icp_qat_fw_comn_resp));
338 : : #endif
339 : :
340 [ # # ]: 0 : if (rx_op->sess_type == RTE_CRYPTO_OP_SECURITY_SESSION) {
341 : : /*
342 : : * Assuming at this point that if it's a security
343 : : * op, that this is for DOCSIS
344 : : */
345 : 0 : sess = SECURITY_GET_SESS_PRIV(rx_op->sym->session);
346 : : is_docsis_sec = 1;
347 : : } else {
348 : 0 : sess = CRYPTODEV_GET_SYM_SESS_PRIV(rx_op->sym->session);
349 : : is_docsis_sec = 0;
350 : : }
351 : :
352 : 0 : if (ICP_QAT_FW_COMN_STATUS_FLAG_OK !=
353 [ # # ]: 0 : ICP_QAT_FW_COMN_RESP_CRYPTO_STAT_GET(
354 : : resp_msg->comn_hdr.comn_status)) {
355 : :
356 : 0 : rx_op->status = RTE_CRYPTO_OP_STATUS_AUTH_FAILED;
357 : : } else {
358 : 0 : rx_op->status = RTE_CRYPTO_OP_STATUS_SUCCESS;
359 : :
360 : : #ifdef RTE_QAT_OPENSSL
361 [ # # ]: 0 : if (sess->bpi_ctx) {
362 : : #else
363 : : if (sess->mb_mgr) {
364 : : #endif
365 : 0 : qat_bpicipher_postprocess(sess, rx_op);
366 [ # # # # ]: 0 : if (is_docsis_sec && sess->qat_cmd !=
367 : : ICP_QAT_FW_LA_CMD_CIPHER_CRC)
368 : 0 : qat_crc_verify(sess, rx_op);
369 : : }
370 : : }
371 : :
372 [ # # ]: 0 : if (sess->is_single_pass_gmac) {
373 : : struct qat_sym_op_cookie *cookie =
374 : : (struct qat_sym_op_cookie *) op_cookie;
375 : 0 : memset(cookie->opt.spc_gmac.cd_cipher.key, 0,
376 : 0 : sess->auth_key_length);
377 : : }
378 : :
379 : : cookie = (struct qat_sym_op_cookie *) op_cookie;
380 [ # # ]: 0 : if (cookie->status == RTE_CRYPTO_OP_STATUS_INVALID_ARGS) {
381 : 0 : rx_op->status = cookie->status;
382 : 0 : cookie->status = 0;
383 : : }
384 : :
385 : 0 : *op = (void *)rx_op;
386 : :
387 : : /*
388 : : * return 1 as dequeue op only move on to the next op
389 : : * if one was ready to return to API
390 : : */
391 : 0 : return 1;
392 : : }
393 : :
394 : : static __rte_always_inline int
395 : 0 : qat_sym_process_response_gen_lce(void **op, uint8_t *resp, void *op_cookie __rte_unused,
396 : : uint64_t *dequeue_err_count __rte_unused)
397 : : {
398 : : struct icp_qat_fw_comn_resp *resp_msg = (struct icp_qat_fw_comn_resp *)resp;
399 : 0 : struct rte_crypto_op *rx_op = (struct rte_crypto_op *)(uintptr_t) (resp_msg->opaque_data);
400 : : struct qat_sym_session *sess;
401 : :
402 : : #if RTE_LOG_DP_LEVEL >= RTE_LOG_DEBUG
403 : : QAT_DP_HEXDUMP_LOG(DEBUG, "qat_response:", (uint8_t *)resp_msg,
404 : : sizeof(struct icp_qat_fw_comn_resp));
405 : : #endif
406 : :
407 : 0 : sess = CRYPTODEV_GET_SYM_SESS_PRIV(rx_op->sym->session);
408 : :
409 : 0 : rx_op->status = RTE_CRYPTO_OP_STATUS_SUCCESS;
410 : :
411 [ # # ]: 0 : if (ICP_QAT_FW_COMN_STATUS_FLAG_OK != ICP_QAT_FW_COMN_RESP_UNSUPPORTED_REQUEST_STAT_GET(
412 : : resp_msg->comn_hdr.comn_status))
413 : 0 : rx_op->status = RTE_CRYPTO_OP_STATUS_NOT_PROCESSED;
414 : :
415 [ # # ]: 0 : else if (ICP_QAT_FW_COMN_STATUS_FLAG_OK != ICP_QAT_FW_COMN_RESP_INVALID_PARAM_STAT_GET(
416 : : resp_msg->comn_hdr.comn_status))
417 : 0 : rx_op->status = RTE_CRYPTO_OP_STATUS_INVALID_ARGS;
418 : :
419 [ # # ]: 0 : if (sess->qat_dir == ICP_QAT_HW_CIPHER_DECRYPT) {
420 [ # # ]: 0 : if (ICP_QAT_FW_LA_VER_STATUS_FAIL == ICP_QAT_FW_COMN_RESP_CRYPTO_STAT_GET(
421 : : resp_msg->comn_hdr.comn_status))
422 : 0 : rx_op->status = RTE_CRYPTO_OP_STATUS_AUTH_FAILED;
423 : : }
424 : :
425 : 0 : *op = (void *)rx_op;
426 : :
427 : : /*
428 : : * return 1 as dequeue op only move on to the next op
429 : : * if one was ready to return to API
430 : : */
431 : 0 : return 1;
432 : : }
433 : :
434 : : int
435 : : qat_sym_configure_dp_ctx(struct rte_cryptodev *dev, uint16_t qp_id,
436 : : struct rte_crypto_raw_dp_ctx *raw_dp_ctx,
437 : : enum rte_crypto_op_sess_type sess_type,
438 : : union rte_cryptodev_session_ctx session_ctx, uint8_t is_update);
439 : :
440 : : int
441 : : qat_sym_get_dp_ctx_size(struct rte_cryptodev *dev);
442 : :
443 : : void
444 : : qat_sym_init_op_cookie(void *cookie);
445 : :
446 : : #if RTE_LOG_DP_LEVEL >= RTE_LOG_DEBUG
447 : : static __rte_always_inline void
448 : : qat_sym_debug_log_dump(struct icp_qat_fw_la_bulk_req *qat_req,
449 : : struct qat_sym_session *ctx,
450 : : struct rte_crypto_vec *vec, uint32_t vec_len,
451 : : struct rte_crypto_va_iova_ptr *cipher_iv,
452 : : struct rte_crypto_va_iova_ptr *auth_iv,
453 : : struct rte_crypto_va_iova_ptr *aad,
454 : : struct rte_crypto_va_iova_ptr *digest)
455 : : {
456 : : uint32_t i;
457 : :
458 : : QAT_DP_HEXDUMP_LOG(DEBUG, "qat_req:", qat_req,
459 : : sizeof(struct icp_qat_fw_la_bulk_req));
460 : : for (i = 0; i < vec_len; i++)
461 : : QAT_DP_HEXDUMP_LOG(DEBUG, "src_data:", vec[i].base, vec[i].len);
462 : : if (cipher_iv && ctx->cipher_iv.length > 0)
463 : : QAT_DP_HEXDUMP_LOG(DEBUG, "cipher iv:", cipher_iv->va,
464 : : ctx->cipher_iv.length);
465 : : if (auth_iv && ctx->auth_iv.length > 0)
466 : : QAT_DP_HEXDUMP_LOG(DEBUG, "auth iv:", auth_iv->va,
467 : : ctx->auth_iv.length);
468 : : if (aad && ctx->aad_len > 0)
469 : : QAT_DP_HEXDUMP_LOG(DEBUG, "aad:", aad->va,
470 : : ctx->aad_len);
471 : : if (digest && ctx->digest_length > 0)
472 : : QAT_DP_HEXDUMP_LOG(DEBUG, "digest:", digest->va,
473 : : ctx->digest_length);
474 : : }
475 : : #else
476 : : static __rte_always_inline void
477 : : qat_sym_debug_log_dump(struct icp_qat_fw_la_bulk_req *qat_req __rte_unused,
478 : : struct qat_sym_session *ctx __rte_unused,
479 : : struct rte_crypto_vec *vec __rte_unused,
480 : : uint32_t vec_len __rte_unused,
481 : : struct rte_crypto_va_iova_ptr *cipher_iv __rte_unused,
482 : : struct rte_crypto_va_iova_ptr *auth_iv __rte_unused,
483 : : struct rte_crypto_va_iova_ptr *aad __rte_unused,
484 : : struct rte_crypto_va_iova_ptr *digest __rte_unused)
485 : : {
486 : : }
487 : : #endif
488 : :
489 : : #else
490 : :
491 : : static inline void
492 : : qat_sym_preprocess_requests(void **ops __rte_unused,
493 : : uint16_t nb_ops __rte_unused)
494 : : {
495 : : }
496 : :
497 : : static inline void
498 : : qat_sym_process_response(void **op __rte_unused, uint8_t *resp __rte_unused,
499 : : void *op_cookie __rte_unused, uint64_t *dequeue_err_count __rte_unused)
500 : : {
501 : : }
502 : :
503 : : static inline void
504 : : qat_sym_process_response_gen_lce(void **op __rte_unused, uint8_t *resp __rte_unused,
505 : : void *op_cookie __rte_unused, uint64_t *dequeue_err_count __rte_unused)
506 : : {
507 : : }
508 : :
509 : : #endif /* BUILD_QAT_SYM */
510 : : #endif /* _QAT_SYM_H_ */
|