1 /* SPDX-License-Identifier: BSD-3-Clause */
2 /* Copyright(c) 2007-2022 Intel Corporation */
3 /**
4 *****************************************************************************
5 * @file dc_dp.c
6 *
7 * @defgroup cpaDcDp Data Compression Data Plane API
8 *
9 * @ingroup cpaDcDp
10 *
11 * @description
12 * Implementation of the Data Compression DP operations.
13 *
14 *****************************************************************************/
15
16 /*
17 *******************************************************************************
18 * Include public/global header files
19 *******************************************************************************
20 */
21 #include "cpa.h"
22 #include "cpa_dc.h"
23 #include "cpa_dc_dp.h"
24
25 #include "icp_qat_fw_comp.h"
26
27 /*
28 *******************************************************************************
29 * Include private header files
30 *******************************************************************************
31 */
32 #include "dc_session.h"
33 #include "dc_datapath.h"
34 #include "lac_common.h"
35 #include "lac_mem.h"
36 #include "lac_mem_pools.h"
37 #include "sal_types_compression.h"
38 #include "lac_sal.h"
39 #include "lac_sync.h"
40 #include "sal_service_state.h"
41 #include "sal_qat_cmn_msg.h"
42 #include "icp_sal_poll.h"
43 #include "sal_hw_gen.h"
44
45 /**
46 *****************************************************************************
47 * @ingroup cpaDcDp
48 * Check that pOpData is valid
49 *
50 * @description
51 * Check that all the parameters defined in the pOpData are valid
52 *
53 * @param[in] pOpData Pointer to a structure containing the
54 * request parameters
55 *
56 * @retval CPA_STATUS_SUCCESS Function executed successfully
57 * @retval CPA_STATUS_INVALID_PARAM Invalid parameter passed in
58 *
59 *****************************************************************************/
60 static CpaStatus
dcDataPlaneParamCheck(const CpaDcDpOpData * pOpData)61 dcDataPlaneParamCheck(const CpaDcDpOpData *pOpData)
62 {
63 sal_compression_service_t *pService = NULL;
64 dc_session_desc_t *pSessionDesc = NULL;
65
66 LAC_CHECK_NULL_PARAM(pOpData);
67 LAC_CHECK_NULL_PARAM(pOpData->dcInstance);
68 LAC_CHECK_NULL_PARAM(pOpData->pSessionHandle);
69
70 /* Ensure this is a compression instance */
71 SAL_CHECK_INSTANCE_TYPE(pOpData->dcInstance,
72 SAL_SERVICE_TYPE_COMPRESSION);
73
74 pService = (sal_compression_service_t *)(pOpData->dcInstance);
75
76 pSessionDesc = DC_SESSION_DESC_FROM_CTX_GET(pOpData->pSessionHandle);
77 if (NULL == pSessionDesc) {
78 QAT_UTILS_LOG("Session handle not as expected.\n");
79 return CPA_STATUS_INVALID_PARAM;
80 }
81
82 if (CPA_FALSE == pSessionDesc->isDcDp) {
83 QAT_UTILS_LOG("The session type should be data plane.\n");
84 return CPA_STATUS_INVALID_PARAM;
85 }
86
87 /* Compressing zero byte is not supported */
88 if ((CPA_DC_DIR_COMPRESS == pSessionDesc->sessDirection) &&
89 (0 == pOpData->bufferLenToCompress)) {
90 QAT_UTILS_LOG("The source buffer length to compress needs to "
91 "be greater than zero byte.\n");
92 return CPA_STATUS_INVALID_PARAM;
93 }
94
95 if (pOpData->sessDirection > CPA_DC_DIR_DECOMPRESS) {
96 QAT_UTILS_LOG("Invalid direction of operation.\n");
97 return CPA_STATUS_INVALID_PARAM;
98 }
99
100 if (0 == pOpData->srcBuffer) {
101 QAT_UTILS_LOG("Invalid srcBuffer\n");
102 return CPA_STATUS_INVALID_PARAM;
103 }
104 if (0 == pOpData->destBuffer) {
105 QAT_UTILS_LOG("Invalid destBuffer\n");
106 return CPA_STATUS_INVALID_PARAM;
107 }
108 if (pOpData->srcBuffer == pOpData->destBuffer) {
109 QAT_UTILS_LOG("In place operation is not supported.\n");
110 return CPA_STATUS_INVALID_PARAM;
111 }
112 if (0 == pOpData->thisPhys) {
113 QAT_UTILS_LOG("Invalid thisPhys\n");
114 return CPA_STATUS_INVALID_PARAM;
115 }
116
117 if ((CPA_TRUE != pOpData->compressAndVerify) &&
118 (CPA_FALSE != pOpData->compressAndVerify)) {
119 QAT_UTILS_LOG("Invalid compressAndVerify\n");
120 return CPA_STATUS_INVALID_PARAM;
121 }
122 if ((CPA_TRUE == pOpData->compressAndVerify) &&
123 !(pService->generic_service_info.dcExtendedFeatures &
124 DC_CNV_EXTENDED_CAPABILITY)) {
125 QAT_UTILS_LOG("Invalid compressAndVerify, no CNV capability\n");
126 return CPA_STATUS_UNSUPPORTED;
127 }
128 if ((CPA_TRUE != pOpData->compressAndVerifyAndRecover) &&
129 (CPA_FALSE != pOpData->compressAndVerifyAndRecover)) {
130 QAT_UTILS_LOG("Invalid compressAndVerifyAndRecover\n");
131 return CPA_STATUS_INVALID_PARAM;
132 }
133 if ((CPA_TRUE == pOpData->compressAndVerifyAndRecover) &&
134 (CPA_FALSE == pOpData->compressAndVerify)) {
135 QAT_UTILS_LOG("CnVnR option set without setting CnV\n");
136 return CPA_STATUS_INVALID_PARAM;
137 }
138 if ((CPA_TRUE == pOpData->compressAndVerifyAndRecover) &&
139 !(pService->generic_service_info.dcExtendedFeatures &
140 DC_CNVNR_EXTENDED_CAPABILITY)) {
141 QAT_UTILS_LOG(
142 "Invalid CnVnR option set and no CnVnR capability.\n");
143 return CPA_STATUS_UNSUPPORTED;
144 }
145
146 if ((CPA_DP_BUFLIST == pOpData->srcBufferLen) &&
147 (CPA_DP_BUFLIST != pOpData->destBufferLen)) {
148 QAT_UTILS_LOG(
149 "The source and destination buffers need to be of the same type (both flat buffers or buffer lists).\n");
150 return CPA_STATUS_INVALID_PARAM;
151 }
152 if ((CPA_DP_BUFLIST != pOpData->srcBufferLen) &&
153 (CPA_DP_BUFLIST == pOpData->destBufferLen)) {
154 QAT_UTILS_LOG(
155 "The source and destination buffers need to be of the same type (both flat buffers or buffer lists).\n");
156 return CPA_STATUS_INVALID_PARAM;
157 }
158
159 if (CPA_DP_BUFLIST != pOpData->srcBufferLen) {
160 if (pOpData->srcBufferLen < pOpData->bufferLenToCompress) {
161 QAT_UTILS_LOG(
162 "srcBufferLen is smaller than bufferLenToCompress.\n");
163 return CPA_STATUS_INVALID_PARAM;
164 }
165
166 if (pOpData->destBufferLen < pOpData->bufferLenForData) {
167 QAT_UTILS_LOG(
168 "destBufferLen is smaller than bufferLenForData.\n");
169 return CPA_STATUS_INVALID_PARAM;
170 }
171 } else {
172 /* We are assuming that there is enough memory in the source and
173 * destination buffer lists. We only receive physical addresses
174 * of the buffers so we are unable to test it here */
175 LAC_CHECK_8_BYTE_ALIGNMENT(pOpData->srcBuffer);
176 LAC_CHECK_8_BYTE_ALIGNMENT(pOpData->destBuffer);
177 }
178
179 LAC_CHECK_8_BYTE_ALIGNMENT(pOpData->thisPhys);
180
181 if ((CPA_DC_DIR_COMPRESS == pSessionDesc->sessDirection) ||
182 (CPA_DC_DIR_COMBINED == pSessionDesc->sessDirection)) {
183 if (CPA_DC_HT_FULL_DYNAMIC == pSessionDesc->huffType) {
184 /* Check if Intermediate Buffer Array pointer is NULL */
185 if (isDcGen2x(pService) &&
186 ((0 == pService->pInterBuffPtrsArrayPhyAddr) ||
187 (NULL == pService->pInterBuffPtrsArray))) {
188 QAT_UTILS_LOG(
189 "No intermediate buffer defined for this instance - see cpaDcStartInstance.\n");
190 return CPA_STATUS_INVALID_PARAM;
191 }
192
193 /* Ensure that the destination buffer length for data is
194 * greater
195 * or equal to 128B */
196 if (pOpData->bufferLenForData <
197 DC_DEST_BUFFER_DYN_MIN_SIZE) {
198 QAT_UTILS_LOG(
199 "Destination buffer length for data should be greater or equal to 128B.\n");
200 return CPA_STATUS_INVALID_PARAM;
201 }
202 } else {
203 /* Ensure that the destination buffer length for data is
204 * greater
205 * or equal to min output buffsize */
206 if (pOpData->bufferLenForData <
207 pService->comp_device_data.minOutputBuffSize) {
208 QAT_UTILS_LOG(
209 "Destination buffer size should be greater or equal to %d bytes.\n",
210 pService->comp_device_data
211 .minOutputBuffSize);
212 return CPA_STATUS_INVALID_PARAM;
213 }
214 }
215 }
216
217 return CPA_STATUS_SUCCESS;
218 }
219
220 /**
221 *****************************************************************************
222 * @ingroup cpaDcDp
223 * Partial-read parameters validation utility.
224 *
225 * @description
226 * Basic check that all partial-read related parameters provided by
227 * caller are valid.
228 *
229 * @param[in] pOpData Pointer to a structure containing the
230 * request parameters
231 * @param[in] pPartReadData Pointer to a structure containing the
232 * partial-read request parameters.
233 *
234 * @retval CPA_STATUS_SUCCESS Function executed successfully
235 * @retval CPA_STATUS_INVALID_PARAM Invalid parameter passed in
236 *
237 *****************************************************************************/
238 static CpaStatus
dcDataPlanePartReadCheck(CpaDcDpOpData * pOpData,CpaDcDpPartialReadData * pPartReadData)239 dcDataPlanePartReadCheck(CpaDcDpOpData *pOpData,
240 CpaDcDpPartialReadData *pPartReadData)
241 {
242 sal_compression_service_t *pService = NULL;
243
244 LAC_CHECK_NULL_PARAM(pPartReadData);
245
246 pService = (sal_compression_service_t *)(pOpData->dcInstance);
247
248 if (!isDcGen4x(pService)) {
249 /* Extended features are not supported prior Gen4 */
250 return CPA_STATUS_UNSUPPORTED;
251 }
252
253 if (pOpData->sessDirection == CPA_DC_DIR_COMPRESS) {
254 /* Decompression specific feature */
255 return CPA_STATUS_INVALID_PARAM;
256 }
257
258 if (pPartReadData->length > pOpData->bufferLenForData) {
259 QAT_UTILS_LOG(
260 "Partial read data length can not be greater than the destination buffer size\n");
261 return CPA_STATUS_INVALID_PARAM;
262 }
263
264 return CPA_STATUS_SUCCESS;
265 }
266
267 /**
268 *****************************************************************************
269 * @ingroup cpaDcDp
270 * Zero-padding parameters validation utility.
271 *
272 * @description
273 * Basic check that all zero-padding related parameters provided by
274 * caller are valid.
275 *
276 * @param[in] pOpData Pointer to a structure containing the
277 * request parameters.
278 *
279 * @retval CPA_STATUS_SUCCESS Function executed successfully
280 * @retval CPA_STATUS_INVALID_PARAM Invalid parameter passed in
281 * @retval CPA_STATUS_NOT_SUPPORTED Feature not supported
282 *
283 *****************************************************************************/
284 static CpaStatus
dcDataPlaneZeroPadCheck(CpaDcDpOpData * pOpData)285 dcDataPlaneZeroPadCheck(CpaDcDpOpData *pOpData)
286 {
287 sal_compression_service_t *pService = NULL;
288
289 pService = (sal_compression_service_t *)(pOpData->dcInstance);
290
291 if (!isDcGen4x(pService)) {
292 /* Extended features are not supported prior Gen4 */
293 return CPA_STATUS_UNSUPPORTED;
294 }
295
296 if (pOpData->sessDirection == CPA_DC_DIR_DECOMPRESS) {
297 /* Compression specific feature */
298 return CPA_STATUS_INVALID_PARAM;
299 }
300
301 return CPA_STATUS_SUCCESS;
302 }
303 CpaStatus
cpaDcDpGetSessionSize(CpaInstanceHandle dcInstance,CpaDcSessionSetupData * pSessionData,Cpa32U * pSessionSize)304 cpaDcDpGetSessionSize(CpaInstanceHandle dcInstance,
305 CpaDcSessionSetupData *pSessionData,
306 Cpa32U *pSessionSize)
307 {
308 return dcGetSessionSize(dcInstance, pSessionData, pSessionSize, NULL);
309 }
310
311 CpaStatus
cpaDcDpInitSession(CpaInstanceHandle dcInstance,CpaDcSessionHandle pSessionHandle,CpaDcSessionSetupData * pSessionData)312 cpaDcDpInitSession(CpaInstanceHandle dcInstance,
313 CpaDcSessionHandle pSessionHandle,
314 CpaDcSessionSetupData *pSessionData)
315 {
316 CpaStatus status = CPA_STATUS_SUCCESS;
317 dc_session_desc_t *pSessionDesc = NULL;
318 sal_compression_service_t *pService = NULL;
319
320 LAC_CHECK_INSTANCE_HANDLE(dcInstance);
321 SAL_CHECK_INSTANCE_TYPE(dcInstance, SAL_SERVICE_TYPE_COMPRESSION);
322
323 pService = (sal_compression_service_t *)dcInstance;
324
325 /* Check if SAL is initialised otherwise return an error */
326 SAL_RUNNING_CHECK(pService);
327
328 /* Stateful is not supported */
329 if (CPA_DC_STATELESS != pSessionData->sessState) {
330 QAT_UTILS_LOG("Invalid sessState value\n");
331 return CPA_STATUS_INVALID_PARAM;
332 }
333
334 status =
335 dcInitSession(dcInstance, pSessionHandle, pSessionData, NULL, NULL);
336 if (CPA_STATUS_SUCCESS == status) {
337 pSessionDesc = DC_SESSION_DESC_FROM_CTX_GET(pSessionHandle);
338 pSessionDesc->isDcDp = CPA_TRUE;
339
340 ICP_QAT_FW_COMN_PTR_TYPE_SET(
341 pSessionDesc->reqCacheDecomp.comn_hdr.comn_req_flags,
342 DC_DP_QAT_PTR_TYPE);
343 ICP_QAT_FW_COMN_PTR_TYPE_SET(
344 pSessionDesc->reqCacheComp.comn_hdr.comn_req_flags,
345 DC_DP_QAT_PTR_TYPE);
346 }
347
348 return status;
349 }
350
351 CpaStatus
cpaDcDpRemoveSession(const CpaInstanceHandle dcInstance,CpaDcSessionHandle pSessionHandle)352 cpaDcDpRemoveSession(const CpaInstanceHandle dcInstance,
353 CpaDcSessionHandle pSessionHandle)
354 {
355 return cpaDcRemoveSession(dcInstance, pSessionHandle);
356 }
357
358 CpaStatus
cpaDcDpUpdateSession(const CpaInstanceHandle dcInstance,CpaDcSessionHandle pSessionHandle,CpaDcSessionUpdateData * pUpdateSessionData)359 cpaDcDpUpdateSession(const CpaInstanceHandle dcInstance,
360 CpaDcSessionHandle pSessionHandle,
361 CpaDcSessionUpdateData *pUpdateSessionData)
362 {
363 return CPA_STATUS_UNSUPPORTED;
364 }
365
366 CpaStatus
cpaDcDpRegCbFunc(const CpaInstanceHandle dcInstance,const CpaDcDpCallbackFn pNewCb)367 cpaDcDpRegCbFunc(const CpaInstanceHandle dcInstance,
368 const CpaDcDpCallbackFn pNewCb)
369 {
370 sal_compression_service_t *pService = NULL;
371
372 LAC_CHECK_NULL_PARAM(dcInstance);
373 SAL_CHECK_INSTANCE_TYPE(dcInstance, SAL_SERVICE_TYPE_COMPRESSION);
374 LAC_CHECK_NULL_PARAM(pNewCb);
375
376 /* Check if SAL is initialised otherwise return an error */
377 SAL_RUNNING_CHECK(dcInstance);
378
379 pService = (sal_compression_service_t *)dcInstance;
380 pService->pDcDpCb = pNewCb;
381
382 return CPA_STATUS_SUCCESS;
383 }
384
385 /**
386 *****************************************************************************
387 * @ingroup cpaDcDp
388 *
389 * @description
390 * Writes the message to the ring
391 *
392 * @param[in] pOpData Pointer to a structure containing the
393 * request parameters
394 * @param[in] pCurrentQatMsg Pointer to current QAT message on the ring
395 *
396 *****************************************************************************/
397 static void
dcDpWriteRingMsg(CpaDcDpOpData * pOpData,icp_qat_fw_comp_req_t * pCurrentQatMsg)398 dcDpWriteRingMsg(CpaDcDpOpData *pOpData, icp_qat_fw_comp_req_t *pCurrentQatMsg)
399 {
400 icp_qat_fw_comp_req_t *pReqCache = NULL;
401 dc_session_desc_t *pSessionDesc = NULL;
402 Cpa8U bufferFormat;
403
404 Cpa8U cnvDecompReq = ICP_QAT_FW_COMP_NO_CNV;
405 Cpa8U cnvnrCompReq = ICP_QAT_FW_COMP_NO_CNV_RECOVERY;
406 CpaBoolean cnvErrorInjection = ICP_QAT_FW_COMP_NO_CNV_DFX;
407 sal_compression_service_t *pService = NULL;
408
409 pService = (sal_compression_service_t *)(pOpData->dcInstance);
410 pSessionDesc = DC_SESSION_DESC_FROM_CTX_GET(pOpData->pSessionHandle);
411
412 if (CPA_DC_DIR_COMPRESS == pOpData->sessDirection) {
413 pReqCache = &(pSessionDesc->reqCacheComp);
414 /* CNV check */
415 if (CPA_TRUE == pOpData->compressAndVerify) {
416 cnvDecompReq = ICP_QAT_FW_COMP_CNV;
417 if (isDcGen4x(pService)) {
418 cnvErrorInjection =
419 pSessionDesc->cnvErrorInjection;
420 }
421
422 /* CNVNR check */
423 if (CPA_TRUE == pOpData->compressAndVerifyAndRecover) {
424 cnvnrCompReq = ICP_QAT_FW_COMP_CNV_RECOVERY;
425 }
426 }
427 } else {
428 pReqCache = &(pSessionDesc->reqCacheDecomp);
429 }
430
431 /* Fills in the template DC ET ring message - cached from the
432 * session descriptor */
433 memcpy((void *)pCurrentQatMsg,
434 (void *)(pReqCache),
435 (LAC_QAT_DC_REQ_SZ_LW * LAC_LONG_WORD_IN_BYTES));
436
437 if (CPA_DP_BUFLIST == pOpData->srcBufferLen) {
438 bufferFormat = QAT_COMN_PTR_TYPE_SGL;
439 } else {
440 bufferFormat = QAT_COMN_PTR_TYPE_FLAT;
441 }
442
443 pCurrentQatMsg->comp_pars.req_par_flags |=
444 ICP_QAT_FW_COMP_REQ_PARAM_FLAGS_BUILD(
445 ICP_QAT_FW_COMP_NOT_SOP,
446 ICP_QAT_FW_COMP_NOT_EOP,
447 ICP_QAT_FW_COMP_NOT_BFINAL,
448 cnvDecompReq,
449 cnvnrCompReq,
450 cnvErrorInjection,
451 ICP_QAT_FW_COMP_CRC_MODE_LEGACY);
452
453 SalQatMsg_CmnMidWrite((icp_qat_fw_la_bulk_req_t *)pCurrentQatMsg,
454 pOpData,
455 bufferFormat,
456 pOpData->srcBuffer,
457 pOpData->destBuffer,
458 pOpData->srcBufferLen,
459 pOpData->destBufferLen);
460
461 pCurrentQatMsg->comp_pars.comp_len = pOpData->bufferLenToCompress;
462 pCurrentQatMsg->comp_pars.out_buffer_sz = pOpData->bufferLenForData;
463 }
464
465 /**
466 *****************************************************************************
467 * @ingroup cpaDcDp
468 *
469 * @description
470 * Updates the request decryptor with optional parameters:
471 * - partial read specific fields
472 * - zero-padding specific field
473 *
474 * @param[in] pOpData Pointer to a structure containing the
475 * request parameters.
476 * @param[in] pPartReadData Pointer to a structure containing the
477 * partial-read request parameters.
478 * @param[in] zeroPadFlag Boolean indicator containing the
479 * zero-padding enablement flag.
480 * @param[in] pCurrentQatMsg Pointer to current QAT message on the ring.
481 *
482 *****************************************************************************/
483 static void
dcDpUpdateRingMsg(CpaDcDpOpData * pOpData,CpaDcDpPartialReadData * pPartReadData,CpaBoolean zeroPadFlag,icp_qat_fw_comp_req_t * pCurrentQatMsg)484 dcDpUpdateRingMsg(CpaDcDpOpData *pOpData,
485 CpaDcDpPartialReadData *pPartReadData,
486 CpaBoolean zeroPadFlag,
487 icp_qat_fw_comp_req_t *pCurrentQatMsg)
488 {
489 sal_compression_service_t *pService = NULL;
490
491 pService = (sal_compression_service_t *)(pOpData->dcInstance);
492 if (!isDcGen4x(pService)) {
493 return;
494 }
495
496 /* Partial read settings */
497 if (NULL != pPartReadData) {
498 pCurrentQatMsg->u1.partial_decompress
499 .partial_decompress_offset = pPartReadData->dataOffset;
500 pCurrentQatMsg->u1.partial_decompress
501 .partial_decompress_length = pPartReadData->length;
502 ICP_QAT_FW_COMP_PART_DECOMP_SET(
503 pCurrentQatMsg->comp_pars.req_par_flags,
504 ICP_QAT_FW_COMP_PART_DECOMP);
505 }
506 /* Zero padding settings */
507 if (CPA_TRUE == zeroPadFlag) {
508 ICP_QAT_FW_COMP_ZEROPAD_SET(
509 pCurrentQatMsg->comp_pars.req_par_flags,
510 ICP_QAT_FW_COMP_ZEROPAD);
511 }
512 }
513
514 static CpaStatus
dcDpEnqueueOpBase(CpaDcDpOpData * pOpData,CpaDcDpPartialReadData * pPartReadData,CpaBoolean zeroPadFlag,const CpaBoolean performOpNow)515 dcDpEnqueueOpBase(CpaDcDpOpData *pOpData,
516 CpaDcDpPartialReadData *pPartReadData,
517 CpaBoolean zeroPadFlag,
518 const CpaBoolean performOpNow)
519 {
520 icp_qat_fw_comp_req_t *pCurrentQatMsg = NULL;
521 icp_comms_trans_handle trans_handle = NULL;
522 dc_session_desc_t *pSessionDesc = NULL;
523 CpaStatus status = CPA_STATUS_SUCCESS;
524
525 status = dcDataPlaneParamCheck(pOpData);
526 if (CPA_STATUS_SUCCESS != status) {
527 return status;
528 }
529
530 if (NULL != pPartReadData) {
531 status = dcDataPlanePartReadCheck(pOpData, pPartReadData);
532 if (CPA_STATUS_SUCCESS != status) {
533 return status;
534 }
535 }
536
537 if (CPA_TRUE == zeroPadFlag) {
538 status = dcDataPlaneZeroPadCheck(pOpData);
539 if (CPA_STATUS_SUCCESS != status) {
540 return status;
541 }
542 }
543
544 if ((CPA_FALSE == pOpData->compressAndVerify) &&
545 (CPA_DC_DIR_COMPRESS == pOpData->sessDirection)) {
546 return CPA_STATUS_UNSUPPORTED;
547 }
548
549 /* Check if SAL is initialised otherwise return an error */
550 SAL_RUNNING_CHECK(pOpData->dcInstance);
551
552 trans_handle = ((sal_compression_service_t *)pOpData->dcInstance)
553 ->trans_handle_compression_tx;
554 pSessionDesc = DC_SESSION_DESC_FROM_CTX_GET(pOpData->pSessionHandle);
555
556 if ((CPA_DC_DIR_COMPRESS == pOpData->sessDirection) &&
557 (CPA_DC_DIR_DECOMPRESS == pSessionDesc->sessDirection)) {
558 QAT_UTILS_LOG(
559 "The session does not support this direction of operation.\n");
560 return CPA_STATUS_INVALID_PARAM;
561 } else if ((CPA_DC_DIR_DECOMPRESS == pOpData->sessDirection) &&
562 (CPA_DC_DIR_COMPRESS == pSessionDesc->sessDirection)) {
563 QAT_UTILS_LOG(
564 "The session does not support this direction of operation.\n");
565 return CPA_STATUS_INVALID_PARAM;
566 }
567
568 icp_adf_getSingleQueueAddr(trans_handle, (void **)&pCurrentQatMsg);
569 if (NULL == pCurrentQatMsg) {
570 return CPA_STATUS_RETRY;
571 }
572
573 dcDpWriteRingMsg(pOpData, pCurrentQatMsg);
574 if (NULL != pPartReadData || CPA_TRUE == zeroPadFlag) {
575 dcDpUpdateRingMsg(pOpData,
576 pPartReadData,
577 zeroPadFlag,
578 pCurrentQatMsg);
579 }
580
581 pSessionDesc->pendingDpStatelessCbCount++;
582
583 if (CPA_TRUE == performOpNow) {
584 SalQatMsg_updateQueueTail(trans_handle);
585 }
586
587 return CPA_STATUS_SUCCESS;
588 }
589
590 CpaStatus
cpaDcDpEnqueueOp(CpaDcDpOpData * pOpData,const CpaBoolean performOpNow)591 cpaDcDpEnqueueOp(CpaDcDpOpData *pOpData, const CpaBoolean performOpNow)
592 {
593
594 return dcDpEnqueueOpBase(pOpData, NULL, CPA_FALSE, performOpNow);
595 }
596
597 CpaStatus
cpaDcDpEnqueueOpWithPartRead(CpaDcDpOpData * pOpData,CpaDcDpPartialReadData * pPartReadData,const CpaBoolean performOpNow)598 cpaDcDpEnqueueOpWithPartRead(CpaDcDpOpData *pOpData,
599 CpaDcDpPartialReadData *pPartReadData,
600 const CpaBoolean performOpNow)
601 {
602 return dcDpEnqueueOpBase(pOpData,
603 pPartReadData,
604 CPA_FALSE,
605 performOpNow);
606 }
607
608 CpaStatus
cpaDcDpEnqueueOpWithZeroPad(CpaDcDpOpData * pOpData,const CpaBoolean performOpNow)609 cpaDcDpEnqueueOpWithZeroPad(CpaDcDpOpData *pOpData,
610 const CpaBoolean performOpNow)
611 {
612 return dcDpEnqueueOpBase(pOpData, NULL, CPA_TRUE, performOpNow);
613 }
614
615 static CpaStatus
dcDpEnqueueOpBatchBase(const Cpa32U numberRequests,CpaDcDpOpData * pOpData[],CpaDcDpPartialReadData * pPartData[],CpaBoolean zeroPadFlag,const CpaBoolean performOpNow)616 dcDpEnqueueOpBatchBase(const Cpa32U numberRequests,
617 CpaDcDpOpData *pOpData[],
618 CpaDcDpPartialReadData *pPartData[],
619 CpaBoolean zeroPadFlag,
620 const CpaBoolean performOpNow)
621 {
622 icp_qat_fw_comp_req_t *pCurrentQatMsg = NULL;
623 icp_comms_trans_handle trans_handle = NULL;
624 dc_session_desc_t *pSessionDesc = NULL;
625 Cpa32U i = 0;
626 CpaStatus status = CPA_STATUS_SUCCESS;
627 sal_compression_service_t *pService = NULL;
628
629 LAC_CHECK_NULL_PARAM(pOpData);
630 LAC_CHECK_NULL_PARAM(pOpData[0]);
631 LAC_CHECK_NULL_PARAM(pOpData[0]->dcInstance);
632
633 pService = (sal_compression_service_t *)(pOpData[0]->dcInstance);
634 if ((numberRequests == 0) ||
635 (numberRequests > pService->maxNumCompConcurrentReq)) {
636 QAT_UTILS_LOG(
637 "The number of requests needs to be between 1 and %d.\n",
638 pService->maxNumCompConcurrentReq);
639 return CPA_STATUS_INVALID_PARAM;
640 }
641
642 for (i = 0; i < numberRequests; i++) {
643 status = dcDataPlaneParamCheck(pOpData[i]);
644 if (CPA_STATUS_SUCCESS != status) {
645 return status;
646 }
647
648 if (NULL != pPartData) {
649 status =
650 dcDataPlanePartReadCheck(pOpData[i], pPartData[i]);
651 if (CPA_STATUS_SUCCESS != status) {
652 return status;
653 }
654 }
655
656 if (CPA_TRUE == zeroPadFlag) {
657 status = dcDataPlaneZeroPadCheck(pOpData[i]);
658 if (CPA_STATUS_SUCCESS != status) {
659 return status;
660 }
661 }
662
663 /* Check that all instance handles and session handles are the
664 * same */
665 if (pOpData[i]->dcInstance != pOpData[0]->dcInstance) {
666 QAT_UTILS_LOG(
667 "All instance handles should be the same in the pOpData.\n");
668 return CPA_STATUS_INVALID_PARAM;
669 }
670
671 if (pOpData[i]->pSessionHandle != pOpData[0]->pSessionHandle) {
672 QAT_UTILS_LOG(
673 "All session handles should be the same in the pOpData.\n");
674 return CPA_STATUS_INVALID_PARAM;
675 }
676 }
677
678 for (i = 0; i < numberRequests; i++) {
679 if ((CPA_FALSE == pOpData[i]->compressAndVerify) &&
680 (CPA_DC_DIR_COMPRESS == pOpData[i]->sessDirection)) {
681 return CPA_STATUS_UNSUPPORTED;
682 }
683 }
684
685 /* Check if SAL is initialised otherwise return an error */
686 SAL_RUNNING_CHECK(pOpData[0]->dcInstance);
687
688 trans_handle = ((sal_compression_service_t *)pOpData[0]->dcInstance)
689 ->trans_handle_compression_tx;
690 pSessionDesc = DC_SESSION_DESC_FROM_CTX_GET(pOpData[0]->pSessionHandle);
691
692 for (i = 0; i < numberRequests; i++) {
693 if ((CPA_DC_DIR_COMPRESS == pOpData[i]->sessDirection) &&
694 (CPA_DC_DIR_DECOMPRESS == pSessionDesc->sessDirection)) {
695 QAT_UTILS_LOG(
696 "The session does not support this direction of operation.\n");
697 return CPA_STATUS_INVALID_PARAM;
698 } else if ((CPA_DC_DIR_DECOMPRESS ==
699 pOpData[i]->sessDirection) &&
700 (CPA_DC_DIR_COMPRESS ==
701 pSessionDesc->sessDirection)) {
702 QAT_UTILS_LOG(
703 "The session does not support this direction of operation.\n");
704 return CPA_STATUS_INVALID_PARAM;
705 }
706 }
707
708 icp_adf_getQueueMemory(trans_handle,
709 numberRequests,
710 (void **)&pCurrentQatMsg);
711 if (NULL == pCurrentQatMsg) {
712 return CPA_STATUS_RETRY;
713 }
714
715 for (i = 0; i < numberRequests; i++) {
716 dcDpWriteRingMsg(pOpData[i], pCurrentQatMsg);
717 if (pPartData) {
718 dcDpUpdateRingMsg(pOpData[i],
719 pPartData[i],
720 CPA_FALSE,
721 pCurrentQatMsg);
722 }
723 if (CPA_TRUE == zeroPadFlag) {
724 dcDpUpdateRingMsg(pOpData[i],
725 NULL,
726 CPA_TRUE,
727 pCurrentQatMsg);
728 }
729 icp_adf_getQueueNext(trans_handle, (void **)&pCurrentQatMsg);
730 }
731
732 pSessionDesc->pendingDpStatelessCbCount += numberRequests;
733
734 if (CPA_TRUE == performOpNow) {
735 SalQatMsg_updateQueueTail(trans_handle);
736 }
737
738 return CPA_STATUS_SUCCESS;
739 }
740
741 CpaStatus
cpaDcDpEnqueueOpBatch(const Cpa32U numberRequests,CpaDcDpOpData * pOpData[],const CpaBoolean performOpNow)742 cpaDcDpEnqueueOpBatch(const Cpa32U numberRequests,
743 CpaDcDpOpData *pOpData[],
744 const CpaBoolean performOpNow)
745 {
746 return dcDpEnqueueOpBatchBase(
747 numberRequests, pOpData, NULL, CPA_FALSE, performOpNow);
748 }
749
750 CpaStatus
cpaDcDpEnqueueOpWithPartReadBatch(const Cpa32U numberRequests,CpaDcDpOpData * pOpData[],CpaDcDpPartialReadData * pPartReadData[],const CpaBoolean performOpNow)751 cpaDcDpEnqueueOpWithPartReadBatch(const Cpa32U numberRequests,
752 CpaDcDpOpData *pOpData[],
753 CpaDcDpPartialReadData *pPartReadData[],
754 const CpaBoolean performOpNow)
755 {
756 return dcDpEnqueueOpBatchBase(
757 numberRequests, pOpData, pPartReadData, CPA_FALSE, performOpNow);
758 }
759
760 CpaStatus
cpaDcDpEnqueueOpWithZeroPadBatch(const Cpa32U numberRequests,CpaDcDpOpData * pOpData[],const CpaBoolean performOpNow)761 cpaDcDpEnqueueOpWithZeroPadBatch(const Cpa32U numberRequests,
762 CpaDcDpOpData *pOpData[],
763 const CpaBoolean performOpNow)
764 {
765 return dcDpEnqueueOpBatchBase(
766 numberRequests, pOpData, NULL, CPA_TRUE, performOpNow);
767 }
768
769 CpaStatus
icp_sal_DcPollDpInstance(CpaInstanceHandle dcInstance,Cpa32U responseQuota)770 icp_sal_DcPollDpInstance(CpaInstanceHandle dcInstance, Cpa32U responseQuota)
771 {
772 icp_comms_trans_handle trans_handle = NULL;
773
774 LAC_CHECK_INSTANCE_HANDLE(dcInstance);
775 SAL_CHECK_INSTANCE_TYPE(dcInstance, SAL_SERVICE_TYPE_COMPRESSION);
776
777 /* Check if SAL is initialised otherwise return an error */
778 SAL_RUNNING_CHECK(dcInstance);
779
780 trans_handle = ((sal_compression_service_t *)dcInstance)
781 ->trans_handle_compression_rx;
782
783 return icp_adf_pollQueue(trans_handle, responseQuota);
784 }
785
786 CpaStatus
cpaDcDpPerformOpNow(CpaInstanceHandle dcInstance)787 cpaDcDpPerformOpNow(CpaInstanceHandle dcInstance)
788 {
789 icp_comms_trans_handle trans_handle = NULL;
790
791 LAC_CHECK_NULL_PARAM(dcInstance);
792 SAL_CHECK_INSTANCE_TYPE(dcInstance, SAL_SERVICE_TYPE_COMPRESSION);
793
794 /* Check if SAL is initialised otherwise return an error */
795 SAL_RUNNING_CHECK(dcInstance);
796
797 trans_handle = ((sal_compression_service_t *)dcInstance)
798 ->trans_handle_compression_tx;
799
800 if (CPA_TRUE == icp_adf_queueDataToSend(trans_handle)) {
801 SalQatMsg_updateQueueTail(trans_handle);
802 }
803
804 return CPA_STATUS_SUCCESS;
805 }
806
807 CpaStatus
cpaDcDpIsPartReadSupported(const CpaInstanceHandle instanceHandle,CpaBoolean * flag)808 cpaDcDpIsPartReadSupported(const CpaInstanceHandle instanceHandle,
809 CpaBoolean *flag)
810 {
811 sal_compression_service_t *pService = NULL;
812 dc_extd_ftrs_t *pExtendedFtrs = NULL;
813
814 LAC_CHECK_NULL_PARAM(instanceHandle);
815 SAL_CHECK_INSTANCE_TYPE(instanceHandle, SAL_SERVICE_TYPE_COMPRESSION);
816
817 pService = (sal_compression_service_t *)instanceHandle;
818 if (!isDcGen4x(pService)) {
819 *flag = CPA_FALSE;
820 return CPA_STATUS_SUCCESS;
821 }
822
823 pExtendedFtrs = (dc_extd_ftrs_t *)&(
824 ((sal_service_t *)instanceHandle)->dcExtendedFeatures);
825
826 *flag = (CpaBoolean)pExtendedFtrs->is_part_read;
827
828 return CPA_STATUS_SUCCESS;
829 }
830
831 CpaStatus
cpaDcDpIsZeroPadSupported(const CpaInstanceHandle instanceHandle,CpaBoolean * flag)832 cpaDcDpIsZeroPadSupported(const CpaInstanceHandle instanceHandle,
833 CpaBoolean *flag)
834 {
835 sal_compression_service_t *pService = NULL;
836 dc_extd_ftrs_t *pExtendedFtrs = NULL;
837
838 LAC_CHECK_NULL_PARAM(instanceHandle);
839 SAL_CHECK_INSTANCE_TYPE(instanceHandle, SAL_SERVICE_TYPE_COMPRESSION);
840
841 pService = (sal_compression_service_t *)instanceHandle;
842 if (!isDcGen4x(pService)) {
843 *flag = CPA_FALSE;
844 return CPA_STATUS_SUCCESS;
845 }
846
847 pExtendedFtrs = (dc_extd_ftrs_t *)&(
848 ((sal_service_t *)instanceHandle)->dcExtendedFeatures);
849
850 *flag = (CpaBoolean)pExtendedFtrs->is_zero_pad;
851
852 return CPA_STATUS_SUCCESS;
853 }
854