1 /* SPDX-License-Identifier: BSD-3-Clause */
2 /* Copyright(c) 2007-2022 Intel Corporation */
3 /**
4 *****************************************************************************
5 * @file dc_session.c
6 *
7 * @ingroup Dc_DataCompression
8 *
9 * @description
10 * Implementation of the Data Compression session operations.
11 *
12 *****************************************************************************/
13
14 /*
15 *******************************************************************************
16 * Include public/global header files
17 *******************************************************************************
18 */
19 #include "cpa.h"
20 #include "cpa_dc.h"
21
22 #include "icp_qat_fw.h"
23 #include "icp_qat_fw_comp.h"
24 #include "icp_qat_hw.h"
25 #include "icp_qat_hw_20_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_mem_pools.h"
35 #include "sal_types_compression.h"
36 #include "lac_buffer_desc.h"
37 #include "sal_service_state.h"
38 #include "sal_qat_cmn_msg.h"
39 #include "sal_hw_gen.h"
40
41 /**
42 *****************************************************************************
43 * @ingroup Dc_DataCompression
44 * Check that pSessionData is valid
45 *
46 * @description
47 * Check that all the parameters defined in the pSessionData are valid
48 *
49 * @param[in] pSessionData Pointer to a user instantiated structure
50 * containing session data
51 *
52 * @retval CPA_STATUS_SUCCESS Function executed successfully
53 * @retval CPA_STATUS_FAIL Function failed to find device
54 * @retval CPA_STATUS_INVALID_PARAM Invalid parameter passed in
55 * @retval CPA_STATUS_UNSUPPORTED Unsupported algorithm/feature
56 *
57 *****************************************************************************/
58 CpaStatus
dcCheckSessionData(const CpaDcSessionSetupData * pSessionData,CpaInstanceHandle dcInstance)59 dcCheckSessionData(const CpaDcSessionSetupData *pSessionData,
60 CpaInstanceHandle dcInstance)
61 {
62 CpaDcInstanceCapabilities instanceCapabilities = { 0 };
63
64 cpaDcQueryCapabilities(dcInstance, &instanceCapabilities);
65
66 if ((pSessionData->compLevel < CPA_DC_L1) ||
67 (pSessionData->compLevel > CPA_DC_L12)) {
68 QAT_UTILS_LOG("Invalid compLevel value\n");
69 return CPA_STATUS_INVALID_PARAM;
70 }
71
72 if ((pSessionData->autoSelectBestHuffmanTree < CPA_DC_ASB_DISABLED) ||
73 (pSessionData->autoSelectBestHuffmanTree > CPA_DC_ASB_ENABLED)) {
74 QAT_UTILS_LOG("Invalid autoSelectBestHuffmanTree value\n");
75 return CPA_STATUS_INVALID_PARAM;
76 }
77 if (pSessionData->compType != CPA_DC_DEFLATE) {
78 QAT_UTILS_LOG("Invalid compType value\n");
79 return CPA_STATUS_INVALID_PARAM;
80 }
81
82 if ((pSessionData->huffType < CPA_DC_HT_STATIC) ||
83 (pSessionData->huffType > CPA_DC_HT_FULL_DYNAMIC) ||
84 (CPA_DC_HT_PRECOMP == pSessionData->huffType)) {
85 QAT_UTILS_LOG("Invalid huffType value\n");
86 return CPA_STATUS_INVALID_PARAM;
87 }
88
89 if ((pSessionData->sessDirection < CPA_DC_DIR_COMPRESS) ||
90 (pSessionData->sessDirection > CPA_DC_DIR_COMBINED)) {
91 QAT_UTILS_LOG("Invalid sessDirection value\n");
92 return CPA_STATUS_INVALID_PARAM;
93 }
94
95 if ((pSessionData->sessState < CPA_DC_STATEFUL) ||
96 (pSessionData->sessState > CPA_DC_STATELESS)) {
97 QAT_UTILS_LOG("Invalid sessState value\n");
98 return CPA_STATUS_INVALID_PARAM;
99 }
100
101 if ((pSessionData->checksum < CPA_DC_NONE) ||
102 (pSessionData->checksum > CPA_DC_ADLER32)) {
103 QAT_UTILS_LOG("Invalid checksum value\n");
104 return CPA_STATUS_INVALID_PARAM;
105 }
106
107 return CPA_STATUS_SUCCESS;
108 }
109
110 /**
111 *****************************************************************************
112 * @ingroup Dc_DataCompression
113 * Populate the compression hardware block
114 *
115 * @description
116 * This function will populate the compression hardware block and update
117 * the size in bytes of the block
118 *
119 * @param[in] pSessionDesc Pointer to the session descriptor
120 * @param[in] pCompConfig Pointer to slice config word
121 * @param[in] compDecomp Direction of the operation
122 * @param[in] enableDmm Delayed Match Mode
123 *
124 *****************************************************************************/
125 static void
dcCompHwBlockPopulate(sal_compression_service_t * pService,dc_session_desc_t * pSessionDesc,icp_qat_hw_compression_config_t * pCompConfig,dc_request_dir_t compDecomp)126 dcCompHwBlockPopulate(sal_compression_service_t *pService,
127 dc_session_desc_t *pSessionDesc,
128 icp_qat_hw_compression_config_t *pCompConfig,
129 dc_request_dir_t compDecomp)
130 {
131 icp_qat_hw_compression_direction_t dir =
132 ICP_QAT_HW_COMPRESSION_DIR_COMPRESS;
133 icp_qat_hw_compression_algo_t algo =
134 ICP_QAT_HW_COMPRESSION_ALGO_DEFLATE;
135 icp_qat_hw_compression_depth_t depth = ICP_QAT_HW_COMPRESSION_DEPTH_1;
136 icp_qat_hw_compression_file_type_t filetype =
137 ICP_QAT_HW_COMPRESSION_FILE_TYPE_0;
138 icp_qat_hw_compression_delayed_match_t dmm;
139
140 /* Set the direction */
141 if (DC_COMPRESSION_REQUEST == compDecomp) {
142 dir = ICP_QAT_HW_COMPRESSION_DIR_COMPRESS;
143 } else {
144 dir = ICP_QAT_HW_COMPRESSION_DIR_DECOMPRESS;
145 }
146
147 if (CPA_DC_DEFLATE == pSessionDesc->compType) {
148 algo = ICP_QAT_HW_COMPRESSION_ALGO_DEFLATE;
149 } else {
150 QAT_UTILS_LOG("Algorithm not supported for Compression\n");
151 }
152
153 /* Set delay match mode */
154 if (CPA_TRUE == pService->comp_device_data.enableDmm) {
155 dmm = ICP_QAT_HW_COMPRESSION_DELAYED_MATCH_ENABLED;
156 } else {
157 dmm = ICP_QAT_HW_COMPRESSION_DELAYED_MATCH_DISABLED;
158 }
159
160 /* Set the depth */
161 if (DC_DECOMPRESSION_REQUEST == compDecomp) {
162 depth = ICP_QAT_HW_COMPRESSION_DEPTH_1;
163 } else {
164 switch (pSessionDesc->compLevel) {
165 case CPA_DC_L1:
166 depth = ICP_QAT_HW_COMPRESSION_DEPTH_1;
167 break;
168 case CPA_DC_L2:
169 depth = ICP_QAT_HW_COMPRESSION_DEPTH_4;
170 break;
171 case CPA_DC_L3:
172 depth = ICP_QAT_HW_COMPRESSION_DEPTH_8;
173 break;
174 case CPA_DC_L4:
175 depth = ICP_QAT_HW_COMPRESSION_DEPTH_16;
176 break;
177 default:
178 depth = pService->comp_device_data
179 .highestHwCompressionDepth;
180 break;
181 }
182 }
183
184 /* The file type is set to ICP_QAT_HW_COMPRESSION_FILE_TYPE_0. The other
185 * modes will be used in the future for precompiled huffman trees */
186 filetype = ICP_QAT_HW_COMPRESSION_FILE_TYPE_0;
187
188 pCompConfig->lower_val = ICP_QAT_HW_COMPRESSION_CONFIG_BUILD(
189 dir, dmm, algo, depth, filetype);
190
191 /* Upper 32-bits of the configuration word do not need to be
192 * configured with legacy devices.
193 */
194 pCompConfig->upper_val = 0;
195 }
196
197 static void
dcCompHwBlockPopulateGen4(sal_compression_service_t * pService,dc_session_desc_t * pSessionDesc,icp_qat_hw_compression_config_t * pCompConfig,dc_request_dir_t compDecomp)198 dcCompHwBlockPopulateGen4(sal_compression_service_t *pService,
199 dc_session_desc_t *pSessionDesc,
200 icp_qat_hw_compression_config_t *pCompConfig,
201 dc_request_dir_t compDecomp)
202 {
203 /* Compression related */
204 if (DC_COMPRESSION_REQUEST == compDecomp) {
205 icp_qat_hw_comp_20_config_csr_upper_t hw_comp_upper_csr;
206 icp_qat_hw_comp_20_config_csr_lower_t hw_comp_lower_csr;
207
208 memset(&hw_comp_upper_csr, 0, sizeof hw_comp_upper_csr);
209 memset(&hw_comp_lower_csr, 0, sizeof hw_comp_lower_csr);
210
211 /* Disable Literal + Length Limit Block Drop by default and
212 * enable it only for dynamic deflate compression.
213 */
214 hw_comp_lower_csr.lllbd =
215 ICP_QAT_HW_COMP_20_LLLBD_CTRL_LLLBD_DISABLED;
216
217 switch (pSessionDesc->compType) {
218 case CPA_DC_DEFLATE:
219 /* DEFLATE algorithm settings */
220 hw_comp_lower_csr.skip_ctrl =
221 ICP_QAT_HW_COMP_20_BYTE_SKIP_3BYTE_LITERAL;
222
223 if (CPA_DC_HT_FULL_DYNAMIC == pSessionDesc->huffType) {
224 hw_comp_lower_csr.algo =
225 ICP_QAT_HW_COMP_20_HW_COMP_FORMAT_ILZ77;
226 } else /* Static DEFLATE */
227 {
228 hw_comp_lower_csr.algo =
229 ICP_QAT_HW_COMP_20_HW_COMP_FORMAT_DEFLATE;
230 hw_comp_upper_csr.scb_ctrl =
231 ICP_QAT_HW_COMP_20_SCB_CONTROL_DISABLE;
232 }
233
234 if (CPA_DC_STATEFUL == pSessionDesc->sessState) {
235 hw_comp_upper_csr.som_ctrl =
236 ICP_QAT_HW_COMP_20_SOM_CONTROL_REPLAY_MODE;
237 }
238 break;
239 default:
240 QAT_UTILS_LOG("Compression algorithm not supported\n");
241 break;
242 }
243 /* Set the search depth */
244 switch (pSessionDesc->compLevel) {
245 case CPA_DC_L1:
246 case CPA_DC_L2:
247 case CPA_DC_L3:
248 case CPA_DC_L4:
249 case CPA_DC_L5:
250 hw_comp_lower_csr.sd =
251 ICP_QAT_HW_COMP_20_SEARCH_DEPTH_LEVEL_1;
252 hw_comp_lower_csr.hash_col =
253 ICP_QAT_HW_COMP_20_SKIP_HASH_COLLISION_DONT_ALLOW;
254 break;
255 case CPA_DC_L6:
256 case CPA_DC_L7:
257 case CPA_DC_L8:
258 hw_comp_lower_csr.sd =
259 ICP_QAT_HW_COMP_20_SEARCH_DEPTH_LEVEL_6;
260 break;
261 case CPA_DC_L9:
262 hw_comp_lower_csr.sd =
263 ICP_QAT_HW_COMP_20_SEARCH_DEPTH_LEVEL_9;
264 break;
265 default:
266 hw_comp_lower_csr.sd = pService->comp_device_data
267 .highestHwCompressionDepth;
268 if ((CPA_DC_HT_FULL_DYNAMIC ==
269 pSessionDesc->huffType) &&
270 (CPA_DC_DEFLATE == pSessionDesc->compType)) {
271 /* Enable Literal + Length Limit Block Drop
272 * with dynamic deflate compression when
273 * highest compression levels are selected.
274 */
275 hw_comp_lower_csr.lllbd =
276 ICP_QAT_HW_COMP_20_LLLBD_CTRL_LLLBD_ENABLED;
277 }
278 break;
279 }
280 /* Same for all algorithms */
281 hw_comp_lower_csr.abd = ICP_QAT_HW_COMP_20_ABD_ABD_DISABLED;
282 hw_comp_lower_csr.hash_update =
283 ICP_QAT_HW_COMP_20_SKIP_HASH_UPDATE_DONT_ALLOW;
284 hw_comp_lower_csr.edmm =
285 (CPA_TRUE == pService->comp_device_data.enableDmm) ?
286 ICP_QAT_HW_COMP_20_EXTENDED_DELAY_MATCH_MODE_EDMM_ENABLED :
287 ICP_QAT_HW_COMP_20_EXTENDED_DELAY_MATCH_MODE_EDMM_DISABLED;
288
289 /* Hard-coded HW-specific values */
290 hw_comp_upper_csr.nice =
291 ICP_QAT_HW_COMP_20_CONFIG_CSR_NICE_PARAM_DEFAULT_VAL;
292 hw_comp_upper_csr.lazy =
293 ICP_QAT_HW_COMP_20_CONFIG_CSR_LAZY_PARAM_DEFAULT_VAL;
294
295 pCompConfig->upper_val =
296 ICP_QAT_FW_COMP_20_BUILD_CONFIG_UPPER(hw_comp_upper_csr);
297
298 pCompConfig->lower_val =
299 ICP_QAT_FW_COMP_20_BUILD_CONFIG_LOWER(hw_comp_lower_csr);
300 } else /* Decompress */
301 {
302 icp_qat_hw_decomp_20_config_csr_lower_t hw_decomp_lower_csr;
303
304 memset(&hw_decomp_lower_csr, 0, sizeof hw_decomp_lower_csr);
305
306 /* Set the algorithm */
307 if (CPA_DC_DEFLATE == pSessionDesc->compType) {
308 hw_decomp_lower_csr.algo =
309 ICP_QAT_HW_DECOMP_20_HW_DECOMP_FORMAT_DEFLATE;
310 } else {
311 QAT_UTILS_LOG("Algorithm not supported for "
312 "Decompression\n");
313 }
314
315 pCompConfig->upper_val = 0;
316 pCompConfig->lower_val =
317 ICP_QAT_FW_DECOMP_20_BUILD_CONFIG_LOWER(
318 hw_decomp_lower_csr);
319 }
320 }
321
322 /**
323 *****************************************************************************
324 * @ingroup Dc_DataCompression
325 * Populate the compression content descriptor
326 *
327 * @description
328 * This function will populate the compression content descriptor
329 *
330 * @param[in] pService Pointer to the service
331 * @param[in] pSessionDesc Pointer to the session descriptor
332 * @param[in] contextBufferAddrPhys Physical address of the context buffer
333 * @param[out] pMsg Pointer to the compression message
334 * @param[in] nextSlice Next slice
335 * @param[in] compDecomp Direction of the operation
336 *
337 *****************************************************************************/
338 static void
dcCompContentDescPopulate(sal_compression_service_t * pService,dc_session_desc_t * pSessionDesc,CpaPhysicalAddr contextBufferAddrPhys,icp_qat_fw_comp_req_t * pMsg,icp_qat_fw_slice_t nextSlice,dc_request_dir_t compDecomp)339 dcCompContentDescPopulate(sal_compression_service_t *pService,
340 dc_session_desc_t *pSessionDesc,
341 CpaPhysicalAddr contextBufferAddrPhys,
342 icp_qat_fw_comp_req_t *pMsg,
343 icp_qat_fw_slice_t nextSlice,
344 dc_request_dir_t compDecomp)
345 {
346
347 icp_qat_fw_comp_cd_hdr_t *pCompControlBlock = NULL;
348 icp_qat_hw_compression_config_t *pCompConfig = NULL;
349 CpaBoolean bankEnabled = CPA_FALSE;
350
351 pCompControlBlock = (icp_qat_fw_comp_cd_hdr_t *)&(pMsg->comp_cd_ctrl);
352 pCompConfig =
353 (icp_qat_hw_compression_config_t *)(pMsg->cd_pars.sl
354 .comp_slice_cfg_word);
355
356 ICP_QAT_FW_COMN_NEXT_ID_SET(pCompControlBlock, nextSlice);
357 ICP_QAT_FW_COMN_CURR_ID_SET(pCompControlBlock, ICP_QAT_FW_SLICE_COMP);
358
359 pCompControlBlock->comp_cfg_offset = 0;
360
361 if ((CPA_DC_STATEFUL == pSessionDesc->sessState) &&
362 (CPA_DC_DEFLATE == pSessionDesc->compType) &&
363 (DC_DECOMPRESSION_REQUEST == compDecomp)) {
364 /* Enable A, B, C, D, and E (CAMs). */
365 pCompControlBlock->ram_bank_flags =
366 ICP_QAT_FW_COMP_RAM_FLAGS_BUILD(
367 ICP_QAT_FW_COMP_BANK_DISABLED, /* Bank I */
368 ICP_QAT_FW_COMP_BANK_DISABLED, /* Bank H */
369 ICP_QAT_FW_COMP_BANK_DISABLED, /* Bank G */
370 ICP_QAT_FW_COMP_BANK_DISABLED, /* Bank F */
371 ICP_QAT_FW_COMP_BANK_ENABLED, /* Bank E */
372 ICP_QAT_FW_COMP_BANK_ENABLED, /* Bank D */
373 ICP_QAT_FW_COMP_BANK_ENABLED, /* Bank C */
374 ICP_QAT_FW_COMP_BANK_ENABLED, /* Bank B */
375 ICP_QAT_FW_COMP_BANK_ENABLED); /* Bank A */
376 bankEnabled = CPA_TRUE;
377 } else {
378 /* Disable all banks */
379 pCompControlBlock->ram_bank_flags =
380 ICP_QAT_FW_COMP_RAM_FLAGS_BUILD(
381 ICP_QAT_FW_COMP_BANK_DISABLED, /* Bank I */
382 ICP_QAT_FW_COMP_BANK_DISABLED, /* Bank H */
383 ICP_QAT_FW_COMP_BANK_DISABLED, /* Bank G */
384 ICP_QAT_FW_COMP_BANK_DISABLED, /* Bank F */
385 ICP_QAT_FW_COMP_BANK_DISABLED, /* Bank E */
386 ICP_QAT_FW_COMP_BANK_DISABLED, /* Bank D */
387 ICP_QAT_FW_COMP_BANK_DISABLED, /* Bank C */
388 ICP_QAT_FW_COMP_BANK_DISABLED, /* Bank B */
389 ICP_QAT_FW_COMP_BANK_DISABLED); /* Bank A */
390 }
391
392 if (DC_COMPRESSION_REQUEST == compDecomp) {
393 LAC_MEM_SHARED_WRITE_VIRT_TO_PHYS_PTR_EXTERNAL(
394 pService->generic_service_info,
395 pCompControlBlock->comp_state_addr,
396 pSessionDesc->stateRegistersComp);
397 } else {
398 LAC_MEM_SHARED_WRITE_VIRT_TO_PHYS_PTR_EXTERNAL(
399 pService->generic_service_info,
400 pCompControlBlock->comp_state_addr,
401 pSessionDesc->stateRegistersDecomp);
402 }
403
404 if (CPA_TRUE == bankEnabled) {
405 pCompControlBlock->ram_banks_addr = contextBufferAddrPhys;
406 } else {
407 pCompControlBlock->ram_banks_addr = 0;
408 }
409
410 pCompControlBlock->resrvd = 0;
411
412 /* Populate Compression Hardware Setup Block */
413 if (isDcGen4x(pService)) {
414 dcCompHwBlockPopulateGen4(pService,
415 pSessionDesc,
416 pCompConfig,
417 compDecomp);
418 } else if (isDcGen2x(pService)) {
419 dcCompHwBlockPopulate(pService,
420 pSessionDesc,
421 pCompConfig,
422 compDecomp);
423 } else {
424 QAT_UTILS_LOG("Invalid QAT generation value\n");
425 }
426 }
427
428 /**
429 *****************************************************************************
430 * @ingroup Dc_DataCompression
431 * Populate the translator content descriptor
432 *
433 * @description
434 * This function will populate the translator content descriptor
435 *
436 * @param[out] pMsg Pointer to the compression message
437 * @param[in] nextSlice Next slice
438 *
439 *****************************************************************************/
440 void
dcTransContentDescPopulate(icp_qat_fw_comp_req_t * pMsg,icp_qat_fw_slice_t nextSlice)441 dcTransContentDescPopulate(icp_qat_fw_comp_req_t *pMsg,
442 icp_qat_fw_slice_t nextSlice)
443 {
444
445 icp_qat_fw_xlt_cd_hdr_t *pTransControlBlock = NULL;
446 pTransControlBlock = (icp_qat_fw_xlt_cd_hdr_t *)&(pMsg->u2.xlt_cd_ctrl);
447
448 ICP_QAT_FW_COMN_NEXT_ID_SET(pTransControlBlock, nextSlice);
449 ICP_QAT_FW_COMN_CURR_ID_SET(pTransControlBlock, ICP_QAT_FW_SLICE_XLAT);
450
451 pTransControlBlock->resrvd1 = 0;
452 pTransControlBlock->resrvd2 = 0;
453 pTransControlBlock->resrvd3 = 0;
454 }
455
456 /**
457 *****************************************************************************
458 * @ingroup Dc_DataCompression
459 * Get the context size and the history size
460 *
461 * @description
462 * This function will get the size of the context buffer and the history
463 * buffer. The history buffer is a subset of the context buffer and its
464 * size is needed for stateful compression.
465
466 * @param[in] dcInstance DC Instance Handle
467 *
468 * @param[in] pSessionData Pointer to a user instantiated
469 * structure containing session data
470 * @param[out] pContextSize Pointer to the context size
471 *
472 * @retval CPA_STATUS_SUCCESS Function executed successfully
473 *
474 *
475 *****************************************************************************/
476 static CpaStatus
dcGetContextSize(CpaInstanceHandle dcInstance,CpaDcSessionSetupData * pSessionData,Cpa32U * pContextSize)477 dcGetContextSize(CpaInstanceHandle dcInstance,
478 CpaDcSessionSetupData *pSessionData,
479 Cpa32U *pContextSize)
480 {
481 sal_compression_service_t *pCompService = NULL;
482
483 pCompService = (sal_compression_service_t *)dcInstance;
484
485 *pContextSize = 0;
486 if ((CPA_DC_STATEFUL == pSessionData->sessState) &&
487 (CPA_DC_DIR_COMPRESS != pSessionData->sessDirection)) {
488 switch (pSessionData->compType) {
489 case CPA_DC_DEFLATE:
490 *pContextSize =
491 pCompService->comp_device_data.inflateContextSize;
492 break;
493 default:
494 QAT_UTILS_LOG("Invalid compression algorithm.");
495 return CPA_STATUS_FAIL;
496 }
497 }
498 return CPA_STATUS_SUCCESS;
499 }
500
501 CpaStatus
dcGetCompressCommandId(sal_compression_service_t * pService,CpaDcSessionSetupData * pSessionData,Cpa8U * pDcCmdId)502 dcGetCompressCommandId(sal_compression_service_t *pService,
503 CpaDcSessionSetupData *pSessionData,
504 Cpa8U *pDcCmdId)
505 {
506 CpaStatus status = CPA_STATUS_SUCCESS;
507 LAC_CHECK_NULL_PARAM(pService);
508 LAC_CHECK_NULL_PARAM(pSessionData);
509 LAC_CHECK_NULL_PARAM(pDcCmdId);
510
511 switch (pSessionData->compType) {
512 case CPA_DC_DEFLATE:
513 *pDcCmdId = (CPA_DC_HT_FULL_DYNAMIC == pSessionData->huffType) ?
514 ICP_QAT_FW_COMP_CMD_DYNAMIC :
515 ICP_QAT_FW_COMP_CMD_STATIC;
516 break;
517 default:
518 QAT_UTILS_LOG("Algorithm not supported for "
519 "compression\n");
520 status = CPA_STATUS_UNSUPPORTED;
521 break;
522 }
523
524 return status;
525 }
526
527 CpaStatus
dcGetDecompressCommandId(sal_compression_service_t * pService,CpaDcSessionSetupData * pSessionData,Cpa8U * pDcCmdId)528 dcGetDecompressCommandId(sal_compression_service_t *pService,
529 CpaDcSessionSetupData *pSessionData,
530 Cpa8U *pDcCmdId)
531 {
532 CpaStatus status = CPA_STATUS_SUCCESS;
533 LAC_CHECK_NULL_PARAM(pService);
534 LAC_CHECK_NULL_PARAM(pSessionData);
535 LAC_CHECK_NULL_PARAM(pDcCmdId);
536
537 switch (pSessionData->compType) {
538 case CPA_DC_DEFLATE:
539 *pDcCmdId = ICP_QAT_FW_COMP_CMD_DECOMPRESS;
540 break;
541 default:
542 QAT_UTILS_LOG("Algorithm not supported for "
543 "decompression\n");
544 status = CPA_STATUS_UNSUPPORTED;
545 break;
546 }
547
548 return status;
549 }
550
551 CpaStatus
dcInitSession(CpaInstanceHandle dcInstance,CpaDcSessionHandle pSessionHandle,CpaDcSessionSetupData * pSessionData,CpaBufferList * pContextBuffer,CpaDcCallbackFn callbackFn)552 dcInitSession(CpaInstanceHandle dcInstance,
553 CpaDcSessionHandle pSessionHandle,
554 CpaDcSessionSetupData *pSessionData,
555 CpaBufferList *pContextBuffer,
556 CpaDcCallbackFn callbackFn)
557 {
558 CpaStatus status = CPA_STATUS_SUCCESS;
559 sal_compression_service_t *pService = NULL;
560 icp_qat_fw_comp_req_t *pReqCache = NULL;
561 dc_session_desc_t *pSessionDesc = NULL;
562 CpaPhysicalAddr contextAddrPhys = 0;
563 CpaPhysicalAddr physAddress = 0;
564 CpaPhysicalAddr physAddressAligned = 0;
565 Cpa32U minContextSize = 0, historySize = 0;
566 Cpa32U rpCmdFlags = 0;
567 icp_qat_fw_serv_specif_flags cmdFlags = 0;
568 Cpa8U secureRam = ICP_QAT_FW_COMP_ENABLE_SECURE_RAM_USED_AS_INTMD_BUF;
569 Cpa8U sessType = ICP_QAT_FW_COMP_STATELESS_SESSION;
570 Cpa8U autoSelectBest = ICP_QAT_FW_COMP_NOT_AUTO_SELECT_BEST;
571 Cpa8U enhancedAutoSelectBest = ICP_QAT_FW_COMP_NOT_ENH_AUTO_SELECT_BEST;
572 Cpa8U disableType0EnhancedAutoSelectBest =
573 ICP_QAT_FW_COMP_NOT_DISABLE_TYPE0_ENH_AUTO_SELECT_BEST;
574 icp_qat_fw_la_cmd_id_t dcCmdId =
575 (icp_qat_fw_la_cmd_id_t)ICP_QAT_FW_COMP_CMD_STATIC;
576 icp_qat_fw_comn_flags cmnRequestFlags = 0;
577 dc_integrity_crc_fw_t *pDataIntegrityCrcs = NULL;
578
579 cmnRequestFlags =
580 ICP_QAT_FW_COMN_FLAGS_BUILD(DC_DEFAULT_QAT_PTR_TYPE,
581 QAT_COMN_CD_FLD_TYPE_16BYTE_DATA);
582
583 pService = (sal_compression_service_t *)dcInstance;
584
585 secureRam = pService->comp_device_data.useDevRam;
586
587 LAC_CHECK_NULL_PARAM(pSessionHandle);
588 LAC_CHECK_NULL_PARAM(pSessionData);
589
590 /* Check that the parameters defined in the pSessionData are valid for
591 * the
592 * device */
593 if (CPA_STATUS_SUCCESS !=
594 dcCheckSessionData(pSessionData, dcInstance)) {
595 return CPA_STATUS_INVALID_PARAM;
596 }
597
598 if ((CPA_DC_STATEFUL == pSessionData->sessState) &&
599 (CPA_DC_DIR_DECOMPRESS != pSessionData->sessDirection)) {
600 QAT_UTILS_LOG("Stateful sessions are not supported.\n");
601 return CPA_STATUS_UNSUPPORTED;
602 }
603
604 /* Check for Gen4 and stateful, return error if both exist */
605 if ((isDcGen4x(pService)) &&
606 (CPA_DC_STATEFUL == pSessionData->sessState &&
607 CPA_DC_DIR_DECOMPRESS != pSessionData->sessDirection)) {
608 QAT_UTILS_LOG("Stateful sessions are not supported for "
609 "compression direction");
610 return CPA_STATUS_UNSUPPORTED;
611 }
612
613 if ((isDcGen2x(pService)) &&
614 (CPA_DC_HT_FULL_DYNAMIC == pSessionData->huffType)) {
615 /* Test if DRAM is available for the intermediate buffers */
616 if ((NULL == pService->pInterBuffPtrsArray) &&
617 (0 == pService->pInterBuffPtrsArrayPhyAddr)) {
618 if (CPA_DC_ASB_STATIC_DYNAMIC ==
619 pSessionData->autoSelectBestHuffmanTree) {
620 /* Define the Huffman tree as static */
621 pSessionData->huffType = CPA_DC_HT_STATIC;
622 } else {
623 QAT_UTILS_LOG(
624 "No buffer defined for this instance - "
625 "see cpaDcStartInstance.\n");
626 return CPA_STATUS_RESOURCE;
627 }
628 }
629 }
630
631 if ((CPA_DC_STATEFUL == pSessionData->sessState) &&
632 (CPA_DC_DEFLATE == pSessionData->compType)) {
633 /* Get the size of the context buffer */
634 status =
635 dcGetContextSize(dcInstance, pSessionData, &minContextSize);
636
637 if (CPA_STATUS_SUCCESS != status) {
638 QAT_UTILS_LOG(
639 "Unable to get the context size of the session.\n");
640 return CPA_STATUS_FAIL;
641 }
642
643 /* If the minContextSize is zero it means we will not save or
644 * restore
645 * any history */
646 if (0 != minContextSize) {
647 Cpa64U contextBuffSize = 0;
648
649 LAC_CHECK_NULL_PARAM(pContextBuffer);
650
651 if (LacBuffDesc_BufferListVerify(
652 pContextBuffer,
653 &contextBuffSize,
654 LAC_NO_ALIGNMENT_SHIFT) != CPA_STATUS_SUCCESS) {
655 return CPA_STATUS_INVALID_PARAM;
656 }
657
658 /* Ensure that the context buffer size is greater or
659 * equal
660 * to minContextSize */
661 if (contextBuffSize < minContextSize) {
662 QAT_UTILS_LOG(
663 "Context buffer size should be greater or equal to %d.\n",
664 minContextSize);
665 return CPA_STATUS_INVALID_PARAM;
666 }
667 }
668 }
669
670 /* Re-align the session structure to 64 byte alignment */
671 physAddress =
672 LAC_OS_VIRT_TO_PHYS_EXTERNAL(pService->generic_service_info,
673 (Cpa8U *)pSessionHandle +
674 sizeof(void *));
675
676 if (physAddress == 0) {
677 QAT_UTILS_LOG(
678 "Unable to get the physical address of the session.\n");
679 return CPA_STATUS_FAIL;
680 }
681
682 physAddressAligned =
683 (CpaPhysicalAddr)LAC_ALIGN_POW2_ROUNDUP(physAddress,
684 LAC_64BYTE_ALIGNMENT);
685
686 pSessionDesc = (dc_session_desc_t *)
687 /* Move the session pointer by the physical offset
688 between aligned and unaligned memory */
689 ((Cpa8U *)pSessionHandle + sizeof(void *) +
690 (physAddressAligned - physAddress));
691
692 /* Save the aligned pointer in the first bytes (size of LAC_ARCH_UINT)
693 * of the session memory */
694 *((LAC_ARCH_UINT *)pSessionHandle) = (LAC_ARCH_UINT)pSessionDesc;
695
696 /* Zero the compression session */
697 LAC_OS_BZERO(pSessionDesc, sizeof(dc_session_desc_t));
698
699 /* Write the buffer descriptor for context/history */
700 if (0 != minContextSize) {
701 status = LacBuffDesc_BufferListDescWrite(
702 pContextBuffer,
703 &contextAddrPhys,
704 CPA_FALSE,
705 &(pService->generic_service_info));
706
707 if (status != CPA_STATUS_SUCCESS) {
708 return status;
709 }
710
711 pSessionDesc->pContextBuffer = pContextBuffer;
712 pSessionDesc->historyBuffSize = historySize;
713 }
714
715 pSessionDesc->cumulativeConsumedBytes = 0;
716
717 /* Initialise pSessionDesc */
718 pSessionDesc->requestType = DC_REQUEST_FIRST;
719 pSessionDesc->huffType = pSessionData->huffType;
720 pSessionDesc->compType = pSessionData->compType;
721 pSessionDesc->checksumType = pSessionData->checksum;
722 pSessionDesc->autoSelectBestHuffmanTree =
723 pSessionData->autoSelectBestHuffmanTree;
724 pSessionDesc->sessDirection = pSessionData->sessDirection;
725 pSessionDesc->sessState = pSessionData->sessState;
726 pSessionDesc->compLevel = pSessionData->compLevel;
727 pSessionDesc->isDcDp = CPA_FALSE;
728 pSessionDesc->minContextSize = minContextSize;
729 pSessionDesc->isSopForCompressionProcessed = CPA_FALSE;
730 pSessionDesc->isSopForDecompressionProcessed = CPA_FALSE;
731
732 if (CPA_DC_ADLER32 == pSessionDesc->checksumType) {
733 pSessionDesc->previousChecksum = 1;
734 } else {
735 pSessionDesc->previousChecksum = 0;
736 }
737
738 if (CPA_DC_STATEFUL == pSessionData->sessState) {
739 /* Init the spinlock used to lock the access to the number of
740 * stateful
741 * in-flight requests */
742 status = LAC_SPINLOCK_INIT(&(pSessionDesc->sessionLock));
743 if (CPA_STATUS_SUCCESS != status) {
744 QAT_UTILS_LOG(
745 "Spinlock init failed for sessionLock.\n");
746 return CPA_STATUS_RESOURCE;
747 }
748 }
749
750 /* For asynchronous - use the user supplied callback
751 * for synchronous - use the internal synchronous callback */
752 pSessionDesc->pCompressionCb = ((void *)NULL != (void *)callbackFn) ?
753 callbackFn :
754 LacSync_GenWakeupSyncCaller;
755
756 /* Reset the pending callback counters */
757 qatUtilsAtomicSet(0, &pSessionDesc->pendingStatelessCbCount);
758 qatUtilsAtomicSet(0, &pSessionDesc->pendingStatefulCbCount);
759 pSessionDesc->pendingDpStatelessCbCount = 0;
760
761 if (CPA_DC_DIR_DECOMPRESS != pSessionData->sessDirection) {
762 if ((isDcGen2x(pService)) &&
763 CPA_DC_HT_FULL_DYNAMIC == pSessionData->huffType) {
764 /* Populate the compression section of the content
765 * descriptor */
766 dcCompContentDescPopulate(pService,
767 pSessionDesc,
768 contextAddrPhys,
769 &(pSessionDesc->reqCacheComp),
770 ICP_QAT_FW_SLICE_XLAT,
771 DC_COMPRESSION_REQUEST);
772
773 /* Populate the translator section of the content
774 * descriptor */
775 dcTransContentDescPopulate(
776 &(pSessionDesc->reqCacheComp),
777 ICP_QAT_FW_SLICE_DRAM_WR);
778
779 if (0 != pService->pInterBuffPtrsArrayPhyAddr) {
780 pReqCache = &(pSessionDesc->reqCacheComp);
781
782 pReqCache->u1.xlt_pars.inter_buff_ptr =
783 pService->pInterBuffPtrsArrayPhyAddr;
784 }
785 } else {
786 dcCompContentDescPopulate(pService,
787 pSessionDesc,
788 contextAddrPhys,
789 &(pSessionDesc->reqCacheComp),
790 ICP_QAT_FW_SLICE_DRAM_WR,
791 DC_COMPRESSION_REQUEST);
792 }
793 }
794
795 /* Populate the compression section of the content descriptor for
796 * the decompression case or combined */
797 if (CPA_DC_DIR_COMPRESS != pSessionData->sessDirection) {
798 dcCompContentDescPopulate(pService,
799 pSessionDesc,
800 contextAddrPhys,
801 &(pSessionDesc->reqCacheDecomp),
802 ICP_QAT_FW_SLICE_DRAM_WR,
803 DC_DECOMPRESSION_REQUEST);
804 }
805
806 if (CPA_DC_STATEFUL == pSessionData->sessState) {
807 sessType = ICP_QAT_FW_COMP_STATEFUL_SESSION;
808
809 LAC_OS_BZERO(&pSessionDesc->stateRegistersComp,
810 sizeof(pSessionDesc->stateRegistersComp));
811
812 LAC_OS_BZERO(&pSessionDesc->stateRegistersDecomp,
813 sizeof(pSessionDesc->stateRegistersDecomp));
814 }
815
816 /* Get physical address of E2E CRC buffer */
817 pSessionDesc->physDataIntegrityCrcs = (icp_qat_addr_width_t)
818 LAC_OS_VIRT_TO_PHYS_EXTERNAL(pService->generic_service_info,
819 &pSessionDesc->dataIntegrityCrcs);
820 if (0 == pSessionDesc->physDataIntegrityCrcs) {
821 QAT_UTILS_LOG(
822 "Unable to get the physical address of Data Integrity buffer.\n");
823 return CPA_STATUS_FAIL;
824 }
825 /* Initialize default CRC parameters */
826 pDataIntegrityCrcs = &pSessionDesc->dataIntegrityCrcs;
827 pDataIntegrityCrcs->crc32 = 0;
828 pDataIntegrityCrcs->adler32 = 1;
829
830 if (isDcGen2x(pService)) {
831 pDataIntegrityCrcs->oCrc32Cpr = DC_INVALID_CRC;
832 pDataIntegrityCrcs->iCrc32Cpr = DC_INVALID_CRC;
833 pDataIntegrityCrcs->oCrc32Xlt = DC_INVALID_CRC;
834 pDataIntegrityCrcs->iCrc32Xlt = DC_INVALID_CRC;
835 pDataIntegrityCrcs->xorFlags = DC_XOR_FLAGS_DEFAULT;
836 pDataIntegrityCrcs->crcPoly = DC_CRC_POLY_DEFAULT;
837 pDataIntegrityCrcs->xorOut = DC_XOR_OUT_DEFAULT;
838 } else {
839 pDataIntegrityCrcs->iCrc64Cpr = DC_INVALID_CRC;
840 pDataIntegrityCrcs->oCrc64Cpr = DC_INVALID_CRC;
841 pDataIntegrityCrcs->iCrc64Xlt = DC_INVALID_CRC;
842 pDataIntegrityCrcs->oCrc64Xlt = DC_INVALID_CRC;
843 pDataIntegrityCrcs->crc64Poly = DC_CRC64_POLY_DEFAULT;
844 pDataIntegrityCrcs->xor64Out = DC_XOR64_OUT_DEFAULT;
845 }
846
847 /* Initialise seed checksums.
848 * It initializes swCrc32I, swCrc32O, too(union).
849 */
850 pSessionDesc->seedSwCrc.swCrc64I = 0;
851 pSessionDesc->seedSwCrc.swCrc64O = 0;
852
853 /* Populate the cmdFlags */
854 switch (pSessionDesc->autoSelectBestHuffmanTree) {
855 case CPA_DC_ASB_DISABLED:
856 break;
857 case CPA_DC_ASB_STATIC_DYNAMIC:
858 autoSelectBest = ICP_QAT_FW_COMP_AUTO_SELECT_BEST;
859 break;
860 case CPA_DC_ASB_UNCOMP_STATIC_DYNAMIC_WITH_STORED_HDRS:
861 autoSelectBest = ICP_QAT_FW_COMP_AUTO_SELECT_BEST;
862 enhancedAutoSelectBest = ICP_QAT_FW_COMP_ENH_AUTO_SELECT_BEST;
863 break;
864 case CPA_DC_ASB_UNCOMP_STATIC_DYNAMIC_WITH_NO_HDRS:
865 autoSelectBest = ICP_QAT_FW_COMP_AUTO_SELECT_BEST;
866 enhancedAutoSelectBest = ICP_QAT_FW_COMP_ENH_AUTO_SELECT_BEST;
867 disableType0EnhancedAutoSelectBest =
868 ICP_QAT_FW_COMP_DISABLE_TYPE0_ENH_AUTO_SELECT_BEST;
869 break;
870 case CPA_DC_ASB_ENABLED:
871 if (pService->comp_device_data.asbEnableSupport == CPA_FALSE) {
872 autoSelectBest = ICP_QAT_FW_COMP_AUTO_SELECT_BEST;
873 enhancedAutoSelectBest =
874 ICP_QAT_FW_COMP_ENH_AUTO_SELECT_BEST;
875 }
876 break;
877 default:
878 break;
879 }
880
881 rpCmdFlags = ICP_QAT_FW_COMP_REQ_PARAM_FLAGS_BUILD(
882 ICP_QAT_FW_COMP_SOP,
883 ICP_QAT_FW_COMP_EOP,
884 ICP_QAT_FW_COMP_BFINAL,
885 ICP_QAT_FW_COMP_NO_CNV,
886 ICP_QAT_FW_COMP_NO_CNV_RECOVERY,
887 ICP_QAT_FW_COMP_NO_CNV_DFX,
888 ICP_QAT_FW_COMP_CRC_MODE_LEGACY);
889
890 cmdFlags =
891 ICP_QAT_FW_COMP_FLAGS_BUILD(sessType,
892 autoSelectBest,
893 enhancedAutoSelectBest,
894 disableType0EnhancedAutoSelectBest,
895 secureRam);
896
897 if (CPA_DC_DIR_DECOMPRESS != pSessionData->sessDirection) {
898 status = dcGetCompressCommandId(pService,
899 pSessionData,
900 (Cpa8U *)&dcCmdId);
901 if (CPA_STATUS_SUCCESS != status) {
902 QAT_UTILS_LOG(
903 "Couldn't get compress command ID for current "
904 "session data.");
905
906 return status;
907 }
908 pReqCache = &(pSessionDesc->reqCacheComp);
909 pReqCache->comp_pars.req_par_flags = rpCmdFlags;
910 pReqCache->comp_pars.crc.legacy.initial_adler = 1;
911 pReqCache->comp_pars.crc.legacy.initial_crc32 = 0;
912
913 /* Populate header of the common request message */
914 SalQatMsg_CmnHdrWrite((icp_qat_fw_comn_req_t *)pReqCache,
915 ICP_QAT_FW_COMN_REQ_CPM_FW_COMP,
916 (uint8_t)dcCmdId,
917 cmnRequestFlags,
918 cmdFlags);
919 }
920
921 if (CPA_DC_DIR_COMPRESS != pSessionData->sessDirection) {
922 status = dcGetDecompressCommandId(pService,
923 pSessionData,
924 (Cpa8U *)&dcCmdId);
925 if (CPA_STATUS_SUCCESS != status) {
926 QAT_UTILS_LOG(
927 "Couldn't get decompress command ID for current "
928 "session data.");
929
930 return status;
931 }
932 pReqCache = &(pSessionDesc->reqCacheDecomp);
933 pReqCache->comp_pars.req_par_flags = rpCmdFlags;
934 pReqCache->comp_pars.crc.legacy.initial_adler = 1;
935 pReqCache->comp_pars.crc.legacy.initial_crc32 = 0;
936
937 /* Populate header of the common request message */
938 SalQatMsg_CmnHdrWrite((icp_qat_fw_comn_req_t *)pReqCache,
939 ICP_QAT_FW_COMN_REQ_CPM_FW_COMP,
940 (uint8_t)dcCmdId,
941 cmnRequestFlags,
942 cmdFlags);
943 }
944
945 return status;
946 }
947
948 CpaStatus
cpaDcInitSession(CpaInstanceHandle dcInstance,CpaDcSessionHandle pSessionHandle,CpaDcSessionSetupData * pSessionData,CpaBufferList * pContextBuffer,CpaDcCallbackFn callbackFn)949 cpaDcInitSession(CpaInstanceHandle dcInstance,
950 CpaDcSessionHandle pSessionHandle,
951 CpaDcSessionSetupData *pSessionData,
952 CpaBufferList *pContextBuffer,
953 CpaDcCallbackFn callbackFn)
954 {
955 CpaInstanceHandle insHandle = NULL;
956 sal_compression_service_t *pService = NULL;
957
958 if (CPA_INSTANCE_HANDLE_SINGLE == dcInstance) {
959 insHandle = dcGetFirstHandle();
960 } else {
961 insHandle = dcInstance;
962 }
963
964 LAC_CHECK_INSTANCE_HANDLE(insHandle);
965 SAL_CHECK_INSTANCE_TYPE(insHandle, SAL_SERVICE_TYPE_COMPRESSION);
966
967 pService = (sal_compression_service_t *)insHandle;
968
969 /* Check if SAL is initialised otherwise return an error */
970 SAL_RUNNING_CHECK(pService);
971
972 return dcInitSession(insHandle,
973 pSessionHandle,
974 pSessionData,
975 pContextBuffer,
976 callbackFn);
977 }
978
979 CpaStatus
cpaDcResetSession(const CpaInstanceHandle dcInstance,CpaDcSessionHandle pSessionHandle)980 cpaDcResetSession(const CpaInstanceHandle dcInstance,
981 CpaDcSessionHandle pSessionHandle)
982 {
983 CpaStatus status = CPA_STATUS_SUCCESS;
984 CpaInstanceHandle insHandle = NULL;
985 sal_compression_service_t *pService = NULL;
986 dc_session_desc_t *pSessionDesc = NULL;
987 Cpa64U numPendingStateless = 0;
988 Cpa64U numPendingStateful = 0;
989 icp_comms_trans_handle trans_handle = NULL;
990 dc_integrity_crc_fw_t *pDataIntegrityCrcs = NULL;
991 dc_sw_checksums_t *pSwCrcs = NULL;
992
993 LAC_CHECK_NULL_PARAM(pSessionHandle);
994 pSessionDesc = DC_SESSION_DESC_FROM_CTX_GET(pSessionHandle);
995 LAC_CHECK_NULL_PARAM(pSessionDesc);
996
997 if (CPA_TRUE == pSessionDesc->isDcDp) {
998 insHandle = dcInstance;
999 } else {
1000 if (CPA_INSTANCE_HANDLE_SINGLE == dcInstance) {
1001 insHandle = dcGetFirstHandle();
1002 } else {
1003 insHandle = dcInstance;
1004 }
1005 }
1006 LAC_CHECK_NULL_PARAM(insHandle);
1007 SAL_CHECK_INSTANCE_TYPE(insHandle, SAL_SERVICE_TYPE_COMPRESSION);
1008 /* Check if SAL is running otherwise return an error */
1009 SAL_RUNNING_CHECK(insHandle);
1010 if (CPA_TRUE == pSessionDesc->isDcDp) {
1011 trans_handle = ((sal_compression_service_t *)insHandle)
1012 ->trans_handle_compression_tx;
1013 if (CPA_TRUE == icp_adf_queueDataToSend(trans_handle)) {
1014 /* Process the remaining messages on the ring */
1015 SalQatMsg_updateQueueTail(trans_handle);
1016 QAT_UTILS_LOG(
1017 "There are remaining messages on the ring\n");
1018 return CPA_STATUS_RETRY;
1019 }
1020
1021 /* Check if there are stateless pending requests */
1022 if (0 != pSessionDesc->pendingDpStatelessCbCount) {
1023 QAT_UTILS_LOG(
1024 "There are %llu stateless DP requests pending.\n",
1025 (unsigned long long)
1026 pSessionDesc->pendingDpStatelessCbCount);
1027 return CPA_STATUS_RETRY;
1028 }
1029 } else {
1030 numPendingStateless =
1031 qatUtilsAtomicGet(&(pSessionDesc->pendingStatelessCbCount));
1032 numPendingStateful =
1033 qatUtilsAtomicGet(&(pSessionDesc->pendingStatefulCbCount));
1034 /* Check if there are stateless pending requests */
1035 if (0 != numPendingStateless) {
1036 QAT_UTILS_LOG(
1037 "There are %llu stateless requests pending.\n",
1038 (unsigned long long)numPendingStateless);
1039 return CPA_STATUS_RETRY;
1040 }
1041 /* Check if there are stateful pending requests */
1042 if (0 != numPendingStateful) {
1043 QAT_UTILS_LOG(
1044 "There are %llu stateful requests pending.\n",
1045 (unsigned long long)numPendingStateful);
1046 return CPA_STATUS_RETRY;
1047 }
1048
1049 /* Reset pSessionDesc */
1050 pSessionDesc->requestType = DC_REQUEST_FIRST;
1051 pSessionDesc->cumulativeConsumedBytes = 0;
1052 if (CPA_DC_ADLER32 == pSessionDesc->checksumType) {
1053 pSessionDesc->previousChecksum = 1;
1054 } else {
1055 pSessionDesc->previousChecksum = 0;
1056 }
1057 pSessionDesc->cnvErrorInjection = ICP_QAT_FW_COMP_NO_CNV_DFX;
1058
1059 /* Reset integrity CRCs to default parameters. */
1060 pDataIntegrityCrcs = &pSessionDesc->dataIntegrityCrcs;
1061 memset(pDataIntegrityCrcs, 0, sizeof(dc_integrity_crc_fw_t));
1062 pDataIntegrityCrcs->adler32 = 1;
1063
1064 pService = (sal_compression_service_t *)insHandle;
1065 if (isDcGen2x(pService)) {
1066 pDataIntegrityCrcs->xorFlags = DC_XOR_FLAGS_DEFAULT;
1067 pDataIntegrityCrcs->crcPoly = DC_CRC_POLY_DEFAULT;
1068 pDataIntegrityCrcs->xorOut = DC_XOR_OUT_DEFAULT;
1069 } else {
1070 pDataIntegrityCrcs->crc64Poly = DC_CRC64_POLY_DEFAULT;
1071 pDataIntegrityCrcs->xor64Out = DC_XOR64_OUT_DEFAULT;
1072 }
1073
1074 /* Reset seed SW checksums. */
1075 pSwCrcs = &pSessionDesc->seedSwCrc;
1076 memset(pSwCrcs, 0, sizeof(dc_sw_checksums_t));
1077
1078 /* Reset integrity SW checksums. */
1079 pSwCrcs = &pSessionDesc->integritySwCrc;
1080 memset(pSwCrcs, 0, sizeof(dc_sw_checksums_t));
1081 }
1082
1083 /* Reset the pending callback counters */
1084 qatUtilsAtomicSet(0, &pSessionDesc->pendingStatelessCbCount);
1085 qatUtilsAtomicSet(0, &pSessionDesc->pendingStatefulCbCount);
1086 pSessionDesc->pendingDpStatelessCbCount = 0;
1087 if (CPA_DC_STATEFUL == pSessionDesc->sessState) {
1088 LAC_OS_BZERO(&pSessionDesc->stateRegistersComp,
1089 sizeof(pSessionDesc->stateRegistersComp));
1090 LAC_OS_BZERO(&pSessionDesc->stateRegistersDecomp,
1091 sizeof(pSessionDesc->stateRegistersDecomp));
1092 }
1093 return status;
1094 }
1095
1096 CpaStatus
cpaDcResetXXHashState(const CpaInstanceHandle dcInstance,CpaDcSessionHandle pSessionHandle)1097 cpaDcResetXXHashState(const CpaInstanceHandle dcInstance,
1098 CpaDcSessionHandle pSessionHandle)
1099 {
1100 return CPA_STATUS_UNSUPPORTED;
1101 }
1102
1103 CpaStatus
cpaDcUpdateSession(const CpaInstanceHandle dcInstance,CpaDcSessionHandle pSessionHandle,CpaDcSessionUpdateData * pUpdateSessionData)1104 cpaDcUpdateSession(const CpaInstanceHandle dcInstance,
1105 CpaDcSessionHandle pSessionHandle,
1106 CpaDcSessionUpdateData *pUpdateSessionData)
1107 {
1108 return CPA_STATUS_UNSUPPORTED;
1109 }
1110
1111 CpaStatus
cpaDcRemoveSession(const CpaInstanceHandle dcInstance,CpaDcSessionHandle pSessionHandle)1112 cpaDcRemoveSession(const CpaInstanceHandle dcInstance,
1113 CpaDcSessionHandle pSessionHandle)
1114 {
1115 CpaStatus status = CPA_STATUS_SUCCESS;
1116 CpaInstanceHandle insHandle = NULL;
1117 dc_session_desc_t *pSessionDesc = NULL;
1118 Cpa64U numPendingStateless = 0;
1119 Cpa64U numPendingStateful = 0;
1120 icp_comms_trans_handle trans_handle = NULL;
1121
1122 LAC_CHECK_NULL_PARAM(pSessionHandle);
1123 pSessionDesc = DC_SESSION_DESC_FROM_CTX_GET(pSessionHandle);
1124 LAC_CHECK_NULL_PARAM(pSessionDesc);
1125
1126 if (CPA_TRUE == pSessionDesc->isDcDp) {
1127 insHandle = dcInstance;
1128 } else {
1129 if (CPA_INSTANCE_HANDLE_SINGLE == dcInstance) {
1130 insHandle = dcGetFirstHandle();
1131 } else {
1132 insHandle = dcInstance;
1133 }
1134 }
1135
1136 LAC_CHECK_NULL_PARAM(insHandle);
1137 SAL_CHECK_INSTANCE_TYPE(insHandle, SAL_SERVICE_TYPE_COMPRESSION);
1138
1139 /* Check if SAL is running otherwise return an error */
1140 SAL_RUNNING_CHECK(insHandle);
1141
1142 if (CPA_TRUE == pSessionDesc->isDcDp) {
1143 trans_handle = ((sal_compression_service_t *)insHandle)
1144 ->trans_handle_compression_tx;
1145
1146 if (CPA_TRUE == icp_adf_queueDataToSend(trans_handle)) {
1147 /* Process the remaining messages on the ring */
1148 SalQatMsg_updateQueueTail(trans_handle);
1149 QAT_UTILS_LOG(
1150 "There are remaining messages on the ring.\n");
1151 return CPA_STATUS_RETRY;
1152 }
1153
1154 /* Check if there are stateless pending requests */
1155 if (0 != pSessionDesc->pendingDpStatelessCbCount) {
1156 QAT_UTILS_LOG(
1157 "There are %llu stateless DP requests pending.\n",
1158 (unsigned long long)
1159 pSessionDesc->pendingDpStatelessCbCount);
1160 return CPA_STATUS_RETRY;
1161 }
1162 } else {
1163 numPendingStateless =
1164 qatUtilsAtomicGet(&(pSessionDesc->pendingStatelessCbCount));
1165 numPendingStateful =
1166 qatUtilsAtomicGet(&(pSessionDesc->pendingStatefulCbCount));
1167
1168 /* Check if there are stateless pending requests */
1169 if (0 != numPendingStateless) {
1170 QAT_UTILS_LOG(
1171 "There are %llu stateless requests pending.\n",
1172 (unsigned long long)numPendingStateless);
1173 status = CPA_STATUS_RETRY;
1174 }
1175
1176 /* Check if there are stateful pending requests */
1177 if (0 != numPendingStateful) {
1178 QAT_UTILS_LOG(
1179 "There are %llu stateful requests pending.\n",
1180 (unsigned long long)numPendingStateful);
1181 status = CPA_STATUS_RETRY;
1182 }
1183 if ((CPA_DC_STATEFUL == pSessionDesc->sessState) &&
1184 (CPA_STATUS_SUCCESS == status)) {
1185 LAC_SPINLOCK_DESTROY(&(pSessionDesc->sessionLock));
1186 }
1187 }
1188
1189 return status;
1190 }
1191
1192 CpaStatus
dcGetSessionSize(CpaInstanceHandle dcInstance,CpaDcSessionSetupData * pSessionData,Cpa32U * pSessionSize,Cpa32U * pContextSize)1193 dcGetSessionSize(CpaInstanceHandle dcInstance,
1194 CpaDcSessionSetupData *pSessionData,
1195 Cpa32U *pSessionSize,
1196 Cpa32U *pContextSize)
1197 {
1198
1199 CpaStatus status = CPA_STATUS_SUCCESS;
1200 CpaInstanceHandle insHandle = NULL;
1201
1202 if (CPA_INSTANCE_HANDLE_SINGLE == dcInstance) {
1203 insHandle = dcGetFirstHandle();
1204 } else {
1205 insHandle = dcInstance;
1206 }
1207
1208 /* Check parameters */
1209 LAC_CHECK_NULL_PARAM(insHandle);
1210 LAC_CHECK_NULL_PARAM(pSessionData);
1211 LAC_CHECK_NULL_PARAM(pSessionSize);
1212
1213 if (dcCheckSessionData(pSessionData, insHandle) != CPA_STATUS_SUCCESS) {
1214 return CPA_STATUS_INVALID_PARAM;
1215 }
1216
1217 /* Get session size for session data */
1218 *pSessionSize = sizeof(dc_session_desc_t) + LAC_64BYTE_ALIGNMENT +
1219 sizeof(LAC_ARCH_UINT);
1220
1221 if (NULL != pContextSize) {
1222 status =
1223 dcGetContextSize(insHandle, pSessionData, pContextSize);
1224
1225 if (CPA_STATUS_SUCCESS != status) {
1226 QAT_UTILS_LOG(
1227 "Unable to get the context size of the session.\n");
1228 return CPA_STATUS_FAIL;
1229 }
1230 }
1231
1232 return CPA_STATUS_SUCCESS;
1233 }
1234
1235 CpaStatus
cpaDcGetSessionSize(CpaInstanceHandle dcInstance,CpaDcSessionSetupData * pSessionData,Cpa32U * pSessionSize,Cpa32U * pContextSize)1236 cpaDcGetSessionSize(CpaInstanceHandle dcInstance,
1237 CpaDcSessionSetupData *pSessionData,
1238 Cpa32U *pSessionSize,
1239 Cpa32U *pContextSize)
1240 {
1241
1242 LAC_CHECK_NULL_PARAM(pContextSize);
1243
1244 return dcGetSessionSize(dcInstance,
1245 pSessionData,
1246 pSessionSize,
1247 pContextSize);
1248 }
1249
1250 CpaStatus
dcSetCnvError(CpaInstanceHandle dcInstance,CpaDcSessionHandle pSessionHandle)1251 dcSetCnvError(CpaInstanceHandle dcInstance, CpaDcSessionHandle pSessionHandle)
1252 {
1253 LAC_CHECK_NULL_PARAM(pSessionHandle);
1254
1255 dc_session_desc_t *pSessionDesc = NULL;
1256 CpaInstanceHandle insHandle = NULL;
1257 sal_compression_service_t *pService = NULL;
1258
1259 if (CPA_INSTANCE_HANDLE_SINGLE == dcInstance) {
1260 insHandle = dcGetFirstHandle();
1261 } else {
1262 insHandle = dcInstance;
1263 }
1264
1265 pService = (sal_compression_service_t *)insHandle;
1266
1267 if (isDcGen2x(pService)) {
1268 QAT_UTILS_LOG("Unsupported compression feature.\n");
1269 return CPA_STATUS_UNSUPPORTED;
1270 }
1271 pSessionDesc = DC_SESSION_DESC_FROM_CTX_GET(pSessionHandle);
1272
1273 LAC_CHECK_NULL_PARAM(pSessionDesc);
1274
1275 pSessionDesc->cnvErrorInjection = ICP_QAT_FW_COMP_CNV_DFX;
1276
1277 return CPA_STATUS_SUCCESS;
1278 }
1279