/* SPDX-License-Identifier: BSD-3-Clause */
/* Copyright(c) 2007-2022 Intel Corporation */
/**
 *****************************************************************************
 * @file dc_session.c
 *
 * @ingroup Dc_DataCompression
 *
 * @description
 *      Implementation of the Data Compression session operations.
 *
 *****************************************************************************/

/*
 *******************************************************************************
 * Include public/global header files
 *******************************************************************************
 */
#include "cpa.h"
#include "cpa_dc.h"

#include "icp_qat_fw.h"
#include "icp_qat_fw_comp.h"
#include "icp_qat_hw.h"
#include "icp_qat_hw_20_comp.h"

/*
 *******************************************************************************
 * Include private header files
 *******************************************************************************
 */
#include "dc_session.h"
#include "dc_datapath.h"
#include "lac_mem_pools.h"
#include "sal_types_compression.h"
#include "lac_buffer_desc.h"
#include "sal_service_state.h"
#include "sal_qat_cmn_msg.h"
#include "sal_hw_gen.h"

/**
 *****************************************************************************
 * @ingroup Dc_DataCompression
 *      Check that pSessionData is valid
 *
 * @description
 *      Check that all the parameters defined in the pSessionData are valid
 *
 * @param[in]       pSessionData     Pointer to a user instantiated structure
 *                                   containing session data
 *
 * @retval CPA_STATUS_SUCCESS        Function executed successfully
 * @retval CPA_STATUS_FAIL           Function failed to find device
 * @retval CPA_STATUS_INVALID_PARAM  Invalid parameter passed in
 * @retval CPA_STATUS_UNSUPPORTED    Unsupported algorithm/feature
 *
 *****************************************************************************/
CpaStatus
dcCheckSessionData(const CpaDcSessionSetupData *pSessionData,
                   CpaInstanceHandle dcInstance)
{
        CpaDcInstanceCapabilities instanceCapabilities = { 0 };

        cpaDcQueryCapabilities(dcInstance, &instanceCapabilities);

        if ((pSessionData->compLevel < CPA_DC_L1) ||
            (pSessionData->compLevel > CPA_DC_L12)) {
                QAT_UTILS_LOG("Invalid compLevel value\n");
                return CPA_STATUS_INVALID_PARAM;
        }

        if ((pSessionData->autoSelectBestHuffmanTree < CPA_DC_ASB_DISABLED) ||
            (pSessionData->autoSelectBestHuffmanTree > CPA_DC_ASB_ENABLED)) {
                QAT_UTILS_LOG("Invalid autoSelectBestHuffmanTree value\n");
                return CPA_STATUS_INVALID_PARAM;
        }
        if (pSessionData->compType != CPA_DC_DEFLATE) {
                QAT_UTILS_LOG("Invalid compType value\n");
                return CPA_STATUS_INVALID_PARAM;
        }

        if ((pSessionData->huffType < CPA_DC_HT_STATIC) ||
            (pSessionData->huffType > CPA_DC_HT_FULL_DYNAMIC) ||
            (CPA_DC_HT_PRECOMP == pSessionData->huffType)) {
                QAT_UTILS_LOG("Invalid huffType value\n");
                return CPA_STATUS_INVALID_PARAM;
        }

        if ((pSessionData->sessDirection < CPA_DC_DIR_COMPRESS) ||
            (pSessionData->sessDirection > CPA_DC_DIR_COMBINED)) {
                QAT_UTILS_LOG("Invalid sessDirection value\n");
                return CPA_STATUS_INVALID_PARAM;
        }

        if ((pSessionData->sessState < CPA_DC_STATEFUL) ||
            (pSessionData->sessState > CPA_DC_STATELESS)) {
                QAT_UTILS_LOG("Invalid sessState value\n");
                return CPA_STATUS_INVALID_PARAM;
        }

        if ((pSessionData->checksum < CPA_DC_NONE) ||
            (pSessionData->checksum > CPA_DC_ADLER32)) {
                QAT_UTILS_LOG("Invalid checksum value\n");
                return CPA_STATUS_INVALID_PARAM;
        }

        return CPA_STATUS_SUCCESS;
}

/**
 *****************************************************************************
 * @ingroup Dc_DataCompression
 *      Populate the compression hardware block
 *
 * @description
 *      This function will populate the compression hardware block and update
 *      the size in bytes of the block
 *
 * @param[in]   pSessionDesc            Pointer to the session descriptor
 * @param[in]   pCompConfig             Pointer to slice config word
 * @param[in]   compDecomp              Direction of the operation
 * @param[in]   enableDmm               Delayed Match Mode
 *
 *****************************************************************************/
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)
{
        icp_qat_hw_compression_direction_t dir =
            ICP_QAT_HW_COMPRESSION_DIR_COMPRESS;
        icp_qat_hw_compression_algo_t algo =
            ICP_QAT_HW_COMPRESSION_ALGO_DEFLATE;
        icp_qat_hw_compression_depth_t depth = ICP_QAT_HW_COMPRESSION_DEPTH_1;
        icp_qat_hw_compression_file_type_t filetype =
            ICP_QAT_HW_COMPRESSION_FILE_TYPE_0;
        icp_qat_hw_compression_delayed_match_t dmm;

        /* Set the direction */
        if (DC_COMPRESSION_REQUEST == compDecomp) {
                dir = ICP_QAT_HW_COMPRESSION_DIR_COMPRESS;
        } else {
                dir = ICP_QAT_HW_COMPRESSION_DIR_DECOMPRESS;
        }

        if (CPA_DC_DEFLATE == pSessionDesc->compType) {
                algo = ICP_QAT_HW_COMPRESSION_ALGO_DEFLATE;
        } else {
                QAT_UTILS_LOG("Algorithm not supported for Compression\n");
        }

        /* Set delay match mode */
        if (ICP_QAT_HW_COMPRESSION_DELAYED_MATCH_ENABLED ==
            pService->comp_device_data.enableDmm) {
                dmm = ICP_QAT_HW_COMPRESSION_DELAYED_MATCH_ENABLED;
        } else {
                dmm = ICP_QAT_HW_COMPRESSION_DELAYED_MATCH_DISABLED;
        }

        /* Set the depth */
        if (DC_DECOMPRESSION_REQUEST == compDecomp) {
                depth = ICP_QAT_HW_COMPRESSION_DEPTH_1;
        } else {
                switch (pSessionDesc->compLevel) {
                case CPA_DC_L1:
                        depth = ICP_QAT_HW_COMPRESSION_DEPTH_1;
                        break;
                case CPA_DC_L2:
                        depth = ICP_QAT_HW_COMPRESSION_DEPTH_4;
                        break;
                case CPA_DC_L3:
                        depth = ICP_QAT_HW_COMPRESSION_DEPTH_8;
                        break;
                case CPA_DC_L4:
                        depth = ICP_QAT_HW_COMPRESSION_DEPTH_16;
                        break;
                default:
                        depth = pService->comp_device_data
                                    .highestHwCompressionDepth;
                        break;
                }
        }

        /* The file type is set to ICP_QAT_HW_COMPRESSION_FILE_TYPE_0. The other
         * modes will be used in the future for precompiled huffman trees */
        filetype = ICP_QAT_HW_COMPRESSION_FILE_TYPE_0;

        pCompConfig->lower_val = ICP_QAT_HW_COMPRESSION_CONFIG_BUILD(
            dir, dmm, algo, depth, filetype);

        /* Upper 32-bits of the configuration word do not need to be
         * configured with legacy devices.
         */
        pCompConfig->upper_val = 0;
}

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)
{
        /* Compression related */
        if (DC_COMPRESSION_REQUEST == compDecomp) {
                icp_qat_hw_comp_20_config_csr_upper_t hw_comp_upper_csr;
                icp_qat_hw_comp_20_config_csr_lower_t hw_comp_lower_csr;

                memset(&hw_comp_upper_csr, 0, sizeof hw_comp_upper_csr);
                memset(&hw_comp_lower_csr, 0, sizeof hw_comp_lower_csr);

                /* Disable Literal + Length Limit Block Drop by default and
                 * enable it only for dynamic deflate compression.
                 */
                hw_comp_lower_csr.lllbd =
                    ICP_QAT_HW_COMP_20_LLLBD_CTRL_LLLBD_DISABLED;

                switch (pSessionDesc->compType) {
                case CPA_DC_DEFLATE:
                        /* DEFLATE algorithm settings */
                        hw_comp_lower_csr.skip_ctrl =
                            ICP_QAT_HW_COMP_20_BYTE_SKIP_3BYTE_LITERAL;

                        if (CPA_DC_HT_FULL_DYNAMIC == pSessionDesc->huffType) {
                                hw_comp_lower_csr.algo =
                                    ICP_QAT_HW_COMP_20_HW_COMP_FORMAT_ILZ77;
                        } else /* Static DEFLATE */
                        {
                                hw_comp_lower_csr.algo =
                                    ICP_QAT_HW_COMP_20_HW_COMP_FORMAT_DEFLATE;
                                hw_comp_upper_csr.scb_ctrl =
                                    ICP_QAT_HW_COMP_20_SCB_CONTROL_DISABLE;
                        }

                        if (CPA_DC_STATEFUL == pSessionDesc->sessState) {
                                hw_comp_upper_csr.som_ctrl =
                                    ICP_QAT_HW_COMP_20_SOM_CONTROL_REPLAY_MODE;
                        }
                        break;
                default:
                        QAT_UTILS_LOG("Compression algorithm not supported\n");
                        break;
                }
                /* Set the search depth */
                switch (pSessionDesc->compLevel) {
                case CPA_DC_L1:
                case CPA_DC_L2:
                case CPA_DC_L3:
                case CPA_DC_L4:
                case CPA_DC_L5:
                        hw_comp_lower_csr.sd =
                            ICP_QAT_HW_COMP_20_SEARCH_DEPTH_LEVEL_1;
                        hw_comp_lower_csr.hash_col =
                            ICP_QAT_HW_COMP_20_SKIP_HASH_COLLISION_DONT_ALLOW;
                        break;
                case CPA_DC_L6:
                case CPA_DC_L7:
                case CPA_DC_L8:
                        hw_comp_lower_csr.sd =
                            ICP_QAT_HW_COMP_20_SEARCH_DEPTH_LEVEL_6;
                        break;
                case CPA_DC_L9:
                        hw_comp_lower_csr.sd =
                            ICP_QAT_HW_COMP_20_SEARCH_DEPTH_LEVEL_9;
                        break;
                default:
                        hw_comp_lower_csr.sd = pService->comp_device_data
                                                   .highestHwCompressionDepth;
                        if ((CPA_DC_HT_FULL_DYNAMIC ==
                             pSessionDesc->huffType) &&
                            (CPA_DC_DEFLATE == pSessionDesc->compType)) {
                                /* Enable Literal + Length Limit Block Drop
                                 * with dynamic deflate compression when
                                 * highest compression levels are selected.
                                 */
                                hw_comp_lower_csr.lllbd =
                                    ICP_QAT_HW_COMP_20_LLLBD_CTRL_LLLBD_ENABLED;
                        }
                        break;
                }
                /* Same for all algorithms */
                hw_comp_lower_csr.abd = ICP_QAT_HW_COMP_20_ABD_ABD_DISABLED;
                hw_comp_lower_csr.hash_update =
                    ICP_QAT_HW_COMP_20_SKIP_HASH_UPDATE_DONT_ALLOW;
                hw_comp_lower_csr.edmm =
                    (ICP_QAT_HW_COMPRESSION_DELAYED_MATCH_ENABLED ==
                        pService->comp_device_data.enableDmm) ?
                    ICP_QAT_HW_COMP_20_EXTENDED_DELAY_MATCH_MODE_EDMM_ENABLED :
                    ICP_QAT_HW_COMP_20_EXTENDED_DELAY_MATCH_MODE_EDMM_DISABLED;

                /* Hard-coded HW-specific values */
                hw_comp_upper_csr.nice =
                    ICP_QAT_HW_COMP_20_CONFIG_CSR_NICE_PARAM_DEFAULT_VAL;
                hw_comp_upper_csr.lazy =
                    ICP_QAT_HW_COMP_20_CONFIG_CSR_LAZY_PARAM_DEFAULT_VAL;

                pCompConfig->upper_val =
                    ICP_QAT_FW_COMP_20_BUILD_CONFIG_UPPER(hw_comp_upper_csr);

                pCompConfig->lower_val =
                    ICP_QAT_FW_COMP_20_BUILD_CONFIG_LOWER(hw_comp_lower_csr);
        } else /* Decompress */
        {
                icp_qat_hw_decomp_20_config_csr_lower_t hw_decomp_lower_csr;

                memset(&hw_decomp_lower_csr, 0, sizeof hw_decomp_lower_csr);

                /* Set the algorithm */
                if (CPA_DC_DEFLATE == pSessionDesc->compType) {
                        hw_decomp_lower_csr.algo =
                            ICP_QAT_HW_DECOMP_20_HW_DECOMP_FORMAT_DEFLATE;
                } else {
                        QAT_UTILS_LOG("Algorithm not supported for "
                                      "Decompression\n");
                }

                pCompConfig->upper_val = 0;
                pCompConfig->lower_val =
                    ICP_QAT_FW_DECOMP_20_BUILD_CONFIG_LOWER(
                        hw_decomp_lower_csr);
        }
}

/**
 *****************************************************************************
 * @ingroup Dc_DataCompression
 *      Populate the compression content descriptor
 *
 * @description
 *      This function will populate the compression content descriptor
 *
 * @param[in]   pService                Pointer to the service
 * @param[in]   pSessionDesc            Pointer to the session descriptor
 * @param[in]   contextBufferAddrPhys   Physical address of the context buffer
 * @param[out]  pMsg                    Pointer to the compression message
 * @param[in]   nextSlice               Next slice
 * @param[in]   compDecomp              Direction of the operation
 *
 *****************************************************************************/
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)
{

        icp_qat_fw_comp_cd_hdr_t *pCompControlBlock = NULL;
        icp_qat_hw_compression_config_t *pCompConfig = NULL;
        CpaBoolean bankEnabled = CPA_FALSE;

        pCompControlBlock = (icp_qat_fw_comp_cd_hdr_t *)&(pMsg->comp_cd_ctrl);
        pCompConfig =
            (icp_qat_hw_compression_config_t *)(pMsg->cd_pars.sl
                                                    .comp_slice_cfg_word);

        ICP_QAT_FW_COMN_NEXT_ID_SET(pCompControlBlock, nextSlice);
        ICP_QAT_FW_COMN_CURR_ID_SET(pCompControlBlock, ICP_QAT_FW_SLICE_COMP);

        pCompControlBlock->comp_cfg_offset = 0;

        if ((CPA_DC_STATEFUL == pSessionDesc->sessState) &&
            (CPA_DC_DEFLATE == pSessionDesc->compType) &&
            (DC_DECOMPRESSION_REQUEST == compDecomp)) {
                /* Enable A, B, C, D, and E (CAMs).  */
                pCompControlBlock->ram_bank_flags =
                    ICP_QAT_FW_COMP_RAM_FLAGS_BUILD(
                        ICP_QAT_FW_COMP_BANK_DISABLED, /* Bank I */
                        ICP_QAT_FW_COMP_BANK_DISABLED, /* Bank H */
                        ICP_QAT_FW_COMP_BANK_DISABLED, /* Bank G */
                        ICP_QAT_FW_COMP_BANK_DISABLED, /* Bank F */
                        ICP_QAT_FW_COMP_BANK_ENABLED,  /* Bank E */
                        ICP_QAT_FW_COMP_BANK_ENABLED,  /* Bank D */
                        ICP_QAT_FW_COMP_BANK_ENABLED,  /* Bank C */
                        ICP_QAT_FW_COMP_BANK_ENABLED,  /* Bank B */
                        ICP_QAT_FW_COMP_BANK_ENABLED); /* Bank A */
                bankEnabled = CPA_TRUE;
        } else {
                /* Disable all banks */
                pCompControlBlock->ram_bank_flags =
                    ICP_QAT_FW_COMP_RAM_FLAGS_BUILD(
                        ICP_QAT_FW_COMP_BANK_DISABLED,  /* Bank I */
                        ICP_QAT_FW_COMP_BANK_DISABLED,  /* Bank H */
                        ICP_QAT_FW_COMP_BANK_DISABLED,  /* Bank G */
                        ICP_QAT_FW_COMP_BANK_DISABLED,  /* Bank F */
                        ICP_QAT_FW_COMP_BANK_DISABLED,  /* Bank E */
                        ICP_QAT_FW_COMP_BANK_DISABLED,  /* Bank D */
                        ICP_QAT_FW_COMP_BANK_DISABLED,  /* Bank C */
                        ICP_QAT_FW_COMP_BANK_DISABLED,  /* Bank B */
                        ICP_QAT_FW_COMP_BANK_DISABLED); /* Bank A */
        }

        if (DC_COMPRESSION_REQUEST == compDecomp) {
                LAC_MEM_SHARED_WRITE_VIRT_TO_PHYS_PTR_EXTERNAL(
                    pService->generic_service_info,
                    pCompControlBlock->comp_state_addr,
                    pSessionDesc->stateRegistersComp);
        } else {
                LAC_MEM_SHARED_WRITE_VIRT_TO_PHYS_PTR_EXTERNAL(
                    pService->generic_service_info,
                    pCompControlBlock->comp_state_addr,
                    pSessionDesc->stateRegistersDecomp);
        }

        if (CPA_TRUE == bankEnabled) {
                pCompControlBlock->ram_banks_addr = contextBufferAddrPhys;
        } else {
                pCompControlBlock->ram_banks_addr = 0;
        }

        pCompControlBlock->resrvd = 0;

        /* Populate Compression Hardware Setup Block */
        if (isDcGen4x(pService)) {
                dcCompHwBlockPopulateGen4(pService,
                                          pSessionDesc,
                                          pCompConfig,
                                          compDecomp);
        } else if (isDcGen2x(pService)) {
                dcCompHwBlockPopulate(pService,
                                      pSessionDesc,
                                      pCompConfig,
                                      compDecomp);
        } else {
                QAT_UTILS_LOG("Invalid QAT generation value\n");
        }
}

/**
 *****************************************************************************
 * @ingroup Dc_DataCompression
 *      Populate the translator content descriptor
 *
 * @description
 *      This function will populate the translator content descriptor
 *
 * @param[out]  pMsg                     Pointer to the compression message
 * @param[in]   nextSlice                Next slice
 *
 *****************************************************************************/
void
dcTransContentDescPopulate(icp_qat_fw_comp_req_t *pMsg,
                           icp_qat_fw_slice_t nextSlice)
{

        icp_qat_fw_xlt_cd_hdr_t *pTransControlBlock = NULL;
        pTransControlBlock = (icp_qat_fw_xlt_cd_hdr_t *)&(pMsg->u2.xlt_cd_ctrl);

        ICP_QAT_FW_COMN_NEXT_ID_SET(pTransControlBlock, nextSlice);
        ICP_QAT_FW_COMN_CURR_ID_SET(pTransControlBlock, ICP_QAT_FW_SLICE_XLAT);

        pTransControlBlock->resrvd1 = 0;
        pTransControlBlock->resrvd2 = 0;
        pTransControlBlock->resrvd3 = 0;
}

/**
 *****************************************************************************
 * @ingroup Dc_DataCompression
 *      Get the context size and the history size
 *
 * @description
 *      This function will get the size of the context buffer and the history
 *      buffer. The history buffer is a subset of the context buffer and its
 *      size is needed for stateful compression.

 * @param[in]   dcInstance         DC Instance Handle
 *
 * @param[in]   pSessionData       Pointer to a user instantiated
 *                                 structure containing session data
 * @param[out]  pContextSize       Pointer to the context size
 *
 * @retval CPA_STATUS_SUCCESS      Function executed successfully
 *
 *
 *****************************************************************************/
static CpaStatus
dcGetContextSize(CpaInstanceHandle dcInstance,
                 CpaDcSessionSetupData *pSessionData,
                 Cpa32U *pContextSize)
{
        sal_compression_service_t *pCompService = NULL;

        pCompService = (sal_compression_service_t *)dcInstance;

        *pContextSize = 0;
        if ((CPA_DC_STATEFUL == pSessionData->sessState) &&
            (CPA_DC_DIR_COMPRESS != pSessionData->sessDirection)) {
                switch (pSessionData->compType) {
                case CPA_DC_DEFLATE:
                        *pContextSize =
                            pCompService->comp_device_data.inflateContextSize;
                        break;
                default:
                        QAT_UTILS_LOG("Invalid compression algorithm.");
                        return CPA_STATUS_FAIL;
                }
        }
        return CPA_STATUS_SUCCESS;
}

CpaStatus
dcGetCompressCommandId(sal_compression_service_t *pService,
                       CpaDcSessionSetupData *pSessionData,
                       Cpa8U *pDcCmdId)
{
        CpaStatus status = CPA_STATUS_SUCCESS;
        LAC_CHECK_NULL_PARAM(pService);
        LAC_CHECK_NULL_PARAM(pSessionData);
        LAC_CHECK_NULL_PARAM(pDcCmdId);

        switch (pSessionData->compType) {
        case CPA_DC_DEFLATE:
                *pDcCmdId = (CPA_DC_HT_FULL_DYNAMIC == pSessionData->huffType) ?
                    ICP_QAT_FW_COMP_CMD_DYNAMIC :
                    ICP_QAT_FW_COMP_CMD_STATIC;
                break;
        default:
                QAT_UTILS_LOG("Algorithm not supported for "
                              "compression\n");
                status = CPA_STATUS_UNSUPPORTED;
                break;
        }

        return status;
}

CpaStatus
dcGetDecompressCommandId(sal_compression_service_t *pService,
                         CpaDcSessionSetupData *pSessionData,
                         Cpa8U *pDcCmdId)
{
        CpaStatus status = CPA_STATUS_SUCCESS;
        LAC_CHECK_NULL_PARAM(pService);
        LAC_CHECK_NULL_PARAM(pSessionData);
        LAC_CHECK_NULL_PARAM(pDcCmdId);

        switch (pSessionData->compType) {
        case CPA_DC_DEFLATE:
                *pDcCmdId = ICP_QAT_FW_COMP_CMD_DECOMPRESS;
                break;
        default:
                QAT_UTILS_LOG("Algorithm not supported for "
                              "decompression\n");
                status = CPA_STATUS_UNSUPPORTED;
                break;
        }

        return status;
}

CpaStatus
dcInitSession(CpaInstanceHandle dcInstance,
              CpaDcSessionHandle pSessionHandle,
              CpaDcSessionSetupData *pSessionData,
              CpaBufferList *pContextBuffer,
              CpaDcCallbackFn callbackFn)
{
        CpaStatus status = CPA_STATUS_SUCCESS;
        sal_compression_service_t *pService = NULL;
        icp_qat_fw_comp_req_t *pReqCache = NULL;
        dc_session_desc_t *pSessionDesc = NULL;
        CpaPhysicalAddr contextAddrPhys = 0;
        CpaPhysicalAddr physAddress = 0;
        CpaPhysicalAddr physAddressAligned = 0;
        Cpa32U minContextSize = 0, historySize = 0;
        Cpa32U rpCmdFlags = 0;
        icp_qat_fw_serv_specif_flags cmdFlags = 0;
        Cpa8U secureRam = ICP_QAT_FW_COMP_ENABLE_SECURE_RAM_USED_AS_INTMD_BUF;
        Cpa8U sessType = ICP_QAT_FW_COMP_STATELESS_SESSION;
        Cpa8U autoSelectBest = ICP_QAT_FW_COMP_NOT_AUTO_SELECT_BEST;
        Cpa8U enhancedAutoSelectBest = ICP_QAT_FW_COMP_NOT_ENH_AUTO_SELECT_BEST;
        Cpa8U disableType0EnhancedAutoSelectBest =
            ICP_QAT_FW_COMP_NOT_DISABLE_TYPE0_ENH_AUTO_SELECT_BEST;
        icp_qat_fw_la_cmd_id_t dcCmdId =
            (icp_qat_fw_la_cmd_id_t)ICP_QAT_FW_COMP_CMD_STATIC;
        icp_qat_fw_comn_flags cmnRequestFlags = 0;
        dc_integrity_crc_fw_t *pDataIntegrityCrcs = NULL;

        cmnRequestFlags =
            ICP_QAT_FW_COMN_FLAGS_BUILD(DC_DEFAULT_QAT_PTR_TYPE,
                                        QAT_COMN_CD_FLD_TYPE_16BYTE_DATA);

        pService = (sal_compression_service_t *)dcInstance;

        secureRam = pService->comp_device_data.useDevRam;

        LAC_CHECK_NULL_PARAM(pSessionHandle);
        LAC_CHECK_NULL_PARAM(pSessionData);

        /* Check that the parameters defined in the pSessionData are valid for
         * the
         * device */
        if (CPA_STATUS_SUCCESS !=
            dcCheckSessionData(pSessionData, dcInstance)) {
                return CPA_STATUS_INVALID_PARAM;
        }

        if ((CPA_DC_STATEFUL == pSessionData->sessState) &&
            (CPA_DC_DIR_DECOMPRESS != pSessionData->sessDirection)) {
                QAT_UTILS_LOG("Stateful sessions are not supported.\n");
                return CPA_STATUS_UNSUPPORTED;
        }

        /* Check for Gen4 and stateful, return error if both exist */
        if ((isDcGen4x(pService)) &&
            (CPA_DC_STATEFUL == pSessionData->sessState &&
             CPA_DC_DIR_DECOMPRESS != pSessionData->sessDirection)) {
                QAT_UTILS_LOG("Stateful sessions are not supported for "
                              "compression direction");
                return CPA_STATUS_UNSUPPORTED;
        }

        if ((isDcGen2x(pService)) &&
            (CPA_DC_HT_FULL_DYNAMIC == pSessionData->huffType)) {
                /* Test if DRAM is available for the intermediate buffers */
                if ((NULL == pService->pInterBuffPtrsArray) &&
                    (0 == pService->pInterBuffPtrsArrayPhyAddr)) {
                        if (CPA_DC_ASB_STATIC_DYNAMIC ==
                            pSessionData->autoSelectBestHuffmanTree) {
                                /* Define the Huffman tree as static */
                                pSessionData->huffType = CPA_DC_HT_STATIC;
                        } else {
                                QAT_UTILS_LOG(
                                    "No buffer defined for this instance - "
                                    "see cpaDcStartInstance.\n");
                                return CPA_STATUS_RESOURCE;
                        }
                }
        }

        if ((CPA_DC_STATEFUL == pSessionData->sessState) &&
            (CPA_DC_DEFLATE == pSessionData->compType)) {
                /* Get the size of the context buffer */
                status =
                    dcGetContextSize(dcInstance, pSessionData, &minContextSize);

                if (CPA_STATUS_SUCCESS != status) {
                        QAT_UTILS_LOG(
                            "Unable to get the context size of the session.\n");
                        return CPA_STATUS_FAIL;
                }

                /* If the minContextSize is zero it means we will not save or
                 * restore
                 * any history */
                if (0 != minContextSize) {
                        Cpa64U contextBuffSize = 0;

                        LAC_CHECK_NULL_PARAM(pContextBuffer);

                        if (LacBuffDesc_BufferListVerify(
                                pContextBuffer,
                                &contextBuffSize,
                                LAC_NO_ALIGNMENT_SHIFT) != CPA_STATUS_SUCCESS) {
                                return CPA_STATUS_INVALID_PARAM;
                        }

                        /* Ensure that the context buffer size is greater or
                         * equal
                         * to minContextSize */
                        if (contextBuffSize < minContextSize) {
                                QAT_UTILS_LOG(
                                    "Context buffer size should be greater or equal to %d.\n",
                                    minContextSize);
                                return CPA_STATUS_INVALID_PARAM;
                        }
                }
        }

        /* Re-align the session structure to 64 byte alignment */
        physAddress =
            LAC_OS_VIRT_TO_PHYS_EXTERNAL(pService->generic_service_info,
                                         (Cpa8U *)pSessionHandle +
                                             sizeof(void *));

        if (physAddress == 0) {
                QAT_UTILS_LOG(
                    "Unable to get the physical address of the session.\n");
                return CPA_STATUS_FAIL;
        }

        physAddressAligned =
            (CpaPhysicalAddr)LAC_ALIGN_POW2_ROUNDUP(physAddress,
                                                    LAC_64BYTE_ALIGNMENT);

        pSessionDesc = (dc_session_desc_t *)
            /* Move the session pointer by the physical offset
            between aligned and unaligned memory */
            ((Cpa8U *)pSessionHandle + sizeof(void *) +
             (physAddressAligned - physAddress));

        /* Save the aligned pointer in the first bytes (size of LAC_ARCH_UINT)
         * of the session memory */
        *((LAC_ARCH_UINT *)pSessionHandle) = (LAC_ARCH_UINT)pSessionDesc;

        /* Zero the compression session */
        LAC_OS_BZERO(pSessionDesc, sizeof(dc_session_desc_t));

        /* Write the buffer descriptor for context/history */
        if (0 != minContextSize) {
                status = LacBuffDesc_BufferListDescWrite(
                    pContextBuffer,
                    &contextAddrPhys,
                    CPA_FALSE,
                    &(pService->generic_service_info));

                if (status != CPA_STATUS_SUCCESS) {
                        return status;
                }

                pSessionDesc->pContextBuffer = pContextBuffer;
                pSessionDesc->historyBuffSize = historySize;
        }

        pSessionDesc->cumulativeConsumedBytes = 0;

        /* Initialise pSessionDesc */
        pSessionDesc->requestType = DC_REQUEST_FIRST;
        pSessionDesc->huffType = pSessionData->huffType;
        pSessionDesc->compType = pSessionData->compType;
        pSessionDesc->checksumType = pSessionData->checksum;
        pSessionDesc->autoSelectBestHuffmanTree =
            pSessionData->autoSelectBestHuffmanTree;
        pSessionDesc->sessDirection = pSessionData->sessDirection;
        pSessionDesc->sessState = pSessionData->sessState;
        pSessionDesc->compLevel = pSessionData->compLevel;
        pSessionDesc->isDcDp = CPA_FALSE;
        pSessionDesc->minContextSize = minContextSize;
        pSessionDesc->isSopForCompressionProcessed = CPA_FALSE;
        pSessionDesc->isSopForDecompressionProcessed = CPA_FALSE;

        if (CPA_DC_ADLER32 == pSessionDesc->checksumType) {
                pSessionDesc->previousChecksum = 1;
        } else {
                pSessionDesc->previousChecksum = 0;
        }

        if (CPA_DC_STATEFUL == pSessionData->sessState) {
                /* Init the spinlock used to lock the access to the number of
                 * stateful
                 * in-flight requests */
                status = LAC_SPINLOCK_INIT(&(pSessionDesc->sessionLock));
                if (CPA_STATUS_SUCCESS != status) {
                        QAT_UTILS_LOG(
                            "Spinlock init failed for sessionLock.\n");
                        return CPA_STATUS_RESOURCE;
                }
        }

        /* For asynchronous - use the user supplied callback
         * for synchronous - use the internal synchronous callback */
        pSessionDesc->pCompressionCb = ((void *)NULL != (void *)callbackFn) ?
            callbackFn :
            LacSync_GenWakeupSyncCaller;

        /* Reset the pending callback counters */
        qatUtilsAtomicSet(0, &pSessionDesc->pendingStatelessCbCount);
        qatUtilsAtomicSet(0, &pSessionDesc->pendingStatefulCbCount);
        pSessionDesc->pendingDpStatelessCbCount = 0;

        if (CPA_DC_DIR_DECOMPRESS != pSessionData->sessDirection) {
                if ((isDcGen2x(pService)) &&
                    CPA_DC_HT_FULL_DYNAMIC == pSessionData->huffType) {
                        /* Populate the compression section of the content
                         * descriptor */
                        dcCompContentDescPopulate(pService,
                                                  pSessionDesc,
                                                  contextAddrPhys,
                                                  &(pSessionDesc->reqCacheComp),
                                                  ICP_QAT_FW_SLICE_XLAT,
                                                  DC_COMPRESSION_REQUEST);

                        /* Populate the translator section of the content
                         * descriptor */
                        dcTransContentDescPopulate(
                            &(pSessionDesc->reqCacheComp),
                            ICP_QAT_FW_SLICE_DRAM_WR);

                        if (0 != pService->pInterBuffPtrsArrayPhyAddr) {
                                pReqCache = &(pSessionDesc->reqCacheComp);

                                pReqCache->u1.xlt_pars.inter_buff_ptr =
                                    pService->pInterBuffPtrsArrayPhyAddr;
                        }
                } else {
                        dcCompContentDescPopulate(pService,
                                                  pSessionDesc,
                                                  contextAddrPhys,
                                                  &(pSessionDesc->reqCacheComp),
                                                  ICP_QAT_FW_SLICE_DRAM_WR,
                                                  DC_COMPRESSION_REQUEST);
                }
        }

        /* Populate the compression section of the content descriptor for
         * the decompression case or combined */
        if (CPA_DC_DIR_COMPRESS != pSessionData->sessDirection) {
                dcCompContentDescPopulate(pService,
                                          pSessionDesc,
                                          contextAddrPhys,
                                          &(pSessionDesc->reqCacheDecomp),
                                          ICP_QAT_FW_SLICE_DRAM_WR,
                                          DC_DECOMPRESSION_REQUEST);
        }

        if (CPA_DC_STATEFUL == pSessionData->sessState) {
                sessType = ICP_QAT_FW_COMP_STATEFUL_SESSION;

                LAC_OS_BZERO(&pSessionDesc->stateRegistersComp,
                             sizeof(pSessionDesc->stateRegistersComp));

                LAC_OS_BZERO(&pSessionDesc->stateRegistersDecomp,
                             sizeof(pSessionDesc->stateRegistersDecomp));
        }

        /* Get physical address of E2E CRC buffer */
        pSessionDesc->physDataIntegrityCrcs = (icp_qat_addr_width_t)
            LAC_OS_VIRT_TO_PHYS_EXTERNAL(pService->generic_service_info,
                                         &pSessionDesc->dataIntegrityCrcs);
        if (0 == pSessionDesc->physDataIntegrityCrcs) {
                QAT_UTILS_LOG(
                    "Unable to get the physical address of Data Integrity buffer.\n");
                return CPA_STATUS_FAIL;
        }
        /* Initialize default CRC parameters */
        pDataIntegrityCrcs = &pSessionDesc->dataIntegrityCrcs;
        pDataIntegrityCrcs->crc32 = 0;
        pDataIntegrityCrcs->adler32 = 1;

        if (isDcGen2x(pService)) {
                pDataIntegrityCrcs->oCrc32Cpr = DC_INVALID_CRC;
                pDataIntegrityCrcs->iCrc32Cpr = DC_INVALID_CRC;
                pDataIntegrityCrcs->oCrc32Xlt = DC_INVALID_CRC;
                pDataIntegrityCrcs->iCrc32Xlt = DC_INVALID_CRC;
                pDataIntegrityCrcs->xorFlags = DC_XOR_FLAGS_DEFAULT;
                pDataIntegrityCrcs->crcPoly = DC_CRC_POLY_DEFAULT;
                pDataIntegrityCrcs->xorOut = DC_XOR_OUT_DEFAULT;
        } else {
                pDataIntegrityCrcs->iCrc64Cpr = DC_INVALID_CRC;
                pDataIntegrityCrcs->oCrc64Cpr = DC_INVALID_CRC;
                pDataIntegrityCrcs->iCrc64Xlt = DC_INVALID_CRC;
                pDataIntegrityCrcs->oCrc64Xlt = DC_INVALID_CRC;
                pDataIntegrityCrcs->crc64Poly = DC_CRC64_POLY_DEFAULT;
                pDataIntegrityCrcs->xor64Out = DC_XOR64_OUT_DEFAULT;
        }

        /* Initialise seed checksums.
         * It initializes swCrc32I, swCrc32O, too(union).
         */
        pSessionDesc->seedSwCrc.swCrc64I = 0;
        pSessionDesc->seedSwCrc.swCrc64O = 0;

        /* Populate the cmdFlags */
        switch (pSessionDesc->autoSelectBestHuffmanTree) {
        case CPA_DC_ASB_DISABLED:
                break;
        case CPA_DC_ASB_STATIC_DYNAMIC:
                autoSelectBest = ICP_QAT_FW_COMP_AUTO_SELECT_BEST;
                break;
        case CPA_DC_ASB_UNCOMP_STATIC_DYNAMIC_WITH_STORED_HDRS:
                autoSelectBest = ICP_QAT_FW_COMP_AUTO_SELECT_BEST;
                enhancedAutoSelectBest = ICP_QAT_FW_COMP_ENH_AUTO_SELECT_BEST;
                break;
        case CPA_DC_ASB_UNCOMP_STATIC_DYNAMIC_WITH_NO_HDRS:
                autoSelectBest = ICP_QAT_FW_COMP_AUTO_SELECT_BEST;
                enhancedAutoSelectBest = ICP_QAT_FW_COMP_ENH_AUTO_SELECT_BEST;
                disableType0EnhancedAutoSelectBest =
                    ICP_QAT_FW_COMP_DISABLE_TYPE0_ENH_AUTO_SELECT_BEST;
                break;
        case CPA_DC_ASB_ENABLED:
                if (pService->comp_device_data.asbEnableSupport == CPA_FALSE) {
                        autoSelectBest = ICP_QAT_FW_COMP_AUTO_SELECT_BEST;
                        enhancedAutoSelectBest =
                            ICP_QAT_FW_COMP_ENH_AUTO_SELECT_BEST;
                }
                break;
        default:
                break;
        }

        rpCmdFlags = ICP_QAT_FW_COMP_REQ_PARAM_FLAGS_BUILD(
            ICP_QAT_FW_COMP_SOP,
            ICP_QAT_FW_COMP_EOP,
            ICP_QAT_FW_COMP_BFINAL,
            ICP_QAT_FW_COMP_NO_CNV,
            ICP_QAT_FW_COMP_NO_CNV_RECOVERY,
            ICP_QAT_FW_COMP_NO_CNV_DFX,
            ICP_QAT_FW_COMP_CRC_MODE_LEGACY);

        cmdFlags =
            ICP_QAT_FW_COMP_FLAGS_BUILD(sessType,
                                        autoSelectBest,
                                        enhancedAutoSelectBest,
                                        disableType0EnhancedAutoSelectBest,
                                        secureRam);

        if (CPA_DC_DIR_DECOMPRESS != pSessionData->sessDirection) {
                status = dcGetCompressCommandId(pService,
                                                pSessionData,
                                                (Cpa8U *)&dcCmdId);
                if (CPA_STATUS_SUCCESS != status) {
                        QAT_UTILS_LOG(
                            "Couldn't get compress command ID for current "
                            "session data.");

                        return status;
                }
                pReqCache = &(pSessionDesc->reqCacheComp);
                pReqCache->comp_pars.req_par_flags = rpCmdFlags;
                pReqCache->comp_pars.crc.legacy.initial_adler = 1;
                pReqCache->comp_pars.crc.legacy.initial_crc32 = 0;

                /* Populate header of the common request message */
                SalQatMsg_CmnHdrWrite((icp_qat_fw_comn_req_t *)pReqCache,
                                      ICP_QAT_FW_COMN_REQ_CPM_FW_COMP,
                                      (uint8_t)dcCmdId,
                                      cmnRequestFlags,
                                      cmdFlags);
        }

        if (CPA_DC_DIR_COMPRESS != pSessionData->sessDirection) {
                status = dcGetDecompressCommandId(pService,
                                                  pSessionData,
                                                  (Cpa8U *)&dcCmdId);
                if (CPA_STATUS_SUCCESS != status) {
                        QAT_UTILS_LOG(
                            "Couldn't get decompress command ID for current "
                            "session data.");

                        return status;
                }
                pReqCache = &(pSessionDesc->reqCacheDecomp);
                pReqCache->comp_pars.req_par_flags = rpCmdFlags;
                pReqCache->comp_pars.crc.legacy.initial_adler = 1;
                pReqCache->comp_pars.crc.legacy.initial_crc32 = 0;

                /* Populate header of the common request message */
                SalQatMsg_CmnHdrWrite((icp_qat_fw_comn_req_t *)pReqCache,
                                      ICP_QAT_FW_COMN_REQ_CPM_FW_COMP,
                                      (uint8_t)dcCmdId,
                                      cmnRequestFlags,
                                      cmdFlags);
        }

        return status;
}

CpaStatus
cpaDcInitSession(CpaInstanceHandle dcInstance,
                 CpaDcSessionHandle pSessionHandle,
                 CpaDcSessionSetupData *pSessionData,
                 CpaBufferList *pContextBuffer,
                 CpaDcCallbackFn callbackFn)
{
        CpaInstanceHandle insHandle = NULL;
        sal_compression_service_t *pService = NULL;

        if (CPA_INSTANCE_HANDLE_SINGLE == dcInstance) {
                insHandle = dcGetFirstHandle();
        } else {
                insHandle = dcInstance;
        }

        LAC_CHECK_INSTANCE_HANDLE(insHandle);
        SAL_CHECK_INSTANCE_TYPE(insHandle, SAL_SERVICE_TYPE_COMPRESSION);

        pService = (sal_compression_service_t *)insHandle;

        /* Check if SAL is initialised otherwise return an error */
        SAL_RUNNING_CHECK(pService);

        return dcInitSession(insHandle,
                             pSessionHandle,
                             pSessionData,
                             pContextBuffer,
                             callbackFn);
}

CpaStatus
cpaDcResetSession(const CpaInstanceHandle dcInstance,
                  CpaDcSessionHandle pSessionHandle)
{
        CpaStatus status = CPA_STATUS_SUCCESS;
        CpaInstanceHandle insHandle = NULL;
        sal_compression_service_t *pService = NULL;
        dc_session_desc_t *pSessionDesc = NULL;
        Cpa64U numPendingStateless = 0;
        Cpa64U numPendingStateful = 0;
        icp_comms_trans_handle trans_handle = NULL;
        dc_integrity_crc_fw_t *pDataIntegrityCrcs = NULL;
        dc_sw_checksums_t *pSwCrcs = NULL;

        LAC_CHECK_NULL_PARAM(pSessionHandle);
        pSessionDesc = DC_SESSION_DESC_FROM_CTX_GET(pSessionHandle);
        LAC_CHECK_NULL_PARAM(pSessionDesc);

        if (CPA_TRUE == pSessionDesc->isDcDp) {
                insHandle = dcInstance;
        } else {
                if (CPA_INSTANCE_HANDLE_SINGLE == dcInstance) {
                        insHandle = dcGetFirstHandle();
                } else {
                        insHandle = dcInstance;
                }
        }
        LAC_CHECK_NULL_PARAM(insHandle);
        SAL_CHECK_INSTANCE_TYPE(insHandle, SAL_SERVICE_TYPE_COMPRESSION);
        /* Check if SAL is running otherwise return an error */
        SAL_RUNNING_CHECK(insHandle);
        if (CPA_TRUE == pSessionDesc->isDcDp) {
                trans_handle = ((sal_compression_service_t *)insHandle)
                                   ->trans_handle_compression_tx;
                if (CPA_TRUE == icp_adf_queueDataToSend(trans_handle)) {
                        /* Process the remaining messages on the ring */
                        SalQatMsg_updateQueueTail(trans_handle);
                        QAT_UTILS_LOG(
                            "There are remaining messages on the ring\n");
                        return CPA_STATUS_RETRY;
                }

                /* Check if there are stateless pending requests */
                if (0 != pSessionDesc->pendingDpStatelessCbCount) {
                        QAT_UTILS_LOG(
                            "There are %llu stateless DP requests pending.\n",
                            (unsigned long long)
                                pSessionDesc->pendingDpStatelessCbCount);
                        return CPA_STATUS_RETRY;
                }
        } else {
                numPendingStateless =
                    qatUtilsAtomicGet(&(pSessionDesc->pendingStatelessCbCount));
                numPendingStateful =
                    qatUtilsAtomicGet(&(pSessionDesc->pendingStatefulCbCount));
                /* Check if there are stateless pending requests */
                if (0 != numPendingStateless) {
                        QAT_UTILS_LOG(
                            "There are %llu stateless requests pending.\n",
                            (unsigned long long)numPendingStateless);
                        return CPA_STATUS_RETRY;
                }
                /* Check if there are stateful pending requests */
                if (0 != numPendingStateful) {
                        QAT_UTILS_LOG(
                            "There are %llu stateful requests pending.\n",
                            (unsigned long long)numPendingStateful);
                        return CPA_STATUS_RETRY;
                }

                /* Reset pSessionDesc */
                pSessionDesc->requestType = DC_REQUEST_FIRST;
                pSessionDesc->cumulativeConsumedBytes = 0;
                if (CPA_DC_ADLER32 == pSessionDesc->checksumType) {
                        pSessionDesc->previousChecksum = 1;
                } else {
                        pSessionDesc->previousChecksum = 0;
                }
                pSessionDesc->cnvErrorInjection = ICP_QAT_FW_COMP_NO_CNV_DFX;

                /* Reset integrity CRCs to default parameters. */
                pDataIntegrityCrcs = &pSessionDesc->dataIntegrityCrcs;
                memset(pDataIntegrityCrcs, 0, sizeof(dc_integrity_crc_fw_t));
                pDataIntegrityCrcs->adler32 = 1;

                pService = (sal_compression_service_t *)insHandle;
                if (isDcGen2x(pService)) {
                        pDataIntegrityCrcs->xorFlags = DC_XOR_FLAGS_DEFAULT;
                        pDataIntegrityCrcs->crcPoly = DC_CRC_POLY_DEFAULT;
                        pDataIntegrityCrcs->xorOut = DC_XOR_OUT_DEFAULT;
                } else {
                        pDataIntegrityCrcs->crc64Poly = DC_CRC64_POLY_DEFAULT;
                        pDataIntegrityCrcs->xor64Out = DC_XOR64_OUT_DEFAULT;
                }

                /* Reset seed SW checksums. */
                pSwCrcs = &pSessionDesc->seedSwCrc;
                memset(pSwCrcs, 0, sizeof(dc_sw_checksums_t));

                /* Reset integrity SW checksums. */
                pSwCrcs = &pSessionDesc->integritySwCrc;
                memset(pSwCrcs, 0, sizeof(dc_sw_checksums_t));
        }

        /* Reset the pending callback counters */
        qatUtilsAtomicSet(0, &pSessionDesc->pendingStatelessCbCount);
        qatUtilsAtomicSet(0, &pSessionDesc->pendingStatefulCbCount);
        pSessionDesc->pendingDpStatelessCbCount = 0;
        if (CPA_DC_STATEFUL == pSessionDesc->sessState) {
                LAC_OS_BZERO(&pSessionDesc->stateRegistersComp,
                             sizeof(pSessionDesc->stateRegistersComp));
                LAC_OS_BZERO(&pSessionDesc->stateRegistersDecomp,
                             sizeof(pSessionDesc->stateRegistersDecomp));
        }
        return status;
}

CpaStatus
cpaDcResetXXHashState(const CpaInstanceHandle dcInstance,
                      CpaDcSessionHandle pSessionHandle)
{
        return CPA_STATUS_UNSUPPORTED;
}

CpaStatus
cpaDcUpdateSession(const CpaInstanceHandle dcInstance,
                   CpaDcSessionHandle pSessionHandle,
                   CpaDcSessionUpdateData *pUpdateSessionData)
{
        return CPA_STATUS_UNSUPPORTED;
}

CpaStatus
cpaDcRemoveSession(const CpaInstanceHandle dcInstance,
                   CpaDcSessionHandle pSessionHandle)
{
        CpaStatus status = CPA_STATUS_SUCCESS;
        CpaInstanceHandle insHandle = NULL;
        dc_session_desc_t *pSessionDesc = NULL;
        Cpa64U numPendingStateless = 0;
        Cpa64U numPendingStateful = 0;
        icp_comms_trans_handle trans_handle = NULL;

        LAC_CHECK_NULL_PARAM(pSessionHandle);
        pSessionDesc = DC_SESSION_DESC_FROM_CTX_GET(pSessionHandle);
        LAC_CHECK_NULL_PARAM(pSessionDesc);

        if (CPA_TRUE == pSessionDesc->isDcDp) {
                insHandle = dcInstance;
        } else {
                if (CPA_INSTANCE_HANDLE_SINGLE == dcInstance) {
                        insHandle = dcGetFirstHandle();
                } else {
                        insHandle = dcInstance;
                }
        }

        LAC_CHECK_NULL_PARAM(insHandle);
        SAL_CHECK_INSTANCE_TYPE(insHandle, SAL_SERVICE_TYPE_COMPRESSION);

        /* Check if SAL is running otherwise return an error */
        SAL_RUNNING_CHECK(insHandle);

        if (CPA_TRUE == pSessionDesc->isDcDp) {
                trans_handle = ((sal_compression_service_t *)insHandle)
                                   ->trans_handle_compression_tx;

                if (CPA_TRUE == icp_adf_queueDataToSend(trans_handle)) {
                        /* Process the remaining messages on the ring */
                        SalQatMsg_updateQueueTail(trans_handle);
                        QAT_UTILS_LOG(
                            "There are remaining messages on the ring.\n");
                        return CPA_STATUS_RETRY;
                }

                /* Check if there are stateless pending requests */
                if (0 != pSessionDesc->pendingDpStatelessCbCount) {
                        QAT_UTILS_LOG(
                            "There are %llu stateless DP requests pending.\n",
                            (unsigned long long)
                                pSessionDesc->pendingDpStatelessCbCount);
                        return CPA_STATUS_RETRY;
                }
        } else {
                numPendingStateless =
                    qatUtilsAtomicGet(&(pSessionDesc->pendingStatelessCbCount));
                numPendingStateful =
                    qatUtilsAtomicGet(&(pSessionDesc->pendingStatefulCbCount));

                /* Check if there are stateless pending requests */
                if (0 != numPendingStateless) {
                        QAT_UTILS_LOG(
                            "There are %llu stateless requests pending.\n",
                            (unsigned long long)numPendingStateless);
                        status = CPA_STATUS_RETRY;
                }

                /* Check if there are stateful pending requests */
                if (0 != numPendingStateful) {
                        QAT_UTILS_LOG(
                            "There are %llu stateful requests pending.\n",
                            (unsigned long long)numPendingStateful);
                        status = CPA_STATUS_RETRY;
                }
                if ((CPA_DC_STATEFUL == pSessionDesc->sessState) &&
                    (CPA_STATUS_SUCCESS == status)) {
                        LAC_SPINLOCK_DESTROY(&(pSessionDesc->sessionLock));
                }
        }

        return status;
}

CpaStatus
dcGetSessionSize(CpaInstanceHandle dcInstance,
                 CpaDcSessionSetupData *pSessionData,
                 Cpa32U *pSessionSize,
                 Cpa32U *pContextSize)
{

        CpaStatus status = CPA_STATUS_SUCCESS;
        CpaInstanceHandle insHandle = NULL;

        if (CPA_INSTANCE_HANDLE_SINGLE == dcInstance) {
                insHandle = dcGetFirstHandle();
        } else {
                insHandle = dcInstance;
        }

        /* Check parameters */
        LAC_CHECK_NULL_PARAM(insHandle);
        LAC_CHECK_NULL_PARAM(pSessionData);
        LAC_CHECK_NULL_PARAM(pSessionSize);

        if (dcCheckSessionData(pSessionData, insHandle) != CPA_STATUS_SUCCESS) {
                return CPA_STATUS_INVALID_PARAM;
        }

        /* Get session size for session data */
        *pSessionSize = sizeof(dc_session_desc_t) + LAC_64BYTE_ALIGNMENT +
            sizeof(LAC_ARCH_UINT);

        if (NULL != pContextSize) {
                status =
                    dcGetContextSize(insHandle, pSessionData, pContextSize);

                if (CPA_STATUS_SUCCESS != status) {
                        QAT_UTILS_LOG(
                            "Unable to get the context size of the session.\n");
                        return CPA_STATUS_FAIL;
                }
        }

        return CPA_STATUS_SUCCESS;
}

CpaStatus
cpaDcGetSessionSize(CpaInstanceHandle dcInstance,
                    CpaDcSessionSetupData *pSessionData,
                    Cpa32U *pSessionSize,
                    Cpa32U *pContextSize)
{

        LAC_CHECK_NULL_PARAM(pContextSize);

        return dcGetSessionSize(dcInstance,
                                pSessionData,
                                pSessionSize,
                                pContextSize);
}

CpaStatus
dcSetCnvError(CpaInstanceHandle dcInstance, CpaDcSessionHandle pSessionHandle)
{
        LAC_CHECK_NULL_PARAM(pSessionHandle);

        dc_session_desc_t *pSessionDesc = NULL;
        CpaInstanceHandle insHandle = NULL;
        sal_compression_service_t *pService = NULL;

        if (CPA_INSTANCE_HANDLE_SINGLE == dcInstance) {
                insHandle = dcGetFirstHandle();
        } else {
                insHandle = dcInstance;
        }

        pService = (sal_compression_service_t *)insHandle;

        if (isDcGen2x(pService)) {
                QAT_UTILS_LOG("Unsupported compression feature.\n");
                return CPA_STATUS_UNSUPPORTED;
        }
        pSessionDesc = DC_SESSION_DESC_FROM_CTX_GET(pSessionHandle);

        LAC_CHECK_NULL_PARAM(pSessionDesc);

        pSessionDesc->cnvErrorInjection = ICP_QAT_FW_COMP_CNV_DFX;

        return CPA_STATUS_SUCCESS;
}